pax_global_header 0000666 0000000 0000000 00000000064 12050675701 0014515 g ustar 00root root 0000000 0000000 52 comment=f9c2e98d9c80abb2b04690c8bc0c16f11a797c79
postgresql-jdbc-9.2-1002.src/ 0000775 0000000 0000000 00000000000 12050675701 0015640 5 ustar 00root root 0000000 0000000 postgresql-jdbc-9.2-1002.src/.gitignore 0000664 0000000 0000000 00000000074 12050675701 0017631 0 ustar 00root root 0000000 0000000 .classpath
.project
.externalToolBuilders
build
jars
.*.swp
postgresql-jdbc-9.2-1002.src/LICENSE 0000664 0000000 0000000 00000003006 12050675701 0016644 0 ustar 00root root 0000000 0000000 Copyright (c) 1997-2011, PostgreSQL Global Development Group
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
3. Neither the name of the PostgreSQL Global Development Group nor the names
of its contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
postgresql-jdbc-9.2-1002.src/META-INF/ 0000775 0000000 0000000 00000000000 12050675701 0017000 5 ustar 00root root 0000000 0000000 postgresql-jdbc-9.2-1002.src/META-INF/services/ 0000775 0000000 0000000 00000000000 12050675701 0020623 5 ustar 00root root 0000000 0000000 postgresql-jdbc-9.2-1002.src/META-INF/services/java.sql.Driver 0000664 0000000 0000000 00000000026 12050675701 0023515 0 ustar 00root root 0000000 0000000 org.postgresql.Driver
postgresql-jdbc-9.2-1002.src/README 0000664 0000000 0000000 00000015340 12050675701 0016523 0 ustar 00root root 0000000 0000000 This is a simple readme describing how to compile and use the jdbc driver.
---------------------------------------------------------------------------
This isn't a guide on how to use JDBC - for that refer to Oracle's website:
http://www.oracle.com/technetwork/java/javase/jdbc/
and the JDBC tutorial:
http://docs.oracle.com/javase/tutorial/jdbc/
For problems with this driver, refer to driver's home page:
http://jdbc.postgresql.org/
and associated mailing list:
http://archives.postgresql.org/pgsql-jdbc/
---------------------------------------------------------------------------
COMPILING
To compile you will need to have a Java 5 or newer JDK and will need to have
Ant installed. To obtain Ant go to http://ant.apache.org/index.html and
download the binary. Being pure Java it will run on virtually all Java
platforms. If you have any problems please email the pgsql-jdbc list.
Once you have Ant, simply run ant in the top level directory. This will
compile the correct driver for your JVM, and build a .jar file (Java ARchive)
called postgresql.jar.
REMEMBER: Once you have compiled the driver, it will work on ALL platforms
that support that version of the API. You don't need to build it for each
platform.
If you are having problems, prebuilt versions of the driver
are available at http://jdbc.postgresql.org/
---------------------------------------------------------------------------
INSTALLING THE DRIVER
To install the driver, the postgresql.jar file has to be in the classpath.
ie: under LINUX/SOLARIS (the example here is my linux box):
export CLASSPATH=.:/usr/local/pgsql/share/java/postgresql.jar
---------------------------------------------------------------------------
USING THE DRIVER
To use the driver, you must introduce it to JDBC. Again, there's two ways
of doing this:
1: Hardcoded.
This method hardcodes your driver into your application/applet. You
introduce the driver using the following snippet of code:
try {
Class.forName("org.postgresql.Driver");
} catch(Exception e) {
// your error handling code goes here
}
Remember, this method restricts your code to just the postgresql database.
However, this is how most people load the driver.
2: Parameters
This method specifies the driver from the command line. When running the
application, you specify the driver using the option:
-Djdbc.drivers=org.postgresql.Driver
eg: This is an example of running one of my other projects with the driver:
java -Djdbc.drivers=org.postgresql.Driver uk.org.retep.finder.Main
note: This method only works with Applications (not for Applets).
However, the application is not tied to one driver, so if you needed
to switch databases (why I don't know ;-) ), you don't need to
recompile the application (as long as you havent hardcoded the url's).
---------------------------------------------------------------------------
JDBC URL syntax
The driver recognises JDBC URL's of the form:
jdbc:postgresql:database
jdbc:postgresql://host/database
jdbc:postgresql://host:port/database
Also, you can supply both username and passwords as arguments, by appending
them to the URL. eg:
jdbc:postgresql:database?user=me
jdbc:postgresql:database?user=me&password=mypass
Notes:
1) If you are connecting to localhost or 127.0.0.1 you can leave it out of the
URL. ie: jdbc:postgresql://localhost/mydb can be replaced with
jdbc:postgresql:mydb
2) The port defaults to 5432 if it's left out.
---------------------------------------------------------------------------
That's the basics related to this driver. You'll need to read the JDBC Docs
on how to use it.
---------------------------------------------------------------------------
BUG REPORTS, PATCHES AND DEVELOPMENT
PgJDBC development is carried out on the PgJDBC mailing list:
http://jdbc.postgresql.org/lists.html
and on GitHub:
https://github.com/pgjdbc/pgjdbc
Bug reports
-----------
For bug reports please post on pgsql-jdbc or add a GitHub issue. If you include
additional unit tests demonstrating the issue, or self-contained runnable test
case including SQL scripts etc that shows the problem, your report is likely to
get more attention. Make sure you include appropriate details on your
environment, like your JDK version, container/appserver if any, platform,
PostgreSQL version, etc. Err on the site of excess detail if in doubt.
Bug fixes and new features
--------------------------
If you've developed a patch you want to propose for inclusion in PgJDBC, feel
free to send a GitHub pull request or post the patch on the PgJDBC mailing
list. Make sure your patch includes additional unit tests demonstrating and
testing any new features. In the case of bug fixes, where possible include a
new unit test that failed before the fix and passes after it.
For information on working with GitHub, see:
http://help.github.com/articles/fork-a-repo
http://learn.github.com/p/intro.html
Testing
-------
Remember to test proposed PgJDBC patches when running against older PostgreSQL
versions where possible, not just against the PostgreSQL you use yourself.
You also need to test your changes with older JDKs. PgJDBC must support JDK5
("Java 1.5") and newer, which means you can't use annotations, auto-boxing, for
(:), and numerous other features added since JDK 5. Code that's JDBC4 specific
may use JDK6 features, and code that's JDBC4.1 specific may use JDK7 features.
Common code and JDBC3 code needs to stick to Java 1.5.
Two different versions of PgJDBC can be built, the JDBC 3 and JDBC 4 drivers.
The former may be built with JDK 5, while building JDBC4 requires JDK 6 or 7.
The driver to build is auto-selected based on the JDK version used to run the
build. The best way to test a proposed change with both the JDBC3 and JDBC4
drivers is to build and test with both JDK5 and JDK6 or 7.
You can get old JDK versions from the Oracle Java Archive:
http://www.oracle.com/technetwork/java/archive-139210.html
Typically you can test against an old JDK with:
export JAVA_HOME=/path/to/jdk_1_5
export PATH=$JAVA_HOME/bin:$JAVA_HOME/jre/bin:
ant clean test
For information about the unit tests and how to run them, see
org/postgresql/test/README
Ideas
-----
If you have ideas or proposed changes, please post on the mailing list.
Think about how the change would affect other users, what side effects it
might have, how practical it is to implement, what implications it would
have for standards compliance and security, etc.
Few of the PgJDBC developers have much spare time, so it's unlikely that your
idea will be picked up and implemented for you. The best way to make sure a
desired feature or improvement happens is to implement it yourself. The PgJDBC
sources are reasonably clear and they're pure Java, so it's sometimes easier
than you might expect.
postgresql-jdbc-9.2-1002.src/build.properties 0000664 0000000 0000000 00000000266 12050675701 0021061 0 ustar 00root root 0000000 0000000 # Default build parameters. These may be overridden by local configuration
# settings in build.local.properties.
#
major=9
minor=2
fullversion=9.2
def_pgport=5432
enable_debug=yes
postgresql-jdbc-9.2-1002.src/build.xml 0000664 0000000 0000000 00000054737 12050675701 0017501 0 ustar 00root root 0000000 0000000
]>
postgresql-jdbc-9.2-1002.src/certdir/ 0000775 0000000 0000000 00000000000 12050675701 0017274 5 ustar 00root root 0000000 0000000 postgresql-jdbc-9.2-1002.src/certdir/README 0000664 0000000 0000000 00000004663 12050675701 0020165 0 ustar 00root root 0000000 0000000
To run the SSL tests, the following properties are used:
certdir: directory where the certificates and keys are store
ssl<8|9>: a connection string to the appropiate database
TYPE is the TYPE or METHOD field from pg_hba.conf that is: host, hostnossl,
hostssl and the special types hostsslcert, that corresponds
to a hostssl type with clientcert=1 and cert that corresponds
to a hostssl type with cert authentication. 'gh' means, the server certificate
matches the hostname (good hostname), 'bh' means it is not (bad
hostname). It can be simulated with a single database, if two names
can be used i.e. localhost and 127.0.0.1. ssloff points to a database,
where ssl is off. The last number is the server major version
For each connection, the following files should be placed into certdir:
goodclient.crt, badclient.crt, goodclient.pk8, badclient.pk8, goodroot.crt, badroot.crt
optionally prefixed by the value of sslprefix property, if
different files are necessary for different connect strings.
This directory contains example certificates generated by the following
commands:
openssl req -x509 -newkey rsa:1024 -days 3650 -keyout goodclient.key -out goodclient.crt
#Common name is test, password is sslpwd
openssl req -x509 -newkey rsa:1024 -days 3650 -keyout badclient.key -out badclient.crt
#Common name is test, password is sslpwd
openssl req -x509 -newkey rsa:1024 -days 3650 -nodes -keyout badroot.key -out badroot.crt
#Common name is localhost
rm badroot.key
openssl pkcs8 -topk8 -in goodclient.key -out goodclient.pk8 -outform DER -v1 PBE-MD5-DES
openssl pkcs8 -topk8 -in badclient.key -out badclient.pk8 -outform DER -v1 PBE-MD5-DES
cp goodclient.crt server/root.crt
cd server
openssl req -x509 -newkey rsa:1024 -nodes -days 3650 -keyout server.key -out server.crt
cp server.crt ../goodroot.crt
#Common name is localhost, no password
The subdirectory server contains what should be copied to the PGDATA directory.
If you do not overwrite the pg_hba.conf then remember to comment out all lines
starting with "host all".
For the tests the sslinfo module must be installed into every database.
The ssl=on must be set in postgresql.conf
The following command creates the databases and installs the sslinfo module.
for db in hostssldb hostnossldb certdb hostsslcertdb; do
createdb $db
psql $db -c "create extension sslinfo"
done
The username for connecting to postgres as specified in build.local.properties tests has to be "test".
postgresql-jdbc-9.2-1002.src/certdir/badclient.crt 0000664 0000000 0000000 00000002036 12050675701 0021734 0 ustar 00root root 0000000 0000000 -----BEGIN CERTIFICATE-----
MIIC3jCCAkegAwIBAgIJAIHg5fMq+z8aMA0GCSqGSIb3DQEBBQUAMFQxCzAJBgNV
BAYTAkFVMRMwEQYDVQQIEwpTb21lLVN0YXRlMSEwHwYDVQQKExhJbnRlcm5ldCBX
aWRnaXRzIFB0eSBMdGQxDTALBgNVBAMTBHRlc3QwHhcNMTExMTEwMjE0MjI3WhcN
MjExMTA3MjE0MjI3WjBUMQswCQYDVQQGEwJBVTETMBEGA1UECBMKU29tZS1TdGF0
ZTEhMB8GA1UEChMYSW50ZXJuZXQgV2lkZ2l0cyBQdHkgTHRkMQ0wCwYDVQQDEwR0
ZXN0MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDbMINU6XwQ/0OSQ4xYRp0o
gYzzsaaGgZjBZEpRMCZkB+TPUD/yxDpyfcknsvsBQPQ0bqLLS9yqf5iS26jHGd4U
/nInOy5rjIKEbJMUgkbNWiuVl5q1K+GFuTEpjpdLI9NH5X+jL1CxH/h8+j8Mr2iX
s4C2gIFu6povShJiIwBNBQIDAQABo4G3MIG0MB0GA1UdDgQWBBQ6L/fB+7uwDN9q
T5Do9X4GIbJnxDCBhAYDVR0jBH0we4AUOi/3wfu7sAzfak+Q6PV+BiGyZ8ShWKRW
MFQxCzAJBgNVBAYTAkFVMRMwEQYDVQQIEwpTb21lLVN0YXRlMSEwHwYDVQQKExhJ
bnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQxDTALBgNVBAMTBHRlc3SCCQCB4OXzKvs/
GjAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEBBQUAA4GBAKq2Q+aE5eC04gW58pAt
pobnL/2L0JHCeLPsv0k/1vjulzjBuphbwaibZtiYWZSDKWL8Dvsg+khq7rEIY0W6
xXGw5y2scRlCukQvseIxbHUoyOCAWJnoqr7d8MyxP2GlpqSDXHk9wEywZ/6f89oN
yudtXjoYuW8157tmvrX3D1yd
-----END CERTIFICATE-----
postgresql-jdbc-9.2-1002.src/certdir/badclient.key 0000664 0000000 0000000 00000001703 12050675701 0021734 0 ustar 00root root 0000000 0000000 -----BEGIN RSA PRIVATE KEY-----
Proc-Type: 4,ENCRYPTED
DEK-Info: DES-EDE3-CBC,95718EE22B89E019
78LEg7uq4krPR3C1sQVCiQsPIXroyoDzPHBFmI+ipEJq7obFACK9KROfUAaMlca8
ZR1UhtQHCPK4TOG1qKjn8lxeKGLZA25Lcilw6QvZCfNyBa6JUp3cdwzUSv7/qE/Y
d/wlVAq71JbOmYsbEwunZlq+DO1AaL91N/2ANgSSC85uR0dye0iZ1C0OZzawMXkd
wXRrXb8c8RCH2gQ6V4aMartTZ/DQznA59+NEUYln5IMP4joRM0TTpcuv6oCq1UUw
o7xEQcwfBB0tKayxkBfgp8Jvrghzw0usSFt4ad9I4DF/V2izojZgYsnT7yGqsop6
7jmPR9llYhDQIZd0V4NZziiRF2Dt/lyG0iUPZq5vlhLaI59FzMAxVSAJP6DrUHQD
L76TeGpQm2LRqWliDc+3AMTCKv0TP1IPbIWJrnLxnNf/C29adO+VSeQEQ0+tBU+/
DE2GVsQ/xul+QyCwXiOce0pfERLuGjSu/kRa1ylAlrdH4+6vBD0ewuXXHv0eTSxB
Vi0vde5a9PzPUMUBkg6PS7IDYJmKm04fFPxx3y8GMlzbZYOYjTepkYMbayekybGK
fHVk9Z3lW5yzegaz8iJu/8le6Kn4Ox21FRG45domu1T+8eJuXPoiBUb290SUVuxh
VTQWhCA8ElmVCYfrbSnYL3naeqVL+Oc6by3VVhvgiqUuXQTZvKN7mkUOhiNbpz2H
iGLwlRj6wXEaS0qLb9NQc9H9Vv6ftj7UPa4FkiJjWhUW0WkA5sqtOKMjLzpsIZtR
dFb26NE65tk0lrywQrzMBFM6fk90VrMYyvwukZIJIKRLCBQaG24PLQ==
-----END RSA PRIVATE KEY-----
postgresql-jdbc-9.2-1002.src/certdir/badclient.pk8 0000664 0000000 0000000 00000001245 12050675701 0021647 0 ustar 00root root 0000000 0000000 00 *H
0g Uks~sR+adV^]r4RBg3&S4 5IT\.X[I_
ǀ
$yPӐ< CR0u)B]]ԜQ;5u$8ݩ=nkbE &EԻ>!&
Petǔor4Rk&Ih^P&x/K
s\#dqnNݴA
(w;4Qax ޣch <D}<4.~6־7sQZrfDzxVԦYu&KSG)IL E ڳn@D~, ^%
elfHL
۹lc-&jt[Cp ]"bG*%ޞ%E@ńa)dFrf#Ejsc1џ? XrBf
~C'*< C-lʄuse"Q^ )k@ ]D^42 ]sejf$tzq}(K"f[W+g"~7#?u%72$2sdBV s{P\vC &J ZN [yܷ"% postgresql-jdbc-9.2-1002.src/certdir/goodroot.crt 0000664 0000000 0000000 00000002066 12050675701 0021646 0 ustar 00root root 0000000 0000000 -----BEGIN CERTIFICATE-----
MIIC7zCCAligAwIBAgIJAOjCfnzSGkPLMA0GCSqGSIb3DQEBBQUAMFkxCzAJBgNV
BAYTAkFVMRMwEQYDVQQIEwpTb21lLVN0YXRlMSEwHwYDVQQKExhJbnRlcm5ldCBX
aWRnaXRzIFB0eSBMdGQxEjAQBgNVBAMTCWxvY2FsaG9zdDAeFw0xMTExMTAyMTQz
NTdaFw0yMTExMDcyMTQzNTdaMFkxCzAJBgNVBAYTAkFVMRMwEQYDVQQIEwpTb21l
LVN0YXRlMSEwHwYDVQQKExhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQxEjAQBgNV
BAMTCWxvY2FsaG9zdDCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEApE4i3cM5
zVAgfw8juoNN9kh/jiqZexQTUgQUrjQAMStSBVvPeoPcShbXYAZFCkICZlPdRrjY
rCyJfdFkII5W+CRh5uNPuv30NDMkCdDYvre02EsOhpmuXaJcUPL24vlTe+9+su4U
Hjy7FxOrQLe4S4kB7CNEE0lqLVDr5gXOKGkCAwEAAaOBvjCBuzAdBgNVHQ4EFgQU
0Cs8cRK/hNU0+IkSJO+rxuebtmcwgYsGA1UdIwSBgzCBgIAU0Cs8cRK/hNU0+IkS
JO+rxuebtmehXaRbMFkxCzAJBgNVBAYTAkFVMRMwEQYDVQQIEwpTb21lLVN0YXRl
MSEwHwYDVQQKExhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQxEjAQBgNVBAMTCWxv
Y2FsaG9zdIIJAOjCfnzSGkPLMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEFBQAD
gYEATKWuep0dRQdOwO3QSOYZX3bmbgbMX5rIMn8RT3a/SX4ZD5MSZSqgVOjdmj/I
kRnlGTyexXIXgKxps4WefCuU8uFqEfGE/yKRD1Lxy4AVve9soPddKtxTAbq1TNXr
A/5bu1Qqf4tSx48qlQkWbj3Okz2yDbWEjYXWoG3ky4CCtfc=
-----END CERTIFICATE-----
postgresql-jdbc-9.2-1002.src/certdir/server/ 0000775 0000000 0000000 00000000000 12050675701 0020602 5 ustar 00root root 0000000 0000000 postgresql-jdbc-9.2-1002.src/certdir/server/pg_hba.conf 0000664 0000000 0000000 00000007441 12050675701 0022677 0 ustar 00root root 0000000 0000000 # PostgreSQL Client Authentication Configuration File
# ===================================================
#
# Refer to the "Client Authentication" section in the
# PostgreSQL documentation for a complete description
# of this file. A short synopsis follows.
#
# This file controls: which hosts are allowed to connect, how clients
# are authenticated, which PostgreSQL user names they can use, which
# databases they can access. Records take one of these forms:
#
# local DATABASE USER METHOD [OPTIONS]
# host DATABASE USER CIDR-ADDRESS METHOD [OPTIONS]
# hostssl DATABASE USER CIDR-ADDRESS METHOD [OPTIONS]
# hostnossl DATABASE USER CIDR-ADDRESS METHOD [OPTIONS]
#
# (The uppercase items must be replaced by actual values.)
#
# The first field is the connection type: "local" is a Unix-domain socket,
# "host" is either a plain or SSL-encrypted TCP/IP socket, "hostssl" is an
# SSL-encrypted TCP/IP socket, and "hostnossl" is a plain TCP/IP socket.
#
# DATABASE can be "all", "sameuser", "samerole", a database name, or
# a comma-separated list thereof.
#
# USER can be "all", a user name, a group name prefixed with "+", or
# a comma-separated list thereof. In both the DATABASE and USER fields
# you can also write a file name prefixed with "@" to include names from
# a separate file.
#
# CIDR-ADDRESS specifies the set of hosts the record matches.
# It is made up of an IP address and a CIDR mask that is an integer
# (between 0 and 32 (IPv4) or 128 (IPv6) inclusive) that specifies
# the number of significant bits in the mask. Alternatively, you can write
# an IP address and netmask in separate columns to specify the set of hosts.
#
# METHOD can be "trust", "reject", "md5", "password", "gss", "sspi", "krb5",
# "ident", "pam", "ldap" or "cert". Note that "password" sends passwords
# in clear text; "md5" is preferred since it sends encrypted passwords.
#
# OPTIONS are a set of options for the authentication in the format
# NAME=VALUE. The available options depend on the different authentication
# methods - refer to the "Client Authentication" section in the documentation
# for a list of which options are available for which authentication methods.
#
# Database and user names containing spaces, commas, quotes and other special
# characters must be quoted. Quoting one of the keywords "all", "sameuser" or
# "samerole" makes the name lose its special character, and just match a
# database or username with that name.
#
# This file is read on server startup and when the postmaster receives
# a SIGHUP signal. If you edit the file on a running system, you have
# to SIGHUP the postmaster for the changes to take effect. You can use
# "pg_ctl reload" to do that.
# Put your actual configuration here
# ----------------------------------
#
# If you want to allow non-local connections, you need to add more
# "host" records. In that case you will also need to make PostgreSQL listen
# on a non-local interface via the listen_addresses configuration parameter,
# or via the -i or -h command line switches.
#
# CAUTION: Configuring the system for local "trust" authentication allows
# any local user to connect as any PostgreSQL user, including the database
# superuser. If you do not trust all your local users, use another
# authentication method.
# TYPE DATABASE USER CIDR-ADDRESS METHOD
# "local" is for Unix domain socket connections only
local all all ident
# IPv4 local connections:
host hostdb all 127.0.0.1/32 md5
hostnossl hostnossldb all 127.0.0.1/32 md5
hostssl hostssldb all 127.0.0.1/32 md5 clientcert=0
hostssl hostsslcertdb all 127.0.0.1/32 md5 clientcert=1
hostssl certdb all 127.0.0.1/32 cert
postgresql-jdbc-9.2-1002.src/certdir/server/root.crt 0000664 0000000 0000000 00000002036 12050675701 0022300 0 ustar 00root root 0000000 0000000 -----BEGIN CERTIFICATE-----
MIIC3jCCAkegAwIBAgIJAM9GGWA8iSiIMA0GCSqGSIb3DQEBBQUAMFQxCzAJBgNV
BAYTAkFVMRMwEQYDVQQIEwpTb21lLVN0YXRlMSEwHwYDVQQKExhJbnRlcm5ldCBX
aWRnaXRzIFB0eSBMdGQxDTALBgNVBAMTBHRlc3QwHhcNMTExMTEwMjE0MTQ3WhcN
MjExMTA3MjE0MTQ3WjBUMQswCQYDVQQGEwJBVTETMBEGA1UECBMKU29tZS1TdGF0
ZTEhMB8GA1UEChMYSW50ZXJuZXQgV2lkZ2l0cyBQdHkgTHRkMQ0wCwYDVQQDEwR0
ZXN0MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCns68NbjKQAnHCpmN6amR1
GdtliqiXDaCjoeBPpVXNQ/ZhqinP9gnDyRPXC5kPqw5/6GqNHcYJqg+IIS8G85Rq
t3Cs5ZL+JlEDAwd0CkD0Ey5h0oJNfN1bDhV2e/yqc831ElBGK6VItGqKopSUV2y/
pNijOOdeMZ8GuktT+9mbAQIDAQABo4G3MIG0MB0GA1UdDgQWBBTE93pAIzHiFRFw
IU38WhnwXm03GzCBhAYDVR0jBH0we4AUxPd6QCMx4hURcCFN/FoZ8F5tNxuhWKRW
MFQxCzAJBgNVBAYTAkFVMRMwEQYDVQQIEwpTb21lLVN0YXRlMSEwHwYDVQQKExhJ
bnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQxDTALBgNVBAMTBHRlc3SCCQDPRhlgPIko
iDAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEBBQUAA4GBAKUsXLsp3i9Tsj1wp46R
4IkIjwWT1bN3+JOjmA9aqwEVcxTRSStAa5kfTQwc4QSAgHK1oFPsA8gsv3sftYmZ
MtvYrvba8cOPonuaCrvtJQMvKgv3d10S6esUGlW+5o3PVPUq5yQ7OaN5JHCDTZGS
phuxlq7//rNjvypX2hbKUj6z
-----END CERTIFICATE-----
postgresql-jdbc-9.2-1002.src/certdir/server/server.crt 0000664 0000000 0000000 00000002066 12050675701 0022626 0 ustar 00root root 0000000 0000000 -----BEGIN CERTIFICATE-----
MIIC7zCCAligAwIBAgIJAOjCfnzSGkPLMA0GCSqGSIb3DQEBBQUAMFkxCzAJBgNV
BAYTAkFVMRMwEQYDVQQIEwpTb21lLVN0YXRlMSEwHwYDVQQKExhJbnRlcm5ldCBX
aWRnaXRzIFB0eSBMdGQxEjAQBgNVBAMTCWxvY2FsaG9zdDAeFw0xMTExMTAyMTQz
NTdaFw0yMTExMDcyMTQzNTdaMFkxCzAJBgNVBAYTAkFVMRMwEQYDVQQIEwpTb21l
LVN0YXRlMSEwHwYDVQQKExhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQxEjAQBgNV
BAMTCWxvY2FsaG9zdDCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEApE4i3cM5
zVAgfw8juoNN9kh/jiqZexQTUgQUrjQAMStSBVvPeoPcShbXYAZFCkICZlPdRrjY
rCyJfdFkII5W+CRh5uNPuv30NDMkCdDYvre02EsOhpmuXaJcUPL24vlTe+9+su4U
Hjy7FxOrQLe4S4kB7CNEE0lqLVDr5gXOKGkCAwEAAaOBvjCBuzAdBgNVHQ4EFgQU
0Cs8cRK/hNU0+IkSJO+rxuebtmcwgYsGA1UdIwSBgzCBgIAU0Cs8cRK/hNU0+IkS
JO+rxuebtmehXaRbMFkxCzAJBgNVBAYTAkFVMRMwEQYDVQQIEwpTb21lLVN0YXRl
MSEwHwYDVQQKExhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQxEjAQBgNVBAMTCWxv
Y2FsaG9zdIIJAOjCfnzSGkPLMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEFBQAD
gYEATKWuep0dRQdOwO3QSOYZX3bmbgbMX5rIMn8RT3a/SX4ZD5MSZSqgVOjdmj/I
kRnlGTyexXIXgKxps4WefCuU8uFqEfGE/yKRD1Lxy4AVve9soPddKtxTAbq1TNXr
A/5bu1Qqf4tSx48qlQkWbj3Okz2yDbWEjYXWoG3ky4CCtfc=
-----END CERTIFICATE-----
postgresql-jdbc-9.2-1002.src/certdir/server/server.key 0000664 0000000 0000000 00000001567 12050675701 0022633 0 ustar 00root root 0000000 0000000 -----BEGIN RSA PRIVATE KEY-----
MIICXAIBAAKBgQCkTiLdwznNUCB/DyO6g032SH+OKpl7FBNSBBSuNAAxK1IFW896
g9xKFtdgBkUKQgJmU91GuNisLIl90WQgjlb4JGHm40+6/fQ0MyQJ0Ni+t7TYSw6G
ma5dolxQ8vbi+VN7736y7hQePLsXE6tAt7hLiQHsI0QTSWotUOvmBc4oaQIDAQAB
AoGAXkP1/QVkxEaUXlFxTjDHKeWuSQJnzBVYgFWXB9sNwSf5htmFz+SXHmq8Znsy
YRA+EDdNXKXwqddjiqv3pjYD7q6TgzF4D32/NwZGfF7VzBDj2fXpVxjSMZpsHixq
7GIMUTZxzqTlUMmozEFCgHycN84Pw9dmPpJ6FerqsxhPA4ECQQDQfIZuhBhBqinP
qHs1ttZQ1VIgJvCnjXXovyQF0fo53xhCqBIHAPQk/zbFDEjdH54e2gSYekBSvtwD
Dy9KmjbjAkEAyb//56WAYY3gFYBVDSyCZF5Afax0KS/eDYKlPiF45BtdxhdNTY6M
56C1+K3FiAuTMzNUbfXnDq9mZ1lZreX5QwJBAMx1gqS5WMx044Ip2YMI5s7pFRxA
8/ttiHeTk/E9RmcgubsM9nj133i07PJ7pK1uR3Q8HQunwJMlZ8B8UMWZzT8CQBD7
zcIlZ4pO1DdbJ03FmnByksFBnEG/WtUOU3TIgpHJT/qWCZbm0ivJlqgJkOBkAQ9F
We0rzzioQVmf5vHBs1sCQDCEzTU8Ge/BrWtd1EP9JVx7aFY8c5bRvj+3FPp+43Ep
5kc1lJK8EINevxykfJ4f94S6GPLuSFfIWEys//WrH14=
-----END RSA PRIVATE KEY-----
postgresql-jdbc-9.2-1002.src/doc/ 0000775 0000000 0000000 00000000000 12050675701 0016405 5 ustar 00root root 0000000 0000000 postgresql-jdbc-9.2-1002.src/doc/pgjdbc.xml 0000664 0000000 0000000 00000340503 12050675701 0020365 0 ustar 00root root 0000000 0000000
The <productname>PostgreSQL</productname> <acronym>JDBC</acronym> InterfaceIntroduction
JDBC is a core API of Java 1.1 and later.
It provides a standard set of
interfaces to SQL-compliant databases.
PostgreSQL provides a type
4 JDBC driver. Type 4 indicates
that the driver is written in Pure Java, and communicates in the
database system's own network protocol. Because of this, the driver
is platform independent; once compiled, the driver can be used on
any system.
This manual is not intended as a complete guide to
JDBC programming, but should help to get you
started. For more information refer to the standard
JDBC API documentation.
Also, take a look at the examples included with the source.
Setting up the <acronym>JDBC</acronym> Driver
This section describes the steps you need to take before you can
write or run programs that use the JDBC interface.
Getting the Driver
Precompiled versions of the driver can be downloaded from
the PostgreSQL
JDBC web site.
Alternatively you can build the driver from source, but you should
only need to do this if you are making changes to the source code.
To build the JDBC driver, you need
Ant 1.5 or higher and a JDK.
Ant is a special tool for building
Java-based packages. It can be downloaded from the Ant
web site.
If you have several Java compilers installed, it depends on the
Ant configuration which one gets used. Precompiled
Ant distributions are typically set up
to read a file .antrc in the current user's
home directory for configuration. For example, to use a different
JDK than the default, this may work:
JAVA_HOME=/usr/local/jdk1.6.0_07
JAVACMD=$JAVA_HOME/bin/java
To compile the driver simply run ant in the top level
directory. The compiled driver will be placed in jars/postgresql.jar.
The resulting driver will be built for the version of Java you are
running. If you build with a 1.4 or 1.5
JDK you will build a version that supports the
JDBC 3 specification and if you build
with a 1.6 or higher JDK you will build a version that
supports the JDBC 4 specification.
Setting up the Class Pathclass pathCLASSPATH
To use the driver, the JAR archive (named
postgresql.jar if you built from source, otherwise
it will likely be named with the following convention:
postgresql-[server version].[buildnumber].jdbc[JDBC version].jar,
for example postgresql-8.0-310.jdbc3.jar)
needs to be included in the class path, either by putting it in the
CLASSPATH environment variable, or by using flags on the
java command line.
For instance, assume we have an application that uses the
JDBC driver to access a database, and that
application is installed as
/usr/local/lib/myapp.jar. The
PostgreSQL JDBC driver installed as
/usr/local/pgsql/share/java/postgresql.jar. To run
the application, we would use:
export CLASSPATH=/usr/local/lib/myapp.jar:/usr/local/pgsql/share/java/postgresql.jar:.
java MyApp
Loading the driver from within the application is covered in
.
Preparing the Database Server for <acronym>JDBC</acronym>
Because Java does not support using unix sockets the
PostgreSQL server must be configured to
allow TCP/IP connections. Starting with server
version 8.0 TCP/IP connections are allowed from
localhost. To allow connections to other interfaces
than the loopback interface, you must modify the
postgresql.conf file's
listen_addresses setting.
For server versions prior to 8.0 the server does not listen on any
interface by default, and you must set
tcpip_socket = true in the
postgresql.conf file.
Once you have made sure the server is correctly listening for
TCP/IP connections the next step is to verify
that users are allowed to connect to the server. Client authentication
is setup in pg_hba.conf.
Refer to the main PostgreSQL documentation for
details. The JDBC driver supports the
trust, ident,
password, md5, and
crypt authentication methods.
Creating a Database
When creating a database to be accessed via JDBC
it is important to select an appropriate encoding for your data. Many
other client interfaces do not care what data you send back and forth,
and will allow you to do inappropriate things, but Java makes sure that
your data is correctly encoded. Do not use a database that uses the
SQL_ASCII encoding. This is not a real
encoding and you will have problems the moment you store data in it that
does not fit in the seven bit ASCII character set.
If you do not know what your encoding will be or are otherwise unsure
about what you will be storing the UTF8 encoding
is a reasonable default to use.
Initializing the Driver
This section describes how to load and initialize the JDBC
driver in your programs.
Importing <acronym>JDBC</acronym>
Any source that uses JDBC needs to import the
java.sql package, using:
import java.sql.*;
You should not import the org.postgresql package
unless you are using not standard PostgreSQL
extensions to the JDBC API.
Loading the Driver
Starting from Java 6.0 it is enough to add the postgresql driver to the class path
because the PostgreSQL JDBC
driver supports the new auto-loading feature. You can safely ignore rest of the section.
In Java 5.0 or older, before you can connect to a database, you need to load the
driver. There are two methods available, and it depends on your
code which is the best one to use.
In the first method, your code implicitly loads the driver using the
Class.forName() method.
For PostgreSQL, you would use:
Class.forName("org.postgresql.Driver");
This will load the driver, and while loading, the driver will automatically
register itself with JDBC.
The forName() method can throw a
ClassNotFoundException if the driver is
not available.
This is the most common method to use, but restricts your code to
use just PostgreSQL. If your code may
access another database system in the future, and you do not use
any PostgreSQL-specific extensions, then
the second method is advisable.
The second method passes the driver as a parameter to the
JVM as it starts, using the
argument. Example:
java -Djdbc.drivers=org.postgresql.Driver example.ImageViewer
In this example, the JVM will attempt to load
the driver as part of its initialization. Once done, the
ImageViewer is started.
Now, this method is the better one to use because it allows your
code to be used with other database packages without recompiling
the code. The only thing that would also change is the connection
URL, which is covered next.
One last thing: When your code then tries to open a
Connection, and you get a No
driver availableSQLException
being thrown, this is probably caused by the driver not being in
the class path, or the value in the parameter not being correct.
Connecting to the Database
With JDBC, a database is represented by a
URL (Uniform Resource Locator). With
PostgreSQL, this takes one of the
following forms:
jdbc:postgresql:database
jdbc:postgresql://host/database
jdbc:postgresql://host:port/database
The parameters have the following meanings:
host
The host name of the server. Defaults to localhost.
To specify an IPv6 address your must enclose the
host parameter
with square brackets, for example:
jdbc:postgresql://[::1]:5740/accounting
port
The port number the server is listening on. Defaults to the
PostgreSQL standard port number (5432).
database
The database name.
To connect, you need to get a Connection instance from
JDBC. To do this,
you use the DriverManager.getConnection() method:
Connection db = DriverManager.getConnection(url, username, password);
Connection Parameters
In addition to the standard connection parameters the driver supports a
number of additional properties which can be used to specify additional
driver behavior specific to PostgreSQL. These
properties may be specified in either the connection
URL or an additional
Properties object parameter to
DriverManager.getConnection. The following
examples illustrate the use of both methods to establish a SSL
connection.
String url = "jdbc:postgresql://localhost/test";
Properties props = new Properties();
props.setProperty("user","fred");
props.setProperty("password","secret");
props.setProperty("ssl","true");
Connection conn = DriverManager.getConnection(url, props);
String url = "jdbc:postgresql://localhost/test?user=fred&password=secret&ssl=true";
Connection conn = DriverManager.getConnection(url);
user = String
The database user on whose behalf the connection is being made.
password = String
The database user's password.
ssl
Connect using SSL. The driver must have been
compiled with SSL support. This property does
not need a value associated with it. The mere presence of it
specifies a SSL connection. However, for
compatibility with future versions, the value "true" is
preferred. For more information see .
Alternatively sslmode can be used.sslmode
Parameter governing the use of SSL. Similar to the
libpq parameter, the allowed values are disable, require, verify-ca,
verify-full. (allow and require are not implemented.)
The use of parameter ssl is discouraged, as sslmode
can cover all the possibilities, however, if sslmode is not
set, the driver's behaviour is backward compatible.
sslcert
The location of the client's SSL certificate.
The file format is compatible with libpq. If missing, the default
locations are looked up (in $HOME/.postgresql under Linux).
In some cases it is desirable
to supress loading the default client certificate (and any other one),
in this case specify sslcert with an empty argument.
sslrootcert
The location of the root certificate for authenticating the server.
The file format is compatible with libpq. If missing, the default
locations are looked up (in $HOME/.postgresql under Linux).
sslkey
The location of the client's SSL key.
The file must be in PKCS#8 format.
The conversion can be made
by the following openssl command:
openssl pkcs8 -topk8 -in client.key -out client.pk8 -outform DER -v1 PBE-SHA1-3DES
the ciphers, recognized by java are PBE-MD5-DES, PBE-SHA1-3DES,
PBE-SHA1-RC2-40,
or with the -nocrypt switch, it can be unencrypted.
If missing, the default
locations are looked up (in $HOME/.postgresql under Linux).
The default filename for the key is postgresql.pk8
instead of postgresql.key to allow simultaneous use of the jdbc driver
and other libpq compatible applications.
sslpassword
The password for the client's ssl key (different from the database password).
sslpasswordcallback
A class, implementing
javax.security.auth.callback.CallbackHandler
that can handle PassworCallback for the ssl password. If set,
sslpassword is ignored.
The supplied class must have either a constructor with a Properties
argument where
the connection info properties are given, or a zero argument constructor
If neither sslpassword nor sslpasswordcallback is set, and the key is
protected,
the user is prompted at the console for a password
sslhostnameverifier
A class, implementing javax.net.ssl.HostnameVerifier
that can verify the server. The supplied class must have either a
constructor
with a Properties argument where the connection info properties are given,
or a zero argument constructor. If set the server hostname is verified
irrespective
of the value of sslmode.
sslfactory = String
The provided value is a class name to use as the
SSLSocketFactory when establishing a
SSL connection.
For more information see .
sslfactoryarg = String
This value is an optional argument to the constructor of the
sslfactory class provided above.
For more information see .
compatible = String
Act like an older version of the driver to retain compatibility with
older applications. At the moment this controls two driver behaviours:
the handling of binary data fields, and the handling of parameters set
via setString()
Older versions of the driver used this property to also control the
protocol used to connect to the backend. This is now controlled by the
protocolVersion property.
Information on binary data handling is detailed in
. To force the use of
Large Objects set the compatible property to 7.1.
When compatible is set to 7.4 or
below, the default for the stringtype parameter is
changed to unspecified.
protocolVersion = String
The driver supports both the V2 and V3 frontend/backend protocols.
The V3 protocol was introduced in 7.4 and the driver will by default
try to connect using the V3 protocol, if that fails it will fall
back to the V2 protocol. If the protocolVersion property is
specified, the driver will try only the specified protocol (which
should be either "2" or "3"). Setting protocolVersion to "2" may
be used to avoid the failed attempt to use the V3 protocol when
connecting to a version 7.3 or earlier server, or to force the
driver to use the V2 protocol despite connecting to a 7.4 or greater
server.
loglevel = int
Set the amount of logging information printed to the DriverManager's
current value for LogStream or LogWriter. It currently supports
values of org.postgresql.Driver.DEBUG (2) and
org.postgresql.Driver.INFO (1).
INFO will log very little information while
DEBUG will produce significant detail. This
property is only really useful if you are a developer or are
having problems with the driver.
charSet = String
The character set to use for data sent to the database or recieved
from the database. This property is only relevent for server
versions less than or equal to 7.2. The 7.3 release was the first
with multibyte support compiled by default and the driver uses
its character set translation facilities instead of trying to do
it itself.
allowEncodingChanges = boolean
When using the V3 protocol the driver monitors changes in certain
server configuration parameters that should not be touched by
end users. The client_encoding setting is set
by the driver and should not be altered. If the driver detects
a change it will abort the connection. There is one legitimate
exception to this behavior though, using the COPY
command on a file residing on the server's filesystem. The only
means of specifying the encoding of this file is by altering the
client_encoding setting. The
JDBC team considers this a failing of the
COPY command and hopes to provide an alternate
means of specifying the encoding in the future, but for now there
is this URL parameter. Enable this only if
you need to override the client encoding when doing a copy.
logUnclosedConnections = boolean
Clients may leak Connection objects by
failing to call its close() method.
Eventually these objects will be garbage collected and the
finalize() method will be called which will
close the Connection if caller has
neglected to do this himself. The usage of a finalizer is just
a stopgap solution. To help developers detect and correct the
source of these leaks the logUnclosedConnections
URL parameter has been added. It captures
a stacktrace at each Connection opening
and if the finalize() method is reached without
having been closed the stacktrace is printed to the log.
binaryTransfer = boolean
The postgresql protocol v3 supports both binary and text transfer
of fields. When binaryTransfer is enabled the driver
requests binary transfer for all supported types. Using the binary
transfer is more optimal for both the server and the client.
Previously driver versions supported only text transfers. The old
functionality can be obtained by setting this field to false.
Currently the following column types currently support binary encoding:
BYTEA, TIMEx,
TIMESTAMP*, DATE,
INT* and FLOAT*.
prepareThreshold = int
Determine the number of PreparedStatement
executions required before switching over to use server side prepared
statements. The default is five, meaning start using server side
prepared statements on the fifth execution of the same
PreparedStatement object. More
information on server side prepared
statements is available in .
loginTimeout = int
Specify how long to wait for establishment of a database connection.
The timeout is specified in seconds.
socketTimeout = int
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.
tcpKeepAlive = boolean
Enable or disable TCP keep-alive probe. The default is
false.
unknownLength = int
Certain postgresql types such as text do not
have a well defined length. When returning meta-data about
these types through functions like
ResultSetMetaData.getColumnDisplaySize
and ResultSetMetaData.getPrecision
we must provide a value and various client tools have
different ideas about what they would like to see. This
parameter specifies the length to return for types of
unknown length.
stringtype = String
Specify the type to use when binding PreparedStatement parameters
set via setString(). If stringtype is set to
varchar (the default), such parameters will be sent to the server as
varchar parameters. If stringtype is set to
unspecified, parameters will be sent to the server as untyped values,
and the server will attempt to infer an appropriate type. This is useful if you have an
existing application that uses setString() to set parameters that
are actually some other type, such as integers, and you are unable to change the
application to use an appropriate method such as setInt().
kerberosServerName = String
The Kerberos service name to use when authenticating with GSSAPI. This is
equivalent to libpq's PGKRBSRVNAME environment variable and defaults to
"postgres".
jaasApplicationName = String
Specifies the name of the JAAS system or application
login configuration.
ApplicationName = String
Specifies the name of the application that is using the connection.
This allows a database administrator to see what applications are
connected to the server and what resources they are using through
views like pg_stat_activity.
sendBufferSize = int
Sets SO_SNDBUF on the connection stream
recvBufferSize = int
Sets SO_RCVBUF on the connection stream
Using <acronym>SSL</acronym>Configuring the Server
Configuring the PostgreSQL server for
SSL is covered in the
main documentation,
so it will not be repeated here. Before trying to access your
SSL enabled server from Java, make sure you
can get to it via psql. You should see output
like the following if you have established a SSL
connnection.
$ ./bin/psql -h localhost
Welcome to psql 8.0.0rc5, the PostgreSQL interactive terminal.
Type: \copyright for distribution terms
\h for help with SQL commands
\? for help with psql commands
\g or terminate with semicolon to execute query
\q to quit
SSL connection (cipher: DHE-RSA-AES256-SHA, bits: 256)
jurka=#
Configuring the Client
If SSL is initiated by setting the ssl
connection parameter, then unlike psql and other
libpq based programs the
JDBC driver does server certificate
validation by default. This means that when establishing a
SSL connection the JDBC
driver will validate the server's identity preventing
"man in the middle" attacks. It does this by checking that
the server certificate is signed by a trusted authority. If
you have a certificate signed by a global certificate authority
(CA), there is nothing further to do
because Java comes with copies of the most common CA's certificates.
If you are dealing with a self-signed certificate though, you
need to make this available to the Java client to enable it
to validate the server's certificate.
Only the JDBC 3 driver supports
SSL. The 1.4 JDK
was the first version to come bundled with SSL
support. Previous JDK versions that wanted
to use SSL could make use of the additional
JSSE library, but it does not support the
full range of features utilized by the
PostgreSQL JDBC
driver.
To make the server certificate available to Java, the first step
is to convert it to a form Java understands.
openssl x509 -in server.crt -out server.crt.der -outform der
From here the easiest thing to do is import this certificate into Java's
system truststore.
keytool -keystore $JAVA_HOME/lib/security/cacerts -alias postgresql -import -file server.crt.der
The default password for the cacerts keystore is changeit. The alias to postgesql is not important and you may select any name you desire.
If you do not have access to the system cacerts truststore you can create your own truststore.
keytool -keystore mystore -alias postgresql -import -file server.crt.der
When starting your Java application you must specify this keystore and
password to use.
java -Djavax.net.ssl.trustStore=mystore -Djavax.net.ssl.trustStorePassword=mypassword com.mycompany.MyApp
In the event of problems extra debugging information is available
by adding -Djavax.net.debug=ssl to your command
line.
To instruct the JDBC driver to try and establish
a SSL connection you must add the connection
URL parameter ssl=true.
Using SSL without Certificate Validation
In some situations it may not be possible to configure your Java
environment to make the server certificate available, for example
in an applet. For a large scale deployment it would be best to
get a certificate signed by recognized certificate authority, but
that is not always an option. The JDBC driver
provides an option to establish a SSL connection
without doing any validation, but please understand the risk
involved before enabling this option.
A non-validating connection is established via a custom
SSLSocketFactory class that is provided with
the driver. Setting the connection URL
parameter
sslfactory=org.postgresql.ssl.NonValidatingFactory
will turn off all SSL validation.
Custom SSLSocketFactoryPostgreSQL provides a way for developers
to customize how a SSL connection is established.
This may be used to provide a custom certificate source or other
extensions by allowing the developer to create their own
SSLContext instance. The connection
URL parameters
sslfactory and sslfactoryarg
allow the user to specify which custom class to use for creating
the SSLSocketFactory. The class name specified
by sslfactory must extend
javax.net.ssl.SSLSocketFactory and be available
to the driver's classloader. This class
must have a zero argument constructor or a single argument
constructor taking a Properies argument where the connection
properties are passed or a single argument constructor taking a
String argument. This argument
may optionally be supplied by sslfactoryarg.
The sslfactory must not initiate a handshake in it's
createSocket method, because a second startHandsake invocation
in the JDBC driver will break the connection.
If an sslhostnameverifier class is supplied,
it is still responsible for handling the hostname verification.
Information on how to actually implement such a class is beyond
the scope of this documentation. Places to look for help are the
JSSE Reference Guide and the source to the
NonValidatingFactory provided by the
JDBC driver.
The Java SSL API is not very
well known to the JDBC driver developers and we
would be interested in any interesting and generally useful
extensions that you have implemented using this mechanism.
Specifically it would be nice to be able to provide client certificates
to be validated by the server.
Issuing a Query and Processing the ResultStatementPreparedStatementResultSet
Any time you want to issue SQL statements to
the database, you require a Statement or
PreparedStatement instance. Once you have
a Statement or
PreparedStatement, you can use issue a
query. This will return a ResultSet
instance, which contains the entire result (see
here for how to alter this behaviour).
illustrates this process.
Processing a Simple Query in <acronym>JDBC</acronym>
This example will issue a simple query and print out the first
column of each row using a Statement.
Statement st = conn.createStatement();
ResultSet rs = st.executeQuery("SELECT * FROM mytable WHERE columnfoo = 500");
while (rs.next()) {
System.out.print("Column 1 returned ");
System.out.println(rs.getString(1));
}
rs.close();
st.close();
This example issues the same query as before but uses
a PreparedStatement
and a bind value in the query.
int foovalue = 500;
PreparedStatement st = conn.prepareStatement("SELECT * FROM mytable WHERE columnfoo = ?");
st.setInt(1, foovalue);
ResultSet rs = st.executeQuery();
while (rs.next()) {
System.out.print("Column 1 returned ");
System.out.println(rs.getString(1));
}
rs.close();
st.close();
Getting results based on a cursorBy default the driver collects all the results for the
query at once. This can be inconvenient for large data sets so
the JDBC driver provides a means of basing
a ResultSet on a database cursor and
only fetching a small number of rows.A small number of rows are cached on the
client side of the connection and when exhausted the next
block of rows is retrieved by repositioning the cursor.
Cursor based ResultSets cannot be used in all
situations. There a number of restrictions which will make the driver
silently fall back to fetching the whole ResultSet
at once.
The connection to the server must be using the V3 protocol. This is the
default for (and is only supported by) server versions 7.4 and later.
The Connection must not be in autocommit
mode. The backend closes cursors at the end of transactions, so in
autocommit mode the backend will have closed the cursor before anything
can be fetched from it.
The Statement must be created with
a ResultSet type of
ResultSet.TYPE_FORWARD_ONLY.
This is the default, so no code will need to be rewritten to take
advantage of this, but it also means that you cannot scroll
backwards or otherwise jump around in the
ResultSet.
The query given must be a single statement, not multiple statements
strung together with semicolons.
Setting fetch size to turn cursors on and off.Changing code to cursor mode is as simple as setting the
fetch size of the Statement to the
appropriate size. Setting the fetch size back to 0 will cause
all rows to be cached (the default behaviour).
// make sure autocommit is off
conn.setAutoCommit(false);
Statement st = conn.createStatement();
// Turn use of the cursor on.
st.setFetchSize(50);
ResultSet rs = st.executeQuery("SELECT * FROM mytable");
while (rs.next()) {
System.out.print("a row was returned.");
}
rs.close();
// Turn the cursor off.
st.setFetchSize(0);
rs = st.executeQuery("SELECT * FROM mytable");
while (rs.next()) {
System.out.print("many rows were returned.");
}
rs.close();
// Close the statement.
st.close();
Using the <classname>Statement</classname> or <classname>PreparedStatement</classname> Interface
The following must be considered when using the
Statement or
PreparedStatement interface:
You can use a single Statement instance
as many times as you want. You could create one as soon as you
open the connection and use it for the connection's
lifetime. But you have to remember that only one
ResultSet can exist per
Statement or
PreparedStatement at a given time.
If you need to perform a query while processing a
ResultSet, you can simply create and
use another Statement.
If you are using threads, and several are using the database,
you must use a separate Statement for
each thread. Refer to if you are
thinking of using threads, as it covers some important points.
When you are done using the Statement
or PreparedStatement
you should close it.
Using the <classname>ResultSet</classname> Interface
The following must be considered when using the
ResultSet interface:
Before reading any values, you must call
next(). This returns true if there is a
result, but more importantly, it prepares the row for
processing.
You must close a ResultSet by calling
close() once you have finished using it.
Once you make another query with the
Statement used to create a
ResultSet, the currently open
ResultSet instance is closed
automatically.
Performing Updates
To change data (perform an INSERT,
UPDATE, or DELETE) you use
the executeUpdate() method. This method is
similar to the method executeQuery() used to
issue a SELECT statement, but it doesn't return
a ResultSet; instead it returns the number
of rows affected by the INSERT,
UPDATE, or DELETE statement.
illustrates the usage.
Deleting Rows in <acronym>JDBC</acronym>
This example will issue a simple DELETE
statement and print out the number of rows deleted.
int foovalue = 500;
PreparedStatement st = conn.prepareStatement("DELETE FROM mytable WHERE columnfoo = ?");
st.setInt(1, foovalue);
int rowsDeleted = st.executeUpdate();
System.out.println(rowsDeleted + " rows deleted");
st.close();
Creating and Modifying Database Objects
To create, modify or drop a database object like a table or view
you use the execute() method. This method is
similar to the method executeQuery(), but it
doesn't return a result.
illustrates the usage.
Dropping a Table in <acronym>JDBC</acronym>
This example will drop a table.
Statement st = conn.createStatement();
st.execute("DROP TABLE mytable");
st.close();
Calling Stored FunctionsCalling a built in stored functionThis example shows how to call
a PostgreSQL built in
function, upper, which simply converts the
supplied string argument to uppercase.
CallableStatement upperProc = conn.prepareCall("{ ? = call upper( ? ) }");
upperProc.registerOutParameter(1, Types.VARCHAR);
upperProc.setString(2, "lowercase to uppercase");
upperProc.execute();
String upperCased = upperProc.getString(1);
upperProc.close();
Obtaining a <classname>ResultSet</classname> from a stored functionPostgreSQL's stored functions
can return results in two different ways. The function may return
either a refcursor value or a SETOF
some datatype. Depending on which of these return methods are used
determines how the function should be called.
From a Function Returing <literal>SETOF</literal> type
Functions that return data as a set should not be called via the
CallableStatement interface, but instead should
use the normal Statement or
PreparedStatement interfaces.
Getting <literal>SETOF</literal> type values from a function
Statement stmt = conn.createStatement();
stmt.execute("CREATE OR REPLACE FUNCTION setoffunc() RETURNS SETOF int AS "
+ "' SELECT 1 UNION SELECT 2;' LANGUAGE sql");
ResultSet rs = stmt.executeQuery("SELECT * FROM setoffunc()");
while (rs.next()) {
// do something
}
rs.close();
stmt.close();
From a Function Returing a <type>refcursor</type>
When calling a function that returns
a refcursor you must cast the return type
of getObject to
a ResultSet
One notable limitation of the current support for a
ResultSet created from a
refcursor is that even though it is a cursor
backed ResultSet, all data will be retrieved
and cached on the client. The Statement
fetch size parameter described in
is ignored. This limitation
is a deficiency of the JDBC driver,
not the server, and it is technically possible to remove it,
we just haven't found the time.
Getting <type>refcursor</type> Value From a Function
// Setup function to call.
Statement stmt = conn.createStatement();
stmt.execute("CREATE OR REPLACE FUNCTION refcursorfunc() RETURNS refcursor AS '"
+ " DECLARE "
+ " mycurs refcursor; "
+ " BEGIN "
+ " OPEN mycurs FOR SELECT 1 UNION SELECT 2; "
+ " RETURN mycurs; "
+ " END;' language plpgsql");
stmt.close();
// We must be inside a transaction for cursors to work.
conn.setAutoCommit(false);
// Procedure call.
CallableStatement proc = conn.prepareCall("{ ? = call refcursorfunc() }");
proc.registerOutParameter(1, Types.OTHER);
proc.execute();
ResultSet results = (ResultSet) proc.getObject(1);
while (results.next()) {
// do something with the results...
}
results.close();
proc.close();
It is also possible to treat the refcursor
return value as a cursor name directly. To do this, use the
getString of ResultSet.
With the underlying cursor name, you are free to directly use cursor
commands on it, such as FETCH and
MOVE.
Treating <type>refcursor</type> as a cursor name
conn.setAutoCommit(false);
CallableStatement proc = conn.prepareCall("{ ? = call refcursorfunc() }");
proc.registerOutParameter(1, Types.OTHER);
proc.execute();
String cursorName = proc.getString(1);
proc.close();
Storing Binary Databyteain JDBClarge objectin JDBCPostgreSQL provides two distinct ways to
store binary data. Binary data can be stored in a table using
the data type bytea or by using the Large Object
feature which stores the binary data in a separate table in a special
format and refers to that table by storing a value of type
oid in your table.
In order to determine which method is appropriate you
need to understand the limitations of each method. The
bytea data type is not well suited for storing very
large amounts of binary data. While a column of type
bytea can hold up to 1 GB of binary data, it would
require a huge amount of memory to
process such a large value. The Large Object method for
storing binary data is better suited to storing very large values,
but it has its own limitations. Specifically deleting a row
that contains a Large Object reference does not delete the Large Object.
Deleting the Large Object is a separate operation that needs to
be performed. Large Objects also have some security
issues since anyone connected to the database can view
and/or modify any Large Object, even if they don't have
permissions to view/update the row containing the Large Object reference.
Version 7.2 was the first release of the JDBC driver
that supports the bytea data type. The introduction of
this functionality in 7.2 has introduced a change in behavior
as compared to previous releases. Since 7.2, the methods
getBytes(), setBytes(),
getBinaryStream(), and
setBinaryStream() operate on
the bytea data type. In 7.1 and earlier, these methods operated
on the oid data type associated with Large Objects.
It is possible to revert the driver back to the old 7.1 behavior
by setting the property compatible on
the Connection object to the value
7.1. More details on connection properties are
available in .
To use the bytea data type you should simply use
the getBytes(), setBytes(),
getBinaryStream(), or
setBinaryStream() methods.
To use the Large Object functionality you can use either the
LargeObject class provided by the
PostgreSQL JDBC driver, or by
using the getBLOB() and
setBLOB() methods.
You must access Large Objects within an SQL
transaction block. You can start a transaction block by calling
setAutoCommit(false).
contains some examples on
how to process binary data using the PostgreSQL
JDBC driver.
Processing Binary Data in <acronym>JDBC</acronym>
For example, suppose you have a table containing the file names of
images and you also want to store the image in a bytea
column:
CREATE TABLE images (imgname text, img bytea);
To insert an image, you would use:
File file = new File("myimage.gif");
FileInputStream fis = new FileInputStream(file);
PreparedStatement ps = conn.prepareStatement("INSERT INTO images VALUES (?, ?)");
ps.setString(1, file.getName());
ps.setBinaryStream(2, fis, (int)file.length());
ps.executeUpdate();
ps.close();
fis.close();
Here, setBinaryStream() transfers a set number
of bytes from a stream into the column of type bytea.
This also could have been done using the setBytes()
method if the contents of the image was already in a
byte[].
The length parameter to setBinaryStream must be
correct. There is no way to indicate that the stream is of unknown
length. If you are in this situation, you must read the stream yourself
into temporary storage and determine the length. Now with the correct
length you may send the data from temporary storage on to the driver.
Retrieving an image is even easier. (We use
PreparedStatement here, but the
Statement class can equally be used.)
PreparedStatement ps = conn.prepareStatement("SELECT img FROM images WHERE imgname = ?");
ps.setString(1, "myimage.gif");
ResultSet rs = ps.executeQuery();
while (rs.next()) {
byte[] imgBytes = rs.getBytes(1);
// use the data in some way here
}
rs.close();
ps.close();
Here the binary data was retrieved as an
byte[]. You could have used a
InputStream object instead.
Alternatively you could be storing a very large file and want to use
the LargeObject API to
store the file:
CREATE TABLE imageslo (imgname text, imgoid oid);
To insert an image, you would use:
// All LargeObject API calls must be within a transaction block
conn.setAutoCommit(false);
// Get the Large Object Manager to perform operations with
LargeObjectManager lobj = ((org.postgresql.PGConnection)conn).getLargeObjectAPI();
// Create a new large object
long oid = lobj.createLO(LargeObjectManager.READ | LargeObjectManager.WRITE);
// Open the large object for writing
LargeObject obj = lobj.open(oid, LargeObjectManager.WRITE);
// Now open the file
File file = new File("myimage.gif");
FileInputStream fis = new FileInputStream(file);
// Copy the data from the file to the large object
byte buf[] = new byte[2048];
int s, tl = 0;
while ((s = fis.read(buf, 0, 2048)) > 0) {
obj.write(buf, 0, s);
tl += s;
}
// Close the large object
obj.close();
// Now insert the row into imageslo
PreparedStatement ps = conn.prepareStatement("INSERT INTO imageslo VALUES (?, ?)");
ps.setString(1, file.getName());
ps.setLong(2, oid);
ps.executeUpdate();
ps.close();
fis.close();
// Finally, commit the transaction.
conn.commit();
Retrieving the image from the Large Object:
// All LargeObject API calls must be within a transaction block
conn.setAutoCommit(false);
// Get the Large Object Manager to perform operations with
LargeObjectManager lobj = ((org.postgresql.PGConnection)conn).getLargeObjectAPI();
PreparedStatement ps = conn.prepareStatement("SELECT imgoid FROM imageslo WHERE imgname = ?");
ps.setString(1, "myimage.gif");
ResultSet rs = ps.executeQuery();
while (rs.next()) {
// Open the large object for reading
long oid = rs.getLong(1);
LargeObject obj = lobj.open(oid, LargeObjectManager.READ);
// Read the data
byte buf[] = new byte[obj.size()];
obj.read(buf, 0, obj.size());
// Do something with the data read here
// Close the object
obj.close();
}
rs.close();
ps.close();
// Finally, commit the transaction.
conn.commit();
<acronym>JDBC</acronym> escapes
The JDBC specification (like the ODBC
specification) acknowledges the fact that some vendor specific
SQL may be required for certain RDBMS
features. To aid developers in writing portable JDBC
applications across multiple database products, a special escape syntax is
used to specify the generic commands the developer wants to be run. The
JDBC driver translates these escape sequences into
native syntax for its specific database.
For more information consult the section 4.1.5 from the
JDBC Technology Guide
(bundled with the Oracle JRE
documentation) and the section 13.4 from the
JDBC 4.0 specification.
The parsing of the sql statements for these escapes can be disabled using Statement.setEscapeProcessing(false).
Connection.nativeSQL(String sql) provides another way to have escapes processed.
It translates the given SQL to a SQL suitable for the PostgreSQL backend.
Using jdbc escapes
To use the JDBC escapes, you simply write your SQL replacing date/time literal
values, outer join and functions by the JDBC escape syntax.
For example :
ResultSet rs = st.executeQuery("SELECT {fn week({d '2005-01-24'})}");
is the portable version for
ResultSet rs = st.executeQuery("SELECT extract(week from DATE '2005-01-24')");
Escape for like escape character
You can specify which escape character to use in strings comparison (with LIKE) to protect wildcards
characters ('%' and '_') by adding the following escape : {escape 'escape-character'}.
The driver supports this only at the end of the comparison expression.
For example, you can compare string values using '|' as escape character to protect '_' :
rs = stmt.executeQuery("select str2 from comparisontest where str1 like '|_abcd' {escape '|'} ");
Escape for outer joins
You can specify outer joins using the following syntax:
{oj table (LEFT|RIGHT|FULL) OUTER JOIN (table | outer-join)
ON search-condition }
For example :
rs = stmt.executeQuery( "select * from {oj a left outer join b on (a.i=b.i)} ");
Date-time escapes
The JDBC specification defines escapes for specifying date, time and timestamp values which are supported by the
driver.
date{d 'yyyy-mm-dd'} which is translated to DATE 'yyyy-mm-dd'time{t 'hh:mm:ss'} which is translated to TIME 'hh:mm:ss'timestamp{ts 'yyyy-mm-dd hh:mm:ss.f...'} which is translated to TIMESTAMP 'yyyy-mm-dd hh:mm:ss.f'
The fractional seconds (.f...) portion of the TIMESTAMP can be omitted. Escaped scalar functions
The JDBC specification defines functions with an escape call syntax : {fn function_name(arguments)}.
The following tables show which functions are supported by the PostgresSQL driver.
The driver supports the nesting and the mixing of escaped functions and escaped values.
The appendix C of the JDBC specification describes the functions.
Some functions in the following tables are translated but not reported as supported because they are
duplicating or changing ther order of the arguments. While this is harmless for literal values or
columns, it will cause problems when using prepared statements.
For example "{fn right(?,?)}" will be translated to "substring(? from (length(?)+1-?))".
As you can see the translated SQL requires more parameters than before the translation but the
driver will not automatically handle this.
Supported escaped numeric functionsfunctionreported as supportedtranslationcommentsabs(arg1)yesabs(arg1)acos(arg1)yesacos(arg1)asin(arg1)yesasin(arg1)atan(arg1)yesatan(arg1)atan2(arg1,arg2)yesatan2(arg1,arg2)ceiling(arg1)yesceil(arg1)cos(arg1)yescos(arg1)cot(arg1)yescot(arg1)degrees(arg1)yesdegrees(arg1)exp(arg1)yesexp(arg1)floor(arg1)yesfloor(arg1)log(arg1)yesln(arg1)log10(arg1)yeslog(arg1)mod(arg1,arg2)yesmod(arg1,arg2)pi(arg1)yespi(arg1)power(arg1,arg2)yespow(arg1,arg2)radians(arg1)yesradians(arg1)rand()yesrandom()rand(arg1)yessetseed(arg1)*0+random()The seed is initialized with the given argument and a new randow value is returned.round(arg1,arg2)yesround(arg1,arg2)sign(arg1)yessign(arg1)sin(arg1)yessin(arg1)sqrt(arg1)yessqrt(arg1)tan(arg1)yestan(arg1)truncate(arg1,arg2)yestrunc(arg1,arg2)
Supported escaped string functionsfunctionreported as supportedtranslationcommentsascii(arg1)yesascii(arg1)char(arg1)yeschr(arg1)concat(arg1,arg2...)yes(arg1||arg2...)The JDBC specification only require the two arguments version, but supporting more arguments was so easy...insert(arg1,arg2,arg3,arg4)nooverlay(arg1 placing arg4 from arg2 for arg3)This function is not reported as supported since it changes the order of the arguments which can be a problem (for prepared statements by example).lcase(arg1)yeslower(arg1)left(arg1,arg2)yessubstring(arg1 for arg2)length(arg1)yeslength(trim(trailing from arg1))locate(arg1,arg2)noposition(arg1 in arg2)locate(arg1,arg2,arg3)no(arg2*sign(position(arg1 in substring(arg2 from arg3)+position(arg1 in substring(arg2 from arg3))Not reported as supported since the three arguments version duplicate and change the order of the arguments.ltrim(arg1)yestrim(leading from arg1)repeat(arg1,arg2)yesrepeat(arg1,arg2)replace(arg1,arg2,arg3)yesreplace(arg1,arg2,arg3)Only reported as supported by 7.3 and above servers.right(arg1,arg2)nosubstring(arg1 from (length(arg1)+1-arg2))Not reported as supported since arg2 is duplicated.rtrim(arg1)yestrim(trailing from arg1)space(arg1)yesrepeat(' ',arg1)substring(arg1,arg2)yessubstr(arg1,arg2)substring(arg1,arg2,arg3)yessubstr(arg1,arg2,arg3)ucase(arg1)yesupper(arg1)soundex(arg1)nosoundex(arg1)Not reported as supported since it requires the fuzzystrmatch contrib module.difference(arg1,arg2)nodifference(arg1,arg2)Not reported as supported since it requires the fuzzystrmatch contrib module.
Supported escaped date/time functionsfunctionreported as supportedtranslationcommentscurdate()yescurrent_datecurtime()yescurrent_timedayname(arg1)yesto_char(arg1,'Day')dayofmonth(arg1)yesextract(day from arg1)dayofweek(arg1)yesextract(dow from arg1)+1We must add 1 to be in the expected 1-7 range.dayofyear(arg1)yesextract(doy from arg1)hour(arg1)yesextract(hour from arg1)minute(arg1)yesextract(minute from arg1)month(arg1)yesextract(month from arg1)monthname(arg1)yesto_char(arg1,'Month')now()yesnow()quarter(arg1)yesextract(quarter from arg1)second(arg1)yesextract(second from arg1)week(arg1)yesextract(week from arg1)year(arg1)yesextract(year from arg1)timestampadd(argIntervalType,argCount,argTimeStamp)yes('(interval according to argIntervalType and argCount)'+argTimeStamp)an argIntervalType value of SQL_TSI_FRAC_SECOND is not implemented since backend does not support ittimestampdiff(argIntervalType,argTimeStamp1,argTimeStamp2)notextract((interval according to argIntervalType) from argTimeStamp2-argTimeStamp1 )only an argIntervalType value of SQL_TSI_FRAC_SECOND,SQL_TSI_FRAC_MINUTE,SQL_TSI_FRAC_HOUR or SQL_TSI_FRAC_DAY is supported
Supported escaped misc functionsfunctionreported as supportedtranslationcommentsdatabase()yescurrent_database()Only reported as supported by 7.3 and above servers.ifnull(arg1,arg2)yescoalesce(arg1,arg2)user()yesuser
<productname>PostgreSQL</productname> Extensions to the
<acronym>JDBC</acronym> <acronym>API</acronym>PostgreSQL is an extensible database
system. You can add your own functions to the server, which can
then be called from queries, or even add your own data types. As
these are facilities unique to PostgreSQL,
we support them from Java, with a set of extension
APIs. Some features within the core of the
standard driver actually use these extensions to implement Large
Objects, etc.
Accessing the Extensions
To access some of the extensions, you need to use some extra
methods in the org.postgresql.PGConnection
class. In this case, you would need to case the return value of
Driver.getConnection(). For example:
Connection db = Driver.getConnection(url, username, password);
// ...
// later on
Fastpath fp = ((org.postgresql.PGConnection)db).getFastpathAPI();
Geometric Data TypesPostgreSQL has a set of data types that
can store geometric features into a table. These include single
points, lines, and polygons. We support these types in Java with
the org.postgresql.geometric package. Please consult the Javadoc
for the details of available classes and features metioned in
.
Using the circle datatype from <acronym>JDBC</acronym>
import java.sql.*;
import org.postgresql.geometric.PGpoint;
import org.postgresql.geometric.PGcircle;
public class GeometricTest {
public static void main(String args[]) throws Exception {
Class.forName("org.postgresql.Driver");
String url = "jdbc:postgresql://localhost:5432/test";
Connection conn = DriverManager.getConnection(url,"test","");
Statement stmt = conn.createStatement();
stmt.execute("CREATE TEMP TABLE geomtest(mycirc circle)");
stmt.close();
insertCircle(conn);
retrieveCircle(conn);
conn.close();
}
private static void insertCircle(Connection conn) throws SQLException {
PGpoint center = new PGpoint(1, 2.5);
double radius = 4;
PGcircle circle = new PGcircle(center, radius);
PreparedStatement ps = conn.prepareStatement("INSERT INTO geomtest(mycirc) VALUES (?)");
ps.setObject(1, circle);
ps.executeUpdate();
ps.close();
}
private static void retrieveCircle(Connection conn) throws SQLException {
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT mycirc, area(mycirc) FROM geomtest");
rs.next();
PGcircle circle = (PGcircle)rs.getObject(1);
double area = rs.getDouble(2);
PGpoint center = circle.center;
double radius = circle.radius;
System.out.println("Center (X, Y) = (" + center.x + ", " + center.y + ")");
System.out.println("Radius = " + radius);
System.out.println("Area = " + area);
}
}
Large Objects
Large objects are supported in the standard
JDBC specification. However, that interface is
limited, and the API provided by PostgreSQL allows for random
access to the objects contents, as if it was a local file.
The org.postgresql.largeobject package provides to Java the libpq
C interface's large object API. It consists of
two classes, LargeObjectManager, which deals with creating,
opening and deleting large objects, and LargeObject which deals
with an individual object. For an example usage of this API,
please see .
Listen / Notify
Listen and Notify provide a simple form of signal or interprocess
communication mechanism for a collection of processes accessing
the same PostgreSQL database. For more
information on notifications consult the main server documentation.
This section only deals with the JDBC specific
aspects of notifications.
Standard LISTEN, NOTIFY, and
UNLISTEN commands are issued via the
standard Statement interface. To retrieve
and process retrieved notifications the
Connection must be cast to the
PostgreSQL specific extension interface
PGConnection. From there the
getNotifications() method can be used to retrieve
any outstanding notifications.
A key limitation of the JDBC driver is that it
cannot receive asynchronous notifications and must poll the
backend to check if any notifications were issued.
Receiving Notifications
import java.sql.*;
public class NotificationTest {
public static void main(String args[]) throws Exception {
Class.forName("org.postgresql.Driver");
String url = "jdbc:postgresql://localhost:5432/test";
// Create two distinct connections, one for the notifier
// and another for the listener to show the communication
// works across connections although this example would
// work fine with just one connection.
Connection lConn = DriverManager.getConnection(url,"test","");
Connection nConn = DriverManager.getConnection(url,"test","");
// Create two threads, one to issue notifications and
// the other to receive them.
Listener listener = new Listener(lConn);
Notifier notifier = new Notifier(nConn);
listener.start();
notifier.start();
}
}
class Listener extends Thread {
private Connection conn;
private org.postgresql.PGConnection pgconn;
Listener(Connection conn) throws SQLException {
this.conn = conn;
this.pgconn = (org.postgresql.PGConnection)conn;
Statement stmt = conn.createStatement();
stmt.execute("LISTEN mymessage");
stmt.close();
}
public void run() {
while (true) {
try {
// issue a dummy query to contact the backend
// and receive any pending notifications.
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT 1");
rs.close();
stmt.close();
org.postgresql.PGNotification notifications[] = pgconn.getNotifications();
if (notifications != null) {
for (int i=0; i<notifications.length; i++) {
System.out.println("Got notification: " + notifications[i].getName());
}
}
// wait a while before checking again for new
// notifications
Thread.sleep(500);
} catch (SQLException sqle) {
sqle.printStackTrace();
} catch (InterruptedException ie) {
ie.printStackTrace();
}
}
}
}
class Notifier extends Thread {
private Connection conn;
public Notifier(Connection conn) {
this.conn = conn;
}
public void run() {
while (true) {
try {
Statement stmt = conn.createStatement();
stmt.execute("NOTIFY mymessage");
stmt.close();
Thread.sleep(2000);
} catch (SQLException sqle) {
sqle.printStackTrace();
} catch (InterruptedException ie) {
ie.printStackTrace();
}
}
}
}
Server Prepared Statements
The PostgreSQL server allows clients
to compile sql statements that are expected to be reused to avoid the
overhead of parsing and planning the statement for every execution.
This functionality is available at the SQL level
via PREPARE and EXECUTE beginning with server version 7.3, and at the
protocol level beginning with server version 7.4, but as Java
developers we really just want to use the standard
PreparedStatement interface.
Previous versions of the driver used PREPARE and EXECUTE to
implement server-prepared statements. This is supported on all server
versions beginning with 7.3, but produced application-visible changes
in query results, such as missing ResultSet metadata and row update
counts. The current driver uses the V3 protocol-level equivalents which
avoid these changes in query results, but the V3 protocol is only
available beginning with server version 7.4. Enabling server-prepared
statements will have no affect when connected to a 7.3 server or when
explicitly using the V2 protocol to connect to a 7.4 server.
There are a number of ways to enable server side prepared statements
depending on your application's needs. The general method is to
set a threshold for a PreparedStatement.
An internal counter keeps track of how many times the statement has
been executed and when it reaches the threshold it will start to
use server side prepared statements.
Server side prepared statements are planned only once by the server.
This avoids the cost of replanning the query every time, but also
means that the planner cannot take advantage of the particular
parameter values used in a particular execution of the query.
You should be cautious about enabling the use of server side prepared
statements globally.
Using server side prepared statements
import java.sql.*;
public class ServerSidePreparedStatement
{
public static void main(String args[]) throws Exception
{
Class.forName("org.postgresql.Driver");
String url = "jdbc:postgresql://localhost:5432/test";
Connection conn = DriverManager.getConnection(url,"test","");
PreparedStatement pstmt = conn.prepareStatement("SELECT ?");
// cast to the pg extension interface
org.postgresql.PGStatement pgstmt = (org.postgresql.PGStatement)pstmt;
// on the third execution start using server side statements
pgstmt.setPrepareThreshold(3);
for (int i=1; i<=5; i++)
{
pstmt.setInt(1,i);
boolean usingServerPrepare = pgstmt.isUseServerPrepare();
ResultSet rs = pstmt.executeQuery();
rs.next();
System.out.println("Execution: "+i+", Used server side: " + usingServerPrepare + ", Result: "+rs.getInt(1));
rs.close();
}
pstmt.close();
conn.close();
}
}
Which produces the expected result of using server side prepared statements upon the third execution.
Execution: 1, Used server side: false, Result: 1
Execution: 2, Used server side: false, Result: 2
Execution: 3, Used server side: true, Result: 3
Execution: 4, Used server side: true, Result: 4
Execution: 5, Used server side: true, Result: 5
The example shown above requires the programmer to use
PostgreSQL specific code in a
supposedly portable API which is not ideal. Also it sets the
threshold only for that particular statement which is some extra
typing if we wanted to use that threshold for every statement.
Let's take a look at the other ways to set the threshold to enable
server side prepared statements. There is already a hierarchy in
place above a PreparedStatement, the
Connection it was created from, and above that
the source of the connection be it a Datasource
or a URL. The server side prepared statement
threshold can be set at any of these levels such that the value
will be the default for all of it's children.
// pg extension interfaces
org.postgresql.PGConnection pgconn;
org.postgresql.PGStatement pgstmt;
// set a prepared statement threshold for connections created from this url
String url = "jdbc:postgresql://localhost:5432/test?prepareThreshold=3";
// see that the connection has picked up the correct threshold from the url
Connection conn = DriverManager.getConnection(url,"test","");
pgconn = (org.postgresql.PGConnection)conn;
System.out.println(pgconn.getPrepareThreshold()); // Should be 3
// see that the statement has picked up the correct threshold from the connection
PreparedStatement pstmt = conn.prepareStatement("SELECT ?");
pgstmt = (org.postgresql.PGStatement)pstmt;
System.out.println(pgstmt.getPrepareThreshold()); // Should be 3
// change the connection's threshold and ensure that new statements pick it up
pgconn.setPrepareThreshold(5);
PreparedStatement pstmt = conn.prepareStatement("SELECT ?");
pgstmt = (org.postgresql.PGStatement)pstmt;
System.out.println(pgstmt.getPrepareThreshold()); // Should be 5
Using the Driver in a Multithreaded or a Servlet Environmentthreadswith JDBC
A problem with many JDBC drivers is that only
one thread can use a Connection at any one
time --- otherwise a thread could send a query while another one is
receiving results, and this could cause severe confusion.
The PostgreSQL JDBC driver
is thread safe.
Consequently, if your application uses multiple threads then you do
not have to worry about complex algorithms to ensure that only one thread
uses the database at a time.
If a thread attempts to use the connection while another one is
using it, it will wait until the other thread has finished its
current operation. If the operation is a regular SQL
statement, then the operation consists of sending the statement and
retrieving any ResultSet (in full). If it
is a fast-path call (e.g., reading a block
from a large object) then it consists of
sending and retrieving the respective data.
This is fine for applications and applets but can cause a
performance problem with servlets. If you have several threads
performing queries then each but one will pause.
To solve this, you are advised to create a pool of connections.
When ever a thread needs to use the database, it asks a manager
class for a Connection object. The manager
hands a free connection to the thread and marks it as busy. If a
free connection is not available, it opens one. Once the thread
has finished using the connection, it returns it to the manager
which can then either close it or add it to the pool. The manager
would also check that the connection is still alive and remove it
from the pool if it is dead. The down side of a connection pool is
that it increases the load on the server because a new session is
created for each Connection object. It is
up to you and your applications' requirements.
Connection Pools and Data Sourcesconnection poolin JDBCDataSource
JDBC 2 introduced standard connection pooling features in an
add-on API known as the JDBC 2.0 Optional
Package (also known as the JDBC 2.0
Standard Extension). These features have since been included in
the core JDBC 3 API.
Overview
The JDBC API provides a client
and a server interface for connection pooling. The client
interface is javax.sql.DataSource,
which is what application code will typically use to
acquire a pooled database connection. The server interface
is javax.sql.ConnectionPoolDataSource,
which is how most application servers will interface with
the PostgreSQL JDBC
driver.
In an application server environment, the
application server configuration will typically refer to
the PostgreSQLConnectionPoolDataSource implementation,
while the application component code will typically acquire a
DataSource implementation provided by
the application server (not by
PostgreSQL).
For an environment without an application server,
PostgreSQL provides two implementations
of DataSource which an application can use
directly. One implementation performs connection pooling,
while the other simply provides access to database connections
through the DataSource interface without
any pooling. Again, these implementations should not be used
in an application server environment unless the application
server does not support the
ConnectionPoolDataSource interface.
Application Servers: <classname>ConnectionPoolDataSource</classname>PostgreSQL includes one implementation
of ConnectionPoolDataSource named
org.postgresql.ds.PGConnectionPoolDataSource.
JDBC requires that a
ConnectionPoolDataSource be configured via
JavaBean properties, shown in ,
so there are get and set methods for each of these properties.
<classname>ConnectionPoolDataSource</classname> Configuration PropertiesPropertyTypeDescriptionserverNameStringPostgreSQL database server
host namedatabaseNameStringPostgreSQL database nameportNumberint
TCP port which the PostgreSQL
database server is listening on (or 0 to use the default port)
userStringUser used to make database connectionspasswordStringPassword used to make database connectionssslboolean
If true, use SSL encrypted connections
(default false)
sslfactoryString
Custom javax.net.ssl.SSLSocketFactory
class name (see )
defaultAutoCommitboolean
Whether connections should have autocommit enabled or disabled
when they are supplied to the caller. The default is
false, to disable autocommit.
Many application servers use a properties-style syntax to
configure these properties, so it would not be unusual to enter
properties as a block of text. If the application server provides
a single area to enter all the properties, they might be listed
like this:
serverName=localhost
databaseName=test
user=testuser
password=testpassword
Or, if semicolons are used as separators instead of newlines, it
could look like this:
serverName=localhost;databaseName=test;user=testuser;password=testpassword
Applications: <classname>DataSource</classname>PostgreSQL includes two
implementations of DataSource
, as shown in . One that does
pooling and the other that does not.
The pooling implementation does not actually close connections
when the client calls the close method, but
instead returns the connections to a pool of available connections
for other clients to use. This avoids any overhead of repeatedly
opening and closing connections, and allows a large number of
clients to share a small number of database connections.The pooling data-source implementation provided here is not
the most feature-rich in the world. Among other things,
connections are never closed until the pool itself is closed;
there is no way to shrink the pool. As well, connections
requested for users other than the default configured user are
not pooled. Its error handling sometimes cannot remove a broken
connection from the pool. In general it is not recommended to
use the PostgreSQL provided connection
pool. Check your application server or check out the excellent
jakarta commons DBCP project.
Both implementations use the same configuration scheme.
JDBC requires that a
DataSource be configured via JavaBean
properties, shown in , so there
are get and set methods for each of these properties.
<classname>DataSource</classname> Configuration PropertiesPropertyTypeDescriptionserverNameStringPostgreSQL database server
host namedatabaseNameStringPostgreSQL database nameportNumberintTCP port which the
PostgreSQL database server is
listening on (or 0 to use the default port)userStringUser used to make database connectionspasswordStringPassword used to make database connectionssslboolean
If true, use SSL encrypted connections
(default false)
sslfactoryString
Custom javax.net.ssl.SSLSocketFactory
class name (see )
The pooling implementation requires some additional
configuration properties, which are shown in .
Additional Pooling <classname>DataSource</classname> Configuration PropertiesPropertyTypeDescriptiondataSourceNameStringEvery pooling DataSource must have a
unique name.initialConnectionsintThe number of database connections to be created
when the pool is initialized.maxConnectionsintThe maximum number of open database connections to
allow. When more connections are requested, the caller
will hang until a connection is returned to the pool.
shows an example of typical application code using a
pooling DataSource.<literal>DataSource</literal> Code Example
Code to initialize a pooling DataSource might look like this:
PGPoolingDataSource source = new PGPoolingDataSource();
source.setDataSourceName("A Data Source");
source.setServerName("localhost");
source.setDatabaseName("test");
source.setUser("testuser");
source.setPassword("testpassword");
source.setMaxConnections(10);
Then code to use a connection from the pool might look
like this. Note that it is critical that the connections
are eventually closed. Else the pool will leak connections and
will eventually lock all the clients out.
Connection conn = null;
try {
conn = source.getConnection();
// use connection
} catch (SQLException e) {
// log error
} finally {
if (con != null) {
try { conn.close(); } catch (SQLException e) {}
}
}
Tomcat setuptomcat
The postgresql.jar file must be placed in $CATALINA_HOME/common/lib
in both Tomcat 4 and 5.
The absolute easiest way to set this up in either tomcat instance
is to use the admin web application that comes with Tomcat, simply
add the datasource to the context you want to use it in.
Setup for Tomcat 4 place the following inside the <Context> tag
inside conf/server.xml
validationQueryselect version();urljdbc:postgresql://localhost/davecpassworddavecmaxActive4maxWait5000driverClassNameorg.postgresql.DriverusernamedavecmaxIdle2]]>
Setup for Tomcat 5, you can use the above method, except that it
goes inside the <DefaultContext> tag inside the <Host>
tag. eg. <Host> ... <DefaultContext> ...
Alternatively there is a conf/Catalina/hostname/context.xml file.
For example http://localhost:8080/servlet-example has a directory
$CATALINA_HOME/conf/Catalina/localhost/servlet-example.xml file.
Inside this file place the above xml inside the <Context> tag
Then you can use the following code to access the connection.
import javax.naming.*;
import javax.sql.*;
import java.sql.*;
public class DBTest
{
String foo = "Not Connected";
int bar = -1;
public void init()
{
try
{
Context ctx = new InitialContext();
if(ctx == null )
throw new Exception("Boom - No Context");
// /jdbc/postgres is the name of the resource above
DataSource ds = (DataSource)ctx.lookup("java:comp/env/jdbc/postgres");
if (ds != null)
{
Connection conn = ds.getConnection();
if(conn != null)
{
foo = "Got Connection "+conn.toString();
Statement stmt = conn.createStatement();
ResultSet rst = stmt.executeQuery("select id, foo, bar from testdata");
if(rst.next()) {
foo=rst.getString(2);
bar=rst.getInt(3);
}
conn.close();
}
}
}
catch(Exception e)
{
e.printStackTrace();
}
}
public String getFoo() { return foo; }
public int getBar() { return bar;}
}
Data Sources and <acronym>JNDI</acronym>JNDI
All the ConnectionPoolDataSource and
DataSource implementations can be stored
in JNDI. In the case of the nonpooling
implementations, a new instance will be created every time the
object is retrieved from JNDI, with the
same settings as the instance that was stored. For the
pooling implementations, the same instance will be retrieved
as long as it is available (e.g., not a different
JVM retrieving the pool from
JNDI), or a new instance with the same
settings created otherwise.
In the application server environment, typically the
application server's DataSource instance
will be stored in JNDI, instead of the
PostgreSQLConnectionPoolDataSource implementation.
In an application environment, the application may store
the DataSource in JNDI
so that it doesn't have to make a reference to the
DataSource available to all application
components that may need to use it. An example of this is
shown in .
<classname>DataSource</classname> <acronym>JNDI</acronym> Code Example
Application code to initialize a pooling DataSource and add
it to JNDI might look like this:
PGPoolingDataSource source = new PGPoolingDataSource();
source.setDataSourceName("A Data Source");
source.setServerName("localhost");
source.setDatabaseName("test");
source.setUser("testuser");
source.setPassword("testpassword");
source.setMaxConnections(10);
new InitialContext().rebind("DataSource", source);
Then code to use a connection from the pool might look
like this:
Connection conn = null;
try {
DataSource source = (DataSource)new InitialContext().lookup("DataSource");
conn = source.getConnection();
// use connection
} catch (SQLException e) {
// log error
} catch (NamingException e) {
// DataSource wasn't found in JNDI
} finally {
if (con != null) {
try { conn.close(); } catch (SQLException e) {}
}
}
Further Reading
If you have not yet read it, you are advised you read the
JDBC API Documentation
(supplied with Oracle's JDK) and the
JDBC Specification. Both are available from
.
contains updated information not included in this manual including
Javadoc class documentation and a FAQ. Additionally it
offers precompiled drivers.
postgresql-jdbc-9.2-1002.src/org/ 0000775 0000000 0000000 00000000000 12050675701 0016427 5 ustar 00root root 0000000 0000000 postgresql-jdbc-9.2-1002.src/org/postgresql/ 0000775 0000000 0000000 00000000000 12050675701 0020632 5 ustar 00root root 0000000 0000000 postgresql-jdbc-9.2-1002.src/org/postgresql/.gitignore 0000664 0000000 0000000 00000000014 12050675701 0022615 0 ustar 00root root 0000000 0000000 Driver.java
postgresql-jdbc-9.2-1002.src/org/postgresql/Driver.java.in 0000664 0000000 0000000 00000072637 12050675701 0023354 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2003-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql;
import java.io.*;
import java.sql.*;
import java.util.*;
import java.net.URL;
import java.security.AccessController;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;
import org.postgresql.util.PSQLException;
import org.postgresql.util.PSQLState;
import org.postgresql.util.PSQLDriverVersion;
import org.postgresql.util.GT;
import org.postgresql.util.HostSpec;
import org.postgresql.core.Logger;
/**
* The Java SQL framework allows for multiple database drivers. Each
* driver should supply a class that implements the Driver interface
*
*
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
{
// make these public so they can be used in setLogLevel below
public static final int DEBUG = 2;
public static final int INFO = 1;
private static final Logger logger = new Logger();
private static boolean logLevelSet = false;
private static Timer cancelTimer=null;
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.
java.sql.DriverManager.registerDriver(new Driver());
}
catch (SQLException e)
{
e.printStackTrace();
}
}
// Helper to retrieve default properties from classloader resource
// properties files.
private Properties defaultProperties;
private synchronized Properties getDefaultProperties() throws IOException {
if (defaultProperties != null)
return defaultProperties;
// Make sure we load properties with the maximum possible
// privileges.
try
{
defaultProperties = (Properties)
AccessController.doPrivileged(new PrivilegedExceptionAction() {
public Object run() throws IOException {
return loadDefaultProperties();
}
});
}
catch (PrivilegedActionException e)
{
throw (IOException)e.getException();
}
// Use the loglevel from the default properties (if any)
// as the driver-wide default unless someone explicitly called
// setLogLevel() already.
synchronized (Driver.class) {
if (!logLevelSet) {
String driverLogLevel = defaultProperties.getProperty("loglevel");
if (driverLogLevel != null) {
try {
setLogLevel(Integer.parseInt(driverLogLevel));
} catch (Exception l_e) {
// XXX revisit
// invalid value for loglevel; ignore it
}
}
}
}
return defaultProperties;
}
private Properties loadDefaultProperties() throws IOException {
Properties merged = new Properties();
try {
merged.setProperty("user", System.getProperty("user.name"));
} catch (java.lang.SecurityException se) {
// We're just trying to set a default, so if we can't
// it's not a big deal.
}
// If we are loaded by the bootstrap classloader, getClassLoader()
// may return null. In that case, try to fall back to the system
// classloader.
//
// We should not need to catch SecurityException here as we are
// accessing either our own classloader, or the system classloader
// when our classloader is null. The ClassLoader javadoc claims
// neither case can throw SecurityException.
ClassLoader cl = getClass().getClassLoader();
if (cl == null)
cl = ClassLoader.getSystemClassLoader();
if (cl == null) {
logger.debug("Can't find a classloader for the Driver; not loading driver configuration");
return merged; // Give up on finding defaults.
}
logger.debug("Loading driver configuration via classloader " + cl);
// When loading the driver config files we don't want settings found
// in later files in the classpath to override settings specified in
// earlier files. To do this we've got to read the returned
// Enumeration into temporary storage.
ArrayList urls = new ArrayList();
Enumeration urlEnum = cl.getResources("org/postgresql/driverconfig.properties");
while (urlEnum.hasMoreElements())
{
urls.add(urlEnum.nextElement());
}
for (int i=urls.size()-1; i>=0; i--) {
URL url = (URL)urls.get(i);
logger.debug("Loading driver configuration from: " + url);
InputStream is = url.openStream();
merged.load(is);
is.close();
}
return merged;
}
/**
* Try to make a database connection to the given URL. The driver
* should return "null" if it realizes it is the wrong kind of
* driver to connect to the given URL. This will be common, as
* when the JDBC driverManager is asked to connect to a given URL,
* it passes the URL to each loaded driver in turn.
*
*
The 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.
*
* user - (required) The user to connect as
* password - (optional) The password for the user
* ssl - (optional) Use SSL when connecting to the server
* charSet - (optional) The character set to be used for converting
* to/from the database to unicode. If multibyte is enabled on the
* server then the character set of the database is used as the default,
* otherwise the jvm character encoding is used as the default.
* This value is only used when connecting to a 7.2 or older server.
* loglevel - (optional) Enable logging of messages from the driver.
* The value is an integer from 1 to 2 where:
* INFO = 1, DEBUG = 2
* The output is sent to DriverManager.getPrintWriter() if set,
* otherwise it is sent to System.out.
* compatible - (optional) This is used to toggle
* between different functionality as it changes across different releases
* of the jdbc driver code. The values here are versions of the jdbc
* client and not server versions. For example in 7.1 get/setBytes
* worked on LargeObject values, in 7.2 these methods were changed
* to work on bytea values. This change in functionality could
* be disabled by setting the compatible level to be "7.1", in
* which case the driver will revert to the 7.1 functionality.
*
*
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 "-E " argument
* to createdb.
*
* Our protocol takes the forms:
*
*
* @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
* @see java.sql.Driver#connect
*/
public java.sql.Connection connect(String url, Properties info) throws SQLException
{
// get defaults
Properties defaults;
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);
for (Enumeration e = info.propertyNames(); e.hasMoreElements(); )
{
String propName = (String)e.nextElement();
props.setProperty(propName, info.getProperty(propName));
}
// parse URL and add more properties
if ((props = parseURL(url, props)) == null)
{
logger.debug("Error in url: " + url);
return null;
}
try
{
logger.debug("Connecting with URL: " + url);
// Enforce login timeout, if specified, by running the connection
// attempt in a separate thread. If we hit the timeout without the
// connection completing, we abandon the connection attempt in
// the calling thread, but the separate thread will keep trying.
// Eventually, the separate thread will either fail or complete
// the connection; at that point we clean up the connection if
// we managed to establish one after all. See ConnectThread for
// more details.
long timeout = timeout(props);
if (timeout <= 0)
return makeConnection(url, props);
ConnectThread ct = new ConnectThread(url, props);
new Thread(ct, "PostgreSQL JDBC driver connection thread").start();
return ct.getResult(timeout);
}
catch (PSQLException ex1)
{
logger.debug("Connection error:", ex1);
// re-throw the exception, otherwise it will be caught next, and a
// org.postgresql.unusual error will be returned instead.
throw ex1;
}
catch (java.security.AccessControlException ace)
{
throw new PSQLException(GT.tr("Your security policy has prevented the connection from being attempted. You probably need to grant the connect java.net.SocketPermission to the database server host and port that you wish to connect to."), PSQLState.UNEXPECTED_ERROR, ace);
}
catch (Exception ex2)
{
logger.debug("Unexpected connection error:", ex2);
throw new PSQLException(GT.tr("Something unusual has occured to cause the driver to fail. Please report this exception."),
PSQLState.UNEXPECTED_ERROR, ex2);
}
}
/**
* Perform a connect in a separate thread; supports
* getting the results from the original thread while enforcing
* a login timout.
*/
private static class ConnectThread implements Runnable {
ConnectThread(String url, Properties props) {
this.url = url;
this.props = props;
}
public void run() {
Connection conn;
Throwable error;
try {
conn = makeConnection(url, props);
error = null;
} catch (Throwable t) {
conn = null;
error = t;
}
synchronized (this) {
if (abandoned) {
if (conn != null) {
try {
conn.close();
} catch (SQLException e) {}
}
} else {
result = conn;
resultException = error;
notify();
}
}
}
/**
* Get the connection result from this (assumed running) thread.
* If the timeout is reached without a result being available,
* a SQLException is thrown.
*
* @param timeout timeout in milliseconds
* @return the new connection, if successful
* @throws SQLException if a connection error occurs or the timeout is reached
*/
public Connection getResult(long timeout) throws SQLException {
long expiry = System.currentTimeMillis() + timeout;
synchronized (this) {
while (true) {
if (result != null)
return result;
if (resultException != null) {
if (resultException instanceof SQLException) {
resultException.fillInStackTrace();
throw (SQLException)resultException;
} else {
throw new PSQLException(GT.tr("Something unusual has occured to cause the driver to fail. Please report this exception."),
PSQLState.UNEXPECTED_ERROR, resultException);
}
}
long delay = expiry - System.currentTimeMillis();
if (delay <= 0) {
abandoned = true;
throw new PSQLException(GT.tr("Connection attempt timed out."),
PSQLState.CONNECTION_UNABLE_TO_CONNECT);
}
try {
wait(delay);
} catch (InterruptedException ie) {
abandoned = true;
throw new PSQLException(GT.tr("Interrupted while attempting to connect."),
PSQLState.CONNECTION_UNABLE_TO_CONNECT);
}
}
}
}
private final String url;
private final Properties props;
private Connection result;
private Throwable resultException;
private boolean abandoned;
}
/**
* Create a connection from URL and properties. Always
* does the connection work in the current thread without
* enforcing a timeout, regardless of any timeout specified
* in the properties.
*
* @param url the original URL
* @param props the parsed/defaulted connection properties
* @return a new connection
* @throws SQLException if the connection could not be made
*/
private static Connection makeConnection(String url, Properties props) throws SQLException {
return new @JDBCCONNECTCLASS@(hostSpecs(props),
user(props), database(props),
props, url);
}
/**
* Returns true if the driver thinks it can open a connection to the
* given URL. Typically, drivers will return true if they understand
* the subprotocol specified in the URL and false if they don't. Our
* protocols start with jdbc:postgresql:
*
* @see java.sql.Driver#acceptsURL
* @param url the URL of the driver
* @return true if this driver accepts the given URL
* @exception SQLException if a database-access error occurs
* (Dont know why it would *shrug*)
*/
public boolean acceptsURL(String url) throws SQLException
{
if (parseURL(url, null) == null)
return false;
return true;
}
private static final Object[][] knownProperties = {
{ "PGDBNAME", Boolean.TRUE,
"Database name to connect to; may be specified directly in the JDBC URL." },
{ "user", Boolean.TRUE,
"Username to connect to the database as.", null },
{ "PGHOST", Boolean.FALSE,
"Hostname of the PostgreSQL server; may be specified directly in the JDBC URL." },
{ "PGPORT", Boolean.FALSE,
"Port number to connect to the PostgreSQL server on; may be specified directly in the JDBC URL.", },
{ "password", Boolean.FALSE,
"Password to use when authenticating.", },
{ "protocolVersion", Boolean.FALSE,
"Force use of a particular protocol version when connecting; if set, disables protocol version fallback.", },
{ "ssl", Boolean.FALSE,
"Control use of SSL; any nonnull value causes SSL to be required." },
{ "sslfactory", Boolean.FALSE,
"Provide a SSLSocketFactory class when using SSL." },
{ "sslfactoryarg", Boolean.FALSE,
"Argument forwarded to constructor of SSLSocketFactory class." },
{ "loglevel", Boolean.FALSE,
"Control the driver's log verbosity: 0 is off, 1 is INFO, 2 is DEBUG.",
new String[] { "0", "1", "2" } },
{ "allowEncodingChanges", Boolean.FALSE,
"Allow the user to change the client_encoding variable." },
{ "logUnclosedConnections", Boolean.FALSE,
"When connections that are not explicitly closed are garbage collected, log the stacktrace from the opening of the connection to trace the leak source."},
{ "prepareThreshold", Boolean.FALSE,
"Default statement prepare threshold (numeric)." },
{ "binaryTransfer", Boolean.FALSE,
"Use binary format for sending and receiving data if possible." },
{ "binaryTransferEnable", Boolean.FALSE,
"Comma separated list of types to enable binary transfer. Either OID numbers or names." },
{ "binaryTransferDisable", Boolean.FALSE,
"Comma separated list of types to disable binary transfer. Either OID numbers or names. Overrides values in the driver default set and values set with binaryTransferEnable." },
{ "charSet", Boolean.FALSE,
"When connecting to a pre-7.3 server, the database encoding to assume is in use." },
{ "compatible", Boolean.FALSE,
"Force compatibility of some features with an older version of the driver.",
new String[] { "7.1", "7.2", "7.3", "7.4", "8.0", "8.1", "8.2" } },
{ "loginTimeout", Boolean.FALSE,
"The login timeout, in seconds; 0 means no timeout beyond the normal TCP connection timout." },
{ "socketTimeout", Boolean.FALSE,
"The timeout value for socket read operations, in seconds; 0 means no timeout." },
{ "tcpKeepAlive", Boolean.FALSE,
"Enable or disable TCP keep-alive probe." },
{ "stringtype", Boolean.FALSE,
"The type to bind String parameters as (usually 'varchar'; 'unspecified' allows implicit casting to other types)",
new String[] { "varchar", "unspecified" } },
{ "kerberosServerName", Boolean.FALSE,
"The Kerberos service name to use when authenticating with GSSAPI. This is equivalent to libpq's PGKRBSRVNAME environment variable." },
{ "jaasApplicationName", Boolean.FALSE,
"Specifies the name of the JAAS system or application login configuration." }
};
/**
* The getPropertyInfo method is intended to allow a generic GUI
* tool to discover what properties it should prompt a human for
* in order to get enough information to connect to a database.
*
*
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
* @exception SQLException if a database-access error occurs
* @see java.sql.Driver#getPropertyInfo
*/
public DriverPropertyInfo[] getPropertyInfo(String url, Properties info) throws SQLException
{
Properties copy = new Properties(info);
parseURL(url, copy);
DriverPropertyInfo[] props = new DriverPropertyInfo[knownProperties.length];
for (int i = 0; i < knownProperties.length; ++i)
{
String name = (String) knownProperties[i][0];
props[i] = new DriverPropertyInfo(name, copy.getProperty(name));
props[i].required = ((Boolean) knownProperties[i][1]).booleanValue();
props[i].description = (String) knownProperties[i][2];
if (knownProperties[i].length > 3)
props[i].choices = (String[]) knownProperties[i][3];
}
return props;
}
public static final int MAJORVERSION = @MAJORVERSION@;
/**
* Gets the drivers major version number
*
* @return the drivers major version number
*/
public int getMajorVersion()
{
return MAJORVERSION;
}
public static final int MINORVERSION = @MINORVERSION@;
/**
* Get the drivers minor version number
*
* @return the drivers minor version number
*/
public int getMinorVersion()
{
return MINORVERSION;
}
/**
* Returns the server version series of this driver and the
* specific build number.
*/
public static String getVersion()
{
return "@VERSION@ (build " + PSQLDriverVersion.buildNumber + ")";
}
/**
* 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).
*/
public boolean jdbcCompliant()
{
return false;
}
static private String[] protocols = { "jdbc", "postgresql" };
/**
* 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
* @exception SQLException
*/
Properties parseURL(String url, Properties defaults) throws SQLException
{
Properties urlProps = new Properties(defaults);
String l_urlServer = url;
String l_urlArgs = "";
int l_qPos = url.indexOf('?');
if (l_qPos != -1)
{
l_urlServer = url.substring(0, l_qPos);
l_urlArgs = url.substring(l_qPos + 1);
}
if (!l_urlServer.startsWith("jdbc:postgresql:")) {
return null;
}
l_urlServer = l_urlServer.substring("jdbc:postgresql:".length());
if (l_urlServer.startsWith("//")) {
l_urlServer = l_urlServer.substring(2);
int slash = l_urlServer.indexOf('/');
if (slash == -1) {
return null;
}
urlProps.setProperty("PGDBNAME", l_urlServer.substring(slash + 1));
String[] addresses = l_urlServer.substring(0, slash).split(",");
StringBuffer hosts = new StringBuffer();
StringBuffer ports = new StringBuffer();
for (int addr = 0; addr < addresses.length; ++addr) {
String address = addresses[addr];
int portIdx = address.lastIndexOf(':');
if (portIdx != -1 && address.lastIndexOf(']') < portIdx) {
String portStr = address.substring(portIdx + 1);
try {
Integer.parseInt(portStr);
} catch (NumberFormatException ex) {
return null;
}
ports.append(portStr);
hosts.append(address.subSequence(0, portIdx));
} else {
ports.append("@DEF_PGPORT@");
hosts.append(address);
}
ports.append(',');
hosts.append(',');
}
ports.setLength(ports.length() - 1);
hosts.setLength(hosts.length() - 1);
urlProps.setProperty("PGPORT", ports.toString());
urlProps.setProperty("PGHOST", hosts.toString());
} else {
urlProps.setProperty("PGPORT", "@DEF_PGPORT@");
urlProps.setProperty("PGHOST", "localhost");
urlProps.setProperty("PGDBNAME", l_urlServer);
}
//parse the args part of the url
String[] args = l_urlArgs.split("&");
for (int i = 0; i < args.length; ++i)
{
String token = args[i];
if (token.length() == 0) {
continue;
}
int l_pos = token.indexOf('=');
if (l_pos == -1)
{
urlProps.setProperty(token, "");
}
else
{
urlProps.setProperty(token.substring(0, l_pos), token.substring(l_pos + 1));
}
}
return urlProps;
}
/**
* @return the address portion of the URL
*/
private static HostSpec[] hostSpecs(Properties props)
{
String[] hosts = props.getProperty("PGHOST").split(",");
String[] ports = props.getProperty("PGPORT").split(",");
HostSpec[] hostSpecs = new HostSpec[hosts.length];
for (int i = 0; i < hostSpecs.length; ++i) {
hostSpecs[i] = new HostSpec(hosts[i], Integer.parseInt(ports[i]));
}
return hostSpecs;
}
/**
* @return the username of the URL
*/
private static String user(Properties props)
{
return props.getProperty("user", "");
}
/**
* @return the database name of the URL
*/
private static String database(Properties props)
{
return props.getProperty("PGDBNAME", "");
}
/**
* @return the timeout from the URL, in milliseconds
*/
private static long timeout(Properties props)
{
String timeout = props.getProperty("loginTimeout");
if (timeout != null) {
try {
return (long) (Float.parseFloat(timeout) * 1000);
} catch (NumberFormatException e) {
// Log level isn't set yet, so this doesn't actually
// get printed.
logger.debug("Couldn't parse loginTimeout value: " + timeout);
}
}
return 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 strace
* @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 unimplemeted function
*/
public static @NOTIMPLEMENTEDEXCEPTION@ notImplemented(Class callClass, String functionName)
{
return new @NOTIMPLEMENTEDEXCEPTION@(GT.tr("Method {0} is not yet implemented.", callClass.getName() + "." + functionName),
PSQLState.NOT_IMPLEMENTED.getState());
}
/**
* used to turn logging on to a certain level, can be called
* by specifying fully qualified class ie org.postgresql.Driver.setLogLevel()
* @param logLevel sets the level which logging will respond to
* INFO being almost no messages
* DEBUG most verbose
*/
public static void setLogLevel(int logLevel)
{
synchronized (Driver.class) {
logger.setLogLevel(logLevel);
logLevelSet = true;
}
}
public static int getLogLevel()
{
synchronized (Driver.class) {
return logger.getLogLevel();
}
}
public java.util.logging.Logger getParentLogger() throws @NOTIMPLEMENTEDEXCEPTION@
{
throw notImplemented(this.getClass(), "getParentLogger()");
}
public synchronized static void addTimerTask(TimerTask timerTask, long milliSeconds)
{
if ( cancelTimer == null )
{
cancelTimer = new Timer(true);
}
cancelTimer.schedule( timerTask, milliSeconds );
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/PGConnection.java 0000664 0000000 0000000 00000007001 12050675701 0024021 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2003-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql;
import java.sql.*;
import org.postgresql.copy.CopyManager;
import org.postgresql.fastpath.Fastpath;
import org.postgresql.largeobject.LargeObjectManager;
/**
* This interface defines the public PostgreSQL extensions to
* java.sql.Connection. All Connections returned by the PostgreSQL driver
* implement PGConnection.
*/
public interface PGConnection
{
/**
* This method returns any notifications that have been received
* since the last call to this method.
* Returns null if there have been no notifications.
* @since 7.3
*/
public PGNotification[] getNotifications() throws SQLException;
/**
* This returns the COPY API for the current connection.
* @since 8.4
*/
public CopyManager getCopyAPI() throws SQLException;
/**
* This returns the LargeObject API for the current connection.
* @since 7.3
*/
public LargeObjectManager getLargeObjectAPI() throws SQLException;
/**
* This returns the Fastpath API for the current connection.
* @since 7.3
*/
public 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)).
*
* @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.
* @throws RuntimeException if the type cannot be registered (class not
* found, etc).
*/
public void addDataType(String type, String name);
/**
* 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.
*
*
where myconn is an open Connection to org.postgresql.
*
*
The handling class must extend org.postgresql.util.PGobject
*
* @since 8.0
*
* @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 if klass does not implement
* {@link org.postgresql.util.PGobject}).
*
* @see org.postgresql.util.PGobject
*/
public 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.
*
* @since build 302
* @param threshold the new threshold
*/
public void setPrepareThreshold(int threshold);
/**
* Get the default server-side prepare reuse threshold for statements created
* from this connection.
*
* @since build 302
* @return the current threshold
*/
public int getPrepareThreshold();
}
postgresql-jdbc-9.2-1002.src/org/postgresql/PGNotification.java 0000664 0000000 0000000 00000001605 12050675701 0024354 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2003-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql;
/**
* This interface defines the public PostgreSQL extension for Notifications
*/
public interface PGNotification
{
/**
* Returns name of this notification
* @since 7.3
*/
public String getName();
/**
* Returns the process id of the backend process making this notification
* @since 7.3
*/
public int getPID();
/**
* Returns additional information from the notifying process.
* This feature has only been implemented in server versions 9.0
* and later, so previous versions will always return an empty String.
*
* @since 8.0
*/
public String getParameter();
}
postgresql-jdbc-9.2-1002.src/org/postgresql/PGRefCursorResultSet.java 0000664 0000000 0000000 00000001404 12050675701 0025510 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2003-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql;
/**
* A ref cursor based result set.
*
* @deprecated As of 8.0, this interface is only present for backwards-
* compatibility purposes. New code should call getString() on the ResultSet
* that contains the refcursor to obtain the underlying cursor name.
*/
public interface PGRefCursorResultSet
{
/** @return the name of the cursor.
* @deprecated As of 8.0, replaced with calling getString() on
* the ResultSet that this ResultSet was obtained from.
*/
public String getRefCursor ();
}
postgresql-jdbc-9.2-1002.src/org/postgresql/PGResultSetMetaData.java 0000664 0000000 0000000 00000001714 12050675701 0025262 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2003-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql;
import java.sql.SQLException;
public interface PGResultSetMetaData
{
/**
* Returns the underlying column name of a query result, or ""
* if it is unable to be determined.
*
* @since 8.0
*/
public String getBaseColumnName(int column) throws SQLException;
/**
* Returns the underlying table name of query result, or ""
* if it is unable to be determined.
*
* @since 8.0
*/
public String getBaseTableName(int column) throws SQLException;
/**
* Returns the underlying table name of query result, or ""
* if it is unable to be determined.
*
* @since 8.0
*/
public String getBaseSchemaName(int column) throws SQLException;
}
postgresql-jdbc-9.2-1002.src/org/postgresql/PGStatement.java 0000664 0000000 0000000 00000006124 12050675701 0023673 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2003-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql;
import java.sql.*;
/**
* This interface defines the public PostgreSQL extensions to
* java.sql.Statement. All Statements constructed by the PostgreSQL
* driver implement PGStatement.
*/
public interface PGStatement
{
// We can't use Long.MAX_VALUE or Long.MIN_VALUE for java.sql.date
// because this would break the 'normalization contract' of the
// java.sql.Date API.
// The follow values are the nearest MAX/MIN values with hour,
// minute, second, millisecond set to 0 - this is used for
// -infinity / infinity representation in Java
public static final long DATE_POSITIVE_INFINITY = 9223372036825200000l;
public static final long DATE_NEGATIVE_INFINITY = -9223372036832400000l;
public static final long DATE_POSITIVE_SMALLER_INFINITY = 185543533774800000l;
public static final long DATE_NEGATIVE_SMALLER_INFINITY = -185543533774800000l;
/**
* Returns the Last inserted/updated oid.
* @return OID of last insert
* @since 7.3
*/
public long getLastOID() throws SQLException;
/**
* Turn on the use of prepared statements in the server (server side
* prepared statements are unrelated to jdbc PreparedStatements)
* As of build 302, this method is equivalent to
* setPrepareThreshold(1).
*
* @deprecated As of build 302, replaced by {@link #setPrepareThreshold(int)}
* @since 7.3
*/
public 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
*/
public 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.
*
* @since build 302
* @param threshold the new threshold for this statement
* @throws SQLException if an exception occurs while changing the threshold
*/
public void setPrepareThreshold(int threshold) throws SQLException;
/**
* Gets the server-side prepare reuse threshold in use for this statement.
*
* @since build 302
* @return the current threshold
* @see #setPrepareThreshold(int)
*/
public int getPrepareThreshold();
}
postgresql-jdbc-9.2-1002.src/org/postgresql/copy/ 0000775 0000000 0000000 00000000000 12050675701 0021604 5 ustar 00root root 0000000 0000000 postgresql-jdbc-9.2-1002.src/org/postgresql/copy/CopyIn.java 0000664 0000000 0000000 00000002664 12050675701 0023660 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2009-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.copy;
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;
/**
* 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.
*/
void flushCopy() throws SQLException;
/**
* Finishes copy operation succesfully.
* @return number of updated rows for server 8.2 or newer (see getHandledRowCount())
* @throws SQLException if the operation fails.
*/
public long endCopy() throws SQLException;
}
postgresql-jdbc-9.2-1002.src/org/postgresql/copy/CopyManager.java 0000664 0000000 0000000 00000016217 12050675701 0024663 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2009-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
/**
* Bulk data copy for PostgreSQL
*/
package org.postgresql.copy;
import java.io.IOException;
import java.io.OutputStream;
import java.io.InputStream;
import java.io.Reader;
import java.io.Writer;
import java.sql.SQLException;
import org.postgresql.core.Encoding;
import org.postgresql.core.QueryExecutor;
import org.postgresql.core.BaseConnection;
import org.postgresql.util.GT;
import org.postgresql.util.PSQLException;
import org.postgresql.util.PSQLState;
/**
* 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.
final static 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 = null;
try {
op = queryExecutor.startCopy(sql, connection.getAutoCommit());
return (CopyIn) op;
} catch(ClassCastException cce) {
op.cancelCopy();
throw new PSQLException(GT.tr("Requested CopyIn but got {0}", op.getClass().getName()), PSQLState.WRONG_OBJECT_TYPE, cce);
}
}
public CopyOut copyOut(String sql) throws SQLException {
CopyOperation op = null;
try {
op = queryExecutor.startCopy(sql, connection.getAutoCommit());
return (CopyOut) op;
} catch(ClassCastException cce) {
op.cancelCopy();
throw new PSQLException(GT.tr("Requested CopyOut but got {0}", op.getClass().getName()), PSQLState.WRONG_OBJECT_TYPE, cce);
}
}
/**
* Pass results of a COPY TO STDOUT query from database into a Writer.
* @param sql COPY TO STDOUT statement
* @param to the stream to write the results to (row by row)
* @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();
} 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)
* @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();
} 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) {
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 ) {
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();
}
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/copy/CopyOperation.java 0000664 0000000 0000000 00000002653 12050675701 0025250 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2009-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
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 succesful 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
*/
public long getHandledRowCount();
}
postgresql-jdbc-9.2-1002.src/org/postgresql/copy/CopyOut.java 0000664 0000000 0000000 00000000576 12050675701 0024061 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2009-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.copy;
import java.sql.SQLException;
public interface CopyOut extends CopyOperation {
byte[] readFromCopy() throws SQLException;
}
postgresql-jdbc-9.2-1002.src/org/postgresql/copy/PGCopyInputStream.java 0000664 0000000 0000000 00000010111 12050675701 0025776 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2009-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.copy;
import java.io.IOException;
import java.io.InputStream;
import java.sql.SQLException;
import org.postgresql.PGConnection;
import org.postgresql.util.GT;
import org.postgresql.util.PSQLException;
import org.postgresql.util.PSQLState;
/**
* InputStream for reading from a PostgreSQL COPY TO STDOUT operation
*/
public class PGCopyInputStream extends InputStream implements CopyOut {
private CopyOut op;
private byte[] buf;
private int at, 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
* @throws SQLException if initializing the operation fails
*/
public PGCopyInputStream(CopyOut op) {
this.op = op;
}
private boolean gotBuf() throws IOException {
if(at >= len) {
try {
buf = op.readFromCopy();
} catch(SQLException sqle) {
throw new IOException(GT.tr("Copying from database failed: {0}", sqle));
}
if(buf == null) {
at = -1;
return false;
} else {
at = 0;
len = buf.length;
return true;
}
}
return buf != null;
}
private void checkClosed() throws IOException {
if (op == null) {
throw new IOException(GT.tr("This copy stream is closed."));
}
}
public int available() throws IOException {
checkClosed();
return ( buf != null ? len - at : 0 );
}
public int read() throws IOException {
checkClosed();
return gotBuf() ? buf[at++] : -1;
}
public int read(byte[] buf) throws IOException {
return read(buf, 0, buf.length);
}
public int read(byte[] buf, int off, int siz) throws IOException {
checkClosed();
int got = 0;
while( got < siz && gotBuf() ) {
buf[off+got++] = this.buf[at++];
}
return got;
}
public byte[] readFromCopy() throws SQLException {
byte[] result = buf;
try {
if(gotBuf()) {
if(at>0 || len < buf.length) {
byte[] ba = new byte[len-at];
for(int i=at; i255)
throw new IOException(GT.tr("Cannot write to copy a byte of value {0}", new Integer(b)));
singleByteBuffer[0] = (byte)b;
write(singleByteBuffer, 0, 1);
}
public void write(byte[] buf) throws IOException {
write(buf, 0, buf.length);
}
public void write(byte[] buf, int off, int siz) throws IOException {
checkClosed();
try {
writeToCopy(buf, off, siz);
} catch(SQLException se) {
IOException ioe = new IOException("Write to copy failed.");
ioe.initCause(se);
throw ioe;
}
}
private void checkClosed() throws IOException {
if (op == null) {
throw new IOException(GT.tr("This copy stream is closed."));
}
}
public void close() throws IOException {
// Don't complain about a double close.
if (op == null)
return;
try{
endCopy();
} catch(SQLException se) {
IOException ioe = new IOException("Ending write to copy failed.");
ioe.initCause(se);
throw ioe;
}
op = null;
}
public void flush() throws IOException {
try {
op.writeToCopy(copyBuffer, 0, at);
at = 0;
op.flushCopy();
} catch (SQLException e) {
IOException ioe = new IOException("Unable to flush stream");
ioe.initCause(e);
throw ioe;
}
}
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
op.writeToCopy(copyBuffer, 0, at);
at = 0;
}
if(siz > copyBuffer.length) { // would still not fit into buf, so just pass it through
op.writeToCopy(buf, off, siz);
} else { // fits into our buf, so save it there
System.arraycopy(buf, off, copyBuffer, at, siz);
at += siz;
}
}
public int getFormat() {
return op.getFormat();
}
public int getFieldFormat(int field) {
return op.getFieldFormat(field);
}
public void cancelCopy() throws SQLException {
op.cancelCopy();
}
public int getFieldCount() {
return op.getFieldCount();
}
public boolean isActive() {
return op.isActive();
}
public void flushCopy() throws SQLException {
op.flushCopy();
}
public long endCopy() throws SQLException {
if(at > 0) {
op.writeToCopy(copyBuffer, 0, at);
}
op.endCopy();
return getHandledRowCount();
}
public long getHandledRowCount() {
return op.getHandledRowCount();
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/ 0000775 0000000 0000000 00000000000 12050675701 0021562 5 ustar 00root root 0000000 0000000 postgresql-jdbc-9.2-1002.src/org/postgresql/core/BaseConnection.java 0000664 0000000 0000000 00000013113 12050675701 0025316 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2003-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.core;
import java.sql.*;
import org.postgresql.PGConnection;
import org.postgresql.jdbc2.TimestampUtils;
/**
* 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.
*/
public 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.
*/
public ResultSet execSQLQuery(String s) throws SQLException;
public 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.
*/
public void execSQLUpdate(String s) throws SQLException;
/**
* Get the QueryExecutor implementation for this connection.
*
* @return the (non-null) executor
*/
public QueryExecutor getQueryExecutor();
/**
* 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.
*
* @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
*/
public Object getObject(String type, String value, byte[] byteValue) throws SQLException;
public Encoding getEncoding() throws SQLException;
public TypeInfo getTypeInfo();
/**
* Check if we should use driver behaviour introduced in a particular
* driver version. This defaults to behaving as the actual driver's version
* but can be overridden by the "compatible" URL parameter.
*
* @param ver the driver version to check
* @return true if the driver's behavioural version is at least "ver".
* @throws SQLException if something goes wrong
*/
public boolean haveMinimumCompatibleVersion(String ver);
/**
* Check if we have at least a particular server version.
*
* @param ver the server version to check
* @return true if the server version is at least "ver".
* @throws SQLException if something goes wrong
*/
public boolean haveMinimumServerVersion(String 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.
*/
public byte[] encodeString(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 \0 character
*/
public 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
* standard_conforming_strings server variable.
*
* @return true if the server treats string literals according to the SQL
* standard
*
* @see ProtocolConnection#getStandardConformingStrings()
*/
public boolean getStandardConformingStrings();
// Ew. Quick hack to give access to the connection-specific utils implementation.
public TimestampUtils getTimestampUtils();
// Get the per-connection logger.
public Logger getLogger();
// Get the bind-string-as-varchar config flag
public boolean getStringVarcharFlag();
/**
* Get the current transaction state of this connection.
*
* @return a ProtocolConnection.TRANSACTION_* constant.
*/
public int 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.
*/
public boolean binaryTransferSend(int oid);
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/BaseResultSet.java 0000664 0000000 0000000 00000001420 12050675701 0025147 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2003-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.core;
import java.sql.*;
/**
* Driver-internal resultset interface. Application code should not use
* this interface.
*/
public interface BaseResultSet extends ResultSet
{
/**
* Return a sanitized numeric string for a column. This handles
* "money" representations, stripping $ and () as appropriate.
*
* @param col the 1-based column to retrieve
* @return the sanitized string
* @throws SQLException if something goes wrong
*/
public String getFixedString(int col) throws SQLException;
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/BaseStatement.java 0000664 0000000 0000000 00000004256 12050675701 0025173 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2003-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.core;
import org.postgresql.PGStatement;
import java.sql.*;
import java.util.List;
/**
* Driver-internal statement interface. Application code should not use
* this interface.
*/
public interface BaseStatement extends PGStatement, Statement
{
/**
* Create a synthetic resultset from data provided by the driver.
*
* @param fields the column metadata for the resultset
* @param tuples the resultset data
* @return the new ResultSet
* @throws SQLException if something goes wrong
*/
public ResultSet createDriverResultSet(Field[] fields, List tuples) throws SQLException;
/**
* Create a resultset from data retrieved from the server.
*
* @param originalQuery the query that generated this resultset; used when dealing with updateable resultsets
* @param fields the column metadata for the resultset
* @param tuples the resultset data
* @param cursor the cursor to use to retrieve more data from the server; if null, no additional data is present.
* @return the new ResultSet
* @throws SQLException if something goes wrong
*/
public ResultSet createResultSet(Query originalQuery, Field[] fields, List tuples, ResultCursor cursor) throws SQLException;
/**
* Execute a query, passing additional query flags.
*
* @param p_sql the query to execute
* @param flags additional {@link QueryExecutor} flags for execution; these
* are bitwise-ORed into the default flags.
* @throws SQLException if something goes wrong.
*/
public boolean executeWithFlags(String p_sql, int flags) throws SQLException;
/**
* Execute a prepared query, passing additional query flags.
*
* @param flags additional {@link QueryExecutor} flags for execution; these
* are bitwise-ORed into the default flags.
* @throws SQLException if something goes wrong.
*/
public boolean executeWithFlags(int flags) throws SQLException;
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/ConnectionFactory.java 0000664 0000000 0000000 00000007725 12050675701 0026067 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
* Copyright (c) 2004, Open Cloud Limited.
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.core;
import java.util.Properties;
import java.sql.SQLException;
import org.postgresql.util.HostSpec;
import org.postgresql.util.PSQLException;
import org.postgresql.util.GT;
import org.postgresql.util.PSQLState;
/**
* Handles protocol-specific connection setup.
*
* @author Oliver Jowett (oliver@opencloud.com)
*/
public abstract class ConnectionFactory {
/**
* Protocol version to implementation instance map.
* If no protocol version is specified, instances are
* tried in order until an exception is thrown or a non-null
* connection is returned.
*/
private static final Object[][] versions = {
{ "3", new org.postgresql.core.v3.ConnectionFactoryImpl() },
{ "2", new org.postgresql.core.v2.ConnectionFactoryImpl() },
};
/**
* Establishes and initializes a new connection.
*
* If 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+) and 2 (pre-7.4) are supported.
*
* @param hostSpecs at least one host and port to connect to; multiple elements for round-robin failover
* @param user the username to authenticate with; may not be null.
* @param database the database on the server to connect to; may not be null.
* @param info extra properties controlling the connection;
* notably, "password" if present supplies the password to authenticate with.
* @param logger the logger to use for this connection
* @return the new, initialized, connection
* @throws SQLException if the connection could not be established.
*/
public static ProtocolConnection openConnection(HostSpec[] hostSpecs, String user, String database, Properties info, Logger logger) throws SQLException {
String protoName = info.getProperty("protocolVersion");
for (int i = 0; i < versions.length; ++i)
{
String versionProtoName = (String) versions[i][0];
if (protoName != null && !protoName.equals(versionProtoName))
continue;
ConnectionFactory factory = (ConnectionFactory) versions[i][1];
ProtocolConnection connection = factory.openConnectionImpl(hostSpecs, user, database, info, logger);
if (connection != null)
return connection;
}
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 user the username to authenticate with; may not be null.
* @param database the database on the server to connect to; may not be null.
* @param info extra properties controlling the connection;
* notably, "password" if present supplies the password to authenticate with.
* @param logger the logger to use for this connection
* @return the new, initialized, connection, or null 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 ProtocolConnection openConnectionImpl(HostSpec[] hostSpecs, String user, String database, Properties info, Logger logger) throws SQLException;
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/Encoding.java 0000664 0000000 0000000 00000023533 12050675701 0024161 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2003-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.core;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.io.IOException;
import java.util.HashMap;
/**
* Representation of a particular character encoding.
*/
public class Encoding
{
private static final Encoding DEFAULT_ENCODING = new Encoding(null);
/*
* Preferred JVM encodings for backend encodings.
*/
private static final HashMap encodings = new HashMap();
static {
//Note: this list should match the set of supported server
// encodings found in backend/util/mb/encnames.c
encodings.put("SQL_ASCII", new String[] { "ASCII", "us-ascii" });
encodings.put("UNICODE", new String[] { "UTF-8", "UTF8" });
encodings.put("UTF8", new String[] { "UTF-8", "UTF8" }); // 8.1's canonical name for UNICODE changed.
encodings.put("LATIN1", new String[] { "ISO8859_1" });
encodings.put("LATIN2", new String[] { "ISO8859_2" });
encodings.put("LATIN3", new String[] { "ISO8859_3" });
encodings.put("LATIN4", new String[] { "ISO8859_4" });
encodings.put("ISO_8859_5", new String[] { "ISO8859_5" });
encodings.put("ISO_8859_6", new String[] { "ISO8859_6" });
encodings.put("ISO_8859_7", new String[] { "ISO8859_7" });
encodings.put("ISO_8859_8", new String[] { "ISO8859_8" });
encodings.put("LATIN5", new String[] { "ISO8859_9" });
encodings.put("LATIN7", new String[] { "ISO8859_13" });
encodings.put("LATIN9", new String[] { "ISO8859_15_FDIS" });
encodings.put("EUC_JP", new String[] { "EUC_JP" });
encodings.put("EUC_CN", new String[] { "EUC_CN" });
encodings.put("EUC_KR", new String[] { "EUC_KR" });
encodings.put("JOHAB", new String[] { "Johab" });
encodings.put("EUC_TW", new String[] { "EUC_TW" });
encodings.put("SJIS", new String[] { "MS932", "SJIS" });
encodings.put("BIG5", new String[] { "Big5", "MS950", "Cp950" });
encodings.put("GBK", new String[] { "GBK", "MS936" });
encodings.put("UHC", new String[] { "MS949", "Cp949", "Cp949C" });
encodings.put("TCVN", new String[] { "Cp1258" });
encodings.put("WIN1256", new String[] { "Cp1256" });
encodings.put("WIN1250", new String[] { "Cp1250" });
encodings.put("WIN874", new String[] { "MS874", "Cp874" });
encodings.put("WIN", new String[] { "Cp1251" });
encodings.put("ALT", new String[] { "Cp866" });
// We prefer KOI8-U, since it is a superset of KOI8-R.
encodings.put("KOI8", new String[] { "KOI8_U", "KOI8_R" });
// If the database isn't encoding-aware then we can't have
// any preferred encodings.
encodings.put("UNKNOWN", new String[0]);
// The following encodings do not have a java equivalent
encodings.put("MULE_INTERNAL", new String[0]);
encodings.put("LATIN6", new String[0]);
encodings.put("LATIN8", new String[0]);
encodings.put("LATIN10", new String[0]);
}
private final String encoding;
private final boolean fastASCIINumbers;
protected Encoding(String encoding)
{
this.encoding = encoding;
fastASCIINumbers = testAsciiNumbers();
}
/**
* Returns true if this encoding has characters
* '-' and '0'..'9' in exactly same posision as ascii.
*
* @return true if the bytes can be scanned directly for ascii numbers.
*/
public boolean hasAsciiNumbers() {
return fastASCIINumbers;
}
/**
* Construct an Encoding for a given JVM encoding.
*
* @param jvmEncoding the name of the JVM encoding
* @return an Encoding instance for the specified encoding,
* or an Encoding instance for the default JVM encoding if the
* specified encoding is unavailable.
*/
public static Encoding getJVMEncoding(String jvmEncoding) {
if (isAvailable(jvmEncoding))
{
if (jvmEncoding.equals("UTF-8") || jvmEncoding.equals("UTF8"))
return new UTF8Encoding(jvmEncoding);
else
return new Encoding(jvmEncoding);
}
else
return defaultEncoding();
}
/**
* Construct an Encoding for a given database encoding.
*
* @param databaseEncoding the name of the database encoding
* @return an Encoding instance for the specified encoding,
* or an Encoding instance for the default JVM encoding if the
* specified encoding is unavailable.
*/
public static Encoding getDatabaseEncoding(String databaseEncoding)
{
// If the backend encoding is known and there is a suitable
// encoding in the JVM we use that. Otherwise we fall back
// to the default encoding of the JVM.
String[] candidates = (String[]) encodings.get(databaseEncoding);
if (candidates != null)
{
for (int i = 0; i < candidates.length; i++)
{
if (isAvailable(candidates[i]))
{
return new Encoding(candidates[i]);
}
}
}
// Try the encoding name directly -- maybe the charset has been
// provided by the user.
if (isAvailable(databaseEncoding))
return new Encoding(databaseEncoding);
// Fall back to default JVM encoding.
return defaultEncoding();
}
/**
* Get the name of the (JVM) encoding used.
*
* @return the JVM encoding name used by this instance.
*/
public String name()
{
return encoding;
}
/**
* 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[] encode(String s) throws IOException
{
if (s == null)
return null;
if (encoding == null)
return s.getBytes();
return s.getBytes(encoding);
}
/**
* Decode an array of bytes into a string.
*
* @param encodedString a bytearray containing the encoded string the string to encod
* @param offset the offset in encodedString 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
{
if (encoding == null)
return new String(encodedString, offset, length);
return new String(encodedString, offset, length, encoding);
}
/**
* Decode an array of bytes into a string.
*
* @param encodedString a bytearray containing the encoded string the string to encod
* @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
{
if (encoding == null)
return new InputStreamReader(in);
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
{
if (encoding == null)
return new OutputStreamWriter(out);
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;
}
/**
* Test if an encoding is available in the JVM.
*
* @param encodingName the JVM encoding name to test
* @return true iff the encoding is supported
*/
private static boolean isAvailable(String encodingName)
{
try
{
"DUMMY".getBytes(encodingName);
return true;
}
catch (java.io.UnsupportedEncodingException e)
{
return false;
}
}
public String toString() {
return (encoding == null ? "" : encoding);
}
/**
* Checks weather 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 boolean testAsciiNumbers() {
// 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
try {
String test = "-0123456789";
byte[] bytes = encode(test);
String res = new String(bytes, "US-ASCII");
return test.equals(res);
} catch (java.io.UnsupportedEncodingException e) {
return false;
} catch (IOException e) {
return false;
}
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/Field.java 0000664 0000000 0000000 00000011654 12050675701 0023457 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2003-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.core;
import java.sql.ResultSetMetaData;
/*
*/
public class Field
{
//The V3 protocol defines two constants for the format of data
public static final int TEXT_FORMAT = 0;
public static final int BINARY_FORMAT = 1;
private final int length; // Internal Length of this field
private final int oid; // OID of the type
private final int mod; // type modifier of this field
private final String columnLabel; // Column label
private String columnName; // Column name
private int format = TEXT_FORMAT; // In the V3 protocol each field has a format
// 0 = text, 1 = binary
// In the V2 protocol all fields in a
// binary cursor are binary and all
// others are text
private final int tableOid; // OID of table ( zero if no table )
private final int positionInTable;
// Cache fields filled in by AbstractJdbc2ResultSetMetaData.fetchFieldMetaData.
// Don't use unless that has been called.
private String tableName = "";
private String schemaName = "";
private int nullable = ResultSetMetaData.columnNullableUnknown;
private boolean autoIncrement = false;
/*
* Construct a field based on the information fed to it.
*
* @param name the name (column name and label) of the field
* @param oid the OID of the field
* @param len the length of the field
*/
public Field(String name, int oid, int length, int mod)
{
this(name, name, oid, length, mod, 0, 0);
}
/*
* Constructor without mod parameter.
*
* @param name the name (column name and label) of the field
* @param oid the OID of the field
* @param len the length of the field
*/
public Field(String name, int oid)
{
this(name, oid, 0, -1);
}
/*
* Construct a field based on the information fed to it.
*
* @param columnLabel the column label of the field
* @param columnName the column label the name of the field
* @param oid the OID of the field
* @param length the length of the field
* @param tableOid the OID of the columns' table
* @param positionInTable the position of column in the table (first column is 1, second column is 2, etc...)
*/
public Field(String columnLabel, String columnName, int oid, int length, int mod, int tableOid, int positionInTable)
{
this.columnLabel = columnLabel;
this.columnName = columnName;
this.oid = oid;
this.length = length;
this.mod = mod;
this.tableOid = tableOid;
this.positionInTable = positionInTable;
}
/*
* @return the oid of this Field's data type
*/
public int getOID()
{
return oid;
}
/*
* @return the mod of this Field's data type
*/
public int getMod()
{
return mod;
}
/*
* @return the column label of this Field's data type
*/
public String getColumnLabel()
{
return columnLabel;
}
/*
* @return the length of this Field's data type
*/
public int getLength()
{
return length;
}
/*
* @return the format of this Field's data (text=0, binary=1)
*/
public int getFormat()
{
return format;
}
/*
* @param format the format of this Field's data (text=0, binary=1)
*/
public void setFormat(int format)
{
this.format = format;
}
/*
* @return the columns' table oid, zero if no oid available
*/
public int getTableOid()
{
return tableOid;
}
public int getPositionInTable()
{
return positionInTable;
}
public void setNullable(int nullable)
{
this.nullable = nullable;
}
public int getNullable()
{
return nullable;
}
public void setAutoIncrement(boolean autoIncrement)
{
this.autoIncrement = autoIncrement;
}
public boolean getAutoIncrement()
{
return autoIncrement;
}
public void setColumnName(String columnName)
{
this.columnName = columnName;
}
public String getColumnName()
{
return columnName;
}
public void setTableName(String tableName)
{
this.tableName = tableName;
}
public String getTableName()
{
return tableName;
}
public void setSchemaName(String schemaName)
{
this.schemaName = schemaName;
}
public String getSchemaName()
{
return schemaName;
}
public String toString() {
return "Field("+ (columnName != null ? columnName : "") + "," +
Oid.toString(oid) + "," + length + "," +
(format == TEXT_FORMAT ? 'T' : 'B') + ")";
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/Logger.java 0000664 0000000 0000000 00000005056 12050675701 0023652 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2005-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.core;
import java.text.SimpleDateFormat;
import java.text.FieldPosition;
import java.sql.DriverManager;
import java.io.PrintWriter;
import java.util.Date;
import org.postgresql.Driver;
/**
* Poor man's logging infrastructure. This just deals with maintaining a per-
* connection ID and log level, and timestamping output.
*/
public final class Logger {
// For brevity we only log the time, not date or timezone (the main reason
// for the timestamp is to see delays etc. between log lines, not to pin
// down an instant in time)
private final SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss.SSS ");
private final FieldPosition dummyPosition = new FieldPosition(0);
private final StringBuffer buffer = new StringBuffer();
private final String connectionIDString;
private int level = 0;
public Logger() {
connectionIDString = "(driver) ";
}
public Logger(int connectionID) {
connectionIDString = "(" + connectionID + ") ";
}
public void setLogLevel(int level) {
this.level = level;
}
public int getLogLevel() {
return level;
}
public boolean logDebug() {
return level >= Driver.DEBUG;
}
public boolean logInfo() {
return level >= Driver.INFO;
}
public void debug(String str) {
debug(str, null);
}
public void debug(String str, Throwable t) {
if (logDebug())
log(str, t);
}
public void info(String str) {
info(str, null);
}
public void info(String str, Throwable t) {
if (logInfo())
log(str, t);
}
public void log(String str, Throwable t) {
PrintWriter writer = DriverManager.getLogWriter();
if (writer == null)
return;
synchronized (this) {
buffer.setLength(0);
dateFormat.format(new Date(), buffer, dummyPosition);
buffer.append(connectionIDString);
buffer.append(str);
// synchronize to ensure that the exception (if any) does
// not get split up from the corresponding log message
synchronized (writer) {
writer.println(buffer.toString());
if (t != null)
t.printStackTrace(writer);
}
}
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/Notification.java 0000664 0000000 0000000 00000002020 12050675701 0025045 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2003-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.core;
import org.postgresql.PGNotification;
public class Notification implements PGNotification
{
public Notification(String p_name, int p_pid)
{
this(p_name, p_pid, "");
}
public Notification(String p_name, int p_pid, String p_parameter)
{
m_name = p_name;
m_pid = p_pid;
m_parameter = p_parameter;
}
/*
* Returns name of this notification
*/
public String getName()
{
return m_name;
}
/*
* Returns the process id of the backend process making this notification
*/
public int getPID()
{
return m_pid;
}
public String getParameter()
{
return m_parameter;
}
private String m_name;
private String m_parameter;
private int m_pid;
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/Oid.java 0000664 0000000 0000000 00000010350 12050675701 0023137 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.core;
import java.lang.reflect.Field;
import org.postgresql.util.GT;
import org.postgresql.util.PSQLException;
import org.postgresql.util.PSQLState;
/**
* Provides constants for well-known backend OIDs for the types we commonly
* use.
*/
public class Oid {
public static final int UNSPECIFIED = 0;
public static final int INT2 = 21;
public static final int INT2_ARRAY = 1005;
public static final int INT4 = 23;
public static final int INT4_ARRAY = 1007;
public static final int INT8 = 20;
public static final int INT8_ARRAY = 1016;
public static final int TEXT = 25;
public static final int TEXT_ARRAY = 1009;
public static final int NUMERIC = 1700;
public static final int NUMERIC_ARRAY = 1231;
public static final int FLOAT4 = 700;
public static final int FLOAT4_ARRAY = 1021;
public static final int FLOAT8 = 701;
public static final int FLOAT8_ARRAY = 1022;
public static final int BOOL = 16;
public static final int BOOL_ARRAY = 1000;
public static final int DATE = 1082;
public static final int DATE_ARRAY = 1182;
public static final int TIME = 1083;
public static final int TIME_ARRAY = 1183;
public static final int TIMETZ = 1266;
public static final int TIMETZ_ARRAY = 1270;
public static final int TIMESTAMP = 1114;
public static final int TIMESTAMP_ARRAY = 1115;
public static final int TIMESTAMPTZ = 1184;
public static final int TIMESTAMPTZ_ARRAY = 1185;
public static final int BYTEA = 17;
public static final int BYTEA_ARRAY = 1001;
public static final int VARCHAR = 1043;
public static final int VARCHAR_ARRAY = 1015;
public static final int OID = 26;
public static final int OID_ARRAY = 1028;
public static final int BPCHAR = 1042;
public static final int BPCHAR_ARRAY = 1014;
public static final int MONEY = 790;
public static final int MONEY_ARRAY = 791;
public static final int NAME = 19;
public static final int NAME_ARRAY = 1003;
public static final int BIT = 1560;
public static final int BIT_ARRAY = 1561;
public static final int VOID = 2278;
public static final int INTERVAL = 1186;
public static final int INTERVAL_ARRAY = 1187;
public static final int CHAR = 18; // This is not char(N), this is "char" a single byte type.
public static final int CHAR_ARRAY = 1002;
public static final int VARBIT = 1562;
public static final int VARBIT_ARRAY = 1563;
public static final int UUID = 2950;
public static final int UUID_ARRAY = 2951;
public static final int XML = 142;
public static final int XML_ARRAY = 143;
public static final int POINT = 600;
public static final int BOX = 603;
/**
* Returns the name of the oid as string.
*
* @param oid The oid to convert to name.
* @return The name of the oid or "" if oid no constant for
* oid value has been defined.
*/
public static String toString(int oid) {
try {
Field[] fields = Oid.class.getFields();
for (int i = 0; i < fields.length; ++i) {
if (fields[i].getInt(null) == oid) {
return fields[i].getName();
}
}
} catch (IllegalAccessException e) {
// never happens
}
return "";
}
public static int valueOf(String oid) throws PSQLException {
try {
return (int)Long.parseLong(oid);
} catch (NumberFormatException ex) {
}
try {
oid = oid.toUpperCase();
Field[] fields = Oid.class.getFields();
for (int i = 0; i < fields.length; ++i) {
if (fields[i].getName().toUpperCase().equals(oid)) {
return fields[i].getInt(null);
}
}
} catch (IllegalAccessException e) {
// never happens
}
throw new PSQLException(GT.tr("oid type {0} not known and not a number", oid), PSQLState.INVALID_PARAMETER_VALUE);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/PGBindException.java 0000664 0000000 0000000 00000000775 12050675701 0025420 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.core;
import java.io.IOException;
public class PGBindException extends IOException {
private IOException _ioe;
public PGBindException(IOException ioe) {
_ioe = ioe;
}
public IOException getIOException() {
return _ioe;
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/PGStream.java 0000664 0000000 0000000 00000040566 12050675701 0024122 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2003-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.core;
import java.io.BufferedOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.EOFException;
import java.io.Writer;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.sql.SQLException;
import org.postgresql.util.GT;
import org.postgresql.util.HostSpec;
import org.postgresql.util.PSQLState;
import org.postgresql.util.PSQLException;
/**
* Wrapper around the raw connection to the server that implements some basic
* primitives (reading/writing formatted data, doing string encoding, etc).
*
* 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
{
private final HostSpec hostSpec;
private final byte[] _int4buf;
private final byte[] _int2buf;
private Socket connection;
private VisibleBufferedInputStream pg_input;
private OutputStream pg_output;
private byte[] streamBuffer;
private Encoding encoding;
private Writer encodingWriter;
/**
* Constructor: Connect to the PostgreSQL back end and return
* a stream connection.
*
* @param hostSpec the host and port to connect to
* @exception IOException if an IOException occurs below it.
*/
public PGStream(HostSpec hostSpec) throws IOException
{
this.hostSpec = hostSpec;
Socket socket = new Socket();
socket.connect(new InetSocketAddress(hostSpec.getHost(), hostSpec.getPort()));
changeSocket(socket);
setEncoding(Encoding.getJVMEncoding("US-ASCII"));
_int2buf = new byte[2];
_int4buf = new byte[4];
}
public HostSpec getHostSpec() {
return hostSpec;
}
public Socket getSocket() {
return connection;
}
/**
* 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
*/
public boolean hasMessagePending() throws IOException {
return pg_input.available() > 0 || connection.getInputStream().available() > 0;
}
/**
* 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 {
this.connection = socket;
// Submitted by Jason Venner . Disable Nagle
// as we are selective about flushing output only when we
// really need to.
connection.setTcpNoDelay(true);
// Buffer sizes submitted by Sverre H Huseby
pg_input = new VisibleBufferedInputStream(connection.getInputStream(), 8192);
pg_output = new BufferedOutputStream(connection.getOutputStream(), 8192);
if (encoding != null)
setEncoding(encoding);
}
public Encoding getEncoding() {
return encoding;
}
/**
* Change the encoding used by this connection.
*
* @param encoding the new encoding to use
* @throws IOException if something goes wrong
*/
public void setEncoding(Encoding encoding) throws IOException {
// Close down any old writer.
if (encodingWriter != null)
encodingWriter.close();
this.encoding = encoding;
// Intercept flush() downcalls from the writer; our caller
// will call PGStream.flush() as needed.
OutputStream interceptor = new FilterOutputStream(pg_output) {
public void flush() throws IOException {
}
public void close() throws IOException {
super.flush();
}
};
encodingWriter = encoding.getEncodingWriter(interceptor);
}
/**
* Get a Writer instance that encodes directly onto the underlying stream.
*
* The 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
* @exception IOException if an I/O error occurs
*/
public void SendChar(int val) throws IOException
{
pg_output.write(val);
}
/**
* Sends a 4-byte integer to the back end
*
* @param val the integer to be sent
* @exception IOException if an I/O error occurs
*/
public void SendInteger4(int val) throws IOException
{
_int4buf[0] = (byte)(val >>> 24);
_int4buf[1] = (byte)(val >>> 16);
_int4buf[2] = (byte)(val >>> 8);
_int4buf[3] = (byte)(val);
pg_output.write(_int4buf);
}
/**
* Sends a 2-byte integer (short) to the back end
*
* @param val the integer to be sent
* @exception IOException if an I/O error occurs or val cannot be encoded in 2 bytes
*/
public void SendInteger2(int val) throws IOException
{
if (val < Short.MIN_VALUE || val > Short.MAX_VALUE)
throw new IOException("Tried to send an out-of-range integer as a 2-byte value: " + val);
_int2buf[0] = (byte)(val >>> 8);
_int2buf[1] = (byte)val;
pg_output.write(_int2buf);
}
/**
* Send an array of bytes to the backend
*
* @param buf The array of bytes to be sent
* @exception IOException if an I/O error occurs
*/
public void Send(byte buf[]) throws IOException
{
pg_output.write(buf);
}
/**
* Send a fixed-size array of bytes to the backend. If buf.length < siz,
* pad with zeros. If buf.lengh > siz, truncate the array.
*
* @param buf the array of bytes to be sent
* @param siz the number of bytes to be sent
* @exception 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 length < siz,
* pad with zeros. If 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
* @exception IOException if an I/O error occurs
*/
public void Send(byte buf[], int off, int siz) throws IOException
{
int bufamt = buf.length - off;
pg_output.write(buf, off, bufamt < siz ? bufamt : siz);
for (int i = bufamt ; i < siz ; ++i)
{
pg_output.write(0);
}
}
/**
* Receives a single character from the backend, without
* advancing the current protocol stream position.
*
* @return the character received
* @exception IOException if an I/O Error occurs
*/
public int PeekChar() throws IOException
{
int c = pg_input.peek();
if (c < 0)
throw new EOFException();
return c;
}
/**
* Receives a single character from the backend
*
* @return the character received
* @exception IOException if an I/O Error occurs
*/
public int ReceiveChar() throws IOException
{
int c = pg_input.read();
if (c < 0)
throw new EOFException();
return c;
}
/**
* Receives a four byte integer from the backend
*
* @return the integer received from the backend
* @exception IOException if an I/O error occurs
*/
public int ReceiveInteger4() throws IOException
{
if (pg_input.read(_int4buf) != 4)
throw new EOFException();
return (_int4buf[0] & 0xFF) << 24 | (_int4buf[1] & 0xFF) << 16 | (_int4buf[2] & 0xFF) << 8 | _int4buf[3] & 0xFF;
}
/**
* Receives a two byte integer from the backend
*
* @return the integer received from the backend
* @exception IOException if an I/O error occurs
*/
public int ReceiveInteger2() throws IOException
{
if (pg_input.read(_int2buf) != 2)
throw new EOFException();
return (_int2buf[0] & 0xFF) << 8 | _int2buf[1] & 0xFF;
}
/**
* Receives a fixed-size string from the backend.
*
* @param len the length of the string to receive, in bytes.
* @return the decoded string
*/
public String ReceiveString(int len) throws IOException {
if (!pg_input.ensureBytes(len)) {
throw new EOFException();
}
String res = encoding.decode(pg_input.getBuffer(), pg_input.getIndex(),
len);
pg_input.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
* @exception IOException if an I/O error occurs, or end of file
*/
public String ReceiveString() throws IOException
{
int len = pg_input.scanCStringLength();
String res = encoding.decode(pg_input.getBuffer(), pg_input.getIndex(),
len - 1);
pg_input.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 null if the current response has no more tuples, otherwise
* an array of bytearrays
* @exception IOException if a data I/O error occurs
*/
public byte[][] ReceiveTupleV3() throws IOException, OutOfMemoryError
{
//TODO: use l_msgSize
int l_msgSize = ReceiveInteger4();
int i;
int l_nf = ReceiveInteger2();
byte[][] answer = new byte[l_nf][];
OutOfMemoryError oom = null;
for (i = 0 ; i < l_nf ; ++i)
{
int l_size = ReceiveInteger4();
if (l_size != -1) {
try {
answer[i] = new byte[l_size];
Receive(answer[i], 0, l_size);
} catch(OutOfMemoryError oome) {
oom = oome;
Skip(l_size);
}
}
}
if (oom != null)
throw oom;
return answer;
}
/**
* Read a tuple from the back end. A tuple is a two dimensional
* array of bytes. This variant reads the V2 protocol's tuple
* representation.
*
* @param nf the number of fields expected
* @param bin true if the tuple is a binary tuple
* @return null if the current response has no more tuples, otherwise
* an array of bytearrays
* @exception IOException if a data I/O error occurs
*/
public byte[][] ReceiveTupleV2(int nf, boolean bin) throws IOException, OutOfMemoryError
{
int i, bim = (nf + 7) / 8;
byte[] bitmask = Receive(bim);
byte[][] answer = new byte[nf][];
int whichbit = 0x80;
int whichbyte = 0;
OutOfMemoryError oom = null;
for (i = 0 ; i < nf ; ++i)
{
boolean isNull = ((bitmask[whichbyte] & whichbit) == 0);
whichbit >>= 1;
if (whichbit == 0)
{
++whichbyte;
whichbit = 0x80;
}
if (!isNull)
{
int len = ReceiveInteger4();
if (!bin)
len -= 4;
if (len < 0)
len = 0;
try {
answer[i] = new byte[len];
Receive(answer[i], 0, len);
} catch(OutOfMemoryError oome) {
oom = oome;
Skip(len);
}
}
}
if (oom != null)
throw oom;
return answer;
}
/**
* Reads in a given number of bytes from the backend
*
* @param siz number of bytes to read
* @return array of bytes received
* @exception 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
* @exception 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 = pg_input.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 += pg_input.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
*/
public void SendStream(InputStream inStream, int remaining) throws IOException {
int expectedLength = remaining;
if (streamBuffer == null)
streamBuffer = new byte[8192];
while (remaining > 0)
{
int count = (remaining > streamBuffer.length ? streamBuffer.length : remaining);
int readCount;
try
{
readCount = inStream.read(streamBuffer, 0, count);
if (readCount < 0)
throw new EOFException(GT.tr("Premature end of input stream, expected {0} bytes, but only read {1}.", new Object[]{new Integer(expectedLength), new Integer(expectedLength - remaining)}));
}
catch (IOException ioe)
{
while (remaining > 0)
{
Send(streamBuffer, count);
remaining -= count;
count = (remaining > streamBuffer.length ? streamBuffer.length : remaining);
}
throw new PGBindException(ioe);
}
Send(streamBuffer, readCount);
remaining -= readCount;
}
}
/**
* Flush any pending output to the backend.
* @exception IOException if an I/O error occurs
*/
public void flush() throws IOException
{
if (encodingWriter != null)
encodingWriter.flush();
pg_output.flush();
}
/**
* Consume an expected EOF from the backend
* @exception SQLException if we get something other than an EOF
*/
public void ReceiveEOF() throws SQLException, IOException
{
int c = pg_input.read();
if (c < 0)
return;
throw new PSQLException(GT.tr("Expected an EOF from server, got: {0}", new Integer(c)), PSQLState.COMMUNICATION_ERROR);
}
/**
* Closes the connection
*
* @exception IOException if an I/O Error occurs
*/
public void close() throws IOException
{
if (encodingWriter != null)
encodingWriter.close();
pg_output.close();
pg_input.close();
connection.close();
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/ParameterList.java 0000664 0000000 0000000 00000014432 12050675701 0025205 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
* Copyright (c) 2004, Open Cloud Limited.
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.core;
import java.sql.SQLException;
import java.io.InputStream;
/**
* 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( 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.
*/
int getParameterCount();
/**
* Get the number of IN parameters in this list.
*
* @return the number of IN parameters in this list
*/
int getInParameterCount();
/**
* Get the number of OUT parameters in this list.
*
* @return the number of OUT parameters in this list
*/
int getOutParameterCount();
/**
* Return the oids of the parameters in this list. May be null for
* a ParameterList that does not support typing of parameters.
*/
public 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 if index is out of range
*/
void setIntParameter(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(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(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(int index, byte[] data, int offset, 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(int index, InputStream stream, int length) 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(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(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, returns "?".
*
* @param index the 1-based parameter index to bind.
* @return a string representation of the parameter.
*/
String toString(int index);
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/Parser.java 0000664 0000000 0000000 00000023612 12050675701 0023665 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2006-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.core;
/**
* Basic query parser infrastructure.
*
* @author Michael Paesold (mpaesold@gmx.at)
*/
public class Parser {
/**
* Find the end of the single-quoted string starting at the given offset.
*
* Note: for 'single '' quote in string', this method currently
* returns the offset of first ' character after the initial
* one. The caller must call the method a second time for the second
* part of the 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)
{
switch (query[offset])
{
case '\'':
return offset;
default:
break;
}
}
}
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 "double "" quote in string",
* this method currently returns the offset of first "
* character after the initial one. The caller must call the method a
* second time for the second part of the quoted string.
*/
public static int parseDoubleQuotes(final char[] query, int offset) {
while (++offset < query.length && query[offset] != '"') ;
return offset;
}
/**
* Test if the dollar character ($) at the given offset starts
* a dollar-quoted string and return the 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, 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 - character at offset starts a
* -- style line comment, and return the position of the first
* \r or \n character.
*/
public static int parseLineComment(final char[] query, int offset) {
if (offset + 1 < query.length && query[offset + 1] == '-')
{
while (++offset < query.length)
{
if (query[offset] == '\r' || query[offset] == '\n')
break;
}
}
return offset;
}
/**
* Test if the / character at offset starts a block
* comment, and return the position of the last / 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;
}
/**
* @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';
}
/**
* @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.
*
* @param c the character to check
* @return true if valid as first character of an identifier; false if not
*/
public static boolean isIdentifierStartChar(char c) {
/*
* Extracted from {ident_start} and {ident_cont} in
* pgsql/src/backend/parser/scan.l:
* ident_start [A-Za-z\200-\377_]
* ident_cont [A-Za-z\200-\377_0-9\$]
*/
return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
|| c == '_' || c > 127 ;
}
/**
* 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 (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
|| c == '_' || c > 127
|| (c >= '0' && c <= '9')
|| c == '$';
}
/**
* @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
*/
return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
|| c == '_' || c > 127;
}
/**
* 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 >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
|| c == '_' || c > 127
|| (c >= '0' && c <= '9');
}
/**
* 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;
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/ProtocolConnection.java 0000664 0000000 0000000 00000007722 12050675701 0026256 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
* Copyright (c) 2004, Open Cloud Limited.
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.core;
import org.postgresql.PGNotification;
import org.postgresql.util.HostSpec;
import java.sql.*;
import java.util.Set;
/**
* Provides access to protocol-level connection operations.
*
* @author Oliver Jowett (oliver@opencloud.com)
*/
public interface ProtocolConnection {
/**
* Constant returned by {@link #getTransactionState} indicating that no
* transaction is currently open.
*/
static final int TRANSACTION_IDLE = 0;
/**
* Constant returned by {@link #getTransactionState} indicating that a
* transaction is currently open.
*/
static final int TRANSACTION_OPEN = 1;
/**
* Constant returned by {@link #getTransactionState} indicating that a
* transaction is currently open, but it has seen errors and will
* refuse subsequent queries until a ROLLBACK.
*/
static final int TRANSACTION_FAILED = 2;
/**
* @return the host and port this connection is connected to.
*/
HostSpec getHostSpec();
/**
* @return the user this connection authenticated as.
*/
String getUser();
/**
* @return the database this connection is connected to.
*/
String getDatabase();
/**
* @return the server version of the connected server, formatted as X.Y.Z.
*/
String getServerVersion();
/**
* @return the current encoding in use by this connection
*/
Encoding getEncoding();
/**
* 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
* standard_conforming_strings server variable.
*
* @return true if the server treats string literals according to the SQL
* standard
*/
boolean getStandardConformingStrings();
/**
* Get the current transaction state of this connection.
*
* @return a ProtocolConnection.TRANSACTION_* constant.
*/
int getTransactionState();
/**
* 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.
*/
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().
*/
SQLWarning getWarnings();
/**
* @return the QueryExecutor instance for this connection.
*/
QueryExecutor getQueryExecutor();
/**
* Sends a query cancellation for this connection.
* @throws SQLException if something goes wrong.
*/
void sendQueryCancel() throws SQLException;
/**
* Close this connection cleanly.
*/
void close();
/**
* Check if this connection is closed.
*
* @return true iff the connection is closed.
*/
boolean isClosed();
/**
*
* @return the version of the implementation
*/
public int getProtocolVersion();
/**
* Sets the oids that should be received using binary encoding.
*
* @param useBinaryForOids The oids to request with binary encoding.
*/
public void setBinaryReceiveOids(Set useBinaryForOids);
/**
* Returns true if server uses integer instead of double for binary
* date and time encodings.
*
* @return the server integer_datetime setting.
*/
public boolean getIntegerDateTimes();
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/Query.java 0000664 0000000 0000000 00000003655 12050675701 0023543 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
* Copyright (c) 2004, Open Cloud Limited.
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.core;
/**
* Abstraction of a generic Query, hiding the details of
* any protocol-version-specific data needed to execute
* the query efficiently.
*
* Query 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();
/**
* Stringize this query to a human-readable form, substituting
* particular parameter values for parameter placeholders.
*
* @param parameters a ParameterList returned by this Query's
* {@link #createParameterList} method, or null to
* leave the parameter placeholders unsubstituted.
* @return a human-readable representation of this query
*/
String toString(ParameterList parameters);
/**
* 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();
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/QueryExecutor.java 0000664 0000000 0000000 00000022402 12050675701 0025251 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2003-2011, PostgreSQL Global Development Group
* Copyright (c) 2004, Open Cloud Limited.
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.core;
import java.sql.SQLException;
import org.postgresql.copy.CopyOperation;
/**
* Abstracts the protocol-specific details of executing a query.
*
* Every connection has a single QueryExecutor implementation associated with it.
* This object provides:
*
*
*
factory methods for Query objects ({@link #createSimpleQuery}
* and {@link #createParameterizedQuery})
*
execution methods for created Query objects ({@link #execute(Query,ParameterList,ResultHandler,int,int,int)}
* for single queries and {@link #execute(Query[],ParameterList[],ResultHandler,int,int,int)} for batches of
* queries)
*
a fastpath call interface ({@link #createFastpathParameters}
* and {@link #fastpathCall}).
*
*
*
* 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 {
/**
* Flag for query execution that indicates the given Query object is unlikely
* to be reused.
*/
static int QUERY_ONESHOT = 1;
/**
* Flag for query execution that indicates that resultset metadata isn't needed
* and can be safely omitted.
*/
static 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).
*/
static int QUERY_NO_RESULTS = 4;
/**
* Flag for query execution that indicates a forward-fetch-capable cursor should
* be used if possible.
*/
static 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.
*/
static 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.
*/
static 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.
*/
static int QUERY_BOTH_ROWS_AND_STATUS = 64;
/**
* Flag to disable batch execution when we expect results (generated keys)
* from a statement.
*/
static int QUERY_DISALLOW_BATCHING = 128;
/**
* Flag for query execution to avoid using binary transfer.
*/
static int QUERY_NO_BINARY_TRANSFER = 256;
/**
* Execute a Query, passing results to a provided ResultHandler.
*
* @param query the query to execute; must be a query returned from
* calling {@link #createSimpleQuery(String)} or {@link #createParameterizedQuery(String)}
* 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,
ParameterList parameters,
ResultHandler handler,
int maxRows,
int fetchSize,
int flags)
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 #createSimpleQuery(String)} or {@link #createParameterizedQuery(String)}
* 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 org.postgresql.core.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,
ParameterList[] parameterLists,
ResultHandler handler,
int maxRows,
int fetchSize,
int flags)
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
* @throws SQLException if query execution fails
*/
void fetch(ResultCursor cursor, ResultHandler handler, int fetchSize) 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
*/
Query createSimpleQuery(String sql);
/**
* Create a parameterized Query object suitable for execution by
* this QueryExecutor. The provided query string is parsed for
* parameter placeholders ('?' characters), and the
* {@link Query#createParameterList} of the returned object will
* create an appropriately-sized ParameterList.
*
* @param sql the SQL for the query to create, with '?' placeholders for
* parameters.
* @return a new Query object
*/
Query createParameterizedQuery(String sql); // Parsed for parameter placeholders ('?')
/**
* Prior to attempting to retrieve notifications, we need to pull
* any recently received notifications off of the network buffers.
* The notification retrieval in ProtocolConnection cannot do this
* as it is prone to deadlock, so the higher level caller must be
* responsible which requires exposing this method.
*/
void processNotifies() throws SQLException;
//
// Fastpath interface.
//
/**
* Create a new ParameterList implementation suitable for invoking a
* fastpath function via {@link #fastpathCall}.
*
* @param count the number of parameters the fastpath call will take
* @return a ParameterList suitable for passing to {@link #fastpathCall}.
*/
ParameterList createFastpathParameters(int count);
/**
* Invoke a backend function via the fastpath interface.
*
* @param fnid the OID of the backend function to invoke
* @param params a ParameterList returned from {@link #createFastpathParameters}
* containing the parameters to pass to the backend function
*
* @return the binary-format result of the fastpath call, or null
* if a void result was returned
* @throws SQLException if an error occurs while executing the fastpath call
*/
byte[] 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.
* @throws SQLException when initializing the given query fails
*/
CopyOperation startCopy(String sql, boolean suppressBegin) throws SQLException;
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/ResultCursor.java 0000664 0000000 0000000 00000001500 12050675701 0025075 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
* 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-jdbc-9.2-1002.src/org/postgresql/core/ResultHandler.java 0000664 0000000 0000000 00000006050 12050675701 0025202 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
* Copyright (c) 2004, Open Cloud Limited.
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.core;
import java.sql.*;
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 be
* null 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, List tuples, ResultCursor cursor);
/**
* Called when a query that did not return a resultset completes.
*
* @param status the command status string (e.g. "SELECT") returned by
* the backend
* @param updateCount the number of rows affected by an INSERT, UPDATE,
* DELETE, FETCH, or MOVE command; -1 if not available.
* @param insertOID for a single-row INSERT query, the OID of the newly
* inserted row; 0 if not available.
*/
void handleCommandStatus(String status, int updateCount, long insertOID);
/**
* Called when a warning is emitted.
*
* @param warning the warning that occured.
*/
void handleWarning(SQLWarning warning);
/**
* Called when an error occurs. Subsequent queries are abandoned;
* in general the only calls between a handleError call and
* a subsequent handleCompletion call are handleError or handleWarning.
*
* @param error the error that occurred
*/
void handleError(SQLException error);
/**
* Called before a QueryExecutor method returns. This method
* may throw a SQLException if desired; if it does, the QueryExecutor
* method will propagate that exception to the original caller.
*
* @throws SQLException if the handler wishes the original method to
* throw an exception.
*/
void handleCompletion() throws SQLException;
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/SetupQueryRunner.java 0000664 0000000 0000000 00000005414 12050675701 0025751 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2003-2011, PostgreSQL Global Development Group
* Copyright (c) 2004, Open Cloud Limited.
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.core;
import java.util.List;
import java.sql.SQLWarning;
import java.sql.SQLException;
import org.postgresql.util.GT;
import org.postgresql.util.PSQLState;
import org.postgresql.util.PSQLException;
/**
* Poor man's Statement & ResultSet, used for initial queries while we're
* still initializing the system.
*/
public class SetupQueryRunner {
private static class SimpleResultHandler implements ResultHandler {
private SQLException error;
private List tuples;
private final ProtocolConnection protoConnection;
SimpleResultHandler(ProtocolConnection protoConnection) {
this.protoConnection = protoConnection;
}
List getResults() {
return tuples;
}
public void handleResultRows(Query fromQuery, Field[] fields, List tuples, ResultCursor cursor) {
this.tuples = tuples;
}
public void handleCommandStatus(String status, int updateCount, long insertOID) {
}
public void handleWarning(SQLWarning warning) {
// We ignore warnings. We assume we know what we're
// doing in the setup queries.
}
public void handleError(SQLException newError) {
if (error == null)
error = newError;
else
error.setNextException(newError);
}
public void handleCompletion() throws SQLException {
if (error != null)
throw error;
}
}
public static byte[][] run(ProtocolConnection protoConnection, String queryString, boolean wantResults) throws SQLException {
QueryExecutor executor = protoConnection.getQueryExecutor();
Query query = executor.createSimpleQuery(queryString);
SimpleResultHandler handler = new SimpleResultHandler(protoConnection);
int flags = QueryExecutor.QUERY_ONESHOT | QueryExecutor.QUERY_SUPPRESS_BEGIN;
if (!wantResults)
flags |= QueryExecutor.QUERY_NO_RESULTS | QueryExecutor.QUERY_NO_METADATA;
try
{
executor.execute(query, null, handler, 0, 0, flags);
}
finally
{
query.close();
}
if (!wantResults)
return null;
List tuples = handler.getResults();
if (tuples == null || tuples.size() != 1)
throw new PSQLException(GT.tr("An unexpected result was returned by a query."), PSQLState.CONNECTION_UNABLE_TO_CONNECT);
return (byte[][]) tuples.get(0);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/TypeInfo.java 0000664 0000000 0000000 00000005757 12050675701 0024200 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2008-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.core;
import java.sql.SQLException;
import java.util.Iterator;
public interface TypeInfo
{
public void addCoreType(String pgTypeName, Integer oid, Integer sqlType, String javaClass, Integer arrayOid);
public void addDataType(String type, Class klass) throws SQLException;
/**
* Look up the SQL typecode for a given type oid.
*
* @param oid the type's OID
* @return the SQL type code (a constant from {@link java.sql.Types})
* for the type
*/
public int getSQLType(int oid) throws SQLException;
/**
* Look up the SQL typecode for a given postgresql type name.
*
* @param pgTypeName the server type name to look up
* @return the SQL type code (a constant from {@link java.sql.Types})
* for the type
*/
public int getSQLType(String pgTypeName) throws SQLException;
/**
* Look up the oid for a given postgresql type name. This is
* the inverse of {@link #getPGType(int)}.
*
* @param pgTypeName the server type name to look up
* @return the type's OID, or 0 if unknown
*/
public int getPGType(String pgTypeName) throws SQLException;
/**
* Look up the postgresql type name for a given oid. This is the
* inverse of {@link #getPGType(String)}.
*
* @param oid the type's OID
* @return the server type name for that OID or null if unknown
*/
public String getPGType(int oid) throws SQLException;
/**
* Look up the oid of an array's base type given the array's type oid.
*
* @param oid the array type's OID
* @return the base type's OID, or 0 if unknown
*/
public int getPGArrayElement(int oid) throws SQLException;
/**
* Determine the oid of the given base postgresql type's array type
*
* @param elementTypeName the base type's
* @return the array type's OID, or 0 if unknown
*/
public int getPGArrayType(String elementTypeName) throws SQLException;
/**
* Determine the delimiter for the elements of the given array type oid.
*
* @param oid the array type's OID
* @return the base type's array type delimiter
*/
public char getArrayDelimiter(int oid) throws SQLException;
public Iterator getPGTypeNamesWithSQLTypes();
public Class getPGobject(String type);
public String getJavaClass(int oid) throws SQLException;
public String getTypeForAlias(String alias);
public int getPrecision(int oid, int typmod);
public int getScale(int oid, int typmod);
public boolean isCaseSensitive(int oid);
public boolean isSigned(int oid);
public int getDisplaySize(int oid, int typmod);
public int getMaximumPrecision(int oid);
public boolean requiresQuoting(int oid) throws SQLException;
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/UTF8Encoding.java 0000664 0000000 0000000 00000015271 12050675701 0024630 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2003-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.core;
import java.io.IOException;
import org.postgresql.util.GT;
class UTF8Encoding extends Encoding {
UTF8Encoding(String jvmEncoding) {
super(jvmEncoding);
}
private static final int MIN_2_BYTES = 0x80;
private static final int MIN_3_BYTES = 0x800;
private static final int MIN_4_BYTES = 0x10000;
private static final int MAX_CODE_POINT = 0x10ffff;
private char[] decoderArray = new char[1024];
// helper for decode
private final static void checkByte(int ch, int pos, int len) throws IOException {
if ((ch & 0xc0) != 0x80)
throw new IOException(GT.tr("Illegal UTF-8 sequence: byte {0} of {1} byte sequence is not 10xxxxxx: {2}",
new Object[] { new Integer(pos), new Integer(len), new Integer(ch) }));
}
private final static void checkMinimal(int ch, int minValue) throws IOException {
if (ch >= minValue)
return;
int actualLen;
switch (minValue) {
case MIN_2_BYTES:
actualLen = 2;
break;
case MIN_3_BYTES:
actualLen = 3;
break;
case MIN_4_BYTES:
actualLen = 4;
break;
default:
throw new IllegalArgumentException("unexpected minValue passed to checkMinimal: " + minValue);
}
int expectedLen;
if (ch < MIN_2_BYTES)
expectedLen = 1;
else if (ch < MIN_3_BYTES)
expectedLen = 2;
else if (ch < MIN_4_BYTES)
expectedLen = 3;
else
throw new IllegalArgumentException("unexpected ch passed to checkMinimal: " + ch);
throw new IOException(GT.tr("Illegal UTF-8 sequence: {0} bytes used to encode a {1} byte value: {2}",
new Object[] { new Integer(actualLen), new Integer(expectedLen), new Integer(ch) }));
}
/**
* Custom byte[] -> String conversion routine for UTF-8 only.
* This is about twice as fast as using the String(byte[],int,int,String)
* ctor, at least under JDK 1.4.2. The extra checks for illegal representations
* add about 10-15% overhead, but they seem worth it given the number of SQL_ASCII
* databases out there.
*
* @param data the array containing UTF8-encoded data
* @param offset the offset of the first byte in data to decode from
* @param length the number of bytes to decode
* @return a decoded string
* @throws IOException if something goes wrong
*/
public synchronized String decode(byte[] data, int offset, int length) throws IOException {
char[] cdata = decoderArray;
if (cdata.length < length)
cdata = decoderArray = new char[length];
int in = offset;
int out = 0;
int end = length + offset;
try
{
while (in < end)
{
int ch = data[in++] & 0xff;
// Convert UTF-8 to 21-bit codepoint.
if (ch < 0x80) {
// 0xxxxxxx -- length 1.
} else if (ch < 0xc0) {
// 10xxxxxx -- illegal!
throw new IOException(GT.tr("Illegal UTF-8 sequence: initial byte is {0}: {1}",
new Object[] { "10xxxxxx", new Integer(ch) }));
} else if (ch < 0xe0) {
// 110xxxxx 10xxxxxx
ch = ((ch & 0x1f) << 6);
checkByte(data[in], 2, 2);
ch = ch | (data[in++] & 0x3f);
checkMinimal(ch, MIN_2_BYTES);
} else if (ch < 0xf0) {
// 1110xxxx 10xxxxxx 10xxxxxx
ch = ((ch & 0x0f) << 12);
checkByte(data[in], 2, 3);
ch = ch | ((data[in++] & 0x3f) << 6);
checkByte(data[in], 3, 3);
ch = ch | (data[in++] & 0x3f);
checkMinimal(ch, MIN_3_BYTES);
} else if (ch < 0xf8) {
// 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
ch = ((ch & 0x07) << 18);
checkByte(data[in], 2, 4);
ch = ch | ((data[in++] & 0x3f) << 12);
checkByte(data[in], 3, 4);
ch = ch | ((data[in++] & 0x3f) << 6);
checkByte(data[in], 4, 4);
ch = ch | (data[in++] & 0x3f);
checkMinimal(ch, MIN_4_BYTES);
} else {
throw new IOException(GT.tr("Illegal UTF-8 sequence: initial byte is {0}: {1}",
new Object[] { "11111xxx", new Integer(ch) }));
}
if (ch > MAX_CODE_POINT)
throw new IOException(GT.tr("Illegal UTF-8 sequence: final value is out of range: {0}",
new Integer(ch)));
// Convert 21-bit codepoint to Java chars:
// 0..ffff are represented directly as a single char
// 10000..10ffff are represented as a "surrogate pair" of two chars
// See: http://java.sun.com/developer/technicalArticles/Intl/Supplementary/
if (ch > 0xffff) {
// Use a surrogate pair to represent it.
ch -= 0x10000; // ch is now 0..fffff (20 bits)
cdata[out++] = (char) (0xd800 + (ch >> 10)); // top 10 bits
cdata[out++] = (char) (0xdc00 + (ch & 0x3ff)); // bottom 10 bits
} else if (ch >= 0xd800 && ch < 0xe000) {
// Not allowed to encode the surrogate range directly.
throw new IOException(GT.tr("Illegal UTF-8 sequence: final value is a surrogate value: {0}",
new Integer(ch)));
} else {
// Normal case.
cdata[out++] = (char) ch;
}
}
}
catch (ArrayIndexOutOfBoundsException a)
{
throw new IOException("Illegal UTF-8 sequence: multibyte sequence was truncated");
}
// Check if we ran past the end without seeing an exception.
if (in > end)
throw new IOException("Illegal UTF-8 sequence: multibyte sequence was truncated");
return new String(cdata, 0, out);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/Utils.java 0000664 0000000 0000000 00000013426 12050675701 0023533 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
* Copyright (c) 2004, Open Cloud Limited.
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.core;
import java.sql.SQLException;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import org.postgresql.util.GT;
import org.postgresql.util.PSQLException;
import org.postgresql.util.PSQLState;
/**
* 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 data
*/
public static String toHexString(byte[] data) {
StringBuffer sb = new StringBuffer(data.length * 2);
for (int i = 0; i < data.length; ++i)
{
sb.append(Integer.toHexString((data[i] >> 4) & 15));
sb.append(Integer.toHexString(data[i] & 15));
}
return sb.toString();
}
/**
* Keep a local copy of the UTF-8 Charset so we can avoid
* synchronization overhead from looking up the Charset by
* name as String.getBytes(String) requires.
*/
private final static Charset utf8Charset = Charset.forName("UTF-8");
/**
* Encode a string as UTF-8.
*
* @param str the string to encode
* @return the UTF-8 representation of str
*/
public static byte[] encodeUTF8(String str) {
// Previously we just used str.getBytes("UTF-8"), but when
// the JVM is using more than one encoding the lookup cost
// makes that a loser to the below (even in the single thread case).
// When multiple threads are doing Charset lookups, they all get
// blocked and must wait, severely dropping throughput.
//
ByteBuffer buf = utf8Charset.encode(CharBuffer.wrap(str));
byte b[] = new byte[buf.limit()];
buf.get(b, 0, buf.limit());
return b;
}
/**
* Escape the given literal value and append it to the string buffer
* sbuf. If sbuf is null, a new StringBuffer will be
* returned. The argument standardConformingStrings defines whether the
* backend expects standard-conforming string literals or allows backslash
* escape sequences.
*
* @param sbuf the string buffer to append to; or null
* @param value the string value
* @param standardConformingStrings
* @return the sbuf argument; or a new string buffer for sbuf == null
* @throws SQLException if the string contains a \0 character
*/
public static StringBuffer appendEscapedLiteral(StringBuffer sbuf, String value,
boolean standardConformingStrings)
throws SQLException {
if (sbuf == null)
sbuf = new StringBuffer(value.length() * 11 / 10); // Add 10% for escaping.
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);
}
}
return sbuf;
}
/**
* Escape the given identifier value and append it to the string
* buffer * sbuf. If sbuf is null, a new
* StringBuffer will be returned. This method is different from
* appendEscapedLiteral in that it includes the quoting required for the
* identifier while appendEscapedLiteral does not.
*
* @param sbuf the string buffer to append to; or null
* @param value the string value
* @return the sbuf argument; or a new string buffer for sbuf == null
* @throws SQLException if the string contains a \0 character
*/
public static StringBuffer appendEscapedIdentifier(StringBuffer sbuf, String value)
throws SQLException {
if (sbuf == null)
sbuf = new StringBuffer(2 + value.length() * 11 / 10); // Add 10% for escaping.
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('"');
return sbuf;
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/VisibleBufferedInputStream.java 0000664 0000000 0000000 00000020100 12050675701 0027652 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2006-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.core;
import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;
/**
* 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;
/**
* 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}
*/
public int read() throws IOException {
if (ensureBytes(1)) {
return buffer[index++] & 0xFF;
}
return -1;
}
/**
* Reads a byte from the buffer without advancing the index pointer.
*/
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 underlaying 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 {
int required = n - endIndex + index;
while (required > 0) {
if (!readMore(required)) {
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) 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 = wrapped.read(buffer, endIndex, canFit);
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 begining 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}
*/
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 = wrapped.read(to, off, len);
if (r <= 0) {
return (read == 0) ? r : read;
}
read += r;
off += r;
len -= r;
} while (len > 0);
return read;
}
/**
* {@inheritDoc}
*/
public long skip(long n) throws IOException {
int avail = endIndex - index;
if (avail >= n) {
index += n;
return n;
}
n -= avail;
index = 0;
endIndex = 0;
return avail + wrapped.skip(n);
}
/**
* {@inheritDoc}
*/
public int available() throws IOException {
int avail = endIndex - index;
return avail > 0 ? avail : wrapped.available();
}
/**
* {@inheritDoc}
*/
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 underlaying 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 EOFxception If the stream did not contain any null terminators.
*/
public int scanCStringLength() throws IOException {
int pos = index;
for (;;) {
while (pos < endIndex) {
if (buffer[pos++] == '\0') {
return pos - index;
}
}
if (!readMore(STRING_SCAN_SPAN)) {
throw new EOFException();
}
pos = index;
}
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/types/ 0000775 0000000 0000000 00000000000 12050675701 0022726 5 ustar 00root root 0000000 0000000 postgresql-jdbc-9.2-1002.src/org/postgresql/core/types/PGBigDecimal.java 0000664 0000000 0000000 00000004234 12050675701 0026003 0 ustar 00root root 0000000 0000000 /*
* Created on May 15, 2005
*
* TODO To change the template for this generated file go to
* Window - Preferences - Java - Code Style - Code Templates
*/
package org.postgresql.core.types;
import java.math.BigDecimal;
import java.sql.Types;
import org.postgresql.util.GT;
import org.postgresql.util.PSQLException;
import org.postgresql.util.PSQLState;
/**
* @author davec
*
* TODO To change the template for this generated type comment go to
* Window - Preferences - Java - Code Style - Code Templates
*/
public class PGBigDecimal implements PGType
{
private BigDecimal val;
protected PGBigDecimal( BigDecimal x )
{
// ensure the value is a valid numeric value to avoid
// sql injection attacks
val = new BigDecimal(x.toString());
}
public static PGType castToServerType( BigDecimal val, int targetType ) throws PSQLException
{
try
{
switch ( targetType )
{
case Types.BIT:
return new PGBoolean( val.doubleValue() == 0?Boolean.FALSE:Boolean.TRUE );
case Types.BIGINT:
return new PGLong( new Long( val.longValue() ) );
case Types.INTEGER:
return new PGInteger( new Integer( val.intValue() ) ) ;
case Types.SMALLINT:
case Types.TINYINT:
return new PGShort( new Short( val.shortValue() ) );
case Types.VARCHAR:
case Types.LONGVARCHAR:
return new PGString( val.toString() );
case Types.DECIMAL:
case Types.NUMERIC:
case Types.DOUBLE:
case Types.FLOAT:
case Types.REAL:
return new PGBigDecimal( val );
default:
return new PGUnknown(val);
}
}
catch( Exception ex )
{
throw new PSQLException(GT.tr("Cannot convert an instance of {0} to type {1}", new Object[]{val.getClass().getName(),"Types.OTHER"}), PSQLState.INVALID_PARAMETER_TYPE, ex);
}
}
public String toString()
{
return val.toString();
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/types/PGBoolean.java 0000664 0000000 0000000 00000004317 12050675701 0025404 0 ustar 00root root 0000000 0000000 /*
* Created on May 15, 2005
*
* TODO To change the template for this generated file go to
* Window - Preferences - Java - Code Style - Code Templates
*/
package org.postgresql.core.types;
import java.sql.Types;
import org.postgresql.util.GT;
import org.postgresql.util.PSQLException;
import org.postgresql.util.PSQLState;
/**
* @author davec
*
* TODO To change the template for this generated type comment go to
* Window - Preferences - Java - Code Style - Code Templates
*/
public class PGBoolean implements PGType
{
private Boolean val;
public PGBoolean(Boolean x)
{
val = x;
}
public static PGType castToServerType( Boolean val, int targetType ) throws PSQLException
{
try
{
switch ( targetType )
{
case Types.BIGINT:
return new PGLong(new Long( val.booleanValue()==true?1:0 ));
case Types.INTEGER:
return new PGInteger( new Integer( val.booleanValue()==true?1:0 ) );
case Types.SMALLINT:
case Types.TINYINT:
return new PGShort( new Short( val.booleanValue()==true?(short)1:(short)0 ) );
case Types.VARCHAR:
case Types.LONGVARCHAR:
return new PGString( val.booleanValue()==true?"true":"false" );
case Types.DOUBLE:
case Types.FLOAT:
return new PGDouble( new Double(val.booleanValue()==true?1:0));
case Types.REAL:
return new PGFloat( new Float(val.booleanValue()==true?1:0));
case Types.NUMERIC:
case Types.DECIMAL:
return new PGBigDecimal( new java.math.BigDecimal(val.booleanValue()==true?1:0));
case Types.BIT:
return new PGBoolean( val );
default:
return new PGUnknown( val );
}
}
catch(Exception ex)
{
throw new PSQLException(GT.tr("Cannot convert an instance of {0} to type {1}", new Object[]{val.getClass().getName(),"Types.OTHER"}), PSQLState.INVALID_PARAMETER_TYPE, ex);
}
}
public String toString()
{
return val.booleanValue()==true?"true":"false";
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/types/PGByte.java 0000664 0000000 0000000 00000004032 12050675701 0024722 0 ustar 00root root 0000000 0000000 /*
* Created on May 15, 2005
*
* TODO To change the template for this generated file go to
* Window - Preferences - Java - Code Style - Code Templates
*/
package org.postgresql.core.types;
import java.math.BigDecimal;
import java.sql.Types;
import org.postgresql.util.GT;
import org.postgresql.util.PSQLException;
import org.postgresql.util.PSQLState;
/**
* @author davec
*
* TODO To change the template for this generated type comment go to
* Window - Preferences - Java - Code Style - Code Templates
*/
public class PGByte implements PGType
{
private Byte val;
public PGByte( Byte x )
{
val = x;
}
/* (non-Javadoc)
* @see org.postgresql.types.PGType#castToServerType(int)
*/
public static PGType castToServerType(Byte val, int targetType) throws PSQLException
{
try
{
switch ( targetType )
{
case Types.BIT:
return new PGBoolean( val.byteValue() == 0?Boolean.FALSE:Boolean.TRUE );
case Types.SMALLINT:
case Types.TINYINT:
return new PGByte( val );
case Types.REAL:
return new PGFloat( new Float( val.floatValue() ) );
case Types.DOUBLE:
case Types.FLOAT:
return new PGDouble( new Double( val.doubleValue() ) );
case Types.NUMERIC:
case Types.DECIMAL:
return new PGBigDecimal( new BigDecimal(val.toString()) );
case Types.VARCHAR:
case Types.LONGVARCHAR:
return new PGString ( val.toString() );
default:
return new PGUnknown(val);
}
}
catch( Exception ex )
{
throw new PSQLException(GT.tr("Cannot convert an instance of {0} to type {1}", new Object[]{val.getClass().getName(),"Types.OTHER"}), PSQLState.INVALID_PARAMETER_TYPE, ex);
}
}
public String toString()
{
return val.toString();
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/types/PGDouble.java 0000664 0000000 0000000 00000004234 12050675701 0025235 0 ustar 00root root 0000000 0000000 /*
* Created on May 15, 2005
*
* TODO To change the template for this generated file go to
* Window - Preferences - Java - Code Style - Code Templates
*/
package org.postgresql.core.types;
import java.math.BigDecimal;
import java.sql.Types;
import org.postgresql.util.GT;
import org.postgresql.util.PSQLException;
import org.postgresql.util.PSQLState;
/**
* @author davec
*
* TODO To change the template for this generated type comment go to
* Window - Preferences - Java - Code Style - Code Templates
*/
public class PGDouble implements PGType
{
private Double val;
protected PGDouble( Double x )
{
val = x;
}
public static PGType castToServerType( Double val, int targetType ) throws PSQLException
{
try
{
switch ( targetType )
{
case Types.BIT:
return new PGBoolean( val.doubleValue() == 0?Boolean.FALSE:Boolean.TRUE );
case Types.BIGINT:
return new PGLong( new Long( val.longValue() ) );
case Types.INTEGER:
return new PGInteger( new Integer( val.intValue() ) ) ;
case Types.SMALLINT:
case Types.TINYINT:
return new PGShort( new Short( val.shortValue() ) );
case Types.VARCHAR:
case Types.LONGVARCHAR:
return new PGString( val.toString() );
case Types.DOUBLE:
case Types.FLOAT:
return new PGDouble( val );
case Types.REAL:
return new PGFloat( new Float( val.floatValue()));
case Types.DECIMAL:
case Types.NUMERIC:
return new PGBigDecimal( new BigDecimal( val.toString()));
default:
return new PGUnknown(val);
}
}
catch( Exception ex )
{
throw new PSQLException(GT.tr("Cannot convert an instance of {0} to type {1}", new Object[]{val.getClass().getName(),"Types.OTHER"}), PSQLState.INVALID_PARAMETER_TYPE, ex);
}
}
public String toString()
{
return val.toString();
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/types/PGFloat.java 0000664 0000000 0000000 00000004236 12050675701 0025072 0 ustar 00root root 0000000 0000000 /*
* Created on May 15, 2005
*
* TODO To change the template for this generated file go to
* Window - Preferences - Java - Code Style - Code Templates
*/
package org.postgresql.core.types;
import java.math.BigDecimal;
import java.sql.Types;
import org.postgresql.util.GT;
import org.postgresql.util.PSQLException;
import org.postgresql.util.PSQLState;
/**
* @author davec
*
* TODO To change the template for this generated type comment go to
* Window - Preferences - Java - Code Style - Code Templates
*/
public class PGFloat implements PGType
{
private Float val;
protected PGFloat( Float x )
{
val = x;
}
public static PGType castToServerType( Float val, int targetType ) throws PSQLException
{
try
{
switch ( targetType )
{
case Types.BIT:
return new PGBoolean( val.floatValue() == 0?Boolean.FALSE:Boolean.TRUE );
case Types.BIGINT:
return new PGLong(new Long( val.longValue() ));
case Types.INTEGER:
return new PGInteger(new Integer( val.intValue() ) );
case Types.SMALLINT:
case Types.TINYINT:
return new PGShort(new Short( val.shortValue() ));
case Types.VARCHAR:
case Types.LONGVARCHAR:
return new PGString( val.toString() );
case Types.DOUBLE:
case Types.FLOAT:
return( new PGDouble( new Double( val.doubleValue())));
case Types.REAL:
return new PGFloat( val );
case Types.DECIMAL:
case Types.NUMERIC:
return new PGBigDecimal( new BigDecimal( val.toString()));
default:
return new PGUnknown(val);
}
}
catch( Exception ex)
{
throw new PSQLException(GT.tr("Cannot convert an instance of {0} to type {1}", new Object[]{val.getClass().getName(),"Types.OTHER"}), PSQLState.INVALID_PARAMETER_TYPE, ex);
}
}
public String toString()
{
return val.toString();
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/types/PGInteger.java 0000664 0000000 0000000 00000004050 12050675701 0025414 0 ustar 00root root 0000000 0000000 /*
* Created on May 15, 2005
*
* TODO To change the template for this generated file go to
* Window - Preferences - Java - Code Style - Code Templates
*/
package org.postgresql.core.types;
import java.math.BigDecimal;
import java.sql.Types;
import org.postgresql.util.GT;
import org.postgresql.util.PSQLException;
import org.postgresql.util.PSQLState;
/**
* @author davec
*
* TODO To change the template for this generated type comment go to
* Window - Preferences - Java - Code Style - Code Templates
*/
public class PGInteger implements PGType
{
private Integer val;
protected PGInteger( Integer x )
{
val = x;
}
public static PGType castToServerType( Integer val, int targetType ) throws PSQLException
{
try
{
switch ( targetType )
{
case Types.BIT:
return new PGBoolean( val.intValue() == 0?Boolean.FALSE:Boolean.TRUE );
case Types.REAL:
return new PGFloat( new Float( val.floatValue() ) );
case Types.DOUBLE:
case Types.FLOAT:
return new PGDouble(new Double( val.doubleValue() ));
case Types.VARCHAR:
case Types.LONGVARCHAR:
return new PGString( val.toString() );
case Types.SMALLINT:
case Types.TINYINT:
return new PGShort( new Short( val.shortValue() ));
case Types.INTEGER:
return new PGInteger( val );
case Types.DECIMAL:
case Types.NUMERIC:
return new PGBigDecimal( new BigDecimal( val.toString()));
default:
return new PGUnknown(val);
}
}
catch( Exception ex )
{
throw new PSQLException(GT.tr("Cannot convert an instance of {0} to type {1}", new Object[]{val.getClass().getName(),"Types.OTHER"}), PSQLState.INVALID_PARAMETER_TYPE, ex);
}
}
public String toString()
{
return val.toString();
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/types/PGLong.java 0000664 0000000 0000000 00000004165 12050675701 0024725 0 ustar 00root root 0000000 0000000 /*
* Created on May 15, 2005
*
* TODO To change the template for this generated file go to
* Window - Preferences - Java - Code Style - Code Templates
*/
package org.postgresql.core.types;
import java.math.BigDecimal;
import java.sql.Types;
import org.postgresql.util.GT;
import org.postgresql.util.PSQLException;
import org.postgresql.util.PSQLState;
/**
* @author davec
*
* TODO To change the template for this generated type comment go to
* Window - Preferences - Java - Code Style - Code Templates
*/
public class PGLong implements PGType
{
private Long val;
protected PGLong( Long x )
{
val = x;
}
public static PGType castToServerType(Long val, int targetType ) throws PSQLException
{
try
{
switch ( targetType )
{
case Types.BIT:
return new PGBoolean(val.longValue()==0?Boolean.FALSE:Boolean.TRUE);
case Types.REAL:
return new PGFloat( new Float(val.floatValue()) );
case Types.FLOAT:
case Types.DOUBLE:
return new PGDouble( new Double(val.doubleValue()) );
case Types.VARCHAR:
case Types.LONGVARCHAR:
return new PGString(val.toString());
case Types.BIGINT:
return new PGLong( val );
case Types.INTEGER:
return new PGInteger( new Integer( val.intValue()));
case Types.SMALLINT:
case Types.TINYINT:
return new PGShort( new Short( val.shortValue() ));
case Types.DECIMAL:
case Types.NUMERIC:
return new PGBigDecimal( new BigDecimal( val.toString()));
default:
return new PGUnknown(val);
}
}
catch( Exception ex )
{
throw new PSQLException(GT.tr("Cannot convert an instance of {0} to type {1}", new Object[]{val.getClass().getName(),"Types.OTHER"}), PSQLState.INVALID_PARAMETER_TYPE, ex);
}
}
public String toString()
{
return val.toString();
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/types/PGNumber.java 0000664 0000000 0000000 00000004204 12050675701 0025250 0 ustar 00root root 0000000 0000000 /*
* Created on May 15, 2005
*
* TODO To change the template for this generated file go to
* Window - Preferences - Java - Code Style - Code Templates
*/
package org.postgresql.core.types;
import java.sql.Types;
import org.postgresql.util.GT;
import org.postgresql.util.PSQLException;
import org.postgresql.util.PSQLState;
/**
* @author davec
*
* TODO To change the template for this generated type comment go to
* Window - Preferences - Java - Code Style - Code Templates
*/
public class PGNumber implements PGType
{
private Number val;
protected PGNumber( Number x )
{
val = x;
}
public static PGType castToServerType( Number val, int targetType ) throws PSQLException
{
try
{
switch ( targetType )
{
case Types.BIT:
return new PGBoolean( val.doubleValue() == 0?Boolean.FALSE:Boolean.TRUE );
case Types.BIGINT:
return new PGLong(new Long( val.longValue() ));
case Types.INTEGER:
return new PGInteger(new Integer( val.intValue() ) );
case Types.TINYINT:
case Types.SMALLINT:
return new PGShort(new Short( val.shortValue() ));
case Types.VARCHAR:
case Types.LONGVARCHAR:
return new PGString( val.toString() );
case Types.DOUBLE:
case Types.FLOAT:
return( new PGDouble( new Double( val.doubleValue())));
case Types.REAL:
return (new PGFloat( new Float( val.floatValue())));
case Types.DECIMAL:
case Types.NUMERIC:
return new PGNumber( val );
default:
return new PGUnknown(val);
}
}
catch( Exception ex )
{
throw new PSQLException(GT.tr("Cannot convert an instance of {0} to type {1}", new Object[]{val.getClass().getName(),"Types.OTHER"}), PSQLState.INVALID_PARAMETER_TYPE, ex);
}
}
public String toString()
{
return val.toString();
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/types/PGShort.java 0000664 0000000 0000000 00000003674 12050675701 0025131 0 ustar 00root root 0000000 0000000 /*
* Created on May 15, 2005
*
* TODO To change the template for this generated file go to
* Window - Preferences - Java - Code Style - Code Templates
*/
package org.postgresql.core.types;
import java.math.BigDecimal;
import java.sql.Types;
import org.postgresql.util.GT;
import org.postgresql.util.PSQLException;
import org.postgresql.util.PSQLState;
/**
* @author davec
*
* TODO To change the template for this generated type comment go to
* Window - Preferences - Java - Code Style - Code Templates
*/
public class PGShort implements PGType
{
Short val;
protected PGShort( Short x )
{
val = x;
}
public static PGType castToServerType( Short val, int targetType ) throws PSQLException
{
try
{
switch ( targetType )
{
case Types.BIT:
return new PGBoolean( val.shortValue() == 0?Boolean.FALSE:Boolean.TRUE );
case Types.SMALLINT:
case Types.TINYINT:
return new PGShort(val);
case Types.REAL:
return new PGFloat( new Float( val.floatValue() ) );
case Types.DOUBLE:
case Types.FLOAT:
return new PGDouble( new Double( val.doubleValue() ) );
case Types.VARCHAR:
case Types.LONGVARCHAR:
return new PGString ( val.toString() );
case Types.DECIMAL:
case Types.NUMERIC:
return new PGBigDecimal( new BigDecimal( val.toString()));
default:
return new PGUnknown(val);
}
}
catch (Exception ex)
{
throw new PSQLException(GT.tr("Cannot convert an instance of {0} to type {1}", new Object[]{val.getClass().getName(),"Types.OTHER"}), PSQLState.INVALID_PARAMETER_TYPE, ex);
}
}
public String toString()
{
return val.toString();
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/types/PGString.java 0000664 0000000 0000000 00000005066 12050675701 0025275 0 ustar 00root root 0000000 0000000 /*
* Created on May 15, 2005
*
* TODO To change the template for this generated file go to
* Window - Preferences - Java - Code Style - Code Templates
*/
package org.postgresql.core.types;
import java.math.BigDecimal;
import java.sql.Types;
import org.postgresql.util.GT;
import org.postgresql.util.PSQLException;
import org.postgresql.util.PSQLState;
/**
* @author davec
*
* TODO To change the template for this generated type comment go to
* Window - Preferences - Java - Code Style - Code Templates
*/
public class PGString implements PGType
{
String val;
protected PGString( String x )
{
val = x;
}
/* (non-Javadoc)
* @see org.postgresql.types.PGType#castToServerType(int)
*/
public static PGType castToServerType(String val, int targetType) throws PSQLException
{
try
{
switch (targetType )
{
case Types.BIT:
{
if ( val.equalsIgnoreCase("true") || val.equalsIgnoreCase("1") || val.equalsIgnoreCase("t"))
return new PGBoolean( Boolean.TRUE );
if ( val.equalsIgnoreCase("false") || val.equalsIgnoreCase("0") || val.equalsIgnoreCase("f"))
return new PGBoolean( Boolean.FALSE);
}
return new PGBoolean( Boolean.FALSE);
case Types.VARCHAR:
case Types.LONGVARCHAR:
return new PGString(val);
case Types.BIGINT:
return new PGLong( new Long(Long.parseLong( val )));
case Types.INTEGER:
return new PGInteger( new Integer(Integer.parseInt( val )));
case Types.TINYINT:
return new PGShort( new Short( Short.parseShort( val )));
case Types.FLOAT:
case Types.DOUBLE:
return new PGDouble( new Double(Double.parseDouble( val )));
case Types.REAL:
return new PGFloat( new Float( Float.parseFloat( val )));
case Types.NUMERIC:
case Types.DECIMAL:
return new PGBigDecimal( new BigDecimal( val));
default:
return new PGUnknown( val );
}
}
catch( Exception ex )
{
throw new PSQLException(GT.tr("Cannot convert an instance of {0} to type {1}", new Object[]{val.getClass().getName(),"Types.OTHER"}), PSQLState.INVALID_PARAMETER_TYPE, ex);
}
}
public String toString()
{
return val;
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/types/PGType.java 0000664 0000000 0000000 00000000633 12050675701 0024743 0 ustar 00root root 0000000 0000000 /*
* Created on May 15, 2005
*
* TODO To change the template for this generated file go to
* Window - Preferences - Java - Code Style - Code Templates
*/
package org.postgresql.core.types;
/**
* @author davec
*
* TODO To change the template for this generated type comment go to
* Window - Preferences - Java - Code Style - Code Templates
*/
public interface PGType
{
public String toString();
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/types/PGUnknown.java 0000664 0000000 0000000 00000001370 12050675701 0025460 0 ustar 00root root 0000000 0000000 /*
* Created on May 15, 2005
*
* TODO To change the template for this generated file go to
* Window - Preferences - Java - Code Style - Code Templates
*/
package org.postgresql.core.types;
/**
* @author davec
*
* TODO To change the template for this generated type comment go to
* Window - Preferences - Java - Code Style - Code Templates
*/
public class PGUnknown implements PGType
{
/* (non-Javadoc)
* @see org.postgresql.types.PGType#castToServerType(int)
*/
Object val;
public PGUnknown( Object x)
{
val = x;
}
public static PGType castToServerType(Object val, int targetType)
{
return new PGUnknown( val );
}
public String toString()
{
return val.toString();
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/v2/ 0000775 0000000 0000000 00000000000 12050675701 0022111 5 ustar 00root root 0000000 0000000 postgresql-jdbc-9.2-1002.src/org/postgresql/core/v2/ConnectionFactoryImpl.java 0000664 0000000 0000000 00000046016 12050675701 0027234 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2003-2011, PostgreSQL Global Development Group
* Copyright (c) 2004, Open Cloud Limited.
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.core.v2;
import java.util.Properties;
import java.util.StringTokenizer;
import java.sql.SQLException;
import java.sql.SQLWarning;
import java.io.IOException;
import java.net.ConnectException;
import org.postgresql.core.*;
import org.postgresql.util.PSQLException;
import org.postgresql.util.PSQLState;
import org.postgresql.util.UnixCrypt;
import org.postgresql.util.MD5Digest;
import org.postgresql.util.GT;
import org.postgresql.util.HostSpec;
/**
* ConnectionFactory implementation for version 2 (pre-7.4) connections.
*
* @author Oliver Jowett (oliver@opencloud.com), based on the previous implementation
*/
public class ConnectionFactoryImpl extends ConnectionFactory {
private static final int AUTH_REQ_OK = 0;
private static final int AUTH_REQ_KRB4 = 1;
private static final int AUTH_REQ_KRB5 = 2;
private static final int AUTH_REQ_PASSWORD = 3;
private static final int AUTH_REQ_CRYPT = 4;
private static final int AUTH_REQ_MD5 = 5;
private static final int AUTH_REQ_SCM = 6;
public ProtocolConnection openConnectionImpl(HostSpec[] hostSpecs, String user, String database, Properties info, Logger logger) throws SQLException {
// Extract interesting values from the info properties:
// - the SSL setting
boolean requireSSL;
boolean trySSL;
String sslmode = info.getProperty("sslmode");
if (sslmode==null)
{ //Fall back to the ssl property
requireSSL = trySSL = (info.getProperty("ssl") != null);
} else {
if ("disable".equals(sslmode))
{
requireSSL = trySSL = false;
}
//allow and prefer are not handled yet
/*else if ("allow".equals(sslmode) || "prefer".equals(sslmode))
{
//XXX Allow and prefer are treated the same way
requireSSL = false;
trySSL = true;
}*/
else if ("require".equals(sslmode) || "verify-ca".equals(sslmode) || "verify-full".equals(sslmode))
{
requireSSL = trySSL = true;
} else {
throw new PSQLException (GT.tr("Invalid sslmode value: {0}", sslmode), PSQLState.CONNECTION_UNABLE_TO_CONNECT);
}
}
// - the TCP keep alive setting
boolean requireTCPKeepAlive = (Boolean.valueOf(info.getProperty("tcpKeepAlive")).booleanValue());
for (int whichHost = 0; whichHost < hostSpecs.length; ++whichHost) {
HostSpec hostSpec = hostSpecs[whichHost];
if (logger.logDebug())
logger.debug("Trying to establish a protocol version 2 connection to " + hostSpec);
//
// Establish a connection.
//
PGStream newStream = null;
try
{
newStream = new PGStream(hostSpec);
// Construct and send an ssl startup packet if requested.
if (trySSL)
newStream = enableSSL(newStream, requireSSL, info, logger);
// Set the socket timeout if the "socketTimeout" property has been set.
String socketTimeoutProperty = info.getProperty("socketTimeout", "0");
try {
int socketTimeout = Integer.parseInt(socketTimeoutProperty);
if (socketTimeout > 0) {
newStream.getSocket().setSoTimeout(socketTimeout*1000);
}
} catch (NumberFormatException nfe) {
logger.info("Couldn't parse socketTimeout value:" + socketTimeoutProperty);
}
// Enable TCP keep-alive probe if required.
newStream.getSocket().setKeepAlive(requireTCPKeepAlive);
// Construct and send a startup packet.
sendStartupPacket(newStream, user, database, logger);
// Do authentication (until AuthenticationOk).
doAuthentication(newStream, user, info.getProperty("password"), logger);
// Do final startup.
ProtocolConnectionImpl protoConnection = new ProtocolConnectionImpl(newStream, user, database, logger);
readStartupMessages(newStream, protoConnection, logger);
// Run some initial queries
runInitialQueries(protoConnection, info, logger);
// And we're done.
return protoConnection;
}
catch (ConnectException cex)
{
// Added by Peter Mount
// ConnectException is thrown when the connection cannot be made.
// we trap this an return a more meaningful message for the end user
if (whichHost + 1 < hostSpecs.length) {
// still more addresses to try
continue;
}
throw new PSQLException (GT.tr("Connection refused. Check that the hostname and port are correct and that the postmaster is accepting TCP/IP connections."), PSQLState.CONNECTION_UNABLE_TO_CONNECT, cex);
}
catch (IOException ioe)
{
if (newStream != null)
{
try
{
newStream.close();
}
catch (IOException e)
{
}
}
if (whichHost + 1 < hostSpecs.length) {
// still more addresses to try
continue;
}
throw new PSQLException (GT.tr("The connection attempt failed."), PSQLState.CONNECTION_UNABLE_TO_CONNECT, ioe);
}
catch (SQLException se)
{
if (newStream != null)
{
try
{
newStream.close();
}
catch (IOException e)
{
}
}
if (whichHost + 1 < hostSpecs.length) {
// still more addresses to try
continue;
}
throw se;
}
}
throw new PSQLException (GT.tr("The connection url is invalid."), PSQLState.CONNECTION_UNABLE_TO_CONNECT);
}
private PGStream enableSSL(PGStream pgStream, boolean requireSSL, Properties info, Logger logger) throws IOException, SQLException {
if (logger.logDebug())
logger.debug(" FE=> SSLRequest");
// Send SSL request packet
pgStream.SendInteger4(8);
pgStream.SendInteger2(1234);
pgStream.SendInteger2(5679);
pgStream.flush();
// Now get the response from the backend, one of N, E, S.
int beresp = pgStream.ReceiveChar();
switch (beresp)
{
case 'E':
if (logger.logDebug())
logger.debug(" <=BE SSLError");
// Server doesn't even know about the SSL handshake protocol
if (requireSSL)
throw new PSQLException(GT.tr("The server does not support SSL."), PSQLState.CONNECTION_REJECTED);
// We have to reconnect to continue.
pgStream.close();
return new PGStream(pgStream.getHostSpec());
case 'N':
if (logger.logDebug())
logger.debug(" <=BE SSLRefused");
// Server does not support ssl
if (requireSSL)
throw new PSQLException(GT.tr("The server does not support SSL."), PSQLState.CONNECTION_REJECTED);
return pgStream;
case 'S':
if (logger.logDebug())
logger.debug(" <=BE SSLOk");
// Server supports ssl
org.postgresql.ssl.MakeSSL.convert(pgStream, info, logger);
return pgStream;
default:
throw new PSQLException(GT.tr("An error occured while setting up the SSL connection."), PSQLState.PROTOCOL_VIOLATION);
}
}
private void sendStartupPacket(PGStream pgStream, String user, String database, Logger logger) throws IOException {
// 4: total size including self
// 2: protocol major
// 2: protocol minor
// 64: database name
// 32: user name
// 64: options
// 64: unused
// 64: tty
if (logger.logDebug())
logger.debug(" FE=> StartupPacket(user=" + user + ",database=" + database + ")");
pgStream.SendInteger4(4 + 4 + 64 + 32 + 64 + 64 + 64);
pgStream.SendInteger2(2); // protocol major
pgStream.SendInteger2(0); // protocol minor
pgStream.Send(database.getBytes("UTF-8"), 64);
pgStream.Send(user.getBytes("UTF-8"), 32);
pgStream.Send(new byte[64]); // options
pgStream.Send(new byte[64]); // unused
pgStream.Send(new byte[64]); // tty
pgStream.flush();
}
private void doAuthentication(PGStream pgStream, String user, String password, Logger logger) throws IOException, SQLException
{
// Now get the response from the backend, either an error message
// or an authentication request
while (true)
{
int beresp = pgStream.ReceiveChar();
switch (beresp)
{
case 'E':
// An error occured, so pass the error message to the
// user.
//
// The most common one to be thrown here is:
// "User authentication failed"
//
String errorMsg = pgStream.ReceiveString();
if (logger.logDebug())
logger.debug(" <=BE ErrorMessage(" + errorMsg + ")");
throw new PSQLException(GT.tr("Connection rejected: {0}.", errorMsg), PSQLState.CONNECTION_REJECTED);
case 'R':
// Authentication request.
// Get the type of request
int areq = pgStream.ReceiveInteger4();
// Process the request.
switch (areq)
{
case AUTH_REQ_CRYPT:
{
byte salt[] = pgStream.Receive(2);
if (logger.logDebug())
logger.debug(" <=BE AuthenticationReqCrypt(salt='" + new String(salt, "US-ASCII") + "')");
if (password == null)
throw new PSQLException(GT.tr("The server requested password-based authentication, but no password was provided."), PSQLState.CONNECTION_REJECTED);
byte[] encodedResult = UnixCrypt.crypt(salt, password.getBytes("UTF-8"));
if (logger.logDebug())
logger.debug(" FE=> Password(crypt='" + new String(encodedResult, "US-ASCII") + "')");
pgStream.SendInteger4(4 + encodedResult.length + 1);
pgStream.Send(encodedResult);
pgStream.SendChar(0);
pgStream.flush();
break;
}
case AUTH_REQ_MD5:
{
byte[] md5Salt = pgStream.Receive(4);
if (logger.logDebug())
logger.debug(" <=BE AuthenticationReqMD5(salt=" + Utils.toHexString(md5Salt) + ")");
if (password == null)
throw new PSQLException(GT.tr("The server requested password-based authentication, but no password was provided."), PSQLState.CONNECTION_REJECTED);
byte[] digest = MD5Digest.encode(user.getBytes("UTF-8"), password.getBytes("UTF-8"), md5Salt);
if (logger.logDebug())
logger.debug(" FE=> Password(md5digest=" + new String(digest, "US-ASCII") + ")");
pgStream.SendInteger4(4 + digest.length + 1);
pgStream.Send(digest);
pgStream.SendChar(0);
pgStream.flush();
break;
}
case AUTH_REQ_PASSWORD:
{
if (logger.logDebug())
logger.debug(" <=BE AuthenticationReqPassword");
if (password == null)
throw new PSQLException(GT.tr("The server requested password-based authentication, but no password was provided."), PSQLState.CONNECTION_REJECTED);
if (logger.logDebug())
logger.debug(" FE=> Password(password=)");
byte[] encodedPassword = password.getBytes("UTF-8");
pgStream.SendInteger4(4 + encodedPassword.length + 1);
pgStream.Send(encodedPassword);
pgStream.SendChar(0);
pgStream.flush();
break;
}
case AUTH_REQ_OK:
if (logger.logDebug())
logger.debug(" <=BE AuthenticationOk");
return ; // We're done.
default:
if (logger.logDebug())
logger.debug(" <=BE AuthenticationReq (unsupported type " + ((int)areq) + ")");
throw new PSQLException(GT.tr("The authentication type {0} is not supported. Check that you have configured the pg_hba.conf file to include the client''s IP address or subnet, and that it is using an authentication scheme supported by the driver.", new Integer(areq)), PSQLState.CONNECTION_REJECTED);
}
break;
default:
throw new PSQLException(GT.tr("Protocol error. Session setup failed."), PSQLState.PROTOCOL_VIOLATION);
}
}
}
private void readStartupMessages(PGStream pgStream, ProtocolConnectionImpl protoConnection, Logger logger) throws IOException, SQLException {
while (true)
{
int beresp = pgStream.ReceiveChar();
switch (beresp)
{
case 'Z': // ReadyForQuery
if (logger.logDebug())
logger.debug(" <=BE ReadyForQuery");
return ;
case 'K': // BackendKeyData
int pid = pgStream.ReceiveInteger4();
int ckey = pgStream.ReceiveInteger4();
if (logger.logDebug())
logger.debug(" <=BE BackendKeyData(pid=" + pid + ",ckey=" + ckey + ")");
protoConnection.setBackendKeyData(pid, ckey);
break;
case 'E': // ErrorResponse
String errorMsg = pgStream.ReceiveString();
if (logger.logDebug())
logger.debug(" <=BE ErrorResponse(" + errorMsg + ")");
throw new PSQLException(GT.tr("Backend start-up failed: {0}.", errorMsg), PSQLState.CONNECTION_UNABLE_TO_CONNECT);
case 'N': // NoticeResponse
String warnMsg = pgStream.ReceiveString();
if (logger.logDebug())
logger.debug(" <=BE NoticeResponse(" + warnMsg + ")");
protoConnection.addWarning(new SQLWarning(warnMsg));
break;
default:
throw new PSQLException(GT.tr("Protocol error. Session setup failed."), PSQLState.PROTOCOL_VIOLATION);
}
}
}
private void runInitialQueries(ProtocolConnectionImpl protoConnection, Properties info, Logger logger) throws SQLException, IOException {
byte[][] results = SetupQueryRunner.run(protoConnection, "set datestyle = 'ISO'; select version(), case when pg_encoding_to_char(1) = 'SQL_ASCII' then 'UNKNOWN' else getdatabaseencoding() end", true);
String rawDbVersion = protoConnection.getEncoding().decode(results[0]);
StringTokenizer versionParts = new StringTokenizer(rawDbVersion);
versionParts.nextToken(); /* "PostgreSQL" */
String dbVersion = versionParts.nextToken(); /* "X.Y.Z" */
protoConnection.setServerVersion(dbVersion);
if (dbVersion.compareTo("7.3") >= 0)
{
// set encoding to be unicode; set datestyle; ensure autocommit is on
// (no-op on 7.4, but might be needed under 7.3)
// The begin/commit is to avoid leaving a transaction open if we're talking to a
// 7.3 server that defaults to autocommit = off.
if (logger.logDebug())
logger.debug("Switching to UTF8 client_encoding");
String sql = "begin; set autocommit = on; set client_encoding = 'UTF8'; ";
if (dbVersion.compareTo("9.0") >= 0) {
sql += "SET extra_float_digits=3; ";
} else if (dbVersion.compareTo("7.4") >= 0) {
sql += "SET extra_float_digits=2; ";
}
sql += "commit";
SetupQueryRunner.run(protoConnection, sql, false);
protoConnection.setEncoding(Encoding.getDatabaseEncoding("UTF8"));
}
else
{
String charSet = info.getProperty("charSet");
String dbEncoding = (results[1] == null ? null : protoConnection.getEncoding().decode(results[1]));
if (logger.logDebug())
{
logger.debug("Specified charset: " + charSet);
logger.debug("Database encoding: " + dbEncoding);
}
if (charSet != null)
{
// Explicitly specified encoding.
protoConnection.setEncoding(Encoding.getJVMEncoding(charSet));
}
else if (dbEncoding != null)
{
// Use database-supplied encoding.
protoConnection.setEncoding(Encoding.getDatabaseEncoding(dbEncoding));
}
else
{
// Fall back to defaults.
// XXX is this ever reached?
protoConnection.setEncoding(Encoding.defaultEncoding());
}
}
if (logger.logDebug())
logger.debug("Connection encoding (using JVM's nomenclature): " + protoConnection.getEncoding());
if (dbVersion.compareTo("8.1") >= 0)
{
// Server versions since 8.1 report standard_conforming_strings
results = SetupQueryRunner.run(protoConnection, "select current_setting('standard_conforming_strings')", true);
String value = protoConnection.getEncoding().decode(results[0]);
protoConnection.setStandardConformingStrings(value.equalsIgnoreCase("on"));
}
else
{
protoConnection.setStandardConformingStrings(false);
}
String appName = info.getProperty("ApplicationName");
if (appName != null && dbVersion.compareTo("9.0") >= 0)
{
StringBuffer sb = new StringBuffer("SET application_name = '");
Utils.appendEscapedLiteral(sb, appName, protoConnection.getStandardConformingStrings());
sb.append("'");
SetupQueryRunner.run(protoConnection, sb.toString(), false);
}
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/v2/FastpathParameterList.java 0000664 0000000 0000000 00000013374 12050675701 0027233 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
* Copyright (c) 2004, Open Cloud Limited.
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.core.v2;
import org.postgresql.core.*;
import java.io.InputStream;
import java.io.IOException;
import java.sql.SQLException;
import java.util.Arrays;
import org.postgresql.util.PSQLException;
import org.postgresql.util.PSQLState;
import org.postgresql.util.StreamWrapper;
import org.postgresql.util.GT;
/**
* Implementation of fastpath parameter lists for the V2 protocol.
* The V2 protocol expects different representations of parameters in
* queries to that used in fastpath calls, so we do a separate implementation
* which supports only what fastpath needs here.
*
* @author Oliver Jowett (oliver@opencloud.com)
*/
class FastpathParameterList implements ParameterList {
FastpathParameterList(int paramCount) {
this.paramValues = new Object[paramCount];
}
public void registerOutParameter(int index, int sqlType ){}
public void registerOutParameter(int index, int sqlType, int precision ){};
public int getInParameterCount() {
return paramValues.length;
}
public int getOutParameterCount()
{
return 0;
}
public int getParameterCount()
{
return paramValues.length;
}
public int[] getTypeOIDs() {
return null;
}
public void setIntParameter(int index, int value) throws SQLException {
if (index < 1 || index > paramValues.length)
throw new PSQLException(GT.tr("The column index is out of range: {0}, number of columns: {1}.", new Object[]{new Integer(index), new Integer(paramValues.length)}), PSQLState.INVALID_PARAMETER_VALUE );
byte[] data = new byte[4];
data[3] = (byte)value;
data[2] = (byte)(value >> 8);
data[1] = (byte)(value >> 16);
data[0] = (byte)(value >> 24);
paramValues[index - 1] = data;
}
public void setLiteralParameter(int index, String value, int oid) throws SQLException {
// Not enough type info here for the V2 path (which requires binary reprs)
throw new IllegalArgumentException("can't setLiteralParameter() on a fastpath parameter");
}
public void setStringParameter(int index, String value, int oid) throws SQLException {
paramValues[index - 1] = value;
}
public void setBytea(int index, byte[] data, int offset, int length) throws SQLException {
if (index < 1 || index > paramValues.length)
throw new PSQLException(GT.tr("The column index is out of range: {0}, number of columns: {1}.", new Object[]{new Integer(index), new Integer(paramValues.length)}), PSQLState.INVALID_PARAMETER_VALUE );
paramValues[index - 1] = new StreamWrapper(data, offset, length);
}
public void setBytea(int index, final InputStream stream, final int length) throws SQLException {
if (index < 1 || index > paramValues.length)
throw new PSQLException(GT.tr("The column index is out of range: {0}, number of columns: {1}.", new Object[]{new Integer(index), new Integer(paramValues.length)}), PSQLState.INVALID_PARAMETER_VALUE );
paramValues[index - 1] = new StreamWrapper(stream, length);
}
public void setNull(int index, int oid) throws SQLException {
throw new IllegalArgumentException("can't setNull() on a v2 fastpath parameter");
}
public String toString(int index) {
if (index < 1 || index > paramValues.length)
throw new IllegalArgumentException("parameter " + index + " out of range");
return "";
}
private void copyStream(PGStream pgStream, StreamWrapper wrapper) throws IOException {
byte[] rawData = wrapper.getBytes();
if (rawData != null)
{
pgStream.Send(rawData, wrapper.getOffset(), wrapper.getLength());
return ;
}
pgStream.SendStream(wrapper.getStream(), wrapper.getLength());
}
void writeV2FastpathValue(int index, PGStream pgStream) throws IOException {
--index;
if (paramValues[index] instanceof StreamWrapper)
{
StreamWrapper wrapper = (StreamWrapper)paramValues[index];
pgStream.SendInteger4(wrapper.getLength());
copyStream(pgStream, wrapper);
}
else if (paramValues[index] instanceof byte[])
{
byte[] data = (byte[])paramValues[index];
pgStream.SendInteger4(data.length);
pgStream.Send(data);
}
else if (paramValues[index] instanceof String)
{
byte[] data = pgStream.getEncoding().encode((String)paramValues[index]);
pgStream.SendInteger4(data.length);
pgStream.Send(data);
}
else
{
throw new IllegalArgumentException("don't know how to stream parameter " + index);
}
}
void checkAllParametersSet() throws SQLException {
for (int i = 0; i < paramValues.length; i++)
{
if (paramValues[i] == null)
throw new PSQLException(GT.tr("No value specified for parameter {0}.", new Integer(i + 1)), PSQLState.INVALID_PARAMETER_VALUE);
}
}
public ParameterList copy() {
FastpathParameterList newCopy = new FastpathParameterList(paramValues.length);
System.arraycopy(paramValues, 0, newCopy.paramValues, 0, paramValues.length);
return newCopy;
}
public void clear() {
Arrays.fill(paramValues, null);
}
public void setBinaryParameter(int index, byte[] value, int oid) {
throw new UnsupportedOperationException();
}
private final Object[] paramValues;
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/v2/ProtocolConnectionImpl.java 0000664 0000000 0000000 00000013165 12050675701 0027425 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
* Copyright (c) 2004, Open Cloud Limited.
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.core.v2;
import java.sql.SQLException;
import java.sql.SQLWarning;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Set;
import org.postgresql.PGNotification;
import org.postgresql.core.*;
import org.postgresql.util.HostSpec;
/**
* V2 implementation of ProtocolConnection.
*
* @author Oliver Jowett (oliver@opencloud.com)
*/
class ProtocolConnectionImpl implements ProtocolConnection {
ProtocolConnectionImpl(PGStream pgStream, String user, String database, Logger logger) {
this.pgStream = pgStream;
this.user = user;
this.database = database;
this.logger = logger;
this.executor = new QueryExecutorImpl(this, pgStream, logger);
}
public HostSpec getHostSpec() {
return pgStream.getHostSpec();
}
public String getUser() {
return user;
}
public String getDatabase() {
return database;
}
public String getServerVersion() {
return serverVersion;
}
public synchronized boolean getStandardConformingStrings()
{
return standardConformingStrings;
}
public synchronized int getTransactionState()
{
return transactionState;
}
public synchronized PGNotification[] getNotifications() throws SQLException {
PGNotification[] array = (PGNotification[])notifications.toArray(new PGNotification[notifications.size()]);
notifications.clear();
return array;
}
public synchronized SQLWarning getWarnings()
{
SQLWarning chain = warnings;
warnings = null;
return chain;
}
public QueryExecutor getQueryExecutor() {
return executor;
}
public void sendQueryCancel() throws SQLException {
if (cancelPid <= 0)
return ;
PGStream cancelStream = null;
// Now we need to construct and send a cancel packet
try
{
if (logger.logDebug())
logger.debug(" FE=> CancelRequest(pid=" + cancelPid + ",ckey=" + cancelKey + ")");
cancelStream = new PGStream(pgStream.getHostSpec());
cancelStream.SendInteger4(16);
cancelStream.SendInteger2(1234);
cancelStream.SendInteger2(5678);
cancelStream.SendInteger4(cancelPid);
cancelStream.SendInteger4(cancelKey);
cancelStream.flush();
cancelStream.ReceiveEOF();
cancelStream.close();
cancelStream = null;
}
catch (IOException e)
{
// Safe to ignore.
if (logger.logDebug())
logger.debug("Ignoring exception on cancel request:", e);
}
finally
{
if (cancelStream != null)
{
try
{
cancelStream.close();
}
catch (IOException e)
{
// Ignored.
}
}
}
}
public void close() {
if (closed)
return ;
try
{
if (logger.logDebug())
logger.debug(" FE=> Terminate");
pgStream.SendChar('X');
pgStream.flush();
pgStream.close();
}
catch (IOException ioe)
{
// Forget it.
if (logger.logDebug())
logger.debug("Discarding IOException on close:", ioe);
}
closed = true;
}
public Encoding getEncoding() {
return pgStream.getEncoding();
}
public boolean isClosed() {
return closed;
}
//
// Package-private accessors called during connection setup
//
void setEncoding(Encoding encoding) throws IOException {
pgStream.setEncoding(encoding);
}
void setServerVersion(String serverVersion) {
this.serverVersion = serverVersion;
}
void setBackendKeyData(int cancelPid, int cancelKey) {
this.cancelPid = cancelPid;
this.cancelKey = cancelKey;
}
synchronized void setStandardConformingStrings(boolean value) {
standardConformingStrings = value;
}
//
// Package-private accessors called by the query executor
//
synchronized void addWarning(SQLWarning newWarning)
{
if (warnings == null)
warnings = newWarning;
else
warnings.setNextWarning(newWarning);
}
synchronized void addNotification(PGNotification notification)
{
notifications.add(notification);
}
synchronized void setTransactionState(int state)
{
transactionState = state;
}
public int getProtocolVersion()
{
return 2;
}
public void setBinaryReceiveOids(Set ignored) {
// ignored for v2 connections
}
public boolean getIntegerDateTimes() {
// not supported in v2 protocol
return false;
}
private String serverVersion;
private int cancelPid;
private int cancelKey;
private boolean standardConformingStrings;
private int transactionState;
private SQLWarning warnings;
private boolean closed = false;
private final ArrayList notifications = new ArrayList();
private final PGStream pgStream;
private final String user;
private final String database;
private final QueryExecutorImpl executor;
private final Logger logger;
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/v2/QueryExecutorImpl.java 0000664 0000000 0000000 00000056121 12050675701 0026427 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2003-2011, PostgreSQL Global Development Group
* Copyright (c) 2004, Open Cloud Limited.
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.core.v2;
import java.util.ArrayList;
import java.util.List;
import java.io.IOException;
import java.io.Writer;
import java.sql.*;
import org.postgresql.core.*;
import org.postgresql.util.PSQLException;
import org.postgresql.util.PSQLState;
import org.postgresql.util.GT;
import org.postgresql.copy.CopyOperation;
/**
* QueryExecutor implementation for the V2 protocol.
*/
public class QueryExecutorImpl implements QueryExecutor {
public QueryExecutorImpl(ProtocolConnectionImpl protoConnection, PGStream pgStream, Logger logger) {
this.protoConnection = protoConnection;
this.pgStream = pgStream;
this.logger = logger;
}
//
// Query parsing
//
public Query createSimpleQuery(String sql) {
return new V2Query(sql, false, protoConnection);
}
public Query createParameterizedQuery(String sql) {
return new V2Query(sql, true, protoConnection);
}
//
// Fastpath
//
public ParameterList createFastpathParameters(int count) {
return new FastpathParameterList(count);
}
public synchronized byte[]
fastpathCall(int fnid, ParameterList parameters, boolean suppressBegin) throws SQLException {
if (protoConnection.getTransactionState() == ProtocolConnection.TRANSACTION_IDLE && !suppressBegin)
{
if (logger.logDebug())
logger.debug("Issuing BEGIN before fastpath call.");
ResultHandler handler = new ResultHandler() {
private boolean sawBegin = false;
private SQLException sqle = null;
public void handleResultRows(Query fromQuery, Field[] fields, List tuples, ResultCursor cursor) {
}
public void handleCommandStatus(String status, int updateCount, long insertOID) {
if (!sawBegin)
{
if (!status.equals("BEGIN"))
handleError(new PSQLException(GT.tr("Expected command status BEGIN, got {0}.", status),
PSQLState.PROTOCOL_VIOLATION));
sawBegin = true;
}
else
{
handleError(new PSQLException(GT.tr("Unexpected command status: {0}.", status),
PSQLState.PROTOCOL_VIOLATION));
}
}
public void handleWarning(SQLWarning warning) {
// we don't want to ignore warnings and it would be tricky
// to chain them back to the connection, so since we don't
// expect to get them in the first place, we just consider
// them errors.
handleError(warning);
}
public void handleError(SQLException error) {
if (sqle == null)
{
sqle = error;
}
else
{
sqle.setNextException(error);
}
}
public void handleCompletion() throws SQLException{
if (sqle != null)
throw sqle;
}
};
try
{
// Create and issue a dummy query to use the existing prefix infrastructure
V2Query query = (V2Query)createSimpleQuery("");
SimpleParameterList params = (SimpleParameterList)query.createParameterList();
sendQuery(query, params, "BEGIN");
processResults(query, handler, 0, 0);
}
catch (IOException ioe)
{
throw new PSQLException(GT.tr("An I/O error occured while sending to the backend."), PSQLState.CONNECTION_FAILURE, ioe);
}
}
try
{
sendFastpathCall(fnid, (FastpathParameterList)parameters);
return receiveFastpathResult();
}
catch (IOException ioe)
{
throw new PSQLException(GT.tr("An I/O error occured while sending to the backend."), PSQLState.CONNECTION_FAILURE, ioe);
}
}
private void sendFastpathCall(int fnid, FastpathParameterList params) throws IOException {
// Send call.
int count = params.getParameterCount();
if (logger.logDebug())
logger.debug(" FE=> FastpathCall(fnid=" + fnid + ",paramCount=" + count + ")");
pgStream.SendChar('F');
pgStream.SendChar(0);
pgStream.SendInteger4(fnid);
pgStream.SendInteger4(count);
for (int i = 1; i <= count; ++i)
params.writeV2FastpathValue(i, pgStream);
pgStream.flush();
}
public synchronized void processNotifies() throws SQLException {
// Asynchronous notifies only arrive when we are not in a transaction
if (protoConnection.getTransactionState() != ProtocolConnection.TRANSACTION_IDLE)
return;
try {
while (pgStream.hasMessagePending()) {
int c = pgStream.ReceiveChar();
switch (c) {
case 'A': // Asynchronous Notify
receiveAsyncNotify();
break;
case 'E': // Error Message
throw receiveErrorMessage();
// break;
case 'N': // Error Notification
protoConnection.addWarning(receiveNotification());
break;
default:
throw new PSQLException(GT.tr("Unknown Response Type {0}.", new Character((char) c)), PSQLState.CONNECTION_FAILURE);
}
}
} catch (IOException ioe) {
throw new PSQLException(GT.tr("An I/O error occured while sending to the backend."), PSQLState.CONNECTION_FAILURE, ioe);
}
}
private byte[] receiveFastpathResult() throws IOException, SQLException {
SQLException error = null;
boolean endQuery = false;
byte[] result = null;
while (!endQuery)
{
int c = pgStream.ReceiveChar();
switch (c)
{
case 'A': // Asynchronous Notify
receiveAsyncNotify();
break;
case 'E': // Error Message
SQLException newError = receiveErrorMessage();
if (error == null)
error = newError;
else
error.setNextException(newError);
// keep processing
break;
case 'N': // Error Notification
protoConnection.addWarning(receiveNotification());
break;
case 'V': // Fastpath result
c = pgStream.ReceiveChar();
if (c == 'G')
{
if (logger.logDebug())
logger.debug(" <=BE FastpathResult");
// Result.
int len = pgStream.ReceiveInteger4();
result = pgStream.Receive(len);
c = pgStream.ReceiveChar();
}
else
{
if (logger.logDebug())
logger.debug(" <=BE FastpathVoidResult");
}
if (c != '0')
throw new PSQLException(GT.tr("Unknown Response Type {0}.", new Character((char) c)), PSQLState.CONNECTION_FAILURE);
break;
case 'Z':
if (logger.logDebug())
logger.debug(" <=BE ReadyForQuery");
endQuery = true;
break;
default:
throw new PSQLException(GT.tr("Unknown Response Type {0}.", new Character((char) c)), PSQLState.CONNECTION_FAILURE);
}
}
// did we get an error during this query?
if (error != null)
throw error;
return result;
}
//
// Query execution
//
public synchronized void execute(Query query,
ParameterList parameters,
ResultHandler handler,
int maxRows, int fetchSize, int flags)
throws SQLException
{
execute((V2Query)query, (SimpleParameterList)parameters, handler, maxRows, flags);
}
// Nothing special yet, just run the queries one at a time.
public synchronized void execute(Query[] queries,
ParameterList[] parameters,
ResultHandler handler,
int maxRows, int fetchSize, int flags)
throws SQLException
{
final ResultHandler delegateHandler = handler;
handler = new ResultHandler() {
public void handleResultRows(Query fromQuery, Field[] fields, List tuples, ResultCursor cursor) {
delegateHandler.handleResultRows(fromQuery, fields, tuples, cursor);
}
public void handleCommandStatus(String status, int updateCount, long insertOID) {
delegateHandler.handleCommandStatus(status, updateCount, insertOID);
}
public void handleWarning(SQLWarning warning) {
delegateHandler.handleWarning(warning);
}
public void handleError(SQLException error) {
delegateHandler.handleError(error);
}
public void handleCompletion() throws SQLException {
}
};
for (int i = 0; i < queries.length; ++i)
execute((V2Query)queries[i], (SimpleParameterList)parameters[i], handler, maxRows, flags);
delegateHandler.handleCompletion();
}
public void fetch(ResultCursor cursor, ResultHandler handler, int rows) throws SQLException {
throw org.postgresql.Driver.notImplemented(this.getClass(), "fetch(ResultCursor,ResultHandler,int)");
}
private void execute(V2Query query,
SimpleParameterList parameters,
ResultHandler handler,
int maxRows, int flags) throws SQLException
{
// The V2 protocol has no support for retrieving metadata
// without executing the whole query.
if ((flags & QueryExecutor.QUERY_DESCRIBE_ONLY) != 0)
return;
if (parameters == null)
parameters = (SimpleParameterList)query.createParameterList();
parameters.checkAllParametersSet();
String queryPrefix = null;
if (protoConnection.getTransactionState() == ProtocolConnection.TRANSACTION_IDLE &&
(flags & QueryExecutor.QUERY_SUPPRESS_BEGIN) == 0)
{
queryPrefix = "BEGIN;";
// Insert a handler that intercepts the BEGIN.
final ResultHandler delegateHandler = handler;
handler = new ResultHandler() {
private boolean sawBegin = false;
public void handleResultRows(Query fromQuery, Field[] fields, List tuples, ResultCursor cursor) {
if (sawBegin)
delegateHandler.handleResultRows(fromQuery, fields, tuples, cursor);
}
public void handleCommandStatus(String status, int updateCount, long insertOID) {
if (!sawBegin)
{
if (!status.equals("BEGIN"))
handleError(new PSQLException(GT.tr("Expected command status BEGIN, got {0}.", status),
PSQLState.PROTOCOL_VIOLATION));
sawBegin = true;
}
else
{
delegateHandler.handleCommandStatus(status, updateCount, insertOID);
}
}
public void handleWarning(SQLWarning warning) {
delegateHandler.handleWarning(warning);
}
public void handleError(SQLException error) {
delegateHandler.handleError(error);
}
public void handleCompletion() throws SQLException{
delegateHandler.handleCompletion();
}
};
}
try
{
sendQuery(query, parameters, queryPrefix);
processResults(query, handler, maxRows, flags);
}
catch (IOException e)
{
protoConnection.close();
handler.handleError(new PSQLException(GT.tr("An I/O error occured while sending to the backend."), PSQLState.CONNECTION_FAILURE, e));
}
handler.handleCompletion();
}
/*
* Send a query to the backend.
*/
protected void sendQuery(V2Query query, SimpleParameterList params, String queryPrefix) throws IOException {
if (logger.logDebug())
logger.debug(" FE=> Query(\"" + (queryPrefix == null ? "" : queryPrefix) + query.toString(params) + "\")");
pgStream.SendChar('Q');
Writer encodingWriter = pgStream.getEncodingWriter();
if (queryPrefix != null)
encodingWriter.write(queryPrefix);
String[] fragments = query.getFragments();
for (int i = 0 ; i < fragments.length; ++i)
{
encodingWriter.write(fragments[i]);
if (i < params.getParameterCount())
params.writeV2Value(i + 1, encodingWriter);
}
encodingWriter.write(0);
pgStream.flush();
}
protected void processResults(Query originalQuery, ResultHandler handler, int maxRows, int flags) throws IOException {
boolean bothRowsAndStatus = (flags & QueryExecutor.QUERY_BOTH_ROWS_AND_STATUS) != 0;
Field[] fields = null;
List tuples = null;
boolean endQuery = false;
while (!endQuery)
{
int c = pgStream.ReceiveChar();
switch (c)
{
case 'A': // Asynchronous Notify
receiveAsyncNotify();
break;
case 'B': // Binary Data Transfer
{
if (fields == null)
throw new IOException("Data transfer before field metadata");
if (logger.logDebug())
logger.debug(" <=BE BinaryRow");
Object tuple = null;
try {
tuple = pgStream.ReceiveTupleV2(fields.length, true);
} catch(OutOfMemoryError oome) {
if (maxRows == 0 || tuples.size() < maxRows) {
handler.handleError(new PSQLException(GT.tr("Ran out of memory retrieving query results."), PSQLState.OUT_OF_MEMORY, oome));
}
}
for (int i = 0; i < fields.length; i++)
fields[i].setFormat(Field.BINARY_FORMAT); //Set the field to binary format
if (maxRows == 0 || tuples.size() < maxRows)
tuples.add(tuple);
}
break;
case 'C': // Command Status
String status = pgStream.ReceiveString();
if (logger.logDebug())
logger.debug(" <=BE CommandStatus(" + status + ")");
if (fields != null)
{
handler.handleResultRows(originalQuery, fields, tuples, null);
fields = null;
if (bothRowsAndStatus)
interpretCommandStatus(status, handler);
}
else
{
interpretCommandStatus(status, handler);
}
break;
case 'D': // Text Data Transfer
{
if (fields == null)
throw new IOException("Data transfer before field metadata");
if (logger.logDebug())
logger.debug(" <=BE DataRow");
Object tuple = null;
try {
tuple = pgStream.ReceiveTupleV2(fields.length, false);
} catch(OutOfMemoryError oome) {
if (maxRows == 0 || tuples.size() < maxRows)
handler.handleError(new PSQLException(GT.tr("Ran out of memory retrieving query results."), PSQLState.OUT_OF_MEMORY, oome));
}
if (maxRows == 0 || tuples.size() < maxRows)
tuples.add(tuple);
}
break;
case 'E': // Error Message
handler.handleError(receiveErrorMessage());
// keep processing
break;
case 'I': // Empty Query
if (logger.logDebug())
logger.debug(" <=BE EmptyQuery");
c = pgStream.ReceiveChar();
if (c != 0)
throw new IOException("Expected \\0 after EmptyQuery, got: " + c);
break;
case 'N': // Error Notification
handler.handleWarning(receiveNotification());
break;
case 'P': // Portal Name
String portalName = pgStream.ReceiveString();
if (logger.logDebug())
logger.debug(" <=BE PortalName(" + portalName + ")");
break;
case 'T': // MetaData Field Description
fields = receiveFields();
tuples = new ArrayList();
break;
case 'Z':
if (logger.logDebug())
logger.debug(" <=BE ReadyForQuery");
endQuery = true;
break;
default:
throw new IOException("Unexpected packet type: " + c);
}
}
}
/*
* Receive the field descriptions from the back end.
*/
private Field[] receiveFields() throws IOException
{
int size = pgStream.ReceiveInteger2();
Field[] fields = new Field[size];
if (logger.logDebug())
logger.debug(" <=BE RowDescription(" + fields.length + ")");
for (int i = 0; i < fields.length; i++)
{
String columnLabel = pgStream.ReceiveString();
int typeOid = pgStream.ReceiveInteger4();
int typeLength = pgStream.ReceiveInteger2();
int typeModifier = pgStream.ReceiveInteger4();
fields[i] = new Field(columnLabel, columnLabel, typeOid, typeLength, typeModifier, 0, 0);
}
return fields;
}
private void receiveAsyncNotify() throws IOException {
int pid = pgStream.ReceiveInteger4();
String msg = pgStream.ReceiveString();
if (logger.logDebug())
logger.debug(" <=BE AsyncNotify(pid=" + pid + ",msg=" + msg + ")");
protoConnection.addNotification(new org.postgresql.core.Notification(msg, pid));
}
private SQLException receiveErrorMessage() throws IOException {
String errorMsg = pgStream.ReceiveString().trim();
if (logger.logDebug())
logger.debug(" <=BE ErrorResponse(" + errorMsg + ")");
return new PSQLException(errorMsg, PSQLState.UNKNOWN_STATE);
}
private SQLWarning receiveNotification() throws IOException {
String warnMsg = pgStream.ReceiveString();
// Strip out the severity field so we have consistency with
// the V3 protocol. SQLWarning.getMessage should return just
// the actual message.
//
int severityMark = warnMsg.indexOf(":");
warnMsg = warnMsg.substring(severityMark+1).trim();
if (logger.logDebug())
logger.debug(" <=BE NoticeResponse(" + warnMsg + ")");
return new SQLWarning(warnMsg);
}
private void interpretCommandStatus(String status, ResultHandler handler) throws IOException {
int update_count = 0;
long insert_oid = 0;
if (status.equals("BEGIN"))
protoConnection.setTransactionState(ProtocolConnection.TRANSACTION_OPEN);
else if (status.equals("COMMIT") || status.equals("ROLLBACK"))
protoConnection.setTransactionState(ProtocolConnection.TRANSACTION_IDLE);
else if (status.startsWith("INSERT") || status.startsWith("UPDATE") || status.startsWith("DELETE") || status.startsWith("MOVE"))
{
try
{
update_count = Integer.parseInt(status.substring(1 + status.lastIndexOf(' ')));
if (status.startsWith("INSERT"))
insert_oid = Long.parseLong(status.substring(1 + status.indexOf(' '),
status.lastIndexOf(' ')));
}
catch (NumberFormatException nfe)
{
handler.handleError(new PSQLException(GT.tr("Unable to interpret the update count in command completion tag: {0}.", status), PSQLState.CONNECTION_FAILURE));
return ;
}
}
handler.handleCommandStatus(status, update_count, insert_oid);
}
private final ProtocolConnectionImpl protoConnection;
private final PGStream pgStream;
private final Logger logger;
public CopyOperation startCopy(String sql, boolean suppressBegin) throws SQLException {
throw new PSQLException(GT.tr("Copy not implemented for protocol version 2"), PSQLState.NOT_IMPLEMENTED);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/v2/SimpleParameterList.java 0000664 0000000 0000000 00000014776 12050675701 0026721 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
* Copyright (c) 2004, Open Cloud Limited.
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.core.v2;
import org.postgresql.core.*;
import java.io.InputStream;
import java.io.Writer;
import java.io.IOException;
import java.sql.SQLException;
import java.util.Arrays;
import org.postgresql.util.PSQLException;
import org.postgresql.util.PSQLState;
import org.postgresql.util.StreamWrapper;
import org.postgresql.util.GT;
/**
* Parameter list for query parameters in the V2 protocol.
*
* @author Oliver Jowett (oliver@opencloud.com)
*/
class SimpleParameterList implements ParameterList {
SimpleParameterList(int paramCount, boolean useEStringSyntax) {
this.paramValues = new Object[paramCount];
this.useEStringSyntax = useEStringSyntax;
}
public void registerOutParameter(int index, int sqlType ){};
public void registerOutParameter(int index, int sqlType, int precision ){};
public int getInParameterCount() {
return paramValues.length;
}
public int getParameterCount()
{
return paramValues.length;
}
public int getOutParameterCount()
{
return 1;
}
public int[] getTypeOIDs() {
return null;
}
public void setIntParameter(int index, int value) throws SQLException {
setLiteralParameter(index, "" + value, Oid.INT4);
}
public void setLiteralParameter(int index, String value, int oid) throws SQLException {
if (index < 1 || index > paramValues.length)
throw new PSQLException(GT.tr("The column index is out of range: {0}, number of columns: {1}.", new Object[]{new Integer(index), new Integer(paramValues.length)}), PSQLState.INVALID_PARAMETER_VALUE );
paramValues[index - 1] = value;
}
public void setStringParameter(int index, String value, int oid) throws SQLException {
StringBuffer sbuf = new StringBuffer(2 + value.length() * 11 / 10); // Add 10% for escaping.
if (useEStringSyntax)
sbuf.append(' ').append('E');
sbuf.append('\'');
Utils.appendEscapedLiteral(sbuf, value, false);
sbuf.append('\'');
setLiteralParameter(index, sbuf.toString(), oid);
}
public void setBytea(int index, byte[] data, int offset, int length) throws SQLException {
if (index < 1 || index > paramValues.length)
throw new PSQLException(GT.tr("The column index is out of range: {0}, number of columns: {1}.", new Object[]{new Integer(index), new Integer(paramValues.length)}), PSQLState.INVALID_PARAMETER_VALUE );
paramValues[index - 1] = new StreamWrapper(data, offset, length);
}
public void setBytea(int index, final InputStream stream, final int length) throws SQLException {
if (index < 1 || index > paramValues.length)
throw new PSQLException(GT.tr("The column index is out of range: {0}, number of columns: {1}.", new Object[]{new Integer(index), new Integer(paramValues.length)}), PSQLState.INVALID_PARAMETER_VALUE );
paramValues[index - 1] = new StreamWrapper(stream, length);
}
public void setNull(int index, int oid) throws SQLException {
if (index < 1 || index > paramValues.length)
throw new PSQLException(GT.tr("The column index is out of range: {0}, number of columns: {1}.", new Object[]{new Integer(index), new Integer(paramValues.length)}), PSQLState.INVALID_PARAMETER_VALUE );
paramValues[index - 1] = NULL_OBJECT;
}
public String toString(int index) {
if (index < 1 || index > paramValues.length)
throw new IllegalArgumentException("Parameter index " + index + " out of range");
if (paramValues[index - 1] == null)
return "?";
else if (paramValues[index -1] == NULL_OBJECT)
return "NULL";
else
return paramValues[index -1].toString();
}
/**
* Send a streamable bytea encoded as a text representation with an arbitary encoding.
*/
private void streamBytea(StreamWrapper param, Writer encodingWriter) throws IOException {
// NB: we escape everything in this path, as I don't like assuming
// that byte values 32..127 will make it through the encoding
// unscathed..
InputStream stream = param.getStream();
char[] buffer = new char[] { '\\', '\\', 0, 0, 0 };
if (useEStringSyntax)
{
encodingWriter.write(' ');
encodingWriter.write('E');
}
encodingWriter.write('\'');
for (int remaining = param.getLength(); remaining > 0; --remaining)
{
int nextByte = stream.read();
buffer[2] = (char)( '0' + ((nextByte >> 6) & 3));
buffer[3] = (char)( '0' + ((nextByte >> 3) & 7));
buffer[4] = (char)( '0' + (nextByte & 7));
encodingWriter.write(buffer, 0, 5);
}
encodingWriter.write('\'');
}
void writeV2Value(int index, Writer encodingWriter) throws IOException {
if (paramValues[index - 1] instanceof StreamWrapper)
{
streamBytea((StreamWrapper)paramValues[index - 1], encodingWriter);
}
else
{
encodingWriter.write((String)paramValues[index - 1]);
}
}
void checkAllParametersSet() throws SQLException {
for (int i = 0; i < paramValues.length; i++)
{
if (paramValues[i] == null)
throw new PSQLException(GT.tr("No value specified for parameter {0}.", new Integer(i + 1)), PSQLState.INVALID_PARAMETER_VALUE);
}
}
public ParameterList copy() {
SimpleParameterList newCopy = new SimpleParameterList(paramValues.length, useEStringSyntax);
System.arraycopy(paramValues, 0, newCopy.paramValues, 0, paramValues.length);
return newCopy;
}
public void clear() {
Arrays.fill(paramValues, null);
}
public void setBinaryParameter(int index, byte[] value, int oid) {
throw new UnsupportedOperationException();
}
private final Object[] paramValues;
private final boolean useEStringSyntax;
/* Object representing NULL; conveniently, String streams exactly as we want it to. *
* nb: we explicitly say "new String" to avoid interning giving us an object that
* might be the same (by identity) as a String elsewhere.
*/
private final static String NULL_OBJECT = new String("NULL");
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/v2/V2Query.java 0000664 0000000 0000000 00000006332 12050675701 0024275 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2003-2011, PostgreSQL Global Development Group
* Copyright (c) 2004, Open Cloud Limited.
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.core.v2;
import java.util.ArrayList;
import java.util.List;
import org.postgresql.core.*;
/**
* Query implementation for all queries via the V2 protocol.
*/
class V2Query implements Query {
V2Query(String query, boolean withParameters, ProtocolConnection pconn) {
useEStringSyntax = pconn.getServerVersion() != null
&& pconn.getServerVersion().compareTo("8.1") > 0;
boolean stdStrings = pconn.getStandardConformingStrings();
if (!withParameters)
{
fragments = new String[] { query };
return ;
}
// Parse query and find parameter placeholders.
List v = new ArrayList();
int lastParmEnd = 0;
char []aChars = query.toCharArray();
for (int i = 0; i < aChars.length; ++i)
{
switch (aChars[i])
{
case '\'': // single-quotes
i = Parser.parseSingleQuotes(aChars, i, stdStrings);
break;
case '"': // double-quotes
i = Parser.parseDoubleQuotes(aChars, i);
break;
case '-': // possibly -- style comment
i = Parser.parseLineComment(aChars, i);
break;
case '/': // possibly /* */ style comment
i = Parser.parseBlockComment(aChars, i);
break;
case '$': // possibly dollar quote start
i = Parser.parseDollarQuotes(aChars, i);
break;
case '?':
v.add(query.substring (lastParmEnd, i));
lastParmEnd = i + 1;
break;
default:
break;
}
}
v.add(query.substring (lastParmEnd, query.length()));
fragments = new String[v.size()];
for (int i = 0 ; i < fragments.length; ++i)
fragments[i] = (String)v.get(i);
}
public ParameterList createParameterList() {
if (fragments.length == 1)
return NO_PARAMETERS;
return new SimpleParameterList(fragments.length - 1, useEStringSyntax);
}
public String toString(ParameterList parameters) {
StringBuffer sbuf = new StringBuffer(fragments[0]);
for (int i = 1; i < fragments.length; ++i)
{
if (parameters == null)
sbuf.append("?");
else
sbuf.append(parameters.toString(i));
sbuf.append(fragments[i]);
}
return sbuf.toString();
}
public void close() {
}
String[] getFragments() {
return fragments;
}
public boolean isStatementDescribed() {
return false;
}
private static final ParameterList NO_PARAMETERS = new SimpleParameterList(0, false);
private final String[] fragments; // Query fragments, length == # of parameters + 1
private final boolean useEStringSyntax; // whether escaped string syntax should be used
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/v3/ 0000775 0000000 0000000 00000000000 12050675701 0022112 5 ustar 00root root 0000000 0000000 postgresql-jdbc-9.2-1002.src/org/postgresql/core/v3/CompositeParameterList.java 0000664 0000000 0000000 00000011526 12050675701 0027421 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
* Copyright (c) 2004, Open Cloud Limited.
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.core.v3;
import org.postgresql.core.*;
import org.postgresql.util.PSQLException;
import org.postgresql.util.PSQLState;
import org.postgresql.util.GT;
import java.sql.SQLException;
import java.io.InputStream;
/**
* Parameter list for V3 query strings that contain multiple statements.
* We delegate to one SimpleParameterList per statement, and translate
* parameter indexes as needed.
*
* @author Oliver Jowett (oliver@opencloud.com)
*/
class CompositeParameterList implements V3ParameterList {
CompositeParameterList(SimpleParameterList[] subparams, int[] offsets) {
this.subparams = subparams;
this.offsets = offsets;
this.total = offsets[offsets.length - 1] + subparams[offsets.length - 1].getInParameterCount();
}
private final int findSubParam(int index) throws SQLException {
if (index < 1 || index > total)
throw new PSQLException(GT.tr("The column index is out of range: {0}, number of columns: {1}.", new Object[]{new Integer(index), new Integer(total)}), PSQLState.INVALID_PARAMETER_VALUE );
for (int i = offsets.length - 1; i >= 0; --i)
if (offsets[i] < index)
return i;
throw new IllegalArgumentException("I am confused; can't find a subparam for index " + index);
}
public void registerOutParameter(int index, int sqlType)
{
}
public int getDirection(int i)
{return 0;}
public int getParameterCount()
{
return total;
}
public int getInParameterCount() {
return total;
}
public int getOutParameterCount()
{
return 0;
}
public int[] getTypeOIDs() {
int oids[] = new int[total];
for (int i=0; i
for (int whichHost = 0; whichHost < hostSpecs.length; ++whichHost) {
HostSpec hostSpec = hostSpecs[whichHost];
if (logger.logDebug())
logger.debug("Trying to establish a protocol version 3 connection to " + hostSpec);
//
// Establish a connection.
//
PGStream newStream = null;
try
{
newStream = new PGStream(hostSpec);
// Construct and send an ssl startup packet if requested.
if (trySSL)
newStream = enableSSL(newStream, requireSSL, info, logger);
// Set the socket timeout if the "socketTimeout" property has been set.
String socketTimeoutProperty = info.getProperty("socketTimeout", "0");
try {
int socketTimeout = Integer.parseInt(socketTimeoutProperty);
if (socketTimeout > 0) {
newStream.getSocket().setSoTimeout(socketTimeout*1000);
}
} catch (NumberFormatException nfe) {
logger.info("Couldn't parse socketTimeout value:" + socketTimeoutProperty);
}
// Enable TCP keep-alive probe if required.
newStream.getSocket().setKeepAlive(requireTCPKeepAlive);
// Try to set SO_SNDBUF and SO_RECVBUF socket options, if requested.
// If receiveBufferSize and send_buffer_size are set to a value greater
// than 0, adjust. -1 means use the system default, 0 is ignored since not
// supported.
// Set SO_RECVBUF read buffer size
String receiveBufferSizeProperty = info.getProperty("receiveBufferSize", "-1");
try {
int receiveBufferSize = Integer.parseInt(receiveBufferSizeProperty);
if (receiveBufferSize > -1) {
// value of 0 not a valid buffer size value
if (receiveBufferSize > 0) {
newStream.getSocket().setReceiveBufferSize(receiveBufferSize);
} else {
logger.info("Ignore invalid value for receiveBufferSize: " + receiveBufferSize);
}
}
} catch (NumberFormatException nfe) {
logger.info("Couldn't parse receiveBufferSize value: " + receiveBufferSizeProperty);
}
// Set SO_SNDBUF write buffer size
String sendBufferSizeProperty = info.getProperty("sendBufferSize", "-1");
try {
int sendBufferSize = Integer.parseInt(sendBufferSizeProperty);
if (sendBufferSize > -1) {
if (sendBufferSize > 0) {
newStream.getSocket().setSendBufferSize(sendBufferSize);
} else {
logger.info("Ignore invalid value for sendBufferSize: " + sendBufferSize);
}
}
} catch (NumberFormatException nfe) {
logger.info("Couldn't parse sendBufferSize value: " + sendBufferSizeProperty);
}
logger.info("Receive Buffer Size is " + newStream.getSocket().getReceiveBufferSize());
logger.info("Send Buffer Size is " + newStream.getSocket().getSendBufferSize());
// Construct and send a startup packet.
String[][] params = {
{ "user", user },
{ "database", database },
{ "client_encoding", "UTF8" },
{ "DateStyle", "ISO" },
{ "extra_float_digits", "2" },
{ "TimeZone", createPostgresTimeZone() },
};
sendStartupPacket(newStream, params, logger);
// Do authentication (until AuthenticationOk).
doAuthentication(newStream, hostSpec.getHost(), user, info, logger);
// Do final startup.
ProtocolConnectionImpl protoConnection = new ProtocolConnectionImpl(newStream, user, database, info, logger);
readStartupMessages(newStream, protoConnection, logger);
runInitialQueries(protoConnection, info, logger);
// And we're done.
return protoConnection;
}
catch (UnsupportedProtocolException upe)
{
// Swallow this and return null so ConnectionFactory tries the next protocol.
if (logger.logDebug())
logger.debug("Protocol not supported, abandoning connection.");
try
{
newStream.close();
}
catch (IOException e)
{
}
return null;
}
catch (ConnectException cex)
{
// Added by Peter Mount
// ConnectException is thrown when the connection cannot be made.
// we trap this an return a more meaningful message for the end user
if (whichHost + 1 < hostSpecs.length) {
// still more addresses to try
continue;
}
throw new PSQLException (GT.tr("Connection refused. Check that the hostname and port are correct and that the postmaster is accepting TCP/IP connections."), PSQLState.CONNECTION_UNABLE_TO_CONNECT, cex);
}
catch (IOException ioe)
{
if (newStream != null)
{
try
{
newStream.close();
}
catch (IOException e)
{
}
}
if (whichHost + 1 < hostSpecs.length) {
// still more addresses to try
continue;
}
throw new PSQLException (GT.tr("The connection attempt failed."), PSQLState.CONNECTION_UNABLE_TO_CONNECT, ioe);
}
catch (SQLException se)
{
if (newStream != null)
{
try
{
newStream.close();
}
catch (IOException e)
{
}
}
if (whichHost + 1 < hostSpecs.length) {
// still more addresses to try
continue;
}
throw se;
}
}
throw new PSQLException (GT.tr("The connection url is invalid."), PSQLState.CONNECTION_UNABLE_TO_CONNECT);
}
/**
* Convert Java time zone to postgres time zone.
* All others stay the same except that GMT+nn changes to GMT-nn and
* vise versa.
*
* @return The current JVM time zone in postgresql format.
*/
private String createPostgresTimeZone() {
String tz = TimeZone.getDefault().getID();
if (tz.length() <= 3 || !tz.startsWith("GMT")) {
return tz;
}
char sign = tz.charAt(3);
String start;
if (sign == '+') {
start = "GMT-";
} else if (sign == '-') {
start = "GMT+";
} else {
// unknown type
return tz;
}
return start + tz.substring(4);
}
private PGStream enableSSL(PGStream pgStream, boolean requireSSL, Properties info, Logger logger) throws IOException, SQLException {
if (logger.logDebug())
logger.debug(" FE=> SSLRequest");
// Send SSL request packet
pgStream.SendInteger4(8);
pgStream.SendInteger2(1234);
pgStream.SendInteger2(5679);
pgStream.flush();
// Now get the response from the backend, one of N, E, S.
int beresp = pgStream.ReceiveChar();
switch (beresp)
{
case 'E':
if (logger.logDebug())
logger.debug(" <=BE SSLError");
// Server doesn't even know about the SSL handshake protocol
if (requireSSL)
throw new PSQLException(GT.tr("The server does not support SSL."), PSQLState.CONNECTION_REJECTED);
// We have to reconnect to continue.
pgStream.close();
return new PGStream(pgStream.getHostSpec());
case 'N':
if (logger.logDebug())
logger.debug(" <=BE SSLRefused");
// Server does not support ssl
if (requireSSL)
throw new PSQLException(GT.tr("The server does not support SSL."), PSQLState.CONNECTION_REJECTED);
return pgStream;
case 'S':
if (logger.logDebug())
logger.debug(" <=BE SSLOk");
// Server supports ssl
org.postgresql.ssl.MakeSSL.convert(pgStream, info, logger);
return pgStream;
default:
throw new PSQLException(GT.tr("An error occured while setting up the SSL connection."), PSQLState.PROTOCOL_VIOLATION);
}
}
private void sendStartupPacket(PGStream pgStream, String[][] params, Logger logger) throws IOException {
if (logger.logDebug())
{
String details = "";
for (int i = 0; i < params.length; ++i)
{
if (i != 0)
details += ", ";
details += params[i][0] + "=" + params[i][1];
}
logger.debug(" FE=> StartupPacket(" + details + ")");
}
/*
* Precalculate message length and encode params.
*/
int length = 4 + 4;
byte[][] encodedParams = new byte[params.length * 2][];
for (int i = 0; i < params.length; ++i)
{
encodedParams[i*2] = params[i][0].getBytes("UTF-8");
encodedParams[i*2 + 1] = params[i][1].getBytes("UTF-8");
length += encodedParams[i * 2].length + 1 + encodedParams[i * 2 + 1].length + 1;
}
length += 1; // Terminating \0
/*
* Send the startup message.
*/
pgStream.SendInteger4(length);
pgStream.SendInteger2(3); // protocol major
pgStream.SendInteger2(0); // protocol minor
for (int i = 0; i < encodedParams.length; ++i)
{
pgStream.Send(encodedParams[i]);
pgStream.SendChar(0);
}
pgStream.SendChar(0);
pgStream.flush();
}
private void doAuthentication(PGStream pgStream, String host, String user, Properties info, Logger logger) throws IOException, SQLException
{
// Now get the response from the backend, either an error message
// or an authentication request
String password = info.getProperty("password");
while (true)
{
int beresp = pgStream.ReceiveChar();
switch (beresp)
{
case 'E':
// An error occured, so pass the error message to the
// user.
//
// The most common one to be thrown here is:
// "User authentication failed"
//
int l_elen = pgStream.ReceiveInteger4();
if (l_elen > 30000)
{
// if the error length is > than 30000 we assume this is really a v2 protocol
// server, so trigger fallback.
throw new UnsupportedProtocolException();
}
ServerErrorMessage errorMsg = new ServerErrorMessage(pgStream.ReceiveString(l_elen - 4), logger.getLogLevel());
if (logger.logDebug())
logger.debug(" <=BE ErrorMessage(" + errorMsg + ")");
throw new PSQLException(errorMsg);
case 'R':
// Authentication request.
// Get the message length
int l_msgLen = pgStream.ReceiveInteger4();
// Get the type of request
int areq = pgStream.ReceiveInteger4();
// Process the request.
switch (areq)
{
case AUTH_REQ_CRYPT:
{
byte[] salt = pgStream.Receive(2);
if (logger.logDebug())
logger.debug(" <=BE AuthenticationReqCrypt(salt='" + new String(salt, "US-ASCII") + "')");
if (password == null)
throw new PSQLException(GT.tr("The server requested password-based authentication, but no password was provided."), PSQLState.CONNECTION_REJECTED);
byte[] encodedResult = UnixCrypt.crypt(salt, password.getBytes("UTF-8"));
if (logger.logDebug())
logger.debug(" FE=> Password(crypt='" + new String(encodedResult, "US-ASCII") + "')");
pgStream.SendChar('p');
pgStream.SendInteger4(4 + encodedResult.length + 1);
pgStream.Send(encodedResult);
pgStream.SendChar(0);
pgStream.flush();
break;
}
case AUTH_REQ_MD5:
{
byte[] md5Salt = pgStream.Receive(4);
if (logger.logDebug())
{
logger.debug(" <=BE AuthenticationReqMD5(salt=" + Utils.toHexString(md5Salt) + ")");
}
if (password == null)
throw new PSQLException(GT.tr("The server requested password-based authentication, but no password was provided."), PSQLState.CONNECTION_REJECTED);
byte[] digest = MD5Digest.encode(user.getBytes("UTF-8"), password.getBytes("UTF-8"), md5Salt);
if (logger.logDebug())
{
logger.debug(" FE=> Password(md5digest=" + new String(digest, "US-ASCII") + ")");
}
pgStream.SendChar('p');
pgStream.SendInteger4(4 + digest.length + 1);
pgStream.Send(digest);
pgStream.SendChar(0);
pgStream.flush();
break;
}
case AUTH_REQ_PASSWORD:
{
if (logger.logDebug())
{
logger.debug(" <=BE AuthenticationReqPassword");
logger.debug(" FE=> Password(password=)");
}
if (password == null)
throw new PSQLException(GT.tr("The server requested password-based authentication, but no password was provided."), PSQLState.CONNECTION_REJECTED);
byte[] encodedPassword = password.getBytes("UTF-8");
pgStream.SendChar('p');
pgStream.SendInteger4(4 + encodedPassword.length + 1);
pgStream.Send(encodedPassword);
pgStream.SendChar(0);
pgStream.flush();
break;
}
case AUTH_REQ_GSS:
case AUTH_REQ_SSPI:
org.postgresql.gss.MakeGSS.authenticate(pgStream, host,
user, password,
info.getProperty("jaasApplicationName"),
info.getProperty("kerberosServerName"),
logger,
Boolean.valueOf(info.getProperty("useSpnego")).booleanValue());
break;
case AUTH_REQ_OK:
if (logger.logDebug())
logger.debug(" <=BE AuthenticationOk");
return ; // We're done.
default:
if (logger.logDebug())
logger.debug(" <=BE AuthenticationReq (unsupported type " + ((int)areq) + ")");
throw new PSQLException(GT.tr("The authentication type {0} is not supported. Check that you have configured the pg_hba.conf file to include the client''s IP address or subnet, and that it is using an authentication scheme supported by the driver.", new Integer(areq)), PSQLState.CONNECTION_REJECTED);
}
break;
default:
throw new PSQLException(GT.tr("Protocol error. Session setup failed."), PSQLState.PROTOCOL_VIOLATION);
}
}
}
private void readStartupMessages(PGStream pgStream, ProtocolConnectionImpl protoConnection, Logger logger) throws IOException, SQLException {
while (true)
{
int beresp = pgStream.ReceiveChar();
switch (beresp)
{
case 'Z':
// Ready For Query; we're done.
if (pgStream.ReceiveInteger4() != 5)
throw new IOException("unexpected length of ReadyForQuery packet");
char tStatus = (char)pgStream.ReceiveChar();
if (logger.logDebug())
logger.debug(" <=BE ReadyForQuery(" + tStatus + ")");
// Update connection state.
switch (tStatus)
{
case 'I':
protoConnection.setTransactionState(ProtocolConnection.TRANSACTION_IDLE);
break;
case 'T':
protoConnection.setTransactionState(ProtocolConnection.TRANSACTION_OPEN);
break;
case 'E':
protoConnection.setTransactionState(ProtocolConnection.TRANSACTION_FAILED);
break;
default:
// Huh?
break;
}
return ;
case 'K':
// BackendKeyData
int l_msgLen = pgStream.ReceiveInteger4();
if (l_msgLen != 12)
throw new PSQLException(GT.tr("Protocol error. Session setup failed."), PSQLState.PROTOCOL_VIOLATION);
int pid = pgStream.ReceiveInteger4();
int ckey = pgStream.ReceiveInteger4();
if (logger.logDebug())
logger.debug(" <=BE BackendKeyData(pid=" + pid + ",ckey=" + ckey + ")");
protoConnection.setBackendKeyData(pid, ckey);
break;
case 'E':
// Error
int l_elen = pgStream.ReceiveInteger4();
ServerErrorMessage l_errorMsg = new ServerErrorMessage(pgStream.ReceiveString(l_elen - 4), logger.getLogLevel());
if (logger.logDebug())
logger.debug(" <=BE ErrorMessage(" + l_errorMsg + ")");
throw new PSQLException(l_errorMsg);
case 'N':
// Warning
int l_nlen = pgStream.ReceiveInteger4();
ServerErrorMessage l_warnMsg = new ServerErrorMessage(pgStream.ReceiveString(l_nlen - 4), logger.getLogLevel());
if (logger.logDebug())
logger.debug(" <=BE NoticeResponse(" + l_warnMsg + ")");
protoConnection.addWarning(new PSQLWarning(l_warnMsg));
break;
case 'S':
// ParameterStatus
int l_len = pgStream.ReceiveInteger4();
String name = pgStream.ReceiveString();
String value = pgStream.ReceiveString();
if (logger.logDebug())
logger.debug(" <=BE ParameterStatus(" + name + " = " + value + ")");
if (name.equals("server_version"))
protoConnection.setServerVersion(value);
else if (name.equals("client_encoding"))
{
if (!value.equals("UTF8"))
throw new PSQLException(GT.tr("Protocol error. Session setup failed."), PSQLState.PROTOCOL_VIOLATION);
pgStream.setEncoding(Encoding.getDatabaseEncoding("UTF8"));
}
else if (name.equals("standard_conforming_strings"))
{
if (value.equals("on"))
protoConnection.setStandardConformingStrings(true);
else if (value.equals("off"))
protoConnection.setStandardConformingStrings(false);
else
throw new PSQLException(GT.tr("Protocol error. Session setup failed."), PSQLState.PROTOCOL_VIOLATION);
}
else if (name.equals("integer_datetimes"))
{
if (value.equals("on"))
protoConnection.setIntegerDateTimes(true);
else if (value.equals("off"))
protoConnection.setIntegerDateTimes(false);
else
throw new PSQLException(GT.tr("Protocol error. Session setup failed."), PSQLState.PROTOCOL_VIOLATION);
}
break;
default:
if (logger.logDebug())
logger.debug("invalid message type=" + (char)beresp);
throw new PSQLException(GT.tr("Protocol error. Session setup failed."), PSQLState.PROTOCOL_VIOLATION);
}
}
}
private void runInitialQueries(ProtocolConnection protoConnection, Properties info, Logger logger) throws SQLException
{
String dbVersion = protoConnection.getServerVersion();
if (dbVersion.compareTo("9.0") >= 0) {
SetupQueryRunner.run(protoConnection, "SET extra_float_digits = 3", false);
}
String appName = info.getProperty("ApplicationName");
if (appName != null && dbVersion.compareTo("9.0") >= 0) {
StringBuffer sql = new StringBuffer();
sql.append("SET application_name = '");
Utils.appendEscapedLiteral(sql, appName, protoConnection.getStandardConformingStrings());
sql.append("'");
SetupQueryRunner.run(protoConnection, sql.toString(), false);
}
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/v3/CopyInImpl.java 0000664 0000000 0000000 00000004221 12050675701 0024777 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2009-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.core.v3;
import java.sql.SQLException;
import org.postgresql.copy.CopyIn;
/**
* Anticipated flow of a COPY FROM STDIN operation:
*
* 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 {
public void writeToCopy(byte[] data, int off, int siz) throws SQLException {
queryExecutor.writeToCopy(this, data, off, siz);
}
public void flushCopy() throws SQLException {
queryExecutor.flushCopy(this);
}
public long endCopy() throws SQLException {
return queryExecutor.endCopy(this);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/v3/CopyOperationImpl.java 0000664 0000000 0000000 00000003253 12050675701 0026375 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2009-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.core.v3;
import java.sql.SQLException;
import org.postgresql.copy.CopyOperation;
import org.postgresql.util.GT;
import org.postgresql.util.PSQLException;
import org.postgresql.util.PSQLState;
public class CopyOperationImpl implements CopyOperation {
QueryExecutorImpl queryExecutor;
int rowFormat;
int[] fieldFormats;
long handledRowCount = -1;
void init(QueryExecutorImpl q, int fmt, int[] fmts) {
queryExecutor = q;
rowFormat = fmt;
fieldFormats = fmts;
}
public void cancelCopy() throws SQLException {
queryExecutor.cancelCopy(this);
}
public int getFieldCount() {
return fieldFormats.length;
}
public int getFieldFormat(int field) {
return fieldFormats[field];
}
public int getFormat() {
return rowFormat;
}
public boolean isActive() {
synchronized(queryExecutor) {
return queryExecutor.hasLock(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);
}
}
public long getHandledRowCount() {
return handledRowCount;
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/v3/CopyOutImpl.java 0000664 0000000 0000000 00000003435 12050675701 0025206 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2009-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.core.v3;
import java.sql.SQLException;
import org.postgresql.copy.CopyOut;
/**
* 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[] currentDataRow;
public byte[] readFromCopy() throws SQLException {
currentDataRow = null;
queryExecutor.readFromCopy(this);
return currentDataRow;
}
void handleCopydata(byte[] data) {
currentDataRow = data;
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/v3/Portal.java 0000664 0000000 0000000 00000003452 12050675701 0024222 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
* Copyright (c) 2004, Open Cloud Limited.
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.core.v3;
import java.lang.ref.PhantomReference;
import org.postgresql.core.*;
/**
* 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(SimpleQuery query, String portalName) {
this.query = query;
this.portalName = portalName;
this.encodedName = Utils.encodeUTF8(portalName);
}
public void close() {
if (cleanupRef != null)
{
cleanupRef.clear();
cleanupRef.enqueue();
cleanupRef = null;
}
}
String getPortalName() {
return portalName;
}
byte[] getEncodedPortalName() {
return encodedName;
}
SimpleQuery getQuery() {
return query;
}
void setCleanupRef(PhantomReference cleanupRef) {
this.cleanupRef = cleanupRef;
}
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 SimpleQuery query;
private final String portalName;
private final byte[] encodedName;
private PhantomReference cleanupRef;
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/v3/ProtocolConnectionImpl.java 0000664 0000000 0000000 00000014365 12050675701 0027431 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
* Copyright (c) 2004, Open Cloud Limited.
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.core.v3;
import org.postgresql.PGNotification;
import org.postgresql.core.*;
import org.postgresql.util.HostSpec;
import java.sql.SQLException;
import java.sql.SQLWarning;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Set;
import java.util.HashSet;
import java.util.Properties;
/**
* ProtocolConnection implementation for the V3 protocol.
*
* @author Oliver Jowett (oliver@opencloud.com)
*/
class ProtocolConnectionImpl implements ProtocolConnection {
ProtocolConnectionImpl(PGStream pgStream, String user, String database, Properties info, Logger logger) {
this.pgStream = pgStream;
this.user = user;
this.database = database;
this.logger = logger;
this.executor = new QueryExecutorImpl(this, pgStream, info, logger);
// default value for server versions that don't report standard_conforming_strings
this.standardConformingStrings = false;
}
public HostSpec getHostSpec() {
return pgStream.getHostSpec();
}
public String getUser() {
return user;
}
public String getDatabase() {
return database;
}
public String getServerVersion() {
return serverVersion;
}
public synchronized boolean getStandardConformingStrings()
{
return standardConformingStrings;
}
public synchronized int getTransactionState()
{
return transactionState;
}
public synchronized PGNotification[] getNotifications() throws SQLException {
PGNotification[] array = (PGNotification[])notifications.toArray(new PGNotification[notifications.size()]);
notifications.clear();
return array;
}
public synchronized SQLWarning getWarnings()
{
SQLWarning chain = warnings;
warnings = null;
return chain;
}
public QueryExecutor getQueryExecutor() {
return executor;
}
public void sendQueryCancel() throws SQLException {
PGStream cancelStream = null;
// Now we need to construct and send a cancel packet
try
{
if (logger.logDebug())
logger.debug(" FE=> CancelRequest(pid=" + cancelPid + ",ckey=" + cancelKey + ")");
cancelStream = new PGStream(pgStream.getHostSpec());
cancelStream.SendInteger4(16);
cancelStream.SendInteger2(1234);
cancelStream.SendInteger2(5678);
cancelStream.SendInteger4(cancelPid);
cancelStream.SendInteger4(cancelKey);
cancelStream.flush();
cancelStream.ReceiveEOF();
cancelStream.close();
cancelStream = null;
}
catch (IOException e)
{
// Safe to ignore.
if (logger.logDebug())
logger.debug("Ignoring exception on cancel request:", e);
}
finally
{
if (cancelStream != null)
{
try
{
cancelStream.close();
}
catch (IOException e)
{
// Ignored.
}
}
}
}
public void close() {
if (closed)
return ;
try
{
if (logger.logDebug())
logger.debug(" FE=> Terminate");
pgStream.SendChar('X');
pgStream.SendInteger4(4);
pgStream.flush();
pgStream.close();
}
catch (IOException ioe)
{
// Forget it.
if (logger.logDebug())
logger.debug("Discarding IOException on close:", ioe);
}
closed = true;
}
public Encoding getEncoding() {
return pgStream.getEncoding();
}
public boolean isClosed() {
return closed;
}
//
// Package-private accessors called during connection setup
//
void setServerVersion(String serverVersion) {
this.serverVersion = serverVersion;
}
void setBackendKeyData(int cancelPid, int cancelKey) {
this.cancelPid = cancelPid;
this.cancelKey = cancelKey;
}
//
// Package-private accessors called by the query executor
//
synchronized void addWarning(SQLWarning newWarning)
{
if (warnings == null)
warnings = newWarning;
else
warnings.setNextWarning(newWarning);
}
synchronized void addNotification(PGNotification notification)
{
notifications.add(notification);
}
synchronized void setTransactionState(int state)
{
transactionState = state;
}
synchronized void setStandardConformingStrings(boolean value)
{
standardConformingStrings = value;
}
public int getProtocolVersion()
{
return 3;
}
public boolean useBinaryForReceive(int oid) {
return useBinaryForOids.contains(oid);
}
public void setBinaryReceiveOids(Set oids) {
useBinaryForOids.clear();
useBinaryForOids.addAll(oids);
}
public void setIntegerDateTimes(boolean state) {
integerDateTimes = state;
}
public boolean getIntegerDateTimes() {
return integerDateTimes;
}
/**
* 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 Set useBinaryForOids = new HashSet();
private String serverVersion;
private int cancelPid;
private int cancelKey;
private boolean standardConformingStrings;
private int transactionState;
private SQLWarning warnings;
private boolean closed = false;
private final ArrayList notifications = new ArrayList();
private final PGStream pgStream;
private final String user;
private final String database;
private final QueryExecutorImpl executor;
private final Logger logger;
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/v3/QueryExecutorImpl.java 0000664 0000000 0000000 00000257434 12050675701 0026442 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2003-2011, PostgreSQL Global Development Group
* Copyright (c) 2004, Open Cloud Limited.
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.core.v3;
import org.postgresql.core.*;
import java.util.ArrayList;
import java.util.List;
import java.util.HashMap;
import java.util.Properties;
import java.lang.ref.*;
import java.io.IOException;
import java.sql.*;
import org.postgresql.util.PSQLException;
import org.postgresql.util.PSQLWarning;
import org.postgresql.util.PSQLState;
import org.postgresql.util.ServerErrorMessage;
import org.postgresql.util.GT;
import org.postgresql.copy.CopyOperation;
/**
* QueryExecutor implementation for the V3 protocol.
*/
public class QueryExecutorImpl implements QueryExecutor {
public QueryExecutorImpl(ProtocolConnectionImpl protoConnection, PGStream pgStream, Properties info, Logger logger) {
this.protoConnection = protoConnection;
this.pgStream = pgStream;
this.logger = logger;
if (info.getProperty("allowEncodingChanges") != null) {
this.allowEncodingChanges = Boolean.valueOf(info.getProperty("allowEncodingChanges")).booleanValue();
} else {
this.allowEncodingChanges = false;
}
}
/**
* 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 Object lockedFor = null;
/**
* 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;
this.notify();
}
/**
* 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 {
this.wait();
} catch(InterruptedException ie) {
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 hasLock(Object holder) {
return lockedFor == holder;
}
//
// Query parsing
//
public Query createSimpleQuery(String sql) {
return parseQuery(sql, false);
}
public Query createParameterizedQuery(String sql) {
return parseQuery(sql, true);
}
private Query parseQuery(String query, boolean withParameters) {
// Parse query and find parameter placeholders;
// also break the query into separate statements.
ArrayList statementList = new ArrayList();
ArrayList fragmentList = new ArrayList(15);
int fragmentStart = 0;
int inParen = 0;
boolean standardConformingStrings = protoConnection.getStandardConformingStrings();
char []aChars = query.toCharArray();
for (int i = 0; i < aChars.length; ++i)
{
switch (aChars[i])
{
case '\'': // single-quotes
i = Parser.parseSingleQuotes(aChars, i, standardConformingStrings);
break;
case '"': // double-quotes
i = Parser.parseDoubleQuotes(aChars, i);
break;
case '-': // possibly -- style comment
i = Parser.parseLineComment(aChars, i);
break;
case '/': // possibly /* */ style comment
i = Parser.parseBlockComment(aChars, i);
break;
case '$': // possibly dollar quote start
i = Parser.parseDollarQuotes(aChars, i);
break;
case '(':
inParen++;
break;
case ')':
inParen--;
break;
case '?':
if (withParameters)
{
fragmentList.add(query.substring(fragmentStart, i));
fragmentStart = i + 1;
}
break;
case ';':
if (inParen == 0)
{
fragmentList.add(query.substring(fragmentStart, i));
fragmentStart = i + 1;
if (fragmentList.size() > 1 || ((String)fragmentList.get(0)).trim().length() > 0)
statementList.add(fragmentList.toArray(new String[fragmentList.size()]));
fragmentList.clear();
}
break;
default:
break;
}
}
fragmentList.add(query.substring(fragmentStart));
if (fragmentList.size() > 1 || ((String)fragmentList.get(0)).trim().length() > 0)
statementList.add(fragmentList.toArray(new String[fragmentList.size()]));
if (statementList.isEmpty()) // Empty query.
return EMPTY_QUERY;
if (statementList.size() == 1)
{
// Only one statement.
return new SimpleQuery((String[]) statementList.get(0), protoConnection);
}
// Multiple statements.
SimpleQuery[] subqueries = new SimpleQuery[statementList.size()];
int[] offsets = new int[statementList.size()];
int offset = 0;
for (int i = 0; i < statementList.size(); ++i)
{
String[] fragments = (String[]) statementList.get(i);
offsets[i] = offset;
subqueries[i] = new SimpleQuery(fragments, protoConnection);
offset += fragments.length - 1;
}
return new CompositeQuery(subqueries, offsets);
}
//
// Query execution
//
public synchronized void execute(Query query,
ParameterList parameters,
ResultHandler handler,
int maxRows,
int fetchSize,
int flags)
throws SQLException
{
waitOnLock();
if (logger.logDebug())
{
logger.debug("simple execute, handler=" + handler +
", maxRows=" + maxRows + ", fetchSize=" + fetchSize + ", flags=" + flags);
}
if (parameters == null)
parameters = SimpleQuery.NO_PARAMETERS;
boolean describeOnly = (QUERY_DESCRIBE_ONLY & flags) != 0;
((V3ParameterList)parameters).convertFunctionOutParameters();
// Check parameters are all set..
if (!describeOnly)
((V3ParameterList)parameters).checkAllParametersSet();
try
{
try
{
handler = sendQueryPreamble(handler, flags);
ErrorTrackingResultHandler trackingHandler = new ErrorTrackingResultHandler(handler);
queryCount = 0;
sendQuery((V3Query)query, (V3ParameterList)parameters, maxRows, fetchSize, flags, trackingHandler);
sendSync();
processResults(handler, flags);
}
catch (PGBindException se)
{
// There are three causes of this error, an
// invalid total Bind message length, a
// BinaryStream that cannot provide the amount
// of data claimed by the length arugment, and
// a BinaryStream that throws an Exception
// when reading.
//
// We simply do not send the Execute message
// so we can just continue on as if nothing
// has happened. Perhaps we need to
// introduce an error here to force the
// caller to rollback if there is a
// transaction in progress?
//
sendSync();
processResults(handler, flags);
handler.handleError(new PSQLException(GT.tr("Unable to bind parameter values for statement."), PSQLState.INVALID_PARAMETER_VALUE, se.getIOException()));
}
}
catch (IOException e)
{
protoConnection.close();
handler.handleError(new PSQLException(GT.tr("An I/O error occured while sending to the backend."), PSQLState.CONNECTION_FAILURE, e));
}
handler.handleCompletion();
}
// Deadlock avoidance:
//
// It's possible for the send and receive streams to get "deadlocked" against each other since
// we do not have a separate thread. The scenario is this: we have two streams:
//
// driver -> TCP buffering -> server
// server -> TCP buffering -> driver
//
// The server behaviour is roughly:
// while true:
// read message
// execute message
// write results
//
// If the server -> driver stream has a full buffer, the write will block.
// If the driver is still writing when this happens, and the driver -> server
// stream also fills up, we deadlock: the driver is blocked on write() waiting
// for the server to read some more data, and the server is blocked on write()
// waiting for the driver to read some more data.
//
// To avoid this, we guess at how many queries we can send before the server ->
// driver stream's buffer is full (MAX_BUFFERED_QUERIES). This is the point where
// the server blocks on write and stops reading data. If we reach this point, we
// force a Sync message and read pending data from the server until ReadyForQuery,
// then go back to writing more queries unless we saw an error.
//
// This is not 100% reliable -- it's only done in the batch-query case and only
// at a reasonably high level (per query, not per message), and it's only an estimate
// -- so it might break. To do it correctly in all cases would seem to require a
// separate send or receive thread as we can only do the Sync-and-read-results
// operation at particular points, and also as we don't really know how much data
// the server is sending.
// Assume 64k server->client buffering and 250 bytes response per query (conservative).
private static final int MAX_BUFFERED_QUERIES = (64000 / 250);
// Helper handler that tracks error status.
private static class ErrorTrackingResultHandler implements ResultHandler {
private final ResultHandler delegateHandler;
private boolean sawError = false;
ErrorTrackingResultHandler(ResultHandler delegateHandler) {
this.delegateHandler = delegateHandler;
}
public void handleResultRows(Query fromQuery, Field[] fields, List tuples, ResultCursor cursor) {
delegateHandler.handleResultRows(fromQuery, fields, tuples, cursor);
}
public void handleCommandStatus(String status, int updateCount, long insertOID) {
delegateHandler.handleCommandStatus(status, updateCount, insertOID);
}
public void handleWarning(SQLWarning warning) {
delegateHandler.handleWarning(warning);
}
public void handleError(SQLException error) {
sawError = true;
delegateHandler.handleError(error);
}
public void handleCompletion() throws SQLException {
delegateHandler.handleCompletion();
}
boolean hasErrors() {
return sawError;
}
}
public synchronized void execute(Query[] queries,
ParameterList[] parameterLists,
ResultHandler handler,
int maxRows,
int fetchSize,
int flags)
throws SQLException
{
waitOnLock();
if (logger.logDebug())
{
logger.debug("batch execute " + queries.length + " queries, handler=" + handler +
", maxRows=" + maxRows + ", fetchSize=" + fetchSize + ", flags=" + flags);
}
boolean describeOnly = (QUERY_DESCRIBE_ONLY & flags) != 0;
// Check parameters and resolve OIDs.
if (!describeOnly) {
for (int i = 0; i < parameterLists.length; ++i)
{
if (parameterLists[i] != null)
((V3ParameterList)parameterLists[i]).checkAllParametersSet();
}
}
try
{
handler = sendQueryPreamble(handler, flags);
ErrorTrackingResultHandler trackingHandler = new ErrorTrackingResultHandler(handler);
queryCount = 0;
for (int i = 0; i < queries.length; ++i)
{
V3Query query = (V3Query)queries[i];
V3ParameterList parameters = (V3ParameterList)parameterLists[i];
if (parameters == null)
parameters = SimpleQuery.NO_PARAMETERS;
sendQuery(query, parameters, maxRows, fetchSize, flags, trackingHandler);
if (trackingHandler.hasErrors())
break;
}
if (!trackingHandler.hasErrors())
{
sendSync();
processResults(handler, flags);
}
}
catch (IOException e)
{
protoConnection.close();
handler.handleError(new PSQLException(GT.tr("An I/O error occured while sending to the backend."), PSQLState.CONNECTION_FAILURE, e));
}
handler.handleCompletion();
}
private ResultHandler sendQueryPreamble(final ResultHandler delegateHandler, int flags) throws IOException {
// First, send CloseStatements for finalized SimpleQueries that had statement names assigned.
processDeadParsedQueries();
processDeadPortals();
// Send BEGIN on first statement in transaction.
if ((flags & QueryExecutor.QUERY_SUPPRESS_BEGIN) != 0 ||
protoConnection.getTransactionState() != ProtocolConnection.TRANSACTION_IDLE)
return delegateHandler;
sendOneQuery(beginTransactionQuery, SimpleQuery.NO_PARAMETERS, 0, 0, QueryExecutor.QUERY_NO_METADATA);
// Insert a handler that intercepts the BEGIN.
return new ResultHandler() {
private boolean sawBegin = false;
public void handleResultRows(Query fromQuery, Field[] fields, List tuples, ResultCursor cursor) {
if (sawBegin)
delegateHandler.handleResultRows(fromQuery, fields, tuples, cursor);
}
public void handleCommandStatus(String status, int updateCount, long insertOID) {
if (!sawBegin)
{
sawBegin = true;
if (!status.equals("BEGIN"))
handleError(new PSQLException(GT.tr("Expected command status BEGIN, got {0}.", status),
PSQLState.PROTOCOL_VIOLATION));
}
else
{
delegateHandler.handleCommandStatus(status, updateCount, insertOID);
}
}
public void handleWarning(SQLWarning warning) {
delegateHandler.handleWarning(warning);
}
public void handleError(SQLException error) {
delegateHandler.handleError(error);
}
public void handleCompletion() throws SQLException{
delegateHandler.handleCompletion();
}
};
}
//
// Fastpath
//
public synchronized byte[]
fastpathCall(int fnid, ParameterList parameters, boolean suppressBegin) throws SQLException {
waitOnLock();
if (!suppressBegin)
{
doSubprotocolBegin();
}
try
{
sendFastpathCall(fnid, (SimpleParameterList)parameters);
return receiveFastpathResult();
}
catch (IOException ioe)
{
protoConnection.close();
throw new PSQLException(GT.tr("An I/O error occured while sending to the backend."), PSQLState.CONNECTION_FAILURE, ioe);
}
}
public void doSubprotocolBegin() throws SQLException {
if (protoConnection.getTransactionState() == ProtocolConnection.TRANSACTION_IDLE)
{
if (logger.logDebug())
logger.debug("Issuing BEGIN before fastpath or copy call.");
ResultHandler handler = new ResultHandler() {
private boolean sawBegin = false;
private SQLException sqle = null;
public void handleResultRows(Query fromQuery, Field[] fields, List tuples, ResultCursor cursor) {
}
public void handleCommandStatus(String status, int updateCount, long insertOID) {
if (!sawBegin)
{
if (!status.equals("BEGIN"))
handleError(new PSQLException(GT.tr("Expected command status BEGIN, got {0}.", status),
PSQLState.PROTOCOL_VIOLATION));
sawBegin = true;
}
else
{
handleError(new PSQLException(GT.tr("Unexpected command status: {0}.", status),
PSQLState.PROTOCOL_VIOLATION));
}
}
public void handleWarning(SQLWarning warning) {
// we don't want to ignore warnings and it would be tricky
// to chain them back to the connection, so since we don't
// expect to get them in the first place, we just consider
// them errors.
handleError(warning);
}
public void handleError(SQLException error) {
if (sqle == null)
{
sqle = error;
}
else
{
sqle.setNextException(error);
}
}
public void handleCompletion() throws SQLException{
if (sqle != null)
throw sqle;
}
};
try
{
sendOneQuery(beginTransactionQuery, SimpleQuery.NO_PARAMETERS, 0, 0, QueryExecutor.QUERY_NO_METADATA);
sendSync();
processResults(handler, 0);
}
catch (IOException ioe)
{
throw new PSQLException(GT.tr("An I/O error occured while sending to the backend."), PSQLState.CONNECTION_FAILURE, ioe);
}
}
}
public ParameterList createFastpathParameters(int count) {
return new SimpleParameterList(count, protoConnection);
}
private void sendFastpathCall(int fnid, SimpleParameterList params) throws SQLException, IOException {
if (logger.logDebug())
logger.debug(" FE=> FunctionCall(" + fnid + ", " + params.getParameterCount() + " params)");
//
// Total size = 4 (length)
// + 4 (function OID)
// + 2 (format code count) + N * 2 (format codes)
// + 2 (parameter count) + encodedSize (parameters)
// + 2 (result format)
int paramCount = params.getParameterCount();
int encodedSize = 0;
for (int i = 1; i <= paramCount; ++i)
{
if (params.isNull(i))
encodedSize += 4;
else
encodedSize += 4 + params.getV3Length(i);
}
pgStream.SendChar('F');
pgStream.SendInteger4(4 + 4 + 2 + 2 * paramCount + 2 + encodedSize + 2);
pgStream.SendInteger4(fnid);
pgStream.SendInteger2(paramCount);
for (int i = 1; i <= paramCount; ++i)
pgStream.SendInteger2(params.isBinary(i) ? 1 : 0);
pgStream.SendInteger2(paramCount);
for (int i = 1; i <= paramCount; i++)
{
if (params.isNull(i))
{
pgStream.SendInteger4( -1);
}
else
{
pgStream.SendInteger4(params.getV3Length(i)); // Parameter size
params.writeV3Value(i, pgStream);
}
}
pgStream.SendInteger2(1); // Binary result format
pgStream.flush();
}
public synchronized void processNotifies() throws SQLException {
waitOnLock();
// Asynchronous notifies only arrive when we are not in a transaction
if (protoConnection.getTransactionState() != ProtocolConnection.TRANSACTION_IDLE)
return;
try {
while (pgStream.hasMessagePending()) {
int c = pgStream.ReceiveChar();
switch (c) {
case 'A': // Asynchronous Notify
receiveAsyncNotify();
break;
case 'E': // Error Response (response to pretty much everything; backend then skips until Sync)
throw receiveErrorResponse();
// break;
case 'N': // Notice Response (warnings / info)
SQLWarning warning = receiveNoticeResponse();
protoConnection.addWarning(warning);
break;
default:
throw new PSQLException(GT.tr("Unknown Response Type {0}.", new Character((char) c)), PSQLState.CONNECTION_FAILURE);
}
}
} catch (IOException ioe) {
throw new PSQLException(GT.tr("An I/O error occured while sending to the backend."), PSQLState.CONNECTION_FAILURE, ioe);
}
}
private byte[] receiveFastpathResult() throws IOException, SQLException {
boolean endQuery = false;
SQLException error = null;
byte[] returnValue = null;
while (!endQuery)
{
int c = pgStream.ReceiveChar();
switch (c)
{
case 'A': // Asynchronous Notify
receiveAsyncNotify();
break;
case 'E': // Error Response (response to pretty much everything; backend then skips until Sync)
SQLException newError = receiveErrorResponse();
if (error == null)
error = newError;
else
error.setNextException(newError);
// keep processing
break;
case 'N': // Notice Response (warnings / info)
SQLWarning warning = receiveNoticeResponse();
protoConnection.addWarning(warning);
break;
case 'Z': // Ready For Query (eventual response to Sync)
receiveRFQ();
endQuery = true;
break;
case 'V': // FunctionCallResponse
int msgLen = pgStream.ReceiveInteger4();
int valueLen = pgStream.ReceiveInteger4();
if (logger.logDebug())
logger.debug(" <=BE FunctionCallResponse(" + valueLen + " bytes)");
if (valueLen != -1)
{
byte buf[] = new byte[valueLen];
pgStream.Receive(buf, 0, valueLen);
returnValue = buf;
}
break;
default:
throw new PSQLException(GT.tr("Unknown Response Type {0}.", new Character((char) c)), PSQLState.CONNECTION_FAILURE);
}
}
// did we get an error during this query?
if (error != null)
throw error;
return returnValue;
}
//
// Copy subprotocol implementation
//
/**
* Sends given query to BE to start, initialize and lock connection for a CopyOperation.
* @param sql COPY FROM STDIN / COPY TO STDOUT statement
* @return CopyIn or CopyOut operation object
* @throws SQLException on failure
*/
public synchronized CopyOperation startCopy(String sql, boolean suppressBegin) throws SQLException {
waitOnLock();
if (!suppressBegin) {
doSubprotocolBegin();
}
byte buf[] = Utils.encodeUTF8(sql);
try {
if (logger.logDebug())
logger.debug(" FE=> Query(CopyStart)");
pgStream.SendChar('Q');
pgStream.SendInteger4(buf.length + 4 + 1);
pgStream.Send(buf);
pgStream.SendChar(0);
pgStream.flush();
return processCopyResults(null, true); // expect a CopyInResponse or CopyOutResponse to our query above
} catch(IOException ioe) {
throw new PSQLException(GT.tr("Database connection failed when starting copy"), PSQLState.CONNECTION_FAILURE, ioe);
}
}
/**
* Locks connection and calls initializer for a new CopyOperation
* Called via startCopy -> processCopyResults
* @param op an unitialized CopyOperation
* @throws SQLException on locking failure
* @throws IOException on database connection failure
*/
private synchronized void initCopy(CopyOperationImpl op) throws SQLException, IOException {
pgStream.ReceiveInteger4(); // length not used
int rowFormat = pgStream.ReceiveChar();
int numFields = pgStream.ReceiveInteger2();
int[] fieldFormats = new int[numFields];
for(int i=0; i CopyFail");
}
final byte[] msg = Utils.encodeUTF8("Copy cancel requested");
pgStream.SendChar('f'); // CopyFail
pgStream.SendInteger4(5 + msg.length);
pgStream.Send(msg);
pgStream.SendChar(0);
pgStream.flush();
do {
try {
processCopyResults(op, true); // discard rest of input
} catch(SQLException se) { // expected error response to failing copy
errors++;
if( error != null ) {
SQLException e = se, next;
while( (next = e.getNextException()) != null )
e = next;
e.setNextException(error);
}
error = se;
}
} while(hasLock(op));
}
} else if (op instanceof CopyOutImpl) {
protoConnection.sendQueryCancel();
}
} catch(IOException ioe) {
throw new PSQLException(GT.tr("Database connection failed when canceling copy operation"), PSQLState.CONNECTION_FAILURE, ioe);
}
if (op instanceof CopyInImpl) {
if(errors < 1) {
throw new PSQLException(GT.tr("Missing expected error response to copy cancel request"), PSQLState.COMMUNICATION_ERROR);
} else if(errors > 1) {
throw new PSQLException(GT.tr("Got {0} error responses to single copy cancel request", String.valueOf(errors)), PSQLState.COMMUNICATION_ERROR, error);
}
}
}
/**
* Finishes writing to copy and unlocks connection
* @param op the copy operation presumably currently holding lock on this connection
* @return number of rows updated for server versions 8.2 or newer
* @throws SQLException on failure
*/
public synchronized long endCopy(CopyInImpl op) throws SQLException {
if(!hasLock(op))
throw new PSQLException(GT.tr("Tried to end inactive copy"), PSQLState.OBJECT_NOT_IN_STATE);
try {
if (logger.logDebug())
logger.debug(" FE=> CopyDone");
pgStream.SendChar('c'); // CopyDone
pgStream.SendInteger4(4);
pgStream.flush();
processCopyResults(op, true);
return op.getHandledRowCount();
} catch(IOException ioe) {
throw new PSQLException(GT.tr("Database connection failed when ending copy"), PSQLState.CONNECTION_FAILURE, ioe);
}
}
/**
* Sends data during a live COPY IN operation. Only unlocks the connection if server
* suddenly returns CommandComplete, which should not happen
* @param op the CopyIn operation presumably currently holding lock on this connection
* @param data bytes to send
* @param off index of first byte to send (usually 0)
* @param siz number of bytes to send (usually data.length)
* @throws SQLException on failure
*/
public synchronized void writeToCopy(CopyInImpl op, byte[] data, int off, int siz) throws SQLException {
if(!hasLock(op))
throw new PSQLException(GT.tr("Tried to write to an inactive copy operation"), PSQLState.OBJECT_NOT_IN_STATE);
if (logger.logDebug())
logger.debug(" FE=> CopyData(" + siz + ")");
try {
pgStream.SendChar('d');
pgStream.SendInteger4(siz + 4);
pgStream.Send(data, off, siz);
processCopyResults(op, false); // collect any pending notifications without blocking
} catch(IOException ioe) {
throw new PSQLException(GT.tr("Database connection failed when writing to copy"), PSQLState.CONNECTION_FAILURE, ioe);
}
}
public synchronized void flushCopy(CopyInImpl op) throws SQLException {
if(!hasLock(op))
throw new PSQLException(GT.tr("Tried to write to an inactive copy operation"), PSQLState.OBJECT_NOT_IN_STATE);
try {
pgStream.flush();
processCopyResults(op, false); // collect any pending notifications without blocking
} catch(IOException ioe) {
throw new PSQLException(GT.tr("Database connection failed when writing to copy"), PSQLState.CONNECTION_FAILURE, ioe);
}
}
/**
* Blocks to wait for a row of data to be received from server on an active copy operation
* Connection gets unlocked by processCopyResults() at end of operation
* @param op the copy operation presumably currently holding lock on this connection
* @throws SQLException on any failure
*/
synchronized void readFromCopy(CopyOutImpl op) throws SQLException {
if(!hasLock(op))
throw new PSQLException(GT.tr("Tried to read from inactive copy"), PSQLState.OBJECT_NOT_IN_STATE);
try {
processCopyResults(op, true); // expect a call to handleCopydata() to store the data
} catch(IOException ioe) {
throw new PSQLException(GT.tr("Database connection failed when reading from copy"), PSQLState.CONNECTION_FAILURE, ioe);
}
}
/**
* Handles copy sub protocol responses from server.
* Unlocks at end of sub protocol,
* so operations on pgStream or QueryExecutor are not allowed in a method after calling this!
* @param block whether to block waiting for input
* @return
* CopyIn when COPY FROM STDIN starts;
* CopyOut when COPY TO STDOUT starts;
* null when copy ends;
* otherwise, the operation given as parameter.
* @throws SQLException in case of misuse
* @throws IOException from the underlying connection
*/
CopyOperationImpl processCopyResults(CopyOperationImpl op, boolean block) throws SQLException, IOException {
boolean endReceiving = false;
SQLException error = null, errors = null;
int len;
while( !endReceiving && (block || pgStream.hasMessagePending()) ) {
// There is a bug in the server's implementation of the copy
// protocol. It returns command complete immediately upon
// receiving the EOF marker in the binary protocol,
// potentially before we've issued CopyDone. When we are not
// blocking, we don't think we are done, so we hold off on
// processing command complete and any subsequent messages
// until we actually are done with the copy.
//
if (!block) {
int c = pgStream.PeekChar();
if (c == 'C') // CommandComplete
{
if (logger.logDebug())
logger.debug(" <=BE CommandStatus, Ignored until CopyDone");
break;
}
}
int c = pgStream.ReceiveChar();
switch(c) {
case 'A': // Asynchronous Notify
if (logger.logDebug())
logger.debug(" <=BE Asynchronous Notification while copying");
receiveAsyncNotify();
break;
case 'N': // Notice Response
if (logger.logDebug())
logger.debug(" <=BE Notification while copying");
protoConnection.addWarning(receiveNoticeResponse());
break;
case 'C': // Command Complete
String status = receiveCommandStatus();
try {
if(op == null)
throw new PSQLException(GT.tr("Received CommandComplete ''{0}'' without an active copy operation", status), PSQLState.OBJECT_NOT_IN_STATE);
op.handleCommandStatus(status);
} catch(SQLException se) {
error = se;
}
block = true;
break;
case 'E': // ErrorMessage (expected response to CopyFail)
error = receiveErrorResponse();
// We've received the error and we now expect to receive
// Ready for query, but we must block because it might still be
// on the wire and not here yet.
block = true;
break;
case 'G': // CopyInResponse
if (logger.logDebug())
logger.debug(" <=BE CopyInResponse");
if(op != null)
error = new PSQLException(GT.tr("Got CopyInResponse from server during an active {0}", op.getClass().getName()), PSQLState.OBJECT_NOT_IN_STATE);
op = new CopyInImpl();
initCopy(op);
endReceiving = true;
break;
case 'H': // CopyOutResponse
if (logger.logDebug())
logger.debug(" <=BE CopyOutResponse");
if(op != null)
error = new PSQLException(GT.tr("Got CopyOutResponse from server during an active {0}", op.getClass().getName()), PSQLState.OBJECT_NOT_IN_STATE);
op = new CopyOutImpl();
initCopy(op);
endReceiving = true;
break;
case 'd': // CopyData
if (logger.logDebug())
logger.debug(" <=BE CopyData");
len = pgStream.ReceiveInteger4() - 4;
byte[] buf = pgStream.Receive(len);
if(op == null) {
error = new PSQLException(GT.tr("Got CopyData without an active copy operation"), PSQLState.OBJECT_NOT_IN_STATE);
} else if (!(op instanceof CopyOutImpl)) {
error = new PSQLException(GT.tr("Unexpected copydata from server for {0}",
op.getClass().getName()), PSQLState.COMMUNICATION_ERROR);
} else {
((CopyOutImpl)op).handleCopydata(buf);
}
endReceiving = true;
break;
case 'c': // CopyDone (expected after all copydata received)
if (logger.logDebug())
logger.debug(" <=BE CopyDone");
len = pgStream.ReceiveInteger4() - 4;
if(len > 0)
pgStream.Receive(len); // not in specification; should never appear
if(!(op instanceof CopyOutImpl))
error = new PSQLException("Got CopyDone while not copying from server", PSQLState.OBJECT_NOT_IN_STATE);
// keep receiving since we expect a CommandComplete
block = true;
break;
case 'Z': // ReadyForQuery: After FE:CopyDone => BE:CommandComplete
receiveRFQ();
if(hasLock(op))
unlock(op);
op = null;
endReceiving = true;
break;
// If the user sends a non-copy query, we've got to handle some additional things.
//
case 'T': // Row Description (response to Describe)
if (logger.logDebug())
logger.debug(" <=BE RowDescription (during copy ignored)");
skipMessage();
break;
case 'D': // DataRow
if (logger.logDebug())
logger.debug(" <=BE DataRow (during copy ignored)");
skipMessage();
break;
default:
throw new IOException(GT.tr("Unexpected packet type during copy: {0}", Integer.toString(c)));
}
// Collect errors into a neat chain for completeness
if(error != null) {
if(errors != null)
error.setNextException(errors);
errors = error;
error = null;
}
}
if(errors != null)
throw errors;
return op;
}
/*
* Send a query to the backend.
*/
private void sendQuery(V3Query query, V3ParameterList parameters, int maxRows, int fetchSize, int flags, ErrorTrackingResultHandler trackingHandler) throws IOException, SQLException {
// Now the query itself.
SimpleQuery[] subqueries = query.getSubqueries();
SimpleParameterList[] subparams = parameters.getSubparams();
boolean disallowBatching = (flags & QueryExecutor.QUERY_DISALLOW_BATCHING) != 0;
if (subqueries == null)
{
++queryCount;
if (disallowBatching || queryCount >= MAX_BUFFERED_QUERIES)
{
sendSync();
processResults(trackingHandler, flags);
queryCount = 0;
}
// If we saw errors, don't send anything more.
if (!trackingHandler.hasErrors())
sendOneQuery((SimpleQuery)query, (SimpleParameterList)parameters, maxRows, fetchSize, flags);
}
else
{
for (int i = 0; i < subqueries.length; ++i)
{
++queryCount;
if (disallowBatching || queryCount >= MAX_BUFFERED_QUERIES)
{
sendSync();
processResults(trackingHandler, flags);
// If we saw errors, don't send anything more.
if (trackingHandler.hasErrors())
break;
queryCount = 0;
}
// In the situation where parameters is already
// NO_PARAMETERS it cannot know the correct
// number of array elements to return in the
// above call to getSubparams(), so it must
// return null which we check for here.
//
SimpleParameterList subparam = SimpleQuery.NO_PARAMETERS;
if (subparams != null)
{
subparam = subparams[i];
}
sendOneQuery(subqueries[i], subparam, maxRows, fetchSize, flags);
}
}
}
//
// Message sending
//
private void sendSync() throws IOException {
if (logger.logDebug())
logger.debug(" FE=> Sync");
pgStream.SendChar('S'); // Sync
pgStream.SendInteger4(4); // Length
pgStream.flush();
}
private void sendParse(SimpleQuery query, SimpleParameterList params, boolean oneShot) throws IOException {
// Already parsed, or we have a Parse pending and the types are right?
int[] typeOIDs = params.getTypeOIDs();
if (query.isPreparedFor(typeOIDs))
return;
// Clean up any existing statement, as we can't use it.
query.unprepare();
processDeadParsedQueries();
// Remove any cached Field values
query.setFields(null);
String statementName = null;
if (!oneShot)
{
// Generate a statement name to use.
statementName = "S_" + (nextUniqueID++);
// And prepare the new statement.
// NB: Must clone the OID array, as it's a direct reference to
// the SimpleParameterList's internal array that might be modified
// under us.
query.setStatementName(statementName);
query.setStatementTypes((int[])typeOIDs.clone());
}
byte[] encodedStatementName = query.getEncodedStatementName();
String[] fragments = query.getFragments();
if (logger.logDebug())
{
StringBuffer sbuf = new StringBuffer(" FE=> Parse(stmt=" + statementName + ",query=\"");
for (int i = 0; i < fragments.length; ++i)
{
if (i > 0)
sbuf.append("$" + i);
sbuf.append(fragments[i]);
}
sbuf.append("\",oids={");
for (int i = 1; i <= params.getParameterCount(); ++i)
{
if (i != 1)
sbuf.append(",");
sbuf.append("" + params.getTypeOID(i));
}
sbuf.append("})");
logger.debug(sbuf.toString());
}
//
// Send Parse.
//
byte[][] parts = new byte[fragments.length * 2 - 1][];
int j = 0;
int encodedSize = 0;
// Total size = 4 (size field)
// + N + 1 (statement name, zero-terminated)
// + N + 1 (query, zero terminated)
// + 2 (parameter count) + N * 4 (parameter types)
// original query: "frag0 ? frag1 ? frag2"
// fragments: { "frag0", "frag1", "frag2" }
// output: "frag0 $1 frag1 $2 frag2"
for (int i = 0; i < fragments.length; ++i)
{
if (i != 0)
{
parts[j] = Utils.encodeUTF8("$" + i);
encodedSize += parts[j].length;
++j;
}
parts[j] = Utils.encodeUTF8(fragments[i]);
encodedSize += parts[j].length;
++j;
}
encodedSize = 4
+ (encodedStatementName == null ? 0 : encodedStatementName.length) + 1
+ encodedSize + 1
+ 2 + 4 * params.getParameterCount();
pgStream.SendChar('P'); // Parse
pgStream.SendInteger4(encodedSize);
if (encodedStatementName != null)
pgStream.Send(encodedStatementName);
pgStream.SendChar(0); // End of statement name
for (int i = 0; i < parts.length; ++i)
{ // Query string
pgStream.Send(parts[i]);
}
pgStream.SendChar(0); // End of query string.
pgStream.SendInteger2(params.getParameterCount()); // # of parameter types specified
for (int i = 1; i <= params.getParameterCount(); ++i)
pgStream.SendInteger4(params.getTypeOID(i));
pendingParseQueue.add(new Object[]{query, query.getStatementName()});
}
private void sendBind(SimpleQuery query, SimpleParameterList params,
Portal portal, boolean noBinaryTransfer) throws IOException {
//
// Send Bind.
//
String statementName = query.getStatementName();
byte[] encodedStatementName = query.getEncodedStatementName();
byte[] encodedPortalName = (portal == null ? null : portal.getEncodedPortalName());
if (logger.logDebug())
{
StringBuffer sbuf = new StringBuffer(" FE=> Bind(stmt=" + statementName + ",portal=" + portal);
for (int i = 1; i <= params.getParameterCount(); ++i)
{
sbuf.append(",$" + i + "=<" + params.toString(i) + ">");
}
sbuf.append(")");
logger.debug(sbuf.toString());
}
// Total size = 4 (size field) + N + 1 (destination portal)
// + N + 1 (statement name)
// + 2 (param format code count) + N * 2 (format codes)
// + 2 (param value count) + N (encoded param value size)
// + 2 (result format code count, 0)
long encodedSize = 0;
for (int i = 1; i <= params.getParameterCount(); ++i)
{
if (params.isNull(i))
encodedSize += 4;
else
encodedSize += (long)4 + params.getV3Length(i);
}
// This is not the number of binary fields, but the total number
// of fields if any of them are binary or zero if all of them
// are text.
int numBinaryFields = 0;
Field[] fields = query.getFields();
if (!noBinaryTransfer && fields != null) {
for (int i = 0; i < fields.length; ++i) {
if (useBinary(fields[i])) {
fields[i].setFormat(Field.BINARY_FORMAT);
numBinaryFields = fields.length;
}
}
}
encodedSize = 4
+ (encodedPortalName == null ? 0 : encodedPortalName.length) + 1
+ (encodedStatementName == null ? 0 : encodedStatementName.length) + 1
+ 2 + params.getParameterCount() * 2
+ 2 + encodedSize
+ 2 + numBinaryFields * 2;
// backend's MaxAllocSize is the largest message that can
// be received from a client. If we have a bigger value
// from either very large parameters or incorrent length
// descriptions of setXXXStream we do not send the bind
// messsage.
//
if (encodedSize > 0x3fffffff)
{
throw new PGBindException(new IOException(GT.tr("Bind message length {0} too long. This can be caused by very large or incorrect length specifications on InputStream parameters.", new Long(encodedSize))));
}
pgStream.SendChar('B'); // Bind
pgStream.SendInteger4((int)encodedSize); // Message size
if (encodedPortalName != null)
pgStream.Send(encodedPortalName); // Destination portal name.
pgStream.SendChar(0); // End of portal name.
if (encodedStatementName != null)
pgStream.Send(encodedStatementName); // Source statement name.
pgStream.SendChar(0); // End of statement name.
pgStream.SendInteger2(params.getParameterCount()); // # of parameter format codes
for (int i = 1; i <= params.getParameterCount(); ++i)
pgStream.SendInteger2(params.isBinary(i) ? 1 : 0); // Parameter format code
pgStream.SendInteger2(params.getParameterCount()); // # of parameter values
// If an error occurs when reading a stream we have to
// continue pumping out data to match the length we
// said we would. Once we've done that we throw
// this exception. Multiple exceptions can occur and
// it really doesn't matter which one is reported back
// to the caller.
//
PGBindException bindException = null;
for (int i = 1; i <= params.getParameterCount(); ++i)
{
if (params.isNull(i))
pgStream.SendInteger4( -1); // Magic size of -1 means NULL
else
{
pgStream.SendInteger4(params.getV3Length(i)); // Parameter size
try
{
params.writeV3Value(i, pgStream); // Parameter value
}
catch (PGBindException be)
{
bindException = be;
}
}
}
pgStream.SendInteger2(numBinaryFields); // # of result format codes
for (int i = 0; i < numBinaryFields; ++i) {
pgStream.SendInteger2(fields[i].getFormat());
}
pendingBindQueue.add(portal);
if (bindException != null)
{
throw bindException;
}
}
/**
* Returns true if the specified field should be retrieved using binary
* encoding.
*
* @param field The field whose Oid type to analyse.
* @return True if {@link Field#BINARY_FORMAT} should be used, false if
* {@link Field#BINARY_FORMAT}.
*/
private boolean useBinary(Field field) {
int oid = field.getOID();
return protoConnection.useBinaryForReceive(oid);
}
private void sendDescribePortal(SimpleQuery query, Portal portal) throws IOException {
//
// Send Describe.
//
if (logger.logDebug())
{
logger.debug(" FE=> Describe(portal=" + portal + ")");
}
byte[] encodedPortalName = (portal == null ? null : portal.getEncodedPortalName());
// Total size = 4 (size field) + 1 (describe type, 'P') + N + 1 (portal name)
int encodedSize = 4 + 1 + (encodedPortalName == null ? 0 : encodedPortalName.length) + 1;
pgStream.SendChar('D'); // Describe
pgStream.SendInteger4(encodedSize); // message size
pgStream.SendChar('P'); // Describe (Portal)
if (encodedPortalName != null)
pgStream.Send(encodedPortalName); // portal name to close
pgStream.SendChar(0); // end of portal name
pendingDescribePortalQueue.add(query);
query.setPortalDescribed(true);
}
private void sendDescribeStatement(SimpleQuery query, SimpleParameterList params, boolean describeOnly) throws IOException {
// Send Statement Describe
if (logger.logDebug())
{
logger.debug(" FE=> Describe(statement=" + query.getStatementName()+")");
}
byte[] encodedStatementName = query.getEncodedStatementName();
// Total size = 4 (size field) + 1 (describe type, 'S') + N + 1 (portal name)
int encodedSize = 4 + 1 + (encodedStatementName == null ? 0 : encodedStatementName.length) + 1;
pgStream.SendChar('D'); // Describe
pgStream.SendInteger4(encodedSize); // Message size
pgStream.SendChar('S'); // Describe (Statement);
if (encodedStatementName != null)
pgStream.Send(encodedStatementName); // Statement name
pgStream.SendChar(0); // end message
pendingDescribeStatementQueue.add(new Object[]{query, params, new Boolean(describeOnly), query.getStatementName()});
pendingDescribePortalQueue.add(query);
query.setStatementDescribed(true);
query.setPortalDescribed(true);
}
private void sendExecute(SimpleQuery query, Portal portal, int limit) throws IOException {
//
// Send Execute.
//
if (logger.logDebug())
{
logger.debug(" FE=> Execute(portal=" + portal + ",limit=" + limit + ")");
}
byte[] encodedPortalName = (portal == null ? null : portal.getEncodedPortalName());
int encodedSize = (encodedPortalName == null ? 0 : encodedPortalName.length);
// Total size = 4 (size field) + 1 + N (source portal) + 4 (max rows)
pgStream.SendChar('E'); // Execute
pgStream.SendInteger4(4 + 1 + encodedSize + 4); // message size
if (encodedPortalName != null)
pgStream.Send(encodedPortalName); // portal name
pgStream.SendChar(0); // portal name terminator
pgStream.SendInteger4(limit); // row limit
pendingExecuteQueue.add(new Object[] { query, portal });
}
private void sendClosePortal(String portalName) throws IOException {
//
// Send Close.
//
if (logger.logDebug())
{
logger.debug(" FE=> ClosePortal(" + portalName + ")");
}
byte[] encodedPortalName = (portalName == null ? null : Utils.encodeUTF8(portalName));
int encodedSize = (encodedPortalName == null ? 0 : encodedPortalName.length);
// Total size = 4 (size field) + 1 (close type, 'P') + 1 + N (portal name)
pgStream.SendChar('C'); // Close
pgStream.SendInteger4(4 + 1 + 1 + encodedSize); // message size
pgStream.SendChar('P'); // Close (Portal)
if (encodedPortalName != null)
pgStream.Send(encodedPortalName);
pgStream.SendChar(0); // unnamed portal
}
private void sendCloseStatement(String statementName) throws IOException {
//
// Send Close.
//
if (logger.logDebug())
{
logger.debug(" FE=> CloseStatement(" + statementName + ")");
}
byte[] encodedStatementName = Utils.encodeUTF8(statementName);
// Total size = 4 (size field) + 1 (close type, 'S') + N + 1 (statement name)
pgStream.SendChar('C'); // Close
pgStream.SendInteger4(4 + 1 + encodedStatementName.length + 1); // message size
pgStream.SendChar('S'); // Close (Statement)
pgStream.Send(encodedStatementName); // statement to close
pgStream.SendChar(0); // statement name terminator
}
// sendOneQuery sends a single statement via the extended query protocol.
// Per the FE/BE docs this is essentially the same as how a simple query runs
// (except that it generates some extra acknowledgement messages, and we
// can send several queries before doing the Sync)
//
// Parse S_n from "query string with parameter placeholders"; skipped if already done previously or if oneshot
// Bind C_n from S_n plus parameters (or from unnamed statement for oneshot queries)
// Describe C_n; skipped if caller doesn't want metadata
// Execute C_n with maxRows limit; maxRows = 1 if caller doesn't want results
// (above repeats once per call to sendOneQuery)
// Sync (sent by caller)
//
private void sendOneQuery(SimpleQuery query, SimpleParameterList params, int maxRows, int fetchSize, int flags) throws IOException {
// nb: if we decide to use a portal (usePortal == true) we must also use a named statement
// (oneShot == false) as otherwise the portal will be closed under us unexpectedly when
// the unnamed statement is next reused.
boolean noResults = (flags & QueryExecutor.QUERY_NO_RESULTS) != 0;
boolean noMeta = (flags & QueryExecutor.QUERY_NO_METADATA) != 0;
boolean describeOnly = (flags & QueryExecutor.QUERY_DESCRIBE_ONLY) != 0;
boolean usePortal = (flags & QueryExecutor.QUERY_FORWARD_CURSOR) != 0 && !noResults && !noMeta && fetchSize > 0 && !describeOnly;
boolean oneShot = (flags & QueryExecutor.QUERY_ONESHOT) != 0 && !usePortal;
boolean noBinaryTransfer = (flags & QUERY_NO_BINARY_TRANSFER) != 0;
// Work out how many rows to fetch in this pass.
int rows;
if (noResults)
{
rows = 1; // We're discarding any results anyway, so limit data transfer to a minimum
}
else if (!usePortal)
{
rows = maxRows; // Not using a portal -- fetchSize is irrelevant
}
else if (maxRows != 0 && fetchSize > maxRows)
{
rows = maxRows; // fetchSize > maxRows, use maxRows (nb: fetchSize cannot be 0 if usePortal == true)
}
else
{
rows = fetchSize; // maxRows > fetchSize
}
sendParse(query, params, oneShot);
// Must do this after sendParse to pick up any changes to the
// query's state.
//
boolean queryHasUnknown = query.hasUnresolvedTypes();
boolean paramsHasUnknown = params.hasUnresolvedTypes();
boolean describeStatement = describeOnly || (!oneShot && paramsHasUnknown && queryHasUnknown && !query.isStatementDescribed());
if (!describeStatement && paramsHasUnknown && !queryHasUnknown)
{
int queryOIDs[] = query.getStatementTypes();
int paramOIDs[] = params.getTypeOIDs();
for (int i=0; i CopyFail");
}
// COPY sub-protocol is not implemented yet
// We'll send a CopyFail message for COPY FROM STDIN so that
// server does not wait for the data.
byte[] buf = Utils.encodeUTF8("The JDBC driver currently does not support COPY operations.");
pgStream.SendChar('f');
pgStream.SendInteger4(buf.length + 4 + 1);
pgStream.Send(buf);
pgStream.SendChar(0);
pgStream.flush();
sendSync(); // send sync message
skipMessage(); // skip the response message
break;
case 'H': // CopyOutResponse
if (logger.logDebug())
logger.debug(" <=BE CopyOutResponse");
skipMessage();
// In case of CopyOutResponse, we cannot abort data transfer,
// so just throw an error and ignore CopyData messages
handler.handleError(new PSQLException(GT.tr("The driver currently does not support COPY operations."), PSQLState.NOT_IMPLEMENTED));
break;
case 'c': // CopyDone
skipMessage();
if (logger.logDebug()) {
logger.debug(" <=BE CopyDone");
}
break;
case 'd': // CopyData
skipMessage();
if (logger.logDebug()) {
logger.debug(" <=BE CopyData");
}
break;
default:
throw new IOException("Unexpected packet type: " + c);
}
}
}
/**
* Ignore the response message by reading the message length and skipping
* over those bytes in the communication stream.
*/
private void skipMessage() throws IOException {
int l_len = pgStream.ReceiveInteger4();
// skip l_len-4 (length includes the 4 bytes for message length itself
pgStream.Skip(l_len - 4);
}
public synchronized void fetch(ResultCursor cursor, ResultHandler handler, int fetchSize)
throws SQLException {
waitOnLock();
final Portal portal = (Portal)cursor;
// Insert a ResultHandler that turns bare command statuses into empty datasets
// (if the fetch returns no rows, we see just a CommandStatus..)
final ResultHandler delegateHandler = handler;
handler = new ResultHandler() {
public void handleResultRows(Query fromQuery, Field[] fields, List tuples, ResultCursor cursor) {
delegateHandler.handleResultRows(fromQuery, fields, tuples, cursor);
}
public void handleCommandStatus(String status, int updateCount, long insertOID) {
handleResultRows(portal.getQuery(), null, new ArrayList(), null);
}
public void handleWarning(SQLWarning warning) {
delegateHandler.handleWarning(warning);
}
public void handleError(SQLException error) {
delegateHandler.handleError(error);
}
public void handleCompletion() throws SQLException{
delegateHandler.handleCompletion();
}
};
// Now actually run it.
try
{
processDeadParsedQueries();
processDeadPortals();
sendExecute(portal.getQuery(), portal, fetchSize);
sendSync();
processResults(handler, 0);
}
catch (IOException e)
{
protoConnection.close();
handler.handleError(new PSQLException(GT.tr("An I/O error occured while sending to the backend."), PSQLState.CONNECTION_FAILURE, e));
}
handler.handleCompletion();
}
/*
* Receive the field descriptions from the back end.
*/
private Field[] receiveFields() throws IOException
{
int l_msgSize = pgStream.ReceiveInteger4();
int size = pgStream.ReceiveInteger2();
Field[] fields = new Field[size];
if (logger.logDebug())
logger.debug(" <=BE RowDescription(" + size + ")");
for (int i = 0; i < fields.length; i++)
{
String columnLabel = pgStream.ReceiveString();
int tableOid = pgStream.ReceiveInteger4();
short positionInTable = (short)pgStream.ReceiveInteger2();
int typeOid = pgStream.ReceiveInteger4();
int typeLength = pgStream.ReceiveInteger2();
int typeModifier = pgStream.ReceiveInteger4();
int formatType = pgStream.ReceiveInteger2();
fields[i] = new Field(columnLabel,
"", /* name not yet determined */
typeOid, typeLength, typeModifier, tableOid, positionInTable);
fields[i].setFormat(formatType);
if (logger.logDebug())
logger.debug(" " + fields[i]);
}
return fields;
}
private void receiveAsyncNotify() throws IOException {
int msglen = pgStream.ReceiveInteger4();
int pid = pgStream.ReceiveInteger4();
String msg = pgStream.ReceiveString();
String param = pgStream.ReceiveString();
protoConnection.addNotification(new org.postgresql.core.Notification(msg, pid, param));
if (logger.logDebug())
logger.debug(" <=BE AsyncNotify(" + pid + "," + msg + "," + param + ")");
}
private SQLException receiveErrorResponse() throws IOException {
// it's possible to get more than one error message for a query
// see libpq comments wrt backend closing a connection
// so, append messages to a string buffer and keep processing
// check at the bottom to see if we need to throw an exception
int elen = pgStream.ReceiveInteger4();
String totalMessage = pgStream.ReceiveString(elen - 4);
ServerErrorMessage errorMsg = new ServerErrorMessage(totalMessage, logger.getLogLevel());
if (logger.logDebug())
logger.debug(" <=BE ErrorMessage(" + errorMsg.toString() + ")");
return new PSQLException(errorMsg);
}
private SQLWarning receiveNoticeResponse() throws IOException {
int nlen = pgStream.ReceiveInteger4();
ServerErrorMessage warnMsg = new ServerErrorMessage(pgStream.ReceiveString(nlen - 4), logger.getLogLevel());
if (logger.logDebug())
logger.debug(" <=BE NoticeResponse(" + warnMsg.toString() + ")");
return new PSQLWarning(warnMsg);
}
private String receiveCommandStatus() throws IOException {
//TODO: better handle the msg len
int l_len = pgStream.ReceiveInteger4();
//read l_len -5 bytes (-4 for l_len and -1 for trailing \0)
String status = pgStream.ReceiveString(l_len - 5);
//now read and discard the trailing \0
pgStream.Receive(1);
if (logger.logDebug())
logger.debug(" <=BE CommandStatus(" + status + ")");
return status;
}
private void interpretCommandStatus(String status, ResultHandler handler) {
int update_count = 0;
long insert_oid = 0;
if (status.startsWith("INSERT") || status.startsWith("UPDATE") || status.startsWith("DELETE") || status.startsWith("MOVE"))
{
try
{
update_count = Integer.parseInt(status.substring(1 + status.lastIndexOf(' ')));
if (status.startsWith("INSERT"))
insert_oid = Long.parseLong(status.substring(1 + status.indexOf(' '),
status.lastIndexOf(' ')));
}
catch (NumberFormatException nfe)
{
handler.handleError(new PSQLException(GT.tr("Unable to interpret the update count in command completion tag: {0}.", status), PSQLState.CONNECTION_FAILURE));
return ;
}
}
handler.handleCommandStatus(status, update_count, insert_oid);
}
private void receiveRFQ() throws IOException {
if (pgStream.ReceiveInteger4() != 5)
throw new IOException("unexpected length of ReadyForQuery message");
char tStatus = (char)pgStream.ReceiveChar();
if (logger.logDebug())
logger.debug(" <=BE ReadyForQuery(" + tStatus + ")");
// Update connection state.
switch (tStatus)
{
case 'I':
protoConnection.setTransactionState(ProtocolConnection.TRANSACTION_IDLE);
break;
case 'T':
protoConnection.setTransactionState(ProtocolConnection.TRANSACTION_OPEN);
break;
case 'E':
protoConnection.setTransactionState(ProtocolConnection.TRANSACTION_FAILED);
break;
default:
throw new IOException("unexpected transaction state in ReadyForQuery message: " + (int)tStatus);
}
}
private final ArrayList pendingParseQueue = new ArrayList(); // list of SimpleQuery instances
private final ArrayList pendingBindQueue = new ArrayList(); // list of Portal instances
private final ArrayList pendingExecuteQueue = new ArrayList(); // list of {SimpleQuery,Portal} object arrays
private final ArrayList pendingDescribeStatementQueue = new ArrayList(); // list of {SimpleQuery, SimpleParameterList, Boolean} object arrays
private final ArrayList pendingDescribePortalQueue = new ArrayList(); // list of SimpleQuery
private long nextUniqueID = 1;
private final ProtocolConnectionImpl protoConnection;
private final PGStream pgStream;
private final Logger logger;
private final boolean allowEncodingChanges;
/**
* The number of queries executed so far without processing any results.
* Used to avoid deadlocks, see MAX_BUFFERED_QUERIES.
*/
private int queryCount;
private final SimpleQuery beginTransactionQuery = new SimpleQuery(new String[] { "BEGIN" }, null);
private final static SimpleQuery EMPTY_QUERY = new SimpleQuery(new String[] { "" }, null);
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/v3/SimpleParameterList.java 0000664 0000000 0000000 00000027162 12050675701 0026713 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2012, PostgreSQL Global Development Group
* Copyright (c) 2004, Open Cloud Limited.
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.core.v3;
import java.io.InputStream;
import java.io.IOException;
import java.sql.SQLException;
import java.util.Arrays;
import org.postgresql.core.*;
import org.postgresql.util.PSQLException;
import org.postgresql.util.PSQLState;
import org.postgresql.util.StreamWrapper;
import org.postgresql.util.GT;
import org.postgresql.util.ByteConverter;
/**
* Parameter list for a single-statement V3 query.
*
* @author Oliver Jowett (oliver@opencloud.com)
*/
class SimpleParameterList implements V3ParameterList {
private final static int IN = 1;
private final static int OUT = 2;
private final static int INOUT = IN|OUT;
private final static int TEXT = 0;
private final static int BINARY = 4;
SimpleParameterList(int paramCount, ProtocolConnectionImpl protoConnection) {
this.paramValues = new Object[paramCount];
this.paramTypes = new int[paramCount];
this.encoded = new byte[paramCount][];
this.flags = new int[paramCount];
this.protoConnection = protoConnection;
}
public void registerOutParameter( int index, int sqlType ) throws SQLException
{
if (index < 1 || index > paramValues.length)
throw new PSQLException(GT.tr("The column index is out of range: {0}, number of columns: {1}.", new Object[]{new Integer(index), new Integer(paramValues.length)}), PSQLState.INVALID_PARAMETER_VALUE);
flags[index-1] |= OUT;
}
private void bind(int index, Object value, int oid, int binary) throws SQLException {
if (index < 1 || index > paramValues.length)
throw new PSQLException(GT.tr("The column index is out of range: {0}, number of columns: {1}.", new Object[]{new Integer(index), new Integer(paramValues.length)}), PSQLState.INVALID_PARAMETER_VALUE);
--index;
encoded[index] = null;
paramValues[index] = value ;
flags[index] = direction(index) | IN | binary;
// If we are setting something to an UNSPECIFIED NULL, don't overwrite
// our existing type for it. We don't need the correct type info to
// send this value, and we don't want to overwrite and require a
// reparse.
if (oid == Oid.UNSPECIFIED && paramTypes[index] != Oid.UNSPECIFIED && value == NULL_OBJECT)
return;
paramTypes[index] = oid;
}
public int getParameterCount()
{
return paramValues.length;
}
public int getOutParameterCount()
{
int count=0;
for( int i=paramTypes.length; --i >= 0;)
{
if ((direction(i) & OUT) == OUT)
{
count++;
}
}
// Every function has at least one output.
if (count == 0)
count = 1;
return count;
}
public int getInParameterCount()
{
int count=0;
for( int i=0; i< paramTypes.length;i++)
{
if (direction(i) != OUT )
{
count++;
}
}
return count;
}
public void setIntParameter(int index, int value) throws SQLException {
byte[] data = new byte[4];
ByteConverter.int4(data,0,value);
bind(index, data, Oid.INT4, BINARY);
}
public void setLiteralParameter(int index, String value, int oid) throws SQLException {
bind(index, value, oid, TEXT);
}
public void setStringParameter(int index, String value, int oid) throws SQLException {
bind(index, value, oid, TEXT);
}
public void setBinaryParameter(int index, byte[] value, int oid) throws SQLException {
bind(index, value, oid, BINARY);
}
public void setBytea(int index, byte[] data, int offset, int length) throws SQLException {
bind(index, new StreamWrapper(data, offset, length), Oid.BYTEA, BINARY);
}
public void setBytea(int index, InputStream stream, int length) throws SQLException {
bind(index, new StreamWrapper(stream, length), Oid.BYTEA, BINARY);
}
public void setNull(int index, int oid) throws SQLException {
bind(index, NULL_OBJECT, oid, BINARY);
}
public String toString(int index) {
--index;
if (paramValues[index] == null)
return "?";
else if (paramValues[index] == NULL_OBJECT)
return "NULL";
else if ( (flags[index]& BINARY) == BINARY )
{
// handle some of the numeric types
switch (paramTypes[index])
{
case Oid.INT2:
short s = ByteConverter.int2((byte[])paramValues[index],0);
return Short.toString(s);
case Oid.INT4:
int i = ByteConverter.int4((byte[])paramValues[index],0);
return Integer.toString(i);
case Oid.INT8:
long l = ByteConverter.int8((byte[])paramValues[index],0);
return Long.toString(l);
case Oid.FLOAT4:
float f = ByteConverter.float4((byte[])paramValues[index],0);
return Float.toString(f);
case Oid.FLOAT8:
double d = ByteConverter.float8((byte[])paramValues[index],0);
return Double.toString(d);
}
return "?";
}
else
{
String param = paramValues[index].toString();
boolean hasBackslash = param.indexOf('\\') != -1;
// add room for quotes + potential escaping.
StringBuffer p = new StringBuffer(3 + param.length() * 11 / 10);
boolean standardConformingStrings = false;
boolean supportsEStringSyntax = false;
if (protoConnection != null)
{
standardConformingStrings = protoConnection.getStandardConformingStrings();
supportsEStringSyntax = protoConnection.getServerVersion().compareTo("8.1") >= 0;
}
if (hasBackslash && !standardConformingStrings && supportsEStringSyntax)
p.append('E');
p.append('\'');
try
{
p = Utils.appendEscapedLiteral(p, param, standardConformingStrings);
}
catch (SQLException sqle)
{
// This should only happen if we have an embedded null
// and there's not much we can do if we do hit one.
//
// The goal of toString isn't to be sent to the server,
// so we aren't 100% accurate (see StreamWrapper), put
// the unescaped version of the data.
//
p.append(param);
}
p.append('\'');
return p.toString();
}
}
public void checkAllParametersSet() throws SQLException {
for (int i = 0; i < paramTypes.length; ++i)
{
if (direction(i) != OUT && paramValues[i] == null)
throw new PSQLException(GT.tr("No value specified for parameter {0}.", new Integer(i + 1)), PSQLState.INVALID_PARAMETER_VALUE);
}
}
public void convertFunctionOutParameters()
{
for (int i=0; inull if this object is already a single-statement
* parameter list.
*/
SimpleParameterList[] getSubparams();
}
postgresql-jdbc-9.2-1002.src/org/postgresql/core/v3/V3Query.java 0000664 0000000 0000000 00000001560 12050675701 0024275 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
* Copyright (c) 2004, Open Cloud Limited.
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.core.v3;
import org.postgresql.core.Query;
/**
* Common interface for all V3 query implementations.
*
* @author Oliver Jowett (oliver@opencloud.com)
*/
interface V3Query extends Query {
/**
* Return a list of the SimpleQuery objects that
* make up this query. If this object is already a
* SimpleQuery, returns null (avoids an extra array
* construction in the common case).
*
* @return an array of single-statement queries, or null
* if this object is already a single-statement query.
*/
SimpleQuery[] getSubqueries();
}
postgresql-jdbc-9.2-1002.src/org/postgresql/ds/ 0000775 0000000 0000000 00000000000 12050675701 0021240 5 ustar 00root root 0000000 0000000 postgresql-jdbc-9.2-1002.src/org/postgresql/ds/.gitignore 0000664 0000000 0000000 00000000151 12050675701 0023225 0 ustar 00root root 0000000 0000000 PGPooledConnection.java
PGPoolingDataSource.java
PGSimpleDataSource.java
PGConnectionPoolDataSource.java
postgresql-jdbc-9.2-1002.src/org/postgresql/ds/PGConnectionPoolDataSource.java.in 0000664 0000000 0000000 00000002544 12050675701 0027650 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.ds;
import javax.sql.ConnectionPoolDataSource;
import org.postgresql.ds.common.*;
/**
* PostgreSQL implementation of ConnectionPoolDataSource. The app server or
* middleware vendor should provide a DataSource implementation that takes advantage
* of this ConnectionPoolDataSource. If not, you can use the PostgreSQL implementation
* known as PoolingDataSource, but that should only be used if your server or middleware
* vendor does not provide their own. Why? The server may want to reuse the same
* Connection across all EJBs requesting a Connection within the same Transaction, or
* provide other similar advanced features.
*
*
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 @CONN_POOL_DS_CLASS@
implements ConnectionPoolDataSource
{
}
postgresql-jdbc-9.2-1002.src/org/postgresql/ds/PGPooledConnection.java.in 0000664 0000000 0000000 00000002261 12050675701 0026202 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.ds;
import java.sql.Connection;
import java.sql.SQLException;
import javax.sql.PooledConnection;
import javax.sql.ConnectionEvent;
/**
* PostgreSQL implementation of the PooledConnection interface. This shouldn't
* be used directly, as the pooling client should just interact with the
* ConnectionPool instead.
* @see org.postgresql.ds.PGConnectionPoolDataSource
*
* @author Aaron Mulder (ammulder@chariotsolutions.com)
* @author Csaba Nagy (ncsaba@yahoo.com)
*/
public class PGPooledConnection
extends @POOLED_CONN_CLASS@
implements PooledConnection
{
public PGPooledConnection(Connection con, boolean autoCommit, boolean isXA)
{
super(con, autoCommit, isXA);
}
public PGPooledConnection(Connection con, boolean autoCommit)
{
this(con, autoCommit, false);
}
protected ConnectionEvent createConnectionEvent(SQLException sqle)
{
return new ConnectionEvent(this, sqle);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/ds/PGPoolingDataSource.java.in 0000664 0000000 0000000 00000003766 12050675701 0026335 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.ds;
import javax.sql.DataSource;
/**
* 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.3 and higher.
*
* @author Aaron Mulder (ammulder@chariotsolutions.com)
*/
public class PGPoolingDataSource
extends @POOLING_DS_CLASS@
implements DataSource
{
protected void addDataSource(String dataSourceName)
{
dataSources.put(dataSourceName, this);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/ds/PGSimpleDataSource.java.in 0000664 0000000 0000000 00000001314 12050675701 0026142 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.ds;
import javax.sql.DataSource;
/**
* Simple DataSource which does not perform connection pooling. In order to use
* the DataSource, you must set the property databaseName. The settings for
* serverName, portNumber, user, and password are optional. Note: these properties
* are declared in the superclass.
*
* @author Aaron Mulder (ammulder@chariotsolutions.com)
*/
public class PGSimpleDataSource
extends @SIMPLE_DS_CLASS@
implements DataSource
{
}
postgresql-jdbc-9.2-1002.src/org/postgresql/ds/common/ 0000775 0000000 0000000 00000000000 12050675701 0022530 5 ustar 00root root 0000000 0000000 postgresql-jdbc-9.2-1002.src/org/postgresql/ds/common/BaseDataSource.java 0000664 0000000 0000000 00000045234 12050675701 0026230 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.ds.common;
import javax.naming.*;
import java.sql.*;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
/**
* Base class for data sources and related classes.
*
* @author Aaron Mulder (ammulder@chariotsolutions.com)
*/
public abstract class BaseDataSource implements Referenceable
{
// Load the normal driver, since we'll use it to actually connect to the
// database. That way we don't have to maintain the connecting code in
// multiple places.
static {
try
{
Class.forName("org.postgresql.Driver");
}
catch (ClassNotFoundException e)
{
System.err.println("PostgreSQL DataSource unable to load PostgreSQL JDBC Driver");
}
}
// Needed to implement the DataSource/ConnectionPoolDataSource interfaces
private transient PrintWriter logger;
// Standard properties, defined in the JDBC 2.0 Optional Package spec
private String serverName = "localhost";
private String databaseName;
private String user;
private String password;
private int portNumber = 0;
private int prepareThreshold = 5;
private int unknownLength = Integer.MAX_VALUE;
private boolean binaryTransfer = true;
private String binaryTransferEnable = "";
private String binaryTransferDisable = "";
private int loginTimeout = 0; // in seconds
private int socketTimeout = 0; // in seconds
private int receiveBufferSize = -1; // off (-1), not in use
private int sendBufferSize = -1; // off (-1), not in use
private boolean ssl = false;
private String sslfactory;
private boolean tcpKeepAlive = false;
private String compatible;
private int logLevel = 0;
private int protocolVersion = 0;
private String applicationName;
/**
* Gets a connection to the PostgreSQL database. The database is identified by the
* DataSource properties serverName, databaseName, and portNumber. The user to
* connect as is identified by the DataSource properties user and password.
*
* @return A valid database connection.
* @throws SQLException
* Occurs when the database connection cannot be established.
*/
public Connection getConnection() throws SQLException
{
return getConnection(user, password);
}
/**
* Gets a connection to the PostgreSQL database. The database is identified by the
* DataSource properties serverName, databaseName, and portNumber. The user to
* connect as is identified by the arguments user and password, which override
* the DataSource properties by the same name.
*
* @return A valid database connection.
* @throws SQLException
* Occurs when the database connection cannot be established.
*/
public Connection getConnection(String user, String password) throws SQLException
{
try
{
Connection con = DriverManager.getConnection(getUrl(), user, password);
if (logger != null)
{
logger.println("Created a non-pooled connection for " + user + " at " + getUrl());
}
return con;
}
catch (SQLException e)
{
if (logger != null)
{
logger.println("Failed to create a non-pooled connection for " + user + " at " + getUrl() + ": " + e);
}
throw e;
}
}
/**
* @return the login timeout, in seconds.
*/
public int getLoginTimeout() throws SQLException
{
return loginTimeout;
}
/**
* Set the login timeout, in seconds.
*/
public void setLoginTimeout(int i) throws SQLException
{
this.loginTimeout = i;
}
/**
* Gets the log writer used to log connections opened.
*/
public PrintWriter getLogWriter() throws SQLException
{
return logger;
}
/**
* The DataSource will note every connection opened to the provided log writer.
*/
public void setLogWriter(PrintWriter printWriter) throws SQLException
{
logger = printWriter;
}
/**
* Gets the name of the host the PostgreSQL database is running on.
*/
public String getServerName()
{
return serverName;
}
/**
* Sets the name of the host the PostgreSQL database is running on. If this
* is changed, it will only affect future calls to getConnection. The default
* value is localhost.
*/
public void setServerName(String serverName)
{
if (serverName == null || serverName.equals(""))
{
this.serverName = "localhost";
}
else
{
this.serverName = serverName;
}
}
public String getCompatible()
{
return compatible;
}
public void setCompatible(String compatible)
{
this.compatible = compatible;
}
public int getLogLevel()
{
return logLevel;
}
public void setLogLevel(int logLevel)
{
this.logLevel = logLevel;
}
public int getProtocolVersion()
{
return protocolVersion;
}
public void setProtocolVersion(int protocolVersion)
{
this.protocolVersion = protocolVersion;
}
/**
* Gets the name of the PostgreSQL database, running on the server identified
* by the serverName property.
*/
public String getDatabaseName()
{
return databaseName;
}
/**
* Sets the name of the PostgreSQL database, running on the server identified
* by the serverName property. If this is changed, it will only affect
* future calls to getConnection.
*/
public void setDatabaseName(String databaseName)
{
this.databaseName = databaseName;
}
/**
* Gets a description of this DataSource-ish thing. Must be customized by
* subclasses.
*/
public abstract String getDescription();
/**
* Gets the user to connect as by default. If this is not specified, you must
* use the getConnection method which takes a user and password as parameters.
*/
public String getUser()
{
return user;
}
/**
* Sets the user to connect as by default. If this is not specified, you must
* use the getConnection method which takes a user and password as parameters.
* If this is changed, it will only affect future calls to getConnection.
*/
public void setUser(String user)
{
this.user = user;
}
/**
* Gets the password to connect with by default. If this is not specified but a
* password is needed to log in, you must use the getConnection method which takes
* a user and password as parameters.
*/
public String getPassword()
{
return password;
}
/**
* Sets the password to connect with by default. If this is not specified but a
* password is needed to log in, you must use the getConnection method which takes
* a user and password as parameters. If this is changed, it will only affect
* future calls to getConnection.
*/
public void setPassword(String password)
{
this.password = password;
}
/**
* Gets the port which the PostgreSQL server is listening on for TCP/IP
* connections.
*
* @return The port, or 0 if the default port will be used.
*/
public int getPortNumber()
{
return portNumber;
}
/**
* Gets the port which the PostgreSQL server is listening on for TCP/IP
* connections. Be sure the -i flag is passed to postmaster when PostgreSQL
* is started. If this is not set, or set to 0, the default port will be used.
*/
public void setPortNumber(int portNumber)
{
this.portNumber = portNumber;
}
/**
* Sets the default threshold for enabling server-side prepare.
* See {@link org.postgresql.PGConnection#setPrepareThreshold(int)} for details.
*
* @param count the number of times a statement object must be reused before server-side
* prepare is enabled.
*/
public void setPrepareThreshold(int count)
{
this.prepareThreshold = count;
}
/**
* Sets the write buffer size of TCP/IP socket.
*/
public void setReceiveBufferSize(int nbytes)
{
this.receiveBufferSize = nbytes;
}
/**
* Sets the send buffer size of TCP/IP socket.
*/
public void setSendBufferSize(int nbytes)
{
this.sendBufferSize = nbytes;
}
/**
* Gets the default threshold for enabling server-side prepare.
*
* @see #setPrepareThreshold(int)
*/
public int getPrepareThreshold()
{
return prepareThreshold;
}
public void setUnknownLength(int unknownLength)
{
this.unknownLength = unknownLength;
}
public int getUnknownLength()
{
return unknownLength;
}
/**
* Sets the socket timeout (SOTimeout), in seconds
*/
public void setSocketTimeout(int seconds)
{
this.socketTimeout = seconds;
}
/**
* @return the socket timeout (SOTimeout), in seconds
*/
public int getSocketTimeout()
{
return this.socketTimeout;
}
/**
* Set whether the connection will be SSL encrypted or not.
*
* @param enabled if true, connect with SSL.
*/
public void setSsl(boolean enabled)
{
this.ssl = enabled;
}
/**
* Gets SSL encryption setting.
*
* @return true if connections will be encrypted with SSL.
*/
public boolean getSsl()
{
return this.ssl;
}
/**
* Set the name of the {@link javax.net.ssl.SSLSocketFactory} to use for connections.
* Use org.postgresql.ssl.NonValidatingFactory if you don't want certificate validation.
*
* @param classname name of a subclass of javax.net.ssl.SSLSocketFactory or null for the default implementation.
*/
public void setSslfactory(String classname)
{
this.sslfactory = classname;
}
/**
* Gets the name of the {@link javax.net.ssl.SSLSocketFactory} used for connections.
*
* @return name of the class or null if the default implementation is used.
*/
public String getSslfactory()
{
return this.sslfactory;
}
public void setApplicationName(String applicationName)
{
this.applicationName = applicationName;
}
public String getApplicationName()
{
return applicationName;
}
public void setTcpKeepAlive(boolean enabled)
{
tcpKeepAlive = enabled;
}
public boolean getTcpKeepAlive()
{
return tcpKeepAlive;
}
/**
* Sets protocol transfer mode.
*
* @param enabled True if the binary transfer mode is used for supported field types,
* false if text based transfer is used.
*/
public void setBinaryTransfer(boolean enabled)
{
this.binaryTransfer = enabled;
}
/**
* Gets the protocol transfer mode.
*
* @see #setBinaryTransfer(boolean)
*/
public boolean getBinaryTransfer()
{
return binaryTransfer;
}
/**
* Add types to the override set of {@link org.postgresql.core.Oid} values used for binary transfer.
*
* @param oidList The comma separated list of Oids. Either textual or numeric value.
*/
public void setBinaryTransferEnable(String oidList)
{
this.binaryTransferEnable = oidList;
}
/**
* Gets override set of Oid values that have binary transfer enabled.
*
* @see #setBinaryTransferEnable(String)
*/
public String getBinaryTransferEnable()
{
return binaryTransferEnable;
}
/**
* Add types to the override set of {@link org.postgresql.core.Oid} values that will not be used for binary transfer.
* This overrides any values in the driver detault set or values set with {@link #setBinaryTransferEnable(String)}.
*
* @param oidList The comma separated list of Oids. Either textual or numeric value.
*/
public void setBinaryTransferDisable(String oidList)
{
this.binaryTransferDisable = oidList;
}
/**
* Gets override set of Oid values that have binary transfer disabled.
*
* @see #setBinaryTransferDisable(String)
*/
public String getBinaryTransferDisable()
{
return binaryTransferDisable;
}
/**
* Generates a DriverManager URL from the other properties supplied.
*/
private String getUrl()
{
StringBuffer sb = new StringBuffer(100);
sb.append("jdbc:postgresql://");
sb.append(serverName);
if (portNumber != 0) {
sb.append(":").append(portNumber);
}
sb.append("/").append(databaseName);
sb.append("?loginTimeout=").append(loginTimeout);
sb.append("&socketTimeout=").append(socketTimeout);
sb.append("&prepareThreshold=").append(prepareThreshold);
sb.append("&unknownLength=").append(unknownLength);
sb.append("&loglevel=").append(logLevel);
if (protocolVersion != 0) {
sb.append("&protocolVersion=").append(protocolVersion);
}
if (ssl) {
sb.append("&ssl=true");
if (sslfactory != null) {
sb.append("&sslfactory=").append(sslfactory);
}
}
if (receiveBufferSize != -1) {
sb.append("&receiveBufferSize=").append(receiveBufferSize);
}
if (sendBufferSize != -1) {
sb.append("&sendBufferSize=").append(sendBufferSize);
}
sb.append("&tcpkeepalive=").append(tcpKeepAlive);
if (compatible != null) {
sb.append("&compatible="+compatible);
}
if (applicationName != null) {
sb.append("&ApplicationName=");
sb.append(applicationName);
}
if (binaryTransfer) {
sb.append("&binaryTransfer=true");
}
return sb.toString();
}
/**
* Generates a reference using the appropriate object factory.
*/
protected Reference createReference() {
return new Reference(
getClass().getName(),
PGObjectFactory.class.getName(),
null);
}
public Reference getReference() throws NamingException
{
Reference ref = createReference();
ref.add(new StringRefAddr("serverName", serverName));
if (portNumber != 0)
{
ref.add(new StringRefAddr("portNumber", Integer.toString(portNumber)));
}
ref.add(new StringRefAddr("databaseName", databaseName));
if (user != null)
{
ref.add(new StringRefAddr("user", user));
}
if (password != null)
{
ref.add(new StringRefAddr("password", password));
}
ref.add(new StringRefAddr("prepareThreshold", Integer.toString(prepareThreshold)));
ref.add(new StringRefAddr("unknownLength", Integer.toString(unknownLength)));
ref.add(new StringRefAddr("binaryTransfer", Boolean.toString(binaryTransfer)));
ref.add(new StringRefAddr("loginTimeout", Integer.toString(loginTimeout)));
ref.add(new StringRefAddr("socketTimeout", Integer.toString(socketTimeout)));
ref.add(new StringRefAddr("ssl", Boolean.toString(ssl)));
ref.add(new StringRefAddr("sslfactory", sslfactory));
ref.add(new StringRefAddr("receiveBufferSize", Integer.toString(receiveBufferSize)));
ref.add(new StringRefAddr("sendBufferSize", Integer.toString(sendBufferSize)));
ref.add(new StringRefAddr("tcpKeepAlive", Boolean.toString(tcpKeepAlive)));
if (compatible != null)
{
ref.add(new StringRefAddr("compatible", compatible));
}
ref.add(new StringRefAddr("logLevel", Integer.toString(logLevel)));
ref.add(new StringRefAddr("protocolVersion", Integer.toString(protocolVersion)));
ref.add(new StringRefAddr("ApplicationName", applicationName));
return ref;
}
protected void writeBaseObject(ObjectOutputStream out) throws IOException
{
out.writeObject(serverName);
out.writeObject(databaseName);
out.writeObject(user);
out.writeObject(password);
out.writeInt(portNumber);
out.writeInt(prepareThreshold);
out.writeInt(unknownLength);
out.writeInt(loginTimeout);
out.writeInt(socketTimeout);
out.writeBoolean(ssl);
out.writeObject(sslfactory);
out.writeInt(receiveBufferSize);
out.writeInt(sendBufferSize);
out.writeBoolean(tcpKeepAlive);
out.writeObject(compatible);
out.writeInt(logLevel);
out.writeInt(protocolVersion);
out.writeObject(applicationName);
out.writeBoolean(binaryTransfer);
out.writeObject(binaryTransferEnable);
out.writeObject(binaryTransferDisable);
}
protected void readBaseObject(ObjectInputStream in) throws IOException, ClassNotFoundException
{
serverName = (String)in.readObject();
databaseName = (String)in.readObject();
user = (String)in.readObject();
password = (String)in.readObject();
portNumber = in.readInt();
prepareThreshold = in.readInt();
unknownLength = in.readInt();
loginTimeout = in.readInt();
socketTimeout = in.readInt();
ssl = in.readBoolean();
sslfactory = (String)in.readObject();
receiveBufferSize = in.readInt();
sendBufferSize = in.readInt();
tcpKeepAlive = in.readBoolean();
compatible = (String)in.readObject();
logLevel = in.readInt();
protocolVersion = in.readInt();
applicationName = (String)in.readObject();
binaryTransfer = in.readBoolean();
binaryTransferEnable = (String)in.readObject();
binaryTransferDisable = (String)in.readObject();
}
public void initializeFrom(BaseDataSource source) throws IOException, ClassNotFoundException {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
source.writeBaseObject(oos);
oos.close();
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bais);
readBaseObject(ois);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/ds/common/PGObjectFactory.java 0000664 0000000 0000000 00000011400 12050675701 0026354 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.ds.common;
import javax.naming.*;
import javax.naming.spi.ObjectFactory;
import java.util.Hashtable;
import org.postgresql.ds.*;
/**
* Returns a DataSource-ish thing based on a JNDI reference. In the case of a
* SimpleDataSource or ConnectionPool, a new instance is created each time, as
* there is no connection state to maintain. In the case of a PoolingDataSource,
* the same DataSource will be returned for every invocation within the same
* VM/ClassLoader, so that the state of the connections in the pool will be
* consistent.
*
* @author Aaron Mulder (ammulder@chariotsolutions.com)
*/
public class PGObjectFactory implements ObjectFactory
{
/**
* Dereferences a PostgreSQL DataSource. Other types of references are
* ignored.
*/
public Object getObjectInstance(Object obj, Name name, Context nameCtx,
Hashtable environment) throws Exception
{
Reference ref = (Reference)obj;
String className = ref.getClassName();
if (className.equals("org.postgresql.ds.PGSimpleDataSource")
|| className.equals("org.postgresql.jdbc2.optional.SimpleDataSource")
|| className.equals("org.postgresql.jdbc3.Jdbc3SimpleDataSource"))
{
return loadSimpleDataSource(ref);
}
else if (className.equals("org.postgresql.ds.PGConnectionPoolDataSource")
|| className.equals("org.postgresql.jdbc2.optional.ConnectionPool")
|| className.equals("org.postgresql.jdbc3.Jdbc3ConnectionPool"))
{
return loadConnectionPool(ref);
}
else if (className.equals("org.postgresql.ds.PGPoolingDataSource")
|| className.equals("org.postgresql.jdbc2.optional.PoolingDataSource")
|| className.equals("org.postgresql.jdbc3.Jdbc3PoolingDataSource"))
{
return loadPoolingDataSource(ref);
}
else
{
return null;
}
}
private Object loadPoolingDataSource(Reference ref)
{
// If DataSource exists, return it
String name = getProperty(ref, "dataSourceName");
PGPoolingDataSource pds = PGPoolingDataSource.getDataSource(name);
if (pds != null)
{
return pds;
}
// Otherwise, create a new one
pds = new PGPoolingDataSource();
pds.setDataSourceName(name);
loadBaseDataSource(pds, ref);
String min = getProperty(ref, "initialConnections");
if (min != null)
{
pds.setInitialConnections(Integer.parseInt(min));
}
String max = getProperty(ref, "maxConnections");
if (max != null)
{
pds.setMaxConnections(Integer.parseInt(max));
}
return pds;
}
private Object loadSimpleDataSource(Reference ref)
{
PGSimpleDataSource ds = new PGSimpleDataSource();
return loadBaseDataSource(ds, ref);
}
private Object loadConnectionPool(Reference ref)
{
PGConnectionPoolDataSource cp = new PGConnectionPoolDataSource();
return loadBaseDataSource(cp, ref);
}
protected Object loadBaseDataSource(BaseDataSource ds, Reference ref)
{
ds.setDatabaseName(getProperty(ref, "databaseName"));
ds.setPassword(getProperty(ref, "password"));
String port = getProperty(ref, "portNumber");
if (port != null)
{
ds.setPortNumber(Integer.parseInt(port));
}
ds.setServerName(getProperty(ref, "serverName"));
ds.setUser(getProperty(ref, "user"));
String prepareThreshold = getProperty(ref, "prepareThreshold");
if (prepareThreshold != null)
ds.setPrepareThreshold(Integer.parseInt(prepareThreshold));
String binaryTransfer = getProperty(ref, "binaryTransfer");
if (binaryTransfer != null)
ds.setBinaryTransfer(Boolean.getBoolean(binaryTransfer));
String binaryTransferEnable = getProperty(ref, "binaryTransferEnable");
if (binaryTransferEnable != null)
ds.setBinaryTransferEnable(binaryTransferEnable);
String binaryTransferDisable = getProperty(ref, "binaryTransferDisable");
if (binaryTransferDisable != null)
ds.setBinaryTransferDisable(binaryTransferDisable);
return ds;
}
protected String getProperty(Reference ref, String s)
{
RefAddr addr = ref.get(s);
if (addr == null)
{
return null;
}
return (String)addr.getContent();
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/ds/jdbc23/ 0000775 0000000 0000000 00000000000 12050675701 0022307 5 ustar 00root root 0000000 0000000 postgresql-jdbc-9.2-1002.src/org/postgresql/ds/jdbc23/AbstractJdbc23ConnectionPoolDataSource.java 0000664 0000000 0000000 00000007112 12050675701 0032473 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.ds.jdbc23;
import javax.sql.PooledConnection;
import java.sql.SQLException;
import java.io.Serializable;
import java.io.ObjectOutputStream;
import java.io.ObjectInputStream;
import java.io.IOException;
import org.postgresql.ds.common.*;
import org.postgresql.ds.PGPooledConnection;
/**
* PostgreSQL implementation of ConnectionPoolDataSource. The app server or
* middleware vendor should provide a DataSource implementation that takes advantage
* of this ConnectionPoolDataSource. If not, you can use the PostgreSQL implementation
* known as PoolingDataSource, but that should only be used if your server or middleware
* vendor does not provide their own. Why? The server may want to reuse the same
* Connection across all EJBs requesting a Connection within the same Transaction, or
* provide other similar advanced features.
*
*
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 AbstractJdbc23ConnectionPoolDataSource extends BaseDataSource implements Serializable
{
private boolean defaultAutoCommit = true;
/**
* Gets a description of this DataSource.
*/
public String getDescription()
{
return "ConnectionPoolDataSource from " + org.postgresql.Driver.getVersion();
}
/**
* 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.
*/
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.
*/
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 false, so that
* autoCommit will be turned off by default.
*/
public boolean isDefaultAutoCommit()
{
return defaultAutoCommit;
}
/**
* Sets whether connections supplied by this pool will have autoCommit
* turned on by default. The default value is false, so that
* autoCommit will be turned off by default.
*/
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-jdbc-9.2-1002.src/org/postgresql/ds/jdbc23/AbstractJdbc23PooledConnection.java 0000664 0000000 0000000 00000037630 12050675701 0031041 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.ds.jdbc23;
import javax.sql.*;
import java.sql.*;
import java.util.*;
import java.lang.reflect.*;
import org.postgresql.PGConnection;
import org.postgresql.util.GT;
import org.postgresql.util.PSQLException;
import org.postgresql.util.PSQLState;
/**
* PostgreSQL implementation of the PooledConnection interface. This shouldn't
* be used directly, as the pooling client should just interact with the
* ConnectionPool instead.
* @see org.postgresql.ds.PGConnectionPoolDataSource
*
* @author Aaron Mulder (ammulder@chariotsolutions.com)
* @author Csaba Nagy (ncsaba@yahoo.com)
*/
public abstract class AbstractJdbc23PooledConnection
{
private List listeners = new LinkedList();
private Connection con;
private ConnectionHandler last;
private final boolean autoCommit;
private final boolean isXA;
/**
* Creates a new PooledConnection representing the specified physical
* connection.
*/
public AbstractJdbc23PooledConnection(Connection con, boolean autoCommit, boolean isXA)
{
this.con = con;
this.autoCommit = autoCommit;
this.isXA = isXA;
}
/**
* Adds a listener for close or fatal error events on the connection
* handed out to a client.
*/
public void addConnectionEventListener(ConnectionEventListener connectionEventListener)
{
listeners.add(connectionEventListener);
}
/**
* Removes a listener for close or fatal error events on the connection
* handed out to a client.
*/
public void removeConnectionEventListener(ConnectionEventListener connectionEventListener)
{
listeners.remove(connectionEventListener);
}
/**
* Closes the physical database connection represented by this
* PooledConnection. If any client has a connection based on
* this PooledConnection, it is forcibly closed as well.
*/
public void close() throws SQLException
{
if (last != null)
{
last.close();
if (!con.getAutoCommit())
{
try
{
con.rollback();
}
catch (SQLException e)
{
}
}
}
try
{
con.close();
}
finally
{
con = null;
}
}
/**
* Gets a handle for a client to use. This is a wrapper around the
* physical connection, so the client can call close and it will just
* return the connection to the pool without really closing the
* pgysical connection.
*
*
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.
*/
public Connection getConnection() throws SQLException
{
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 occures 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
if (last != null)
{
last.close();
if (!con.getAutoCommit())
{
try
{
con.rollback();
}
catch (SQLException e)
{
}
}
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.setAutoCommit(autoCommit);
}
catch (SQLException sqlException)
{
fireConnectionFatalError(sqlException);
throw (SQLException)sqlException.fillInStackTrace();
}
ConnectionHandler handler = new ConnectionHandler(con);
last = handler;
Connection proxyCon = (Connection)Proxy.newProxyInstance(getClass().getClassLoader(), new Class[]{Connection.class, PGConnection.class}, handler);
last.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 = (ConnectionEventListener[]) listeners.toArray(new ConnectionEventListener[listeners.size()]);
for (int i = 0; i < local.length; i++)
{
ConnectionEventListener listener = local[i];
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 = (ConnectionEventListener[])listeners.toArray(new ConnectionEventListener[listeners.size()]);
for (int i = 0; i < local.length; i++)
{
ConnectionEventListener listener = local[i];
if (evt == null)
{
evt = createConnectionEvent(e);
}
listener.connectionErrorOccurred(evt);
}
}
protected abstract ConnectionEvent createConnectionEvent(SQLException e);
// Classes we consider fatal.
private static 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(String state) {
if (state == null) // no info, assume fatal
return true;
if (state.length() < 2) // no class info, assume fatal
return true;
for (int i = 0; i < fatalClasses.length; ++i)
if (state.startsWith(fatalClasses[i]))
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 Connection con;
private Connection proxy; // the Connection the client is currently using, which is a proxy
private boolean automatic = false;
public ConnectionHandler(Connection con)
{
this.con = con;
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable
{
// From Object
if (method.getDeclaringClass().getName().equals("java.lang.Object"))
{
if (method.getName().equals("toString"))
{
return "Pooled connection wrapping physical connection " + con;
}
if (method.getName().equals("equals"))
{
return new Boolean(proxy == args[0]);
}
if (method.getName().equals("hashCode"))
{
return new Integer(System.identityHashCode(proxy));
}
try
{
return method.invoke(con, args);
}
catch (InvocationTargetException e)
{
throw e.getTargetException();
}
}
// All the rest is from the Connection or PGConnection interface
if (method.getName().equals("isClosed"))
{
return con == null ? Boolean.TRUE : Boolean.FALSE;
}
if (con == null && !method.getName().equals("close"))
{
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);
}
if (method.getName().equals("close"))
{
// we are already closed and a double close
// is not an error.
if (con == null)
return null;
SQLException ex = null;
if (!isXA && !con.getAutoCommit())
{
try
{
con.rollback();
}
catch (SQLException e)
{
ex = e;
}
}
con.clearWarnings();
con = null;
this.proxy = null;
last = null;
fireConnectionClosed();
if (ex != null)
{
throw ex;
}
return null;
}
// From here on in, we invoke via reflection, catch exceptions,
// and check if they're fatal before rethrowing.
try {
if (method.getName().equals("createStatement"))
{
Statement st = (Statement)method.invoke(con, args);
return Proxy.newProxyInstance(getClass().getClassLoader(), new Class[]{Statement.class, org.postgresql.PGStatement.class}, new StatementHandler(this, st));
}
else if (method.getName().equals("prepareCall"))
{
Statement st = (Statement)method.invoke(con, args);
return Proxy.newProxyInstance(getClass().getClassLoader(), new Class[]{CallableStatement.class, org.postgresql.PGStatement.class}, new StatementHandler(this, st));
}
else if (method.getName().equals("prepareStatement"))
{
Statement st = (Statement)method.invoke(con, args);
return Proxy.newProxyInstance(getClass().getClassLoader(), new Class[]{PreparedStatement.class, org.postgresql.PGStatement.class}, new StatementHandler(this, st));
}
else
{
return method.invoke(con, args);
}
} catch (InvocationTargetException e) {
Throwable te = e.getTargetException();
if (te instanceof SQLException)
fireConnectionError((SQLException)te); // Tell listeners about exception if it's fatal
throw te;
}
}
Connection getProxy() {
return 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
}
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 AbstractJdbc23PooledConnection.ConnectionHandler con;
private Statement st;
public StatementHandler(AbstractJdbc23PooledConnection.ConnectionHandler con, Statement st) {
this.con = con;
this.st = st;
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable
{
// From Object
if (method.getDeclaringClass().getName().equals("java.lang.Object"))
{
if (method.getName().equals("toString"))
{
return "Pooled statement wrapping physical statement " + st;
}
if (method.getName().equals("hashCode"))
{
return new Integer(System.identityHashCode(proxy));
}
if (method.getName().equals("equals"))
{
return new Boolean(proxy == args[0]);
}
return method.invoke(st, args);
}
// All the rest is from the Statement interface
if (method.getName().equals("close"))
{
// closing an already closed object is a no-op
if (st == null || con.isClosed())
return null;
try
{
st.close();
}
finally
{
con = null;
st = null;
}
return null;
}
if (st == null || con.isClosed())
{
throw new PSQLException(GT.tr("Statement has been closed."),
PSQLState.OBJECT_NOT_IN_STATE);
}
if (method.getName().equals("getConnection"))
{
return con.getProxy(); // the proxied connection, not a physical connection
}
try
{
return method.invoke(st, args);
} catch (InvocationTargetException e) {
Throwable te = e.getTargetException();
if (te instanceof SQLException)
fireConnectionError((SQLException)te); // Tell listeners about exception if it's fatal
throw te;
}
}
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/ds/jdbc23/AbstractJdbc23PoolingDataSource.java 0000664 0000000 0000000 00000042667 12050675701 0031167 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.ds.jdbc23;
import javax.sql.*;
import javax.naming.*;
import java.util.*;
import java.sql.Connection;
import java.sql.SQLException;
import org.postgresql.util.GT;
import org.postgresql.util.PSQLState;
import org.postgresql.util.PSQLException;
import org.postgresql.ds.*;
import org.postgresql.ds.common.*;
/**
* 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.3 and higher.
*
* @author Aaron Mulder (ammulder@chariotsolutions.com)
*/
public abstract class AbstractJdbc23PoolingDataSource extends BaseDataSource
{
protected static Map dataSources = new HashMap();
public static PGPoolingDataSource getDataSource(String name)
{
return (PGPoolingDataSource)dataSources.get(name);
}
// Additional Data Source properties
protected String dataSourceName; // Must be protected for subclasses to sync updates to it
private int initialConnections = 0;
private int maxConnections = 0;
// State variables
private boolean initialized = false;
private Stack available = new Stack();
private Stack used = new Stack();
private Object lock = new Object()
;
private PGConnectionPoolDataSource source;
/**
* Gets a description of this DataSource.
*/
public String getDescription()
{
return "Pooling DataSource '" + dataSourceName + " from " + org.postgresql.Driver.getVersion();
}
/**
* Ensures the DataSource properties are not changed after the DataSource has
* been used.
*
* @throws java.lang.IllegalStateException
* The Server Name cannot be changed after the DataSource has been
* used.
*/
public void setServerName(String serverName)
{
if (initialized)
{
throw new IllegalStateException("Cannot set Data Source properties after DataSource has been used");
}
super.setServerName(serverName);
}
/**
* Ensures the DataSource properties are not changed after the DataSource has
* been used.
*
* @throws java.lang.IllegalStateException
* The Database Name cannot be changed after the DataSource has been
* used.
*/
public void setDatabaseName(String databaseName)
{
if (initialized)
{
throw new IllegalStateException("Cannot set Data Source properties after DataSource has been used");
}
super.setDatabaseName(databaseName);
}
/**
* Ensures the DataSource properties are not changed after the DataSource has
* been used.
*
* @throws java.lang.IllegalStateException
* The User cannot be changed after the DataSource has been
* used.
*/
public void setUser(String user)
{
if (initialized)
{
throw new IllegalStateException("Cannot set Data Source properties after DataSource has been used");
}
super.setUser(user);
}
/**
* Ensures the DataSource properties are not changed after the DataSource has
* been used.
*
* @throws java.lang.IllegalStateException
* The Password cannot be changed after the DataSource has been
* used.
*/
public void setPassword(String password)
{
if (initialized)
{
throw new IllegalStateException("Cannot set Data Source properties after DataSource has been used");
}
super.setPassword(password);
}
/**
* Ensures the DataSource properties are not changed after the DataSource has
* been used.
*
* @throws java.lang.IllegalStateException
* The Port Number cannot be changed after the DataSource has been
* used.
*/
public void setPortNumber(int portNumber)
{
if (initialized)
{
throw new IllegalStateException("Cannot set Data Source properties after DataSource has been used");
}
super.setPortNumber(portNumber);
}
/**
* Gets the number of connections that will be created when this DataSource
* is initialized. If you do not call initialize explicitly, it will be
* initialized the first time a connection is drawn from it.
*/
public int getInitialConnections()
{
return initialConnections;
}
/**
* Sets the number of connections that will be created when this DataSource
* is initialized. If you do not call initialize explicitly, it will be
* initialized the first time a connection is drawn from it.
*
* @throws java.lang.IllegalStateException
* The Initial Connections cannot be changed after the DataSource has been
* used.
*/
public void setInitialConnections(int initialConnections)
{
if (initialized)
{
throw new IllegalStateException("Cannot set Data Source properties after DataSource has been used");
}
this.initialConnections = initialConnections;
}
/**
* Gets the maximum number of connections that the pool will allow. If a request
* comes in and this many connections are in use, the request will block until a
* connection is available. Note that connections for a user other than the
* default user will not be pooled and don't count against this limit.
*
* @return The maximum number of pooled connection allowed, or 0 for no maximum.
*/
public int getMaxConnections()
{
return maxConnections;
}
/**
* Sets the maximum number of connections that the pool will allow. If a request
* comes in and this many connections are in use, the request will block until a
* connection is available. Note that connections for a user other than the
* default user will not be pooled and don't count against this limit.
*
* @param maxConnections The maximum number of pooled connection to allow, or
* 0 for no maximum.
*
* @throws java.lang.IllegalStateException
* The Maximum Connections cannot be changed after the DataSource has been
* used.
*/
public void setMaxConnections(int maxConnections)
{
if (initialized)
{
throw new IllegalStateException("Cannot set Data Source properties after DataSource has been used");
}
this.maxConnections = maxConnections;
}
/**
* Gets the name of this DataSource. This uniquely identifies the DataSource.
* You cannot use more than one DataSource in the same VM with the same name.
*/
public String getDataSourceName()
{
return dataSourceName;
}
/**
* Sets the name of this DataSource. This is required, and uniquely identifies
* the DataSource. You cannot create or use more than one DataSource in the
* same VM with the same name.
*
* @throws java.lang.IllegalStateException
* The Data Source Name cannot be changed after the DataSource has been
* used.
* @throws java.lang.IllegalArgumentException
* Another PoolingDataSource with the same dataSourceName already
* exists.
*/
public void setDataSourceName(String dataSourceName)
{
if (initialized)
{
throw new IllegalStateException("Cannot set Data Source properties after DataSource has been used");
}
if (this.dataSourceName != null && dataSourceName != null && dataSourceName.equals(this.dataSourceName))
{
return ;
}
synchronized (dataSources)
{
if (getDataSource(dataSourceName) != null)
{
throw new IllegalArgumentException("DataSource with name '" + dataSourceName + "' already exists!");
}
if (this.dataSourceName != null)
{
dataSources.remove(this.dataSourceName);
}
this.dataSourceName = dataSourceName;
addDataSource(dataSourceName);
}
}
/**
* Initializes this DataSource. If the initialConnections is greater than zero,
* that number of connections will be created. After this method is called,
* the DataSource properties cannot be changed. If you do not call this
* explicitly, it will be called the first time you get a connection from the
* DataSource.
* @throws java.sql.SQLException
* Occurs when the initialConnections is greater than zero, but the
* DataSource is not able to create enough physical connections.
*/
public void initialize() throws SQLException
{
synchronized (lock )
{
source = createConnectionPool();
try {
source.initializeFrom(this);
} catch (Exception e) {
throw new PSQLException(GT.tr("Failed to setup DataSource."),
PSQLState.UNEXPECTED_ERROR, e);
}
while (available.size() < initialConnections)
{
available.push(source.getPooledConnection());
}
initialized = true;
}
}
protected boolean isInitialized() {
return initialized;
}
/**
* Creates the appropriate ConnectionPool to use for this DataSource.
*/
protected PGConnectionPoolDataSource createConnectionPool() {
return new PGConnectionPoolDataSource();
}
/**
* Gets a non-pooled connection, unless the user and password are the
* same as the default values for this connection pool.
*
* @return A pooled connection.
* @throws SQLException
* Occurs when no pooled connection is available, and a new physical
* connection cannot be created.
*/
public Connection getConnection(String user, String password) throws SQLException
{
// If this is for the default user/password, use a pooled connection
if (user == null ||
(user.equals(getUser()) && ((password == null && getPassword() == null) || (password != null && password.equals(getPassword())))))
{
return getConnection();
}
// Otherwise, use a non-pooled connection
if (!initialized)
{
initialize();
}
return super.getConnection(user, password);
}
/**
* Gets a connection from the connection pool.
*
* @return A pooled connection.
* @throws SQLException
* Occurs when no pooled connection is available, and a new physical
* connection cannot be created.
*/
public Connection getConnection() throws SQLException
{
if (!initialized)
{
initialize();
}
return getPooledConnection();
}
/**
* Closes this DataSource, and all the pooled connections, whether in use or not.
*/
public void close()
{
synchronized (lock )
{
while (available.size() > 0)
{
PGPooledConnection pci = (PGPooledConnection)available.pop();
try
{
pci.close();
}
catch (SQLException e)
{
}
}
available = null;
while (used.size() > 0)
{
PGPooledConnection pci = (PGPooledConnection)used.pop();
pci.removeConnectionEventListener(connectionEventListener);
try
{
pci.close();
}
catch (SQLException e)
{
}
}
used = null;
}
removeStoredDataSource();
}
protected void removeStoredDataSource() {
synchronized (dataSources)
{
dataSources.remove(dataSourceName);
}
}
protected abstract void addDataSource(String dataSourceName);
/**
* Gets a connection from the pool. Will get an available one if
* present, or create a new one if under the max limit. Will
* block if all used and a new one would exceed the max.
*/
private Connection getPooledConnection() throws SQLException
{
PooledConnection pc = null;
synchronized (lock )
{
if (available == null)
{
throw new PSQLException(GT.tr("DataSource has been closed."),
PSQLState.CONNECTION_DOES_NOT_EXIST);
}
while (true)
{
if (available.size() > 0)
{
pc = (PooledConnection)available.pop();
used.push(pc);
break;
}
if (maxConnections == 0 || used.size() < maxConnections)
{
pc = source.getPooledConnection();
used.push(pc);
break;
}
else
{
try
{
// Wake up every second at a minimum
lock.wait(1000L);
}
catch (InterruptedException e)
{
}
}
}
}
pc.addConnectionEventListener(connectionEventListener);
return pc.getConnection();
}
/**
* Notified when a pooled connection is closed, or a fatal error occurs
* on a pooled connection. This is the only way connections are marked
* as unused.
*/
private ConnectionEventListener connectionEventListener = new ConnectionEventListener()
{
public void connectionClosed(ConnectionEvent event)
{
((PooledConnection)event.getSource()).removeConnectionEventListener(this);
synchronized (lock )
{
if (available == null)
{
return ; // DataSource has been closed
}
boolean removed = used.remove(event.getSource());
if (removed)
{
available.push(event.getSource());
// There's now a new connection available
lock.notify();
}
else
{
// a connection error occured
}
}
}
/**
* This is only called for fatal errors, where the physical connection is
* useless afterward and should be removed from the pool.
*/
public void connectionErrorOccurred(ConnectionEvent event)
{
((PooledConnection) event.getSource()).removeConnectionEventListener(this);
synchronized (lock )
{
if (available == null)
{
return ; // DataSource has been closed
}
used.remove(event.getSource());
// We're now at least 1 connection under the max
lock.notify();
}
}
};
/**
* Adds custom properties for this DataSource to the properties defined in
* the superclass.
*/
public Reference getReference() throws NamingException
{
Reference ref = super.getReference();
ref.add(new StringRefAddr("dataSourceName", dataSourceName));
if (initialConnections > 0)
{
ref.add(new StringRefAddr("initialConnections", Integer.toString(initialConnections)));
}
if (maxConnections > 0)
{
ref.add(new StringRefAddr("maxConnections", Integer.toString(maxConnections)));
}
return ref;
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/ds/jdbc23/AbstractJdbc23SimpleDataSource.java 0000664 0000000 0000000 00000002436 12050675701 0030777 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.ds.jdbc23;
import java.io.Serializable;
import java.io.ObjectOutputStream;
import java.io.ObjectInputStream;
import java.io.IOException;
import org.postgresql.ds.common.*;
/**
* Simple DataSource which does not perform connection pooling. In order to use
* the DataSource, you must set the property databaseName. The settings for
* serverName, portNumber, user, and password are optional. Note: these properties
* are declared in the superclass.
*
* @author Aaron Mulder (ammulder@chariotsolutions.com)
*/
public abstract class AbstractJdbc23SimpleDataSource extends BaseDataSource implements Serializable
{
/**
* Gets a description of this DataSource.
*/
public String getDescription()
{
return "Non-Pooling DataSource from " + org.postgresql.Driver.getVersion();
}
private void writeObject(ObjectOutputStream out) throws IOException
{
writeBaseObject(out);
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
{
readBaseObject(in);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/ds/jdbc4/ 0000775 0000000 0000000 00000000000 12050675701 0022226 5 ustar 00root root 0000000 0000000 postgresql-jdbc-9.2-1002.src/org/postgresql/ds/jdbc4/AbstractJdbc4ConnectionPoolDataSource.java 0000664 0000000 0000000 00000000723 12050675701 0032332 0 ustar 00root root 0000000 0000000 package org.postgresql.ds.jdbc4;
import java.sql.SQLFeatureNotSupportedException;
import org.postgresql.ds.jdbc23.AbstractJdbc23ConnectionPoolDataSource;
public class AbstractJdbc4ConnectionPoolDataSource
extends AbstractJdbc23ConnectionPoolDataSource
{
public java.util.logging.Logger getParentLogger() throws java.sql.SQLFeatureNotSupportedException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getParentLogger()");
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/ds/jdbc4/AbstractJdbc4PooledConnection.java 0000664 0000000 0000000 00000002036 12050675701 0030667 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.ds.jdbc4;
import java.sql.Connection;
import java.sql.SQLFeatureNotSupportedException;
import javax.sql.StatementEventListener;
import org.postgresql.ds.jdbc23.AbstractJdbc23PooledConnection;
public abstract class AbstractJdbc4PooledConnection extends AbstractJdbc23PooledConnection
{
public AbstractJdbc4PooledConnection(Connection con, boolean autoCommit, boolean isXA)
{
super(con, autoCommit, isXA);
}
public void removeStatementEventListener(StatementEventListener listener)
{
}
public void addStatementEventListener(StatementEventListener listener)
{
}
public java.util.logging.Logger getParentLogger() throws SQLFeatureNotSupportedException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getParentLogger()");
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/ds/jdbc4/AbstractJdbc4PoolingDataSource.java 0000664 0000000 0000000 00000002014 12050675701 0031003 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.ds.jdbc4;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import org.postgresql.ds.jdbc23.AbstractJdbc23PoolingDataSource;
public abstract class AbstractJdbc4PoolingDataSource extends AbstractJdbc23PoolingDataSource
{
public boolean isWrapperFor(Class iface) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "isWrapperFor(Class)");
}
public T unwrap(Class iface) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "unwrap(Class)");
}
public java.util.logging.Logger getParentLogger() throws SQLFeatureNotSupportedException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getParentLogger()");
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/ds/jdbc4/AbstractJdbc4SimpleDataSource.java 0000664 0000000 0000000 00000002007 12050675701 0030627 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.ds.jdbc4;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import org.postgresql.ds.jdbc23.AbstractJdbc23SimpleDataSource;
public abstract class AbstractJdbc4SimpleDataSource extends AbstractJdbc23SimpleDataSource
{
public boolean isWrapperFor(Class iface) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "isWrapperFor(Class)");
}
public T unwrap(Class iface) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "unwrap(Class)");
}
public java.util.logging.Logger getParentLogger() throws SQLFeatureNotSupportedException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getParentLogger()");
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/fastpath/ 0000775 0000000 0000000 00000000000 12050675701 0022444 5 ustar 00root root 0000000 0000000 postgresql-jdbc-9.2-1002.src/org/postgresql/fastpath/Fastpath.java 0000664 0000000 0000000 00000022225 12050675701 0025064 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2003-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.fastpath;
import java.sql.SQLException;
import java.sql.ResultSet;
import java.util.HashMap;
import java.util.Map;
import org.postgresql.core.BaseConnection;
import org.postgresql.core.QueryExecutor;
import org.postgresql.core.ParameterList;
import org.postgresql.util.PSQLException;
import org.postgresql.util.PSQLState;
import org.postgresql.util.GT;
/**
* This class implements the Fastpath api.
*
*
This 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 final static long NUM_OIDS = 4294967296L; // 2^32
// This maps the functions names to their id's (possible unique just
// to a connection).
private final Map func = new HashMap();
private final QueryExecutor executor;
private final BaseConnection connection;
/**
* Initialises the fastpath system
*
* @param conn BaseConnection to attach to
*/
public Fastpath(BaseConnection conn)
{
this.connection = conn;
this.executor = conn.getQueryExecutor();
}
/**
* Send a function call to the PostgreSQL backend
*
* @param fnId Function id
* @param resultType True if the result is an integer, false for other results
* @param args FastpathArguments to pass to fastpath
* @return null if no data, Integer if an integer result, or byte[] otherwise
* @exception SQLException if a database-access error occurs.
*/
public Object fastpath(int fnId, boolean resultType, FastpathArg[] args) throws SQLException
{
// Turn fastpath array into a parameter list.
ParameterList params = executor.createFastpathParameters(args.length);
for (int i = 0; i < args.length; ++i)
{
args[i].populateParameter(params, i + 1);
}
// Run it.
byte[] returnValue = executor.fastpathCall(fnId, params, connection.getAutoCommit());
// Interpret results.
if (!resultType || returnValue == null)
return returnValue;
if (returnValue.length != 4)
throw new PSQLException(GT.tr("Fastpath call {0} - No result was returned and we expected an integer.", new Integer(fnId)),
PSQLState.NO_DATA);
return new Integer((returnValue[3] & 255) |
((returnValue[2] & 255) << 8) |
((returnValue[1] & 255) << 16) |
((returnValue[0] & 255) << 24));
}
/**
* Send a function call to the PostgreSQL backend by name.
*
* Note: the mapping for the procedure name to function id needs to exist,
* usually to an earlier call to addfunction().
*
* This is the prefered 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 resulttype True if the result is an integer, false for other
* results
* @param args FastpathArguments to pass to fastpath
* @return null if no data, Integer if an integer result, or byte[] otherwise
* @exception SQLException if name is unknown or if a database-access error
* occurs.
* @see org.postgresql.largeobject.LargeObject
*/
public Object fastpath(String name, boolean resulttype, FastpathArg[] args) throws SQLException
{
if (connection.getLogger().logDebug())
connection.getLogger().debug("Fastpath: calling " + name);
return fastpath(getID(name), resulttype, args);
}
/**
* This convenience method assumes that the return value is an Integer
* @param name Function name
* @param args Function arguments
* @return integer result
* @exception SQLException if a database-access error occurs or no result
*/
public int getInteger(String name, FastpathArg[] args) throws SQLException
{
Integer i = (Integer)fastpath(name, true, args);
if (i == null)
throw new PSQLException(GT.tr("Fastpath call {0} - No result was returned and we expected an integer.", name),
PSQLState.NO_DATA);
return i.intValue();
}
/**
* This convenience method assumes that the return value is an oid.
* @param name Function name
* @param args Function arguments
* @exception 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
* @exception SQLException if a database-access error occurs or no result
*/
public byte[] getData(String name, FastpathArg[] args) throws SQLException
{
return (byte[])fastpath(name, false, 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, new Integer(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.
*
*
Dont 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
* @exception SQLException if a database-access error occurs.
* @see org.postgresql.largeobject.LargeObjectManager
*/
public void addFunctions(ResultSet rs) throws SQLException
{
while (rs.next())
{
func.put(rs.getString(1), new Integer(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
* @exception SQLException is function is unknown.
*/
public int getID(String name) throws SQLException
{
Integer id = (Integer)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.intValue();
}
/**
* 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.
*/
public static FastpathArg createOIDArg(long oid)
{
if (oid > Integer.MAX_VALUE)
oid -= NUM_OIDS;
return new FastpathArg((int)oid);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/fastpath/FastpathArg.java 0000664 0000000 0000000 00000004305 12050675701 0025515 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2003-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.fastpath;
import java.sql.SQLException;
import org.postgresql.core.ParameterList;
// 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[] bytes;
private final int bytesStart;
private final int bytesLength;
/**
* 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 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 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)
{
this(s.getBytes());
}
void populateParameter(ParameterList params, int index) throws SQLException {
if (bytes == null)
params.setNull(index, 0);
else
params.setBytea(index, bytes, bytesStart, bytesLength);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/geometric/ 0000775 0000000 0000000 00000000000 12050675701 0022610 5 ustar 00root root 0000000 0000000 postgresql-jdbc-9.2-1002.src/org/postgresql/geometric/PGbox.java 0000664 0000000 0000000 00000012006 12050675701 0024471 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2003-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.geometric;
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 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 point[] = new PGpoint[2];
/**
* @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();
this.point[0] = new PGpoint(x1, y1);
this.point[1] = new PGpoint(x2, y2);
}
/**
* @param p1 first point
* @param p2 second point
*/
public PGbox(PGpoint p1, PGpoint p2)
{
this();
this.point[0] = p1;
this.point[1] = p2;
}
/**
* @param s Box definition in PostgreSQL syntax
* @exception SQLException if definition is invalid
*/
public PGbox(String s) throws SQLException
{
this();
setValue(s);
}
/**
* Required constructor
*/
public PGbox()
{
setType("box");
}
/**
* This method sets the value of this object. It should be overidden,
* but still called by subclasses.
*
* @param value a string representation of the value of the object
* @exception SQLException thrown if value is invalid for this type
*/
public void setValue(String value) throws SQLException
{
PGtokenizer t = new PGtokenizer(value, ',');
if (t.getSize() != 2)
throw new PSQLException(GT.tr("Conversion to type {0} failed: {1}.", new Object[]{type,value}), PSQLState.DATA_TYPE_MISMATCH);
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
*/
public void setByteValue(byte[] b, int offset) {
point[0] = new PGpoint();
point[0].setByteValue(b, offset);
point[1] = new PGpoint();
point[1].setByteValue(b, offset + point[0].lengthInBytes());
}
/**
* @param obj Object to compare with
* @return true if the two boxes are identical
*/
public boolean equals(Object obj)
{
if (obj instanceof PGbox)
{
PGbox p = (PGbox)obj;
// Same points.
if (p.point[0].equals(point[0]) && p.point[1].equals(point[1]))
return true;
// Points swapped.
if (p.point[0].equals(point[1]) && p.point[1].equals(point[0]))
return true;
// Using the opposite two points of the box:
// (x1,y1),(x2,y2) -> (x1,y2),(x2,y1)
if (p.point[0].x == point[0].x && p.point[0].y == point[1].y &&
p.point[1].x == point[1].x && p.point[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 (p.point[0].x == point[1].x && p.point[0].y == point[0].y &&
p.point[1].x == point[0].x && p.point[1].y == point[1].y)
return true;
}
return false;
}
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.
return point[0].hashCode() ^ point[1].hashCode();
}
public Object clone() throws CloneNotSupportedException
{
PGbox newPGbox = (PGbox) super.clone();
if( newPGbox.point != null )
{
newPGbox.point = (PGpoint[]) 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
*/
public String getValue()
{
return point[0].toString() + "," + point[1].toString();
}
public int lengthInBytes() {
return point[0].lengthInBytes() + point[1].lengthInBytes();
}
public void toBytes(byte[] bytes, int offset) {
point[0].toBytes(bytes, offset);
point[1].toBytes(bytes, offset + point[0].lengthInBytes());
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/geometric/PGcircle.java 0000664 0000000 0000000 00000006451 12050675701 0025151 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2003-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
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 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 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.
* @exception SQLException on conversion failure
*/
public PGcircle(String s) throws SQLException
{
this();
setValue(s);
}
/**
* This constructor is used by the driver.
*/
public PGcircle()
{
setType("circle");
}
/**
* @param s definition of the circle in PostgreSQL's syntax.
* @exception SQLException on conversion failure
*/
public void setValue(String s) throws SQLException
{
PGtokenizer t = new PGtokenizer(PGtokenizer.removeAngle(s), ',');
if (t.getSize() != 2)
throw new PSQLException(GT.tr("Conversion to type {0} failed: {1}.", new Object[]{type,s}), PSQLState.DATA_TYPE_MISMATCH);
try
{
center = new PGpoint(t.getToken(0));
radius = Double.valueOf(t.getToken(1)).doubleValue();
}
catch (NumberFormatException e)
{
throw new PSQLException(GT.tr("Conversion to type {0} failed: {1}.", new Object[]{type,s}), PSQLState.DATA_TYPE_MISMATCH, e);
}
}
/**
* @param obj Object to compare with
* @return true if the two circles are identical
*/
public boolean equals(Object obj)
{
if (obj instanceof PGcircle)
{
PGcircle p = (PGcircle)obj;
return p.center.equals(center) && p.radius == radius;
}
return false;
}
public int hashCode()
{
long v = Double.doubleToLongBits(radius);
return (int) (center.hashCode() ^ v ^ (v >>> 32));
}
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
*/
public String getValue()
{
return "<" + center + "," + radius + ">";
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/geometric/PGline.java 0000664 0000000 0000000 00000006542 12050675701 0024640 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2003-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
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 java.io.Serializable;
import java.sql.SQLException;
/**
* This implements a line consisting of two points.
*
* Currently line is not yet implemented in the backend, but this class
* ensures that when it's done were ready for it.
*/
public class PGline extends PGobject implements Serializable, Cloneable
{
/**
* These are the two points.
*/
public PGpoint point[] = new PGpoint[2];
/**
* @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 PGline(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 PGline(PGpoint p1, PGpoint p2)
{
this();
this.point[0] = p1;
this.point[1] = p2;
}
/**
* @param s definition of the line in PostgreSQL's syntax.
* @exception SQLException on conversion failure
*/
public PGline(String s) throws SQLException
{
this();
setValue(s);
}
/**
* reuired by the driver
*/
public PGline()
{
setType("line");
}
/**
* @param s Definition of the line in PostgreSQL's syntax
* @exception SQLException on conversion failure
*/
public void setValue(String s) throws SQLException
{
PGtokenizer t = new PGtokenizer(PGtokenizer.removeBox(s), ',');
if (t.getSize() != 2)
throw new PSQLException(GT.tr("Conversion to type {0} failed: {1}.", new Object[]{type,s}), PSQLState.DATA_TYPE_MISMATCH);
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 lines are identical
*/
public boolean equals(Object obj)
{
if (obj instanceof PGline)
{
PGline p = (PGline)obj;
return (p.point[0].equals(point[0]) && p.point[1].equals(point[1])) ||
(p.point[0].equals(point[1]) && p.point[1].equals(point[0]));
}
return false;
}
public int hashCode() {
return point[0].hashCode() ^ point[1].hashCode();
}
public Object clone() throws CloneNotSupportedException
{
PGline newPGline = (PGline) super.clone();
if( newPGline.point != null )
{
newPGline.point = (PGpoint[]) newPGline.point.clone();
for( int i = 0; i < newPGline.point.length; ++i )
if( newPGline.point[i] != null )
newPGline.point[i] = (PGpoint) newPGline.point[i].clone();
}
return newPGline;
}
/**
* @return the PGline in the syntax expected by org.postgresql
*/
public String getValue()
{
return "[" + point[0] + "," + point[1] + "]";
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/geometric/PGlseg.java 0000664 0000000 0000000 00000006423 12050675701 0024641 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2003-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
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 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 point[] = new PGpoint[2];
/**
* @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();
this.point[0] = p1;
this.point[1] = p2;
}
/**
* @param s definition of the line segment in PostgreSQL's syntax.
* @exception SQLException on conversion failure
*/
public PGlseg(String s) throws SQLException
{
this();
setValue(s);
}
/**
* reuired by the driver
*/
public PGlseg()
{
setType("lseg");
}
/**
* @param s Definition of the line segment in PostgreSQL's syntax
* @exception SQLException on conversion failure
*/
public void setValue(String s) throws SQLException
{
PGtokenizer t = new PGtokenizer(PGtokenizer.removeBox(s), ',');
if (t.getSize() != 2)
throw new PSQLException(GT.tr("Conversion to type {0} failed: {1}.", new Object[]{type,s}), PSQLState.DATA_TYPE_MISMATCH);
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
*/
public boolean equals(Object obj)
{
if (obj instanceof PGlseg)
{
PGlseg p = (PGlseg)obj;
return (p.point[0].equals(point[0]) && p.point[1].equals(point[1])) ||
(p.point[0].equals(point[1]) && p.point[1].equals(point[0]));
}
return false;
}
public int hashCode()
{
return point[0].hashCode() ^ point[1].hashCode();
}
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
*/
public String getValue()
{
return "[" + point[0] + "," + point[1] + "]";
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/geometric/PGpath.java 0000664 0000000 0000000 00000010205 12050675701 0024634 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2003-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
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 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 points[];
/**
* @param points the PGpoints that define the path
* @param open True if the path is open, false if closed
*/
public PGpath(PGpoint[] points, boolean open)
{
this();
this.points = points;
this.open = open;
}
/**
* Required by the driver
*/
public PGpath()
{
setType("path");
}
/**
* @param s definition of the path in PostgreSQL's syntax.
* @exception SQLException on conversion failure
*/
public PGpath(String s) throws SQLException
{
this();
setValue(s);
}
/**
* @param s Definition of the path in PostgreSQL's syntax
* @exception SQLException on conversion failure
*/
public void setValue(String s) throws SQLException
{
// 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();
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 paths are identical
*/
public boolean equals(Object obj)
{
if (obj instanceof PGpath)
{
PGpath p = (PGpath)obj;
if (p.points.length != points.length)
return false;
if (p.open != open)
return false;
for (int i = 0;i < points.length;i++)
if (!points[i].equals(p.points[i]))
return false;
return true;
}
return false;
}
public int hashCode() {
// XXX not very good..
int hash = 0;
for (int i = 0; i < points.length && i < 5; ++i)
{
hash = hash ^ points[i].hashCode();
}
return hash;
}
public Object clone() throws CloneNotSupportedException
{
PGpath newPGpath = (PGpath) super.clone();
if( newPGpath.points != null )
{
newPGpath.points = (PGpoint[]) newPGpath.points.clone();
for( int i = 0; i < newPGpath.points.length; ++i )
newPGpath.points[i] = (PGpoint) newPGpath.points[i].clone();
}
return newPGpath;
}
/**
* This returns the path in the syntax expected by org.postgresql
*/
public String getValue()
{
StringBuffer b = new StringBuffer(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;
}
public boolean isClosed()
{
return !open;
}
public void closePath()
{
open = false;
}
public void openPath()
{
open = true;
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/geometric/PGpoint.java 0000664 0000000 0000000 00000011635 12050675701 0025041 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2003-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
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 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;
/**
* @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
*/
public PGpoint(String value) throws SQLException
{
this();
setValue(value);
}
/**
* Required by the driver
*/
public PGpoint()
{
setType("point");
}
/**
* @param s Definition of this point in PostgreSQL's syntax
* @exception SQLException on conversion failure
*/
public void setValue(String s) throws SQLException
{
PGtokenizer t = new PGtokenizer(PGtokenizer.removePara(s), ',');
try
{
x = Double.valueOf(t.getToken(0)).doubleValue();
y = Double.valueOf(t.getToken(1)).doubleValue();
}
catch (NumberFormatException e)
{
throw new PSQLException(GT.tr("Conversion to type {0} failed: {1}.", new Object[]{type,s}), PSQLState.DATA_TYPE_MISMATCH, e);
}
}
/**
* @param b Definition of this point in PostgreSQL's binary syntax
*/
public void setByteValue(byte[] b, int offset) {
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
*/
public boolean equals(Object obj)
{
if (obj instanceof PGpoint)
{
PGpoint p = (PGpoint)obj;
return x == p.x && y == p.y;
}
return false;
}
public int hashCode()
{
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
*/
public String getValue()
{
return "(" + x + "," + y + ")";
}
public int lengthInBytes() {
return 16;
}
/**
* @return the PGpoint in the binary syntax expected by org.postgresql
*/
public void toBytes(byte[] b, int offset) {
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.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.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
*/
public void setLocation(Point p)
{
setLocation(p.x, p.y);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/geometric/PGpolygon.java 0000664 0000000 0000000 00000006401 12050675701 0025372 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2003-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.geometric;
import org.postgresql.util.PGobject;
import org.postgresql.util.PGtokenizer;
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 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.
* @exception SQLException on conversion failure
*/
public PGpolygon(String s) throws SQLException
{
this();
setValue(s);
}
/**
* Required by the driver
*/
public PGpolygon()
{
setType("polygon");
}
/**
* @param s Definition of the polygon in PostgreSQL's syntax
* @exception SQLException on conversion failure
*/
public void setValue(String s) throws SQLException
{
PGtokenizer t = new PGtokenizer(PGtokenizer.removePara(s), ',');
int npoints = t.getSize();
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
*/
public boolean equals(Object obj)
{
if (obj instanceof PGpolygon)
{
PGpolygon p = (PGpolygon)obj;
if (p.points.length != points.length)
return false;
for (int i = 0;i < points.length;i++)
if (!points[i].equals(p.points[i]))
return false;
return true;
}
return false;
}
public int hashCode() {
// XXX not very good..
int hash = 0;
for (int i = 0; i < points.length && i < 5; ++i)
{
hash = hash ^ points[i].hashCode();
}
return hash;
}
public Object clone() throws CloneNotSupportedException
{
PGpolygon newPGpolygon = (PGpolygon) super.clone();
if( newPGpolygon.points != null )
{
newPGpolygon.points = (PGpoint[]) newPGpolygon.points.clone();
for( int i = 0; i < newPGpolygon.points.length; ++i )
if( newPGpolygon.points[i] != null )
newPGpolygon.points[i] = (PGpoint) newPGpolygon.points[i].clone();
}
return newPGpolygon;
}
/**
* @return the PGpolygon in the syntax expected by org.postgresql
*/
public String getValue()
{
StringBuffer b = new StringBuffer();
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-jdbc-9.2-1002.src/org/postgresql/gss/ 0000775 0000000 0000000 00000000000 12050675701 0021426 5 ustar 00root root 0000000 0000000 postgresql-jdbc-9.2-1002.src/org/postgresql/gss/GSSCallbackHandler.java 0000664 0000000 0000000 00000004236 12050675701 0025645 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2008-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.gss;
import java.io.IOException;
import javax.security.auth.callback.*;
public class GSSCallbackHandler implements CallbackHandler {
private final String user;
private final String password;
public GSSCallbackHandler(String user, String password)
{
this.user = user;
this.password = password;
}
public void handle(Callback[] callbacks) throws IOException, UnsupportedCallbackException
{
for (int i=0; i Password(GSS Authentication Token)");
pgStream.SendChar('p');
pgStream.SendInteger4(4 + outToken.length);
pgStream.Send(outToken);
pgStream.flush();
}
if (!secContext.isEstablished()) {
int response = pgStream.ReceiveChar();
// Error
if (response == 'E') {
int l_elen = pgStream.ReceiveInteger4();
ServerErrorMessage l_errorMsg = new ServerErrorMessage(pgStream.ReceiveString(l_elen - 4), logger.getLogLevel());
if (logger.logDebug())
logger.debug(" <=BE ErrorMessage(" + l_errorMsg + ")");
return new PSQLException(l_errorMsg);
} else if (response == 'R') {
if (logger.logDebug())
logger.debug(" <=BE AuthenticationGSSContinue");
int len = pgStream.ReceiveInteger4();
int type = pgStream.ReceiveInteger4();
// should check type = 8
inToken = pgStream.Receive(len - 8);
} else {
// Unknown/unexpected message type.
return new PSQLException(GT.tr("Protocol error. Session setup failed."), PSQLState.CONNECTION_UNABLE_TO_CONNECT);
}
} else {
established = true;
}
}
} catch (IOException e) {
return e;
} catch (GSSException gsse) {
return new PSQLException(GT.tr("GSS Authentication failed"), PSQLState.CONNECTION_FAILURE, gsse);
}
return null;
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc2/ 0000775 0000000 0000000 00000000000 12050675701 0021616 5 ustar 00root root 0000000 0000000 postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc2/AbstractJdbc2Array.java 0000664 0000000 0000000 00000075173 12050675701 0026105 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc2;
import org.postgresql.core.*;
import org.postgresql.util.ByteConverter;
import org.postgresql.util.PSQLException;
import org.postgresql.util.PSQLState;
import org.postgresql.util.GT;
import java.io.IOException;
import java.math.BigDecimal;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
/**
* Array is used collect one column of query result data.
*
*
* Read 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 abstract class AbstractJdbc2Array
{
/**
* Array list implementation specific for storing PG array elements.
*/
private static class PgArrayList extends ArrayList
{
private static final long serialVersionUID = 2052783752654562677L;
/**
* How many dimensions.
*/
int dimensionsCount = 1;
}
/**
* A database connection.
*/
private BaseConnection connection = null;
/**
* The OID of this field.
*/
private int oid;
/**
* Field value as String.
*/
private String fieldString = null;
/**
* Whether Object[] should be used instead primitive arrays. Object[] can
* contain null elements. It should be set to true if
* {@link BaseConnection#haveMinimumCompatibleVersion(String)} returns
* true for argument "8.3".
*/
private final boolean useObjects;
/**
* Are we connected to an 8.2 or higher server? Only 8.2 or higher
* supports null array elements.
*/
private final boolean haveMinServer82;
/**
* Value of field as {@link PgArrayList}. Will be initialized only once
* within {@link #buildArrayList()}.
*/
private PgArrayList arrayList;
private byte[] fieldBytes;
private AbstractJdbc2Array(BaseConnection connection, int oid) throws SQLException {
this.connection = connection;
this.oid = oid;
this.useObjects = connection.haveMinimumCompatibleVersion("8.3");
this.haveMinServer82 = connection.haveMinimumServerVersion("8.2");
}
/**
* 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
*/
public AbstractJdbc2Array(BaseConnection connection, int oid, 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
*/
public AbstractJdbc2Array(BaseConnection connection, int oid, byte[] fieldBytes) throws SQLException {
this(connection, oid);
this.fieldBytes = fieldBytes;
}
public Object getArray() throws SQLException
{
return getArrayImpl(1, 0, null);
}
public Object getArray(long index, int count) throws SQLException
{
return getArrayImpl(index, count, null);
}
public Object getArrayImpl(Map map) throws SQLException
{
return getArrayImpl(1, 0, map);
}
public Object getArrayImpl(long index, int count, Map map) throws SQLException
{
// for now maps aren't supported.
if (map != null && !map.isEmpty())
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getArrayImpl(long,int,Map)");
}
// array index is out of range
if (index < 1)
{
throw new PSQLException(GT.tr("The array index is out of range: {0}", new Long(index)), PSQLState.DATA_ERROR);
}
if (fieldBytes != null) {
return readBinaryArray((int) index, count);
}
buildArrayList();
if (count == 0)
count = arrayList.size();
// array index out of range
if ((--index) + count > arrayList.size())
{
throw new PSQLException(GT.tr("The array index is out of range: {0}, number of elements: {1}.", new Object[] { new Long(index + count), new Long(arrayList.size()) }), PSQLState.DATA_ERROR);
}
return buildArray(arrayList, (int) index, count);
}
private Object readBinaryArray(int index, int count) throws SQLException {
int dimensions = ByteConverter.int4(fieldBytes, 0);
//int flags = ByteConverter.int4(fieldBytes, 4); // bit 0: 0=no-nulls, 1=has-nulls
int elementOid = ByteConverter.int4(fieldBytes, 8);
int pos = 12;
int[] dims = new int[dimensions];
for (int d = 0; d < dimensions; ++d) {
dims[d] = ByteConverter.int4(fieldBytes, pos); pos += 4;
/*int lbound = ByteConverter.int4(fieldBytes, pos);*/ pos += 4;
}
if (dimensions == 0) {
return java.lang.reflect.Array.newInstance(elementOidToClass(elementOid), 0);
}
if (count > 0) {
dims[0] = Math.min(count, dims[0]);
}
Object arr = java.lang.reflect.Array.newInstance(elementOidToClass(elementOid), dims);
try {
storeValues((Object[]) arr, elementOid, dims, pos, 0, index);
}
catch (IOException ioe)
{
throw new PSQLException(GT.tr("Invalid character data was found. This is most likely caused by stored data containing characters that are invalid for the character set the database was created in. The most common example of this is storing 8bit data in a SQL_ASCII database."), PSQLState.DATA_ERROR, ioe);
}
return arr;
}
private int storeValues(final Object[] arr, int elementOid, final int[] dims, int pos, final int thisDimension, int index) throws SQLException, IOException {
if (thisDimension == dims.length - 1) {
for (int i = 1; i < index; ++i) {
int len = ByteConverter.int4(fieldBytes, pos); pos += 4;
if (len != -1) {
pos += len;
}
}
for (int i = 0; i < dims[thisDimension]; ++i) {
int len = ByteConverter.int4(fieldBytes, pos); pos += 4;
if (len == -1) {
continue;
}
switch (elementOid) {
case Oid.INT2:
arr[i] = new Short(ByteConverter.int2(fieldBytes, pos));
break;
case Oid.INT4:
arr[i] = new Integer(ByteConverter.int4(fieldBytes, pos));
break;
case Oid.INT8:
arr[i] = new Long(ByteConverter.int8(fieldBytes, pos));
break;
case Oid.FLOAT4:
arr[i] = new Float(ByteConverter.float4(fieldBytes, pos));
break;
case Oid.FLOAT8:
arr[i] = new Double(ByteConverter.float8(fieldBytes, pos));
break;
case Oid.TEXT:
case Oid.VARCHAR:
Encoding encoding = connection.getEncoding();
arr[i] = encoding.decode(fieldBytes, pos, len);
break;
}
pos += len;
}
} else {
for (int i = 0; i < dims[thisDimension]; ++i) {
pos = storeValues((Object[]) arr[i], elementOid, dims, pos, thisDimension + 1, 0);
}
}
return pos;
}
private ResultSet readBinaryResultSet(int index, int count) throws SQLException {
int dimensions = ByteConverter.int4(fieldBytes, 0);
//int flags = ByteConverter.int4(fieldBytes, 4); // bit 0: 0=no-nulls, 1=has-nulls
int elementOid = ByteConverter.int4(fieldBytes, 8);
int pos = 12;
int[] dims = new int[dimensions];
for (int d = 0; d < dimensions; ++d) {
dims[d] = ByteConverter.int4(fieldBytes, pos); pos += 4;
/*int lbound = ByteConverter.int4(fieldBytes, pos); */ pos += 4;
}
if (count > 0 && dimensions > 0) {
dims[0] = Math.min(count, dims[0]);
}
List rows = new ArrayList();
Field[] fields = new Field[2];
if (dimensions > 0) {
storeValues(rows, fields, elementOid, dims, pos, 0, index);
}
BaseStatement stat = (BaseStatement) connection.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
return stat.createDriverResultSet(fields, rows);
}
private int storeValues(List rows, Field[] fields, int elementOid, final int[] dims, int pos, final int thisDimension, int index) throws SQLException {
if (thisDimension == dims.length - 1) {
fields[0] = new Field("INDEX", Oid.INT4);
fields[0].setFormat(Field.BINARY_FORMAT);
fields[1] = new Field("VALUE", elementOid);
fields[1].setFormat(Field.BINARY_FORMAT);
for (int i = 1; i < index; ++i) {
int len = ByteConverter.int4(fieldBytes, pos); pos += 4;
if (len != -1) {
pos += len;
}
}
for (int i = 0; i < dims[thisDimension]; ++i) {
byte[][] rowData = new byte[2][];
rowData[0] = new byte[4];
ByteConverter.int4(rowData[0], 0, i + index);
rows.add(rowData);
int len = ByteConverter.int4(fieldBytes, pos); pos += 4;
if (len == -1) {
continue;
}
rowData[1] = new byte[len];
System.arraycopy(fieldBytes, pos, rowData[1], 0, rowData[1].length);
pos += len;
}
} else {
fields[0] = new Field("INDEX", Oid.INT4);
fields[0].setFormat(Field.BINARY_FORMAT);
fields[1] = new Field("VALUE", oid);
fields[1].setFormat(Field.BINARY_FORMAT);
int nextDimension = thisDimension + 1;
int dimensionsLeft = dims.length - nextDimension;
for (int i = 1; i < index; ++i) {
pos = calcRemainingDataLength(dims, pos, elementOid, nextDimension);
}
for (int i = 0; i < dims[thisDimension]; ++i) {
byte[][] rowData = new byte[2][];
rowData[0] = new byte[4];
ByteConverter.int4(rowData[0], 0, i + index);
rows.add(rowData);
int dataEndPos = calcRemainingDataLength(dims, pos, elementOid, nextDimension);
int dataLength = dataEndPos - pos;
rowData[1] = new byte[12 + 8 * dimensionsLeft + dataLength];
ByteConverter.int4(rowData[1], 0, dimensionsLeft);
System.arraycopy(fieldBytes, 4, rowData[1], 4, 8);
System.arraycopy(fieldBytes, 12 + nextDimension * 8, rowData[1], 12, dimensionsLeft * 8);
System.arraycopy(fieldBytes, pos, rowData[1], 12 + dimensionsLeft * 8, dataLength);
pos = dataEndPos;
}
}
return pos;
}
private int calcRemainingDataLength(int[] dims, int pos, int elementOid, int thisDimension) {
if (thisDimension == dims.length - 1) {
for (int i = 0; i < dims[thisDimension]; ++i) {
int len = ByteConverter.int4(fieldBytes, pos); pos += 4;
if (len == -1) {
continue;
}
pos += len;
}
} else {
pos = calcRemainingDataLength(dims, elementOid, pos, thisDimension + 1);
}
return pos;
}
private Class elementOidToClass(int oid)
throws SQLException {
switch (oid) {
case Oid.INT2:
return Short.class;
case Oid.INT4:
return Integer.class;
case Oid.INT8:
return Long.class;
case Oid.FLOAT4:
return Float.class;
case Oid.FLOAT8:
return Double.class;
case Oid.TEXT:
case Oid.VARCHAR:
return String.class;
default:
throw org.postgresql.Driver.notImplemented(this.getClass(),
"readBinaryArray(data,oid)");
}
}
/**
* Build {@link ArrayList} from field's string input. As a result
* of this method {@link #arrayList} is build. Method can be called
* many times in order to make sure that array list is ready to use, however
* {@link #arrayList} will be set only once during first call.
*/
private synchronized void buildArrayList() throws SQLException
{
if (arrayList != null)
return;
arrayList = new PgArrayList();
char delim = connection.getTypeInfo().getArrayDelimiter(oid);
if (fieldString != null)
{
char[] chars = fieldString.toCharArray();
StringBuffer buffer = null;
boolean insideString = false;
boolean wasInsideString = false; // needed for checking if NULL
// value occured
List dims = new ArrayList(); // array dimension arrays
PgArrayList curArray = arrayList; // currently processed array
// Starting with 8.0 non-standard (beginning index
// isn't 1) bounds the dimensions are returned in the
// data formatted like so "[0:3]={0,1,2,3,4}".
// Older versions simply do not return the bounds.
//
// Right now we ignore these bounds, but we could
// consider allowing these index values to be used
// even though the JDBC spec says 1 is the first
// index. I'm not sure what a client would like
// to see, so we just retain the old behavior.
int startOffset = 0;
{
if (chars[0] == '[')
{
while (chars[startOffset] != '=')
{
startOffset++;
}
startOffset++; // skip =
}
}
for (int i = startOffset; i < chars.length; i++)
{
// escape character that we need to skip
if (chars[i] == '\\')
i++;
// subarray start
else if (!insideString && chars[i] == '{')
{
if (dims.size() == 0)
{
dims.add(arrayList);
}
else
{
PgArrayList a = new PgArrayList();
PgArrayList p = ((PgArrayList) dims.get(dims.size() - 1));
p.add(a);
dims.add(a);
}
curArray = (PgArrayList) dims.get(dims.size() - 1);
// number of dimensions
{
for (int t = i + 1; t < chars.length; t++) {
if (Character.isWhitespace(chars[t])) continue;
else if (chars[t] == '{') curArray.dimensionsCount++;
else break;
}
}
buffer = new StringBuffer();
continue;
}
// quoted element
else if (chars[i] == '"')
{
insideString = !insideString;
wasInsideString = true;
continue;
}
// white space
else if (!insideString && Character.isWhitespace(chars[i]))
{
continue;
}
// array end or element end
else if ((!insideString && (chars[i] == delim || chars[i] == '}')) || i == chars.length - 1)
{
// when character that is a part of array element
if (chars[i] != '"' && chars[i] != '}' && chars[i] != delim && buffer != null)
{
buffer.append(chars[i]);
}
String b = buffer == null ? null : buffer.toString();
// add element to current array
if (b != null && (b.length() > 0 || wasInsideString))
{
curArray.add(!wasInsideString && haveMinServer82 && b.equals("NULL") ? null : b);
}
wasInsideString = false;
buffer = new StringBuffer();
// when end of an array
if (chars[i] == '}')
{
dims.remove(dims.size() - 1);
// when multi-dimension
if (dims.size() > 0)
{
curArray = (PgArrayList) dims.get(dims.size() - 1);
}
buffer = null;
}
continue;
}
if (buffer != null)
buffer.append(chars[i]);
}
}
}
/**
* Convert {@link ArrayList} to array.
*
* @param input list to be converted into array
*/
private Object buildArray (PgArrayList input, int index, int count) throws SQLException
{
if (count < 0)
count = input.size();
// array to be returned
Object ret = null;
// how many dimensions
int dims = input.dimensionsCount;
// dimensions length array (to be used with java.lang.reflect.Array.newInstance(Class, int[]))
int[] dimsLength = dims > 1 ? new int[dims] : null;
if (dims > 1) {
for (int i = 0; i < dims; i++) {
dimsLength[i] = (i == 0 ? count : 0);
}
}
// array elements counter
int length = 0;
// array elements type
final int type = connection.getTypeInfo().getSQLType(connection.getTypeInfo().getPGArrayElement(oid));
if (type == Types.BIT)
{
boolean[] pa = null; // primitive array
Object[] oa = null; // objects array
if (dims > 1 || useObjects)
{
ret = oa = (dims > 1 ? (Object[]) java.lang.reflect.Array.newInstance(useObjects ? Boolean.class : boolean.class, dimsLength) : new Boolean[count]);
}
else
{
ret = pa = new boolean[count];
}
// add elements
for (; count > 0; count--)
{
Object o = input.get(index++);
if (dims > 1 || useObjects)
{
oa[length++] = o == null ? null : (dims > 1 ? buildArray((PgArrayList) o, 0, -1) : new Boolean(AbstractJdbc2ResultSet.toBoolean((String) o)));
}
else
{
pa[length++] = o == null ? false : AbstractJdbc2ResultSet.toBoolean((String) o);
}
}
}
else if (type == Types.SMALLINT || type == Types.INTEGER)
{
int[] pa = null;
Object[] oa = null;
if (dims > 1 || useObjects)
{
ret = oa = (dims > 1 ? (Object[]) java.lang.reflect.Array.newInstance(useObjects ? Integer.class : int.class, dimsLength) : new Integer[count]);
}
else
{
ret = pa = new int[count];
}
for (; count > 0; count--)
{
Object o = input.get(index++);
if (dims > 1 || useObjects)
{
oa[length++] = o == null ? null : (dims > 1 ? buildArray((PgArrayList) o, 0, -1) : new Integer(AbstractJdbc2ResultSet.toInt((String) o)));
}
else
{
pa[length++] = o == null ? 0 : AbstractJdbc2ResultSet.toInt((String) o);
}
}
}
else if (type == Types.BIGINT)
{
long[] pa = null;
Object[] oa = null;
if (dims > 1 || useObjects)
{
ret = oa = (dims > 1 ? (Object[]) java.lang.reflect.Array.newInstance(useObjects ? Long.class : long.class, dimsLength) : new Long[count]);
}
else
{
ret = pa = new long[count];
}
for (; count > 0; count--)
{
Object o = input.get(index++);
if (dims > 1 || useObjects)
{
oa[length++] = o == null ? null : (dims > 1 ? buildArray((PgArrayList) o, 0, -1) : new Long(AbstractJdbc2ResultSet.toLong((String) o)));
}
else
{
pa[length++] = o == null ? 0l : AbstractJdbc2ResultSet.toLong((String) o);
}
}
}
else if (type == Types.NUMERIC)
{
Object[] oa = null;
ret = oa = (dims > 1 ? (Object[]) java.lang.reflect.Array.newInstance(BigDecimal.class, dimsLength) : new BigDecimal[count]);
for (; count > 0; count--)
{
Object v = input.get(index++);
oa[length++] = dims > 1 && v != null ? buildArray((PgArrayList) v, 0, -1) : (v == null ? null : AbstractJdbc2ResultSet.toBigDecimal((String) v, -1));
}
}
else if (type == Types.REAL)
{
float[] pa = null;
Object[] oa = null;
if (dims > 1 || useObjects)
{
ret = oa = (dims > 1 ? (Object[]) java.lang.reflect.Array.newInstance(useObjects ? Float.class : float.class, dimsLength) : new Float[count]);
}
else
{
ret = pa = new float[count];
}
for (; count > 0; count--)
{
Object o = input.get(index++);
if (dims > 1 || useObjects)
{
oa[length++] = o == null ? null : (dims > 1 ? buildArray((PgArrayList) o, 0, -1) : new Float(AbstractJdbc2ResultSet.toFloat((String) o)));
}
else
{
pa[length++] = o == null ? 0f : AbstractJdbc2ResultSet.toFloat((String) o);
}
}
}
else if (type == Types.DOUBLE)
{
double[] pa = null;
Object[] oa = null;
if (dims > 1 || useObjects)
{
ret = oa = (dims > 1 ? (Object[]) java.lang.reflect.Array.newInstance(useObjects ? Double.class : double.class, dimsLength) : new Double[count]);
}
else
{
ret = pa = new double[count];
}
for (; count > 0; count--)
{
Object o = input.get(index++);
if (dims > 1 || useObjects)
{
oa[length++] = o == null ? null : (dims > 1 ? buildArray((PgArrayList) o, 0, -1) : new Double(AbstractJdbc2ResultSet.toDouble((String) o)));
}
else
{
pa[length++] = o == null ? 0d : AbstractJdbc2ResultSet.toDouble((String) o);
}
}
}
else if (type == Types.CHAR || type == Types.VARCHAR)
{
Object[] oa = null;
ret = oa = (dims > 1 ? (Object[]) java.lang.reflect.Array.newInstance(String.class, dimsLength) : new String[count]);
for (; count > 0; count--)
{
Object v = input.get(index++);
oa[length++] = dims > 1 && v != null ? buildArray((PgArrayList) v, 0, -1) : v;
}
}
else if (type == Types.DATE)
{
Object[] oa = null;
ret = oa = (dims > 1 ? (Object[]) java.lang.reflect.Array.newInstance(java.sql.Date.class, dimsLength) : new java.sql.Date[count]);
for (; count > 0; count--)
{
Object v = input.get(index++);
oa[length++] = dims > 1 && v != null ? buildArray((PgArrayList) v, 0, -1) : (v == null ? null : connection.getTimestampUtils().toDate(null, (String) v));
}
}
else if (type == Types.TIME)
{
Object[] oa = null;
ret = oa = (dims > 1 ? (Object[]) java.lang.reflect.Array.newInstance(java.sql.Time.class, dimsLength) : new java.sql.Time[count]);
for (; count > 0; count--)
{
Object v = input.get(index++);
oa[length++] = dims > 1 && v != null ? buildArray((PgArrayList) v, 0, -1) : (v == null ? null : connection.getTimestampUtils().toTime(null, (String) v));
}
}
else if (type == Types.TIMESTAMP)
{
Object[] oa = null;
ret = oa = (dims > 1 ? (Object[]) java.lang.reflect.Array.newInstance(java.sql.Timestamp.class, dimsLength) : new java.sql.Timestamp[count]);
for (; count > 0; count--)
{
Object v = input.get(index++);
oa[length++] = dims > 1 && v != null ? buildArray((PgArrayList) v, 0, -1) : (v == null ? null : connection.getTimestampUtils().toTimestamp(null, (String) v));
}
}
// other datatypes not currently supported
else
{
if (connection.getLogger().logDebug())
connection.getLogger().debug("getArrayImpl(long,int,Map) with " + getBaseTypeName());
throw org.postgresql.Driver.notImplemented(this.getClass(), "getArrayImpl(long,int,Map)");
}
return ret;
}
public int getBaseType() throws SQLException
{
return connection.getTypeInfo().getSQLType(getBaseTypeName());
}
public String getBaseTypeName() throws SQLException
{
buildArrayList();
int elementOID = connection.getTypeInfo().getPGArrayElement(oid);
return connection.getTypeInfo().getPGType(elementOID);
}
public java.sql.ResultSet getResultSet() throws SQLException
{
return getResultSetImpl(1, 0, null);
}
public java.sql.ResultSet getResultSet(long index, int count) throws SQLException
{
return getResultSetImpl(index, count, null);
}
public java.sql.ResultSet getResultSetImpl(Map map) throws SQLException
{
return getResultSetImpl(1, 0, map);
}
public ResultSet getResultSetImpl(long index, int count, Map map) throws SQLException
{
// for now maps aren't supported.
if (map != null && !map.isEmpty())
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getResultSetImpl(long,int,Map)");
}
// array index is out of range
if (index < 1)
{
throw new PSQLException(GT.tr("The array index is out of range: {0}", new Long(index)), PSQLState.DATA_ERROR);
}
if (fieldBytes != null) {
return readBinaryResultSet((int) index, count);
}
buildArrayList();
if (count == 0)
{
count = arrayList.size();
}
// array index out of range
if ((--index) + count > arrayList.size())
{
throw new PSQLException(GT.tr("The array index is out of range: {0}, number of elements: {1}.", new Object[] { new Long(index + count), new Long(arrayList.size()) }), PSQLState.DATA_ERROR);
}
List rows = new ArrayList();
Field[] fields = new Field[2];
// one dimensional array
if (arrayList.dimensionsCount <= 1)
{
// array element type
final int baseOid = connection.getTypeInfo().getPGArrayElement(oid);
fields[0] = new Field("INDEX", Oid.INT4);
fields[1] = new Field("VALUE", baseOid);
for (int i = 0; i < count; i++)
{
int offset = (int)index + i;
byte[][] t = new byte[2][0];
String v = (String) arrayList.get(offset);
t[0] = connection.encodeString(Integer.toString(offset + 1));
t[1] = v == null ? null : connection.encodeString(v);
rows.add(t);
}
}
// when multi-dimensional
else
{
fields[0] = new Field("INDEX", Oid.INT4);
fields[1] = new Field("VALUE", oid);
for (int i = 0; i < count; i++)
{
int offset = (int)index + i;
byte[][] t = new byte[2][0];
Object v = arrayList.get(offset);
t[0] = connection.encodeString(Integer.toString(offset + 1));
t[1] = v == null ? null : connection.encodeString(toString((PgArrayList) v));
rows.add(t);
}
}
BaseStatement stat = (BaseStatement) connection.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
return (ResultSet) stat.createDriverResultSet(fields, rows);
}
public String toString()
{
return fieldString;
}
/**
* Convert array list to PG String representation (e.g. {0,1,2}).
*/
private String toString(PgArrayList list) throws SQLException
{
StringBuffer b = new StringBuffer().append('{');
char delim = connection.getTypeInfo().getArrayDelimiter(oid);
for (int i = 0; i < list.size(); i++)
{
Object v = list.get(i);
if (i > 0)
b.append(delim);
if (v == null)
b.append("NULL");
else if (v instanceof PgArrayList)
b.append(toString((PgArrayList) v));
else
escapeArrayElement(b, (String)v);
}
b.append('}');
return b.toString();
}
public static void escapeArrayElement(StringBuffer b, String s)
{
b.append('"');
for (int j = 0; j < s.length(); j++) {
char c = s.charAt(j);
if (c == '"' || c == '\\') {
b.append('\\');
}
b.append(c);
}
b.append('"');
}
public boolean isBinary() {
return fieldBytes != null;
}
public byte[] toBytes() {
return fieldBytes;
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc2/AbstractJdbc2Blob.java 0000664 0000000 0000000 00000001013 12050675701 0025663 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc2;
import java.sql.SQLException;
import org.postgresql.core.BaseConnection;
public abstract class AbstractJdbc2Blob extends AbstractJdbc2BlobClob
{
public AbstractJdbc2Blob(BaseConnection conn, long oid) throws SQLException
{
super(conn, oid);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc2/AbstractJdbc2BlobClob.java 0000664 0000000 0000000 00000015754 12050675701 0026504 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2005-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc2;
import java.io.InputStream;
import java.io.OutputStream;
import java.sql.Blob;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Iterator;
import org.postgresql.core.BaseConnection;
import org.postgresql.largeobject.LargeObject;
import org.postgresql.largeobject.LargeObjectManager;
import org.postgresql.util.GT;
import org.postgresql.util.PSQLState;
import org.postgresql.util.PSQLException;
/**
* This class holds all of the methods common to both Blobs and Clobs.
*
* @author Michael Barker
*
*/
public abstract class AbstractJdbc2BlobClob
{
protected BaseConnection conn;
protected LargeObject lo;
/**
* We create separate LargeObjects for methods that use streams
* so they won't interfere with each other.
*/
private ArrayList subLOs;
public AbstractJdbc2BlobClob(BaseConnection conn, long oid) throws SQLException
{
this.conn = conn;
LargeObjectManager lom = conn.getLargeObjectAPI();
this.lo = lom.open(oid);
subLOs = new ArrayList();
}
public synchronized void free() throws SQLException
{
if (lo != null) {
lo.close();
lo = null;
}
Iterator i = subLOs.iterator();
while (i.hasNext()) {
LargeObject subLO = (LargeObject)i.next();
subLO.close();
}
subLOs = null;
}
/**
* For Blobs this should be in bytes while for Clobs it should be
* in characters. Since we really haven't figured out how to handle
* character sets for Clobs the current implementation uses bytes for
* both Blobs and Clobs.
*/
public synchronized void truncate(long len) throws SQLException
{
checkFreed();
if (!conn.haveMinimumServerVersion("8.3"))
throw new PSQLException(GT.tr("Truncation of large objects is only implemented in 8.3 and later servers."), PSQLState.NOT_IMPLEMENTED);
if (len < 0)
{
throw new PSQLException(GT.tr("Cannot truncate LOB to a negative length."), PSQLState.INVALID_PARAMETER_VALUE);
}
if (len > Integer.MAX_VALUE)
{
throw new PSQLException(GT.tr("PostgreSQL LOBs can only index to: {0}", new Integer(Integer.MAX_VALUE)), PSQLState.INVALID_PARAMETER_VALUE);
}
lo.truncate((int)len);
}
public synchronized long length() throws SQLException
{
checkFreed();
return lo.size();
}
public synchronized byte[] getBytes(long pos, int length) throws SQLException
{
assertPosition(pos);
lo.seek((int)(pos-1), LargeObject.SEEK_SET);
return lo.read(length);
}
public synchronized InputStream getBinaryStream() throws SQLException
{
checkFreed();
LargeObject subLO = lo.copy();
subLOs.add(subLO);
subLO.seek(0, LargeObject.SEEK_SET);
return subLO.getInputStream();
}
public synchronized OutputStream setBinaryStream(long pos) throws SQLException
{
assertPosition(pos);
LargeObject subLO = lo.copy();
subLOs.add(subLO);
subLO.seek((int)(pos-1));
return subLO.getOutputStream();
}
/**
* Iterate over the buffer looking for the specified pattern
*
* @param pattern A pattern of bytes to search the blob for.
* @param start The position to start reading from.
*/
public synchronized long position(byte[] pattern, long start) throws SQLException
{
assertPosition(start, pattern.length);
int position = 1;
int patternIdx = 0;
long result = -1;
int tmpPosition = 1;
for (LOIterator i = new LOIterator(start-1); i.hasNext(); position++)
{
byte b = i.next();
if (b == pattern[patternIdx])
{
if (patternIdx == 0)
{
tmpPosition = position;
}
patternIdx++;
if (patternIdx == pattern.length)
{
result = tmpPosition;
break;
}
}
else
{
patternIdx = 0;
}
}
return result;
}
/**
* Iterates over a large object returning byte values. Will buffer
* the data from the large object.
*
*
*/
private class LOIterator
{
private static final int BUFFER_SIZE = 8096;
private byte buffer[] = new byte[BUFFER_SIZE];
private int idx = BUFFER_SIZE;
private int numBytes = BUFFER_SIZE;
public LOIterator(long start) throws SQLException
{
lo.seek((int) start);
}
public boolean hasNext() throws SQLException
{
boolean result = false;
if (idx < numBytes)
{
result = true;
}
else
{
numBytes = lo.read(buffer, 0, BUFFER_SIZE);
idx = 0;
result = (numBytes > 0);
}
return result;
}
private byte next()
{
return buffer[idx++];
}
}
/**
* This is simply passing the byte value of the pattern Blob
*/
public synchronized long position(Blob pattern, long start) throws SQLException
{
return position(pattern.getBytes(1, (int)pattern.length()), start);
}
/**
* Throws an exception if the pos value exceeds the max value by
* which the large object API can index.
*
* @param pos Position to write at.
*/
protected void assertPosition(long pos) throws SQLException
{
assertPosition(pos, 0);
}
/**
* Throws an exception if the pos value exceeds the max value by
* which the large object API can index.
*
* @param pos Position to write at.
* @param len number of bytes to write.
*/
protected void assertPosition(long pos, long len) throws SQLException
{
checkFreed();
if (pos < 1)
{
throw new PSQLException(GT.tr("LOB positioning offsets start at 1."), PSQLState.INVALID_PARAMETER_VALUE);
}
if (pos + len - 1 > Integer.MAX_VALUE)
{
throw new PSQLException(GT.tr("PostgreSQL LOBs can only index to: {0}", new Integer(Integer.MAX_VALUE)), PSQLState.INVALID_PARAMETER_VALUE);
}
}
/**
* Checks that this LOB hasn't been free()d already.
* @throws SQLException if LOB has been freed.
*/
protected void checkFreed() throws SQLException
{
if (lo == null)
throw new PSQLException(GT.tr("free() was called on this LOB previously"), PSQLState.OBJECT_NOT_IN_STATE);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc2/AbstractJdbc2Clob.java 0000664 0000000 0000000 00000003164 12050675701 0025675 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc2;
import org.postgresql.core.BaseConnection;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.sql.Clob;
import java.sql.SQLException;
public abstract class AbstractJdbc2Clob extends AbstractJdbc2BlobClob
{
public AbstractJdbc2Clob(BaseConnection conn, long oid) throws SQLException
{
super(conn, oid);
}
public synchronized InputStream getAsciiStream() throws SQLException
{
return getBinaryStream();
}
public synchronized Reader getCharacterStream() throws SQLException
{
return new InputStreamReader(getBinaryStream());
}
public synchronized String getSubString(long i, int j) throws SQLException
{
assertPosition(i, j);
lo.seek((int)i - 1);
return new String(lo.read(j));
}
/*
* For now, this is not implemented.
*/
public synchronized long position(String pattern, long start) throws SQLException
{
checkFreed();
throw org.postgresql.Driver.notImplemented(this.getClass(), "position(String,long)");
}
/*
* This should be simply passing the byte value of the pattern Blob
*/
public synchronized long position(Clob pattern, long start) throws SQLException
{
checkFreed();
throw org.postgresql.Driver.notImplemented(this.getClass(), "position(Clob,start)");
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc2/AbstractJdbc2Connection.java 0000664 0000000 0000000 00000122007 12050675701 0027113 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc2;
import java.io.IOException;
import java.io.PrintWriter;
import java.sql.*;
import java.util.*;
import org.postgresql.core.*;
import org.postgresql.Driver;
import org.postgresql.PGNotification;
import org.postgresql.fastpath.Fastpath;
import org.postgresql.largeobject.LargeObjectManager;
import org.postgresql.util.*;
import org.postgresql.util.HostSpec;
import org.postgresql.copy.*;
/**
* This class defines methods of the jdbc2 specification.
* The real Connection class (for jdbc2) is org.postgresql.jdbc2.Jdbc2Connection
*/
public abstract class AbstractJdbc2Connection implements BaseConnection
{
//
// Driver-wide connection ID counter, used for logging
//
private static int nextConnectionID = 1;
//
// Data initialized on construction:
//
// Per-connection logger
private final Logger logger;
/* URL we were created via */
private final String creatingURL;
private Throwable openStackTrace;
/* Actual network handler */
private final ProtocolConnection protoConnection;
/* Compatibility version */
private final String compatible;
/* Actual server version */
private final String dbVersionNumber;
/* Query that runs COMMIT */
private final Query commitQuery;
/* Query that runs ROLLBACK */
private final Query rollbackQuery;
private TypeInfo _typeCache;
// Default statement prepare threshold.
protected int prepareThreshold;
// Connection's autocommit state.
public boolean autoCommit = true;
// Connection's readonly state.
public boolean readOnly = false;
// Bind String to UNSPECIFIED or VARCHAR?
public final boolean bindStringAsVarchar;
// Current warnings; there might be more on protoConnection too.
public SQLWarning firstWarning = null;
/** Set of oids that use binary transfer when sending to server. */
private Set useBinarySendForOids;
/** Set of oids that use binary transfer when receiving from server. */
private Set useBinaryReceiveForOids;
public abstract DatabaseMetaData getMetaData() throws SQLException;
//
// Ctor.
//
protected AbstractJdbc2Connection(HostSpec[] hostSpecs, String user, String database, Properties info, String url) throws SQLException
{
this.creatingURL = url;
// Read loglevel arg and set the loglevel based on this value;
// In addition to setting the log level, enable output to
// standard out if no other printwriter is set
int logLevel = Driver.getLogLevel();
String connectionLogLevel = info.getProperty("loglevel");
if (connectionLogLevel != null) {
try {
logLevel = Integer.parseInt(connectionLogLevel);
} catch (Exception l_e) {
// XXX revisit
// invalid value for loglevel; ignore it
}
}
synchronized (AbstractJdbc2Connection.class) {
logger = new Logger(nextConnectionID++);
logger.setLogLevel(logLevel);
}
if (logLevel > 0)
enableDriverManagerLogging();
prepareThreshold = 5;
try
{
prepareThreshold = Integer.parseInt(info.getProperty("prepareThreshold", "5"));
if (prepareThreshold < 0)
prepareThreshold = 0;
}
catch (Exception e)
{
}
boolean binaryTransfer = true;
try
{
binaryTransfer = Boolean.valueOf(info.getProperty("binaryTransfer", "true")).booleanValue();
}
catch (Exception e)
{
}
//Print out the driver version number
if (logger.logInfo())
logger.info(Driver.getVersion());
// Now make the initial connection and set up local state
this.protoConnection = ConnectionFactory.openConnection(hostSpecs, user, database, info, logger);
this.dbVersionNumber = protoConnection.getServerVersion();
this.compatible = info.getProperty("compatible", Driver.MAJORVERSION + "." + Driver.MINORVERSION);
// Formats that currently have binary protocol support
Set binaryOids = new HashSet();
if (binaryTransfer && protoConnection.getProtocolVersion() >= 3) {
binaryOids.add(Oid.BYTEA);
binaryOids.add(Oid.INT2);
binaryOids.add(Oid.INT4);
binaryOids.add(Oid.INT8);
binaryOids.add(Oid.FLOAT4);
binaryOids.add(Oid.FLOAT8);
binaryOids.add(Oid.TIME);
binaryOids.add(Oid.DATE);
binaryOids.add(Oid.TIMETZ);
binaryOids.add(Oid.TIMESTAMP);
binaryOids.add(Oid.TIMESTAMPTZ);
binaryOids.add(Oid.INT2_ARRAY);
binaryOids.add(Oid.INT4_ARRAY);
binaryOids.add(Oid.INT8_ARRAY);
binaryOids.add(Oid.FLOAT4_ARRAY);
binaryOids.add(Oid.FLOAT8_ARRAY);
binaryOids.add(Oid.FLOAT8_ARRAY);
binaryOids.add(Oid.VARCHAR_ARRAY);
binaryOids.add(Oid.TEXT_ARRAY);
binaryOids.add(Oid.POINT);
binaryOids.add(Oid.BOX);
binaryOids.add(Oid.UUID);
}
// the pre 8.0 servers do not disclose their internal encoding for
// time fields so do not try to use them.
if (!haveMinimumCompatibleVersion("8.0")) {
binaryOids.remove(Oid.TIME);
binaryOids.remove(Oid.TIMETZ);
binaryOids.remove(Oid.TIMESTAMP);
binaryOids.remove(Oid.TIMESTAMPTZ);
}
// driver supports only null-compatible arrays
if (!haveMinimumCompatibleVersion("8.3")) {
binaryOids.remove(Oid.INT2_ARRAY);
binaryOids.remove(Oid.INT4_ARRAY);
binaryOids.remove(Oid.INT8_ARRAY);
binaryOids.remove(Oid.FLOAT4_ARRAY);
binaryOids.remove(Oid.FLOAT8_ARRAY);
binaryOids.remove(Oid.FLOAT8_ARRAY);
binaryOids.remove(Oid.VARCHAR_ARRAY);
binaryOids.remove(Oid.TEXT_ARRAY);
}
binaryOids.addAll(getOidSet(info.getProperty("binaryTransferEnable", "")));
binaryOids.removeAll(getOidSet(info.getProperty("binaryTransferDisable", "")));
// split for receive and send for better control
useBinarySendForOids = new HashSet();
useBinarySendForOids.addAll(binaryOids);
useBinaryReceiveForOids = new HashSet();
useBinaryReceiveForOids.addAll(binaryOids);
/*
* Does not pass unit tests because unit tests expect setDate to have
* millisecond accuracy whereas the binary transfer only supports
* date accuracy.
*/
useBinarySendForOids.remove(Oid.DATE);
protoConnection.setBinaryReceiveOids(useBinaryReceiveForOids);
if (logger.logDebug())
{
logger.debug(" compatible = " + compatible);
logger.debug(" loglevel = " + logLevel);
logger.debug(" prepare threshold = " + prepareThreshold);
logger.debug(" types using binary send = " + oidsToString(useBinarySendForOids));
logger.debug(" types using binary receive = " + oidsToString(useBinaryReceiveForOids));
logger.debug(" integer date/time = " + protoConnection.getIntegerDateTimes());
}
//
// String -> text or unknown?
//
String stringType = info.getProperty("stringtype");
if (stringType != null) {
if (stringType.equalsIgnoreCase("unspecified"))
bindStringAsVarchar = false;
else if (stringType.equalsIgnoreCase("varchar"))
bindStringAsVarchar = true;
else
throw new PSQLException(GT.tr("Unsupported value for stringtype parameter: {0}", stringType),
PSQLState.INVALID_PARAMETER_VALUE);
} else {
bindStringAsVarchar = haveMinimumCompatibleVersion("8.0");
}
// Initialize timestamp stuff
timestampUtils = new TimestampUtils(haveMinimumServerVersion("7.4"), haveMinimumServerVersion("8.2"),
!protoConnection.getIntegerDateTimes());
// Initialize common queries.
commitQuery = getQueryExecutor().createSimpleQuery("COMMIT");
rollbackQuery = getQueryExecutor().createSimpleQuery("ROLLBACK");
int unknownLength = Integer.MAX_VALUE;
String strLength = info.getProperty("unknownLength");
if (strLength != null) {
try {
unknownLength = Integer.parseInt(strLength);
} catch (NumberFormatException nfe) {
throw new PSQLException(GT.tr("unknownLength parameter value must be an integer"), PSQLState.INVALID_PARAMETER_VALUE, nfe);
}
}
// Initialize object handling
_typeCache = createTypeInfo(this, unknownLength);
initObjectTypes(info);
if (Boolean.valueOf(info.getProperty("logUnclosedConnections")).booleanValue()) {
openStackTrace = new Throwable("Connection was created at this point:");
enableDriverManagerLogging();
}
}
private Set getOidSet(String oidList) throws PSQLException {
Set oids = new HashSet();
StringTokenizer tokenizer = new StringTokenizer(oidList, ",");
while (tokenizer.hasMoreTokens()) {
String oid = tokenizer.nextToken();
oids.add(Oid.valueOf(oid));
}
return oids;
}
private String oidsToString(Set oids) {
StringBuffer sb = new StringBuffer();
for (Integer oid : oids) {
sb.append(Oid.toString(oid));
sb.append(',');
}
if (sb.length() > 0) {
sb.setLength(sb.length() - 1);
} else {
sb.append(" ");
}
return sb.toString();
}
private final TimestampUtils timestampUtils;
public TimestampUtils getTimestampUtils() { return timestampUtils; }
/*
* The current type mappings
*/
protected java.util.Map typemap;
public java.sql.Statement createStatement() throws SQLException
{
// We now follow the spec and default to TYPE_FORWARD_ONLY.
return createStatement(java.sql.ResultSet.TYPE_FORWARD_ONLY, java.sql.ResultSet.CONCUR_READ_ONLY);
}
public abstract java.sql.Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException;
public java.sql.PreparedStatement prepareStatement(String sql) throws SQLException
{
return prepareStatement(sql, java.sql.ResultSet.TYPE_FORWARD_ONLY, java.sql.ResultSet.CONCUR_READ_ONLY);
}
public abstract java.sql.PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency) throws SQLException;
public java.sql.CallableStatement prepareCall(String sql) throws SQLException
{
return prepareCall(sql, java.sql.ResultSet.TYPE_FORWARD_ONLY, java.sql.ResultSet.CONCUR_READ_ONLY);
}
public abstract java.sql.CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException;
public java.util.Map getTypeMap() throws SQLException
{
checkClosed();
return typemap;
}
// Query executor associated with this connection.
public QueryExecutor getQueryExecutor() {
return protoConnection.getQueryExecutor();
}
/*
* This adds a warning to the warning chain.
* @param warn warning to add
*/
public void addWarning(SQLWarning warn)
{
// Add the warning to the chain
if (firstWarning != null)
firstWarning.setNextWarning(warn);
else
firstWarning = warn;
}
public ResultSet execSQLQuery(String s) throws SQLException {
return execSQLQuery(s, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
}
/**
* Simple query execution.
*/
public ResultSet execSQLQuery(String s, int resultSetType, int resultSetConcurrency) throws SQLException {
BaseStatement stat = (BaseStatement) createStatement(resultSetType, resultSetConcurrency);
boolean hasResultSet = stat.executeWithFlags(s, QueryExecutor.QUERY_SUPPRESS_BEGIN);
while (!hasResultSet && stat.getUpdateCount() != -1)
hasResultSet = stat.getMoreResults();
if (!hasResultSet)
throw new PSQLException(GT.tr("No results were returned by the query."), PSQLState.NO_DATA);
// Transfer warnings to the connection, since the user never
// has a chance to see the statement itself.
SQLWarning warnings = stat.getWarnings();
if (warnings != null)
addWarning(warnings);
return stat.getResultSet();
}
public void execSQLUpdate(String s) throws SQLException {
BaseStatement stmt = (BaseStatement) createStatement();
if (stmt.executeWithFlags(s, QueryExecutor.QUERY_NO_METADATA | QueryExecutor.QUERY_NO_RESULTS | QueryExecutor.QUERY_SUPPRESS_BEGIN))
throw new PSQLException(GT.tr("A result was returned when none was expected."),
PSQLState.TOO_MANY_RESULTS);
// Transfer warnings to the connection, since the user never
// has a chance to see the statement itself.
SQLWarning warnings = stmt.getWarnings();
if (warnings != null)
addWarning(warnings);
stmt.close();
}
/*
* In SQL, a result table can be retrieved through a cursor that
* is named. The current row of a result can be updated or deleted
* using a positioned update/delete statement that references the
* cursor name.
*
* We do not support positioned update/delete, so this is a no-op.
*
* @param cursor the cursor name
* @exception SQLException if a database access error occurs
*/
public void setCursorName(String cursor) throws SQLException
{
checkClosed();
// No-op.
}
/*
* getCursorName gets the cursor name.
*
* @return the current cursor name
* @exception SQLException if a database access error occurs
*/
public String getCursorName() throws SQLException
{
checkClosed();
return null;
}
/*
* We are required to bring back certain information by
* the DatabaseMetaData class. These functions do that.
*
* Method getURL() brings back the URL (good job we saved it)
*
* @return the url
* @exception SQLException just in case...
*/
public String getURL() throws SQLException
{
return creatingURL;
}
/*
* Method getUserName() brings back the User Name (again, we
* saved it)
*
* @return the user name
* @exception SQLException just in case...
*/
public String getUserName() throws SQLException
{
return protoConnection.getUser();
}
/*
* This returns the Fastpath API for the current connection.
*
*
NOTE: This is not part of JDBC, but allows access to
* functions on the org.postgresql backend itself.
*
*
where myconn is an open Connection to org.postgresql.
*
* @return Fastpath object allowing access to functions on the org.postgresql
* backend.
* @exception SQLException by Fastpath when initialising for first time
*/
public Fastpath getFastpathAPI() throws SQLException
{
checkClosed();
if (fastpath == null)
fastpath = new Fastpath(this);
return fastpath;
}
// This holds a reference to the Fastpath API if already open
private Fastpath fastpath = null;
/*
* This returns the LargeObject API for the current connection.
*
*
NOTE: This is not part of JDBC, but allows access to
* functions on the org.postgresql backend itself.
*
*
where myconn is an open Connection to org.postgresql.
*
* @return LargeObject object that implements the API
* @exception SQLException by LargeObject when initialising for first time
*/
public LargeObjectManager getLargeObjectAPI() throws SQLException
{
checkClosed();
if (largeobject == null)
largeobject = new LargeObjectManager(this);
return largeobject;
}
// This holds a reference to the LargeObject API if already open
private LargeObjectManager largeobject = null;
/*
* This method is used internally to return an object based around
* org.postgresql's more unique data types.
*
*
It uses an internal HashMap to get the handling class. If the
* type is not supported, then an instance of org.postgresql.util.PGobject
* is returned.
*
* You can use the getValue() or setValue() methods to handle the returned
* object. Custom objects can have their own methods.
*
* @return PGobject for this type, and set to value
* @exception SQLException if value is not correct for this type
*/
public Object getObject(String type, String value, byte[] byteValue) throws SQLException
{
if (typemap != null)
{
Class c = (Class) typemap.get(type);
if (c != null)
{
// Handle the type (requires SQLInput & SQLOutput classes to be implemented)
throw new PSQLException(GT.tr("Custom type maps are not supported."), PSQLState.NOT_IMPLEMENTED);
}
}
PGobject obj = null;
if (logger.logDebug())
logger.debug("Constructing object from type=" + type + " value=<" + value + ">");
try
{
Class klass = _typeCache.getPGobject(type);
// If className is not null, then try to instantiate it,
// It must be basetype PGobject
// This is used to implement the org.postgresql unique types (like lseg,
// point, etc).
if (klass != null)
{
obj = (PGobject) (klass.newInstance());
obj.setType(type);
if (byteValue != null && obj instanceof PGBinaryObject) {
PGBinaryObject binObj = (PGBinaryObject) obj;
binObj.setByteValue(byteValue, 0);
} else {
obj.setValue(value);
}
}
else
{
// If className is null, then the type is unknown.
// so return a PGobject with the type set, and the value set
obj = new PGobject();
obj.setType( type );
obj.setValue( value );
}
return obj;
}
catch (SQLException sx)
{
// rethrow the exception. Done because we capture any others next
throw sx;
}
catch (Exception ex)
{
throw new PSQLException(GT.tr("Failed to create object for: {0}.", type), PSQLState.CONNECTION_FAILURE, ex);
}
}
protected TypeInfo createTypeInfo(BaseConnection conn, int unknownLength)
{
return new TypeInfoCache(conn, unknownLength);
}
public TypeInfo getTypeInfo()
{
return _typeCache;
}
public void addDataType(String type, String name)
{
try
{
addDataType(type, Class.forName(name));
}
catch (Exception e)
{
throw new RuntimeException("Cannot register new type: " + e);
}
}
public void addDataType(String type, Class klass) throws SQLException
{
checkClosed();
_typeCache.addDataType(type, klass);
}
// This initialises the objectTypes hash map
private void initObjectTypes(Properties info) throws SQLException
{
// Add in the types that come packaged with the driver.
// These can be overridden later if desired.
addDataType("box", org.postgresql.geometric.PGbox.class);
addDataType("circle", org.postgresql.geometric.PGcircle.class);
addDataType("line", org.postgresql.geometric.PGline.class);
addDataType("lseg", org.postgresql.geometric.PGlseg.class);
addDataType("path", org.postgresql.geometric.PGpath.class);
addDataType("point", org.postgresql.geometric.PGpoint.class);
addDataType("polygon", org.postgresql.geometric.PGpolygon.class);
addDataType("money", org.postgresql.util.PGmoney.class);
addDataType("interval", org.postgresql.util.PGInterval.class);
for (Enumeration e = info.propertyNames(); e.hasMoreElements(); )
{
String propertyName = (String)e.nextElement();
if (propertyName.startsWith("datatype."))
{
String typeName = propertyName.substring(9);
String className = info.getProperty(propertyName);
Class klass;
try
{
klass = Class.forName(className);
}
catch (ClassNotFoundException cnfe)
{
throw new PSQLException(GT.tr("Unable to load the class {0} responsible for the datatype {1}", new Object[] { className, typeName }),
PSQLState.SYSTEM_ERROR, cnfe);
}
addDataType(typeName, klass);
}
}
}
/**
* In some cases, it is desirable to immediately release a Connection's
* database and JDBC resources instead of waiting for them to be
* automatically released.
*
* Note: A Connection is automatically closed when it is
* garbage collected. Certain fatal errors also result in a closed
* connection.
*
* @exception SQLException if a database access error occurs
*/
public void close()
{
protoConnection.close();
openStackTrace = null;
}
/*
* A driver may convert the JDBC sql grammar into its system's
* native SQL grammar prior to sending it; nativeSQL returns the
* native form of the statement that the driver would have sent.
*
* @param sql a SQL statement that may contain one or more '?'
* parameter placeholders
* @return the native form of this statement
* @exception SQLException if a database access error occurs
*/
public String nativeSQL(String sql) throws SQLException
{
checkClosed();
StringBuffer buf = new StringBuffer(sql.length());
AbstractJdbc2Statement.parseSql(sql,0,buf,false,getStandardConformingStrings());
return buf.toString();
}
/*
* The first warning reported by calls on this Connection is
* returned.
*
* Note: Sebsequent warnings will be changed to this
* SQLWarning
*
* @return the first SQLWarning or null
* @exception SQLException if a database access error occurs
*/
public synchronized SQLWarning getWarnings()
throws SQLException
{
checkClosed();
SQLWarning newWarnings = protoConnection.getWarnings(); // NB: also clears them.
if (firstWarning == null)
firstWarning = newWarnings;
else
firstWarning.setNextWarning(newWarnings); // Chain them on.
return firstWarning;
}
/*
* After this call, getWarnings returns null until a new warning
* is reported for this connection.
*
* @exception SQLException if a database access error occurs
*/
public synchronized void clearWarnings()
throws SQLException
{
checkClosed();
protoConnection.getWarnings(); // Clear and discard.
firstWarning = null;
}
/*
* You can put a connection in read-only mode as a hunt to enable
* database optimizations
*
* Note: setReadOnly cannot be called while in the middle
* of a transaction
*
* @param readOnly - true enables read-only mode; false disables it
* @exception SQLException if a database access error occurs
*/
public void setReadOnly(boolean readOnly) throws SQLException
{
checkClosed();
if (protoConnection.getTransactionState() != ProtocolConnection.TRANSACTION_IDLE)
throw new PSQLException(GT.tr("Cannot change transaction read-only property in the middle of a transaction."),
PSQLState.ACTIVE_SQL_TRANSACTION);
if (haveMinimumServerVersion("7.4") && readOnly != this.readOnly)
{
String readOnlySql = "SET SESSION CHARACTERISTICS AS TRANSACTION " + (readOnly ? "READ ONLY" : "READ WRITE");
execSQLUpdate(readOnlySql); // nb: no BEGIN triggered.
}
this.readOnly = readOnly;
}
/*
* Tests to see if the connection is in Read Only Mode.
*
* @return true if the connection is read only
* @exception SQLException if a database access error occurs
*/
public boolean isReadOnly() throws SQLException
{
checkClosed();
return readOnly;
}
/*
* If a connection is in auto-commit mode, than all its SQL
* statements will be executed and committed as individual
* transactions. Otherwise, its SQL statements are grouped
* into transactions that are terminated by either commit()
* or rollback(). By default, new connections are in auto-
* commit mode. The commit occurs when the statement completes
* or the next execute occurs, whichever comes first. In the
* case of statements returning a ResultSet, the statement
* completes when the last row of the ResultSet has been retrieved
* or the ResultSet has been closed. In advanced cases, a single
* statement may return multiple results as well as output parameter
* values. Here the commit occurs when all results and output param
* values have been retrieved.
*
* @param autoCommit - true enables auto-commit; false disables it
* @exception SQLException if a database access error occurs
*/
public void setAutoCommit(boolean autoCommit) throws SQLException
{
checkClosed();
if (this.autoCommit == autoCommit)
return ;
if (!this.autoCommit)
commit();
this.autoCommit = autoCommit;
}
/*
* gets the current auto-commit state
*
* @return Current state of the auto-commit mode
* @see setAutoCommit
*/
public boolean getAutoCommit() throws SQLException
{
checkClosed();
return this.autoCommit;
}
private void executeTransactionCommand(Query query) throws SQLException {
getQueryExecutor().execute(query, null, new TransactionCommandHandler(),
0, 0, QueryExecutor.QUERY_NO_METADATA | QueryExecutor.QUERY_NO_RESULTS | QueryExecutor.QUERY_SUPPRESS_BEGIN);
}
/*
* The method commit() makes all changes made since the previous
* commit/rollback permanent and releases any database locks currently
* held by the Connection. This method should only be used when
* auto-commit has been disabled.
*
* @exception SQLException if a database access error occurs,
* this method is called on a closed connection or
* this Connection object is in auto-commit mode
* @see setAutoCommit
*/
public void commit() throws SQLException
{
checkClosed();
if (autoCommit)
throw new PSQLException(GT.tr("Cannot commit when autoCommit is enabled."),
PSQLState.NO_ACTIVE_SQL_TRANSACTION);
if (protoConnection.getTransactionState() != ProtocolConnection.TRANSACTION_IDLE)
executeTransactionCommand(commitQuery);
}
protected void checkClosed() throws SQLException {
if (isClosed())
throw new PSQLException(GT.tr("This connection has been closed."),
PSQLState.CONNECTION_DOES_NOT_EXIST);
}
/*
* The method rollback() drops all changes made since the previous
* commit/rollback and releases any database locks currently held by
* the Connection.
*
* @exception SQLException if a database access error occurs,
* this method is called on a closed connection or
* this Connection object is in auto-commit mode
* @see commit
*/
public void rollback() throws SQLException
{
checkClosed();
if (autoCommit)
throw new PSQLException(GT.tr("Cannot rollback when autoCommit is enabled."),
PSQLState.NO_ACTIVE_SQL_TRANSACTION);
if (protoConnection.getTransactionState() != ProtocolConnection.TRANSACTION_IDLE)
executeTransactionCommand(rollbackQuery);
}
public int getTransactionState() {
return protoConnection.getTransactionState();
}
/*
* Get this Connection's current transaction isolation mode.
*
* @return the current TRANSACTION_* mode value
* @exception SQLException if a database access error occurs
*/
public int getTransactionIsolation() throws SQLException
{
checkClosed();
String level = null;
if (haveMinimumServerVersion("7.3"))
{
// 7.3+ returns the level as a query result.
ResultSet rs = execSQLQuery("SHOW TRANSACTION ISOLATION LEVEL"); // nb: no BEGIN triggered
if (rs.next())
level = rs.getString(1);
rs.close();
}
else
{
// 7.2 returns the level as an INFO message. Ew.
// We juggle the warning chains a bit here.
// Swap out current warnings.
SQLWarning saveWarnings = getWarnings();
clearWarnings();
// Run the query any examine any resulting warnings.
execSQLUpdate("SHOW TRANSACTION ISOLATION LEVEL"); // nb: no BEGIN triggered
SQLWarning warning = getWarnings();
if (warning != null)
level = warning.getMessage();
// Swap original warnings back.
clearWarnings();
if (saveWarnings != null)
addWarning(saveWarnings);
}
// XXX revisit: throw exception instead of silently eating the error in unkwon cases?
if (level == null)
return Connection.TRANSACTION_READ_COMMITTED; // Best guess.
level = level.toUpperCase(Locale.US);
if (level.indexOf("READ COMMITTED") != -1)
return Connection.TRANSACTION_READ_COMMITTED;
if (level.indexOf("READ UNCOMMITTED") != -1)
return Connection.TRANSACTION_READ_UNCOMMITTED;
if (level.indexOf("REPEATABLE READ") != -1)
return Connection.TRANSACTION_REPEATABLE_READ;
if (level.indexOf("SERIALIZABLE") != -1)
return Connection.TRANSACTION_SERIALIZABLE;
return Connection.TRANSACTION_READ_COMMITTED; // Best guess.
}
/*
* You can call this method to try to change the transaction
* isolation level using one of the TRANSACTION_* values.
*
* Note: setTransactionIsolation cannot be called while
* in the middle of a transaction
*
* @param level one of the TRANSACTION_* isolation values with
* the exception of TRANSACTION_NONE; some databases may
* not support other values
* @exception SQLException if a database access error occurs
* @see java.sql.DatabaseMetaData#supportsTransactionIsolationLevel
*/
public void setTransactionIsolation(int level) throws SQLException
{
checkClosed();
if (protoConnection.getTransactionState() != ProtocolConnection.TRANSACTION_IDLE)
throw new PSQLException(GT.tr("Cannot change transaction isolation level in the middle of a transaction."),
PSQLState.ACTIVE_SQL_TRANSACTION);
String isolationLevelName = getIsolationLevelName(level);
if (isolationLevelName == null)
throw new PSQLException(GT.tr("Transaction isolation level {0} not supported.", new Integer(level)), PSQLState.NOT_IMPLEMENTED);
String isolationLevelSQL = "SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL " + isolationLevelName;
execSQLUpdate(isolationLevelSQL); // nb: no BEGIN triggered
}
protected String getIsolationLevelName(int level)
{
boolean pg80 = haveMinimumServerVersion("8.0");
if (level == Connection.TRANSACTION_READ_COMMITTED)
{
return "READ COMMITTED";
}
else if (level == Connection.TRANSACTION_SERIALIZABLE)
{
return "SERIALIZABLE";
}
else if (pg80 && level == Connection.TRANSACTION_READ_UNCOMMITTED)
{
return "READ UNCOMMITTED";
}
else if (pg80 && level == Connection.TRANSACTION_REPEATABLE_READ)
{
return "REPEATABLE READ";
}
return null;
}
/*
* A sub-space of this Connection's database may be selected by
* setting a catalog name. If the driver does not support catalogs,
* it will silently ignore this request
*
* @exception SQLException if a database access error occurs
*/
public void setCatalog(String catalog) throws SQLException
{
checkClosed();
//no-op
}
/*
* Return the connections current catalog name, or null if no
* catalog name is set, or we dont support catalogs.
*
* @return the current catalog name or null
* @exception SQLException if a database access error occurs
*/
public String getCatalog() throws SQLException
{
checkClosed();
return protoConnection.getDatabase();
}
/*
* Overides finalize(). If called, it closes the connection.
*
* This was done at the request of Rachel Greenham
* who hit a problem where multiple
* clients didn't close the connection, and once a fortnight enough
* clients were open to kill the postgres server.
*/
protected void finalize() throws Throwable
{
if (openStackTrace != null)
logger.log(GT.tr("Finalizing a Connection that was never closed:"), openStackTrace);
close();
}
/*
* Get server version number
*/
public String getDBVersionNumber()
{
return dbVersionNumber;
}
// Parse a "dirty" integer surrounded by non-numeric characters
private static int integerPart(String dirtyString)
{
int start, end;
for (start = 0; start < dirtyString.length() && !Character.isDigit(dirtyString.charAt(start)); ++start)
;
for (end = start; end < dirtyString.length() && Character.isDigit(dirtyString.charAt(end)); ++end)
;
if (start == end)
return 0;
return Integer.parseInt(dirtyString.substring(start, end));
}
/*
* Get server major version
*/
public int getServerMajorVersion()
{
try
{
StringTokenizer versionTokens = new StringTokenizer(dbVersionNumber, "."); // aaXbb.ccYdd
return integerPart(versionTokens.nextToken()); // return X
}
catch (NoSuchElementException e)
{
return 0;
}
}
/*
* Get server minor version
*/
public int getServerMinorVersion()
{
try
{
StringTokenizer versionTokens = new StringTokenizer(dbVersionNumber, "."); // aaXbb.ccYdd
versionTokens.nextToken(); // Skip aaXbb
return integerPart(versionTokens.nextToken()); // return Y
}
catch (NoSuchElementException e)
{
return 0;
}
}
/**
* Is the server we are connected to running at least this version?
* This comparison method will fail whenever a major or minor version
* goes to two digits (10.3.0) or (7.10.1).
*/
public boolean haveMinimumServerVersion(String ver)
{
return (dbVersionNumber.compareTo(ver) >= 0);
}
/*
* This method returns true if the compatible level set in the connection
* (which can be passed into the connection or specified in the URL)
* is at least the value passed to this method. This is used to toggle
* between different functionality as it changes across different releases
* of the jdbc driver code. The values here are versions of the jdbc client
* and not server versions. For example in 7.1 get/setBytes worked on
* LargeObject values, in 7.2 these methods were changed to work on bytea
* values. This change in functionality could be disabled by setting the
* "compatible" level to be 7.1, in which case the driver will revert to
* the 7.1 functionality.
*/
public boolean haveMinimumCompatibleVersion(String ver)
{
return (compatible.compareTo(ver) >= 0);
}
public Encoding getEncoding() {
return protoConnection.getEncoding();
}
public byte[] encodeString(String str) throws SQLException {
try
{
return getEncoding().encode(str);
}
catch (IOException ioe)
{
throw new PSQLException(GT.tr("Unable to translate data into the desired encoding."), PSQLState.DATA_ERROR, ioe);
}
}
public String escapeString(String str) throws SQLException {
return Utils.appendEscapedLiteral(null, str,
protoConnection.getStandardConformingStrings()).toString();
}
public boolean getStandardConformingStrings() {
return protoConnection.getStandardConformingStrings();
}
// This is a cache of the DatabaseMetaData instance for this connection
protected java.sql.DatabaseMetaData metadata;
/*
* Tests to see if a Connection is closed
*
* @return the status of the connection
* @exception SQLException (why?)
*/
public boolean isClosed() throws SQLException
{
return protoConnection.isClosed();
}
public void cancelQuery() throws SQLException
{
checkClosed();
protoConnection.sendQueryCancel();
}
public PGNotification[] getNotifications() throws SQLException
{
checkClosed();
getQueryExecutor().processNotifies();
// Backwards-compatibility hand-holding.
PGNotification[] notifications = protoConnection.getNotifications();
return (notifications.length == 0 ? null : notifications);
}
//
// Handler for transaction queries
//
private class TransactionCommandHandler implements ResultHandler {
private SQLException error;
public void handleResultRows(Query fromQuery, Field[] fields, List tuples, ResultCursor cursor) {
}
public void handleCommandStatus(String status, int updateCount, long insertOID) {
}
public void handleWarning(SQLWarning warning) {
AbstractJdbc2Connection.this.addWarning(warning);
}
public void handleError(SQLException newError) {
if (error == null)
error = newError;
else
error.setNextException(newError);
}
public void handleCompletion() throws SQLException {
if (error != null)
throw error;
}
}
public int getPrepareThreshold() {
return prepareThreshold;
}
public void setPrepareThreshold(int newThreshold) {
this.prepareThreshold = (newThreshold <= 0 ? 0 : newThreshold);
}
public void setTypeMapImpl(java.util.Map map) throws SQLException
{
typemap = map;
}
public Logger getLogger()
{
return logger;
}
//Because the get/setLogStream methods are deprecated in JDBC2
//we use the get/setLogWriter methods here for JDBC2 by overriding
//the base version of this method
protected void enableDriverManagerLogging()
{
if (DriverManager.getLogWriter() == null)
{
DriverManager.setLogWriter(new PrintWriter(System.out, true));
}
}
public int getProtocolVersion()
{
return protoConnection.getProtocolVersion();
}
public boolean getStringVarcharFlag()
{
return bindStringAsVarchar;
}
private CopyManager copyManager = null;
public CopyManager getCopyAPI() throws SQLException
{
checkClosed();
if (copyManager == null)
copyManager = new CopyManager(this);
return copyManager;
}
public boolean binaryTransferSend(int oid) {
return useBinarySendForOids.contains(oid);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc2/AbstractJdbc2DatabaseMetaData.java 0000664 0000000 0000000 00000523442 12050675701 0030131 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc2;
import java.sql.*;
import java.util.*;
import org.postgresql.core.*;
import org.postgresql.util.PSQLException;
import org.postgresql.util.PSQLState;
import org.postgresql.Driver;
import org.postgresql.util.GT;
public abstract class AbstractJdbc2DatabaseMetaData
{
public AbstractJdbc2DatabaseMetaData(AbstractJdbc2Connection conn)
{
this.connection = conn;
}
private static final String keywords = "abort,acl,add,aggregate,append,archive," +
"arch_store,backward,binary,boolean,change,cluster," +
"copy,database,delimiter,delimiters,do,extend," +
"explain,forward,heavy,index,inherits,isnull," +
"light,listen,load,merge,nothing,notify," +
"notnull,oids,purge,rename,replace,retrieve," +
"returns,rule,recipe,setof,stdin,stdout,store," +
"vacuum,verbose,version";
protected final AbstractJdbc2Connection connection; // The connection association
private int NAMEDATALEN = 0; // length for name datatype
private int INDEX_MAX_KEYS = 0; // maximum number of keys in an index.
protected int getMaxIndexKeys() throws SQLException {
if (INDEX_MAX_KEYS == 0)
{
String sql;
if (connection.haveMinimumServerVersion("8.0")) {
sql = "SELECT setting FROM pg_catalog.pg_settings WHERE name='max_index_keys'";
} else {
String from;
if (connection.haveMinimumServerVersion("7.3"))
{
from = "pg_catalog.pg_namespace n, pg_catalog.pg_type t1, pg_catalog.pg_type t2 WHERE t1.typnamespace=n.oid AND n.nspname='pg_catalog' AND ";
}
else
{
from = "pg_type t1, pg_type t2 WHERE ";
}
sql = "SELECT t1.typlen/t2.typlen FROM " + from + " t1.typelem=t2.oid AND t1.typname='oidvector'";
}
ResultSet rs = connection.createStatement().executeQuery(sql);
if (!rs.next())
{
throw new PSQLException(GT.tr("Unable to determine a value for MaxIndexKeys due to missing system catalog data."), PSQLState.UNEXPECTED_ERROR);
}
INDEX_MAX_KEYS = rs.getInt(1);
rs.close();
}
return INDEX_MAX_KEYS;
}
protected int getMaxNameLength() throws SQLException {
if (NAMEDATALEN == 0)
{
String sql;
if (connection.haveMinimumServerVersion("7.3"))
{
sql = "SELECT t.typlen FROM pg_catalog.pg_type t, pg_catalog.pg_namespace n WHERE t.typnamespace=n.oid AND t.typname='name' AND n.nspname='pg_catalog'";
}
else
{
sql = "SELECT typlen FROM pg_type WHERE typname='name'";
}
ResultSet rs = connection.createStatement().executeQuery(sql);
if (!rs.next())
{
throw new PSQLException(GT.tr("Unable to find name datatype in the system catalogs."), PSQLState.UNEXPECTED_ERROR);
}
NAMEDATALEN = rs.getInt("typlen");
rs.close();
}
return NAMEDATALEN - 1;
}
/*
* Can all the procedures returned by getProcedures be called
* by the current user?
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean allProceduresAreCallable() throws SQLException
{
return true; // For now...
}
/*
* Can all the tables returned by getTable be SELECTed by
* the current user?
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean allTablesAreSelectable() throws SQLException
{
return true; // For now...
}
/*
* What is the URL for this database?
*
* @return the url or null if it cannott be generated
* @exception SQLException if a database access error occurs
*/
public String getURL() throws SQLException
{
return connection.getURL();
}
/*
* What is our user name as known to the database?
*
* @return our database user name
* @exception SQLException if a database access error occurs
*/
public String getUserName() throws SQLException
{
return connection.getUserName();
}
/*
* Is the database in read-only mode?
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean isReadOnly() throws SQLException
{
return connection.isReadOnly();
}
/*
* Are NULL values sorted high?
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean nullsAreSortedHigh() throws SQLException
{
return connection.haveMinimumServerVersion("7.2");
}
/*
* Are NULL values sorted low?
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean nullsAreSortedLow() throws SQLException
{
return false;
}
/*
* Are NULL values sorted at the start regardless of sort order?
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean nullsAreSortedAtStart() throws SQLException
{
return false;
}
/*
* Are NULL values sorted at the end regardless of sort order?
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean nullsAreSortedAtEnd() throws SQLException
{
return !connection.haveMinimumServerVersion("7.2");
}
/*
* What is the name of this database product - we hope that it is
* PostgreSQL, so we return that explicitly.
*
* @return the database product name
* @exception SQLException if a database access error occurs
*/
public String getDatabaseProductName() throws SQLException
{
return "PostgreSQL";
}
/*
* What is the version of this database product.
*
* @return the database version
* @exception SQLException if a database access error occurs
*/
public String getDatabaseProductVersion() throws SQLException
{
return connection.getDBVersionNumber();
}
/*
* What is the name of this JDBC driver? If we don't know this
* we are doing something wrong!
*
* @return the JDBC driver name
* @exception SQLException why?
*/
public String getDriverName() throws SQLException
{
return "PostgreSQL Native Driver";
}
/*
* What is the version string of this JDBC driver? Again, this is
* static.
*
* @return the JDBC driver name.
* @exception SQLException why?
*/
public String getDriverVersion() throws SQLException
{
return Driver.getVersion();
}
/*
* What is this JDBC driver's major version number?
*
* @return the JDBC driver major version
*/
public int getDriverMajorVersion()
{
return Driver.MAJORVERSION;
}
/*
* What is this JDBC driver's minor version number?
*
* @return the JDBC driver minor version
*/
public int getDriverMinorVersion()
{
return Driver.MINORVERSION;
}
/*
* Does the database store tables in a local file? No - it
* stores them in a file on the server.
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean usesLocalFiles() throws SQLException
{
return false;
}
/*
* Does the database use a file for each table? Well, not really,
* since it doesnt use local files.
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean usesLocalFilePerTable() throws SQLException
{
return false;
}
/*
* Does the database treat mixed case unquoted SQL identifiers
* as case sensitive and as a result store them in mixed case?
* A JDBC-Compliant driver will always return false.
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsMixedCaseIdentifiers() throws SQLException
{
return false;
}
/*
* Does the database treat mixed case unquoted SQL identifiers as
* case insensitive and store them in upper case?
*
* @return true if so
*/
public boolean storesUpperCaseIdentifiers() throws SQLException
{
return false;
}
/*
* Does the database treat mixed case unquoted SQL identifiers as
* case insensitive and store them in lower case?
*
* @return true if so
*/
public boolean storesLowerCaseIdentifiers() throws SQLException
{
return true;
}
/*
* Does the database treat mixed case unquoted SQL identifiers as
* case insensitive and store them in mixed case?
*
* @return true if so
*/
public boolean storesMixedCaseIdentifiers() throws SQLException
{
return false;
}
/*
* Does the database treat mixed case quoted SQL identifiers as
* case sensitive and as a result store them in mixed case? A
* JDBC compliant driver will always return true.
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsMixedCaseQuotedIdentifiers() throws SQLException
{
return true;
}
/*
* Does the database treat mixed case quoted SQL identifiers as
* case insensitive and store them in upper case?
*
* @return true if so
*/
public boolean storesUpperCaseQuotedIdentifiers() throws SQLException
{
return false;
}
/*
* Does the database treat mixed case quoted SQL identifiers as case
* insensitive and store them in lower case?
*
* @return true if so
*/
public boolean storesLowerCaseQuotedIdentifiers() throws SQLException
{
return false;
}
/*
* Does the database treat mixed case quoted SQL identifiers as case
* insensitive and store them in mixed case?
*
* @return true if so
*/
public boolean storesMixedCaseQuotedIdentifiers() throws SQLException
{
return false;
}
/*
* What is the string used to quote SQL identifiers? This returns
* a space if identifier quoting isn't supported. A JDBC Compliant
* driver will always use a double quote character.
*
* @return the quoting string
* @exception SQLException if a database access error occurs
*/
public String getIdentifierQuoteString() throws SQLException
{
return "\"";
}
/*
* Get a comma separated list of all a database's SQL keywords that
* are NOT also SQL92 keywords.
*
*
Within PostgreSQL, the keywords are found in
* src/backend/parser/keywords.c
*
*
For SQL Keywords, I took the list provided at
*
* http://web.dementia.org/~shadow/sql/sql3bnf.sep93.txt
* which is for SQL3, not SQL-92, but it is close enough for
* this purpose.
*
* @return a comma separated list of keywords we use
* @exception SQLException if a database access error occurs
*/
public String getSQLKeywords() throws SQLException
{
return keywords;
}
/**
* get supported escaped numeric functions
* @return a comma separated list of function names
*/
public String getNumericFunctions() throws SQLException
{
return EscapedFunctions.ABS+','+EscapedFunctions.ACOS+
','+EscapedFunctions.ASIN+','+EscapedFunctions.ATAN+
','+EscapedFunctions.ATAN2+','+EscapedFunctions.CEILING+
','+EscapedFunctions.COS+','+EscapedFunctions.COT+
','+EscapedFunctions.DEGREES+','+EscapedFunctions.EXP+
','+EscapedFunctions.FLOOR+','+EscapedFunctions.LOG+
','+EscapedFunctions.LOG10+','+EscapedFunctions.MOD+
','+EscapedFunctions.PI+','+EscapedFunctions.POWER+
','+EscapedFunctions.RADIANS+
','+EscapedFunctions.ROUND+','+EscapedFunctions.SIGN+
','+EscapedFunctions.SIN+','+EscapedFunctions.SQRT+
','+EscapedFunctions.TAN+','+EscapedFunctions.TRUNCATE;
}
public String getStringFunctions() throws SQLException
{
String funcs = EscapedFunctions.ASCII+','+EscapedFunctions.CHAR+
','+EscapedFunctions.CONCAT+
','+EscapedFunctions.LCASE+','+EscapedFunctions.LEFT+
','+EscapedFunctions.LENGTH+
','+EscapedFunctions.LTRIM+','+EscapedFunctions.REPEAT+
','+EscapedFunctions.RTRIM+
','+EscapedFunctions.SPACE+','+EscapedFunctions.SUBSTRING+
','+EscapedFunctions.UCASE;
// Currently these don't work correctly with parameterized
// arguments, so leave them out. They reorder the arguments
// when rewriting the query, but no translation layer is provided,
// so a setObject(N, obj) will not go to the correct parameter.
//','+EscapedFunctions.INSERT+','+EscapedFunctions.LOCATE+
//','+EscapedFunctions.RIGHT+
if (connection.haveMinimumServerVersion("7.3")) {
funcs += ','+EscapedFunctions.REPLACE;
}
return funcs;
}
public String getSystemFunctions() throws SQLException
{
if (connection.haveMinimumServerVersion("7.3")){
return EscapedFunctions.DATABASE+','+EscapedFunctions.IFNULL+
','+EscapedFunctions.USER;
} else {
return EscapedFunctions.IFNULL+
','+EscapedFunctions.USER;
}
}
public String getTimeDateFunctions() throws SQLException
{
String timeDateFuncs = EscapedFunctions.CURDATE+','+EscapedFunctions.CURTIME+
','+EscapedFunctions.DAYNAME+','+EscapedFunctions.DAYOFMONTH+
','+EscapedFunctions.DAYOFWEEK+','+EscapedFunctions.DAYOFYEAR+
','+EscapedFunctions.HOUR+','+EscapedFunctions.MINUTE+
','+EscapedFunctions.MONTH+
','+EscapedFunctions.MONTHNAME+','+EscapedFunctions.NOW+
','+EscapedFunctions.QUARTER+','+EscapedFunctions.SECOND+
','+EscapedFunctions.WEEK+','+EscapedFunctions.YEAR;
if (connection.haveMinimumServerVersion("8.0")) {
timeDateFuncs += ','+EscapedFunctions.TIMESTAMPADD;
}
//+','+EscapedFunctions.TIMESTAMPDIFF;
return timeDateFuncs;
}
/*
* This is the string that can be used to escape '_' and '%' in
* a search string pattern style catalog search parameters
*
* @return the string used to escape wildcard characters
* @exception SQLException if a database access error occurs
*/
public String getSearchStringEscape() throws SQLException
{
// This method originally returned "\\\\" assuming that it
// would be fed directly into pg's input parser so it would
// need two backslashes. This isn't how it's supposed to be
// used though. If passed as a PreparedStatement parameter
// or fed to a DatabaseMetaData method then double backslashes
// are incorrect. If you're feeding something directly into
// a query you are responsible for correctly escaping it.
// With 8.2+ this escaping is a little trickier because you
// must know the setting of standard_conforming_strings, but
// that's not our problem.
return "\\";
}
/*
* Get all the "extra" characters that can be used in unquoted
* identifier names (those beyond a-zA-Z0-9 and _)
*
*
Postgresql allows any high-bit character to be used
* in an unquoted identifer, so we can't possibly list them all.
*
* From the file src/backend/parser/scan.l, an identifier is
* ident_start [A-Za-z\200-\377_]
* ident_cont [A-Za-z\200-\377_0-9\$]
* identifier {ident_start}{ident_cont}*
*
* @return a string containing the extra characters
* @exception SQLException if a database access error occurs
*/
public String getExtraNameCharacters() throws SQLException
{
return "";
}
/*
* Is "ALTER TABLE" with an add column supported?
* Yes for PostgreSQL 6.1
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsAlterTableWithAddColumn() throws SQLException
{
return true;
}
/*
* Is "ALTER TABLE" with a drop column supported?
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsAlterTableWithDropColumn() throws SQLException
{
return connection.haveMinimumServerVersion("7.3");
}
/*
* Is column aliasing supported?
*
*
If so, the SQL AS clause can be used to provide names for
* computed columns or to provide alias names for columns as
* required. A JDBC Compliant driver always returns true.
*
*
e.g.
*
*
* select count(C) as C_COUNT from T group by C;
*
*
* should return a column named as C_COUNT instead of count(C)
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsColumnAliasing() throws SQLException
{
return true;
}
/*
* Are concatenations between NULL and non-NULL values NULL? A
* JDBC Compliant driver always returns true
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean nullPlusNonNullIsNull() throws SQLException
{
return true;
}
public boolean supportsConvert() throws SQLException
{
return false;
}
public boolean supportsConvert(int fromType, int toType) throws SQLException
{
return false;
}
/*
* Are table correlation names supported? A JDBC Compliant
* driver always returns true.
*
* @return true if so; false otherwise
* @exception SQLException - if a database access error occurs
*/
public boolean supportsTableCorrelationNames() throws SQLException
{
return true;
}
/*
* If table correlation names are supported, are they restricted to
* be different from the names of the tables?
*
* @return true if so; false otherwise
* @exception SQLException - if a database access error occurs
*/
public boolean supportsDifferentTableCorrelationNames() throws SQLException
{
return false;
}
/*
* Are expressions in "ORDER BY" lists supported?
*
* e.g. select * from t order by a + b;
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsExpressionsInOrderBy() throws SQLException
{
return true;
}
/*
* Can an "ORDER BY" clause use columns not in the SELECT?
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsOrderByUnrelated() throws SQLException
{
return connection.haveMinimumServerVersion("6.4");
}
/*
* Is some form of "GROUP BY" clause supported?
* I checked it, and yes it is.
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsGroupBy() throws SQLException
{
return true;
}
/*
* Can a "GROUP BY" clause use columns not in the SELECT?
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsGroupByUnrelated() throws SQLException
{
return connection.haveMinimumServerVersion("6.4");
}
/*
* Can a "GROUP BY" clause add columns not in the SELECT provided
* it specifies all the columns in the SELECT? Does anyone actually
* understand what they mean here?
*
* (I think this is a subset of the previous function. -- petere)
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsGroupByBeyondSelect() throws SQLException
{
return connection.haveMinimumServerVersion("6.4");
}
/*
* Is the escape character in "LIKE" clauses supported? A
* JDBC compliant driver always returns true.
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsLikeEscapeClause() throws SQLException
{
return connection.haveMinimumServerVersion("7.1");
}
/*
* Are multiple ResultSets from a single execute supported?
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsMultipleResultSets() throws SQLException
{
return true;
}
/*
* Can we have multiple transactions open at once (on different
* connections?)
* I guess we can have, since Im relying on it.
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsMultipleTransactions() throws SQLException
{
return true;
}
/*
* Can columns be defined as non-nullable. A JDBC Compliant driver
* always returns true.
*
*
This changed from false to true in v6.2 of the driver, as this
* support was added to the backend.
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsNonNullableColumns() throws SQLException
{
return true;
}
/*
* Does this driver support the minimum ODBC SQL grammar. This
* grammar is defined at:
*
*
In Appendix C. From this description, we seem to support the
* ODBC minimal (Level 0) grammar.
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsMinimumSQLGrammar() throws SQLException
{
return true;
}
/*
* Does this driver support the Core ODBC SQL grammar. We need
* SQL-92 conformance for this.
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsCoreSQLGrammar() throws SQLException
{
return false;
}
/*
* Does this driver support the Extended (Level 2) ODBC SQL
* grammar. We don't conform to the Core (Level 1), so we can't
* conform to the Extended SQL Grammar.
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsExtendedSQLGrammar() throws SQLException
{
return false;
}
/*
* Does this driver support the ANSI-92 entry level SQL grammar?
* All JDBC Compliant drivers must return true. We currently
* report false until 'schema' support is added. Then this
* should be changed to return true, since we will be mostly
* compliant (probably more compliant than many other databases)
* And since this is a requirement for all JDBC drivers we
* need to get to the point where we can return true.
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsANSI92EntryLevelSQL() throws SQLException
{
return connection.haveMinimumServerVersion("7.3");
}
/*
* Does this driver support the ANSI-92 intermediate level SQL
* grammar?
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsANSI92IntermediateSQL() throws SQLException
{
return false;
}
/*
* Does this driver support the ANSI-92 full SQL grammar?
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsANSI92FullSQL() throws SQLException
{
return false;
}
/*
* Is the SQL Integrity Enhancement Facility supported?
* Our best guess is that this means support for constraints
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsIntegrityEnhancementFacility() throws SQLException
{
return true;
}
/*
* Is some form of outer join supported?
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsOuterJoins() throws SQLException
{
return connection.haveMinimumServerVersion("7.1");
}
/*
* Are full nexted outer joins supported?
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsFullOuterJoins() throws SQLException
{
return connection.haveMinimumServerVersion("7.1");
}
/*
* Is there limited support for outer joins?
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsLimitedOuterJoins() throws SQLException
{
return connection.haveMinimumServerVersion("7.1");
}
/*
* What is the database vendor's preferred term for "schema"?
* PostgreSQL doesn't have schemas, but when it does, we'll use the
* term "schema".
*
* @return the vendor term
* @exception SQLException if a database access error occurs
*/
public String getSchemaTerm() throws SQLException
{
return "schema";
}
/*
* What is the database vendor's preferred term for "procedure"?
* Traditionally, "function" has been used.
*
* @return the vendor term
* @exception SQLException if a database access error occurs
*/
public String getProcedureTerm() throws SQLException
{
return "function";
}
/*
* What is the database vendor's preferred term for "catalog"?
*
* @return the vendor term
* @exception SQLException if a database access error occurs
*/
public String getCatalogTerm() throws SQLException
{
return "database";
}
/*
* Does a catalog appear at the start of a qualified table name?
* (Otherwise it appears at the end).
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean isCatalogAtStart() throws SQLException
{
return true;
}
/*
* What is the Catalog separator.
*
* @return the catalog separator string
* @exception SQLException if a database access error occurs
*/
public String getCatalogSeparator() throws SQLException
{
return ".";
}
/*
* Can a schema name be used in a data manipulation statement?
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsSchemasInDataManipulation() throws SQLException
{
return connection.haveMinimumServerVersion("7.3");
}
/*
* Can a schema name be used in a procedure call statement?
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsSchemasInProcedureCalls() throws SQLException
{
return connection.haveMinimumServerVersion("7.3");
}
/*
* Can a schema be used in a table definition statement?
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsSchemasInTableDefinitions() throws SQLException
{
return connection.haveMinimumServerVersion("7.3");
}
/*
* Can a schema name be used in an index definition statement?
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsSchemasInIndexDefinitions() throws SQLException
{
return connection.haveMinimumServerVersion("7.3");
}
/*
* Can a schema name be used in a privilege definition statement?
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsSchemasInPrivilegeDefinitions() throws SQLException
{
return connection.haveMinimumServerVersion("7.3");
}
/*
* Can a catalog name be used in a data manipulation statement?
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsCatalogsInDataManipulation() throws SQLException
{
return false;
}
/*
* Can a catalog name be used in a procedure call statement?
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsCatalogsInProcedureCalls() throws SQLException
{
return false;
}
/*
* Can a catalog name be used in a table definition statement?
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsCatalogsInTableDefinitions() throws SQLException
{
return false;
}
/*
* Can a catalog name be used in an index definition?
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsCatalogsInIndexDefinitions() throws SQLException
{
return false;
}
/*
* Can a catalog name be used in a privilege definition statement?
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsCatalogsInPrivilegeDefinitions() throws SQLException
{
return false;
}
/*
* We support cursors for gets only it seems. I dont see a method
* to get a positioned delete.
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsPositionedDelete() throws SQLException
{
return false; // For now...
}
/*
* Is positioned UPDATE supported?
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsPositionedUpdate() throws SQLException
{
return false; // For now...
}
/*
* Is SELECT for UPDATE supported?
*
* @return true if so; false otherwise
* @exception SQLException - if a database access error occurs
*/
public boolean supportsSelectForUpdate() throws SQLException
{
return connection.haveMinimumServerVersion("6.5");
}
/*
* Are stored procedure calls using the stored procedure escape
* syntax supported?
*
* @return true if so; false otherwise
* @exception SQLException - if a database access error occurs
*/
public boolean supportsStoredProcedures() throws SQLException
{
return true;
}
/*
* Are subqueries in comparison expressions supported? A JDBC
* Compliant driver always returns true.
*
* @return true if so; false otherwise
* @exception SQLException - if a database access error occurs
*/
public boolean supportsSubqueriesInComparisons() throws SQLException
{
return true;
}
/*
* Are subqueries in 'exists' expressions supported? A JDBC
* Compliant driver always returns true.
*
* @return true if so; false otherwise
* @exception SQLException - if a database access error occurs
*/
public boolean supportsSubqueriesInExists() throws SQLException
{
return true;
}
/*
* Are subqueries in 'in' statements supported? A JDBC
* Compliant driver always returns true.
*
* @return true if so; false otherwise
* @exception SQLException - if a database access error occurs
*/
public boolean supportsSubqueriesInIns() throws SQLException
{
return true;
}
/*
* Are subqueries in quantified expressions supported? A JDBC
* Compliant driver always returns true.
*
* (No idea what this is, but we support a good deal of
* subquerying.)
*
* @return true if so; false otherwise
* @exception SQLException - if a database access error occurs
*/
public boolean supportsSubqueriesInQuantifieds() throws SQLException
{
return true;
}
/*
* Are correlated subqueries supported? A JDBC Compliant driver
* always returns true.
*
* (a.k.a. subselect in from?)
*
* @return true if so; false otherwise
* @exception SQLException - if a database access error occurs
*/
public boolean supportsCorrelatedSubqueries() throws SQLException
{
return connection.haveMinimumServerVersion("7.1");
}
/*
* Is SQL UNION supported?
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsUnion() throws SQLException
{
return true; // since 6.3
}
/*
* Is SQL UNION ALL supported?
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsUnionAll() throws SQLException
{
return connection.haveMinimumServerVersion("7.1");
}
/*
* In PostgreSQL, Cursors are only open within transactions.
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsOpenCursorsAcrossCommit() throws SQLException
{
return false;
}
/*
* Do we support open cursors across multiple transactions?
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsOpenCursorsAcrossRollback() throws SQLException
{
return false;
}
/*
* Can statements remain open across commits? They may, but
* this driver cannot guarentee that. In further reflection.
* we are talking a Statement object here, so the answer is
* yes, since the Statement is only a vehicle to ExecSQL()
*
* @return true if they always remain open; false otherwise
* @exception SQLException if a database access error occurs
*/
public boolean supportsOpenStatementsAcrossCommit() throws SQLException
{
return true;
}
/*
* Can statements remain open across rollbacks? They may, but
* this driver cannot guarentee that. In further contemplation,
* we are talking a Statement object here, so the answer is yes,
* since the Statement is only a vehicle to ExecSQL() in Connection
*
* @return true if they always remain open; false otherwise
* @exception SQLException if a database access error occurs
*/
public boolean supportsOpenStatementsAcrossRollback() throws SQLException
{
return true;
}
/*
* How many hex characters can you have in an inline binary literal
*
* @return the max literal length
* @exception SQLException if a database access error occurs
*/
public int getMaxBinaryLiteralLength() throws SQLException
{
return 0; // no limit
}
/*
* What is the maximum length for a character literal
* I suppose it is 8190 (8192 - 2 for the quotes)
*
* @return the max literal length
* @exception SQLException if a database access error occurs
*/
public int getMaxCharLiteralLength() throws SQLException
{
return 0; // no limit
}
/*
* Whats the limit on column name length.
*
* @return the maximum column name length
* @exception SQLException if a database access error occurs
*/
public int getMaxColumnNameLength() throws SQLException
{
return getMaxNameLength();
}
/*
* What is the maximum number of columns in a "GROUP BY" clause?
*
* @return the max number of columns
* @exception SQLException if a database access error occurs
*/
public int getMaxColumnsInGroupBy() throws SQLException
{
return 0; // no limit
}
/*
* What's the maximum number of columns allowed in an index?
*
* @return max number of columns
* @exception SQLException if a database access error occurs
*/
public int getMaxColumnsInIndex() throws SQLException
{
return getMaxIndexKeys();
}
/*
* What's the maximum number of columns in an "ORDER BY clause?
*
* @return the max columns
* @exception SQLException if a database access error occurs
*/
public int getMaxColumnsInOrderBy() throws SQLException
{
return 0; // no limit
}
/*
* What is the maximum number of columns in a "SELECT" list?
*
* @return the max columns
* @exception SQLException if a database access error occurs
*/
public int getMaxColumnsInSelect() throws SQLException
{
return 0; // no limit
}
/*
* What is the maximum number of columns in a table? From the
* CREATE TABLE reference page...
*
*
"The new class is created as a heap with no initial data. A
* class can have no more than 1600 attributes (realistically,
* this is limited by the fact that tuple sizes must be less than
* 8192 bytes)..."
*
* @return the max columns
* @exception SQLException if a database access error occurs
*/
public int getMaxColumnsInTable() throws SQLException
{
return 1600;
}
/*
* How many active connection can we have at a time to this
* database? Well, since it depends on postmaster, which just
* does a listen() followed by an accept() and fork(), its
* basically very high. Unless the system runs out of processes,
* it can be 65535 (the number of aux. ports on a TCP/IP system).
* I will return 8192 since that is what even the largest system
* can realistically handle,
*
* @return the maximum number of connections
* @exception SQLException if a database access error occurs
*/
public int getMaxConnections() throws SQLException
{
return 8192;
}
/*
* What is the maximum cursor name length
*
* @return max cursor name length in bytes
* @exception SQLException if a database access error occurs
*/
public int getMaxCursorNameLength() throws SQLException
{
return getMaxNameLength();
}
/*
* Retrieves the maximum number of bytes for an index, including all
* of the parts of the index.
*
* @return max index length in bytes, which includes the composite
* of all the constituent parts of the index; a result of zero means
* that there is no limit or the limit is not known
* @exception SQLException if a database access error occurs
*/
public int getMaxIndexLength() throws SQLException
{
return 0; // no limit (larger than an int anyway)
}
public int getMaxSchemaNameLength() throws SQLException
{
return getMaxNameLength();
}
/*
* What is the maximum length of a procedure name
*
* @return the max name length in bytes
* @exception SQLException if a database access error occurs
*/
public int getMaxProcedureNameLength() throws SQLException
{
return getMaxNameLength();
}
public int getMaxCatalogNameLength() throws SQLException
{
return getMaxNameLength();
}
/*
* What is the maximum length of a single row?
*
* @return max row size in bytes
* @exception SQLException if a database access error occurs
*/
public int getMaxRowSize() throws SQLException
{
if (connection.haveMinimumServerVersion("7.1"))
return 1073741824; // 1 GB
else
return 8192; // XXX could be altered
}
/*
* Did getMaxRowSize() include LONGVARCHAR and LONGVARBINARY
* blobs? We don't handle blobs yet
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean doesMaxRowSizeIncludeBlobs() throws SQLException
{
return false;
}
/*
* What is the maximum length of a SQL statement?
*
* @return max length in bytes
* @exception SQLException if a database access error occurs
*/
public int getMaxStatementLength() throws SQLException
{
if (connection.haveMinimumServerVersion("7.0"))
return 0; // actually whatever fits in size_t
else
return 16384;
}
/*
* How many active statements can we have open at one time to
* this database? We're only limited by Java heap space really.
*
* @return the maximum
* @exception SQLException if a database access error occurs
*/
public int getMaxStatements() throws SQLException
{
return 0;
}
/*
* What is the maximum length of a table name
*
* @return max name length in bytes
* @exception SQLException if a database access error occurs
*/
public int getMaxTableNameLength() throws SQLException
{
return getMaxNameLength();
}
/*
* What is the maximum number of tables that can be specified
* in a SELECT?
*
* @return the maximum
* @exception SQLException if a database access error occurs
*/
public int getMaxTablesInSelect() throws SQLException
{
return 0; // no limit
}
/*
* What is the maximum length of a user name
*
* @return the max name length in bytes
* @exception SQLException if a database access error occurs
*/
public int getMaxUserNameLength() throws SQLException
{
return getMaxNameLength();
}
/*
* What is the database's default transaction isolation level?
*
* @return the default isolation level
* @exception SQLException if a database access error occurs
* @see Connection
*/
public int getDefaultTransactionIsolation() throws SQLException
{
return Connection.TRANSACTION_READ_COMMITTED;
}
/*
* Are transactions supported? If not, commit and rollback are noops
* and the isolation level is TRANSACTION_NONE. We do support
* transactions.
*
* @return true if transactions are supported
* @exception SQLException if a database access error occurs
*/
public boolean supportsTransactions() throws SQLException
{
return true;
}
/*
* Does the database support the given transaction isolation level?
* We only support TRANSACTION_SERIALIZABLE and TRANSACTION_READ_COMMITTED
* before 8.0; from 8.0 READ_UNCOMMITTED and REPEATABLE_READ are accepted aliases
* for READ_COMMITTED.
*
* @param level the values are defined in java.sql.Connection
* @return true if so
* @exception SQLException if a database access error occurs
* @see Connection
*/
public boolean supportsTransactionIsolationLevel(int level) throws SQLException
{
if (level == Connection.TRANSACTION_SERIALIZABLE ||
level == Connection.TRANSACTION_READ_COMMITTED)
return true;
else if (connection.haveMinimumServerVersion("8.0") && (level == Connection.TRANSACTION_READ_UNCOMMITTED || level == Connection.TRANSACTION_REPEATABLE_READ))
return true;
else
return false;
}
/*
* Are both data definition and data manipulation transactions
* supported?
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsDataDefinitionAndDataManipulationTransactions() throws SQLException
{
return true;
}
/*
* Are only data manipulation statements withing a transaction
* supported?
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean supportsDataManipulationTransactionsOnly() throws SQLException
{
return false;
}
/*
* Does a data definition statement within a transaction force
* the transaction to commit? I think this means something like:
*
*
* CREATE TABLE T (A INT);
* INSERT INTO T (A) VALUES (2);
* BEGIN;
* UPDATE T SET A = A + 1;
* CREATE TABLE X (A INT);
* SELECT A FROM T INTO X;
* COMMIT;
*
*
* does the CREATE TABLE call cause a commit? The answer is no.
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean dataDefinitionCausesTransactionCommit() throws SQLException
{
return false;
}
/*
* Is a data definition statement within a transaction ignored?
*
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean dataDefinitionIgnoredInTransactions() throws SQLException
{
return false;
}
/**
* Turn the provided value into a valid string literal for
* direct inclusion into a query. This includes the single quotes
* needed around it.
*/
protected String escapeQuotes(String s) throws SQLException {
StringBuffer sb = new StringBuffer();
if (!connection.getStandardConformingStrings() && connection.haveMinimumServerVersion("8.1")) {
sb.append("E");
}
sb.append("'");
sb.append(connection.escapeString(s));
sb.append("'");
return sb.toString();
}
/*
* Get a description of stored procedures available in a catalog
*
*
Only procedure descriptions matching the schema and procedure
* name criteria are returned. They are ordered by PROCEDURE_SCHEM
* and PROCEDURE_NAME
*
*
Each procedure description has the following columns:
*
*
PROCEDURE_CAT String => procedure catalog (may be null)
*
PROCEDURE_SCHEM String => procedure schema (may be null)
*
PROCEDURE_NAME String => procedure name
*
Field 4 reserved (make it null)
*
Field 5 reserved (make it null)
*
Field 6 reserved (make it null)
*
REMARKS String => explanatory comment on the procedure
*
PROCEDURE_TYPE short => kind of procedure
*
*
procedureResultUnknown - May return a result
*
procedureNoResult - Does not return a result
*
procedureReturnsResult - Returns a result
*
*
*
* @param catalog - a catalog name; "" retrieves those without a
* catalog; null means drop catalog name from criteria
* @param schemaParrern - a schema name pattern; "" retrieves those
* without a schema - we ignore this parameter
* @param procedureNamePattern - a procedure name pattern
* @return ResultSet - each row is a procedure description
* @exception SQLException if a database access error occurs
*/
public java.sql.ResultSet getProcedures(String catalog, String schemaPattern, String procedureNamePattern) throws SQLException
{
return getProcedures(2, catalog, schemaPattern, procedureNamePattern);
}
protected java.sql.ResultSet getProcedures(int jdbcVersion, String catalog, String schemaPattern, String procedureNamePattern) throws SQLException
{
String sql;
if (connection.haveMinimumServerVersion("7.3"))
{
sql = "SELECT NULL AS PROCEDURE_CAT, n.nspname AS PROCEDURE_SCHEM, p.proname AS PROCEDURE_NAME, NULL, NULL, NULL, d.description AS REMARKS, " + java.sql.DatabaseMetaData.procedureReturnsResult + " AS PROCEDURE_TYPE ";
if (jdbcVersion >= 4) {
sql += ", p.proname || '_' || p.oid AS SPECIFIC_NAME ";
}
sql += " FROM pg_catalog.pg_namespace n, pg_catalog.pg_proc p " +
" LEFT JOIN pg_catalog.pg_description d ON (p.oid=d.objoid) " +
" LEFT JOIN pg_catalog.pg_class c ON (d.classoid=c.oid AND c.relname='pg_proc') " +
" LEFT JOIN pg_catalog.pg_namespace pn ON (c.relnamespace=pn.oid AND pn.nspname='pg_catalog') " +
" WHERE p.pronamespace=n.oid ";
if (schemaPattern != null && !"".equals(schemaPattern))
{
sql += " AND n.nspname LIKE " + escapeQuotes(schemaPattern);
}
if (procedureNamePattern != null)
{
sql += " AND p.proname LIKE " + escapeQuotes(procedureNamePattern);
}
sql += " ORDER BY PROCEDURE_SCHEM, PROCEDURE_NAME, p.oid::text ";
}
else if (connection.haveMinimumServerVersion("7.1"))
{
sql = "SELECT NULL AS PROCEDURE_CAT, NULL AS PROCEDURE_SCHEM, p.proname AS PROCEDURE_NAME, NULL, NULL, NULL, d.description AS REMARKS, " + java.sql.DatabaseMetaData.procedureReturnsResult + " AS PROCEDURE_TYPE ";
if (jdbcVersion >= 4) {
sql += ", p.proname || '_' || p.oid AS SPECIFIC_NAME ";
}
sql += " FROM pg_proc p " +
" LEFT JOIN pg_description d ON (p.oid=d.objoid) ";
if (connection.haveMinimumServerVersion("7.2"))
{
sql += " LEFT JOIN pg_class c ON (d.classoid=c.oid AND c.relname='pg_proc') ";
}
if (procedureNamePattern != null)
{
sql += " WHERE p.proname LIKE " + escapeQuotes(procedureNamePattern);
}
sql += " ORDER BY PROCEDURE_NAME, p.oid::text ";
}
else
{
sql = "SELECT NULL AS PROCEDURE_CAT, NULL AS PROCEDURE_SCHEM, p.proname AS PROCEDURE_NAME, NULL, NULL, NULL, NULL AS REMARKS, " + java.sql.DatabaseMetaData.procedureReturnsResult + " AS PROCEDURE_TYPE ";
if (jdbcVersion >= 4) {
sql += ", p.proname || '_' || p.oid AS SPECIFIC_NAME ";
}
sql += " FROM pg_proc p ";
if (procedureNamePattern != null)
{
sql += " WHERE p.proname LIKE " + escapeQuotes(procedureNamePattern);
}
sql += " ORDER BY PROCEDURE_NAME, p.oid::text ";
}
return createMetaDataStatement().executeQuery(sql);
}
/*
* Get a description of a catalog's stored procedure parameters
* and result columns.
*
*
Only descriptions matching the schema, procedure and parameter
* name criteria are returned. They are ordered by PROCEDURE_SCHEM
* and PROCEDURE_NAME. Within this, the return value, if any, is
* first. Next are the parameter descriptions in call order. The
* column descriptions follow in column number order.
*
*
Each row in the ResultSet is a parameter description or column
* description with the following fields:
*
*
PROCEDURE_CAT String => procedure catalog (may be null)
*
PROCEDURE_SCHEM String => procedure schema (may be null)
*
PROCEDURE_NAME String => procedure name
*
COLUMN_NAME String => column/parameter name
*
COLUMN_TYPE Short => kind of column/parameter:
*
procedureColumnUnknown - nobody knows
*
procedureColumnIn - IN parameter
*
procedureColumnInOut - INOUT parameter
*
procedureColumnOut - OUT parameter
*
procedureColumnReturn - procedure return value
*
procedureColumnResult - result column in ResultSet
*
*
DATA_TYPE short => SQL type from java.sql.Types
*
TYPE_NAME String => Data source specific type name
*
* @param catalog This is ignored in org.postgresql, advise this is set to null
* @param schemaPattern
* @param procedureNamePattern a procedure name pattern
* @param columnNamePattern a column name pattern, this is currently ignored because postgresql does not name procedure parameters.
* @return each row is a stored procedure parameter or column description
* @exception SQLException if a database-access error occurs
* @see #getSearchStringEscape
*/
// Implementation note: This is required for Borland's JBuilder to work
public java.sql.ResultSet getProcedureColumns(String catalog, String schemaPattern, String procedureNamePattern, String columnNamePattern) throws SQLException
{
return getProcedureColumns(2, catalog, schemaPattern, procedureNamePattern, columnNamePattern);
}
protected java.sql.ResultSet getProcedureColumns(int jdbcVersion, String catalog, String schemaPattern, String procedureNamePattern, String columnNamePattern) throws SQLException
{
int columns = 13;
if (jdbcVersion >= 4) {
columns += 7;
}
Field f[] = new Field[columns];
List v = new ArrayList(); // The new ResultSet tuple stuff
f[0] = new Field("PROCEDURE_CAT", Oid.VARCHAR);
f[1] = new Field("PROCEDURE_SCHEM", Oid.VARCHAR);
f[2] = new Field("PROCEDURE_NAME", Oid.VARCHAR);
f[3] = new Field("COLUMN_NAME", Oid.VARCHAR);
f[4] = new Field("COLUMN_TYPE", Oid.INT2);
f[5] = new Field("DATA_TYPE", Oid.INT2);
f[6] = new Field("TYPE_NAME", Oid.VARCHAR);
f[7] = new Field("PRECISION", Oid.INT4);
f[8] = new Field("LENGTH", Oid.INT4);
f[9] = new Field("SCALE", Oid.INT2);
f[10] = new Field("RADIX", Oid.INT2);
f[11] = new Field("NULLABLE", Oid.INT2);
f[12] = new Field("REMARKS", Oid.VARCHAR);
if (jdbcVersion >= 4) {
f[13] = new Field("COLUMN_DEF", Oid.VARCHAR);
f[14] = new Field("SQL_DATA_TYPE", Oid.INT4);
f[15] = new Field("SQL_DATETIME_SUB", Oid.INT4);
f[16] = new Field("CHAR_OCTECT_LENGTH", Oid.INT4);
f[17] = new Field("ORDINAL_POSITION", Oid.INT4);
f[18] = new Field("IS_NULLABLE", Oid.VARCHAR);
f[19] = new Field("SPECIFIC_NAME", Oid.VARCHAR);
}
String sql;
if (connection.haveMinimumServerVersion("7.3"))
{
sql = "SELECT n.nspname,p.proname,p.prorettype,p.proargtypes, t.typtype,t.typrelid ";
if (connection.haveMinimumServerVersion("8.1"))
sql += ", p.proargnames, p.proargmodes, p.proallargtypes ";
else if (connection.haveMinimumServerVersion("8.0"))
sql += ", p.proargnames, NULL AS proargmodes, NULL AS proallargtypes ";
else
sql += ", NULL AS proargnames, NULL AS proargmodes, NULL AS proallargtypes ";
sql += ", p.oid "
+ " FROM pg_catalog.pg_proc p, pg_catalog.pg_namespace n, pg_catalog.pg_type t "
+ " WHERE p.pronamespace=n.oid AND p.prorettype=t.oid ";
if (schemaPattern != null && !"".equals(schemaPattern))
{
sql += " AND n.nspname LIKE " + escapeQuotes(schemaPattern);
}
if (procedureNamePattern != null)
{
sql += " AND p.proname LIKE " + escapeQuotes(procedureNamePattern);
}
sql += " ORDER BY n.nspname, p.proname, p.oid::text ";
}
else
{
sql = "SELECT NULL AS nspname,p.proname,p.prorettype,p.proargtypes,t.typtype,t.typrelid, NULL AS proargnames, NULL AS proargmodes, NULL AS proallargtypes, p.oid " +
" FROM pg_proc p,pg_type t " +
" WHERE p.prorettype=t.oid ";
if (procedureNamePattern != null)
{
sql += " AND p.proname LIKE " + escapeQuotes(procedureNamePattern);
}
sql += " ORDER BY p.proname, p.oid::text ";
}
byte isnullableUnknown[] = new byte[0];
ResultSet rs = connection.createStatement().executeQuery(sql);
while (rs.next())
{
byte schema[] = rs.getBytes("nspname");
byte procedureName[] = rs.getBytes("proname");
byte specificName[] = connection.encodeString(rs.getString("proname") + "_" + rs.getString("oid"));
int returnType = (int)rs.getLong("prorettype");
String returnTypeType = rs.getString("typtype");
int returnTypeRelid = (int)rs.getLong("typrelid");
String strArgTypes = rs.getString("proargtypes");
StringTokenizer st = new StringTokenizer(strArgTypes);
List argTypes = new ArrayList();
while (st.hasMoreTokens())
{
argTypes.add(new Long(st.nextToken()));
}
String argNames[] = null;
Array argNamesArray = rs.getArray("proargnames");
if (argNamesArray != null)
argNames = (String[])argNamesArray.getArray();
String argModes[] = null;
Array argModesArray = rs.getArray("proargmodes");
if (argModesArray != null)
argModes = (String[])argModesArray.getArray();
int numArgs = argTypes.size();
Long allArgTypes[] = null;
Array allArgTypesArray = rs.getArray("proallargtypes");
if (allArgTypesArray != null) {
// Depending on what the user has selected we'll get
// either long[] or Long[] back, and there's no
// obvious way for the driver to override this for
// it's own usage.
if (connection.haveMinimumCompatibleVersion("8.3")) {
allArgTypes = (Long[])allArgTypesArray.getArray();
} else {
long tempAllArgTypes[] = (long[])allArgTypesArray.getArray();
allArgTypes = new Long[tempAllArgTypes.length];
for (int i=0; i= 4) {
tuple[17] = connection.encodeString(Integer.toString(0));
tuple[18] = isnullableUnknown;
tuple[19] = specificName;
}
v.add(tuple);
}
// Add a row for each argument.
for (int i = 0; i < numArgs; i++)
{
byte[][] tuple = new byte[columns][];
tuple[0] = null;
tuple[1] = schema;
tuple[2] = procedureName;
if (argNames != null)
tuple[3] = connection.encodeString(argNames[i]);
else
tuple[3] = connection.encodeString("$" + (i + 1));
int columnMode = DatabaseMetaData.procedureColumnIn;
if (argModes != null && argModes[i].equals("o"))
columnMode = DatabaseMetaData.procedureColumnOut;
else if (argModes != null && argModes[i].equals("b"))
columnMode = DatabaseMetaData.procedureColumnInOut;
tuple[4] = connection.encodeString(Integer.toString(columnMode));
int argOid;
if (allArgTypes != null)
argOid = allArgTypes[i].intValue();
else
argOid = ((Long)argTypes.get(i)).intValue();
tuple[5] = connection.encodeString(Integer.toString(connection.getTypeInfo().getSQLType(argOid)));
tuple[6] = connection.encodeString(connection.getTypeInfo().getPGType(argOid));
tuple[7] = null;
tuple[8] = null;
tuple[9] = null;
tuple[10] = null;
tuple[11] = connection.encodeString(Integer.toString(DatabaseMetaData.procedureNullableUnknown));
tuple[12] = null;
if (jdbcVersion >= 4) {
tuple[17] = connection.encodeString(Integer.toString(i+1));
tuple[18] = isnullableUnknown;
tuple[19] = specificName;
}
v.add(tuple);
}
// if we are returning a multi-column result.
if (returnTypeType.equals("c") || (returnTypeType.equals("p") && argModesArray != null))
{
String columnsql = "SELECT a.attname,a.atttypid FROM ";
if (connection.haveMinimumServerVersion("7.3")) {
columnsql += "pg_catalog.";
}
columnsql += "pg_attribute a WHERE a.attrelid = " + returnTypeRelid + " AND a.attnum > 0 ORDER BY a.attnum ";
ResultSet columnrs = connection.createStatement().executeQuery(columnsql);
while (columnrs.next())
{
int columnTypeOid = (int)columnrs.getLong("atttypid");
byte[][] tuple = new byte[columns][];
tuple[0] = null;
tuple[1] = schema;
tuple[2] = procedureName;
tuple[3] = columnrs.getBytes("attname");
tuple[4] = connection.encodeString(Integer.toString(java.sql.DatabaseMetaData.procedureColumnResult));
tuple[5] = connection.encodeString(Integer.toString(connection.getTypeInfo().getSQLType(columnTypeOid)));
tuple[6] = connection.encodeString(connection.getTypeInfo().getPGType(columnTypeOid));
tuple[7] = null;
tuple[8] = null;
tuple[9] = null;
tuple[10] = null;
tuple[11] = connection.encodeString(Integer.toString(java.sql.DatabaseMetaData.procedureNullableUnknown));
tuple[12] = null;
if (jdbcVersion >= 4) {
tuple[17] = connection.encodeString(Integer.toString(0));
tuple[18] = isnullableUnknown;
tuple[19] = specificName;
}
v.add(tuple);
}
columnrs.close();
}
}
rs.close();
return (ResultSet)((BaseStatement)createMetaDataStatement()).createDriverResultSet(f, v);
}
/*
* Get a description of tables available in a catalog.
*
*
Only table descriptions matching the catalog, schema, table
* name and type criteria are returned. They are ordered by
* TABLE_TYPE, TABLE_SCHEM and TABLE_NAME.
*
*
Each table description has the following columns:
*
*
*
TABLE_CAT String => table catalog (may be null)
*
TABLE_SCHEM String => table schema (may be null)
*
REMARKS String => explanatory comment on the table
*
*
*
The valid values for the types parameter are:
* "TABLE", "INDEX", "SEQUENCE", "VIEW", "TYPE"
* "SYSTEM TABLE", "SYSTEM INDEX", "SYSTEM VIEW",
* "SYSTEM TOAST TABLE", "SYSTEM TOAST INDEX",
* "TEMPORARY TABLE", "TEMPORARY VIEW", "TEMPORARY INDEX",
* "TEMPORARY SEQUENCE", "FOREIGN TABLE".
*
* @param catalog a catalog name; For org.postgresql, this is ignored, and
* should be set to null
* @param schemaPattern a schema name pattern
* @param tableNamePattern a table name pattern. For all tables this should be "%"
* @param types a list of table types to include; null returns
* all types
* @return each row is a table description
* @exception SQLException if a database-access error occurs.
*/
public java.sql.ResultSet getTables(String catalog, String schemaPattern, String tableNamePattern, String types[]) throws SQLException
{
String select;
String orderby;
String useSchemas;
if (connection.haveMinimumServerVersion("7.3"))
{
useSchemas = "SCHEMAS";
select = "SELECT NULL AS TABLE_CAT, n.nspname AS TABLE_SCHEM, c.relname AS TABLE_NAME, " +
" CASE n.nspname ~ '^pg_' OR n.nspname = 'information_schema' " +
" WHEN true THEN CASE " +
" WHEN n.nspname = 'pg_catalog' OR n.nspname = 'information_schema' THEN CASE c.relkind " +
" WHEN 'r' THEN 'SYSTEM TABLE' " +
" WHEN 'v' THEN 'SYSTEM VIEW' " +
" WHEN 'i' THEN 'SYSTEM INDEX' " +
" ELSE NULL " +
" END " +
" WHEN n.nspname = 'pg_toast' THEN CASE c.relkind " +
" WHEN 'r' THEN 'SYSTEM TOAST TABLE' " +
" WHEN 'i' THEN 'SYSTEM TOAST INDEX' " +
" ELSE NULL " +
" END " +
" ELSE CASE c.relkind " +
" WHEN 'r' THEN 'TEMPORARY TABLE' " +
" WHEN 'i' THEN 'TEMPORARY INDEX' " +
" WHEN 'S' THEN 'TEMPORARY SEQUENCE' " +
" WHEN 'v' THEN 'TEMPORARY VIEW' " +
" ELSE NULL " +
" END " +
" END " +
" WHEN false THEN CASE c.relkind " +
" WHEN 'r' THEN 'TABLE' " +
" WHEN 'i' THEN 'INDEX' " +
" WHEN 'S' THEN 'SEQUENCE' " +
" WHEN 'v' THEN 'VIEW' " +
" WHEN 'c' THEN 'TYPE' " +
" WHEN 'f' THEN 'FOREIGN TABLE' " +
" ELSE NULL " +
" END " +
" ELSE NULL " +
" END " +
" AS TABLE_TYPE, d.description AS REMARKS " +
" FROM pg_catalog.pg_namespace n, pg_catalog.pg_class c " +
" LEFT JOIN pg_catalog.pg_description d ON (c.oid = d.objoid AND d.objsubid = 0) " +
" LEFT JOIN pg_catalog.pg_class dc ON (d.classoid=dc.oid AND dc.relname='pg_class') " +
" LEFT JOIN pg_catalog.pg_namespace dn ON (dn.oid=dc.relnamespace AND dn.nspname='pg_catalog') " +
" WHERE c.relnamespace = n.oid ";
if (schemaPattern != null && !"".equals(schemaPattern))
{
select += " AND n.nspname LIKE " + escapeQuotes(schemaPattern);
}
orderby = " ORDER BY TABLE_TYPE,TABLE_SCHEM,TABLE_NAME ";
}
else
{
useSchemas = "NOSCHEMAS";
String tableType = "" +
" CASE c.relname ~ '^pg_' " +
" WHEN true THEN CASE c.relname ~ '^pg_toast_' " +
" WHEN true THEN CASE c.relkind " +
" WHEN 'r' THEN 'SYSTEM TOAST TABLE' " +
" WHEN 'i' THEN 'SYSTEM TOAST INDEX' " +
" ELSE NULL " +
" END " +
" WHEN false THEN CASE c.relname ~ '^pg_temp_' " +
" WHEN true THEN CASE c.relkind " +
" WHEN 'r' THEN 'TEMPORARY TABLE' " +
" WHEN 'i' THEN 'TEMPORARY INDEX' " +
" WHEN 'S' THEN 'TEMPORARY SEQUENCE' " +
" WHEN 'v' THEN 'TEMPORARY VIEW' " +
" ELSE NULL " +
" END " +
" WHEN false THEN CASE c.relkind " +
" WHEN 'r' THEN 'SYSTEM TABLE' " +
" WHEN 'v' THEN 'SYSTEM VIEW' " +
" WHEN 'i' THEN 'SYSTEM INDEX' " +
" ELSE NULL " +
" END " +
" ELSE NULL " +
" END " +
" ELSE NULL " +
" END " +
" WHEN false THEN CASE c.relkind " +
" WHEN 'r' THEN 'TABLE' " +
" WHEN 'i' THEN 'INDEX' " +
" WHEN 'S' THEN 'SEQUENCE' " +
" WHEN 'v' THEN 'VIEW' " +
" WHEN 'c' THEN 'TYPE' " +
" ELSE NULL " +
" END " +
" ELSE NULL " +
" END ";
orderby = " ORDER BY TABLE_TYPE,TABLE_NAME ";
if (connection.haveMinimumServerVersion("7.2"))
{
select = "SELECT NULL AS TABLE_CAT, NULL AS TABLE_SCHEM, c.relname AS TABLE_NAME, " + tableType + " AS TABLE_TYPE, d.description AS REMARKS " +
" FROM pg_class c " +
" LEFT JOIN pg_description d ON (c.oid=d.objoid AND d.objsubid = 0) " +
" LEFT JOIN pg_class dc ON (d.classoid = dc.oid AND dc.relname='pg_class') " +
" WHERE true ";
}
else if (connection.haveMinimumServerVersion("7.1"))
{
select = "SELECT NULL AS TABLE_CAT, NULL AS TABLE_SCHEM, c.relname AS TABLE_NAME, " + tableType + " AS TABLE_TYPE, d.description AS REMARKS " +
" FROM pg_class c " +
" LEFT JOIN pg_description d ON (c.oid=d.objoid) " +
" WHERE true ";
}
else
{
select = "SELECT NULL AS TABLE_CAT, NULL AS TABLE_SCHEM, c.relname AS TABLE_NAME, " + tableType + " AS TABLE_TYPE, NULL AS REMARKS " +
" FROM pg_class c " +
" WHERE true ";
}
}
if (tableNamePattern != null && !"".equals(tableNamePattern))
{
select += " AND c.relname LIKE " + escapeQuotes(tableNamePattern);
}
if (types != null) {
select += " AND (false ";
for (int i = 0; i < types.length; i++)
{
Map clauses = (Map)tableTypeClauses.get(types[i]);
if (clauses != null)
{
String clause = (String)clauses.get(useSchemas);
select += " OR ( " + clause + " ) ";
}
}
select += ") ";
}
String sql = select + orderby;
return createMetaDataStatement().executeQuery(sql);
}
private static final Map tableTypeClauses;
static {
tableTypeClauses = new HashMap();
Map ht = new HashMap();
tableTypeClauses.put("TABLE", ht);
ht.put("SCHEMAS", "c.relkind = 'r' AND n.nspname !~ '^pg_' AND n.nspname <> 'information_schema'");
ht.put("NOSCHEMAS", "c.relkind = 'r' AND c.relname !~ '^pg_'");
ht = new HashMap();
tableTypeClauses.put("VIEW", ht);
ht.put("SCHEMAS", "c.relkind = 'v' AND n.nspname <> 'pg_catalog' AND n.nspname <> 'information_schema'");
ht.put("NOSCHEMAS", "c.relkind = 'v' AND c.relname !~ '^pg_'");
ht = new HashMap();
tableTypeClauses.put("INDEX", ht);
ht.put("SCHEMAS", "c.relkind = 'i' AND n.nspname !~ '^pg_' AND n.nspname <> 'information_schema'");
ht.put("NOSCHEMAS", "c.relkind = 'i' AND c.relname !~ '^pg_'");
ht = new HashMap();
tableTypeClauses.put("SEQUENCE", ht);
ht.put("SCHEMAS", "c.relkind = 'S'");
ht.put("NOSCHEMAS", "c.relkind = 'S'");
ht = new HashMap();
tableTypeClauses.put("TYPE", ht);
ht.put("SCHEMAS", "c.relkind = 'c' AND n.nspname !~ '^pg_' AND n.nspname <> 'information_schema'");
ht.put("NOSCHEMAS", "c.relkind = 'c' AND c.relname !~ '^pg_'");
ht = new HashMap();
tableTypeClauses.put("SYSTEM TABLE", ht);
ht.put("SCHEMAS", "c.relkind = 'r' AND (n.nspname = 'pg_catalog' OR n.nspname = 'information_schema')");
ht.put("NOSCHEMAS", "c.relkind = 'r' AND c.relname ~ '^pg_' AND c.relname !~ '^pg_toast_' AND c.relname !~ '^pg_temp_'");
ht = new HashMap();
tableTypeClauses.put("SYSTEM TOAST TABLE", ht);
ht.put("SCHEMAS", "c.relkind = 'r' AND n.nspname = 'pg_toast'");
ht.put("NOSCHEMAS", "c.relkind = 'r' AND c.relname ~ '^pg_toast_'");
ht = new HashMap();
tableTypeClauses.put("SYSTEM TOAST INDEX", ht);
ht.put("SCHEMAS", "c.relkind = 'i' AND n.nspname = 'pg_toast'");
ht.put("NOSCHEMAS", "c.relkind = 'i' AND c.relname ~ '^pg_toast_'");
ht = new HashMap();
tableTypeClauses.put("SYSTEM VIEW", ht);
ht.put("SCHEMAS", "c.relkind = 'v' AND (n.nspname = 'pg_catalog' OR n.nspname = 'information_schema') ");
ht.put("NOSCHEMAS", "c.relkind = 'v' AND c.relname ~ '^pg_'");
ht = new HashMap();
tableTypeClauses.put("SYSTEM INDEX", ht);
ht.put("SCHEMAS", "c.relkind = 'i' AND (n.nspname = 'pg_catalog' OR n.nspname = 'information_schema') ");
ht.put("NOSCHEMAS", "c.relkind = 'v' AND c.relname ~ '^pg_' AND c.relname !~ '^pg_toast_' AND c.relname !~ '^pg_temp_'");
ht = new HashMap();
tableTypeClauses.put("TEMPORARY TABLE", ht);
ht.put("SCHEMAS", "c.relkind = 'r' AND n.nspname ~ '^pg_temp_' ");
ht.put("NOSCHEMAS", "c.relkind = 'r' AND c.relname ~ '^pg_temp_' ");
ht = new HashMap();
tableTypeClauses.put("TEMPORARY INDEX", ht);
ht.put("SCHEMAS", "c.relkind = 'i' AND n.nspname ~ '^pg_temp_' ");
ht.put("NOSCHEMAS", "c.relkind = 'i' AND c.relname ~ '^pg_temp_' ");
ht = new HashMap();
tableTypeClauses.put("TEMPORARY VIEW", ht);
ht.put("SCHEMAS", "c.relkind = 'v' AND n.nspname ~ '^pg_temp_' ");
ht.put("NOSCHEMAS", "c.relkind = 'v' AND c.relname ~ '^pg_temp_' ");
ht = new HashMap();
tableTypeClauses.put("TEMPORARY SEQUENCE", ht);
ht.put("SCHEMAS", "c.relkind = 'S' AND n.nspname ~ '^pg_temp_' ");
ht.put("NOSCHEMAS", "c.relkind = 'S' AND c.relname ~ '^pg_temp_' ");
ht = new HashMap();
tableTypeClauses.put("FOREIGN TABLE", ht);
ht.put("SCHEMAS", "c.relkind = 'f'");
ht.put("NOSCHEMAS", "c.relkind = 'f'");
}
/*
* Get the schema names available in this database. The results
* are ordered by schema name.
*
*
The schema column is:
*
*
TABLE_SCHEM String => schema name
*
*
* @return ResultSet each row has a single String column that is a
* schema name
*/
public java.sql.ResultSet getSchemas() throws SQLException
{
return getSchemas(2, null, null);
}
protected ResultSet getSchemas(int jdbcVersion, String catalog, String schemaPattern) throws SQLException {
String sql;
// Show only the users temp schemas, but not other peoples
// because they can't access any objects in them.
if (connection.haveMinimumServerVersion("7.3"))
{
// 7.3 can't extract elements from an array returned by
// a function, so we've got to coerce it to text and then
// hack it up with a regex.
String tempSchema = "substring(textin(array_out(pg_catalog.current_schemas(true))) from '{(pg_temp_[0-9]+),')";
if (connection.haveMinimumServerVersion("7.4")) {
tempSchema = "(pg_catalog.current_schemas(true))[1]";
}
sql = "SELECT nspname AS TABLE_SCHEM ";
if (jdbcVersion >= 3)
sql += ", NULL AS TABLE_CATALOG ";
sql += " FROM pg_catalog.pg_namespace WHERE nspname <> 'pg_toast' AND (nspname !~ '^pg_temp_' OR nspname = " + tempSchema + ") AND (nspname !~ '^pg_toast_temp_' OR nspname = replace(" + tempSchema + ", 'pg_temp_', 'pg_toast_temp_')) ";
if (schemaPattern != null && !"".equals(schemaPattern))
{
sql += " AND nspname LIKE " + escapeQuotes(schemaPattern);
}
sql += " ORDER BY TABLE_SCHEM";
}
else
{
sql = "SELECT ''::text AS TABLE_SCHEM ";
if (jdbcVersion >= 3) {
sql += ", NULL AS TABLE_CATALOG ";
}
if (schemaPattern != null)
{
sql += " WHERE ''::text LIKE " + escapeQuotes(schemaPattern);
}
}
return createMetaDataStatement().executeQuery(sql);
}
/*
* Get the catalog names available in this database. The results
* are ordered by catalog name.
*
* Postgresql does not support multiple catalogs from a single
* connection, so to reduce confusion we only return the current
* catalog.
*
*
The catalog column is:
*
*
TABLE_CAT String => catalog name
*
*
* @return ResultSet each row has a single String column that is a
* catalog name
*/
public java.sql.ResultSet getCatalogs() throws SQLException
{
Field f[] = new Field[1];
List v = new ArrayList();
f[0] = new Field("TABLE_CAT", Oid.VARCHAR);
byte[][] tuple = new byte[1][];
tuple[0] = connection.encodeString(connection.getCatalog());
v.add(tuple);
return (ResultSet) ((BaseStatement)createMetaDataStatement()).createDriverResultSet(f, v);
}
/*
* Get the table types available in this database. The results
* are ordered by table type.
*
*
*
* @return ResultSet each row has a single String column that is a
* table type
*/
public java.sql.ResultSet getTableTypes() throws SQLException
{
String types[] = new String[tableTypeClauses.size()];
Iterator e = tableTypeClauses.keySet().iterator();
int i = 0;
while (e.hasNext())
{
types[i++] = (String)e.next();
}
sortStringArray(types);
Field f[] = new Field[1];
List v = new ArrayList();
f[0] = new Field("TABLE_TYPE", Oid.VARCHAR);
for (i = 0; i < types.length; i++)
{
byte[][] tuple = new byte[1][];
tuple[0] = connection.encodeString(types[i]);
v.add(tuple);
}
return (ResultSet) ((BaseStatement)createMetaDataStatement()).createDriverResultSet(f, v);
}
protected java.sql.ResultSet getColumns(int jdbcVersion, String catalog, String schemaPattern, String tableNamePattern, String columnNamePattern) throws SQLException
{
int numberOfFields;
if (jdbcVersion >= 4) {
numberOfFields = 23;
} else if (jdbcVersion >= 3) {
numberOfFields = 22;
} else {
numberOfFields = 18;
}
List v = new ArrayList(); // The new ResultSet tuple stuff
Field f[] = new Field[numberOfFields]; // The field descriptors for the new ResultSet
f[0] = new Field("TABLE_CAT", Oid.VARCHAR);
f[1] = new Field("TABLE_SCHEM", Oid.VARCHAR);
f[2] = new Field("TABLE_NAME", Oid.VARCHAR);
f[3] = new Field("COLUMN_NAME", Oid.VARCHAR);
f[4] = new Field("DATA_TYPE", Oid.INT2);
f[5] = new Field("TYPE_NAME", Oid.VARCHAR);
f[6] = new Field("COLUMN_SIZE", Oid.INT4);
f[7] = new Field("BUFFER_LENGTH", Oid.VARCHAR);
f[8] = new Field("DECIMAL_DIGITS", Oid.INT4);
f[9] = new Field("NUM_PREC_RADIX", Oid.INT4);
f[10] = new Field("NULLABLE", Oid.INT4);
f[11] = new Field("REMARKS", Oid.VARCHAR);
f[12] = new Field("COLUMN_DEF", Oid.VARCHAR);
f[13] = new Field("SQL_DATA_TYPE", Oid.INT4);
f[14] = new Field("SQL_DATETIME_SUB", Oid.INT4);
f[15] = new Field("CHAR_OCTET_LENGTH", Oid.VARCHAR);
f[16] = new Field("ORDINAL_POSITION", Oid.INT4);
f[17] = new Field("IS_NULLABLE", Oid.VARCHAR);
if (jdbcVersion >= 3) {
f[18] = new Field("SCOPE_CATLOG", Oid.VARCHAR);
f[19] = new Field("SCOPE_SCHEMA", Oid.VARCHAR);
f[20] = new Field("SCOPE_TABLE", Oid.VARCHAR);
f[21] = new Field("SOURCE_DATA_TYPE", Oid.INT2);
}
if (jdbcVersion >= 4) {
f[22] = new Field("IS_AUTOINCREMENT", Oid.VARCHAR);
}
String sql;
if (connection.haveMinimumServerVersion("7.3"))
{
// a.attnum isn't decremented when preceding columns are dropped,
// so the only way to calculate the correct column number is with
// window functions, new in 8.4.
//
// We want to push as much predicate information below the window
// function as possible (schema/table names), but must leave
// column name outside so we correctly count the other columns.
//
if (connection.haveMinimumServerVersion("8.4"))
sql = "SELECT * FROM (";
else
sql = "";
sql += "SELECT n.nspname,c.relname,a.attname,a.atttypid,a.attnotnull OR (t.typtype = 'd' AND t.typnotnull) AS attnotnull,a.atttypmod,a.attlen,";
if (connection.haveMinimumServerVersion("8.4"))
sql += "row_number() OVER (PARTITION BY a.attrelid ORDER BY a.attnum) AS attnum, ";
else
sql += "a.attnum,";
sql += "pg_catalog.pg_get_expr(def.adbin, def.adrelid) AS adsrc,dsc.description,t.typbasetype,t.typtype " +
" FROM pg_catalog.pg_namespace n " +
" JOIN pg_catalog.pg_class c ON (c.relnamespace = n.oid) " +
" JOIN pg_catalog.pg_attribute a ON (a.attrelid=c.oid) " +
" JOIN pg_catalog.pg_type t ON (a.atttypid = t.oid) " +
" LEFT JOIN pg_catalog.pg_attrdef def ON (a.attrelid=def.adrelid AND a.attnum = def.adnum) " +
" LEFT JOIN pg_catalog.pg_description dsc ON (c.oid=dsc.objoid AND a.attnum = dsc.objsubid) " +
" LEFT JOIN pg_catalog.pg_class dc ON (dc.oid=dsc.classoid AND dc.relname='pg_class') " +
" LEFT JOIN pg_catalog.pg_namespace dn ON (dc.relnamespace=dn.oid AND dn.nspname='pg_catalog') " +
" WHERE a.attnum > 0 AND NOT a.attisdropped ";
if (schemaPattern != null && !"".equals(schemaPattern))
{
sql += " AND n.nspname LIKE " + escapeQuotes(schemaPattern);
}
if (tableNamePattern != null && !"".equals(tableNamePattern))
{
sql += " AND c.relname LIKE " + escapeQuotes(tableNamePattern);
}
if (connection.haveMinimumServerVersion("8.4"))
sql += ") c WHERE true ";
}
else if (connection.haveMinimumServerVersion("7.2"))
{
sql = "SELECT NULL::text AS nspname,c.relname,a.attname,a.atttypid,a.attnotnull,a.atttypmod,a.attlen,a.attnum,pg_get_expr(def.adbin,def.adrelid) AS adsrc,dsc.description,NULL::oid AS typbasetype,t.typtype " +
" FROM pg_class c " +
" JOIN pg_attribute a ON (a.attrelid=c.oid) " +
" JOIN pg_type t ON (a.atttypid = t.oid) " +
" LEFT JOIN pg_attrdef def ON (a.attrelid=def.adrelid AND a.attnum = def.adnum) " +
" LEFT JOIN pg_description dsc ON (c.oid=dsc.objoid AND a.attnum = dsc.objsubid) " +
" LEFT JOIN pg_class dc ON (dc.oid=dsc.classoid AND dc.relname='pg_class') " +
" WHERE a.attnum > 0 ";
}
else if (connection.haveMinimumServerVersion("7.1"))
{
sql = "SELECT NULL::text AS nspname,c.relname,a.attname,a.atttypid,a.attnotnull,a.atttypmod,a.attlen,a.attnum,def.adsrc,dsc.description,NULL::oid AS typbasetype, 'b' AS typtype " +
" FROM pg_class c " +
" JOIN pg_attribute a ON (a.attrelid=c.oid) " +
" LEFT JOIN pg_attrdef def ON (a.attrelid=def.adrelid AND a.attnum = def.adnum) " +
" LEFT JOIN pg_description dsc ON (a.oid=dsc.objoid) " +
" WHERE a.attnum > 0 ";
}
else
{
// if < 7.1 then don't get defaults or descriptions.
sql = "SELECT NULL::text AS nspname,c.relname,a.attname,a.atttypid,a.attnotnull,a.atttypmod,a.attlen,a.attnum,NULL AS adsrc,NULL AS description,NULL AS typbasetype, 'b' AS typtype " +
" FROM pg_class c, pg_attribute a " +
" WHERE a.attrelid=c.oid AND a.attnum > 0 ";
}
if (!connection.haveMinimumServerVersion("7.3") && tableNamePattern != null && !"".equals(tableNamePattern))
{
sql += " AND c.relname LIKE " + escapeQuotes(tableNamePattern);
}
if (columnNamePattern != null && !"".equals(columnNamePattern))
{
sql += " AND attname LIKE " + escapeQuotes(columnNamePattern);
}
sql += " ORDER BY nspname,c.relname,attnum ";
ResultSet rs = connection.createStatement().executeQuery(sql);
while (rs.next())
{
byte[][] tuple = new byte[numberOfFields][];
int typeOid = (int)rs.getLong("atttypid");
int typeMod = rs.getInt("atttypmod");
tuple[0] = null; // Catalog name, not supported
tuple[1] = rs.getBytes("nspname"); // Schema
tuple[2] = rs.getBytes("relname"); // Table name
tuple[3] = rs.getBytes("attname"); // Column name
String typtype = rs.getString("typtype");
int sqlType;
if ("c".equals(typtype)) {
sqlType = Types.STRUCT;
} else if ("d".equals(typtype)) {
sqlType = Types.DISTINCT;
} else {
sqlType = connection.getTypeInfo().getSQLType(typeOid);
}
tuple[4] = connection.encodeString(Integer.toString(sqlType));
String pgType = connection.getTypeInfo().getPGType(typeOid);
tuple[5] = connection.encodeString(pgType); // Type name
tuple[7] = null; // Buffer length
String defval = rs.getString("adsrc");
if ( defval != null )
{
if ( pgType.equals("int4") )
{
if (defval.indexOf("nextval(") != -1)
tuple[5] = connection.encodeString("serial"); // Type name == serial
}
else if ( pgType.equals("int8") )
{
if (defval.indexOf("nextval(") != -1)
tuple[5] = connection.encodeString("bigserial"); // Type name == bigserial
}
}
int decimalDigits = connection.getTypeInfo().getScale(typeOid, typeMod);
int columnSize = connection.getTypeInfo().getPrecision(typeOid, typeMod);
if (columnSize == 0) {
columnSize = connection.getTypeInfo().getDisplaySize(typeOid, typeMod);
}
tuple[6] = connection.encodeString(Integer.toString(columnSize));
tuple[8] = connection.encodeString(Integer.toString(decimalDigits));
// Everything is base 10 unless we override later.
tuple[9] = connection.encodeString("10");
if (pgType.equals("bit") || pgType.equals("varbit"))
{
tuple[9] = connection.encodeString("2");
}
tuple[10] = connection.encodeString(Integer.toString(rs.getBoolean("attnotnull") ? java.sql.DatabaseMetaData.columnNoNulls : java.sql.DatabaseMetaData.columnNullable)); // Nullable
tuple[11] = rs.getBytes("description"); // Description (if any)
tuple[12] = rs.getBytes("adsrc"); // Column default
tuple[13] = null; // sql data type (unused)
tuple[14] = null; // sql datetime sub (unused)
tuple[15] = tuple[6]; // char octet length
tuple[16] = connection.encodeString(String.valueOf(rs.getInt("attnum"))); // ordinal position
tuple[17] = connection.encodeString(rs.getBoolean("attnotnull") ? "NO" : "YES"); // Is nullable
if (jdbcVersion >= 3) {
int baseTypeOid = (int) rs.getLong("typbasetype");
tuple[18] = null; // SCOPE_CATLOG
tuple[19] = null; // SCOPE_SCHEMA
tuple[20] = null; // SCOPE_TABLE
tuple[21] = baseTypeOid == 0 ? null : connection.encodeString(Integer.toString(connection.getTypeInfo().getSQLType(baseTypeOid))); // SOURCE_DATA_TYPE
}
if (jdbcVersion >= 4) {
String autoinc = "NO";
if (defval != null && defval.indexOf("nextval(") != -1) {
autoinc = "YES";
}
tuple[22] = connection.encodeString(autoinc);
}
v.add(tuple);
}
rs.close();
return (ResultSet) ((BaseStatement)createMetaDataStatement()).createDriverResultSet(f, v);
}
/*
* Get a description of table columns available in a catalog.
*
*
Only column descriptions matching the catalog, schema, table
* and column name criteria are returned. They are ordered by
* TABLE_SCHEM, TABLE_NAME and ORDINAL_POSITION.
*
*
Each column description has the following columns:
*
*
TABLE_CAT String => table catalog (may be null)
*
TABLE_SCHEM String => table schema (may be null)
*
TABLE_NAME String => table name
*
COLUMN_NAME String => column name
*
DATA_TYPE short => SQL type from java.sql.Types
*
TYPE_NAME String => Data source dependent type name
*
COLUMN_SIZE int => column size. For char or date
* types this is the maximum number of characters, for numeric or
* decimal types this is precision.
*
BUFFER_LENGTH is not used.
*
DECIMAL_DIGITS int => the number of fractional digits
*
NUM_PREC_RADIX int => Radix (typically either 10 or 2)
*
NULLABLE int => is NULL allowed?
*
*
columnNoNulls - might not allow NULL values
*
columnNullable - definitely allows NULL values
*
columnNullableUnknown - nullability unknown
*
*
REMARKS String => comment describing column (may be null)
*
COLUMN_DEF String => default value (may be null)
*
SQL_DATA_TYPE int => unused
*
SQL_DATETIME_SUB int => unused
*
CHAR_OCTET_LENGTH int => for char types the
* maximum number of bytes in the column
*
ORDINAL_POSITION int => index of column in table
* (starting at 1)
*
IS_NULLABLE String => "NO" means column definitely
* does not allow NULL values; "YES" means the column might
* allow NULL values. An empty string means nobody knows.
*
*
* @param catalog a catalog name; "" retrieves those without a catalog
* @param schemaPattern a schema name pattern; "" retrieves those
* without a schema
* @param tableNamePattern a table name pattern
* @param columnNamePattern a column name pattern
* @return ResultSet each row is a column description
* @see #getSearchStringEscape
*/
public java.sql.ResultSet getColumns(String catalog, String schemaPattern, String tableNamePattern, String columnNamePattern) throws SQLException
{
return getColumns(2, catalog, schemaPattern, tableNamePattern, columnNamePattern);
}
/*
* Get a description of the access rights for a table's columns.
*
*
Only privileges matching the column name criteria are
* returned. They are ordered by COLUMN_NAME and PRIVILEGE.
*
*
Each privilige description has the following columns:
*
*
TABLE_CAT String => table catalog (may be null)
*
TABLE_SCHEM String => table schema (may be null)
*
TABLE_NAME String => table name
*
COLUMN_NAME String => column name
*
GRANTOR => grantor of access (may be null)
*
GRANTEE String => grantee of access
*
PRIVILEGE String => name of access (SELECT,
* INSERT, UPDATE, REFRENCES, ...)
*
IS_GRANTABLE String => "YES" if grantee is permitted
* to grant to others; "NO" if not; null if unknown
*
*
* @param catalog a catalog name; "" retrieves those without a catalog
* @param schema a schema name; "" retrieves those without a schema
* @param table a table name
* @param columnNamePattern a column name pattern
* @return ResultSet each row is a column privilege description
* @see #getSearchStringEscape
*/
public java.sql.ResultSet getColumnPrivileges(String catalog, String schema, String table, String columnNamePattern) throws SQLException
{
Field f[] = new Field[8];
List v = new ArrayList();
if (table == null)
table = "%";
if (columnNamePattern == null)
columnNamePattern = "%";
f[0] = new Field("TABLE_CAT", Oid.VARCHAR);
f[1] = new Field("TABLE_SCHEM", Oid.VARCHAR);
f[2] = new Field("TABLE_NAME", Oid.VARCHAR);
f[3] = new Field("COLUMN_NAME", Oid.VARCHAR);
f[4] = new Field("GRANTOR", Oid.VARCHAR);
f[5] = new Field("GRANTEE", Oid.VARCHAR);
f[6] = new Field("PRIVILEGE", Oid.VARCHAR);
f[7] = new Field("IS_GRANTABLE", Oid.VARCHAR);
String sql;
if (connection.haveMinimumServerVersion("8.4"))
{
sql = "SELECT n.nspname,c.relname,r.rolname,c.relacl,a.attacl,a.attname " +
" FROM pg_catalog.pg_namespace n, pg_catalog.pg_class c, pg_catalog.pg_roles r, pg_catalog.pg_attribute a " +
" WHERE c.relnamespace = n.oid " +
" AND c.relowner = r.oid " +
" AND c.oid = a.attrelid " +
" AND c.relkind = 'r' " +
" AND a.attnum > 0 AND NOT a.attisdropped ";
if (schema != null && !"".equals(schema))
{
sql += " AND n.nspname = " + escapeQuotes(schema);
}
}
else if (connection.haveMinimumServerVersion("7.3"))
{
sql = "SELECT n.nspname,c.relname,r.rolname,c.relacl,a.attname " +
" FROM pg_catalog.pg_namespace n, pg_catalog.pg_class c, pg_catalog.pg_roles r, pg_catalog.pg_attribute a " +
" WHERE c.relnamespace = n.oid " +
" AND c.relowner = r.oid " +
" AND c.oid = a.attrelid " +
" AND c.relkind = 'r' " +
" AND a.attnum > 0 AND NOT a.attisdropped ";
if (schema != null && !"".equals(schema))
{
sql += " AND n.nspname = " + escapeQuotes(schema);
}
}
else
{
sql = "SELECT NULL::text AS nspname,c.relname,u.usename,c.relacl,a.attname " +
"FROM pg_class c, pg_user u,pg_attribute a " +
" WHERE u.usesysid = c.relowner " +
" AND c.oid = a.attrelid " +
" AND a.attnum > 0 " +
" AND c.relkind = 'r' ";
}
sql += " AND c.relname = " + escapeQuotes(table);
if (columnNamePattern != null && !"".equals(columnNamePattern))
{
sql += " AND a.attname LIKE " + escapeQuotes(columnNamePattern);
}
sql += " ORDER BY attname ";
ResultSet rs = connection.createStatement().executeQuery(sql);
while (rs.next())
{
byte schemaName[] = rs.getBytes("nspname");
byte tableName[] = rs.getBytes("relname");
byte column[] = rs.getBytes("attname");
String owner = rs.getString("rolname");
String relAcl = rs.getString("relacl");
Map permissions = parseACL(relAcl, owner);
if (connection.haveMinimumServerVersion("8.4"))
{
String acl = rs.getString("attacl");
Map relPermissions = parseACL(acl, owner);
permissions.putAll(relPermissions);
}
String permNames[] = new String[permissions.size()];
Iterator e = permissions.keySet().iterator();
int i = 0;
while (e.hasNext())
{
permNames[i++] = (String)e.next();
}
sortStringArray(permNames);
for (i = 0; i < permNames.length; i++)
{
byte[] privilege = connection.encodeString(permNames[i]);
Map grantees = (Map)permissions.get(permNames[i]);
String granteeUsers[] = new String[grantees.size()];
Iterator g = grantees.keySet().iterator();
int k = 0;
while (g.hasNext()){
granteeUsers[k++] = (String)g.next();
}
for (int j = 0; j < grantees.size(); j++)
{
List grantor = (List)grantees.get(granteeUsers[j]);
String grantee = (String)granteeUsers[j];
for (int l = 0; l < grantor.size(); l++) {
String[] grants = (String[])grantor.get(l);
String grantable = owner.equals(grantee) ? "YES" : grants[1];
byte[][] tuple = new byte[8][];
tuple[0] = null;
tuple[1] = schemaName;
tuple[2] = tableName;
tuple[3] = column;
tuple[4] = connection.encodeString(grants[0]);
tuple[5] = connection.encodeString(grantee);
tuple[6] = privilege;
tuple[7] = connection.encodeString(grantable);
v.add(tuple);
}
}
}
}
rs.close();
return (ResultSet) ((BaseStatement)createMetaDataStatement()).createDriverResultSet(f, v);
}
/*
* Get a description of the access rights for each table available
* in a catalog.
*
* This method is currently unimplemented.
*
*
Only privileges matching the schema and table name
* criteria are returned. They are ordered by TABLE_SCHEM,
* TABLE_NAME, and PRIVILEGE.
*
*
Each privilege description has the following columns:
*
*
TABLE_CAT String => table catalog (may be null)
*
TABLE_SCHEM String => table schema (may be null)
*
TABLE_NAME String => table name
*
GRANTOR => grantor of access (may be null)
*
GRANTEE String => grantee of access
*
PRIVILEGE String => name of access (SELECT,
* INSERT, UPDATE, REFRENCES, ...)
*
IS_GRANTABLE String => "YES" if grantee is permitted
* to grant to others; "NO" if not; null if unknown
*
*
* @param catalog a catalog name; "" retrieves those without a catalog
* @param schemaPattern a schema name pattern; "" retrieves those
* without a schema
* @param tableNamePattern a table name pattern
* @return ResultSet each row is a table privilege description
* @see #getSearchStringEscape
*/
public java.sql.ResultSet getTablePrivileges(String catalog, String schemaPattern, String tableNamePattern) throws SQLException
{
Field f[] = new Field[7];
List v = new ArrayList();
f[0] = new Field("TABLE_CAT", Oid.VARCHAR);
f[1] = new Field("TABLE_SCHEM", Oid.VARCHAR);
f[2] = new Field("TABLE_NAME", Oid.VARCHAR);
f[3] = new Field("GRANTOR", Oid.VARCHAR);
f[4] = new Field("GRANTEE", Oid.VARCHAR);
f[5] = new Field("PRIVILEGE", Oid.VARCHAR);
f[6] = new Field("IS_GRANTABLE", Oid.VARCHAR);
String sql;
if (connection.haveMinimumServerVersion("7.3"))
{
sql = "SELECT n.nspname,c.relname,r.rolname,c.relacl " +
" FROM pg_catalog.pg_namespace n, pg_catalog.pg_class c, pg_catalog.pg_roles r " +
" WHERE c.relnamespace = n.oid " +
" AND c.relowner = r.oid " +
" AND c.relkind = 'r' ";
if (schemaPattern != null && !"".equals(schemaPattern))
{
sql += " AND n.nspname LIKE " + escapeQuotes(schemaPattern);
}
}
else
{
sql = "SELECT NULL::text AS nspname,c.relname,u.usename,c.relacl " +
"FROM pg_class c, pg_user u " +
" WHERE u.usesysid = c.relowner " +
" AND c.relkind = 'r' ";
}
if (tableNamePattern != null && !"".equals(tableNamePattern))
{
sql += " AND c.relname LIKE " + escapeQuotes(tableNamePattern);
}
sql += " ORDER BY nspname, relname ";
ResultSet rs = connection.createStatement().executeQuery(sql);
while (rs.next())
{
byte schema[] = rs.getBytes("nspname");
byte table[] = rs.getBytes("relname");
String owner = rs.getString("rolname");
String acl = rs.getString("relacl");
Map permissions = parseACL(acl, owner);
String permNames[] = new String[permissions.size()];
Iterator e = permissions.keySet().iterator();
int i = 0;
while (e.hasNext())
{
permNames[i++] = (String)e.next();
}
sortStringArray(permNames);
for (i = 0; i < permNames.length; i++)
{
byte[] privilege = connection.encodeString(permNames[i]);
Map grantees = (Map)permissions.get(permNames[i]);
String granteeUsers[] = new String[grantees.size()];
Iterator g = grantees.keySet().iterator();
int k = 0;
while (g.hasNext()){
granteeUsers[k++] = (String)g.next();
}
for (int j = 0; j < granteeUsers.length; j++)
{
List grants = (List)grantees.get(granteeUsers[j]);
String grantee = (String)granteeUsers[j];
for (int l = 0; l < grants.size(); l++) {
String[] grantTuple = (String[])grants.get(l);
// report the owner as grantor if it's missing
String grantor = grantTuple[0].equals(null) ? owner : grantTuple[0];
// owner always has grant privileges
String grantable = owner.equals(grantee) ? "YES" : grantTuple[1];
byte[][] tuple = new byte[7][];
tuple[0] = null;
tuple[1] = schema;
tuple[2] = table;
tuple[3] = connection.encodeString(grantor);
tuple[4] = connection.encodeString(grantee);
tuple[5] = privilege;
tuple[6] = connection.encodeString(grantable);
v.add(tuple);
}
}
}
}
rs.close();
return (ResultSet) ((BaseStatement)createMetaDataStatement()).createDriverResultSet(f, v);
}
private static void sortStringArray(String s[]) {
for (int i = 0; i < s.length - 1; i++)
{
for (int j = i + 1; j < s.length; j++)
{
if (s[i].compareTo(s[j]) > 0)
{
String tmp = s[i];
s[i] = s[j];
s[j] = tmp;
}
}
}
}
/**
* Parse an String of ACLs into a List of ACLs.
*/
private static List parseACLArray(String aclString) {
List acls = new ArrayList();
if (aclString == null || aclString.length() == 0)
{
return acls;
}
boolean inQuotes = false;
// start at 1 because of leading "{"
int beginIndex = 1;
char prevChar = ' ';
for (int i = beginIndex; i < aclString.length(); i++)
{
char c = aclString.charAt(i);
if (c == '"' && prevChar != '\\')
{
inQuotes = !inQuotes;
}
else if (c == ',' && !inQuotes)
{
acls.add(aclString.substring(beginIndex, i));
beginIndex = i + 1;
}
prevChar = c;
}
// add last element removing the trailing "}"
acls.add(aclString.substring(beginIndex, aclString.length() - 1));
// Strip out enclosing quotes, if any.
for (int i = 0; i < acls.size(); i++)
{
String acl = (String)acls.get(i);
if (acl.startsWith("\"") && acl.endsWith("\""))
{
acl = acl.substring(1, acl.length() - 1);
acls.set(i, acl);
}
}
return acls;
}
/**
* Add the user described by the given acl to the Lists of users
* with the privileges described by the acl.
*/
private void addACLPrivileges(String acl, Map privileges) {
int equalIndex = acl.lastIndexOf("=");
int slashIndex = acl.lastIndexOf("/");
if (equalIndex == -1)
return;
String user = acl.substring(0, equalIndex);
String grantor = null;
if (user.length() == 0)
{
user = "PUBLIC";
}
String privs;
if (slashIndex != -1) {
privs = acl.substring(equalIndex + 1, slashIndex);
grantor = acl.substring(slashIndex + 1, acl.length());
} else {
privs = acl.substring(equalIndex + 1, acl.length());
}
for (int i = 0; i < privs.length(); i++)
{
char c = privs.charAt(i);
if (c != '*') {
String sqlpriv;
String grantable;
if ( i < privs.length()-1 && privs.charAt(i + 1) == '*') {
grantable = "YES";
} else {
grantable = "NO";
}
switch (c)
{
case 'a':
sqlpriv = "INSERT";
break;
case 'r':
sqlpriv = "SELECT";
break;
case 'w':
sqlpriv = "UPDATE";
break;
case 'd':
sqlpriv = "DELETE";
break;
case 'D':
sqlpriv = "TRUNCATE";
break;
case 'R':
sqlpriv = "RULE";
break;
case 'x':
sqlpriv = "REFERENCES";
break;
case 't':
sqlpriv = "TRIGGER";
break;
// the following can't be granted to a table, but
// we'll keep them for completeness.
case 'X':
sqlpriv = "EXECUTE";
break;
case 'U':
sqlpriv = "USAGE";
break;
case 'C':
sqlpriv = "CREATE";
break;
case 'T':
sqlpriv = "CREATE TEMP";
break;
default:
sqlpriv = "UNKNOWN";
}
Map usersWithPermission = (Map)privileges.get(sqlpriv);
String[] grant = {grantor, grantable};
if (usersWithPermission == null) {
usersWithPermission = new HashMap();
List permissionByGrantor = new ArrayList();
permissionByGrantor.add(grant);
usersWithPermission.put(user, permissionByGrantor);
privileges.put(sqlpriv, usersWithPermission);
} else {
List permissionByGrantor = (List)usersWithPermission.get(user);
if (permissionByGrantor == null) {
permissionByGrantor = new ArrayList();
permissionByGrantor.add(grant);
usersWithPermission.put(user,permissionByGrantor);
} else {
permissionByGrantor.add(grant);
}
}
}
}
}
/**
* Take the a String representing an array of ACLs and return
* a Map mapping the SQL permission name to a List of
* usernames who have that permission.
*/
public Map parseACL(String aclArray, String owner) {
if (aclArray == null)
{
//null acl is a shortcut for owner having full privs
String perms = "arwdRxt";
if (connection.haveMinimumServerVersion("8.2")) {
// 8.2 Removed the separate RULE permission
perms = "arwdxt";
} else if (connection.haveMinimumServerVersion("8.4")) {
// 8.4 Added a separate TRUNCATE permission
perms = "arwdDxt";
}
aclArray = "{" + owner + "=" + perms + "/" + owner + "}";
}
List acls = parseACLArray(aclArray);
Map privileges = new HashMap();
for (int i = 0; i < acls.size(); i++)
{
String acl = (String)acls.get(i);
addACLPrivileges(acl, privileges);
}
return privileges;
}
/*
* Get a description of a table's optimal set of columns that
* uniquely identifies a row. They are ordered by SCOPE.
*
*
Each column description has the following columns:
*
*
SCOPE short => actual scope of result
*
*
bestRowTemporary - very temporary, while using row
*
bestRowTransaction - valid for remainder of current transaction
*
bestRowSession - valid for remainder of current session
*
*
COLUMN_NAME String => column name
*
DATA_TYPE short => SQL data type from java.sql.Types
*
TYPE_NAME String => Data source dependent type name
*
COLUMN_SIZE int => precision
*
BUFFER_LENGTH int => not used
*
DECIMAL_DIGITS short => scale
*
PSEUDO_COLUMN short => is this a pseudo column
* like an Oracle ROWID
*
*
bestRowUnknown - may or may not be pseudo column
*
bestRowNotPseudo - is NOT a pseudo column
*
bestRowPseudo - is a pseudo column
*
*
*
* @param catalog a catalog name; "" retrieves those without a catalog
* @param schema a schema name; "" retrieves those without a schema
* @param table a table name
* @param scope the scope of interest; use same values as SCOPE
* @param nullable include columns that are nullable?
* @return ResultSet each row is a column description
*/
// Implementation note: This is required for Borland's JBuilder to work
public java.sql.ResultSet getBestRowIdentifier(String catalog, String schema, String table, int scope, boolean nullable) throws SQLException
{
Field f[] = new Field[8];
List v = new ArrayList(); // The new ResultSet tuple stuff
f[0] = new Field("SCOPE", Oid.INT2);
f[1] = new Field("COLUMN_NAME", Oid.VARCHAR);
f[2] = new Field("DATA_TYPE", Oid.INT2);
f[3] = new Field("TYPE_NAME", Oid.VARCHAR);
f[4] = new Field("COLUMN_SIZE", Oid.INT4);
f[5] = new Field("BUFFER_LENGTH", Oid.INT4);
f[6] = new Field("DECIMAL_DIGITS", Oid.INT2);
f[7] = new Field("PSEUDO_COLUMN", Oid.INT2);
/* At the moment this simply returns a table's primary key,
* if there is one. I believe other unique indexes, ctid,
* and oid should also be considered. -KJ
*/
String sql;
if (connection.haveMinimumServerVersion("8.1"))
{
sql = "SELECT a.attname, a.atttypid, atttypmod "
+ "FROM pg_catalog.pg_class ct "
+ " JOIN pg_catalog.pg_attribute a ON (ct.oid = a.attrelid) "
+ " JOIN pg_catalog.pg_namespace n ON (ct.relnamespace = n.oid) "
+ " JOIN (SELECT i.indexrelid, i.indrelid, i.indisprimary, "
+ " information_schema._pg_expandarray(i.indkey) AS keys "
+ " FROM pg_catalog.pg_index i) i "
+ " ON (a.attnum = (i.keys).x AND a.attrelid = i.indrelid) "
+ "WHERE true ";
if (schema != null && !"".equals(schema))
{
sql += " AND n.nspname = " + escapeQuotes(schema);
}
}
else
{
String from;
String where = "";
if (connection.haveMinimumServerVersion("7.3"))
{
from = " FROM pg_catalog.pg_namespace n, pg_catalog.pg_class ct, pg_catalog.pg_class ci, pg_catalog.pg_attribute a, pg_catalog.pg_index i ";
where = " AND ct.relnamespace = n.oid ";
if (schema != null && !"".equals(schema))
{
where += " AND n.nspname = " + escapeQuotes(schema);
}
}
else
{
from = " FROM pg_class ct, pg_class ci, pg_attribute a, pg_index i ";
}
sql = "SELECT a.attname, a.atttypid, a.atttypmod " +
from +
" WHERE ct.oid=i.indrelid AND ci.oid=i.indexrelid " +
" AND a.attrelid=ci.oid " +
where;
}
sql += " AND ct.relname = " + escapeQuotes(table) +
" AND i.indisprimary " +
" ORDER BY a.attnum ";
ResultSet rs = connection.createStatement().executeQuery(sql);
while (rs.next())
{
byte tuple[][] = new byte[8][];
int typeOid = (int)rs.getLong("atttypid");
int typeMod = rs.getInt("atttypmod");
int decimalDigits = connection.getTypeInfo().getScale(typeOid, typeMod);
int columnSize = connection.getTypeInfo().getPrecision(typeOid, typeMod);
if (columnSize == 0) {
columnSize = connection.getTypeInfo().getDisplaySize(typeOid, typeMod);
}
tuple[0] = connection.encodeString(Integer.toString(scope));
tuple[1] = rs.getBytes("attname");
tuple[2] = connection.encodeString(Integer.toString(connection.getTypeInfo().getSQLType(typeOid)));
tuple[3] = connection.encodeString(connection.getTypeInfo().getPGType(typeOid));
tuple[4] = connection.encodeString(Integer.toString(columnSize));
tuple[5] = null; // unused
tuple[6] = connection.encodeString(Integer.toString(decimalDigits));
tuple[7] = connection.encodeString(Integer.toString(java.sql.DatabaseMetaData.bestRowNotPseudo));
v.add(tuple);
}
return (ResultSet) ((BaseStatement)createMetaDataStatement()).createDriverResultSet(f, v);
}
/*
* Get a description of a table's columns that are automatically
* updated when any value in a row is updated. They are
* unordered.
*
*
Each column description has the following columns:
*
*
SCOPE short => is not used
*
COLUMN_NAME String => column name
*
DATA_TYPE short => SQL data type from java.sql.Types
*
TYPE_NAME String => Data source dependent type name
*
COLUMN_SIZE int => precision
*
BUFFER_LENGTH int => length of column value in bytes
*
DECIMAL_DIGITS short => scale
*
PSEUDO_COLUMN short => is this a pseudo column
* like an Oracle ROWID
*
*
versionColumnUnknown - may or may not be pseudo column
*
versionColumnNotPseudo - is NOT a pseudo column
*
versionColumnPseudo - is a pseudo column
*
*
*
* @param catalog a catalog name; "" retrieves those without a catalog
* @param schema a schema name; "" retrieves those without a schema
* @param table a table name
* @return ResultSet each row is a column description
*/
public java.sql.ResultSet getVersionColumns(String catalog, String schema, String table) throws SQLException
{
Field f[] = new Field[8];
List v = new ArrayList(); // The new ResultSet tuple stuff
f[0] = new Field("SCOPE", Oid.INT2);
f[1] = new Field("COLUMN_NAME", Oid.VARCHAR);
f[2] = new Field("DATA_TYPE", Oid.INT2);
f[3] = new Field("TYPE_NAME", Oid.VARCHAR);
f[4] = new Field("COLUMN_SIZE", Oid.INT4);
f[5] = new Field("BUFFER_LENGTH", Oid.INT4);
f[6] = new Field("DECIMAL_DIGITS", Oid.INT2);
f[7] = new Field("PSEUDO_COLUMN", Oid.INT2);
byte tuple[][] = new byte[8][];
/* Postgresql does not have any column types that are
* automatically updated like some databases' timestamp type.
* We can't tell what rules or triggers might be doing, so we
* are left with the system columns that change on an update.
* An update may change all of the following system columns:
* ctid, xmax, xmin, cmax, and cmin. Depending on if we are
* in a transaction and wether we roll it back or not the
* only guaranteed change is to ctid. -KJ
*/
tuple[0] = null;
tuple[1] = connection.encodeString("ctid");
tuple[2] = connection.encodeString(Integer.toString(connection.getTypeInfo().getSQLType("tid")));
tuple[3] = connection.encodeString("tid");
tuple[4] = null;
tuple[5] = null;
tuple[6] = null;
tuple[7] = connection.encodeString(Integer.toString(java.sql.DatabaseMetaData.versionColumnPseudo));
v.add(tuple);
/* Perhaps we should check that the given
* catalog.schema.table actually exists. -KJ
*/
return (ResultSet) ((BaseStatement)createMetaDataStatement()).createDriverResultSet(f, v);
}
/*
* Get a description of a table's primary key columns. They
* are ordered by COLUMN_NAME.
*
*
Each column description has the following columns:
*
*
TABLE_CAT String => table catalog (may be null)
*
TABLE_SCHEM String => table schema (may be null)
*
TABLE_NAME String => table name
*
COLUMN_NAME String => column name
*
KEY_SEQ short => sequence number within primary key
*
PK_NAME String => primary key name (may be null)
*
*
* @param catalog a catalog name; "" retrieves those without a catalog
* @param schema a schema name pattern; "" retrieves those
* without a schema
* @param table a table name
* @return ResultSet each row is a primary key column description
*/
public java.sql.ResultSet getPrimaryKeys(String catalog, String schema, String table) throws SQLException
{
String sql;
if (connection.haveMinimumServerVersion("8.1"))
{
sql = "SELECT NULL AS TABLE_CAT, n.nspname AS TABLE_SCHEM, "
+ " ct.relname AS TABLE_NAME, a.attname AS COLUMN_NAME, "
+ " (i.keys).n AS KEY_SEQ, ci.relname AS PK_NAME "
+ "FROM pg_catalog.pg_class ct "
+ " JOIN pg_catalog.pg_attribute a ON (ct.oid = a.attrelid) "
+ " JOIN pg_catalog.pg_namespace n ON (ct.relnamespace = n.oid) "
+ " JOIN (SELECT i.indexrelid, i.indrelid, i.indisprimary, "
+ " information_schema._pg_expandarray(i.indkey) AS keys "
+ " FROM pg_catalog.pg_index i) i "
+ " ON (a.attnum = (i.keys).x AND a.attrelid = i.indrelid) "
+ " JOIN pg_catalog.pg_class ci ON (ci.oid = i.indexrelid) "
+ "WHERE true ";
if (schema != null && !"".equals(schema))
{
sql += " AND n.nspname = " + escapeQuotes(schema);
}
} else {
String select;
String from;
String where = "";
if (connection.haveMinimumServerVersion("7.3"))
{
select = "SELECT NULL AS TABLE_CAT, n.nspname AS TABLE_SCHEM, ";
from = " FROM pg_catalog.pg_namespace n, pg_catalog.pg_class ct, pg_catalog.pg_class ci, pg_catalog.pg_attribute a, pg_catalog.pg_index i ";
where = " AND ct.relnamespace = n.oid ";
if (schema != null && !"".equals(schema))
{
where += " AND n.nspname = " + escapeQuotes(schema);
}
}
else
{
select = "SELECT NULL AS TABLE_CAT, NULL AS TABLE_SCHEM, ";
from = " FROM pg_class ct, pg_class ci, pg_attribute a, pg_index i ";
}
sql = select +
" ct.relname AS TABLE_NAME, " +
" a.attname AS COLUMN_NAME, " +
" a.attnum AS KEY_SEQ, " +
" ci.relname AS PK_NAME " +
from +
" WHERE ct.oid=i.indrelid AND ci.oid=i.indexrelid " +
" AND a.attrelid=ci.oid " +
where;
}
if (table != null && !"".equals(table))
{
sql += " AND ct.relname = " + escapeQuotes(table);
}
sql += " AND i.indisprimary " +
" ORDER BY table_name, pk_name, key_seq";
return createMetaDataStatement().executeQuery(sql);
}
/**
*
* @param primaryCatalog
* @param primarySchema
* @param primaryTable if provided will get the keys exported by this table
* @param foreignTable if provided will get the keys imported by this table
* @return ResultSet
* @throws SQLException
*/
protected java.sql.ResultSet getImportedExportedKeys(String primaryCatalog, String primarySchema, String primaryTable, String foreignCatalog, String foreignSchema, String foreignTable) throws SQLException
{
Field f[] = new Field[14];
f[0] = new Field("PKTABLE_CAT", Oid.VARCHAR);
f[1] = new Field("PKTABLE_SCHEM", Oid.VARCHAR);
f[2] = new Field("PKTABLE_NAME", Oid.VARCHAR);
f[3] = new Field("PKCOLUMN_NAME", Oid.VARCHAR);
f[4] = new Field("FKTABLE_CAT", Oid.VARCHAR);
f[5] = new Field("FKTABLE_SCHEM", Oid.VARCHAR);
f[6] = new Field("FKTABLE_NAME", Oid.VARCHAR);
f[7] = new Field("FKCOLUMN_NAME", Oid.VARCHAR);
f[8] = new Field("KEY_SEQ", Oid.INT2);
f[9] = new Field("UPDATE_RULE", Oid.INT2);
f[10] = new Field("DELETE_RULE", Oid.INT2);
f[11] = new Field("FK_NAME", Oid.VARCHAR);
f[12] = new Field("PK_NAME", Oid.VARCHAR);
f[13] = new Field("DEFERRABILITY", Oid.INT2);
String select;
String from;
String where = "";
/*
* The addition of the pg_constraint in 7.3 table should have really
* helped us out here, but it comes up just a bit short.
* - The conkey, confkey columns aren't really useful without
* contrib/array unless we want to issues separate queries.
* - Unique indexes that can support foreign keys are not necessarily
* added to pg_constraint. Also multiple unique indexes covering
* the same keys can be created which make it difficult to determine
* the PK_NAME field.
*/
if (connection.haveMinimumServerVersion("7.4"))
{
String sql = "SELECT NULL::text AS PKTABLE_CAT, pkn.nspname AS PKTABLE_SCHEM, pkc.relname AS PKTABLE_NAME, pka.attname AS PKCOLUMN_NAME, " +
"NULL::text AS FKTABLE_CAT, fkn.nspname AS FKTABLE_SCHEM, fkc.relname AS FKTABLE_NAME, fka.attname AS FKCOLUMN_NAME, " +
"pos.n AS KEY_SEQ, " +
"CASE con.confupdtype " +
" WHEN 'c' THEN " + DatabaseMetaData.importedKeyCascade +
" WHEN 'n' THEN " + DatabaseMetaData.importedKeySetNull +
" WHEN 'd' THEN " + DatabaseMetaData.importedKeySetDefault +
" WHEN 'r' THEN " + DatabaseMetaData.importedKeyRestrict +
" WHEN 'a' THEN " + DatabaseMetaData.importedKeyNoAction +
" ELSE NULL END AS UPDATE_RULE, " +
"CASE con.confdeltype " +
" WHEN 'c' THEN " + DatabaseMetaData.importedKeyCascade +
" WHEN 'n' THEN " + DatabaseMetaData.importedKeySetNull +
" WHEN 'd' THEN " + DatabaseMetaData.importedKeySetDefault +
" WHEN 'r' THEN " + DatabaseMetaData.importedKeyRestrict +
" WHEN 'a' THEN " + DatabaseMetaData.importedKeyNoAction +
" ELSE NULL END AS DELETE_RULE, " +
"con.conname AS FK_NAME, pkic.relname AS PK_NAME, " +
"CASE " +
" WHEN con.condeferrable AND con.condeferred THEN " + DatabaseMetaData.importedKeyInitiallyDeferred +
" WHEN con.condeferrable THEN " + DatabaseMetaData.importedKeyInitiallyImmediate +
" ELSE " + DatabaseMetaData.importedKeyNotDeferrable +
" END AS DEFERRABILITY " +
" FROM " +
" pg_catalog.pg_namespace pkn, pg_catalog.pg_class pkc, pg_catalog.pg_attribute pka, " +
" pg_catalog.pg_namespace fkn, pg_catalog.pg_class fkc, pg_catalog.pg_attribute fka, " +
" pg_catalog.pg_constraint con, ";
if (connection.haveMinimumServerVersion("8.0")) {
sql += " pg_catalog.generate_series(1, " + getMaxIndexKeys() + ") pos(n), ";
} else {
sql += " information_schema._pg_keypositions() pos(n), ";
}
sql += " pg_catalog.pg_depend dep, pg_catalog.pg_class pkic " +
" WHERE pkn.oid = pkc.relnamespace AND pkc.oid = pka.attrelid AND pka.attnum = con.confkey[pos.n] AND con.confrelid = pkc.oid " +
" AND fkn.oid = fkc.relnamespace AND fkc.oid = fka.attrelid AND fka.attnum = con.conkey[pos.n] AND con.conrelid = fkc.oid " +
" AND con.contype = 'f' AND con.oid = dep.objid AND pkic.oid = dep.refobjid AND pkic.relkind = 'i' AND dep.classid = 'pg_constraint'::regclass::oid AND dep.refclassid = 'pg_class'::regclass::oid ";
if (primarySchema != null && !"".equals(primarySchema))
{
sql += " AND pkn.nspname = " + escapeQuotes(primarySchema);
}
if (foreignSchema != null && !"".equals(foreignSchema))
{
sql += " AND fkn.nspname = " + escapeQuotes(foreignSchema);
}
if (primaryTable != null && !"".equals(primaryTable))
{
sql += " AND pkc.relname = " + escapeQuotes(primaryTable);
}
if (foreignTable != null && !"".equals(foreignTable))
{
sql += " AND fkc.relname = " + escapeQuotes(foreignTable);
}
if (primaryTable != null)
{
sql += " ORDER BY fkn.nspname,fkc.relname,pos.n";
}
else
{
sql += " ORDER BY pkn.nspname,pkc.relname,pos.n";
}
return createMetaDataStatement().executeQuery(sql);
}
else if (connection.haveMinimumServerVersion("7.3"))
{
select = "SELECT DISTINCT n1.nspname as pnspname,n2.nspname as fnspname, ";
from = " FROM pg_catalog.pg_namespace n1 " +
" JOIN pg_catalog.pg_class c1 ON (c1.relnamespace = n1.oid) " +
" JOIN pg_catalog.pg_index i ON (c1.oid=i.indrelid) " +
" JOIN pg_catalog.pg_class ic ON (i.indexrelid=ic.oid) " +
" JOIN pg_catalog.pg_attribute a ON (ic.oid=a.attrelid), " +
" pg_catalog.pg_namespace n2 " +
" JOIN pg_catalog.pg_class c2 ON (c2.relnamespace=n2.oid), " +
" pg_catalog.pg_trigger t1 " +
" JOIN pg_catalog.pg_proc p1 ON (t1.tgfoid=p1.oid), " +
" pg_catalog.pg_trigger t2 " +
" JOIN pg_catalog.pg_proc p2 ON (t2.tgfoid=p2.oid) ";
if (primarySchema != null && !"".equals(primarySchema))
{
where += " AND n1.nspname = " + escapeQuotes(primarySchema);
}
if (foreignSchema != null && !"".equals(foreignSchema))
{
where += " AND n2.nspname = " + escapeQuotes(foreignSchema);
}
}
else
{
select = "SELECT DISTINCT NULL::text as pnspname, NULL::text as fnspname, ";
from = " FROM pg_class c1 " +
" JOIN pg_index i ON (c1.oid=i.indrelid) " +
" JOIN pg_class ic ON (i.indexrelid=ic.oid) " +
" JOIN pg_attribute a ON (ic.oid=a.attrelid), " +
" pg_class c2, " +
" pg_trigger t1 " +
" JOIN pg_proc p1 ON (t1.tgfoid=p1.oid), " +
" pg_trigger t2 " +
" JOIN pg_proc p2 ON (t2.tgfoid=p2.oid) ";
}
String sql = select
+ "c1.relname as prelname, "
+ "c2.relname as frelname, "
+ "t1.tgconstrname, "
+ "a.attnum as keyseq, "
+ "ic.relname as fkeyname, "
+ "t1.tgdeferrable, "
+ "t1.tginitdeferred, "
+ "t1.tgnargs,t1.tgargs, "
+ "p1.proname as updaterule, "
+ "p2.proname as deleterule "
+ from
+ "WHERE "
// isolate the update rule
+ "(t1.tgrelid=c1.oid "
+ "AND t1.tgisconstraint "
+ "AND t1.tgconstrrelid=c2.oid "
+ "AND p1.proname ~ '^RI_FKey_.*_upd$') "
+ "AND "
// isolate the delete rule
+ "(t2.tgrelid=c1.oid "
+ "AND t2.tgisconstraint "
+ "AND t2.tgconstrrelid=c2.oid "
+ "AND p2.proname ~ '^RI_FKey_.*_del$') "
+ "AND i.indisprimary "
+ where;
if (primaryTable != null)
{
sql += "AND c1.relname=" + escapeQuotes(primaryTable);
}
if (foreignTable != null)
{
sql += "AND c2.relname=" + escapeQuotes(foreignTable);
}
sql += "ORDER BY ";
// orderby is as follows getExported, orders by FKTABLE,
// getImported orders by PKTABLE
// getCrossReference orders by FKTABLE, so this should work for both,
// since when getting crossreference, primaryTable will be defined
if (primaryTable != null)
{
if (connection.haveMinimumServerVersion("7.3"))
{
sql += "fnspname,";
}
sql += "frelname";
}
else
{
if (connection.haveMinimumServerVersion("7.3"))
{
sql += "pnspname,";
}
sql += "prelname";
}
sql += ",keyseq";
ResultSet rs = connection.createStatement().executeQuery(sql);
// returns the following columns
// and some example data with a table defined as follows
// create table people ( id int primary key);
// create table policy ( id int primary key);
// create table users ( id int primary key, people_id int references people(id), policy_id int references policy(id))
// prelname | frelname | tgconstrname | keyseq | fkeyName | tgdeferrable | tginitdeferred
// 1 | 2 | 3 | 4 | 5 | 6 | 7
// people | users | | 1 | people_pkey | f | f
// | tgnargs | tgargs | updaterule | deleterule
// | 8 | 9 | 10 | 11
// | 6 | \000users\000people\000UNSPECIFIED\000people_id\000id\000 | RI_FKey_noaction_upd | RI_FKey_noaction_del
List tuples = new ArrayList();
while ( rs.next() )
{
byte tuple[][] = new byte[14][];
tuple[1] = rs.getBytes(1); //PKTABLE_SCHEM
tuple[5] = rs.getBytes(2); //FKTABLE_SCHEM
tuple[2] = rs.getBytes(3); //PKTABLE_NAME
tuple[6] = rs.getBytes(4); //FKTABLE_NAME
String fKeyName = rs.getString(5);
String updateRule = rs.getString(12);
if (updateRule != null )
{
// Rules look like this RI_FKey_noaction_del so we want to pull out the part between the 'Key_' and the last '_' s
String rule = updateRule.substring(8, updateRule.length() - 4);
int action = java.sql.DatabaseMetaData.importedKeyNoAction;
if ( rule == null || "noaction".equals(rule) )
action = java.sql.DatabaseMetaData.importedKeyNoAction;
if ("cascade".equals(rule))
action = java.sql.DatabaseMetaData.importedKeyCascade;
else if ("setnull".equals(rule))
action = java.sql.DatabaseMetaData.importedKeySetNull;
else if ("setdefault".equals(rule))
action = java.sql.DatabaseMetaData.importedKeySetDefault;
else if ("restrict".equals(rule))
action = java.sql.DatabaseMetaData.importedKeyRestrict;
tuple[9] = connection.encodeString(Integer.toString(action));
}
String deleteRule = rs.getString(13);
if ( deleteRule != null )
{
String rule = deleteRule.substring(8, deleteRule.length() - 4);
int action = java.sql.DatabaseMetaData.importedKeyNoAction;
if ("cascade".equals(rule))
action = java.sql.DatabaseMetaData.importedKeyCascade;
else if ("setnull".equals(rule))
action = java.sql.DatabaseMetaData.importedKeySetNull;
else if ("setdefault".equals(rule))
action = java.sql.DatabaseMetaData.importedKeySetDefault;
else if ("restrict".equals(rule))
action = java.sql.DatabaseMetaData.importedKeyRestrict;
tuple[10] = connection.encodeString(Integer.toString(action));
}
int keySequence = rs.getInt(6); //KEY_SEQ
// Parse the tgargs data
String fkeyColumn = "";
String pkeyColumn = "";
String fkName = "";
// Note, I am guessing at most of this, but it should be close
// if not, please correct
// the keys are in pairs and start after the first four arguments
// the arguments are seperated by \000
String targs = rs.getString(11);
// args look like this
//\000ww\000vv\000UNSPECIFIED\000m\000a\000n\000b\000
// we are primarily interested in the column names which are the last items in the string
List tokens = tokenize(targs, "\\000");
if (tokens.size() > 0)
{
fkName = (String)tokens.get(0);
}
if (fkName.startsWith(""))
{
fkName = targs;
}
int element = 4 + (keySequence - 1) * 2;
if (tokens.size() > element)
{
fkeyColumn = (String)tokens.get(element);
}
element++;
if (tokens.size() > element)
{
pkeyColumn = (String)tokens.get(element);
}
tuple[3] = connection.encodeString(pkeyColumn); //PKCOLUMN_NAME
tuple[7] = connection.encodeString(fkeyColumn); //FKCOLUMN_NAME
tuple[8] = rs.getBytes(6); //KEY_SEQ
tuple[11] = connection.encodeString(fkName); //FK_NAME this will give us a unique name for the foreign key
tuple[12] = rs.getBytes(7); //PK_NAME
// DEFERRABILITY
int deferrability = java.sql.DatabaseMetaData.importedKeyNotDeferrable;
boolean deferrable = rs.getBoolean(8);
boolean initiallyDeferred = rs.getBoolean(9);
if (deferrable)
{
if (initiallyDeferred)
deferrability = java.sql.DatabaseMetaData.importedKeyInitiallyDeferred;
else
deferrability = java.sql.DatabaseMetaData.importedKeyInitiallyImmediate;
}
tuple[13] = connection.encodeString(Integer.toString(deferrability));
tuples.add(tuple);
}
return (ResultSet) ((BaseStatement)createMetaDataStatement()).createDriverResultSet(f, tuples);
}
/*
* Get a description of the primary key columns that are
* referenced by a table's foreign key columns (the primary keys
* imported by a table). They are ordered by PKTABLE_CAT,
* PKTABLE_SCHEM, PKTABLE_NAME, and KEY_SEQ.
*
*
Each primary key column description has the following columns:
*
*
PKTABLE_CAT String => primary key table catalog
* being imported (may be null)
*
PKTABLE_SCHEM String => primary key table schema
* being imported (may be null)
*
PKTABLE_NAME String => primary key table name
* being imported
*
PKCOLUMN_NAME String => primary key column name
* being imported
*
KEY_SEQ short => sequence number within foreign key
*
UPDATE_RULE short => What happens to
* foreign key when primary is updated:
*
*
importedKeyCascade - change imported key to agree
* with primary key update
*
importedKeyRestrict - do not allow update of primary
* key if it has been imported
*
importedKeySetNull - change imported key to NULL if
* its primary key has been updated
*
*
DELETE_RULE short => What happens to
* the foreign key when primary is deleted.
*
*
importedKeyCascade - delete rows that import a deleted key
*
importedKeyRestrict - do not allow delete of primary
* key if it has been imported
*
importedKeySetNull - change imported key to NULL if
* its primary key has been deleted
*
*
FK_NAME String => foreign key name (may be null)
*
PK_NAME String => primary key name (may be null)
*
*
* @param catalog a catalog name; "" retrieves those without a catalog
* @param schema a schema name pattern; "" retrieves those
* without a schema
* @param table a table name
* @return ResultSet each row is a primary key column description
* @see #getExportedKeys
*/
public java.sql.ResultSet getImportedKeys(String catalog, String schema, String table) throws SQLException
{
return getImportedExportedKeys(null, null, null, catalog, schema, table);
}
/*
* Get a description of a foreign key columns that reference a
* table's primary key columns (the foreign keys exported by a
* table). They are ordered by FKTABLE_CAT, FKTABLE_SCHEM,
* FKTABLE_NAME, and KEY_SEQ.
*
* This method is currently unimplemented.
*
*
Each foreign key column description has the following columns:
*
FKTABLE_CAT String => foreign key table catalog (may be null)
* being exported (may be null)
*
FKTABLE_SCHEM String => foreign key table schema (may be null)
* being exported (may be null)
*
FKTABLE_NAME String => foreign key table name
* being exported
*
FKCOLUMN_NAME String => foreign key column name
* being exported
*
KEY_SEQ short => sequence number within foreign key
*
UPDATE_RULE short => What happens to
* foreign key when primary is updated:
*
*
importedKeyCascade - change imported key to agree
* with primary key update
*
importedKeyRestrict - do not allow update of primary
* key if it has been imported
*
importedKeySetNull - change imported key to NULL if
* its primary key has been updated
*
*
DELETE_RULE short => What happens to
* the foreign key when primary is deleted.
*
*
importedKeyCascade - delete rows that import a deleted key
*
importedKeyRestrict - do not allow delete of primary
* key if it has been imported
*
importedKeySetNull - change imported key to NULL if
* its primary key has been deleted
*
*
FK_NAME String => foreign key identifier (may be null)
*
PK_NAME String => primary key identifier (may be null)
*
*
* @param catalog a catalog name; "" retrieves those without a catalog
* @param schema a schema name pattern; "" retrieves those
* without a schema
* @param table a table name
* @return ResultSet each row is a foreign key column description
* @see #getImportedKeys
*/
public java.sql.ResultSet getExportedKeys(String catalog, String schema, String table) throws SQLException
{
return getImportedExportedKeys(catalog, schema, table, null, null, null);
}
/*
* Get a description of the foreign key columns in the foreign key
* table that reference the primary key columns of the primary key
* table (describe how one table imports another's key.) This
* should normally return a single foreign key/primary key pair
* (most tables only import a foreign key from a table once.) They
* are ordered by FKTABLE_CAT, FKTABLE_SCHEM, FKTABLE_NAME, and
* KEY_SEQ.
*
* This method is currently unimplemented.
*
*
Each foreign key column description has the following columns:
*
FKTABLE_CAT String => foreign key table catalog (may be null)
* being exported (may be null)
*
FKTABLE_SCHEM String => foreign key table schema (may be null)
* being exported (may be null)
*
FKTABLE_NAME String => foreign key table name
* being exported
*
FKCOLUMN_NAME String => foreign key column name
* being exported
*
KEY_SEQ short => sequence number within foreign key
*
UPDATE_RULE short => What happens to
* foreign key when primary is updated:
*
*
importedKeyCascade - change imported key to agree
* with primary key update
*
importedKeyRestrict - do not allow update of primary
* key if it has been imported
*
importedKeySetNull - change imported key to NULL if
* its primary key has been updated
*
*
DELETE_RULE short => What happens to
* the foreign key when primary is deleted.
*
*
importedKeyCascade - delete rows that import a deleted key
*
importedKeyRestrict - do not allow delete of primary
* key if it has been imported
*
importedKeySetNull - change imported key to NULL if
* its primary key has been deleted
*
*
FK_NAME String => foreign key identifier (may be null)
*
PK_NAME String => primary key identifier (may be null)
*
*
* @param catalog a catalog name; "" retrieves those without a catalog
* @param schema a schema name pattern; "" retrieves those
* without a schema
* @param table a table name
* @return ResultSet each row is a foreign key column description
* @see #getImportedKeys
*/
public java.sql.ResultSet getCrossReference(String primaryCatalog, String primarySchema, String primaryTable, String foreignCatalog, String foreignSchema, String foreignTable) throws SQLException
{
return getImportedExportedKeys(primaryCatalog, primarySchema, primaryTable, foreignCatalog, foreignSchema, foreignTable);
}
/*
* Get a description of all the standard SQL types supported by
* this database. They are ordered by DATA_TYPE and then by how
* closely the data type maps to the corresponding JDBC SQL type.
*
*
Each type description has the following columns:
*
*
TYPE_NAME String => Type name
*
DATA_TYPE short => SQL data type from java.sql.Types
*
PRECISION int => maximum precision
*
LITERAL_PREFIX String => prefix used to quote a literal
* (may be null)
*
LITERAL_SUFFIX String => suffix used to quote a literal
(may be null)
*
CREATE_PARAMS String => parameters used in creating
* the type (may be null)
*
NULLABLE short => can you use NULL for this type?
*
*
typeNoNulls - does not allow NULL values
*
typeNullable - allows NULL values
*
typeNullableUnknown - nullability unknown
*
*
CASE_SENSITIVE boolean=> is it case sensitive?
*
SEARCHABLE short => can you use "WHERE" based on this type:
*
*
typePredNone - No support
*
typePredChar - Only supported with WHERE .. LIKE
*
typePredBasic - Supported except for WHERE .. LIKE
*
typeSearchable - Supported for all WHERE ..
*
*
UNSIGNED_ATTRIBUTE boolean => is it unsigned?
*
FIXED_PREC_SCALE boolean => can it be a money value?
*
AUTO_INCREMENT boolean => can it be used for an
* auto-increment value?
*
LOCAL_TYPE_NAME String => localized version of type name
* (may be null)
*
MINIMUM_SCALE short => minimum scale supported
*
MAXIMUM_SCALE short => maximum scale supported
*
SQL_DATA_TYPE int => unused
*
SQL_DATETIME_SUB int => unused
*
NUM_PREC_RADIX int => usually 2 or 10
*
*
* @return ResultSet each row is a SQL type description
*/
public java.sql.ResultSet getTypeInfo() throws SQLException
{
Field f[] = new Field[18];
List v = new ArrayList(); // The new ResultSet tuple stuff
f[0] = new Field("TYPE_NAME", Oid.VARCHAR);
f[1] = new Field("DATA_TYPE", Oid.INT2);
f[2] = new Field("PRECISION", Oid.INT4);
f[3] = new Field("LITERAL_PREFIX", Oid.VARCHAR);
f[4] = new Field("LITERAL_SUFFIX", Oid.VARCHAR);
f[5] = new Field("CREATE_PARAMS", Oid.VARCHAR);
f[6] = new Field("NULLABLE", Oid.INT2);
f[7] = new Field("CASE_SENSITIVE", Oid.BOOL);
f[8] = new Field("SEARCHABLE", Oid.INT2);
f[9] = new Field("UNSIGNED_ATTRIBUTE", Oid.BOOL);
f[10] = new Field("FIXED_PREC_SCALE", Oid.BOOL);
f[11] = new Field("AUTO_INCREMENT", Oid.BOOL);
f[12] = new Field("LOCAL_TYPE_NAME", Oid.VARCHAR);
f[13] = new Field("MINIMUM_SCALE", Oid.INT2);
f[14] = new Field("MAXIMUM_SCALE", Oid.INT2);
f[15] = new Field("SQL_DATA_TYPE", Oid.INT4);
f[16] = new Field("SQL_DATETIME_SUB", Oid.INT4);
f[17] = new Field("NUM_PREC_RADIX", Oid.INT4);
String sql;
if (connection.haveMinimumServerVersion("7.3"))
{
sql = "SELECT t.typname,t.oid FROM pg_catalog.pg_type t"
+ " JOIN pg_catalog.pg_namespace n ON (t.typnamespace = n.oid) "
+ " WHERE n.nspname != 'pg_toast'";
}
else
{
sql = "SELECT typname,oid FROM pg_type" +
" WHERE NOT (typname ~ '^pg_toast_') ";
}
ResultSet rs = connection.createStatement().executeQuery(sql);
// cache some results, this will keep memory useage down, and speed
// things up a little.
byte bZero[] = connection.encodeString("0");
byte b10[] = connection.encodeString("10");
byte bf[] = connection.encodeString("f");
byte bt[] = connection.encodeString("t");
byte bliteral[] = connection.encodeString("'");
byte bNullable[] = connection.encodeString(Integer.toString(java.sql.DatabaseMetaData.typeNullable));
byte bSearchable[] = connection.encodeString(Integer.toString(java.sql.DatabaseMetaData.typeSearchable));
while (rs.next())
{
byte[][] tuple = new byte[18][];
String typname = rs.getString(1);
int typeOid = (int)rs.getLong(2);
tuple[0] = connection.encodeString(typname);
tuple[1] = connection.encodeString(Integer.toString(connection.getTypeInfo().getSQLType(typname)));
tuple[2] = connection.encodeString(Integer.toString(connection.getTypeInfo().getMaximumPrecision(typeOid)));
if (connection.getTypeInfo().requiresQuoting(typeOid))
{
tuple[3] = bliteral;
tuple[4] = bliteral;
}
tuple[6] = bNullable; // all types can be null
tuple[7] = connection.getTypeInfo().isCaseSensitive(typeOid) ? bt : bf;
tuple[8] = bSearchable; // any thing can be used in the WHERE clause
tuple[9] = connection.getTypeInfo().isSigned(typeOid) ? bf : bt;
tuple[10] = bf; // false for now - must handle money
tuple[11] = bf; // false - it isn't autoincrement
tuple[13] = bZero; // min scale is zero
// only numeric can supports a scale.
tuple[14] = (typeOid == Oid.NUMERIC) ? connection.encodeString("1000") : bZero;
// 12 - LOCAL_TYPE_NAME is null
// 15 & 16 are unused so we return null
tuple[17] = b10; // everything is base 10
v.add(tuple);
// add pseudo-type serial, bigserial
if ( typname.equals("int4") )
{
byte[][] tuple1 = (byte[][])tuple.clone();
tuple1[0] = connection.encodeString("serial");
tuple1[11] = bt;
v.add(tuple1);
}
else if ( typname.equals("int8") )
{
byte[][] tuple1 = (byte[][])tuple.clone();
tuple1[0] = connection.encodeString("bigserial");
tuple1[11] = bt;
v.add(tuple1);
}
}
rs.close();
return (ResultSet) ((BaseStatement)createMetaDataStatement()).createDriverResultSet(f, v);
}
/*
* Get a description of a table's indices and statistics. They are
* ordered by NON_UNIQUE, TYPE, INDEX_NAME, and ORDINAL_POSITION.
*
*
Each index column description has the following columns:
*
*
TABLE_CAT String => table catalog (may be null)
*
TABLE_SCHEM String => table schema (may be null)
*
TABLE_NAME String => table name
*
NON_UNIQUE boolean => Can index values be non-unique?
* false when TYPE is tableIndexStatistic
*
INDEX_QUALIFIER String => index catalog (may be null);
* null when TYPE is tableIndexStatistic
*
INDEX_NAME String => index name; null when TYPE is
* tableIndexStatistic
*
TYPE short => index type:
*
*
tableIndexStatistic - this identifies table statistics that are
* returned in conjuction with a table's index descriptions
*
tableIndexClustered - this is a clustered index
*
tableIndexHashed - this is a hashed index
*
tableIndexOther - this is some other style of index
*
*
ORDINAL_POSITION short => column sequence number
* within index; zero when TYPE is tableIndexStatistic
*
COLUMN_NAME String => column name; null when TYPE is
* tableIndexStatistic
*
ASC_OR_DESC String => column sort sequence, "A" => ascending
* "D" => descending, may be null if sort sequence is not supported;
* null when TYPE is tableIndexStatistic
*
CARDINALITY int => When TYPE is tableIndexStatisic then
* this is the number of rows in the table; otherwise it is the
* number of unique values in the index.
*
PAGES int => When TYPE is tableIndexStatisic then
* this is the number of pages used for the table, otherwise it
* is the number of pages used for the current index.
*
FILTER_CONDITION String => Filter condition, if any.
* (may be null)
*
*
* @param catalog a catalog name; "" retrieves those without a catalog
* @param schema a schema name pattern; "" retrieves those without a schema
* @param table a table name
* @param unique when true, return only indices for unique values;
* when false, return indices regardless of whether unique or not
* @param approximate when true, result is allowed to reflect approximate
* or out of data values; when false, results are requested to be
* accurate
* @return ResultSet each row is an index column description
*/
// Implementation note: This is required for Borland's JBuilder to work
public java.sql.ResultSet getIndexInfo(String catalog, String schema, String tableName, boolean unique, boolean approximate) throws SQLException
{
/* This is a complicated function because we have three possible
* situations:
* <= 7.2 no schemas, single column functional index
* 7.3 schemas, single column functional index
* >= 7.4 schemas, multi-column expressional index
* >= 8.3 supports ASC/DESC column info
* >= 9.0 no longer renames index columns on a table column rename,
* so we must look at the table attribute names
*
* with the single column functional index we need an extra
* join to the table's pg_attribute data to get the column
* the function operates on.
*/
String sql;
if (connection.haveMinimumServerVersion("8.3"))
{
sql = "SELECT NULL AS TABLE_CAT, n.nspname AS TABLE_SCHEM, "
+ " ct.relname AS TABLE_NAME, NOT i.indisunique AS NON_UNIQUE, "
+ " NULL AS INDEX_QUALIFIER, ci.relname AS INDEX_NAME, "
+ " CASE i.indisclustered "
+ " WHEN true THEN " + java.sql.DatabaseMetaData.tableIndexClustered
+ " ELSE CASE am.amname "
+ " WHEN 'hash' THEN " + java.sql.DatabaseMetaData.tableIndexHashed
+ " ELSE " + java.sql.DatabaseMetaData.tableIndexOther
+ " END "
+ " END AS TYPE, "
+ " (i.keys).n AS ORDINAL_POSITION, "
+ " pg_catalog.pg_get_indexdef(ci.oid, (i.keys).n, false) AS COLUMN_NAME, "
+ " CASE am.amcanorder "
+ " WHEN true THEN CASE i.indoption[(i.keys).n - 1] & 1 "
+ " WHEN 1 THEN 'D' "
+ " ELSE 'A' "
+ " END "
+ " ELSE NULL "
+ " END AS ASC_OR_DESC, "
+ " ci.reltuples AS CARDINALITY, "
+ " ci.relpages AS PAGES, "
+ " pg_catalog.pg_get_expr(i.indpred, i.indrelid) AS FILTER_CONDITION "
+ "FROM pg_catalog.pg_class ct "
+ " JOIN pg_catalog.pg_namespace n ON (ct.relnamespace = n.oid) "
+ " JOIN (SELECT i.indexrelid, i.indrelid, i.indoption, "
+ " i.indisunique, i.indisclustered, i.indpred, "
+ " i.indexprs, "
+ " information_schema._pg_expandarray(i.indkey) AS keys "
+ " FROM pg_catalog.pg_index i) i "
+ " ON (ct.oid = i.indrelid) "
+ " JOIN pg_catalog.pg_class ci ON (ci.oid = i.indexrelid) "
+ " JOIN pg_catalog.pg_am am ON (ci.relam = am.oid) "
+ "WHERE true ";
if (schema != null && !"".equals(schema))
{
sql += " AND n.nspname = " + escapeQuotes(schema);
}
} else {
String select;
String from;
String where = "";
if (connection.haveMinimumServerVersion("7.3"))
{
select = "SELECT NULL AS TABLE_CAT, n.nspname AS TABLE_SCHEM, ";
from = " FROM pg_catalog.pg_namespace n, pg_catalog.pg_class ct, pg_catalog.pg_class ci, pg_catalog.pg_attribute a, pg_catalog.pg_am am ";
where = " AND n.oid = ct.relnamespace ";
if (!connection.haveMinimumServerVersion("7.4")) {
from += ", pg_catalog.pg_attribute ai, pg_catalog.pg_index i LEFT JOIN pg_catalog.pg_proc ip ON (i.indproc = ip.oid) ";
where += " AND ai.attnum = i.indkey[0] AND ai.attrelid = ct.oid ";
} else {
from += ", pg_catalog.pg_index i ";
}
if (schema != null && ! "".equals(schema))
{
where += " AND n.nspname = " + escapeQuotes(schema);
}
}
else
{
select = "SELECT NULL AS TABLE_CAT, NULL AS TABLE_SCHEM, ";
from = " FROM pg_class ct, pg_class ci, pg_attribute a, pg_am am, pg_attribute ai, pg_index i LEFT JOIN pg_proc ip ON (i.indproc = ip.oid) ";
where = " AND ai.attnum = i.indkey[0] AND ai.attrelid = ct.oid ";
}
sql = select +
" ct.relname AS TABLE_NAME, NOT i.indisunique AS NON_UNIQUE, NULL AS INDEX_QUALIFIER, ci.relname AS INDEX_NAME, " +
" CASE i.indisclustered " +
" WHEN true THEN " + java.sql.DatabaseMetaData.tableIndexClustered +
" ELSE CASE am.amname " +
" WHEN 'hash' THEN " + java.sql.DatabaseMetaData.tableIndexHashed +
" ELSE " + java.sql.DatabaseMetaData.tableIndexOther +
" END " +
" END AS TYPE, " +
" a.attnum AS ORDINAL_POSITION, ";
if( connection.haveMinimumServerVersion("7.4"))
{
sql += " CASE WHEN i.indexprs IS NULL THEN a.attname ELSE pg_catalog.pg_get_indexdef(ci.oid,a.attnum,false) END AS COLUMN_NAME, ";
}
else
{
sql += " CASE i.indproc WHEN 0 THEN a.attname ELSE ip.proname || '(' || ai.attname || ')' END AS COLUMN_NAME, ";
}
sql += " NULL AS ASC_OR_DESC, " +
" ci.reltuples AS CARDINALITY, " +
" ci.relpages AS PAGES, ";
if( connection.haveMinimumServerVersion("7.3"))
{
sql += " pg_catalog.pg_get_expr(i.indpred, i.indrelid) AS FILTER_CONDITION ";
}
else if( connection.haveMinimumServerVersion("7.2"))
{
sql += " pg_get_expr(i.indpred, i.indrelid) AS FILTER_CONDITION ";
}
else
{
sql += " NULL AS FILTER_CONDITION ";
}
sql += from +
" WHERE ct.oid=i.indrelid AND ci.oid=i.indexrelid AND a.attrelid=ci.oid AND ci.relam=am.oid " +
where;
}
sql += " AND ct.relname = " + escapeQuotes(tableName);
if (unique)
{
sql += " AND i.indisunique ";
}
sql += " ORDER BY NON_UNIQUE, TYPE, INDEX_NAME, ORDINAL_POSITION ";
return createMetaDataStatement().executeQuery(sql);
}
/**
* Tokenize based on words not on single characters.
*/
private static List tokenize(String input, String delimiter) {
List result = new ArrayList();
int start = 0;
int end = input.length();
int delimiterSize = delimiter.length();
while (start < end)
{
int delimiterIndex = input.indexOf(delimiter, start);
if (delimiterIndex < 0)
{
result.add(input.substring(start));
break;
}
else
{
String token = input.substring(start, delimiterIndex);
result.add(token);
start = delimiterIndex + delimiterSize;
}
}
return result;
}
// ** JDBC 2 Extensions **
/*
* Does the database support the given result set type?
*
* @param type - defined in java.sql.ResultSet
* @return true if so; false otherwise
* @exception SQLException - if a database access error occurs
*/
public boolean supportsResultSetType(int type) throws SQLException
{
// The only type we don't support
return type != java.sql.ResultSet.TYPE_SCROLL_SENSITIVE;
}
/*
* Does the database support the concurrency type in combination
* with the given result set type?
*
* @param type - defined in java.sql.ResultSet
* @param concurrency - type defined in java.sql.ResultSet
* @return true if so; false otherwise
* @exception SQLException - if a database access error occurs
*/
public boolean supportsResultSetConcurrency(int type, int concurrency) throws SQLException
{
// These combinations are not supported!
if (type == java.sql.ResultSet.TYPE_SCROLL_SENSITIVE)
return false;
// We do support Updateable ResultSets
if (concurrency == java.sql.ResultSet.CONCUR_UPDATABLE)
return true;
// Everything else we do
return true;
}
/* lots of unsupported stuff... */
public boolean ownUpdatesAreVisible(int type) throws SQLException
{
return true;
}
public boolean ownDeletesAreVisible(int type) throws SQLException
{
return true;
}
public boolean ownInsertsAreVisible(int type) throws SQLException
{
// indicates that
return true;
}
public boolean othersUpdatesAreVisible(int type) throws SQLException
{
return false;
}
public boolean othersDeletesAreVisible(int i) throws SQLException
{
return false;
}
public boolean othersInsertsAreVisible(int type) throws SQLException
{
return false;
}
public boolean updatesAreDetected(int type) throws SQLException
{
return false;
}
public boolean deletesAreDetected(int i) throws SQLException
{
return false;
}
public boolean insertsAreDetected(int type) throws SQLException
{
return false;
}
/*
* Indicates whether the driver supports batch updates.
*/
public boolean supportsBatchUpdates() throws SQLException
{
return true;
}
/**
*
* @param catalog String
* @param schemaPattern String
* @param typeNamePattern String
* @param types int[]
* @throws SQLException
* @return ResultSet
*/
public java.sql.ResultSet getUDTs(String catalog,
String schemaPattern,
String typeNamePattern,
int[] types
) throws SQLException
{
String sql = "select "
+ "null as type_cat, n.nspname as type_schem, t.typname as type_name, null as class_name, "
+ "CASE WHEN t.typtype='c' then " + java.sql.Types.STRUCT + " else " + java.sql.Types.DISTINCT + " end as data_type, pg_catalog.obj_description(t.oid, 'pg_type') "
+ "as remarks, CASE WHEN t.typtype = 'd' then (select CASE";
for (Iterator i = connection.getTypeInfo().getPGTypeNamesWithSQLTypes(); i.hasNext();) {
String pgType = (String)i.next();
int sqlType = connection.getTypeInfo().getSQLType(pgType);
sql += " when typname = " + escapeQuotes(pgType) + " then " + sqlType;
}
sql += " else " + java.sql.Types.OTHER + " end from pg_type where oid=t.typbasetype) "
+ "else null end as base_type "
+ "from pg_catalog.pg_type t, pg_catalog.pg_namespace n where t.typnamespace = n.oid and n.nspname != 'pg_catalog' and n.nspname != 'pg_toast'";
String toAdd = "";
if ( types != null )
{
toAdd += " and (false ";
for (int i = 0; i < types.length; i++)
{
switch (types[i] )
{
case java.sql.Types.STRUCT:
toAdd += " or t.typtype = 'c'";
break;
case java.sql.Types.DISTINCT:
toAdd += " or t.typtype = 'd'";
break;
}
}
toAdd += " ) ";
}
else
{
toAdd += " and t.typtype IN ('c','d') ";
}
// spec says that if typeNamePattern is a fully qualified name
// then the schema and catalog are ignored
if (typeNamePattern != null)
{
// search for qualifier
int firstQualifier = typeNamePattern.indexOf('.') ;
int secondQualifier = typeNamePattern.lastIndexOf('.');
if ( firstQualifier != -1 ) // if one of them is -1 they both will be
{
if ( firstQualifier != secondQualifier )
{
// we have a catalog.schema.typename, ignore catalog
schemaPattern = typeNamePattern.substring(firstQualifier + 1, secondQualifier);
}
else
{
// we just have a schema.typename
schemaPattern = typeNamePattern.substring(0, firstQualifier);
}
// strip out just the typeName
typeNamePattern = typeNamePattern.substring(secondQualifier + 1);
}
toAdd += " and t.typname like " + escapeQuotes(typeNamePattern);
}
// schemaPattern may have been modified above
if ( schemaPattern != null)
{
toAdd += " and n.nspname like " + escapeQuotes(schemaPattern);
}
sql += toAdd;
sql += " order by data_type, type_schem, type_name";
java.sql.ResultSet rs = createMetaDataStatement().executeQuery(sql);
return rs;
}
/*
* Retrieves the connection that produced this metadata object.
*
* @return the connection that produced this metadata object
*/
public java.sql.Connection getConnection() throws SQLException
{
return (java.sql.Connection)connection;
}
/* I don't find these in the spec!?! */
public boolean rowChangesAreDetected(int type) throws SQLException
{
return false;
}
public boolean rowChangesAreVisible(int type) throws SQLException
{
return false;
}
protected java.sql.Statement createMetaDataStatement() throws SQLException
{
return ((AbstractJdbc2Connection)connection).createStatement(java.sql.ResultSet.TYPE_SCROLL_INSENSITIVE, java.sql.ResultSet.CONCUR_READ_ONLY);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc2/AbstractJdbc2ResultSet.java 0000664 0000000 0000000 00000306637 12050675701 0026763 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2003-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc2;
import java.io.CharArrayReader;
import java.io.InputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.io.ByteArrayInputStream;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.sql.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.TimeZone;
import java.util.Calendar;
import java.util.Locale;
import org.postgresql.core.*;
import org.postgresql.largeobject.*;
import org.postgresql.util.ByteConverter;
import org.postgresql.util.HStoreConverter;
import org.postgresql.util.PGobject;
import org.postgresql.util.PGbytea;
import org.postgresql.util.PGtokenizer;
import org.postgresql.util.PSQLException;
import org.postgresql.util.PSQLState;
import org.postgresql.util.GT;
import org.postgresql.PGResultSetMetaData;
public abstract class AbstractJdbc2ResultSet implements BaseResultSet, org.postgresql.PGRefCursorResultSet
{
//needed for updateable result set support
private boolean updateable = false;
private boolean doingUpdates = false;
private HashMap updateValues = null;
private boolean usingOID = false; // are we using the OID for the primary key?
private List primaryKeys; // list of primary keys
private boolean singleTable = false;
private String onlyTable = "";
private String tableName = null;
private PreparedStatement updateStatement = null;
private PreparedStatement insertStatement = null;
private PreparedStatement deleteStatement = null;
private PreparedStatement selectStatement = null;
private final int resultsettype;
private final int resultsetconcurrency;
private int fetchdirection = ResultSet.FETCH_UNKNOWN;
protected final BaseConnection connection; // the connection we belong to
protected final BaseStatement statement; // the statement we belong to
private Statement realStatement; // the real statement we belong to (when using forced binary prepared statement test hack)
protected final Field fields[]; // Field metadata for this resultset.
protected final Query originalQuery; // Query we originated from
protected final int maxRows; // Maximum rows in this resultset (might be 0).
protected final int maxFieldSize; // Maximum field size in this resultset (might be 0).
protected List rows; // Current page of results.
protected int current_row = -1; // Index into 'rows' of our currrent row (0-based)
protected int row_offset; // Offset of row 0 in the actual resultset
protected byte[][] this_row; // copy of the current result row
protected SQLWarning warnings = null; // The warning chain
/**
* True if the last obtained column value was SQL NULL as specified by
* {@link #wasNull}. The value is always updated by the
* {@link #checkResultSet} method.
*/
protected boolean wasNullFlag = false;
protected boolean onInsertRow = false; // are we on the insert row (for JDBC2 updatable resultsets)?
private byte[][] rowBuffer = null; // updateable rowbuffer
protected int fetchSize; // Current fetch size (might be 0).
protected ResultCursor cursor; // Cursor for fetching additional data.
private HashMap columnNameIndexMap; // Speed up findColumn by caching lookups
private ResultSetMetaData rsMetaData;
protected abstract ResultSetMetaData createMetaData() throws SQLException;
public ResultSetMetaData getMetaData() throws SQLException
{
checkClosed();
if (rsMetaData == null) {
rsMetaData = createMetaData();
}
return rsMetaData;
}
public AbstractJdbc2ResultSet(Query originalQuery, BaseStatement statement, Field[] fields, List tuples,
ResultCursor cursor, int maxRows, int maxFieldSize,
int rsType, int rsConcurrency) throws SQLException
{
this.originalQuery = originalQuery;
this.connection = (BaseConnection) statement.getConnection();
this.statement = statement;
this.fields = fields;
this.rows = tuples;
this.cursor = cursor;
this.maxRows = maxRows;
this.maxFieldSize = maxFieldSize;
this.resultsettype = rsType;
this.resultsetconcurrency = rsConcurrency;
}
public java.net.URL getURL(int columnIndex) throws SQLException
{
checkClosed();
throw org.postgresql.Driver.notImplemented(this.getClass(), "getURL(int)");
}
public java.net.URL getURL(String columnName) throws SQLException
{
return getURL(findColumn(columnName));
}
protected Object internalGetObject(int columnIndex, Field field) throws SQLException
{
switch (getSQLType(columnIndex))
{
case Types.BIT:
// Also Types.BOOLEAN in JDBC3
return getBoolean(columnIndex) ? Boolean.TRUE : Boolean.FALSE;
case Types.TINYINT:
case Types.SMALLINT:
case Types.INTEGER:
return new Integer(getInt(columnIndex));
case Types.BIGINT:
return new Long(getLong(columnIndex));
case Types.NUMERIC:
case Types.DECIMAL:
return getBigDecimal
(columnIndex, (field.getMod() == -1) ? -1 : ((field.getMod() - 4) & 0xffff));
case Types.REAL:
return new Float(getFloat(columnIndex));
case Types.FLOAT:
case Types.DOUBLE:
return new Double(getDouble(columnIndex));
case Types.CHAR:
case Types.VARCHAR:
case Types.LONGVARCHAR:
return getString(columnIndex);
case Types.DATE:
return getDate(columnIndex);
case Types.TIME:
return getTime(columnIndex);
case Types.TIMESTAMP:
return getTimestamp(columnIndex, null);
case Types.BINARY:
case Types.VARBINARY:
case Types.LONGVARBINARY:
return getBytes(columnIndex);
case Types.ARRAY:
return getArray(columnIndex);
case Types.CLOB:
return getClob(columnIndex);
case Types.BLOB:
return getBlob(columnIndex);
default:
String type = getPGType(columnIndex);
// if the backend doesn't know the type then coerce to String
if (type.equals("unknown"))
return getString(columnIndex);
if (type.equals("uuid")) {
if (isBinary(columnIndex)) {
return getUUID(this_row[columnIndex - 1]);
}
return getUUID(getString(columnIndex));
}
// Specialized support for ref cursors is neater.
if (type.equals("refcursor"))
{
// Fetch all results.
String cursorName = getString(columnIndex);
StringBuffer sb = new StringBuffer("FETCH ALL IN ");
Utils.appendEscapedIdentifier(sb, cursorName);
// nb: no BEGIN triggered here. This is fine. If someone
// committed, and the cursor was not holdable (closing the
// cursor), we avoid starting a new xact and promptly causing
// it to fail. If the cursor *was* holdable, we don't want a
// new xact anyway since holdable cursor state isn't affected
// by xact boundaries. If our caller didn't commit at all, or
// autocommit was on, then we wouldn't issue a BEGIN anyway.
//
// We take the scrollability from the statement, but until
// we have updatable cursors it must be readonly.
ResultSet rs = connection.execSQLQuery(sb.toString(), resultsettype, ResultSet.CONCUR_READ_ONLY);
//
// In long running transactions these backend cursors take up memory space
// we could close in rs.close(), but if the transaction is closed before the result set, then
// the cursor no longer exists
sb.setLength(0);
sb.append("CLOSE ");
Utils.appendEscapedIdentifier(sb, cursorName);
connection.execSQLUpdate(sb.toString());
((AbstractJdbc2ResultSet)rs).setRefCursor(cursorName);
return rs;
}
if ("hstore".equals(type)) {
if (isBinary(columnIndex)) {
return HStoreConverter.fromBytes(this_row[columnIndex - 1], connection.getEncoding());
}
return HStoreConverter.fromString(getString(columnIndex));
}
// Caller determines what to do (JDBC3 overrides in this case)
return null;
}
}
private void checkScrollable() throws SQLException
{
checkClosed();
if (resultsettype == ResultSet.TYPE_FORWARD_ONLY)
throw new PSQLException(GT.tr("Operation requires a scrollable ResultSet, but this ResultSet is FORWARD_ONLY."),
PSQLState.INVALID_CURSOR_STATE);
}
public boolean absolute(int index) throws SQLException
{
checkScrollable();
// index is 1-based, but internally we use 0-based indices
int internalIndex;
if (index == 0)
{
beforeFirst();
return false;
}
final int rows_size = rows.size();
//if index<0, count from the end of the result set, but check
//to be sure that it is not beyond the first index
if (index < 0)
{
if (index >= -rows_size)
internalIndex = rows_size + index;
else
{
beforeFirst();
return false;
}
}
else
{
//must be the case that index>0,
//find the correct place, assuming that
//the index is not too large
if (index <= rows_size)
internalIndex = index - 1;
else
{
afterLast();
return false;
}
}
current_row = internalIndex;
initRowBuffer();
onInsertRow = false;
return true;
}
public void afterLast() throws SQLException
{
checkScrollable();
final int rows_size = rows.size();
if (rows_size > 0)
current_row = rows_size;
onInsertRow = false;
this_row = null;
rowBuffer = null;
}
public void beforeFirst() throws SQLException
{
checkScrollable();
if (rows.size() > 0)
current_row = -1;
onInsertRow = false;
this_row = null;
rowBuffer = null;
}
public boolean first() throws SQLException
{
checkScrollable();
if (rows.size() <= 0)
return false;
current_row = 0;
initRowBuffer();
onInsertRow = false;
return true;
}
public java.sql.Array getArray(String colName) throws SQLException
{
return getArray(findColumn(colName));
}
protected abstract Array makeArray(int oid, byte[] value) throws SQLException;
protected abstract Array makeArray(int oid, String value) throws SQLException;
public java.sql.Array getArray(int i) throws SQLException
{
checkResultSet( i );
if (wasNullFlag)
return null;
int oid = fields[i - 1].getOID();
if (isBinary(i)) {
return makeArray(oid, this_row[i - 1]);
}
return makeArray(oid, getFixedString(i));
}
public java.math.BigDecimal getBigDecimal(int columnIndex) throws SQLException
{
return getBigDecimal(columnIndex, -1);
}
public java.math.BigDecimal getBigDecimal(String columnName) throws SQLException
{
return getBigDecimal(findColumn(columnName));
}
public Blob getBlob(String columnName) throws SQLException
{
return getBlob(findColumn(columnName));
}
protected abstract Blob makeBlob(long oid) throws SQLException;
public Blob getBlob(int i) throws SQLException
{
checkResultSet(i);
if (wasNullFlag)
return null;
return makeBlob(getLong(i));
}
public java.io.Reader getCharacterStream(String columnName) throws SQLException
{
return getCharacterStream(findColumn(columnName));
}
public java.io.Reader getCharacterStream(int i) throws SQLException
{
checkResultSet( i );
if (wasNullFlag)
return null;
if (((AbstractJdbc2Connection) connection).haveMinimumCompatibleVersion("7.2"))
{
//Version 7.2 supports AsciiStream for all the PG text types
//As the spec/javadoc for this method indicate this is to be used for
//large text values (i.e. LONGVARCHAR) PG doesn't have a separate
//long string datatype, but with toast the text datatype is capable of
//handling very large values. Thus the implementation ends up calling
//getString() since there is no current way to stream the value from the server
return new CharArrayReader(getString(i).toCharArray());
}
else
{
// In 7.1 Handle as BLOBS so return the LargeObject input stream
Encoding encoding = connection.getEncoding();
InputStream input = getBinaryStream(i);
try
{
return encoding.getDecodingReader(input);
}
catch (IOException ioe)
{
throw new PSQLException(GT.tr("Unexpected error while decoding character data from a large object."), PSQLState.UNEXPECTED_ERROR, ioe);
}
}
}
public Clob getClob(String columnName) throws SQLException
{
return getClob(findColumn(columnName));
}
protected abstract Clob makeClob(long oid) throws SQLException;
public Clob getClob(int i) throws SQLException
{
checkResultSet(i);
if (wasNullFlag)
return null;
return makeClob(getLong(i));
}
public int getConcurrency() throws SQLException
{
checkClosed();
return resultsetconcurrency;
}
public java.sql.Date getDate(int i, java.util.Calendar cal) throws SQLException
{
checkResultSet(i);
if (wasNullFlag)
return null;
if (isBinary(i)) {
int col = i - 1;
int oid = fields[col].getOID();
TimeZone tz = cal == null ? null : cal.getTimeZone();
if (oid == Oid.DATE) {
return connection.getTimestampUtils().toDateBin(tz, this_row[col]);
} else if (oid == Oid.TIMESTAMP || oid == Oid.TIMESTAMPTZ) {
// JDBC spec says getDate of Timestamp must be supported
return connection.getTimestampUtils().convertToDate(getTimestamp(i, cal), tz);
} else {
throw new PSQLException (GT.tr("Cannot convert the column of type {0} to requested type {1}.",
new Object[]{Oid.toString(oid), "date"}),
PSQLState.DATA_TYPE_MISMATCH);
}
}
if (cal != null)
cal = (Calendar)cal.clone();
return connection.getTimestampUtils().toDate(cal, getString(i));
}
public Time getTime(int i, java.util.Calendar cal) throws SQLException
{
checkResultSet(i);
if (wasNullFlag)
return null;
if (isBinary(i)) {
int col = i - 1;
int oid = fields[col].getOID();
TimeZone tz = cal == null ? null : cal.getTimeZone();
if (oid == Oid.TIME || oid == Oid.TIMETZ) {
return connection.getTimestampUtils().toTimeBin(tz, this_row[col]);
} else if (oid == Oid.TIMESTAMP || oid == Oid.TIMESTAMPTZ) {
// JDBC spec says getTime of Timestamp must be supported
return connection.getTimestampUtils().convertToTime(getTimestamp(i, cal), tz);
} else {
throw new PSQLException (GT.tr("Cannot convert the column of type {0} to requested type {1}.",
new Object[]{Oid.toString(oid), "time"}),
PSQLState.DATA_TYPE_MISMATCH);
}
}
if (cal != null)
cal = (Calendar)cal.clone();
return connection.getTimestampUtils().toTime(cal, getString(i));
}
public Timestamp getTimestamp(int i, java.util.Calendar cal) throws SQLException
{
checkResultSet(i);
if (wasNullFlag)
return null;
if (isBinary(i)) {
int col = i - 1;
int oid = fields[col].getOID();
if (oid == Oid.TIMESTAMPTZ || oid == Oid.TIMESTAMP) {
boolean hasTimeZone = oid == Oid.TIMESTAMPTZ;
TimeZone tz = cal == null ? null : cal.getTimeZone();
return connection.getTimestampUtils().toTimestampBin(tz, this_row[col], hasTimeZone);
} else {
// JDBC spec says getTimestamp of Time and Date must be supported
long millis;
if (oid == Oid.TIME || oid == Oid.TIMETZ) {
millis = getTime(i, cal).getTime();
} else if (oid == Oid.DATE) {
millis = getDate(i, cal).getTime();
} else {
throw new PSQLException (GT.tr("Cannot convert the column of type {0} to requested type {1}.",
new Object[]{Oid.toString(oid), "timestamp"}),
PSQLState.DATA_TYPE_MISMATCH);
}
return new Timestamp(millis);
}
}
if (cal != null)
cal = (Calendar)cal.clone();
// If this is actually a timestamptz, the server-provided timezone will override
// the one we pass in, which is the desired behaviour. Otherwise, we'll
// interpret the timezone-less value in the provided timezone.
return connection.getTimestampUtils().toTimestamp(cal, getString(i));
}
public java.sql.Date getDate(String c, java.util.Calendar cal) throws SQLException
{
return getDate(findColumn(c), cal);
}
public Time getTime(String c, java.util.Calendar cal) throws SQLException
{
return getTime(findColumn(c), cal);
}
public Timestamp getTimestamp(String c, java.util.Calendar cal) throws SQLException
{
return getTimestamp(findColumn(c), cal);
}
public int getFetchDirection() throws SQLException
{
checkClosed();
return fetchdirection;
}
public Object getObjectImpl(String columnName, java.util.Map map) throws SQLException
{
return getObjectImpl(findColumn(columnName), map);
}
/*
* This checks against map for the type of column i, and if found returns
* an object based on that mapping. The class must implement the SQLData
* interface.
*/
public Object getObjectImpl(int i, java.util.Map map) throws SQLException
{
checkClosed();
if (map == null || map.isEmpty()) {
return getObject(i);
}
throw org.postgresql.Driver.notImplemented(this.getClass(), "getObjectImpl(int,Map)");
}
public Ref getRef(String columnName) throws SQLException
{
return getRef(findColumn(columnName));
}
public Ref getRef(int i) throws SQLException
{
checkClosed();
//The backend doesn't yet have SQL3 REF types
throw org.postgresql.Driver.notImplemented(this.getClass(), "getRef(int)");
}
public int getRow() throws SQLException
{
checkClosed();
if (onInsertRow)
return 0;
final int rows_size = rows.size();
if (current_row < 0 || current_row >= rows_size)
return 0;
return row_offset + current_row + 1;
}
// This one needs some thought, as not all ResultSets come from a statement
public Statement getStatement() throws SQLException
{
checkClosed();
return (Statement) statement;
}
public int getType() throws SQLException
{
checkClosed();
return resultsettype;
}
public boolean isAfterLast() throws SQLException
{
checkClosed();
if (onInsertRow)
return false;
final int rows_size = rows.size();
return (current_row >= rows_size && rows_size > 0);
}
public boolean isBeforeFirst() throws SQLException
{
checkClosed();
if (onInsertRow)
return false;
return ((row_offset + current_row) < 0 && rows.size() > 0);
}
public boolean isFirst() throws SQLException
{
checkClosed();
if (onInsertRow)
return false;
return ((row_offset + current_row) == 0);
}
public boolean isLast() throws SQLException
{
checkClosed();
if (onInsertRow)
return false;
final int rows_size = rows.size();
if (rows_size == 0)
return false; // No rows.
if (current_row != (rows_size - 1))
return false; // Not on the last row of this block.
// We are on the last row of the current block.
if (cursor == null)
{
// This is the last block and therefore the last row.
return true;
}
if (maxRows > 0 && row_offset + current_row == maxRows)
{
// We are implicitly limited by maxRows.
return true;
}
// Now the more painful case begins.
// We are on the last row of the current block, but we don't know if the
// current block is the last block; we must try to fetch some more data to
// find out.
// We do a fetch of the next block, then prepend the current row to that
// block (so current_row == 0). This works as the current row
// must be the last row of the current block if we got this far.
row_offset += rows_size - 1; // Discarding all but one row.
// Work out how many rows maxRows will let us fetch.
int fetchRows = fetchSize;
if (maxRows != 0)
{
if (fetchRows == 0 || row_offset + fetchRows > maxRows) // Fetch would exceed maxRows, limit it.
fetchRows = maxRows - row_offset;
}
// Do the actual fetch.
connection.getQueryExecutor().fetch(cursor, new CursorResultHandler(), fetchRows);
// Now prepend our one saved row and move to it.
rows.add(0, this_row);
current_row = 0;
// Finally, now we can tell if we're the last row or not.
return (rows.size() == 1);
}
public boolean last() throws SQLException
{
checkScrollable();
final int rows_size = rows.size();
if (rows_size <= 0)
return false;
current_row = rows_size - 1;
initRowBuffer();
onInsertRow = false;
return true;
}
public boolean previous() throws SQLException
{
checkScrollable();
if (onInsertRow)
throw new PSQLException(GT.tr("Can''t use relative move methods while on the insert row."),
PSQLState.INVALID_CURSOR_STATE);
if (current_row -1 < 0)
{
current_row = -1;
this_row = null;
rowBuffer = null;
return false;
}
else
{
current_row--;
}
initRowBuffer();
return true;
}
public boolean relative(int rows) throws SQLException
{
checkScrollable();
if (onInsertRow)
throw new PSQLException(GT.tr("Can''t use relative move methods while on the insert row."),
PSQLState.INVALID_CURSOR_STATE);
//have to add 1 since absolute expects a 1-based index
return absolute(current_row + 1 + rows);
}
public void setFetchDirection(int direction) throws SQLException
{
checkClosed();
switch (direction)
{
case ResultSet.FETCH_FORWARD:
break;
case ResultSet.FETCH_REVERSE:
case ResultSet.FETCH_UNKNOWN:
checkScrollable();
break;
default:
throw new PSQLException(GT.tr("Invalid fetch direction constant: {0}.", new Integer(direction)),
PSQLState.INVALID_PARAMETER_VALUE);
}
this.fetchdirection = direction;
}
public synchronized void cancelRowUpdates()
throws SQLException
{
checkClosed();
if (onInsertRow)
{
throw new PSQLException(GT.tr("Cannot call cancelRowUpdates() when on the insert row."),
PSQLState.INVALID_CURSOR_STATE);
}
if (doingUpdates)
{
doingUpdates = false;
clearRowBuffer(true);
}
}
public synchronized void deleteRow()
throws SQLException
{
checkUpdateable();
if (onInsertRow)
{
throw new PSQLException(GT.tr("Cannot call deleteRow() when on the insert row."),
PSQLState.INVALID_CURSOR_STATE);
}
if (isBeforeFirst())
{
throw new PSQLException(GT.tr("Currently positioned before the start of the ResultSet. You cannot call deleteRow() here."),
PSQLState.INVALID_CURSOR_STATE);
}
if (isAfterLast())
{
throw new PSQLException(GT.tr("Currently positioned after the end of the ResultSet. You cannot call deleteRow() here."),
PSQLState.INVALID_CURSOR_STATE);
}
if (rows.size() == 0)
{
throw new PSQLException(GT.tr("There are no rows in this ResultSet."),
PSQLState.INVALID_CURSOR_STATE);
}
int numKeys = primaryKeys.size();
if ( deleteStatement == null )
{
StringBuffer deleteSQL = new StringBuffer("DELETE FROM " ).append(onlyTable).append(tableName).append(" where " );
for ( int i = 0; i < numKeys; i++ )
{
Utils.appendEscapedIdentifier(deleteSQL, ((PrimaryKey)primaryKeys.get(i)).name);
deleteSQL.append(" = ?");
if ( i < numKeys - 1 )
{
deleteSQL.append( " and " );
}
}
deleteStatement = ((java.sql.Connection) connection).prepareStatement(deleteSQL.toString());
}
deleteStatement.clearParameters();
for ( int i = 0; i < numKeys; i++ )
{
deleteStatement.setObject(i + 1, ((PrimaryKey) primaryKeys.get(i)).getValue());
}
deleteStatement.executeUpdate();
rows.remove(current_row);
current_row--;
moveToCurrentRow();
}
public synchronized void insertRow()
throws SQLException
{
checkUpdateable();
if (!onInsertRow)
{
throw new PSQLException(GT.tr("Not on the insert row."), PSQLState.INVALID_CURSOR_STATE);
}
else if (updateValues.size() == 0)
{
throw new PSQLException(GT.tr("You must specify at least one column value to insert a row."),
PSQLState.INVALID_PARAMETER_VALUE);
}
else
{
// loop through the keys in the insertTable and create the sql statement
// we have to create the sql every time since the user could insert different
// columns each time
StringBuffer insertSQL = new StringBuffer("INSERT INTO ").append(tableName).append(" (");
StringBuffer paramSQL = new StringBuffer(") values (" );
Iterator columnNames = updateValues.keySet().iterator();
int numColumns = updateValues.size();
for ( int i = 0; columnNames.hasNext(); i++ )
{
String columnName = (String) columnNames.next();
Utils.appendEscapedIdentifier(insertSQL, columnName);
if ( i < numColumns - 1 )
{
insertSQL.append(", ");
paramSQL.append("?,");
}
else
{
paramSQL.append("?)");
}
}
insertSQL.append(paramSQL.toString());
insertStatement = ((java.sql.Connection) connection).prepareStatement(insertSQL.toString());
Iterator keys = updateValues.keySet().iterator();
for ( int i = 1; keys.hasNext(); i++)
{
String key = (String) keys.next();
Object o = updateValues.get(key);
insertStatement.setObject(i, o);
}
insertStatement.executeUpdate();
if ( usingOID )
{
// we have to get the last inserted OID and put it in the resultset
long insertedOID = ((AbstractJdbc2Statement) insertStatement).getLastOID();
updateValues.put("oid", new Long(insertedOID) );
}
// update the underlying row to the new inserted data
updateRowBuffer();
rows.add(rowBuffer);
// we should now reflect the current data in this_row
// that way getXXX will get the newly inserted data
this_row = rowBuffer;
// need to clear this in case of another insert
clearRowBuffer(false);
}
}
public synchronized void moveToCurrentRow()
throws SQLException
{
checkUpdateable();
if (current_row < 0 || current_row >= rows.size())
{
this_row = null;
rowBuffer = null;
}
else
{
initRowBuffer();
}
onInsertRow = false;
doingUpdates = false;
}
public synchronized void moveToInsertRow()
throws SQLException
{
checkUpdateable();
if (insertStatement != null)
{
insertStatement = null;
}
// make sure the underlying data is null
clearRowBuffer(false);
onInsertRow = true;
doingUpdates = false;
}
private synchronized void clearRowBuffer(boolean copyCurrentRow)
throws SQLException
{
// rowBuffer is the temporary storage for the row
rowBuffer = new byte[fields.length][];
// inserts want an empty array while updates want a copy of the current row
if (copyCurrentRow)
{
System.arraycopy(this_row, 0, rowBuffer, 0, this_row.length);
}
// clear the updateValues hash map for the next set of updates
updateValues.clear();
}
public boolean rowDeleted() throws SQLException
{
checkClosed();
return false;
}
public boolean rowInserted() throws SQLException
{
checkClosed();
return false;
}
public boolean rowUpdated() throws SQLException
{
checkClosed();
return false;
}
public synchronized void updateAsciiStream(int columnIndex,
java.io.InputStream x,
int length
)
throws SQLException
{
if (x == null)
{
updateNull(columnIndex);
return ;
}
try
{
InputStreamReader reader = new InputStreamReader(x, "ASCII");
char data[] = new char[length];
int numRead = 0;
while (true)
{
int n = reader.read(data, numRead, length - numRead);
if (n == -1)
break;
numRead += n;
if (numRead == length)
break;
}
updateString(columnIndex, new String(data, 0, numRead));
}
catch (UnsupportedEncodingException uee)
{
throw new PSQLException(GT.tr("The JVM claims not to support the encoding: {0}","ASCII"), PSQLState.UNEXPECTED_ERROR, uee);
}
catch (IOException ie)
{
throw new PSQLException(GT.tr("Provided InputStream failed."), null, ie);
}
}
public synchronized void updateBigDecimal(int columnIndex,
java.math.BigDecimal x )
throws SQLException
{
updateValue(columnIndex, x);
}
public synchronized void updateBinaryStream(int columnIndex,
java.io.InputStream x,
int length
)
throws SQLException
{
if (x == null)
{
updateNull(columnIndex);
return ;
}
byte data[] = new byte[length];
int numRead = 0;
try
{
while (true)
{
int n = x.read(data, numRead, length - numRead);
if (n == -1)
break;
numRead += n;
if (numRead == length)
break;
}
}
catch (IOException ie)
{
throw new PSQLException(GT.tr("Provided InputStream failed."), null, ie);
}
if (numRead == length)
{
updateBytes(columnIndex, data);
}
else
{
// the stream contained less data than they said
// perhaps this is an error?
byte data2[] = new byte[numRead];
System.arraycopy(data, 0, data2, 0, numRead);
updateBytes(columnIndex, data2);
}
}
public synchronized void updateBoolean(int columnIndex, boolean x)
throws SQLException
{
updateValue(columnIndex, new Boolean(x));
}
public synchronized void updateByte(int columnIndex, byte x)
throws SQLException
{
updateValue(columnIndex, String.valueOf(x));
}
public synchronized void updateBytes(int columnIndex, byte[] x)
throws SQLException
{
updateValue(columnIndex, x);
}
public synchronized void updateCharacterStream(int columnIndex,
java.io.Reader x,
int length
)
throws SQLException
{
if (x == null)
{
updateNull(columnIndex);
return ;
}
try
{
char data[] = new char[length];
int numRead = 0;
while (true)
{
int n = x.read(data, numRead, length - numRead);
if (n == -1)
break;
numRead += n;
if (numRead == length)
break;
}
updateString(columnIndex, new String(data, 0, numRead));
}
catch (IOException ie)
{
throw new PSQLException(GT.tr("Provided Reader failed."), null, ie);
}
}
public synchronized void updateDate(int columnIndex, java.sql.Date x)
throws SQLException
{
updateValue(columnIndex, x);
}
public synchronized void updateDouble(int columnIndex, double x)
throws SQLException
{
updateValue(columnIndex, new Double(x));
}
public synchronized void updateFloat(int columnIndex, float x)
throws SQLException
{
updateValue(columnIndex, new Float(x));
}
public synchronized void updateInt(int columnIndex, int x)
throws SQLException
{
updateValue(columnIndex, new Integer(x));
}
public synchronized void updateLong(int columnIndex, long x)
throws SQLException
{
updateValue(columnIndex, new Long(x));
}
public synchronized void updateNull(int columnIndex)
throws SQLException
{
checkColumnIndex(columnIndex);
String columnTypeName = connection.getTypeInfo().getPGType(fields[columnIndex - 1].getOID());
updateValue(columnIndex, new NullObject(columnTypeName));
}
public synchronized void updateObject(int columnIndex, Object x)
throws SQLException
{
updateValue(columnIndex, x);
}
public synchronized void updateObject(int columnIndex, Object x, int scale)
throws SQLException
{
this.updateObject(columnIndex, x);
}
public void refreshRow() throws SQLException
{
checkUpdateable();
if (onInsertRow)
throw new PSQLException(GT.tr("Can''t refresh the insert row."),
PSQLState.INVALID_CURSOR_STATE);
if (isBeforeFirst() || isAfterLast() || rows.size() == 0)
return ;
StringBuffer selectSQL = new StringBuffer( "select ");
ResultSetMetaData rsmd = getMetaData();
PGResultSetMetaData pgmd = (PGResultSetMetaData)rsmd;
for (int i=1; i <= rsmd.getColumnCount(); i++) {
if (i > 1) {
selectSQL.append(", ");
}
selectSQL.append( pgmd.getBaseColumnName(i) );
}
selectSQL.append(" from " ).append(onlyTable).append(tableName).append(" where ");
int numKeys = primaryKeys.size();
for ( int i = 0; i < numKeys; i++ )
{
PrimaryKey primaryKey = ((PrimaryKey) primaryKeys.get(i));
selectSQL.append(primaryKey.name).append("= ?");
if ( i < numKeys - 1 )
{
selectSQL.append(" and ");
}
}
if ( connection.getLogger().logDebug() )
connection.getLogger().debug("selecting " + selectSQL.toString());
// because updateable result sets do not yet support binary transfers we must request refresh with updateable result set to get field data in correct format
selectStatement = ((java.sql.Connection) connection).prepareStatement(selectSQL.toString(), ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE);
for ( int j = 0, i = 1; j < numKeys; j++, i++)
{
selectStatement.setObject( i, ((PrimaryKey) primaryKeys.get(j)).getValue() );
}
AbstractJdbc2ResultSet rs = (AbstractJdbc2ResultSet) selectStatement.executeQuery();
if ( rs.next() )
{
rowBuffer = rs.this_row;
}
rows.set( current_row, rowBuffer );
this_row = rowBuffer;
connection.getLogger().debug("done updates");
rs.close();
selectStatement.close();
selectStatement = null;
}
public synchronized void updateRow()
throws SQLException
{
checkUpdateable();
if (onInsertRow)
{
throw new PSQLException(GT.tr("Cannot call updateRow() when on the insert row."),
PSQLState.INVALID_CURSOR_STATE);
}
if (isBeforeFirst() || isAfterLast() || rows.size() == 0)
{
throw new PSQLException(GT.tr("Cannot update the ResultSet because it is either before the start or after the end of the results."),
PSQLState.INVALID_CURSOR_STATE);
}
if (!doingUpdates)
return; // No work pending.
StringBuffer updateSQL = new StringBuffer("UPDATE " + onlyTable + tableName + " SET ");
int numColumns = updateValues.size();
Iterator columns = updateValues.keySet().iterator();
for (int i = 0; columns.hasNext(); i++ )
{
String column = (String) columns.next();
Utils.appendEscapedIdentifier(updateSQL, column);
updateSQL.append(" = ?");
if ( i < numColumns - 1 )
updateSQL.append(", ");
}
updateSQL.append( " WHERE " );
int numKeys = primaryKeys.size();
for ( int i = 0; i < numKeys; i++ )
{
PrimaryKey primaryKey = ((PrimaryKey) primaryKeys.get(i));
Utils.appendEscapedIdentifier(updateSQL, primaryKey.name);
updateSQL.append(" = ?");
if ( i < numKeys - 1 )
updateSQL.append(" and ");
}
if ( connection.getLogger().logDebug() )
connection.getLogger().debug("updating " + updateSQL.toString());
updateStatement = ((java.sql.Connection) connection).prepareStatement(updateSQL.toString());
int i = 0;
Iterator iterator = updateValues.values().iterator();
for (; iterator.hasNext(); i++)
{
Object o = iterator.next();
updateStatement.setObject( i + 1, o );
}
for ( int j = 0; j < numKeys; j++, i++)
{
updateStatement.setObject( i + 1, ((PrimaryKey) primaryKeys.get(j)).getValue() );
}
updateStatement.executeUpdate();
updateStatement.close();
updateStatement = null;
updateRowBuffer();
connection.getLogger().debug("copying data");
System.arraycopy(rowBuffer, 0, this_row, 0, rowBuffer.length);
rows.set( current_row, rowBuffer );
connection.getLogger().debug("done updates");
updateValues.clear();
doingUpdates = false;
}
public synchronized void updateShort(int columnIndex, short x)
throws SQLException
{
updateValue(columnIndex, new Short(x));
}
public synchronized void updateString(int columnIndex, String x)
throws SQLException
{
updateValue(columnIndex, x);
}
public synchronized void updateTime(int columnIndex, Time x)
throws SQLException
{
updateValue(columnIndex, x);
}
public synchronized void updateTimestamp(int columnIndex, Timestamp x)
throws SQLException
{
updateValue(columnIndex, x);
}
public synchronized void updateNull(String columnName)
throws SQLException
{
updateNull(findColumn(columnName));
}
public synchronized void updateBoolean(String columnName, boolean x)
throws SQLException
{
updateBoolean(findColumn(columnName), x);
}
public synchronized void updateByte(String columnName, byte x)
throws SQLException
{
updateByte(findColumn(columnName), x);
}
public synchronized void updateShort(String columnName, short x)
throws SQLException
{
updateShort(findColumn(columnName), x);
}
public synchronized void updateInt(String columnName, int x)
throws SQLException
{
updateInt(findColumn(columnName), x);
}
public synchronized void updateLong(String columnName, long x)
throws SQLException
{
updateLong(findColumn(columnName), x);
}
public synchronized void updateFloat(String columnName, float x)
throws SQLException
{
updateFloat(findColumn(columnName), x);
}
public synchronized void updateDouble(String columnName, double x)
throws SQLException
{
updateDouble(findColumn(columnName), x);
}
public synchronized void updateBigDecimal(String columnName, BigDecimal x)
throws SQLException
{
updateBigDecimal(findColumn(columnName), x);
}
public synchronized void updateString(String columnName, String x)
throws SQLException
{
updateString(findColumn(columnName), x);
}
public synchronized void updateBytes(String columnName, byte x[])
throws SQLException
{
updateBytes(findColumn(columnName), x);
}
public synchronized void updateDate(String columnName, java.sql.Date x)
throws SQLException
{
updateDate(findColumn(columnName), x);
}
public synchronized void updateTime(String columnName, java.sql.Time x)
throws SQLException
{
updateTime(findColumn(columnName), x);
}
public synchronized void updateTimestamp(String columnName, java.sql.Timestamp x)
throws SQLException
{
updateTimestamp(findColumn(columnName), x);
}
public synchronized void updateAsciiStream(
String columnName,
java.io.InputStream x,
int length)
throws SQLException
{
updateAsciiStream(findColumn(columnName), x, length);
}
public synchronized void updateBinaryStream(
String columnName,
java.io.InputStream x,
int length)
throws SQLException
{
updateBinaryStream(findColumn(columnName), x, length);
}
public synchronized void updateCharacterStream(
String columnName,
java.io.Reader reader,
int length)
throws SQLException
{
updateCharacterStream(findColumn(columnName), reader, length);
}
public synchronized void updateObject(String columnName, Object x, int scale)
throws SQLException
{
updateObject(findColumn(columnName), x);
}
public synchronized void updateObject(String columnName, Object x)
throws SQLException
{
updateObject(findColumn(columnName), x);
}
/**
* Is this ResultSet updateable?
*/
boolean isUpdateable() throws SQLException
{
checkClosed();
if (resultsetconcurrency == ResultSet.CONCUR_READ_ONLY)
throw new PSQLException(GT.tr("ResultSets with concurrency CONCUR_READ_ONLY cannot be updated."),
PSQLState.INVALID_CURSOR_STATE);
if (updateable)
return true;
connection.getLogger().debug("checking if rs is updateable");
parseQuery();
if ( singleTable == false )
{
connection.getLogger().debug("not a single table");
return false;
}
connection.getLogger().debug("getting primary keys");
//
// Contains the primary key?
//
primaryKeys = new ArrayList();
// this is not stricty jdbc spec, but it will make things much faster if used
// the user has to select oid, * from table and then we will just use oid
usingOID = false;
int oidIndex = findColumnIndex( "oid" ); // 0 if not present
int i = 0;
// if we find the oid then just use it
//oidIndex will be >0 if the oid was in the select list
if ( oidIndex > 0 )
{
i++;
primaryKeys.add( new PrimaryKey( oidIndex, "oid" ) );
usingOID = true;
}
else
{
// otherwise go and get the primary keys and create a list of keys
String[] s = quotelessTableName(tableName);
String quotelessTableName = s[0];
String quotelessSchemaName = s[1];
java.sql.ResultSet rs = ((java.sql.Connection) connection).getMetaData().getPrimaryKeys("", quotelessSchemaName, quotelessTableName);
for (; rs.next(); i++ )
{
String columnName = rs.getString(4); // get the columnName
int index = findColumn( columnName );
if ( index > 0 )
{
primaryKeys.add( new PrimaryKey(index, columnName ) ); // get the primary key information
}
}
rs.close();
}
if ( connection.getLogger().logDebug() )
connection.getLogger().debug( "no of keys=" + i );
if ( i < 1 )
{
throw new PSQLException(GT.tr("No primary key found for table {0}.", tableName),
PSQLState.DATA_ERROR);
}
updateable = primaryKeys.size() > 0;
if ( connection.getLogger().logDebug() )
connection.getLogger().debug( "checking primary key " + updateable );
return updateable;
}
/** Cracks out the table name and schema (if it exists) from a fully
* qualified table name.
* @param fullname string that we are trying to crack. Test cases:
* @return String array with element zero always being the tablename and
* element 1 the schema name which may be a zero length string.
*/
public static String[] quotelessTableName(String fullname) {
StringBuffer buf = new StringBuffer(fullname);
String[] parts = new String[] {null, ""};
StringBuffer acc = new StringBuffer();
boolean betweenQuotes = false;
for (int i = 0; i < buf.length(); i++)
{
char c = buf.charAt(i);
switch (c)
{
case '"':
if ((i < buf.length() - 1) && (buf.charAt(i + 1) == '"'))
{
// two consecutive quotes - keep one
i++;
acc.append(c); // keep the quote
}
else
{ // Discard it
betweenQuotes = !betweenQuotes;
}
break;
case '.':
if (betweenQuotes)
{ // Keep it
acc.append(c);
}
else
{ // Have schema name
parts[1] = acc.toString();
acc = new StringBuffer();
}
break;
default:
acc.append((betweenQuotes) ? c : Character.toLowerCase(c));
break;
}
}
// Always put table in slot 0
parts[0] = acc.toString();
return parts;
}
private void parseQuery()
{
String l_sql = originalQuery.toString(null);
StringTokenizer st = new StringTokenizer(l_sql, " \r\t\n");
boolean tableFound = false, tablesChecked = false;
String name = "";
singleTable = true;
while ( !tableFound && !tablesChecked && st.hasMoreTokens() )
{
name = st.nextToken();
if ( !tableFound )
{
if ("from".equalsIgnoreCase(name))
{
tableName = st.nextToken();
if ("only".equalsIgnoreCase(tableName)) {
tableName = st.nextToken();
onlyTable = "ONLY ";
}
tableFound = true;
}
}
else
{
tablesChecked = true;
// if the very next token is , then there are multiple tables
singleTable = !name.equalsIgnoreCase(",");
}
}
}
private void updateRowBuffer() throws SQLException
{
Iterator columns = updateValues.keySet().iterator();
while ( columns.hasNext() )
{
String columnName = (String) columns.next();
int columnIndex = findColumn( columnName ) - 1;
Object valueObject = updateValues.get(columnName);
if (valueObject instanceof NullObject)
{
rowBuffer[columnIndex] = null;
}
else
{
switch ( getSQLType(columnIndex + 1) )
{
//
// toString() isn't enough for date and time types; we must format it correctly
// or we won't be able to re-parse it.
//
case Types.DATE:
rowBuffer[columnIndex] =
connection.encodeString(connection.getTimestampUtils().toString(null, (Date)valueObject));
break;
case Types.TIME:
rowBuffer[columnIndex] =
connection.encodeString(connection.getTimestampUtils().toString(null, (Time)valueObject));
break;
case Types.TIMESTAMP:
rowBuffer[columnIndex] =
connection.encodeString(connection.getTimestampUtils().toString(null, (Timestamp)valueObject));
break;
case Types.NULL:
// Should never happen?
break;
case Types.BINARY:
case Types.LONGVARBINARY:
case Types.VARBINARY:
if (isBinary(columnIndex + 1)) {
rowBuffer[columnIndex] = (byte[]) valueObject;
} else {
try {
rowBuffer[columnIndex] = PGbytea.toPGString((byte[]) valueObject).getBytes("ISO-8859-1");
} catch (UnsupportedEncodingException e) {
throw new PSQLException(GT.tr("The JVM claims not to support the encoding: {0}", "ISO-8859-1"), PSQLState.UNEXPECTED_ERROR, e);
}
}
break;
default:
rowBuffer[columnIndex] = connection.encodeString(String.valueOf( valueObject));
break;
}
}
}
}
public class CursorResultHandler implements ResultHandler {
private SQLException error;
public void handleResultRows(Query fromQuery, Field[] fields, List tuples, ResultCursor cursor) {
AbstractJdbc2ResultSet.this.rows = tuples;
AbstractJdbc2ResultSet.this.cursor = cursor;
}
public void handleCommandStatus(String status, int updateCount, long insertOID) {
handleError(new PSQLException(GT.tr("Unexpected command status: {0}.", status),
PSQLState.PROTOCOL_VIOLATION));
}
public void handleWarning(SQLWarning warning) {
AbstractJdbc2ResultSet.this.addWarning(warning);
}
public void handleError(SQLException newError) {
if (error == null)
error = newError;
else
error.setNextException(newError);
}
public void handleCompletion() throws SQLException {
if (error != null)
throw error;
}
};
public BaseStatement getPGStatement() {
return statement;
}
//
// Backwards compatibility with PGRefCursorResultSet
//
private String refCursorName;
public String getRefCursor() {
// Can't check this because the PGRefCursorResultSet
// interface doesn't allow throwing a SQLException
//
// checkClosed();
return refCursorName;
}
private void setRefCursor(String refCursorName) {
this.refCursorName = refCursorName;
}
public void setFetchSize(int rows) throws SQLException
{
checkClosed();
if (rows < 0)
throw new PSQLException(GT.tr("Fetch size must be a value greater to or equal to 0."),
PSQLState.INVALID_PARAMETER_VALUE);
fetchSize = rows;
}
public int getFetchSize() throws SQLException
{
checkClosed();
return fetchSize;
}
public boolean next() throws SQLException
{
checkClosed();
if (onInsertRow)
throw new PSQLException(GT.tr("Can''t use relative move methods while on the insert row."),
PSQLState.INVALID_CURSOR_STATE);
if (current_row + 1 >= rows.size())
{
if (cursor == null || (maxRows > 0 && row_offset + rows.size() >= maxRows))
{
current_row = rows.size();
this_row = null;
rowBuffer = null;
return false; // End of the resultset.
}
// Ask for some more data.
row_offset += rows.size(); // We are discarding some data.
int fetchRows = fetchSize;
if (maxRows != 0)
{
if (fetchRows == 0 || row_offset + fetchRows > maxRows) // Fetch would exceed maxRows, limit it.
fetchRows = maxRows - row_offset;
}
// Execute the fetch and update this resultset.
connection.getQueryExecutor().fetch(cursor, new CursorResultHandler(), fetchRows);
current_row = 0;
// Test the new rows array.
if (rows.size() == 0)
{
this_row = null;
rowBuffer = null;
return false;
}
}
else
{
current_row++;
}
initRowBuffer();
return true;
}
public void close() throws SQLException
{
//release resources held (memory for tuples)
rows = null;
if (cursor != null) {
cursor.close();
cursor = null;
}
}
public boolean wasNull() throws SQLException
{
checkClosed();
return wasNullFlag;
}
public String getString(int columnIndex) throws SQLException
{
checkResultSet( columnIndex );
if (wasNullFlag)
return null;
// varchar in binary is same as text, other binary fields are converted to their text format
if (isBinary(columnIndex) && getSQLType(columnIndex) != Types.VARCHAR) {
Object obj = internalGetObject(columnIndex, fields[columnIndex - 1]);
if (obj == null) {
return null;
}
// hack to be compatible with text protocol
if (obj instanceof java.util.Date) {
return connection.getTimestampUtils().timeToString((java.util.Date) obj);
}
if ("hstore".equals(getPGType(columnIndex))) {
return HStoreConverter.toString((Map) obj);
}
return trimString(columnIndex, obj.toString());
}
Encoding encoding = connection.getEncoding();
try
{
return trimString(columnIndex, encoding.decode(this_row[columnIndex - 1]));
}
catch (IOException ioe)
{
throw new PSQLException(GT.tr("Invalid character data was found. This is most likely caused by stored data containing characters that are invalid for the character set the database was created in. The most common example of this is storing 8bit data in a SQL_ASCII database."), PSQLState.DATA_ERROR, ioe);
}
}
public boolean getBoolean(int columnIndex) throws SQLException
{
checkResultSet(columnIndex);
if (wasNullFlag)
return false; // SQL NULL
if (isBinary(columnIndex)) {
int col = columnIndex - 1;
return readDoubleValue(this_row[col], fields[col].getOID(),
"boolean") == 1;
}
return toBoolean( getString(columnIndex) );
}
private static final BigInteger BYTEMAX = new BigInteger(Byte.toString(Byte.MAX_VALUE));
private static final BigInteger BYTEMIN = new BigInteger(Byte.toString(Byte.MIN_VALUE));
public byte getByte(int columnIndex) throws SQLException
{
checkResultSet(columnIndex);
if (wasNullFlag)
return 0; // SQL NULL
if (isBinary(columnIndex)) {
int col = columnIndex - 1;
// there is no Oid for byte so must always do conversion from
// some other numeric type
return (byte)
readLongValue(this_row[col], fields[col].getOID(), Byte.MIN_VALUE,
Byte.MAX_VALUE, "byte");
}
String s = getString(columnIndex);
if (s != null )
{
s = s.trim();
if ( s.length() == 0 )
return 0;
try
{
// try the optimal parse
return Byte.parseByte(s);
}
catch (NumberFormatException e)
{
// didn't work, assume the column is not a byte
try
{
BigDecimal n = new BigDecimal(s);
BigInteger i = n.toBigInteger();
int gt = i.compareTo(BYTEMAX);
int lt = i.compareTo(BYTEMIN);
if ( gt > 0 || lt < 0 )
{
throw new PSQLException(GT.tr("Bad value for type {0} : {1}", new Object[]{"byte",s}),
PSQLState.NUMERIC_VALUE_OUT_OF_RANGE);
}
return i.byteValue();
}
catch ( NumberFormatException ex )
{
throw new PSQLException(GT.tr("Bad value for type {0} : {1}", new Object[]{"byte",s}),
PSQLState.NUMERIC_VALUE_OUT_OF_RANGE);
}
}
}
return 0; // SQL NULL
}
private static final BigInteger SHORTMAX = new BigInteger(Short.toString(Short.MAX_VALUE));
private static final BigInteger SHORTMIN = new BigInteger(Short.toString(Short.MIN_VALUE));
public short getShort(int columnIndex) throws SQLException
{
checkResultSet(columnIndex);
if (wasNullFlag)
return 0; // SQL NULL
if (isBinary(columnIndex)) {
int col = columnIndex - 1;
int oid = fields[col].getOID();
if (oid == Oid.INT2) {
return ByteConverter.int2(this_row[col], 0);
}
return (short) readLongValue(this_row[col], oid, Short.MIN_VALUE,
Short.MAX_VALUE, "short");
}
String s = getFixedString(columnIndex);
if (s != null)
{
s = s.trim();
try
{
return Short.parseShort(s);
}
catch (NumberFormatException e)
{
try
{
BigDecimal n = new BigDecimal(s);
BigInteger i = n.toBigInteger();
int gt = i.compareTo(SHORTMAX);
int lt = i.compareTo(SHORTMIN);
if ( gt > 0 || lt < 0 )
{
throw new PSQLException(GT.tr("Bad value for type {0} : {1}", new Object[]{"short",s}),
PSQLState.NUMERIC_VALUE_OUT_OF_RANGE);
}
return i.shortValue();
}
catch ( NumberFormatException ne )
{
throw new PSQLException(GT.tr("Bad value for type {0} : {1}", new Object[]{"short",s}),
PSQLState.NUMERIC_VALUE_OUT_OF_RANGE);
}
}
}
return 0; // SQL NULL
}
public int getInt(int columnIndex) throws SQLException
{
checkResultSet(columnIndex);
if (wasNullFlag)
return 0; // SQL NULL
if (isBinary(columnIndex)) {
int col = columnIndex - 1;
int oid = fields[col].getOID();
if (oid == Oid.INT4) {
return ByteConverter.int4(this_row[col], 0);
}
return (int) readLongValue(this_row[col], oid, Integer.MIN_VALUE,
Integer.MAX_VALUE, "int");
}
Encoding encoding = connection.getEncoding();
if (encoding.hasAsciiNumbers()) {
try {
return getFastInt(columnIndex);
} catch (NumberFormatException ex) {
}
}
return toInt( getFixedString(columnIndex) );
}
public long getLong(int columnIndex) throws SQLException
{
checkResultSet(columnIndex);
if (wasNullFlag)
return 0; // SQL NULL
if (isBinary(columnIndex)) {
int col = columnIndex - 1;
int oid = fields[col].getOID();
if (oid == Oid.INT8) {
return ByteConverter.int8(this_row[col], 0);
}
return readLongValue(this_row[col], oid, Long.MIN_VALUE,
Long.MAX_VALUE, "long");
}
Encoding encoding = connection.getEncoding();
if (encoding.hasAsciiNumbers()) {
try {
return getFastLong(columnIndex);
} catch (NumberFormatException ex) {
}
}
return toLong( getFixedString(columnIndex) );
}
/**
* A dummy exception thrown when fast byte[] to number parsing fails and
* no value can be returned. The exact stack trace does not matter because
* the exception is always caught and is not visible to users.
*/
private static final NumberFormatException FAST_NUMBER_FAILED =
new NumberFormatException();
/**
* Optimised byte[] to number parser. This code does not
* handle null values, so the caller must do checkResultSet
* and handle null values prior to calling this function.
*
* @param columnIndex The column to parse.
* @return The parsed number.
* @throws SQLException If an error occurs while fetching column.
* @throws NumberFormatException If the number is invalid or the
* out of range for fast parsing. The value must then be parsed by
* {@link #toLong(String)}.
*/
private long getFastLong(int columnIndex) throws SQLException,
NumberFormatException {
byte[] bytes = this_row[columnIndex - 1];
if (bytes.length == 0) {
throw FAST_NUMBER_FAILED;
}
long val = 0;
int start;
boolean neg;
if (bytes[0] == '-') {
neg = true;
start = 1;
if (bytes.length == 1 || bytes.length > 19) {
throw FAST_NUMBER_FAILED;
}
} else {
start = 0;
neg = false;
if (bytes.length > 18) {
throw FAST_NUMBER_FAILED;
}
}
while (start < bytes.length) {
byte b = bytes[start++];
if (b < '0' || b > '9') {
throw FAST_NUMBER_FAILED;
}
val *= 10;
val += b - '0';
}
if (neg) {
val = -val;
}
return val;
}
/**
* Optimised byte[] to number parser. This code does not
* handle null values, so the caller must do checkResultSet
* and handle null values prior to calling this function.
*
* @param columnIndex The column to parse.
* @return The parsed number.
* @throws SQLException If an error occurs while fetching column.
* @throws NumberFormatException If the number is invalid or the
* out of range for fast parsing. The value must then be parsed by
* {@link #toInt(String)}.
*/
private int getFastInt(int columnIndex) throws SQLException,
NumberFormatException {
byte[] bytes = this_row[columnIndex - 1];
if (bytes.length == 0) {
throw FAST_NUMBER_FAILED;
}
int val = 0;
int start;
boolean neg;
if (bytes[0] == '-') {
neg = true;
start = 1;
if (bytes.length == 1 || bytes.length > 10) {
throw FAST_NUMBER_FAILED;
}
} else {
start = 0;
neg = false;
if (bytes.length > 9) {
throw FAST_NUMBER_FAILED;
}
}
while (start < bytes.length) {
byte b = bytes[start++];
if (b < '0' || b > '9') {
throw FAST_NUMBER_FAILED;
}
val *= 10;
val += b - '0';
}
if (neg) {
val = -val;
}
return val;
}
/**
* Optimised byte[] to number parser. This code does not
* handle null values, so the caller must do checkResultSet
* and handle null values prior to calling this function.
*
* @param columnIndex The column to parse.
* @return The parsed number.
* @throws SQLException If an error occurs while fetching column.
* @throws NumberFormatException If the number is invalid or the
* out of range for fast parsing. The value must then be parsed by
* {@link #toBigDecimal(String)}.
*/
private BigDecimal getFastBigDecimal(int columnIndex) throws SQLException,
NumberFormatException {
byte[] bytes = this_row[columnIndex - 1];
if (bytes.length == 0) {
throw FAST_NUMBER_FAILED;
}
int scale = 0;
long val = 0;
int start;
boolean neg;
if (bytes[0] == '-') {
neg = true;
start = 1;
if (bytes.length == 1 || bytes.length > 19) {
throw FAST_NUMBER_FAILED;
}
} else {
start = 0;
neg = false;
if (bytes.length > 18) {
throw FAST_NUMBER_FAILED;
}
}
int periodsSeen = 0;
while (start < bytes.length) {
byte b = bytes[start++];
if (b < '0' || b > '9') {
if (b == '.') {
scale = bytes.length - start;
periodsSeen++;
continue;
} else
throw FAST_NUMBER_FAILED;
}
val *= 10;
val += b - '0';
}
int numNonSignChars = neg ? bytes.length - 1 : bytes.length;
if (periodsSeen > 1 || periodsSeen == numNonSignChars)
throw FAST_NUMBER_FAILED;
if (neg) {
val = -val;
}
return BigDecimal.valueOf(val, scale);
}
public float getFloat(int columnIndex) throws SQLException
{
checkResultSet(columnIndex);
if (wasNullFlag)
return 0; // SQL NULL
if (isBinary(columnIndex)) {
int col = columnIndex - 1;
int oid = fields[col].getOID();
if (oid == Oid.FLOAT4) {
return ByteConverter.float4(this_row[col], 0);
}
return (float) readDoubleValue(this_row[col], oid, "float");
}
return toFloat( getFixedString(columnIndex) );
}
public double getDouble(int columnIndex) throws SQLException
{
checkResultSet(columnIndex);
if (wasNullFlag)
return 0; // SQL NULL
if (isBinary(columnIndex)) {
int col = columnIndex - 1;
int oid = fields[col].getOID();
if (oid == Oid.FLOAT8) {
return ByteConverter.float8(this_row[col], 0);
}
return readDoubleValue(this_row[col], oid, "double");
}
return toDouble( getFixedString(columnIndex) );
}
public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException
{
checkResultSet(columnIndex);
if (wasNullFlag)
return null;
Encoding encoding = connection.getEncoding();
if (encoding.hasAsciiNumbers()) {
try {
return getFastBigDecimal(columnIndex);
} catch (NumberFormatException ex) {
}
}
return toBigDecimal( getFixedString(columnIndex), scale );
}
/*
* Get the value of a column in the current row as a Java byte array.
*
*
In normal use, the bytes represent the raw values returned by the
* backend. However, if the column is an OID, then it is assumed to
* refer to a Large Object, and that object is returned as a byte array.
*
*
Be warned If the large object is huge, then you may run out
* of memory.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @return the column value; if the value is SQL NULL, the result
* is null
* @exception SQLException if a database access error occurs
*/
public byte[] getBytes(int columnIndex) throws SQLException
{
checkResultSet( columnIndex );
if (wasNullFlag)
return null;
if (isBinary(columnIndex))
{
//If the data is already binary then just return it
return this_row[columnIndex - 1];
}
else if (connection.haveMinimumCompatibleVersion("7.2"))
{
//Version 7.2 supports the bytea datatype for byte arrays
if (fields[columnIndex - 1].getOID() == Oid.BYTEA)
{
return trimBytes(columnIndex, PGbytea.toBytes(this_row[columnIndex - 1]));
}
else
{
return trimBytes(columnIndex, this_row[columnIndex - 1]);
}
}
else
{
//Version 7.1 and earlier supports LargeObjects for byte arrays
// Handle OID's as BLOBS
if ( fields[columnIndex - 1].getOID() == Oid.OID)
{
LargeObjectManager lom = connection.getLargeObjectAPI();
LargeObject lob = lom.open(getLong(columnIndex));
byte buf[] = lob.read(lob.size());
lob.close();
return trimBytes(columnIndex, buf);
}
else
{
return trimBytes(columnIndex, this_row[columnIndex - 1]);
}
}
}
public java.sql.Date getDate(int columnIndex) throws SQLException
{
return getDate(columnIndex, null);
}
public Time getTime(int columnIndex) throws SQLException
{
return getTime(columnIndex, null);
}
public Timestamp getTimestamp(int columnIndex) throws SQLException
{
return getTimestamp(columnIndex, null);
}
public InputStream getAsciiStream(int columnIndex) throws SQLException
{
checkResultSet( columnIndex );
if (wasNullFlag)
return null;
if (connection.haveMinimumCompatibleVersion("7.2"))
{
//Version 7.2 supports AsciiStream for all the PG text types
//As the spec/javadoc for this method indicate this is to be used for
//large text values (i.e. LONGVARCHAR) PG doesn't have a separate
//long string datatype, but with toast the text datatype is capable of
//handling very large values. Thus the implementation ends up calling
//getString() since there is no current way to stream the value from the server
try
{
return new ByteArrayInputStream(getString(columnIndex).getBytes("ASCII"));
}
catch (UnsupportedEncodingException l_uee)
{
throw new PSQLException(GT.tr("The JVM claims not to support the encoding: {0}","ASCII"), PSQLState.UNEXPECTED_ERROR, l_uee);
}
}
else
{
// In 7.1 Handle as BLOBS so return the LargeObject input stream
return getBinaryStream(columnIndex);
}
}
public InputStream getUnicodeStream(int columnIndex) throws SQLException
{
checkResultSet( columnIndex );
if (wasNullFlag)
return null;
if (connection.haveMinimumCompatibleVersion("7.2"))
{
//Version 7.2 supports AsciiStream for all the PG text types
//As the spec/javadoc for this method indicate this is to be used for
//large text values (i.e. LONGVARCHAR) PG doesn't have a separate
//long string datatype, but with toast the text datatype is capable of
//handling very large values. Thus the implementation ends up calling
//getString() since there is no current way to stream the value from the server
try
{
return new ByteArrayInputStream(getString(columnIndex).getBytes("UTF-8"));
}
catch (UnsupportedEncodingException l_uee)
{
throw new PSQLException(GT.tr("The JVM claims not to support the encoding: {0}","UTF-8"), PSQLState.UNEXPECTED_ERROR, l_uee);
}
}
else
{
// In 7.1 Handle as BLOBS so return the LargeObject input stream
return getBinaryStream(columnIndex);
}
}
public InputStream getBinaryStream(int columnIndex) throws SQLException
{
checkResultSet( columnIndex );
if (wasNullFlag)
return null;
if (connection.haveMinimumCompatibleVersion("7.2"))
{
//Version 7.2 supports BinaryStream for all PG bytea type
//As the spec/javadoc for this method indicate this is to be used for
//large binary values (i.e. LONGVARBINARY) PG doesn't have a separate
//long binary datatype, but with toast the bytea datatype is capable of
//handling very large values. Thus the implementation ends up calling
//getBytes() since there is no current way to stream the value from the server
byte b[] = getBytes(columnIndex);
if (b != null)
return new ByteArrayInputStream(b);
}
else
{
// In 7.1 Handle as BLOBS so return the LargeObject input stream
if ( fields[columnIndex - 1].getOID() == Oid.OID)
{
LargeObjectManager lom = connection.getLargeObjectAPI();
LargeObject lob = lom.open(getLong(columnIndex));
return lob.getInputStream();
}
}
return null;
}
public String getString(String columnName) throws SQLException
{
return getString(findColumn(columnName));
}
public boolean getBoolean(String columnName) throws SQLException
{
return getBoolean(findColumn(columnName));
}
public byte getByte(String columnName) throws SQLException
{
return getByte(findColumn(columnName));
}
public short getShort(String columnName) throws SQLException
{
return getShort(findColumn(columnName));
}
public int getInt(String columnName) throws SQLException
{
return getInt(findColumn(columnName));
}
public long getLong(String columnName) throws SQLException
{
return getLong(findColumn(columnName));
}
public float getFloat(String columnName) throws SQLException
{
return getFloat(findColumn(columnName));
}
public double getDouble(String columnName) throws SQLException
{
return getDouble(findColumn(columnName));
}
public BigDecimal getBigDecimal(String columnName, int scale) throws SQLException
{
return getBigDecimal(findColumn(columnName), scale);
}
public byte[] getBytes(String columnName) throws SQLException
{
return getBytes(findColumn(columnName));
}
public java.sql.Date getDate(String columnName) throws SQLException
{
return getDate(findColumn(columnName), null);
}
public Time getTime(String columnName) throws SQLException
{
return getTime(findColumn(columnName), null);
}
public Timestamp getTimestamp(String columnName) throws SQLException
{
return getTimestamp(findColumn(columnName), null);
}
public InputStream getAsciiStream(String columnName) throws SQLException
{
return getAsciiStream(findColumn(columnName));
}
public InputStream getUnicodeStream(String columnName) throws SQLException
{
return getUnicodeStream(findColumn(columnName));
}
public InputStream getBinaryStream(String columnName) throws SQLException
{
return getBinaryStream(findColumn(columnName));
}
public SQLWarning getWarnings() throws SQLException
{
checkClosed();
return warnings;
}
public void clearWarnings() throws SQLException
{
checkClosed();
warnings = null;
}
protected void addWarning(SQLWarning warnings)
{
if (this.warnings != null)
this.warnings.setNextWarning(warnings);
else
this.warnings = warnings;
}
public String getCursorName() throws SQLException
{
checkClosed();
return null;
}
/*
* Get the value of a column in the current row as a Java object
*
*
This method will return the value of the given column as a
* Java object. The type of the Java object will be the default
* Java Object type corresponding to the column's SQL type, following
* the mapping specified in the JDBC specification.
*
*
This method may also be used to read database specific abstract
* data types.
*
* @param columnIndex the first column is 1, the second is 2...
* @return a Object holding the column value
* @exception SQLException if a database access error occurs
*/
public Object getObject(int columnIndex) throws SQLException {
Field field;
checkResultSet(columnIndex);
if (wasNullFlag)
return null;
field = fields[columnIndex - 1];
// some fields can be null, mainly from those returned by MetaData methods
if (field == null)
{
wasNullFlag = true;
return null;
}
Object result = internalGetObject(columnIndex, field);
if (result != null)
return result;
if (isBinary(columnIndex)) {
return connection.getObject(getPGType(columnIndex), null, this_row[columnIndex - 1]);
}
return connection.getObject(getPGType(columnIndex), getString(columnIndex), null);
}
public Object getObject(String columnName) throws SQLException
{
return getObject(findColumn(columnName));
}
/*
* Map a ResultSet column name to a ResultSet column index
*/
public int findColumn(String columnName) throws SQLException
{
checkClosed();
int col = findColumnIndex(columnName);
if (col == 0)
throw new PSQLException (GT.tr("The column name {0} was not found in this ResultSet.", columnName),
PSQLState.UNDEFINED_COLUMN);
return col;
}
private int findColumnIndex(String columnName)
{
if (columnNameIndexMap == null)
{
columnNameIndexMap = new HashMap(fields.length * 2);
// The JDBC spec says when you have duplicate columns names,
// the first one should be returned. So load the map in
// reverse order so the first ones will overwrite later ones.
for (int i = fields.length - 1; i >= 0; i--)
{
columnNameIndexMap.put(fields[i].getColumnLabel().toLowerCase(Locale.US), new Integer(i + 1));
}
}
Integer index = (Integer)columnNameIndexMap.get(columnName);
if (index != null)
{
return index.intValue();
}
index = (Integer)columnNameIndexMap.get(columnName.toLowerCase(Locale.US));
if (index != null)
{
columnNameIndexMap.put(columnName, index);
return index.intValue();
}
return 0;
}
/*
* returns the OID of a field.
* It is used internally by the driver.
*/
public int getColumnOID(int field)
{
return fields[field -1].getOID();
}
/*
* This is used to fix get*() methods on Money fields. It should only be
* used by those methods!
*
* It converts ($##.##) to -##.## and $##.## to ##.##
*/
public String getFixedString(int col) throws SQLException
{
String s = getString(col);
if (s == null)
return null;
// if we don't have at least 2 characters it can't be money.
if (s.length() < 2)
return s;
// Handle Money
char ch = s.charAt(0);
// optimise for non-money type: return immediately with one check
// if the first char cannot be '(', '$' or '-'
if (ch > '-') {
return s;
}
if (ch == '(')
{
s = "-" + PGtokenizer.removePara(s).substring(1);
}
else if (ch == '$')
{
s = s.substring(1);
}
else if (ch == '-' && s.charAt(1) == '$')
{
s = "-" + s.substring(2);
}
return s;
}
protected String getPGType( int column ) throws SQLException
{
return connection.getTypeInfo().getPGType(fields[column - 1].getOID());
}
protected int getSQLType( int column ) throws SQLException
{
return connection.getTypeInfo().getSQLType(fields[column - 1].getOID());
}
private void checkUpdateable() throws SQLException
{
checkClosed();
if (!isUpdateable())
throw new PSQLException(GT.tr("ResultSet is not updateable. The query that generated this result set must select only one table, and must select all primary keys from that table. See the JDBC 2.1 API Specification, section 5.6 for more details."),
PSQLState.INVALID_CURSOR_STATE);
if (updateValues == null)
{
// allow every column to be updated without a rehash.
updateValues = new HashMap((int)(fields.length / 0.75), 0.75f);
}
}
protected void checkClosed() throws SQLException {
if (rows == null)
throw new PSQLException(GT.tr("This ResultSet is closed."), PSQLState.OBJECT_NOT_IN_STATE);
}
protected void checkColumnIndex(int column) throws SQLException
{
if ( column < 1 || column > fields.length )
throw new PSQLException(GT.tr("The column index is out of range: {0}, number of columns: {1}.", new Object[]{new Integer(column), new Integer(fields.length)}), PSQLState.INVALID_PARAMETER_VALUE );
}
/**
* Checks that the result set is not closed, it's positioned on a
* valid row and that the given column number is valid. Also
* updates the {@link #wasNullFlag} to correct value.
*
* @param column The column number to check. Range starts from 1.
* @throws SQLException If state or column is invalid.
*/
protected void checkResultSet( int column ) throws SQLException
{
checkClosed();
if ( this_row == null )
throw new PSQLException(GT.tr("ResultSet not positioned properly, perhaps you need to call next."),
PSQLState.INVALID_CURSOR_STATE);
checkColumnIndex(column);
wasNullFlag = (this_row[column - 1] == null);
}
/**
* Returns true if the value of the given column is in binary format.
*
* @param column The column to check. Range starts from 1.
* @return True if the column is in binary format.
*/
protected boolean isBinary(int column) {
return fields[column - 1].getFormat() == Field.BINARY_FORMAT;
}
//----------------- Formatting Methods -------------------
public static boolean toBoolean(String s)
{
if (s != null)
{
s = s.trim();
if (s.equalsIgnoreCase("t") || s.equalsIgnoreCase("true") || s.equals("1"))
return true;
if (s.equalsIgnoreCase("f") || s.equalsIgnoreCase("false") || s.equals("0"))
return false;
try
{
if (Double.valueOf(s).doubleValue() == 1)
return true;
}
catch (NumberFormatException e)
{
}
}
return false; // SQL NULL
}
private static final BigInteger INTMAX = new BigInteger(Integer.toString(Integer.MAX_VALUE));
private static final BigInteger INTMIN = new BigInteger(Integer.toString(Integer.MIN_VALUE));
public static int toInt(String s) throws SQLException
{
if (s != null)
{
try
{
s = s.trim();
return Integer.parseInt(s);
}
catch (NumberFormatException e)
{
try
{
BigDecimal n = new BigDecimal(s);
BigInteger i = n.toBigInteger();
int gt = i.compareTo(INTMAX);
int lt = i.compareTo(INTMIN);
if (gt > 0 || lt < 0)
{
throw new PSQLException(GT.tr("Bad value for type {0} : {1}", new Object[]{"int",s}),
PSQLState.NUMERIC_VALUE_OUT_OF_RANGE);
}
return i.intValue();
}
catch ( NumberFormatException ne )
{
throw new PSQLException(GT.tr("Bad value for type {0} : {1}", new Object[]{"int",s}),
PSQLState.NUMERIC_VALUE_OUT_OF_RANGE);
}
}
}
return 0; // SQL NULL
}
private final static BigInteger LONGMAX = new BigInteger(Long.toString(Long.MAX_VALUE));
private final static BigInteger LONGMIN = new BigInteger(Long.toString(Long.MIN_VALUE));
public static long toLong(String s) throws SQLException
{
if (s != null)
{
try
{
s = s.trim();
return Long.parseLong(s);
}
catch (NumberFormatException e)
{
try
{
BigDecimal n = new BigDecimal(s);
BigInteger i = n.toBigInteger();
int gt = i.compareTo(LONGMAX);
int lt = i.compareTo(LONGMIN);
if ( gt > 0 || lt < 0 )
{
throw new PSQLException(GT.tr("Bad value for type {0} : {1}", new Object[]{"long",s}),
PSQLState.NUMERIC_VALUE_OUT_OF_RANGE);
}
return i.longValue();
}
catch ( NumberFormatException ne )
{
throw new PSQLException(GT.tr("Bad value for type {0} : {1}", new Object[]{"long",s}),
PSQLState.NUMERIC_VALUE_OUT_OF_RANGE);
}
}
}
return 0; // SQL NULL
}
public static BigDecimal toBigDecimal(String s, int scale) throws SQLException
{
BigDecimal val;
if (s != null)
{
try
{
s = s.trim();
val = new BigDecimal(s);
}
catch (NumberFormatException e)
{
throw new PSQLException(GT.tr("Bad value for type {0} : {1}", new Object[]{"BigDecimal",s}),
PSQLState.NUMERIC_VALUE_OUT_OF_RANGE);
}
if (scale == -1)
return val;
try
{
return val.setScale(scale);
}
catch (ArithmeticException e)
{
throw new PSQLException(GT.tr("Bad value for type {0} : {1}", new Object[]{"BigDecimal",s}),
PSQLState.NUMERIC_VALUE_OUT_OF_RANGE);
}
}
return null; // SQL NULL
}
public static float toFloat(String s) throws SQLException
{
if (s != null)
{
try
{
s = s.trim();
return Float.parseFloat(s);
}
catch (NumberFormatException e)
{
throw new PSQLException(GT.tr("Bad value for type {0} : {1}", new Object[]{"float",s}),
PSQLState.NUMERIC_VALUE_OUT_OF_RANGE);
}
}
return 0; // SQL NULL
}
public static double toDouble(String s) throws SQLException
{
if (s != null)
{
try
{
s = s.trim();
return Double.parseDouble(s);
}
catch (NumberFormatException e)
{
throw new PSQLException(GT.tr("Bad value for type {0} : {1}", new Object[]{"double",s}),
PSQLState.NUMERIC_VALUE_OUT_OF_RANGE);
}
}
return 0; // SQL NULL
}
private void initRowBuffer()
{
this_row = (byte[][]) rows.get(current_row);
// We only need a copy of the current row if we're going to
// modify it via an updatable resultset.
if (resultsetconcurrency == ResultSet.CONCUR_UPDATABLE) {
rowBuffer = new byte[this_row.length][];
System.arraycopy(this_row, 0, rowBuffer, 0, this_row.length);
} else {
rowBuffer = null;
}
}
private boolean isColumnTrimmable(int columnIndex) throws SQLException
{
switch (getSQLType(columnIndex))
{
case Types.CHAR:
case Types.VARCHAR:
case Types.LONGVARCHAR:
case Types.BINARY:
case Types.VARBINARY:
case Types.LONGVARBINARY:
return true;
}
return false;
}
private byte[] trimBytes(int p_columnIndex, byte[] p_bytes) throws SQLException
{
//we need to trim if maxsize is set and the length is greater than maxsize and the
//type of this column is a candidate for trimming
if (maxFieldSize > 0 && p_bytes.length > maxFieldSize && isColumnTrimmable(p_columnIndex))
{
byte[] l_bytes = new byte[maxFieldSize];
System.arraycopy (p_bytes, 0, l_bytes, 0, maxFieldSize);
return l_bytes;
}
else
{
return p_bytes;
}
}
private String trimString(int p_columnIndex, String p_string) throws SQLException
{
//we need to trim if maxsize is set and the length is greater than maxsize and the
//type of this column is a candidate for trimming
if (maxFieldSize > 0 && p_string.length() > maxFieldSize && isColumnTrimmable(p_columnIndex))
{
return p_string.substring(0, maxFieldSize);
}
else
{
return p_string;
}
}
/**
* Converts any numeric binary field to double value. This method
* does no overflow checking.
*
* @param bytes The bytes of the numeric field.
* @param oid The oid of the field.
* @param targetType The target type. Used for error reporting.
* @return The value as double.
* @throws PSQLException If the field type is not supported numeric type.
*/
private double readDoubleValue(byte[] bytes, int oid,
String targetType) throws PSQLException {
// currently implemented binary encoded fields
switch (oid) {
case Oid.INT2:
return ByteConverter.int2(bytes, 0);
case Oid.INT4:
return ByteConverter.int4(bytes, 0);
case Oid.INT8:
// might not fit but there still should be no overflow checking
return ByteConverter.int8(bytes, 0);
case Oid.FLOAT4:
return ByteConverter.float4(bytes, 0);
case Oid.FLOAT8:
return ByteConverter.float8(bytes, 0);
}
throw new PSQLException (GT.tr("Cannot convert the column of type {0} to requested type {1}.",
new Object[]{Oid.toString(oid), targetType}),
PSQLState.DATA_TYPE_MISMATCH);
}
/**
* Converts any numeric binary field to long value.
*
* This method is used by getByte,getShort,getInt and getLong.
* It must support a subset of the following java types that use Binary
* encoding. (fields that use text encoding use a different code path).
*
* byte,short,int,long,float,double,BigDecimal,boolean,string.
* @param bytes The bytes of the numeric field.
* @param oid The oid of the field.
* @param minVal the minimum value allowed.
* @param minVal the maximum value allowed.
* @param targetType The target type. Used for error reporting.
* @return The value as long.
* @throws PSQLException If the field type is not supported numeric type
* or if the value is out of range.
*/
private long readLongValue(byte[] bytes, int oid, long minVal, long maxVal,
String targetType)
throws PSQLException {
long val;
// currently implemented binary encoded fields
switch (oid) {
case Oid.INT2:
val = ByteConverter.int2(bytes, 0);
break;
case Oid.INT4:
val = ByteConverter.int4(bytes, 0);
break;
case Oid.INT8:
val = ByteConverter.int8(bytes, 0);
break;
case Oid.FLOAT4:
val = (long) ByteConverter.float4(bytes, 0);
break;
case Oid.FLOAT8:
val = (long) ByteConverter.float8(bytes, 0);
break;
default:
throw new PSQLException (GT.tr("Cannot convert the column of type {0} to requested type {1}.",
new Object[]{Oid.toString(oid), targetType}),
PSQLState.DATA_TYPE_MISMATCH);
}
if (val < minVal || val > maxVal) {
throw new PSQLException(GT.tr("Bad value for type {0} : {1}", new Object[]{targetType, new Long(val)}),
PSQLState.NUMERIC_VALUE_OUT_OF_RANGE);
}
return val;
}
protected void updateValue(int columnIndex, Object value) throws SQLException {
checkUpdateable();
if (!onInsertRow && (isBeforeFirst() || isAfterLast() || rows.size() == 0))
{
throw new PSQLException(GT.tr("Cannot update the ResultSet because it is either before the start or after the end of the results."),
PSQLState.INVALID_CURSOR_STATE);
}
checkColumnIndex(columnIndex);
doingUpdates = !onInsertRow;
if (value == null) {
updateNull(columnIndex);
} else {
PGResultSetMetaData md = (PGResultSetMetaData)getMetaData();
updateValues.put(md.getBaseColumnName(columnIndex), value);
}
}
/**
* Newer JVMs will return a java.util.UUID object, but it isn't
* available in older versions.
*/
protected Object getUUID(String data) throws SQLException
{
return data;
}
/**
* Newer JVMs will return a java.util.UUID object, but it isn't
* available in older versions.
*/
protected Object getUUID(byte[] data) throws SQLException
{
return data;
}
private class PrimaryKey
{
int index; // where in the result set is this primaryKey
String name; // what is the columnName of this primary Key
PrimaryKey( int index, String name)
{
this.index = index;
this.name = name;
}
Object getValue() throws SQLException
{
return getObject(index);
}
};
//
// We need to specify the type of NULL when updating a column to NULL, so
// NullObject is a simple extension of PGobject that always returns null
// values but retains column type info.
//
static class NullObject extends PGobject {
NullObject(String type) {
setType(type);
}
public String getValue() {
return null;
}
};
/**
* Used to add rows to an already existing ResultSet that exactly
* match the existing rows. Currently only used for assembling
* generated keys from batch statement execution.
*/
void addRows(List tuples) {
rows.addAll(tuples);
}
public void registerRealStatement(Statement realStatement) {
this.realStatement = realStatement;
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc2/AbstractJdbc2ResultSetMetaData.java 0000664 0000000 0000000 00000037513 12050675701 0030356 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc2;
import org.postgresql.PGResultSetMetaData;
import org.postgresql.core.*;
import org.postgresql.util.PSQLException;
import org.postgresql.util.PSQLState;
import java.sql.*;
import org.postgresql.util.GT;
public abstract class AbstractJdbc2ResultSetMetaData implements PGResultSetMetaData
{
protected final BaseConnection connection;
protected final Field[] fields;
private boolean fieldInfoFetched;
/*
* Initialise for a result with a tuple set and
* a field descriptor set
*
* @param fields the array of field descriptors
*/
public AbstractJdbc2ResultSetMetaData(BaseConnection connection, Field[] fields)
{
this.connection = connection;
this.fields = fields;
fieldInfoFetched = false;
}
/*
* Whats the number of columns in the ResultSet?
*
* @return the number
* @exception SQLException if a database access error occurs
*/
public int getColumnCount() throws SQLException
{
return fields.length;
}
/*
* Is the column automatically numbered (and thus read-only)
* I believe that PostgreSQL does not support this feature.
*
* @param column the first column is 1, the second is 2...
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean isAutoIncrement(int column) throws SQLException
{
fetchFieldMetaData();
Field field = getField(column);
return field.getAutoIncrement();
}
/*
* Does a column's case matter? ASSUMPTION: Any field that is
* not obviously case insensitive is assumed to be case sensitive
*
* @param column the first column is 1, the second is 2...
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean isCaseSensitive(int column) throws SQLException
{
Field field = getField(column);
return connection.getTypeInfo().isCaseSensitive(field.getOID());
}
/*
* Can the column be used in a WHERE clause? Basically for
* this, I split the functions into two types: recognised
* types (which are always useable), and OTHER types (which
* may or may not be useable). The OTHER types, for now, I
* will assume they are useable. We should really query the
* catalog to see if they are useable.
*
* @param column the first column is 1, the second is 2...
* @return true if they can be used in a WHERE clause
* @exception SQLException if a database access error occurs
*/
public boolean isSearchable(int column) throws SQLException
{
return true;
}
/*
* Is the column a cash value? 6.1 introduced the cash/money
* type, which haven't been incorporated as of 970414, so I
* just check the type name for both 'cash' and 'money'
*
* @param column the first column is 1, the second is 2...
* @return true if its a cash column
* @exception SQLException if a database access error occurs
*/
public boolean isCurrency(int column) throws SQLException
{
String type_name = getPGType(column);
return type_name.equals("cash") || type_name.equals("money");
}
/*
* Indicates the nullability of values in the designated column.
*
* @param column the first column is 1, the second is 2...
* @return one of the columnNullable values
* @exception SQLException if a database access error occurs
*/
public int isNullable(int column) throws SQLException
{
fetchFieldMetaData();
Field field = getField(column);
return field.getNullable();
}
/*
* Is the column a signed number? In PostgreSQL, all numbers
* are signed, so this is trivial. However, strings are not
* signed (duh!)
*
* @param column the first column is 1, the second is 2...
* @return true if so
* @exception SQLException if a database access error occurs
*/
public boolean isSigned(int column) throws SQLException
{
Field field = getField(column);
return connection.getTypeInfo().isSigned(field.getOID());
}
/*
* What is the column's normal maximum width in characters?
*
* @param column the first column is 1, the second is 2, etc.
* @return the maximum width
* @exception SQLException if a database access error occurs
*/
public int getColumnDisplaySize(int column) throws SQLException
{
Field field = getField(column);
return connection.getTypeInfo().getDisplaySize(field.getOID(), field.getMod());
}
/*
* @param column the first column is 1, the second is 2, etc.
* @return the column label
* @exception SQLException if a database access error occurs
*/
public String getColumnLabel(int column) throws SQLException
{
Field field = getField(column);
return field.getColumnLabel();
}
/*
* What's a column's name?
*
* @param column the first column is 1, the second is 2, etc.
* @return the column name
* @exception SQLException if a database access error occurs
*/
public String getColumnName(int column) throws SQLException
{
return getColumnLabel(column);
}
public String getBaseColumnName(int column) throws SQLException {
fetchFieldMetaData();
Field field = getField(column);
return field.getColumnName();
}
/*
* @param column the first column is 1, the second is 2...
* @return the Schema Name
* @exception SQLException if a database access error occurs
*/
public String getSchemaName(int column) throws SQLException
{
return "";
}
private void fetchFieldMetaData() throws SQLException {
if (fieldInfoFetched)
return;
fieldInfoFetched = true;
StringBuffer sql = new StringBuffer();
sql.append("SELECT c.oid, a.attnum, a.attname, c.relname, n.nspname, ");
sql.append("a.attnotnull OR (t.typtype = 'd' AND t.typnotnull), ");
sql.append("pg_catalog.pg_get_expr(d.adbin, d.adrelid) LIKE '%nextval(%' ");
sql.append("FROM pg_catalog.pg_class c ");
sql.append("JOIN pg_catalog.pg_namespace n ON (c.relnamespace = n.oid) ");
sql.append("JOIN pg_catalog.pg_attribute a ON (c.oid = a.attrelid) ");
sql.append("JOIN pg_catalog.pg_type t ON (a.atttypid = t.oid) ");
sql.append("LEFT JOIN pg_catalog.pg_attrdef d ON (d.adrelid = a.attrelid AND d.adnum = a.attnum) ");
sql.append("JOIN (");
// 7.4 servers don't support row IN operations (a,b) IN ((c,d),(e,f))
// so we've got to fake that with a JOIN here.
//
boolean hasSourceInfo = false;
for (int i=0; i fields.length)
throw new PSQLException(GT.tr("The column index is out of range: {0}, number of columns: {1}.", new Object[]{new Integer(columnIndex), new Integer(fields.length)}), PSQLState.INVALID_PARAMETER_VALUE );
return fields[columnIndex - 1];
}
protected String getPGType(int columnIndex) throws SQLException
{
return connection.getTypeInfo().getPGType(getField(columnIndex).getOID());
}
protected int getSQLType(int columnIndex) throws SQLException
{
return connection.getTypeInfo().getSQLType(getField(columnIndex).getOID());
}
// ** JDBC 2 Extensions **
// This can hook into our PG_Object mechanism
/**
* Returns the fully-qualified name of the Java class whose instances
* are manufactured if the method ResultSet.getObject
* is called to retrieve a value from the column.
*
* ResultSet.getObject may return a subclass of the class
* returned by this method.
*
* @param column the first column is 1, the second is 2, ...
* @return the fully-qualified name of the class in the Java programming
* language that would be used by the method
* ResultSet.getObject to retrieve the value in the specified
* column. This is the class name used for custom mapping.
* @exception SQLException if a database access error occurs
*/
public String getColumnClassName(int column) throws SQLException
{
Field field = getField(column);
String result = connection.getTypeInfo().getJavaClass(field.getOID());
if (result != null)
return result;
int sqlType = getSQLType(column);
switch(sqlType) {
case Types.ARRAY:
return ("java.sql.Array");
default:
String type = getPGType(column);
if ("unknown".equals(type)) {
return ("java.lang.String");
}
return ("java.lang.Object");
}
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc2/AbstractJdbc2Statement.java 0000664 0000000 0000000 00000360316 12050675701 0026767 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc2;
import java.io.*;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.math.*;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.TimerTask;
import java.util.TimeZone;
import java.util.Calendar;
import org.postgresql.Driver;
import org.postgresql.largeobject.*;
import org.postgresql.core.*;
import org.postgresql.core.types.*;
import org.postgresql.util.ByteConverter;
import org.postgresql.util.HStoreConverter;
import org.postgresql.util.PGBinaryObject;
import org.postgresql.util.PSQLException;
import org.postgresql.util.PSQLState;
import org.postgresql.util.PGobject;
import org.postgresql.util.GT;
/**
* This class defines methods of the jdbc2 specification.
* The real Statement class (for jdbc2) is org.postgresql.jdbc2.Jdbc2Statement
*/
public abstract class AbstractJdbc2Statement implements BaseStatement
{
// only for testing purposes. even single shot statements will use binary transfers
public static final boolean ForceBinaryTransfers = Boolean.getBoolean("org.postgresql.forcebinary");
protected ArrayList batchStatements = null;
protected ArrayList batchParameters = null;
protected final int resultsettype; // the resultset type to return (ResultSet.TYPE_xxx)
protected final int concurrency; // is it updateable or not? (ResultSet.CONCUR_xxx)
protected int fetchdirection = ResultSet.FETCH_FORWARD; // fetch direction hint (currently ignored)
private TimerTask cancelTimer=null;
/**
* Does the caller of execute/executeUpdate want generated keys for this
* execution? This is set by Statement methods that have generated keys
* arguments and cleared after execution is complete.
*/
protected boolean wantsGeneratedKeysOnce = false;
/**
* Was this PreparedStatement created to return generated keys for every
* execution? This is set at creation time and never cleared by
* execution.
*/
public boolean wantsGeneratedKeysAlways = false;
// The connection who created us
protected BaseConnection connection;
/** The warnings chain. */
protected SQLWarning warnings = null;
/** The last warning of the warning chain. */
protected SQLWarning lastWarning = null;
/** Maximum number of rows to return, 0 = unlimited */
protected int maxrows = 0;
/** Number of rows to get in a batch. */
protected int fetchSize = 0;
/** Timeout (in seconds) for a query (not used) */
protected int timeout = 0;
protected boolean replaceProcessingEnabled = true;
/** The current results. */
protected ResultWrapper result = null;
/** The first unclosed result. */
protected ResultWrapper firstUnclosedResult = null;
/** Results returned by a statement that wants generated keys. */
protected ResultWrapper generatedKeys = null;
/** used to differentiate between new function call
* logic and old function call logic
* will be set to true if the server is < 8.1 or
* if we are using v2 protocol
* There is an exception to this where we are using v3, and the
* call does not have an out parameter before the call
*/
protected boolean adjustIndex = false;
/*
* Used to set adjustIndex above
*/
protected boolean outParmBeforeFunc=false;
// Static variables for parsing SQL when replaceProcessing is true.
private static final short IN_SQLCODE = 0;
private static final short IN_STRING = 1;
private static final short IN_IDENTIFIER = 6;
private static final short BACKSLASH = 2;
private static final short ESC_TIMEDATE = 3;
private static final short ESC_FUNCTION = 4;
private static final short ESC_OUTERJOIN = 5;
private static final short ESC_ESCAPECHAR = 7;
protected final Query preparedQuery; // Query fragments for prepared statement.
protected final ParameterList preparedParameters; // Parameter values for prepared statement.
protected Query lastSimpleQuery;
protected int m_prepareThreshold; // Reuse threshold to enable use of PREPARE
protected int m_useCount = 0; // Number of times this statement has been used
//Used by the callablestatement style methods
private boolean isFunction;
// functionReturnType contains the user supplied value to check
// testReturn contains a modified version to make it easier to
// check the getXXX methods..
private int []functionReturnType;
private int []testReturn;
// returnTypeSet is true when a proper call to registerOutParameter has been made
private boolean returnTypeSet;
protected Object []callResult;
protected int maxfieldSize = 0;
public ResultSet createDriverResultSet(Field[] fields, List tuples)
throws SQLException
{
return createResultSet(null, fields, tuples, null);
}
public AbstractJdbc2Statement (AbstractJdbc2Connection c, int rsType, int rsConcurrency) throws SQLException
{
this.connection = c;
this.preparedQuery = null;
this.preparedParameters = null;
this.lastSimpleQuery = null;
resultsettype = rsType;
concurrency = rsConcurrency;
}
public AbstractJdbc2Statement(AbstractJdbc2Connection connection, String sql, boolean isCallable, int rsType, int rsConcurrency) throws SQLException
{
this.connection = connection;
this.lastSimpleQuery = null;
String parsed_sql = replaceProcessing(sql);
if (isCallable)
parsed_sql = modifyJdbcCall(parsed_sql);
this.preparedQuery = connection.getQueryExecutor().createParameterizedQuery(parsed_sql);
this.preparedParameters = preparedQuery.createParameterList();
int inParamCount = preparedParameters.getInParameterCount() + 1;
this.testReturn = new int[inParamCount];
this.functionReturnType = new int[inParamCount];
resultsettype = rsType;
concurrency = rsConcurrency;
}
public abstract ResultSet createResultSet(Query originalQuery, Field[] fields, List tuples, ResultCursor cursor)
throws SQLException;
public BaseConnection getPGConnection() {
return connection;
}
public String getFetchingCursorName() {
return null;
}
public int getFetchSize() {
return fetchSize;
}
protected boolean wantsScrollableResultSet() {
return resultsettype != ResultSet.TYPE_FORWARD_ONLY;
}
protected boolean wantsHoldableResultSet() {
return false;
}
//
// ResultHandler implementations for updates, queries, and either-or.
//
public class StatementResultHandler implements ResultHandler {
private SQLException error;
private ResultWrapper results;
ResultWrapper getResults() {
return results;
}
private void append(ResultWrapper newResult) {
if (results == null)
results = newResult;
else
results.append(newResult);
}
public void handleResultRows(Query fromQuery, Field[] fields, List tuples, ResultCursor cursor) {
try
{
ResultSet rs = AbstractJdbc2Statement.this.createResultSet(fromQuery, fields, tuples, cursor);
append(new ResultWrapper(rs));
}
catch (SQLException e)
{
handleError(e);
}
}
public void handleCommandStatus(String status, int updateCount, long insertOID) {
append(new ResultWrapper(updateCount, insertOID));
}
public void handleWarning(SQLWarning warning) {
AbstractJdbc2Statement.this.addWarning(warning);
}
public void handleError(SQLException newError) {
if (error == null)
error = newError;
else
error.setNextException(newError);
}
public void handleCompletion() throws SQLException {
if (error != null)
throw error;
}
}
/*
* Execute a SQL statement that retruns a single ResultSet
*
* @param sql typically a static SQL SELECT statement
* @return a ResulSet that contains the data produced by the query
* @exception SQLException if a database access error occurs
*/
public java.sql.ResultSet executeQuery(String p_sql) throws SQLException
{
if (preparedQuery != null)
throw new PSQLException(GT.tr("Can''t use query methods that take a query string on a PreparedStatement."),
PSQLState.WRONG_OBJECT_TYPE);
if (ForceBinaryTransfers) {
clearWarnings();
// Close any existing resultsets associated with this statement.
while (firstUnclosedResult != null)
{
if (firstUnclosedResult.getResultSet() != null)
firstUnclosedResult.getResultSet().close();
firstUnclosedResult = firstUnclosedResult.getNext();
}
PreparedStatement ps = connection.prepareStatement(p_sql, resultsettype, concurrency, getResultSetHoldability());
ps.setMaxFieldSize(getMaxFieldSize());
ps.setFetchSize(getFetchSize());
ps.setFetchDirection(getFetchDirection());
AbstractJdbc2ResultSet rs = (AbstractJdbc2ResultSet) ps.executeQuery();
rs.registerRealStatement(this);
result = firstUnclosedResult = new ResultWrapper(rs);
return rs;
}
if (!executeWithFlags(p_sql, 0))
throw new PSQLException(GT.tr("No results were returned by the query."), PSQLState.NO_DATA);
if (result.getNext() != null)
throw new PSQLException(GT.tr("Multiple ResultSets were returned by the query."),
PSQLState.TOO_MANY_RESULTS);
return (ResultSet)result.getResultSet();
}
/*
* A Prepared SQL query is executed and its ResultSet is returned
*
* @return a ResultSet that contains the data produced by the
* * query - never null
* @exception SQLException if a database access error occurs
*/
public java.sql.ResultSet executeQuery() throws SQLException
{
if (!executeWithFlags(0))
throw new PSQLException(GT.tr("No results were returned by the query."), PSQLState.NO_DATA);
if (result.getNext() != null)
throw new PSQLException(GT.tr("Multiple ResultSets were returned by the query."), PSQLState.TOO_MANY_RESULTS);
return (ResultSet) result.getResultSet();
}
/*
* Execute a SQL INSERT, UPDATE or DELETE statement. In addition
* SQL statements that return nothing such as SQL DDL statements
* can be executed
*
* @param sql a SQL statement
* @return either a row count, or 0 for SQL commands
* @exception SQLException if a database access error occurs
*/
public int executeUpdate(String p_sql) throws SQLException
{
if (preparedQuery != null)
throw new PSQLException(GT.tr("Can''t use query methods that take a query string on a PreparedStatement."),
PSQLState.WRONG_OBJECT_TYPE);
if( isFunction )
{
executeWithFlags(p_sql, 0);
return 0;
}
executeWithFlags(p_sql, QueryExecutor.QUERY_NO_RESULTS);
ResultWrapper iter = result;
while (iter != null) {
if (iter.getResultSet() != null) {
throw new PSQLException(GT.tr("A result was returned when none was expected."),
PSQLState.TOO_MANY_RESULTS);
}
iter = iter.getNext();
}
return getUpdateCount();
}
/*
* Execute a SQL INSERT, UPDATE or DELETE statement. In addition,
* SQL statements that return nothing such as SQL DDL statements can
* be executed.
*
* @return either the row count for INSERT, UPDATE or DELETE; or
* * 0 for SQL statements that return nothing.
* @exception SQLException if a database access error occurs
*/
public int executeUpdate() throws SQLException
{
if( isFunction )
{
executeWithFlags(0);
return 0;
}
executeWithFlags(QueryExecutor.QUERY_NO_RESULTS);
ResultWrapper iter = result;
while (iter != null) {
if (iter.getResultSet() != null) {
throw new PSQLException(GT.tr("A result was returned when none was expected."),
PSQLState.TOO_MANY_RESULTS);
}
iter = iter.getNext();
}
return getUpdateCount();
}
/*
* Execute a SQL statement that may return multiple results. We
* don't have to worry about this since we do not support multiple
* ResultSets. You can use getResultSet or getUpdateCount to
* retrieve the result.
*
* @param sql any SQL statement
* @return true if the next result is a ResulSet, false if it is
* an update count or there are no more results
* @exception SQLException if a database access error occurs
*/
public boolean execute(String p_sql) throws SQLException
{
if (preparedQuery != null)
throw new PSQLException(GT.tr("Can''t use query methods that take a query string on a PreparedStatement."),
PSQLState.WRONG_OBJECT_TYPE);
return executeWithFlags(p_sql, 0);
}
public boolean executeWithFlags(String p_sql, int flags) throws SQLException
{
checkClosed();
p_sql = replaceProcessing(p_sql);
Query simpleQuery = connection.getQueryExecutor().createSimpleQuery(p_sql);
execute(simpleQuery, null, QueryExecutor.QUERY_ONESHOT | flags);
this.lastSimpleQuery = simpleQuery;
return (result != null && result.getResultSet() != null);
}
public boolean execute() throws SQLException
{
return executeWithFlags(0);
}
public boolean executeWithFlags(int flags) throws SQLException
{
checkClosed();
execute(preparedQuery, preparedParameters, flags);
// If we are executing and there are out parameters
// callable statement function set the return data
if (isFunction && returnTypeSet )
{
if (result == null || result.getResultSet() == null)
throw new PSQLException(GT.tr("A CallableStatement was executed with nothing returned."), PSQLState.NO_DATA);
ResultSet rs = result.getResultSet();
if (!rs.next())
throw new PSQLException(GT.tr("A CallableStatement was executed with nothing returned."), PSQLState.NO_DATA);
// figure out how many columns
int cols = rs.getMetaData().getColumnCount();
int outParameterCount = preparedParameters.getOutParameterCount() ;
if ( cols != outParameterCount )
throw new PSQLException(GT.tr("A CallableStatement was executed with an invalid number of parameters"),PSQLState.SYNTAX_ERROR);
// reset last result fetched (for wasNull)
lastIndex = 0;
// allocate enough space for all possible parameters without regard to in/out
callResult = new Object[preparedParameters.getParameterCount()+1];
// move them into the result set
for ( int i=0,j=0; i < cols; i++,j++)
{
// find the next out parameter, the assumption is that the functionReturnType
// array will be initialized with 0 and only out parameters will have values
// other than 0. 0 is the value for java.sql.Types.NULL, which should not
// conflict
while( j< functionReturnType.length && functionReturnType[j]==0) j++;
callResult[j] = rs.getObject(i+1);
int columnType = rs.getMetaData().getColumnType(i+1);
if (columnType != functionReturnType[j])
{
// this is here for the sole purpose of passing the cts
if ( columnType == Types.DOUBLE && functionReturnType[j] == Types.REAL )
{
// return it as a float
if ( callResult[j] != null)
callResult[j] = new Float(((Double)callResult[j]).floatValue());
}
else
{
throw new PSQLException (GT.tr("A CallableStatement function was executed and the out parameter {0} was of type {1} however type {2} was registered.",
new Object[]{new Integer(i+1),
"java.sql.Types=" + columnType, "java.sql.Types=" + functionReturnType[j] }),
PSQLState.DATA_TYPE_MISMATCH);
}
}
}
rs.close();
result = null;
return false;
}
return (result != null && result.getResultSet() != null);
}
protected void closeForNextExecution() throws SQLException {
// Every statement execution clears any previous warnings.
clearWarnings();
// Close any existing resultsets associated with this statement.
while (firstUnclosedResult != null)
{
if (firstUnclosedResult.getResultSet() != null)
firstUnclosedResult.getResultSet().close();
firstUnclosedResult = firstUnclosedResult.getNext();
}
result = null;
if (lastSimpleQuery != null) {
lastSimpleQuery.close();
lastSimpleQuery = null;
}
if (generatedKeys != null) {
if (generatedKeys.getResultSet() != null) {
generatedKeys.getResultSet().close();
}
generatedKeys = null;
}
}
protected void execute(Query queryToExecute, ParameterList queryParameters, int flags) throws SQLException {
closeForNextExecution();
// Enable cursor-based resultset if possible.
if (fetchSize > 0 && !wantsScrollableResultSet() && !connection.getAutoCommit() && !wantsHoldableResultSet())
flags |= QueryExecutor.QUERY_FORWARD_CURSOR;
if (wantsGeneratedKeysOnce || wantsGeneratedKeysAlways)
{
flags |= QueryExecutor.QUERY_BOTH_ROWS_AND_STATUS;
// If the no results flag is set (from executeUpdate)
// clear it so we get the generated keys results.
//
if ((flags & QueryExecutor.QUERY_NO_RESULTS) != 0)
flags &= ~(QueryExecutor.QUERY_NO_RESULTS);
}
// Only use named statements after we hit the threshold
if (preparedQuery != null)
{
++m_useCount; // We used this statement once more.
if (m_prepareThreshold == 0 || m_useCount < m_prepareThreshold)
flags |= QueryExecutor.QUERY_ONESHOT;
}
if (connection.getAutoCommit())
flags |= QueryExecutor.QUERY_SUPPRESS_BEGIN;
// updateable result sets do not yet support binary updates
if (concurrency != ResultSet.CONCUR_READ_ONLY)
flags |= QueryExecutor.QUERY_NO_BINARY_TRANSFER;
if (ForceBinaryTransfers) {
int flags2 = flags | QueryExecutor.QUERY_DESCRIBE_ONLY;
StatementResultHandler handler2 = new StatementResultHandler();
connection.getQueryExecutor().execute(queryToExecute, queryParameters, handler2, 0, 0, flags2);
ResultWrapper result2 = handler2.getResults();
if (result2 != null) {
result2.getResultSet().close();
}
}
StatementResultHandler handler = new StatementResultHandler();
result = null;
connection.getQueryExecutor().execute(queryToExecute,
queryParameters,
handler,
maxrows,
fetchSize,
flags);
if ( cancelTimer != null )
{
cancelTimer.cancel();
cancelTimer=null;
}
result = firstUnclosedResult = handler.getResults();
if (wantsGeneratedKeysOnce || wantsGeneratedKeysAlways)
{
generatedKeys = result;
result = result.getNext();
if (wantsGeneratedKeysOnce)
wantsGeneratedKeysOnce = false;
}
}
/*
* setCursorName defines the SQL cursor name that will be used by
* subsequent execute methods. This name can then be used in SQL
* positioned update/delete statements to identify the current row
* in the ResultSet generated by this statement. If a database
* doesn't support positioned update/delete, this method is a
* no-op.
*
*
Note: By definition, positioned update/delete execution
* must be done by a different Statement than the one which
* generated the ResultSet being used for positioning. Also, cursor
* names must be unique within a Connection.
*
* @param name the new cursor name
* @exception SQLException if a database access error occurs
*/
public void setCursorName(String name) throws SQLException
{
checkClosed();
// No-op.
}
protected boolean isClosed = false;
private int lastIndex = 0;
/*
* getUpdateCount returns the current result as an update count,
* if the result is a ResultSet or there are no more results, -1
* is returned. It should only be called once per result.
*
* @return the current result as an update count.
* @exception SQLException if a database access error occurs
*/
public int getUpdateCount() throws SQLException
{
checkClosed();
if (result == null || result.getResultSet() != null)
return -1;
return result.getUpdateCount();
}
/*
* getMoreResults moves to a Statement's next result. If it returns
* true, this result is a ResulSet.
*
* @return true if the next ResultSet is valid
* @exception SQLException if a database access error occurs
*/
public boolean getMoreResults() throws SQLException
{
if (result == null)
return false;
result = result.getNext();
// Close preceding resultsets.
while (firstUnclosedResult != result)
{
if (firstUnclosedResult.getResultSet() != null)
firstUnclosedResult.getResultSet().close();
firstUnclosedResult = firstUnclosedResult.getNext();
}
return (result != null && result.getResultSet() != null);
}
/*
* The maxRows limit is set to limit the number of rows that
* any ResultSet can contain. If the limit is exceeded, the
* excess rows are silently dropped.
*
* @return the current maximum row limit; zero means unlimited
* @exception SQLException if a database access error occurs
*/
public int getMaxRows() throws SQLException
{
checkClosed();
return maxrows;
}
/*
* Set the maximum number of rows
*
* @param max the new max rows limit; zero means unlimited
* @exception SQLException if a database access error occurs
* @see getMaxRows
*/
public void setMaxRows(int max) throws SQLException
{
checkClosed();
if (max < 0)
throw new PSQLException(GT.tr("Maximum number of rows must be a value grater than or equal to 0."),
PSQLState.INVALID_PARAMETER_VALUE);
maxrows = max;
}
/*
* If escape scanning is on (the default), the driver will do escape
* substitution before sending the SQL to the database.
*
* @param enable true to enable; false to disable
* @exception SQLException if a database access error occurs
*/
public void setEscapeProcessing(boolean enable) throws SQLException
{
checkClosed();
replaceProcessingEnabled = enable;
}
/*
* The queryTimeout limit is the number of seconds the driver
* will wait for a Statement to execute. If the limit is
* exceeded, a SQLException is thrown.
*
* @return the current query timeout limit in seconds; 0 = unlimited
* @exception SQLException if a database access error occurs
*/
public int getQueryTimeout() throws SQLException
{
checkClosed();
return timeout;
}
/*
* Sets the queryTimeout limit
*
* @param seconds - the new query timeout limit in seconds
* @exception SQLException if a database access error occurs
*/
public void setQueryTimeout(int seconds) throws SQLException
{
checkClosed();
if (seconds < 0)
throw new PSQLException(GT.tr("Query timeout must be a value greater than or equals to 0."),
PSQLState.INVALID_PARAMETER_VALUE);
if (seconds == 0) {
if ( cancelTimer != null ) {
cancelTimer.cancel();
cancelTimer = null;
}
return;
}
cancelTimer = new TimerTask() {
public void run()
{
try {
AbstractJdbc2Statement.this.cancel();
} catch (SQLException e) {
}
}
};
Driver.addTimerTask( cancelTimer, seconds * 1000);
timeout = seconds;
}
/**
* This adds a warning to the warning chain. We track the
* tail of the warning chain as well to avoid O(N) behavior
* for adding a new warning to an existing chain. Some
* server functions which RAISE NOTICE (or equivalent) produce
* a ton of warnings.
* @param warn warning to add
*/
public void addWarning(SQLWarning warn)
{
if (warnings == null) {
warnings = warn;
lastWarning = warn;
} else {
lastWarning.setNextWarning(warn);
lastWarning = warn;
}
}
/*
* The first warning reported by calls on this Statement is
* returned. A Statement's execute methods clear its SQLWarning
* chain. Subsequent Statement warnings will be chained to this
* SQLWarning.
*
*
The Warning chain is automatically cleared each time a statement
* is (re)executed.
*
*
Note: If you are processing a ResultSet then any warnings
* associated with ResultSet reads will be chained on the ResultSet
* object.
*
* @return the first SQLWarning on null
* @exception SQLException if a database access error occurs
*/
public SQLWarning getWarnings() throws SQLException
{
checkClosed();
return warnings;
}
/*
* The maxFieldSize limit (in bytes) is the maximum amount of
* data returned for any column value; it only applies to
* BINARY, VARBINARY, LONGVARBINARY, CHAR, VARCHAR and LONGVARCHAR
* columns. If the limit is exceeded, the excess data is silently
* discarded.
*
* @return the current max column size limit; zero means unlimited
* @exception SQLException if a database access error occurs
*/
public int getMaxFieldSize() throws SQLException
{
return maxfieldSize;
}
/*
* Sets the maxFieldSize
*
* @param max the new max column size limit; zero means unlimited
* @exception SQLException if a database access error occurs
*/
public void setMaxFieldSize(int max) throws SQLException
{
checkClosed();
if (max < 0)
throw new PSQLException(GT.tr("The maximum field size must be a value greater than or equal to 0."),
PSQLState.INVALID_PARAMETER_VALUE);
maxfieldSize = max;
}
/*
* After this call, getWarnings returns null until a new warning
* is reported for this Statement.
*
* @exception SQLException if a database access error occurs
*/
public void clearWarnings() throws SQLException
{
warnings = null;
lastWarning = null;
}
/*
* getResultSet returns the current result as a ResultSet. It
* should only be called once per result.
*
* @return the current result set; null if there are no more
* @exception SQLException if a database access error occurs (why?)
*/
public java.sql.ResultSet getResultSet() throws SQLException
{
checkClosed();
if (result == null)
return null;
return (ResultSet) result.getResultSet();
}
/*
* In many cases, it is desirable to immediately release a
* Statement's database and JDBC resources instead of waiting
* for this to happen when it is automatically closed. The
* close method provides this immediate release.
*
*
Note: A Statement is automatically closed when it is
* garbage collected. When a Statement is closed, its current
* ResultSet, if one exists, is also closed.
*
* @exception SQLException if a database access error occurs (why?)
*/
public void close() throws SQLException
{
// closing an already closed Statement is a no-op.
if (isClosed)
return ;
closeForNextExecution();
if (preparedQuery != null)
preparedQuery.close();
isClosed = true;
}
/**
* This finalizer ensures that statements that have allocated server-side
* resources free them when they become unreferenced.
*/
protected void finalize() {
try
{
close();
}
catch (SQLException e)
{
}
}
/*
* Filter the SQL string of Java SQL Escape clauses.
*
* Currently 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'".
*/
protected String replaceProcessing(String p_sql) 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 = p_sql.length();
StringBuffer newsql = new StringBuffer(len);
int i=0;
while (i 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(p_sql.charAt(i));
i++;
}
}
return newsql.toString();
}
else
{
return p_sql;
}
}
/**
* parse the given sql from index i, appending it to the gven 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 p_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
*/
protected static int parseSql(String p_sql,int i,StringBuffer newsql, boolean stopOnComma,
boolean stdStrings)throws SQLException{
short state = IN_SQLCODE;
int len = p_sql.length();
int nestedParenthesis=0;
boolean endOfNested=false;
// because of the ++i loop
i--;
while (!endOfNested && ++i < len)
{
char c = p_sql.charAt(i);
switch (state)
{
case IN_SQLCODE:
if (c == '\'') // start of a string?
state = IN_STRING;
else if (c == '"') // start of a identifer?
state = IN_IDENTIFIER;
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)
{
char next = p_sql.charAt(i + 1);
char nextnext = (i + 2 < len) ? p_sql.charAt(i + 2) : '\0';
if (next == 'd' || next == 'D')
{
state = ESC_TIMEDATE;
i++;
newsql.append("DATE ");
break;
}
else if (next == 't' || next == 'T')
{
state = ESC_TIMEDATE;
if (nextnext == 's' || nextnext == 'S'){
// timestamp constant
i+=2;
newsql.append("TIMESTAMP ");
}else{
// time constant
i++;
newsql.append("TIME ");
}
break;
}
else if ( next == 'f' || next == 'F' )
{
state = ESC_FUNCTION;
i += (nextnext == 'n' || nextnext == 'N') ? 2 : 1;
break;
}
else if ( next == 'o' || next == 'O' )
{
state = ESC_OUTERJOIN;
i += (nextnext == 'j' || nextnext == 'J') ? 2 : 1;
break;
}
else if ( next == 'e' || next == 'E' )
{ // we assume that escape is the only escape sequence beginning with e
state = ESC_ESCAPECHAR;
break;
}
}
}
newsql.append(c);
break;
case IN_STRING:
if (c == '\'') // end of string?
state = IN_SQLCODE;
else if (c == '\\' && !stdStrings) // a backslash?
state = BACKSLASH;
newsql.append(c);
break;
case IN_IDENTIFIER:
if (c == '"') // end of identifier
state = IN_SQLCODE;
newsql.append(c);
break;
case BACKSLASH:
state = IN_STRING;
newsql.append(c);
break;
case ESC_FUNCTION:
// extract function name
String functionName;
int posArgs = p_sql.indexOf('(',i);
if (posArgs!=-1){
functionName=p_sql.substring(i,posArgs).trim();
// extract arguments
i= posArgs+1;// we start the scan after the first (
StringBuffer args=new StringBuffer();
i = parseSql(p_sql,i,args,false,stdStrings);
// translate the function and parse arguments
newsql.append(escapeFunction(functionName,args.toString(),stdStrings));
}
// go to the end of the function copying anything found
i++;
while (iNote: You must specify the parameter's SQL type.
*
* @param parameterIndex the first parameter is 1, etc...
* @param sqlType the SQL type code defined in java.sql.Types
* @exception SQLException if a database access error occurs
*/
public void setNull(int parameterIndex, int sqlType) throws SQLException
{
checkClosed();
int oid;
switch (sqlType)
{
case Types.INTEGER:
oid = Oid.INT4;
break;
case Types.TINYINT:
case Types.SMALLINT:
oid = Oid.INT2;
break;
case Types.BIGINT:
oid = Oid.INT8;
break;
case Types.REAL:
oid = Oid.FLOAT4;
break;
case Types.DOUBLE:
case Types.FLOAT:
oid = Oid.FLOAT8;
break;
case Types.DECIMAL:
case Types.NUMERIC:
oid = Oid.NUMERIC;
break;
case Types.CHAR:
oid = Oid.BPCHAR;
break;
case Types.VARCHAR:
case Types.LONGVARCHAR:
oid = Oid.VARCHAR;
break;
case Types.DATE:
oid = Oid.DATE;
break;
case Types.TIME:
case Types.TIMESTAMP:
oid = Oid.UNSPECIFIED;
break;
case Types.BIT:
oid = Oid.BOOL;
break;
case Types.BINARY:
case Types.VARBINARY:
case Types.LONGVARBINARY:
if (connection.haveMinimumCompatibleVersion("7.2"))
{
oid = Oid.BYTEA;
}
else
{
oid = Oid.OID;
}
break;
case Types.BLOB:
case Types.CLOB:
oid = Oid.OID;
break;
case Types.ARRAY:
case Types.DISTINCT:
case Types.STRUCT:
case Types.NULL:
case Types.OTHER:
oid = Oid.UNSPECIFIED;
break;
default:
// Bad Types value.
throw new PSQLException(GT.tr("Unknown Types value."), PSQLState.INVALID_PARAMETER_TYPE);
}
if ( adjustIndex )
parameterIndex--;
preparedParameters.setNull( parameterIndex, oid);
}
/*
* Set a parameter to a Java boolean value. The driver converts this
* to a SQL BIT value when it sends it to the database.
*
* @param parameterIndex the first parameter is 1...
* @param x the parameter value
* @exception SQLException if a database access error occurs
*/
public void setBoolean(int parameterIndex, boolean x) throws SQLException
{
checkClosed();
bindString(parameterIndex, x ? "1" : "0", Oid.BOOL);
}
/*
* Set a parameter to a Java byte value. The driver converts this to
* a SQL TINYINT value when it sends it to the database.
*
* @param parameterIndex the first parameter is 1...
* @param x the parameter value
* @exception SQLException if a database access error occurs
*/
public void setByte(int parameterIndex, byte x) throws SQLException
{
setShort(parameterIndex, x);
}
/*
* Set a parameter to a Java short value. The driver converts this
* to a SQL SMALLINT value when it sends it to the database.
*
* @param parameterIndex the first parameter is 1...
* @param x the parameter value
* @exception SQLException if a database access error occurs
*/
public void setShort(int parameterIndex, short x) throws SQLException
{
checkClosed();
if (connection.binaryTransferSend(Oid.INT2)) {
byte[] val = new byte[2];
ByteConverter.int2(val, 0, x);
bindBytes(parameterIndex, val, Oid.INT2);
return;
}
bindLiteral(parameterIndex, Integer.toString(x), Oid.INT2);
}
/*
* Set a parameter to a Java int value. The driver converts this to
* a SQL INTEGER value when it sends it to the database.
*
* @param parameterIndex the first parameter is 1...
* @param x the parameter value
* @exception SQLException if a database access error occurs
*/
public void setInt(int parameterIndex, int x) throws SQLException
{
checkClosed();
if (connection.binaryTransferSend(Oid.INT4)) {
byte[] val = new byte[4];
ByteConverter.int4(val, 0, x);
bindBytes(parameterIndex, val, Oid.INT4);
return;
}
bindLiteral(parameterIndex, Integer.toString(x), Oid.INT4);
}
/*
* Set a parameter to a Java long value. The driver converts this to
* a SQL BIGINT value when it sends it to the database.
*
* @param parameterIndex the first parameter is 1...
* @param x the parameter value
* @exception SQLException if a database access error occurs
*/
public void setLong(int parameterIndex, long x) throws SQLException
{
checkClosed();
if (connection.binaryTransferSend(Oid.INT8)) {
byte[] val = new byte[8];
ByteConverter.int8(val, 0, x);
bindBytes(parameterIndex, val, Oid.INT8);
return;
}
bindLiteral(parameterIndex, Long.toString(x), Oid.INT8);
}
/*
* Set a parameter to a Java float value. The driver converts this
* to a SQL FLOAT value when it sends it to the database.
*
* @param parameterIndex the first parameter is 1...
* @param x the parameter value
* @exception SQLException if a database access error occurs
*/
public void setFloat(int parameterIndex, float x) throws SQLException
{
checkClosed();
if (connection.binaryTransferSend(Oid.FLOAT4)) {
byte[] val = new byte[4];
ByteConverter.float4(val, 0, x);
bindBytes(parameterIndex, val, Oid.FLOAT4);
return;
}
bindLiteral(parameterIndex, Float.toString(x), Oid.FLOAT8);
}
/*
* Set a parameter to a Java double value. The driver converts this
* to a SQL DOUBLE value when it sends it to the database
*
* @param parameterIndex the first parameter is 1...
* @param x the parameter value
* @exception SQLException if a database access error occurs
*/
public void setDouble(int parameterIndex, double x) throws SQLException
{
checkClosed();
if (connection.binaryTransferSend(Oid.FLOAT8)) {
byte[] val = new byte[8];
ByteConverter.float8(val, 0, x);
bindBytes(parameterIndex, val, Oid.FLOAT8);
return;
}
bindLiteral(parameterIndex, Double.toString(x), Oid.FLOAT8);
}
/*
* Set a parameter to a java.lang.BigDecimal value. The driver
* converts this to a SQL NUMERIC value when it sends it to the
* database.
*
* @param parameterIndex the first parameter is 1...
* @param x the parameter value
* @exception SQLException if a database access error occurs
*/
public void setBigDecimal(int parameterIndex, BigDecimal x) throws SQLException
{
checkClosed();
if (x == null)
setNull(parameterIndex, Types.DECIMAL);
else
bindLiteral(parameterIndex, x.toString(), Oid.NUMERIC);
}
/*
* Set a parameter to a Java String value. The driver converts this
* to a SQL VARCHAR or LONGVARCHAR value (depending on the arguments
* size relative to the driver's limits on VARCHARs) when it sends it
* to the database.
*
* @param parameterIndex the first parameter is 1...
* @param x the parameter value
* @exception SQLException if a database access error occurs
*/
public void setString(int parameterIndex, String x) throws SQLException
{
checkClosed();
setString(parameterIndex, x, (connection.getStringVarcharFlag() ? Oid.VARCHAR : Oid.UNSPECIFIED));
}
protected void setString(int parameterIndex, String x, int oid) throws SQLException
{
// if the passed string is null, then set this column to null
checkClosed();
if (x == null)
{
if ( adjustIndex )
parameterIndex--;
preparedParameters.setNull( parameterIndex, oid);
}
else
bindString(parameterIndex, x, oid);
}
/*
* Set a parameter to a Java array of bytes. The driver converts this
* to a SQL VARBINARY or LONGVARBINARY (depending on the argument's
* size relative to the driver's limits on VARBINARYs) when it sends
* it to the database.
*
*
Implementation note:
* With org.postgresql, this creates a large object, and stores the
* objects oid in this column.
*
* @param parameterIndex the first parameter is 1...
* @param x the parameter value
* @exception SQLException if a database access error occurs
*/
public void setBytes(int parameterIndex, byte[] x) throws SQLException
{
checkClosed();
if (null == x)
{
setNull(parameterIndex, Types.VARBINARY);
return ;
}
if (connection.haveMinimumCompatibleVersion("7.2"))
{
//Version 7.2 supports the bytea datatype for byte arrays
byte[] copy = new byte[x.length];
System.arraycopy(x, 0, copy, 0, x.length);
preparedParameters.setBytea( parameterIndex, copy, 0, x.length);
}
else
{
//Version 7.1 and earlier support done as LargeObjects
LargeObjectManager lom = connection.getLargeObjectAPI();
long oid = lom.createLO();
LargeObject lob = lom.open(oid);
lob.write(x);
lob.close();
setLong(parameterIndex, oid);
}
}
/*
* Set a parameter to a java.sql.Date value. The driver converts this
* to a SQL DATE value when it sends it to the database.
*
* @param parameterIndex the first parameter is 1...
* @param x the parameter value
* @exception SQLException if a database access error occurs
*/
public void setDate(int parameterIndex, java.sql.Date x) throws SQLException
{
setDate(parameterIndex, x, null);
}
/*
* Set a parameter to a java.sql.Time value. The driver converts
* this to a SQL TIME value when it sends it to the database.
*
* @param parameterIndex the first parameter is 1...));
* @param x the parameter value
* @exception SQLException if a database access error occurs
*/
public void setTime(int parameterIndex, Time x) throws SQLException
{
setTime(parameterIndex, x, null);
}
/*
* Set a parameter to a java.sql.Timestamp value. The driver converts
* this to a SQL TIMESTAMP value when it sends it to the database.
*
* @param parameterIndex the first parameter is 1...
* @param x the parameter value
* @exception SQLException if a database access error occurs
*/
public void setTimestamp(int parameterIndex, Timestamp x) throws SQLException
{
setTimestamp(parameterIndex, x, null);
}
private void setCharacterStreamPost71(int parameterIndex, InputStream x, int length, String encoding) throws SQLException
{
if (x == null)
{
setNull(parameterIndex, Types.VARCHAR);
return ;
}
if (length < 0)
throw new PSQLException(GT.tr("Invalid stream length {0}.", new Integer(length)),
PSQLState.INVALID_PARAMETER_VALUE);
//Version 7.2 supports AsciiStream for all PG text types (char, varchar, text)
//As the spec/javadoc for this method indicate this is to be used for
//large String values (i.e. LONGVARCHAR) PG doesn't have a separate
//long varchar datatype, but with toast all text datatypes are capable of
//handling very large values. Thus the implementation ends up calling
//setString() since there is no current way to stream the value to the server
try
{
InputStreamReader l_inStream = new InputStreamReader(x, encoding);
char[] l_chars = new char[length];
int l_charsRead = 0;
while (true)
{
int n = l_inStream.read(l_chars, l_charsRead, length - l_charsRead);
if (n == -1)
break;
l_charsRead += n;
if (l_charsRead == length)
break;
}
setString(parameterIndex, new String(l_chars, 0, l_charsRead), Oid.VARCHAR);
}
catch (UnsupportedEncodingException l_uee)
{
throw new PSQLException(GT.tr("The JVM claims not to support the {0} encoding.", encoding), PSQLState.UNEXPECTED_ERROR, l_uee);
}
catch (IOException l_ioe)
{
throw new PSQLException(GT.tr("Provided InputStream failed."), PSQLState.UNEXPECTED_ERROR, l_ioe);
}
}
/*
* When a very large ASCII value is input to a LONGVARCHAR parameter,
* it may be more practical to send it via a java.io.InputStream.
* JDBC will read the data from the stream as needed, until it reaches
* end-of-file. The JDBC driver will do any necessary conversion from
* ASCII to the database char format.
*
*
Note: This stream object can either be a standard Java
* stream object or your own subclass that implements the standard
* interface.
*
* @param parameterIndex the first parameter is 1...
* @param x the parameter value
* @param length the number of bytes in the stream
* @exception SQLException if a database access error occurs
*/
public void setAsciiStream(int parameterIndex, InputStream x, int length) throws SQLException
{
checkClosed();
if (connection.haveMinimumCompatibleVersion("7.2"))
{
setCharacterStreamPost71(parameterIndex, x, length, "ASCII");
}
else
{
//Version 7.1 supported only LargeObjects by treating everything
//as binary data
setBinaryStream(parameterIndex, x, length);
}
}
/*
* When a very large Unicode value is input to a LONGVARCHAR parameter,
* it may be more practical to send it via a java.io.InputStream.
* JDBC will read the data from the stream as needed, until it reaches
* end-of-file. The JDBC driver will do any necessary conversion from
* UNICODE to the database char format.
*
*
Note: This stream object can either be a standard Java
* stream object or your own subclass that implements the standard
* interface.
*
* @param parameterIndex the first parameter is 1...
* @param x the parameter value
* @exception SQLException if a database access error occurs
*/
public void setUnicodeStream(int parameterIndex, InputStream x, int length) throws SQLException
{
checkClosed();
if (connection.haveMinimumCompatibleVersion("7.2"))
{
setCharacterStreamPost71(parameterIndex, x, length, "UTF-8");
}
else
{
//Version 7.1 supported only LargeObjects by treating everything
//as binary data
setBinaryStream(parameterIndex, x, length);
}
}
/*
* When a very large binary value is input to a LONGVARBINARY parameter,
* it may be more practical to send it via a java.io.InputStream.
* JDBC will read the data from the stream as needed, until it reaches
* end-of-file.
*
*
Note: This stream object can either be a standard Java
* stream object or your own subclass that implements the standard
* interface.
*
* @param parameterIndex the first parameter is 1...
* @param x the parameter value
* @exception SQLException if a database access error occurs
*/
public void setBinaryStream(int parameterIndex, InputStream x, int length) throws SQLException
{
checkClosed();
if (x == null)
{
setNull(parameterIndex, Types.VARBINARY);
return ;
}
if (length < 0)
throw new PSQLException(GT.tr("Invalid stream length {0}.", new Integer(length)),
PSQLState.INVALID_PARAMETER_VALUE);
if (connection.haveMinimumCompatibleVersion("7.2"))
{
//Version 7.2 supports BinaryStream for for the PG bytea type
//As the spec/javadoc for this method indicate this is to be used for
//large binary values (i.e. LONGVARBINARY) PG doesn't have a separate
//long binary datatype, but with toast the bytea datatype is capable of
//handling very large values.
preparedParameters.setBytea(parameterIndex, x, length);
}
else
{
//Version 7.1 only supported streams for LargeObjects
//but the jdbc spec indicates that streams should be
//available for LONGVARBINARY instead
LargeObjectManager lom = connection.getLargeObjectAPI();
long oid = lom.createLO();
LargeObject lob = lom.open(oid);
OutputStream los = lob.getOutputStream();
try
{
// could be buffered, but then the OutputStream returned by LargeObject
// is buffered internally anyhow, so there would be no performance
// boost gained, if anything it would be worse!
int c = x.read();
int p = 0;
while (c > -1 && p < length)
{
los.write(c);
c = x.read();
p++;
}
los.close();
}
catch (IOException se)
{
throw new PSQLException(GT.tr("Provided InputStream failed."), PSQLState.UNEXPECTED_ERROR, se);
}
// lob is closed by the stream so don't call lob.close()
setLong(parameterIndex, oid);
}
}
/*
* In general, parameter values remain in force for repeated used of a
* Statement. Setting a parameter value automatically clears its
* previous value. However, in coms cases, it is useful to immediately
* release the resources used by the current parameter values; this
* can be done by calling clearParameters
*
* @exception SQLException if a database access error occurs
*/
public void clearParameters() throws SQLException
{
preparedParameters.clear();
}
private PGType createInternalType( Object x, int targetType ) throws PSQLException
{
if ( x instanceof Byte ) return PGByte.castToServerType((Byte)x, targetType );
if ( x instanceof Short ) return PGShort.castToServerType((Short)x, targetType );
if ( x instanceof Integer ) return PGInteger.castToServerType((Integer)x, targetType );
if ( x instanceof Long ) return PGLong.castToServerType((Long)x, targetType );
if ( x instanceof Double ) return PGDouble.castToServerType((Double)x, targetType );
if ( x instanceof Float ) return PGFloat.castToServerType((Float)x, targetType );
if ( x instanceof BigDecimal) return PGBigDecimal.castToServerType((BigDecimal)x, targetType );
// since all of the above are instances of Number make sure this is after them
if ( x instanceof Number ) return PGNumber.castToServerType((Number)x, targetType );
if ( x instanceof Boolean) return PGBoolean.castToServerType((Boolean)x, targetType );
return new PGUnknown(x);
}
// Helper method for setting parameters to PGobject subclasses.
private void setPGobject(int parameterIndex, PGobject x) throws SQLException {
String typename = x.getType();
int oid = connection.getTypeInfo().getPGType(typename);
if (oid == Oid.UNSPECIFIED)
throw new PSQLException(GT.tr("Unknown type {0}.", typename), PSQLState.INVALID_PARAMETER_TYPE);
if ((x instanceof PGBinaryObject) && connection.binaryTransferSend(oid)) {
PGBinaryObject binObj = (PGBinaryObject) x;
byte[] data = new byte[binObj.lengthInBytes()];
binObj.toBytes(data, 0);
bindBytes(parameterIndex, data, oid);
} else {
setString(parameterIndex, x.getValue(), oid);
}
}
private void setMap(int parameterIndex, Map x) throws SQLException {
int oid = connection.getTypeInfo().getPGType("hstore");
if (oid == Oid.UNSPECIFIED)
throw new PSQLException(GT.tr("No hstore extension installed."), PSQLState.INVALID_PARAMETER_TYPE);
if (connection.binaryTransferSend(oid)) {
byte[] data = HStoreConverter.toBytes(x, connection.getEncoding());
bindBytes(parameterIndex, data, oid);
} else {
setString(parameterIndex, HStoreConverter.toString(x), oid);
}
}
/*
* Set the value of a parameter using an object; use the java.lang
* equivalent objects for integral values.
*
*
The given Java object will be converted to the targetSqlType before
* being sent to the database.
*
*
note that this method may be used to pass database-specific
* abstract data types. This is done by using a Driver-specific
* Java type and using a targetSqlType of java.sql.Types.OTHER
*
* @param parameterIndex the first parameter is 1...
* @param x the object containing the input parameter value
* @param targetSqlType The SQL type to be send to the database
* @param scale For java.sql.Types.DECIMAL or java.sql.Types.NUMERIC
* * types this is the number of digits after the decimal. For
* * all other types this value will be ignored.
* @exception SQLException if a database access error occurs
*/
public void setObject(int parameterIndex, Object in, int targetSqlType, int scale) throws SQLException
{
checkClosed();
if (in == null)
{
setNull(parameterIndex, targetSqlType);
return ;
}
Object pgType = createInternalType( in, targetSqlType );
switch (targetSqlType)
{
case Types.INTEGER:
bindLiteral(parameterIndex, pgType.toString(), Oid.INT4);
break;
case Types.TINYINT:
case Types.SMALLINT:
bindLiteral(parameterIndex, pgType.toString(), Oid.INT2);
break;
case Types.BIGINT:
bindLiteral(parameterIndex, pgType.toString(), Oid.INT8);
break;
case Types.REAL:
//TODO: is this really necessary ?
//bindLiteral(parameterIndex, new Float(pgType.toString()).toString(), Oid.FLOAT4);
bindLiteral(parameterIndex, pgType.toString(), Oid.FLOAT4);
break;
case Types.DOUBLE:
case Types.FLOAT:
bindLiteral(parameterIndex, pgType.toString(), Oid.FLOAT8);
break;
case Types.DECIMAL:
case Types.NUMERIC:
bindLiteral(parameterIndex, pgType.toString(), Oid.NUMERIC);
break;
case Types.CHAR:
setString(parameterIndex, pgType.toString(), Oid.BPCHAR);
break;
case Types.VARCHAR:
case Types.LONGVARCHAR:
setString(parameterIndex, pgType.toString(), Oid.VARCHAR);
break;
case Types.DATE:
if (in instanceof java.sql.Date)
setDate(parameterIndex, (java.sql.Date)in);
else
{
java.sql.Date tmpd;
if (in instanceof java.util.Date) {
tmpd = new java.sql.Date(((java.util.Date)in).getTime());
} else {
tmpd = connection.getTimestampUtils().toDate(null, in.toString());
}
setDate(parameterIndex, tmpd);
}
break;
case Types.TIME:
if (in instanceof java.sql.Time)
setTime(parameterIndex, (java.sql.Time)in);
else
{
java.sql.Time tmpt;
if (in instanceof java.util.Date) {
tmpt = new java.sql.Time(((java.util.Date)in).getTime());
} else {
tmpt = connection.getTimestampUtils().toTime(null, in.toString());
}
setTime(parameterIndex, tmpt);
}
break;
case Types.TIMESTAMP:
if (in instanceof java.sql.Timestamp)
setTimestamp(parameterIndex , (java.sql.Timestamp)in);
else
{
java.sql.Timestamp tmpts;
if (in instanceof java.util.Date) {
tmpts = new java.sql.Timestamp(((java.util.Date)in).getTime());
} else {
tmpts = connection.getTimestampUtils().toTimestamp(null, in.toString());
}
setTimestamp(parameterIndex, tmpts);
}
break;
case Types.BIT:
bindLiteral(parameterIndex, pgType.toString(), Oid.BOOL);
break;
case Types.BINARY:
case Types.VARBINARY:
case Types.LONGVARBINARY:
setObject(parameterIndex, in);
break;
case Types.BLOB:
if (in instanceof Blob)
setBlob(parameterIndex, (Blob)in);
else
throw new PSQLException(GT.tr("Cannot cast an instance of {0} to type {1}", new Object[]{in.getClass().getName(),"Types.BLOB"}), PSQLState.INVALID_PARAMETER_TYPE);
break;
case Types.CLOB:
if (in instanceof Clob)
setClob(parameterIndex, (Clob)in);
else
throw new PSQLException(GT.tr("Cannot cast an instance of {0} to type {1}", new Object[]{in.getClass().getName(),"Types.CLOB"}), PSQLState.INVALID_PARAMETER_TYPE);
break;
case Types.ARRAY:
if (in instanceof Array)
setArray(parameterIndex, (Array)in);
else
throw new PSQLException(GT.tr("Cannot cast an instance of {0} to type {1}", new Object[]{in.getClass().getName(),"Types.ARRAY"}), PSQLState.INVALID_PARAMETER_TYPE);
break;
case Types.DISTINCT:
bindString(parameterIndex, in.toString(), Oid.UNSPECIFIED);
break;
case Types.OTHER:
if (in instanceof PGobject)
setPGobject(parameterIndex, (PGobject)in);
else
bindString(parameterIndex, in.toString(), Oid.UNSPECIFIED);
break;
default:
throw new PSQLException(GT.tr("Unsupported Types value: {0}", new Integer(targetSqlType)), PSQLState.INVALID_PARAMETER_TYPE);
}
}
public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException
{
setObject(parameterIndex, x, targetSqlType, 0);
}
/*
* This stores an Object into a parameter.
*/
public void setObject(int parameterIndex, Object x) throws SQLException
{
checkClosed();
if (x == null)
setNull(parameterIndex, Types.OTHER);
else if (x instanceof String)
setString(parameterIndex, (String)x);
else if (x instanceof BigDecimal)
setBigDecimal(parameterIndex, (BigDecimal)x);
else if (x instanceof Short)
setShort(parameterIndex, ((Short)x).shortValue());
else if (x instanceof Integer)
setInt(parameterIndex, ((Integer)x).intValue());
else if (x instanceof Long)
setLong(parameterIndex, ((Long)x).longValue());
else if (x instanceof Float)
setFloat(parameterIndex, ((Float)x).floatValue());
else if (x instanceof Double)
setDouble(parameterIndex, ((Double)x).doubleValue());
else if (x instanceof byte[])
setBytes(parameterIndex, (byte[])x);
else if (x instanceof java.sql.Date)
setDate(parameterIndex, (java.sql.Date)x);
else if (x instanceof Time)
setTime(parameterIndex, (Time)x);
else if (x instanceof Timestamp)
setTimestamp(parameterIndex, (Timestamp)x);
else if (x instanceof Boolean)
setBoolean(parameterIndex, ((Boolean)x).booleanValue());
else if (x instanceof Byte)
setByte(parameterIndex, ((Byte)x).byteValue());
else if (x instanceof Blob)
setBlob(parameterIndex, (Blob)x);
else if (x instanceof Clob)
setClob(parameterIndex, (Clob)x);
else if (x instanceof Array)
setArray(parameterIndex, (Array)x);
else if (x instanceof PGobject)
setPGobject(parameterIndex, (PGobject)x);
else if (x instanceof Character)
setString(parameterIndex, ((Character)x).toString());
else if (x instanceof Map)
setMap(parameterIndex, (Map)x);
else
{
// Can't infer a type.
throw new PSQLException(GT.tr("Can''t infer the SQL type to use for an instance of {0}. Use setObject() with an explicit Types value to specify the type to use.", x.getClass().getName()), PSQLState.INVALID_PARAMETER_TYPE);
}
}
/*
* Before 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
* @exception SQLException if a database-access error occurs.
*/
public void registerOutParameter(int parameterIndex, int sqlType, boolean setPreparedParameters) 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;
default:
break;
}
if (!isFunction)
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);
checkIndex(parameterIndex, false);
if( setPreparedParameters )
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;
}
/*
* You must also specify the scale for numeric/decimal types:
*
*
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.
*
* @param parameterIndex the first parameter is 1, the second is 2,...
* @param sqlType use either java.sql.Type.NUMERIC or java.sql.Type.DECIMAL
* @param scale a value greater than or equal to zero representing the
* desired number of digits to the right of the decimal point
* @exception SQLException if a database-access error occurs.
*/
public void registerOutParameter(int parameterIndex, int sqlType,
int scale, boolean setPreparedParameters) throws SQLException
{
registerOutParameter (parameterIndex, sqlType, setPreparedParameters); // ignore for now..
}
/*
* An OUT parameter may have the value of SQL NULL; wasNull
* reports whether the last value read has this special value.
*
*
Note: You must first call getXXX on a parameter to read its
* value and then call wasNull() to see if the value was SQL NULL.
* @return true if the last parameter read was SQL NULL
* @exception SQLException if a database-access error occurs.
*/
public boolean wasNull() throws SQLException
{
if (lastIndex == 0)
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);
}
/*
* Get the value of a CHAR, VARCHAR, or LONGVARCHAR parameter as a
* Java String.
*
* @param parameterIndex the first parameter is 1, the second is 2,...
* @return the parameter value; if the value is SQL NULL, the result is null
* @exception SQLException if a database-access error occurs.
*/
public String getString(int parameterIndex) throws SQLException
{
checkClosed();
checkIndex (parameterIndex, Types.VARCHAR, "String");
return (String)callResult[parameterIndex-1];
}
/*
* Get the value of a BIT parameter as a Java boolean.
*
* @param parameterIndex the first parameter is 1, the second is 2,...
* @return the parameter value; if the value is SQL NULL, the result is false
* @exception SQLException if a database-access error occurs.
*/
public boolean getBoolean(int parameterIndex) throws SQLException
{
checkClosed();
checkIndex (parameterIndex, Types.BIT, "Boolean");
if (callResult[parameterIndex-1] == null)
return false;
return ((Boolean)callResult[parameterIndex-1]).booleanValue ();
}
/*
* Get the value of a TINYINT parameter as a Java byte.
*
* @param parameterIndex the first parameter is 1, the second is 2,...
* @return the parameter value; if the value is SQL NULL, the result is 0
* @exception SQLException if a database-access error occurs.
*/
public byte getByte(int parameterIndex) throws SQLException
{
checkClosed();
// fake tiny int with smallint
checkIndex (parameterIndex, Types.SMALLINT, "Byte");
if (callResult[parameterIndex-1] == null)
return 0;
return ((Integer)callResult[parameterIndex-1]).byteValue();
}
/*
* Get the value of a SMALLINT parameter as a Java short.
*
* @param parameterIndex the first parameter is 1, the second is 2,...
* @return the parameter value; if the value is SQL NULL, the result is 0
* @exception SQLException if a database-access error occurs.
*/
public short getShort(int parameterIndex) throws SQLException
{
checkClosed();
checkIndex (parameterIndex, Types.SMALLINT, "Short");
if (callResult[parameterIndex-1] == null)
return 0;
return ((Integer)callResult[parameterIndex-1]).shortValue ();
}
/*
* Get the value of an INTEGER parameter as a Java int.
*
* @param parameterIndex the first parameter is 1, the second is 2,...
* @return the parameter value; if the value is SQL NULL, the result is 0
* @exception SQLException if a database-access error occurs.
*/
public int getInt(int parameterIndex) throws SQLException
{
checkClosed();
checkIndex (parameterIndex, Types.INTEGER, "Int");
if (callResult[parameterIndex-1] == null)
return 0;
return ((Integer)callResult[parameterIndex-1]).intValue ();
}
/*
* Get the value of a BIGINT parameter as a Java long.
*
* @param parameterIndex the first parameter is 1, the second is 2,...
* @return the parameter value; if the value is SQL NULL, the result is 0
* @exception SQLException if a database-access error occurs.
*/
public long getLong(int parameterIndex) throws SQLException
{
checkClosed();
checkIndex (parameterIndex, Types.BIGINT, "Long");
if (callResult[parameterIndex-1] == null)
return 0;
return ((Long)callResult[parameterIndex-1]).longValue ();
}
/*
* Get the value of a FLOAT parameter as a Java float.
*
* @param parameterIndex the first parameter is 1, the second is 2,...
* @return the parameter value; if the value is SQL NULL, the result is 0
* @exception SQLException if a database-access error occurs.
*/
public float getFloat(int parameterIndex) throws SQLException
{
checkClosed();
checkIndex (parameterIndex, Types.REAL, "Float");
if (callResult[parameterIndex-1] == null)
return 0;
return ((Float)callResult[parameterIndex-1]).floatValue ();
}
/*
* Get the value of a DOUBLE parameter as a Java double.
*
* @param parameterIndex the first parameter is 1, the second is 2,...
* @return the parameter value; if the value is SQL NULL, the result is 0
* @exception SQLException if a database-access error occurs.
*/
public double getDouble(int parameterIndex) throws SQLException
{
checkClosed();
checkIndex (parameterIndex, Types.DOUBLE, "Double");
if (callResult[parameterIndex-1] == null)
return 0;
return ((Double)callResult[parameterIndex-1]).doubleValue ();
}
/*
* Get the value of a NUMERIC parameter as a java.math.BigDecimal
* object.
*
* @param parameterIndex the first parameter is 1, the second is 2,...
* @param scale a value greater than or equal to zero representing the
* desired number of digits to the right of the decimal point
* @return the parameter value; if the value is SQL NULL, the result is null
* @exception SQLException if a database-access error occurs.
* @deprecated in Java2.0
*/
public BigDecimal getBigDecimal(int parameterIndex, int scale)
throws SQLException
{
checkClosed();
checkIndex (parameterIndex, Types.NUMERIC, "BigDecimal");
return ((BigDecimal)callResult[parameterIndex-1]);
}
/*
* Get the value of a SQL BINARY or VARBINARY parameter as a Java
* byte[]
*
* @param parameterIndex the first parameter is 1, the second is 2,...
* @return the parameter value; if the value is SQL NULL, the result is null
* @exception SQLException if a database-access error occurs.
*/
public byte[] getBytes(int parameterIndex) throws SQLException
{
checkClosed();
checkIndex (parameterIndex, Types.VARBINARY, Types.BINARY, "Bytes");
return ((byte [])callResult[parameterIndex-1]);
}
/*
* Get the value of a SQL DATE parameter as a java.sql.Date object
*
* @param parameterIndex the first parameter is 1, the second is 2,...
* @return the parameter value; if the value is SQL NULL, the result is null
* @exception SQLException if a database-access error occurs.
*/
public java.sql.Date getDate(int parameterIndex) throws SQLException
{
checkClosed();
checkIndex (parameterIndex, Types.DATE, "Date");
return (java.sql.Date)callResult[parameterIndex-1];
}
/*
* Get the value of a SQL TIME parameter as a java.sql.Time object.
*
* @param parameterIndex the first parameter is 1, the second is 2,...
* @return the parameter value; if the value is SQL NULL, the result is null
* @exception SQLException if a database-access error occurs.
*/
public java.sql.Time getTime(int parameterIndex) throws SQLException
{
checkClosed();
checkIndex (parameterIndex, Types.TIME, "Time");
return (java.sql.Time)callResult[parameterIndex-1];
}
/*
* Get the value of a SQL TIMESTAMP parameter as a java.sql.Timestamp object.
*
* @param parameterIndex the first parameter is 1, the second is 2,...
* @return the parameter value; if the value is SQL NULL, the result is null
* @exception SQLException if a database-access error occurs.
*/
public java.sql.Timestamp getTimestamp(int parameterIndex)
throws SQLException
{
checkClosed();
checkIndex (parameterIndex, Types.TIMESTAMP, "Timestamp");
return (java.sql.Timestamp)callResult[parameterIndex-1];
}
// getObject returns a Java object for the parameter.
// See the JDBC spec's "Dynamic Programming" chapter for details.
/*
* Get the value of a parameter as a Java object.
*
*
This method returns a Java object whose type coresponds to the
* SQL type that was registered for this parameter using
* registerOutParameter.
*
*
Note that this method may be used to read datatabase-specific,
* abstract data types. This is done by specifying a targetSqlType
* of java.sql.types.OTHER, which allows the driver to return a
* database-specific Java type.
*
*
See the JDBC spec's "Dynamic Programming" chapter for details.
*
* @param parameterIndex the first parameter is 1, the second is 2,...
* @return A java.lang.Object holding the OUT parameter value.
* @exception SQLException if a database-access error occurs.
*/
public Object getObject(int parameterIndex)
throws SQLException
{
checkClosed();
checkIndex (parameterIndex);
return callResult[parameterIndex-1];
}
/*
* Returns the SQL statement with the current template values
* substituted.
*/
public String toString()
{
if (preparedQuery == null)
return super.toString();
return preparedQuery.toString(preparedParameters);
}
/*
* Note if s is a String it should be escaped by the caller to avoid SQL
* injection attacks. It is not done here for efficency reasons as
* most calls to this method do not require escaping as the source
* of the string is known safe (i.e. Integer.toString())
*/
protected void bindLiteral(int paramIndex, String s, int oid) throws SQLException
{
if(adjustIndex)
paramIndex--;
preparedParameters.setLiteralParameter(paramIndex, s, oid);
}
protected void bindBytes(int paramIndex, byte[] b, int oid) throws SQLException
{
if(adjustIndex)
paramIndex--;
preparedParameters.setBinaryParameter(paramIndex, b, oid);
}
/*
* This version is for values that should turn into strings
* e.g. setString directly calls bindString with no escaping;
* the per-protocol ParameterList does escaping as needed.
*/
private void bindString(int paramIndex, String s, int oid) throws SQLException
{
if (adjustIndex)
paramIndex--;
preparedParameters.setStringParameter( paramIndex, s, oid);
}
/**
* this method will turn a string of the form
* { [? =] call [(?, [?,..])] }
* into the PostgreSQL format which is
* select (?, [?, ...]) as result
* or select * from (?, [?, ...]) as result (7.3)
*/
private String modifyJdbcCall(String p_sql) throws SQLException
{
checkClosed();
// Mini-parser for JDBC function-call syntax (only)
// TODO: Merge with escape processing (and parameter parsing?)
// so we only parse each query once.
isFunction = false;
boolean stdStrings = connection.getStandardConformingStrings();
int len = p_sql.length();
int state = 1;
boolean inQuotes = false, inEscape = false;
outParmBeforeFunc = false;
int startIndex = -1, endIndex = -1;
boolean syntaxError = false;
int i = 0;
while (i < len && !syntaxError)
{
char ch = p_sql.charAt(i);
switch (state)
{
case 1: // Looking for { at start of query
if (ch == '{')
{
++i;
++state;
}
else if (Character.isWhitespace(ch))
{
++i;
}
else
{
// Not function-call syntax. Skip the rest of the string.
i = len;
}
break;
case 2: // After {, looking for ? or =, skipping whitespace
if (ch == '?')
{
outParmBeforeFunc = isFunction = true; // { ? = call ... } -- function with one out parameter
++i;
++state;
}
else if (ch == 'c')
{ // { call ... } -- proc with no out parameters
state += 3; // Don't increase 'i'
}
else if (Character.isWhitespace(ch))
{
++i;
}
else
{
// "{ foo ...", doesn't make sense, complain.
syntaxError = true;
}
break;
case 3: // Looking for = after ?, skipping whitespace
if (ch == '=')
{
++i;
++state;
}
else if (Character.isWhitespace(ch))
{
++i;
}
else
{
syntaxError = true;
}
break;
case 4: // Looking for 'call' after '? =' skipping whitespace
if (ch == 'c' || ch == 'C')
{
++state; // Don't increase 'i'.
}
else if (Character.isWhitespace(ch))
{
++i;
}
else
{
syntaxError = true;
}
break;
case 5: // Should be at 'call ' either at start of string or after ?=
if ((ch == 'c' || ch == 'C') && i + 4 <= len && p_sql.substring(i, i + 4).equalsIgnoreCase("call"))
{
isFunction=true;
i += 4;
++state;
}
else if (Character.isWhitespace(ch))
{
++i;
}
else
{
syntaxError = true;
}
break;
case 6: // Looking for whitespace char after 'call'
if (Character.isWhitespace(ch))
{
// Ok, we found the start of the real call.
++i;
++state;
startIndex = i;
}
else
{
syntaxError = true;
}
break;
case 7: // In "body" of the query (after "{ [? =] call ")
if (ch == '\'')
{
inQuotes = !inQuotes;
++i;
}
else if (inQuotes && ch == '\\' && !stdStrings)
{
// Backslash in string constant, skip next character.
i += 2;
}
else if (!inQuotes && ch == '{')
{
inEscape = !inEscape;
++i;
}
else if (!inQuotes && ch == '}')
{
if (!inEscape)
{
// Should be end of string.
endIndex = i;
++i;
++state;
}
else
{
inEscape = false;
}
}
else if (!inQuotes && ch == ';')
{
syntaxError = true;
}
else
{
// Everything else is ok.
++i;
}
break;
case 8: // At trailing end of query, eating whitespace
if (Character.isWhitespace(ch))
{
++i;
}
else
{
syntaxError = true;
}
break;
default:
throw new IllegalStateException("somehow got into bad state " + state);
}
}
// We can only legally end in a couple of states here.
if (i == len && !syntaxError)
{
if (state == 1)
return p_sql; // Not an escaped syntax.
if (state != 8)
syntaxError = true; // Ran out of query while still parsing
}
if (syntaxError)
throw new PSQLException (GT.tr("Malformed function or procedure escape syntax at offset {0}.", new Integer(i)),
PSQLState.STATEMENT_NOT_ALLOWED_IN_FUNCTION_CALL);
if (connection.haveMinimumServerVersion("8.1") && ((AbstractJdbc2Connection)connection).getProtocolVersion() == 3)
{
String s = p_sql.substring(startIndex, endIndex );
StringBuffer sb = new StringBuffer(s);
if ( outParmBeforeFunc )
{
// move the single out parameter into the function call
// so that it can be treated like all other parameters
boolean needComma=false;
// have to use String.indexOf for java 2
int opening = s.indexOf('(')+1;
int closing = s.indexOf(')');
for ( int j=opening; j< closing;j++ )
{
if ( !Character.isWhitespace(sb.charAt(j)) )
{
needComma = true;
break;
}
}
if ( needComma )
{
sb.insert(opening, "?,");
}
else
{
sb.insert(opening, "?");
}
}
return "select * from " + sb.toString() + " as result";
}
else
{
return "select " + p_sql.substring(startIndex, endIndex) + " as result";
}
}
/** helperfunction for the getXXX calls to check isFunction and index == 1
* Compare BOTH type fields against the return type.
*/
protected void checkIndex (int parameterIndex, int type1, int type2, String getName)
throws SQLException
{
checkIndex (parameterIndex);
if (type1 != this.testReturn[parameterIndex-1] && type2 != this.testReturn[parameterIndex-1])
throw new PSQLException(GT.tr("Parameter of type {0} was registered, but call to get{1} (sqltype={2}) was made.",
new Object[]{"java.sql.Types=" + testReturn[parameterIndex-1],
getName,
"java.sql.Types=" + type1}),
PSQLState.MOST_SPECIFIC_TYPE_DOES_NOT_MATCH);
}
/** helperfunction for the getXXX calls to check isFunction and index == 1
*/
protected void checkIndex (int parameterIndex, int type, String getName)
throws SQLException
{
checkIndex (parameterIndex);
if (type != this.testReturn[parameterIndex-1])
throw new PSQLException(GT.tr("Parameter of type {0} was registered, but call to get{1} (sqltype={2}) was made.",
new Object[]{"java.sql.Types=" + testReturn[parameterIndex-1],
getName,
"java.sql.Types=" + type}),
PSQLState.MOST_SPECIFIC_TYPE_DOES_NOT_MATCH);
}
private void checkIndex (int parameterIndex) throws SQLException
{
checkIndex(parameterIndex, true);
}
/** helperfunction for the getXXX calls to check isFunction and index == 1
* @param parameterIndex index of getXXX (index)
* check to make sure is a function and index == 1
*/
private void checkIndex (int parameterIndex, boolean fetchingData) throws SQLException
{
if (!isFunction)
throw new PSQLException(GT.tr("A CallableStatement was declared, but no call to registerOutParameter(1, ) was made."), PSQLState.STATEMENT_NOT_ALLOWED_IN_FUNCTION_CALL);
if (fetchingData) {
if (!returnTypeSet)
throw new PSQLException(GT.tr("No function outputs were registered."), PSQLState.OBJECT_NOT_IN_STATE);
if (callResult == null)
throw new PSQLException(GT.tr("Results cannot be retrieved from a CallableStatement before it is executed."), PSQLState.NO_DATA);
lastIndex = parameterIndex;
}
}
public void setPrepareThreshold(int newThreshold) throws SQLException {
checkClosed();
if (ForceBinaryTransfers)
newThreshold = 1;
if (newThreshold < 0)
newThreshold = 0;
this.m_prepareThreshold = newThreshold;
}
public int getPrepareThreshold() {
return m_prepareThreshold;
}
public void setUseServerPrepare(boolean flag) throws SQLException {
setPrepareThreshold(flag ? 1 : 0);
}
public boolean isUseServerPrepare() {
return (preparedQuery != null && m_prepareThreshold != 0 && m_useCount + 1 >= m_prepareThreshold);
}
protected void checkClosed() throws SQLException
{
if (isClosed)
throw new PSQLException(GT.tr("This statement has been closed."),
PSQLState.OBJECT_NOT_IN_STATE);
}
// ** JDBC 2 Extensions **
public void addBatch(String p_sql) throws SQLException
{
checkClosed();
if (preparedQuery != null)
throw new PSQLException(GT.tr("Can''t use query methods that take a query string on a PreparedStatement."),
PSQLState.WRONG_OBJECT_TYPE);
if (batchStatements == null)
{
batchStatements = new ArrayList();
batchParameters = new ArrayList();
}
p_sql = replaceProcessing(p_sql);
batchStatements.add(connection.getQueryExecutor().createSimpleQuery(p_sql));
batchParameters.add(null);
}
public void clearBatch() throws SQLException
{
if (batchStatements != null)
{
batchStatements.clear();
batchParameters.clear();
}
}
//
// ResultHandler for batch queries.
//
private class BatchResultHandler implements ResultHandler {
private BatchUpdateException batchException = null;
private int resultIndex = 0;
private final Query[] queries;
private final ParameterList[] parameterLists;
private final int[] updateCounts;
private final boolean expectGeneratedKeys;
private ResultSet generatedKeys;
BatchResultHandler(Query[] queries, ParameterList[] parameterLists, int[] updateCounts, boolean expectGeneratedKeys) {
this.queries = queries;
this.parameterLists = parameterLists;
this.updateCounts = updateCounts;
this.expectGeneratedKeys = expectGeneratedKeys;
}
public void handleResultRows(Query fromQuery, Field[] fields, List tuples, ResultCursor cursor) {
if (!expectGeneratedKeys) {
handleError(new PSQLException(GT.tr("A result was returned when none was expected."),
PSQLState.TOO_MANY_RESULTS));
} else {
if (generatedKeys == null) {
try
{
generatedKeys = AbstractJdbc2Statement.this.createResultSet(fromQuery, fields, tuples, cursor);
}
catch (SQLException e)
{
handleError(e);
}
} else {
((AbstractJdbc2ResultSet)generatedKeys).addRows(tuples);
}
}
}
public void handleCommandStatus(String status, int updateCount, long insertOID) {
if (resultIndex >= updateCounts.length)
{
handleError(new PSQLException(GT.tr("Too many update results were returned."),
PSQLState.TOO_MANY_RESULTS));
return ;
}
updateCounts[resultIndex++] = updateCount;
}
public void handleWarning(SQLWarning warning) {
AbstractJdbc2Statement.this.addWarning(warning);
}
public void handleError(SQLException newError) {
if (batchException == null)
{
int[] successCounts;
if (resultIndex >= updateCounts.length)
successCounts = updateCounts;
else
{
successCounts = new int[resultIndex];
System.arraycopy(updateCounts, 0, successCounts, 0, resultIndex);
}
String queryString = "";
if (resultIndex < queries.length)
queryString = queries[resultIndex].toString(parameterLists[resultIndex]);
batchException = new BatchUpdateException(GT.tr("Batch entry {0} {1} was aborted. Call getNextException to see the cause.",
new Object[]{ new Integer(resultIndex),
queryString}),
newError.getSQLState(),
successCounts);
}
batchException.setNextException(newError);
}
public void handleCompletion() throws SQLException {
if (batchException != null)
throw batchException;
}
public ResultSet getGeneratedKeys() {
return generatedKeys;
}
}
private class CallableBatchResultHandler implements ResultHandler {
private BatchUpdateException batchException = null;
private int resultIndex = 0;
private final Query[] queries;
private final ParameterList[] parameterLists;
private final int[] updateCounts;
CallableBatchResultHandler(Query[] queries, ParameterList[] parameterLists, int[] updateCounts) {
this.queries = queries;
this.parameterLists = parameterLists;
this.updateCounts = updateCounts;
}
public void handleResultRows(Query fromQuery, Field[] fields, List tuples, ResultCursor cursor)
{
}
public void handleCommandStatus(String status, int updateCount, long insertOID) {
if (resultIndex >= updateCounts.length)
{
handleError(new PSQLException(GT.tr("Too many update results were returned."),
PSQLState.TOO_MANY_RESULTS));
return ;
}
updateCounts[resultIndex++] = updateCount;
}
public void handleWarning(SQLWarning warning) {
AbstractJdbc2Statement.this.addWarning(warning);
}
public void handleError(SQLException newError) {
if (batchException == null)
{
int[] successCounts;
if (resultIndex >= updateCounts.length)
successCounts = updateCounts;
else
{
successCounts = new int[resultIndex];
System.arraycopy(updateCounts, 0, successCounts, 0, resultIndex);
}
String queryString = "";
if (resultIndex < queries.length)
queryString = queries[resultIndex].toString(parameterLists[resultIndex]);
batchException = new BatchUpdateException(GT.tr("Batch entry {0} {1} was aborted. Call getNextException to see the cause.",
new Object[]{ new Integer(resultIndex),
queryString}),
newError.getSQLState(),
successCounts);
}
batchException.setNextException(newError);
}
public void handleCompletion() throws SQLException {
if (batchException != null)
throw batchException;
}
}
public int[] executeBatch() throws SQLException
{
checkClosed();
closeForNextExecution();
if (batchStatements == null || batchStatements.isEmpty())
return new int[0];
int size = batchStatements.size();
int[] updateCounts = new int[size];
// Construct query/parameter arrays.
Query[] queries = (Query[])batchStatements.toArray(new Query[batchStatements.size()]);
ParameterList[] parameterLists = (ParameterList[])batchParameters.toArray(new ParameterList[batchParameters.size()]);
batchStatements.clear();
batchParameters.clear();
int flags;
boolean preDescribe = false;
if (wantsGeneratedKeysAlways) {
flags = QueryExecutor.QUERY_BOTH_ROWS_AND_STATUS | QueryExecutor.QUERY_DISALLOW_BATCHING;
} else {
flags = QueryExecutor.QUERY_NO_RESULTS;
}
// Only use named statements after we hit the threshold
if (preparedQuery != null)
{
m_useCount += queries.length;
}
if (m_prepareThreshold == 0 || m_useCount < m_prepareThreshold) {
flags |= QueryExecutor.QUERY_ONESHOT;
} else {
preDescribe = wantsGeneratedKeysAlways && !queries[0].isStatementDescribed();
}
if (connection.getAutoCommit())
flags |= QueryExecutor.QUERY_SUPPRESS_BEGIN;
if (preDescribe || ForceBinaryTransfers) {
int flags2 = flags | QueryExecutor.QUERY_DESCRIBE_ONLY;
StatementResultHandler handler2 = new StatementResultHandler();
connection.getQueryExecutor().execute(queries[0], parameterLists[0], handler2, 0, 0, flags2);
ResultWrapper result2 = handler2.getResults();
if (result2 != null) {
result2.getResultSet().close();
}
}
result = null;
ResultHandler handler;
if (isFunction) {
handler = new CallableBatchResultHandler(queries, parameterLists, updateCounts );
} else {
handler = new BatchResultHandler(queries, parameterLists, updateCounts, wantsGeneratedKeysAlways);
}
connection.getQueryExecutor().execute(queries,
parameterLists,
handler,
maxrows,
fetchSize,
flags);
if (wantsGeneratedKeysAlways) {
generatedKeys = new ResultWrapper(((BatchResultHandler)handler).getGeneratedKeys());
}
return updateCounts;
}
/*
* Cancel can be used by one thread to cancel a statement that
* is being executed by another thread.
*
*
* @exception SQLException only because thats the spec.
*/
public void cancel() throws SQLException
{
connection.cancelQuery();
}
public Connection getConnection() throws SQLException
{
return (Connection) connection;
}
public int getFetchDirection()
{
return fetchdirection;
}
public int getResultSetConcurrency()
{
return concurrency;
}
public int getResultSetType()
{
return resultsettype;
}
public void setFetchDirection(int direction) throws SQLException
{
switch (direction)
{
case ResultSet.FETCH_FORWARD:
case ResultSet.FETCH_REVERSE:
case ResultSet.FETCH_UNKNOWN:
fetchdirection = direction;
break;
default:
throw new PSQLException(GT.tr("Invalid fetch direction constant: {0}.", new Integer(direction)),
PSQLState.INVALID_PARAMETER_VALUE);
}
}
public void setFetchSize(int rows) throws SQLException
{
checkClosed();
if (rows < 0)
throw new PSQLException(GT.tr("Fetch size must be a value greater to or equal to 0."),
PSQLState.INVALID_PARAMETER_VALUE);
fetchSize = rows;
}
public void addBatch() throws SQLException
{
checkClosed();
if (batchStatements == null)
{
batchStatements = new ArrayList();
batchParameters = new ArrayList();
}
// we need to create copies of our parameters, otherwise the values can be changed
batchStatements.add(preparedQuery);
batchParameters.add(preparedParameters.copy());
}
public ResultSetMetaData getMetaData() throws SQLException
{
checkClosed();
ResultSet rs = getResultSet();
if (rs == null) {
// OK, we haven't executed it yet, we've got to go to the backend
// for more info. We send the full query, but just don't
// execute it.
int flags = QueryExecutor.QUERY_ONESHOT | QueryExecutor.QUERY_DESCRIBE_ONLY | QueryExecutor.QUERY_SUPPRESS_BEGIN;
StatementResultHandler handler = new StatementResultHandler();
connection.getQueryExecutor().execute(preparedQuery, preparedParameters, handler, 0, 0, flags);
ResultWrapper wrapper = handler.getResults();
if (wrapper != null) {
rs = wrapper.getResultSet();
}
}
if (rs != null)
return rs.getMetaData();
return null;
}
public void setArray(int i, java.sql.Array x) throws SQLException
{
checkClosed();
if (null == x)
{
setNull(i, Types.ARRAY);
return;
}
// This only works for Array implementations that return a valid array
// literal from Array.toString(), such as the implementation we return
// from ResultSet.getArray(). Eventually we need a proper implementation
// here that works for any Array implementation.
// Use a typename that is "_" plus the base type; this matches how the
// backend looks for array types.
String typename = "_" + x.getBaseTypeName();
int oid = connection.getTypeInfo().getPGType(typename);
if (oid == Oid.UNSPECIFIED)
throw new PSQLException(GT.tr("Unknown type {0}.", typename), PSQLState.INVALID_PARAMETER_TYPE);
if (x instanceof AbstractJdbc2Array) {
AbstractJdbc2Array arr = (AbstractJdbc2Array) x;
if (arr.isBinary()) {
bindBytes(i, arr.toBytes(), oid);
return;
}
}
setString(i, x.toString(), oid);
}
public void setBlob(int i, Blob x) throws SQLException
{
checkClosed();
if (x == null)
{
setNull(i, Types.BLOB);
return;
}
InputStream l_inStream = x.getBinaryStream();
LargeObjectManager lom = connection.getLargeObjectAPI();
long oid = lom.createLO();
LargeObject lob = lom.open(oid);
OutputStream los = lob.getOutputStream();
byte[] buf = new byte[4096];
try
{
// could be buffered, but then the OutputStream returned by LargeObject
// is buffered internally anyhow, so there would be no performance
// boost gained, if anything it would be worse!
int bytesRemaining = (int)x.length();
int numRead = l_inStream.read(buf, 0, Math.min(buf.length, bytesRemaining));
while (numRead != -1 && bytesRemaining > 0)
{
bytesRemaining -= numRead;
if ( numRead == buf.length )
los.write(buf); // saves a buffer creation and copy in LargeObject since it's full
else
los.write(buf, 0, numRead);
numRead = l_inStream.read(buf, 0, Math.min(buf.length, bytesRemaining));
}
}
catch (IOException se)
{
throw new PSQLException(GT.tr("Unexpected error writing large object to database."), PSQLState.UNEXPECTED_ERROR, se);
}
finally
{
try
{
los.close();
l_inStream.close();
}
catch ( Exception e )
{
}
}
setLong(i, oid);
}
public void setCharacterStream(int i, java.io.Reader x, int length) throws SQLException
{
checkClosed();
if (x == null) {
if (connection.haveMinimumServerVersion("7.2")) {
setNull(i, Types.VARCHAR);
} else {
setNull(i, Types.CLOB);
}
return;
}
if (length < 0)
throw new PSQLException(GT.tr("Invalid stream length {0}.", new Integer(length)),
PSQLState.INVALID_PARAMETER_VALUE);
if (connection.haveMinimumCompatibleVersion("7.2"))
{
//Version 7.2 supports CharacterStream for for the PG text types
//As the spec/javadoc for this method indicate this is to be used for
//large text values (i.e. LONGVARCHAR) PG doesn't have a separate
//long varchar datatype, but with toast all the text datatypes are capable of
//handling very large values. Thus the implementation ends up calling
//setString() since there is no current way to stream the value to the server
char[] l_chars = new char[length];
int l_charsRead = 0;
try
{
while (true)
{
int n = x.read(l_chars, l_charsRead, length - l_charsRead);
if (n == -1)
break;
l_charsRead += n;
if (l_charsRead == length)
break;
}
}
catch (IOException l_ioe)
{
throw new PSQLException(GT.tr("Provided Reader failed."), PSQLState.UNEXPECTED_ERROR, l_ioe);
}
setString(i, new String(l_chars, 0, l_charsRead));
}
else
{
//Version 7.1 only supported streams for LargeObjects
//but the jdbc spec indicates that streams should be
//available for LONGVARCHAR instead
LargeObjectManager lom = connection.getLargeObjectAPI();
long oid = lom.createLO();
LargeObject lob = lom.open(oid);
OutputStream los = lob.getOutputStream();
try
{
// could be buffered, but then the OutputStream returned by LargeObject
// is buffered internally anyhow, so there would be no performance
// boost gained, if anything it would be worse!
int c = x.read();
int p = 0;
while (c > -1 && p < length)
{
los.write(c);
c = x.read();
p++;
}
los.close();
}
catch (IOException se)
{
throw new PSQLException(GT.tr("Unexpected error writing large object to database."), PSQLState.UNEXPECTED_ERROR, se);
}
// lob is closed by the stream so don't call lob.close()
setLong(i, oid);
}
}
public void setClob(int i, Clob x) throws SQLException
{
checkClosed();
if (x == null)
{
setNull(i, Types.CLOB);
return;
}
InputStream l_inStream = x.getAsciiStream();
int l_length = (int) x.length();
LargeObjectManager lom = connection.getLargeObjectAPI();
long oid = lom.createLO();
LargeObject lob = lom.open(oid);
OutputStream los = lob.getOutputStream();
try
{
// could be buffered, but then the OutputStream returned by LargeObject
// is buffered internally anyhow, so there would be no performance
// boost gained, if anything it would be worse!
int c = l_inStream.read();
int p = 0;
while (c > -1 && p < l_length)
{
los.write(c);
c = l_inStream.read();
p++;
}
los.close();
}
catch (IOException se)
{
throw new PSQLException(GT.tr("Unexpected error writing large object to database."), PSQLState.UNEXPECTED_ERROR, se);
}
// lob is closed by the stream so don't call lob.close()
setLong(i, oid);
}
public void setNull(int i, int t, String s) throws SQLException
{
checkClosed();
setNull(i, t);
}
public void setRef(int i, Ref x) throws SQLException
{
throw Driver.notImplemented(this.getClass(), "setRef(int,Ref)");
}
public void setDate(int i, java.sql.Date d, java.util.Calendar cal) throws SQLException
{
checkClosed();
if (d == null)
{
setNull(i, Types.DATE);
return;
}
if (connection.binaryTransferSend(Oid.DATE)) {
byte[] val = new byte[4];
TimeZone tz = cal != null ? cal.getTimeZone() : null;
connection.getTimestampUtils().toBinDate(tz, val, d);
preparedParameters.setBinaryParameter(i, val, Oid.DATE);
return;
}
if (cal != null)
cal = (Calendar)cal.clone();
// We must use UNSPECIFIED here, or inserting a Date-with-timezone into a
// timestamptz field does an unexpected rotation by the server's TimeZone:
//
// We want to interpret 2005/01/01 with calendar +0100 as
// "local midnight in +0100", but if we go via date it interprets it
// as local midnight in the server's timezone:
// template1=# select '2005-01-01+0100'::timestamptz;
// timestamptz
// ------------------------
// 2005-01-01 02:00:00+03
// (1 row)
// template1=# select '2005-01-01+0100'::date::timestamptz;
// timestamptz
// ------------------------
// 2005-01-01 00:00:00+03
// (1 row)
bindString(i, connection.getTimestampUtils().toString(cal, d), Oid.UNSPECIFIED);
}
public void setTime(int i, Time t, java.util.Calendar cal) throws SQLException
{
checkClosed();
if (t == null)
{
setNull(i, Types.TIME);
return;
}
if (cal != null)
cal = (Calendar)cal.clone();
bindString(i, connection.getTimestampUtils().toString(cal, t), Oid.UNSPECIFIED);
}
public void setTimestamp(int i, Timestamp t, java.util.Calendar cal) throws SQLException
{
checkClosed();
if (t == null) {
setNull(i, Types.TIMESTAMP);
return;
}
if (cal != null)
cal = (Calendar)cal.clone();
// Use UNSPECIFIED as a compromise to get both TIMESTAMP and TIMESTAMPTZ working.
// This is because you get this in a +1300 timezone:
//
// template1=# select '2005-01-01 15:00:00 +1000'::timestamptz;
// timestamptz
// ------------------------
// 2005-01-01 18:00:00+13
// (1 row)
// template1=# select '2005-01-01 15:00:00 +1000'::timestamp;
// timestamp
// ---------------------
// 2005-01-01 15:00:00
// (1 row)
// template1=# select '2005-01-01 15:00:00 +1000'::timestamptz::timestamp;
// timestamp
// ---------------------
// 2005-01-01 18:00:00
// (1 row)
// So we want to avoid doing a timestamptz -> timestamp conversion, as that
// will first convert the timestamptz to an equivalent time in the server's
// timezone (+1300, above), then turn it into a timestamp with the "wrong"
// time compared to the string we originally provided. But going straight
// to timestamp is OK as the input parser for timestamp just throws away
// the timezone part entirely. Since we don't know ahead of time what type
// we're actually dealing with, UNSPECIFIED seems the lesser evil, even if it
// does give more scope for type-mismatch errors being silently hidden.
bindString(i, connection.getTimestampUtils().toString(cal, t), Oid.UNSPECIFIED); // Let the server infer the right type.
}
// ** JDBC 2 Extensions for CallableStatement**
public java.sql.Array getArray(int i) throws SQLException
{
checkClosed();
checkIndex(i, Types.ARRAY, "Array");
return (Array)callResult[i-1];
}
public java.math.BigDecimal getBigDecimal(int parameterIndex) throws SQLException
{
checkClosed();
checkIndex (parameterIndex, Types.NUMERIC, "BigDecimal");
return ((BigDecimal)callResult[parameterIndex-1]);
}
public Blob getBlob(int i) throws SQLException
{
throw Driver.notImplemented(this.getClass(), "getBlob(int)");
}
public Clob getClob(int i) throws SQLException
{
throw Driver.notImplemented(this.getClass(), "getClob(int)");
}
public Object getObjectImpl(int i, java.util.Map map) throws SQLException
{
if (map == null || map.isEmpty()) {
return getObject(i);
}
throw Driver.notImplemented(this.getClass(), "getObjectImpl(int,Map)");
}
public Ref getRef(int i) throws SQLException
{
throw Driver.notImplemented(this.getClass(), "getRef(int)");
}
public java.sql.Date getDate(int i, java.util.Calendar cal) throws SQLException
{
checkClosed();
checkIndex(i, Types.DATE, "Date");
if (callResult[i-1] == null)
return null;
if (cal != null)
cal = (Calendar)cal.clone();
String value = callResult[i-1].toString();
return connection.getTimestampUtils().toDate(cal, value);
}
public Time getTime(int i, java.util.Calendar cal) throws SQLException
{
checkClosed();
checkIndex(i, Types.TIME, "Time");
if (callResult[i-1] == null)
return null;
if (cal != null)
cal = (Calendar)cal.clone();
String value = callResult[i-1].toString();
return connection.getTimestampUtils().toTime(cal, value);
}
public Timestamp getTimestamp(int i, java.util.Calendar cal) throws SQLException
{
checkClosed();
checkIndex(i, Types.TIMESTAMP, "Timestamp");
if (callResult[i-1] == null)
return null;
if (cal != null)
cal = (Calendar)cal.clone();
String value = callResult[i-1].toString();
return connection.getTimestampUtils().toTimestamp(cal, value);
}
// no custom types allowed yet..
public void registerOutParameter(int parameterIndex, int sqlType, String typeName) throws SQLException
{
throw Driver.notImplemented(this.getClass(), "registerOutParameter(int,int,String)");
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc2/EscapedFunctions.java 0000664 0000000 0000000 00000062354 12050675701 0025730 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc2;
import java.lang.reflect.Method;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Locale;
import java.util.List;
import java.util.Map;
import org.postgresql.util.GT;
import org.postgresql.util.PSQLException;
import org.postgresql.util.PSQLState;
/**
* this class stores supported escaped function
* @author Xavier Poinsard
*/
public class EscapedFunctions {
// numeric functions names
public final static String ABS="abs";
public final static String ACOS="acos";
public final static String ASIN="asin";
public final static String ATAN="atan";
public final static String ATAN2="atan2";
public final static String CEILING="ceiling";
public final static String COS="cos";
public final static String COT="cot";
public final static String DEGREES="degrees";
public final static String EXP="exp";
public final static String FLOOR="floor";
public final static String LOG="log";
public final static String LOG10="log10";
public final static String MOD="mod";
public final static String PI="pi";
public final static String POWER="power";
public final static String RADIANS="radians";
public final static String ROUND="round";
public final static String SIGN="sign";
public final static String SIN="sin";
public final static String SQRT="sqrt";
public final static String TAN="tan";
public final static String TRUNCATE="truncate";
// string function names
public final static String ASCII="ascii";
public final static String CHAR="char";
public final static String CONCAT="concat";
public final static String INSERT="insert"; // change arguments order
public final static String LCASE="lcase";
public final static String LEFT="left";
public final static String LENGTH="length";
public final static String LOCATE="locate"; // the 3 args version duplicate args
public final static String LTRIM="ltrim";
public final static String REPEAT="repeat";
public final static String REPLACE="replace";
public final static String RIGHT="right"; // duplicate args
public final static String RTRIM="rtrim";
public final static String SPACE="space";
public final static String SUBSTRING="substring";
public final static String UCASE="ucase";
// soundex is implemented on the server side by
// the contrib/fuzzystrmatch module. We provide a translation
// for this in the driver, but since we don't want to bother with run
// time detection of this module's installation we don't report this
// method as supported in DatabaseMetaData.
// difference is currently unsupported entirely.
// date time function names
public final static String CURDATE="curdate";
public final static String CURTIME="curtime";
public final static String DAYNAME="dayname";
public final static String DAYOFMONTH="dayofmonth";
public final static String DAYOFWEEK="dayofweek";
public final static String DAYOFYEAR="dayofyear";
public final static String HOUR="hour";
public final static String MINUTE="minute";
public final static String MONTH="month";
public final static String MONTHNAME="monthname";
public final static String NOW="now";
public final static String QUARTER="quarter";
public final static String SECOND="second";
public final static String WEEK="week";
public final static String YEAR="year";
// for timestampadd and timestampdiff the fractional part of second is not supported
// by the backend
// timestampdiff is very partially supported
public final static String TIMESTAMPADD="timestampadd";
public final static String TIMESTAMPDIFF="timestampdiff";
// constants for timestampadd and timestampdiff
public final static String SQL_TSI_ROOT="SQL_TSI_";
public final static String SQL_TSI_DAY="DAY";
public final static String SQL_TSI_FRAC_SECOND="FRAC_SECOND";
public final static String SQL_TSI_HOUR="HOUR";
public final static String SQL_TSI_MINUTE="MINUTE";
public final static String SQL_TSI_MONTH="MONTH";
public final static String SQL_TSI_QUARTER="QUARTER";
public final static String SQL_TSI_SECOND="SECOND";
public final static String SQL_TSI_WEEK="WEEK";
public final static String SQL_TSI_YEAR="YEAR";
// system functions
public final static String DATABASE="database";
public final static String IFNULL="ifnull";
public final static String USER="user";
/** storage for functions implementations */
private static Map functionMap = createFunctionMap();
private static Map createFunctionMap() {
Method[] arrayMeths = EscapedFunctions.class.getDeclaredMethods();
Map functionMap = new HashMap(arrayMeths.length*2);
for (int i=0;i l_yearlen; i--)
{
sb.append("0");
}
sb.append(l_year);
sb.append('-');
int l_month = cal.get(Calendar.MONTH) + 1;
if (l_month < 10)
sb.append('0');
sb.append(l_month);
sb.append('-');
int l_day = cal.get(Calendar.DAY_OF_MONTH);
if (l_day < 10)
sb.append('0');
sb.append(l_day);
}
private static void appendTime(StringBuffer sb, Calendar cal, int nanos)
{
int hours = cal.get(Calendar.HOUR_OF_DAY);
if (hours < 10)
sb.append('0');
sb.append(hours);
sb.append(':');
int minutes = cal.get(Calendar.MINUTE);
if (minutes < 10)
sb.append('0');
sb.append(minutes);
sb.append(':');
int seconds = cal.get(Calendar.SECOND);
if (seconds < 10)
sb.append('0');
sb.append(seconds);
// Add nanoseconds.
// This won't work for server versions < 7.2 which only want
// a two digit fractional second, but we don't need to support 7.1
// anymore and getting the version number here is difficult.
//
char[] decimalStr = {'0', '0', '0', '0', '0', '0', '0', '0', '0'};
char[] nanoStr = Integer.toString(nanos).toCharArray();
System.arraycopy(nanoStr, 0, decimalStr, decimalStr.length - nanoStr.length, nanoStr.length);
sb.append('.');
sb.append(decimalStr, 0, 6);
}
private void appendTimeZone(StringBuffer sb, java.util.Calendar cal)
{
int offset = (cal.get(Calendar.ZONE_OFFSET) + cal.get(Calendar.DST_OFFSET)) / 1000;
int absoff = Math.abs(offset);
int hours = absoff / 60 / 60;
int mins = (absoff - hours * 60 * 60) / 60;
int secs = absoff - hours * 60 * 60 - mins * 60;
sb.append((offset >= 0) ? " +" : " -");
if (hours < 10)
sb.append('0');
sb.append(hours);
sb.append(':');
if (mins < 10)
sb.append('0');
sb.append(mins);
if (min82) {
sb.append(':');
if (secs < 10)
sb.append('0');
sb.append(secs);
}
}
private static void appendEra(StringBuffer sb, Calendar cal)
{
if (cal.get(Calendar.ERA) == GregorianCalendar.BC) {
sb.append(" BC");
}
}
private static int skipWhitespace(char []s, int start)
{
int slen = s.length;
for (int i=start; i= end) {
throw new NumberFormatException();
}
int n=0;
for ( int i=start; i < end; i++)
{
n = 10 * n + (s[i]-'0');
}
return n;
}
private static char charAt(char []s, int pos) {
if (pos >= 0 && pos < s.length) {
return s[pos];
}
return '\0';
}
/**
* Returns the SQL Date object matching the given bytes with
* {@link Oid#DATE}.
*
* @param tz The timezone used.
* @param bytes The binary encoded date value.
* @return The parsed date object.
* @throws PSQLException If binary format could not be parsed.
*/
public Date toDateBin(TimeZone tz, byte[] bytes) throws PSQLException {
if (bytes.length != 4) {
throw new PSQLException(GT.tr("Unsupported binary encoding of {0}.",
"date"), PSQLState.BAD_DATETIME_FORMAT);
}
int days = ByteConverter.int4(bytes, 0);
if (tz == null) {
tz = defaultTz;
}
long secs = toJavaSecs(days * 86400L);
long millis = secs * 1000L;
int offset = tz.getOffset(millis);
if (millis <= PGStatement.DATE_NEGATIVE_SMALLER_INFINITY) {
millis = PGStatement.DATE_NEGATIVE_INFINITY;
offset = 0;
} else if (millis >= PGStatement.DATE_POSITIVE_SMALLER_INFINITY) {
millis = PGStatement.DATE_POSITIVE_INFINITY;
offset = 0;
}
return new Date(millis - offset);
}
/**
* Returns the SQL Time object matching the given bytes with
* {@link Oid#TIME} or {@link Oid#TIMETZ}.
*
* @param tz The timezone used when received data is {@link Oid#TIME},
* ignored if data already contains {@link Oid#TIMETZ}.
* @param bytes The binary encoded time value.
* @return The parsed time object.
* @throws PSQLException If binary format could not be parsed.
*/
public Time toTimeBin(TimeZone tz, byte[] bytes) throws PSQLException {
if ((bytes.length != 8 && bytes.length != 12)) {
throw new PSQLException(GT.tr("Unsupported binary encoding of {0}.",
"time"), PSQLState.BAD_DATETIME_FORMAT);
}
long millis;
int timeOffset;
if (usesDouble) {
double time = ByteConverter.float8(bytes, 0);
millis = (long) (time * 1000);
} else {
long time = ByteConverter.int8(bytes, 0);
millis = time / 1000;
}
if (bytes.length == 12) {
timeOffset = ByteConverter.int4(bytes, 8);
timeOffset *= -1000;
} else {
if (tz == null) {
tz = defaultTz;
}
timeOffset = tz.getOffset(millis);
}
millis -= timeOffset;
return new Time(millis);
}
/**
* Returns the SQL Timestamp object matching the given bytes with
* {@link Oid#TIMESTAMP} or {@link Oid#TIMESTAMPTZ}.
*
* @param tz The timezone used when received data is {@link Oid#TIMESTAMP},
* ignored if data already contains {@link Oid#TIMESTAMPTZ}.
* @param bytes The binary encoded timestamp value.
* @param timestamptz True if the binary is in GMT.
* @return The parsed timestamp object.
* @throws PSQLException If binary format could not be parsed.
*/
public Timestamp toTimestampBin(TimeZone tz, byte[] bytes, boolean timestamptz)
throws PSQLException {
if (bytes.length != 8) {
throw new PSQLException(GT.tr("Unsupported binary encoding of {0}.",
"timestamp"), PSQLState.BAD_DATETIME_FORMAT);
}
long secs;
int nanos;
if (usesDouble) {
double time = ByteConverter.float8(bytes, 0);
if (time == Double.POSITIVE_INFINITY) {
return new Timestamp(PGStatement.DATE_POSITIVE_INFINITY);
} else if (time == Double.NEGATIVE_INFINITY) {
return new Timestamp(PGStatement.DATE_NEGATIVE_INFINITY);
}
secs = (long) time;
nanos = (int) ((time - secs) * 1000000);
} else {
long time = ByteConverter.int8(bytes, 0);
// compatibility with text based receiving, not strictly necessary
// and can actually be confusing because there are timestamps
// that are larger than infinite
if (time == Long.MAX_VALUE) {
return new Timestamp(PGStatement.DATE_POSITIVE_INFINITY);
} else if (time == Long.MIN_VALUE) {
return new Timestamp(PGStatement.DATE_NEGATIVE_INFINITY);
}
secs = time / 1000000;
nanos = (int) (time - secs * 1000000);
}
if (nanos < 0) {
secs--;
nanos += 1000000;
}
nanos *= 1000;
secs = toJavaSecs(secs);
long millis = secs * 1000L;
if (!timestamptz) {
if (tz == null) {
tz = defaultTz;
}
millis -= tz.getOffset(millis);
}
Timestamp ts = new Timestamp(millis);
ts.setNanos(nanos);
return ts;
}
/**
* Extracts the date part from a timestamp.
*
* @param timestamp The timestamp from which to extract the date.
* @param tz The time zone of the date.
* @return The extracted date.
*/
public Date convertToDate(Timestamp timestamp, TimeZone tz) {
long millis = timestamp.getTime();
// no adjustments for the inifity hack values
if (millis <= PGStatement.DATE_NEGATIVE_INFINITY ||
millis >= PGStatement.DATE_POSITIVE_INFINITY) {
return new Date(millis);
}
if (tz == null) {
tz = defaultTz;
}
int offset = tz.getOffset(millis);
long timePart = millis % ONEDAY;
if (timePart + offset >= ONEDAY) {
millis += ONEDAY;
}
millis -= timePart;
millis -= offset;
return new Date(millis);
}
/**
* Extracts the time part from a timestamp.
*
* @param timestamp The timestamp from which to extract the time.
* @param tz The time zone of the time.
* @return The extracted time.
*/
public Time convertToTime(Timestamp timestamp, TimeZone tz) {
long millis = timestamp.getTime();
if (tz == null) {
tz = defaultTz;
}
int offset = tz.getOffset(millis);
long low = - tz.getOffset(millis);
long high = low + ONEDAY;
if (millis < low) {
do { millis += ONEDAY; } while (millis < low);
} else if (millis >= high) {
do { millis -= ONEDAY; } while (millis > high);
}
return new Time(millis);
}
/**
* Returns the given time value as String matching what the
* current postgresql server would send in text mode.
*/
public String timeToString(java.util.Date time) {
long millis = time.getTime();
if (millis <= PGStatement.DATE_NEGATIVE_INFINITY) {
return "-infinity";
}
if (millis >= PGStatement.DATE_POSITIVE_INFINITY) {
return "infinity";
}
return time.toString();
}
/**
* Converts the given postgresql seconds to java seconds.
* Reverse engineered by inserting varying dates to postgresql
* and tuning the formula until the java dates matched.
* See {@link #toPgSecs} for the reverse operation.
*
* @param secs Postgresql seconds.
* @return Java seconds.
*/
private static long toJavaSecs(long secs) {
// postgres epoc to java epoc
secs += 946684800L;
// Julian/Gregorian calendar cutoff point
if (secs < -12219292800L) { // October 4, 1582 -> October 15, 1582
secs += 86400 * 10;
if (secs < -14825808000L) { // 1500-02-28 -> 1500-03-01
int extraLeaps = (int) ((secs + 14825808000L) / 3155760000L);
extraLeaps--;
extraLeaps -= extraLeaps / 4;
secs += extraLeaps * 86400L;
}
}
return secs;
}
/**
* Converts the given java seconds to postgresql seconds.
* See {@link #toJavaSecs} for the reverse operation.
* The conversion is valid for any year 100 BC onwards.
*
* @param secs Postgresql seconds.
* @return Java seconds.
*/
private static long toPgSecs(long secs) {
// java epoc to postgres epoc
secs -= 946684800L;
// Julian/Greagorian calendar cutoff point
if (secs < -13165977600L) { // October 15, 1582 -> October 4, 1582
secs -= 86400 * 10;
if (secs < -15773356800L) { // 1500-03-01 -> 1500-02-28
int years = (int) ((secs + 15773356800L) / -3155823050L);
years++;
years -= years/4;
secs += years * 86400;
}
}
return secs;
}
/**
* Converts the SQL Date to binary representation for {@link Oid#DATE}.
*
* @param tz The timezone used.
* @param bytes The binary encoded date value.
* @throws PSQLException If binary format could not be parsed.
*/
public void toBinDate(TimeZone tz, byte[] bytes, Date value) throws PSQLException {
long millis = value.getTime();
if (tz == null) {
tz = defaultTz;
}
millis += tz.getOffset(millis);
long secs = toPgSecs(millis / 1000);
ByteConverter.int4(bytes, 0, (int) (secs / 86400));
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc2/TypeInfoCache.java 0000664 0000000 0000000 00000061104 12050675701 0025144 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2005-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc2;
import java.util.Map;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Collections;
import java.sql.Types;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.PreparedStatement;
import org.postgresql.Driver;
import org.postgresql.core.Oid;
import org.postgresql.core.BaseStatement;
import org.postgresql.core.BaseConnection;
import org.postgresql.core.QueryExecutor;
import org.postgresql.core.TypeInfo;
import org.postgresql.util.GT;
import org.postgresql.util.PGobject;
import org.postgresql.util.PSQLState;
import org.postgresql.util.PSQLException;
public class TypeInfoCache implements TypeInfo {
// pgname (String) -> java.sql.Types (Integer)
private Map _pgNameToSQLType;
// pgname (String) -> java class name (String)
// ie "text" -> "java.lang.String"
private Map _pgNameToJavaClass;
// oid (Integer) -> pgname (String)
private Map _oidToPgName;
// pgname (String) -> oid (Integer)
private Map _pgNameToOid;
// pgname (String) -> extension pgobject (Class)
private Map _pgNameToPgObject;
// type array oid -> base type's oid
private Map/**/ _pgArrayToPgType;
// array type oid -> base type array element delimiter
private Map/**/ _arrayOidToDelimiter;
private BaseConnection _conn;
private final int _unknownLength;
private PreparedStatement _getOidStatement;
private PreparedStatement _getNameStatement;
private PreparedStatement _getArrayElementOidStatement;
private PreparedStatement _getArrayDelimiterStatement;
private PreparedStatement _getTypeInfoStatement;
// basic pg types info:
// 0 - type name
// 1 - type oid
// 2 - sql type
// 3 - java class
// 4 - array type oid
// 5 - conditional minimum server version
// 6 - conditional minimum JDK build version
private static final Object types[][] = {
{"int2", new Integer(Oid.INT2), new Integer(Types.SMALLINT), "java.lang.Integer", new Integer(Oid.INT2_ARRAY)},
{"int4", new Integer(Oid.INT4), new Integer(Types.INTEGER), "java.lang.Integer", new Integer(Oid.INT4_ARRAY)},
{"oid", new Integer(Oid.OID), new Integer(Types.BIGINT), "java.lang.Long", new Integer(Oid.OID_ARRAY)},
{"int8", new Integer(Oid.INT8), new Integer(Types.BIGINT), "java.lang.Long", new Integer(Oid.INT8_ARRAY)},
{"money", new Integer(Oid.MONEY), new Integer(Types.DOUBLE), "java.lang.Double", new Integer(Oid.MONEY_ARRAY)},
{"numeric", new Integer(Oid.NUMERIC), new Integer(Types.NUMERIC), "java.math.BigDecimal", new Integer(Oid.NUMERIC_ARRAY)},
{"float4", new Integer(Oid.FLOAT4), new Integer(Types.REAL), "java.lang.Float", new Integer(Oid.FLOAT4_ARRAY)},
{"float8", new Integer(Oid.FLOAT8), new Integer(Types.DOUBLE), "java.lang.Double", new Integer(Oid.FLOAT8_ARRAY)},
{"char", new Integer(Oid.CHAR), new Integer(Types.CHAR), "java.lang.String", new Integer(Oid.CHAR_ARRAY)},
{"bpchar", new Integer(Oid.BPCHAR), new Integer(Types.CHAR), "java.lang.String", new Integer(Oid.BPCHAR_ARRAY)},
{"varchar", new Integer(Oid.VARCHAR), new Integer(Types.VARCHAR), "java.lang.String", new Integer(Oid.VARCHAR_ARRAY)},
{"text", new Integer(Oid.TEXT), new Integer(Types.VARCHAR), "java.lang.String", new Integer(Oid.TEXT_ARRAY)},
{"name", new Integer(Oid.NAME), new Integer(Types.VARCHAR), "java.lang.String", new Integer(Oid.NAME_ARRAY)},
{"bytea", new Integer(Oid.BYTEA), new Integer(Types.BINARY), "[B", new Integer(Oid.BYTEA_ARRAY)},
{"bool", new Integer(Oid.BOOL), new Integer(Types.BIT), "java.lang.Boolean", new Integer(Oid.BOOL_ARRAY)},
{"bit", new Integer(Oid.BIT), new Integer(Types.BIT), "java.lang.Boolean", new Integer(Oid.BIT_ARRAY)},
{"date", new Integer(Oid.DATE), new Integer(Types.DATE), "java.sql.Date", new Integer(Oid.DATE_ARRAY)},
{"time", new Integer(Oid.TIME), new Integer(Types.TIME), "java.sql.Time", new Integer(Oid.TIME_ARRAY)},
{"timetz", new Integer(Oid.TIMETZ), new Integer(Types.TIME), "java.sql.Time", new Integer(Oid.TIMETZ_ARRAY)},
{"timestamp", new Integer(Oid.TIMESTAMP), new Integer(Types.TIMESTAMP), "java.sql.Timestamp", new Integer(Oid.TIMESTAMP_ARRAY)},
{"timestamptz", new Integer(Oid.TIMESTAMPTZ), new Integer(Types.TIMESTAMP), "java.sql.Timestamp", new Integer(Oid.TIMESTAMPTZ_ARRAY)},
};
/**
* PG maps several alias to real type names. When we do queries
* against pg_catalog, we must use the real type, not an alias, so
* use this mapping.
*/
private final static HashMap typeAliases;
static {
typeAliases = new HashMap();
typeAliases.put("smallint", "int2");
typeAliases.put("integer", "int4");
typeAliases.put("int", "int4");
typeAliases.put("bigint", "int8");
typeAliases.put("float", "float8");
typeAliases.put("boolean", "bool");
typeAliases.put("decimal", "numeric");
}
public TypeInfoCache(BaseConnection conn, int unknownLength)
{
_conn = conn;
_unknownLength = unknownLength;
_oidToPgName = new HashMap();
_pgNameToOid = new HashMap();
_pgNameToJavaClass = new HashMap();
_pgNameToPgObject = new HashMap();
_pgArrayToPgType = new HashMap();
_arrayOidToDelimiter = new HashMap();
// needs to be synchronized because the iterator is returned
// from getPGTypeNamesWithSQLTypes()
_pgNameToSQLType = Collections.synchronizedMap(new HashMap());
for (int i=0; i> 16;
case Oid.CHAR:
case Oid.BOOL:
return 1;
case Oid.BPCHAR:
case Oid.VARCHAR:
if (typmod == -1)
return _unknownLength;
return typmod - 4;
// datetime types get the
// "length in characters of the String representation"
case Oid.DATE:
case Oid.TIME:
case Oid.TIMETZ:
case Oid.INTERVAL:
case Oid.TIMESTAMP:
case Oid.TIMESTAMPTZ:
return getDisplaySize(oid, typmod);
case Oid.BIT:
return typmod;
case Oid.VARBIT:
if (typmod == -1)
return _unknownLength;
return typmod;
case Oid.TEXT:
case Oid.BYTEA:
default:
return _unknownLength;
}
}
public int getScale(int oid, int typmod) {
oid = convertArrayToBaseOid(oid);
switch(oid) {
case Oid.FLOAT4:
return 8;
case Oid.FLOAT8:
return 17;
case Oid.NUMERIC:
if (typmod == -1)
return 0;
return (typmod-4) & 0xFFFF;
case Oid.TIME:
case Oid.TIMETZ:
case Oid.TIMESTAMP:
case Oid.TIMESTAMPTZ:
if (typmod == -1)
return 6;
return typmod;
case Oid.INTERVAL:
if (typmod == -1)
return 6;
return typmod & 0xFFFF;
default:
return 0;
}
}
public boolean isCaseSensitive(int oid) {
oid = convertArrayToBaseOid(oid);
switch(oid) {
case Oid.OID:
case Oid.INT2:
case Oid.INT4:
case Oid.INT8:
case Oid.FLOAT4:
case Oid.FLOAT8:
case Oid.NUMERIC:
case Oid.BOOL:
case Oid.BIT:
case Oid.VARBIT:
case Oid.DATE:
case Oid.TIME:
case Oid.TIMETZ:
case Oid.TIMESTAMP:
case Oid.TIMESTAMPTZ:
case Oid.INTERVAL:
return false;
default:
return true;
}
}
public boolean isSigned(int oid) {
oid = convertArrayToBaseOid(oid);
switch(oid) {
case Oid.INT2:
case Oid.INT4:
case Oid.INT8:
case Oid.FLOAT4:
case Oid.FLOAT8:
case Oid.NUMERIC:
return true;
default:
return false;
}
}
public int getDisplaySize(int oid, int typmod) {
oid = convertArrayToBaseOid(oid);
switch(oid) {
case Oid.INT2:
return 6; // -32768 to +32767
case Oid.INT4:
return 11; // -2147483648 to +2147483647
case Oid.OID:
return 10; // 0 to 4294967295
case Oid.INT8:
return 20; // -9223372036854775808 to +9223372036854775807
case Oid.FLOAT4:
// varies based upon the extra_float_digits GUC.
// These values are for the longest possible length.
return 15; // sign + 9 digits + decimal point + e + sign + 2 digits
case Oid.FLOAT8:
return 25; // sign + 18 digits + decimal point + e + sign + 3 digits
case Oid.CHAR:
return 1;
case Oid.BOOL:
return 1;
case Oid.DATE:
return 13; // "4713-01-01 BC" to "01/01/4713 BC" - "31/12/32767"
case Oid.TIME:
case Oid.TIMETZ:
case Oid.TIMESTAMP:
case Oid.TIMESTAMPTZ:
// Calculate the number of decimal digits + the decimal point.
int secondSize;
switch(typmod) {
case -1:
secondSize = 6 + 1;
break;
case 0:
secondSize = 0;
break;
case 1:
// Bizarrely SELECT '0:0:0.1'::time(1); returns 2 digits.
secondSize = 2 + 1;
break;
default:
secondSize = typmod + 1;
break;
}
// We assume the worst case scenario for all of these.
// time = '00:00:00' = 8
// date = '5874897-12-31' = 13 (although at large values second precision is lost)
// date = '294276-11-20' = 12 --enable-integer-datetimes
// zone = '+11:30' = 6;
switch(oid) {
case Oid.TIME:
return 8 + secondSize;
case Oid.TIMETZ:
return 8 + secondSize + 6;
case Oid.TIMESTAMP:
return 13 + 1 + 8 + secondSize;
case Oid.TIMESTAMPTZ:
return 13 + 1 + 8 + secondSize + 6;
}
case Oid.INTERVAL:
return 49; // SELECT LENGTH('-123456789 years 11 months 33 days 23 hours 10.123456 seconds'::interval);
case Oid.VARCHAR:
case Oid.BPCHAR:
if (typmod == -1)
return _unknownLength;
return typmod - 4;
case Oid.NUMERIC:
if (typmod == -1)
return 131089; // SELECT LENGTH(pow(10::numeric,131071)); 131071 = 2^17-1
int precision = (typmod-4 >> 16) & 0xffff;
int scale = (typmod-4) & 0xffff;
// sign + digits + decimal point (only if we have nonzero scale)
return 1 + precision + (scale != 0 ? 1 : 0);
case Oid.BIT:
return typmod;
case Oid.VARBIT:
if (typmod == -1)
return _unknownLength;
return typmod;
case Oid.TEXT:
case Oid.BYTEA:
return _unknownLength;
default:
return _unknownLength;
}
}
public int getMaximumPrecision(int oid) {
oid = convertArrayToBaseOid(oid);
switch(oid) {
case Oid.NUMERIC:
return 1000;
case Oid.TIME:
case Oid.TIMETZ:
// Technically this depends on the --enable-integer-datetimes
// configure setting. It is 6 with integer and 10 with float.
return 6;
case Oid.TIMESTAMP:
case Oid.TIMESTAMPTZ:
case Oid.INTERVAL:
return 6;
case Oid.BPCHAR:
case Oid.VARCHAR:
return 10485760;
case Oid.BIT:
case Oid.VARBIT:
return 83886080;
default:
return 0;
}
}
public boolean requiresQuoting(int oid) throws SQLException
{
int sqlType = getSQLType(oid);
switch(sqlType) {
case Types.BIGINT:
case Types.DOUBLE:
case Types.FLOAT:
case Types.INTEGER:
case Types.REAL:
case Types.SMALLINT:
case Types.TINYINT:
case Types.NUMERIC:
case Types.DECIMAL:
return false;
}
return true;
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc2/optional/ 0000775 0000000 0000000 00000000000 12050675701 0023443 5 ustar 00root root 0000000 0000000 postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc2/optional/ConnectionPool.java 0000664 0000000 0000000 00000000601 12050675701 0027234 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc2.optional;
import org.postgresql.ds.PGConnectionPoolDataSource;
public class ConnectionPool extends PGConnectionPoolDataSource
{
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc2/optional/PoolingDataSource.java 0000664 0000000 0000000 00000000565 12050675701 0027676 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc2.optional;
import org.postgresql.ds.PGPoolingDataSource;
public class PoolingDataSource extends PGPoolingDataSource
{
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc2/optional/SimpleDataSource.java 0000664 0000000 0000000 00000000562 12050675701 0027515 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc2.optional;
import org.postgresql.ds.PGSimpleDataSource;
public class SimpleDataSource extends PGSimpleDataSource
{
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc3/ 0000775 0000000 0000000 00000000000 12050675701 0021617 5 ustar 00root root 0000000 0000000 postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc3/AbstractJdbc3Blob.java 0000664 0000000 0000000 00000005007 12050675701 0025674 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc3;
import java.sql.SQLException;
public abstract class AbstractJdbc3Blob extends org.postgresql.jdbc2.AbstractJdbc2Blob
{
public AbstractJdbc3Blob(org.postgresql.core.BaseConnection conn, long oid) throws SQLException
{
super(conn, oid);
}
/**
* Writes the given array of bytes to the BLOB value that
* this Blob object represents, starting at position
* pos, and returns the number of bytes written.
*
* @param pos the position in the BLOB object at which
* to start writing
* @param bytes the array of bytes to be written to the BLOB
* value that this Blob object represents
* @return the number of bytes written
* @exception SQLException if there is an error accessing the
* BLOB value
* @see #getBytes
* @since 1.4
*/
public synchronized int setBytes(long pos, byte[] bytes) throws SQLException
{
return setBytes(pos, bytes, 0, bytes.length);
}
/**
* Writes all or part of the given byte array to the
* BLOB value that this Blob object represents
* and returns the number of bytes written.
* Writing starts at position pos in the BLOB
* value; len bytes from the given byte array are written.
*
* @param pos the position in the BLOB object at which
* to start writing
* @param bytes the array of bytes to be written to this BLOB
* object
* @param offset the offset into the array bytes at which
* to start reading the bytes to be set
* @param len the number of bytes to be written to the BLOB
* value from the array of bytes bytes
* @return the number of bytes written
* @exception SQLException if there is an error accessing the
* BLOB value
* @see #getBytes
* @since 1.4
*/
public synchronized int setBytes(long pos, byte[] bytes, int offset, int len) throws SQLException
{
assertPosition(pos);
lo.seek((int) (pos-1));
lo.write(bytes, offset, len);
return len;
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc3/AbstractJdbc3Clob.java 0000664 0000000 0000000 00000007520 12050675701 0025677 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc3;
import java.sql.*;
public abstract class AbstractJdbc3Clob extends org.postgresql.jdbc2.AbstractJdbc2Clob
{
public AbstractJdbc3Clob(org.postgresql.core.BaseConnection conn, long oid) throws SQLException
{
super(conn, oid);
}
/**
* Writes the given Java String to the CLOB
* value that this Clob object designates at the position
* pos.
*
* @param pos the position at which to start writing to the CLOB
* value that this Clob object represents
* @param str the string to be written to the CLOB
* value that this Clob designates
* @return the number of characters written
* @exception SQLException if there is an error accessing the
* CLOB value
*
* @since 1.4
*/
public synchronized int setString(long pos, String str) throws SQLException
{
checkFreed();
throw org.postgresql.Driver.notImplemented(this.getClass(), "setString(long,str)");
}
/**
* Writes len characters of str, starting
* at character offset, to the CLOB value
* that this Clob represents.
*
* @param pos the position at which to start writing to this
* CLOB object
* @param str the string to be written to the CLOB
* value that this Clob object represents
* @param offset the offset into str to start reading
* the characters to be written
* @param len the number of characters to be written
* @return the number of characters written
* @exception SQLException if there is an error accessing the
* CLOB value
*
* @since 1.4
*/
public synchronized int setString(long pos, String str, int offset, int len) throws SQLException
{
checkFreed();
throw org.postgresql.Driver.notImplemented(this.getClass(), "setString(long,String,int,int)");
}
/**
* Retrieves a stream to be used to write Ascii characters to the
* CLOB value that this Clob object represents,
* starting at position pos.
*
* @param pos the position at which to start writing to this
* CLOB object
* @return the stream to which ASCII encoded characters can be written
* @exception SQLException if there is an error accessing the
* CLOB value
* @see #getAsciiStream
*
* @since 1.4
*/
public synchronized java.io.OutputStream setAsciiStream(long pos) throws SQLException
{
checkFreed();
throw org.postgresql.Driver.notImplemented(this.getClass(), "setAsciiStream(long)");
}
/**
* Retrieves a stream to be used to write a stream of Unicode characters
* to the CLOB value that this Clob object
* represents, at position pos.
*
* @param pos the position at which to start writing to the
* CLOB value
*
* @return a stream to which Unicode encoded characters can be written
* @exception SQLException if there is an error accessing the
* CLOB value
* @see #getCharacterStream
*
* @since 1.4
*/
public synchronized java.io.Writer setCharacterStream(long pos) throws SQLException
{
checkFreed();
throw org.postgresql.Driver.notImplemented(this.getClass(), "setCharacteStream(long)");
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc3/AbstractJdbc3Connection.java 0000664 0000000 0000000 00000050630 12050675701 0027117 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc3;
import java.util.Properties;
import java.sql.*;
import org.postgresql.util.HostSpec;
import org.postgresql.util.PSQLException;
import org.postgresql.util.PSQLState;
import org.postgresql.util.GT;
/**
* This class defines methods of the jdbc3 specification. This class extends
* org.postgresql.jdbc2.AbstractJdbc2Connection which provides the jdbc2
* methods. The real Connection class (for jdbc3) is org.postgresql.jdbc3.Jdbc3Connection
*/
public abstract class AbstractJdbc3Connection extends org.postgresql.jdbc2.AbstractJdbc2Connection
{
private int rsHoldability = ResultSet.CLOSE_CURSORS_AT_COMMIT;
private int savepointId = 0;
protected AbstractJdbc3Connection(HostSpec[] hostSpec, String user, String database, Properties info, String url) throws SQLException {
super(hostSpec, user, database, info, url);
}
/**
* Changes the holdability of ResultSet objects
* created using this Connection object to the given
* holdability.
*
* @param holdability a ResultSet holdability constant; one of
* ResultSet.HOLD_CURSORS_OVER_COMMIT or
* ResultSet.CLOSE_CURSORS_AT_COMMIT
* @throws SQLException if a database access occurs, the given parameter
* is not a ResultSet constant indicating holdability,
* or the given holdability is not supported
* @see #getHoldability
* @see ResultSet
* @since 1.4
*/
public void setHoldability(int holdability) throws SQLException
{
checkClosed();
switch (holdability)
{
case ResultSet.CLOSE_CURSORS_AT_COMMIT:
rsHoldability = holdability;
break;
case ResultSet.HOLD_CURSORS_OVER_COMMIT:
rsHoldability = holdability;
break;
default:
throw new PSQLException(GT.tr("Unknown ResultSet holdability setting: {0}.", new Integer(holdability)),
PSQLState.INVALID_PARAMETER_VALUE);
}
}
/**
* Retrieves the current holdability of ResultSet objects
* created using this Connection object.
*
* @return the holdability, one of
* ResultSet.HOLD_CURSORS_OVER_COMMIT or
* ResultSet.CLOSE_CURSORS_AT_COMMIT
* @throws SQLException if a database access occurs
* @see #setHoldability
* @see ResultSet
* @since 1.4
*/
public int getHoldability() throws SQLException
{
checkClosed();
return rsHoldability;
}
/**
* Creates an unnamed savepoint in the current transaction and
* returns the new Savepoint object that represents it.
*
* @return the new Savepoint object
* @exception SQLException if a database access error occurs
* or this Connection object is currently in
* auto-commit mode
* @see Savepoint
* @since 1.4
*/
public Savepoint setSavepoint() throws SQLException
{
checkClosed();
if (!haveMinimumServerVersion("8.0"))
throw new PSQLException(GT.tr("Server versions prior to 8.0 do not support savepoints."), PSQLState.NOT_IMPLEMENTED);
if (getAutoCommit())
throw new PSQLException(GT.tr("Cannot establish a savepoint in auto-commit mode."),
PSQLState.NO_ACTIVE_SQL_TRANSACTION);
PSQLSavepoint savepoint = new PSQLSavepoint(savepointId++);
// Note we can't use execSQLUpdate because we don't want
// to suppress BEGIN.
Statement stmt = createStatement();
stmt.executeUpdate("SAVEPOINT " + savepoint.getPGName());
stmt.close();
return savepoint;
}
/**
* Creates a savepoint with the given name in the current transaction
* and returns the new Savepoint object that represents it.
*
* @param name a String containing the name of the savepoint
* @return the new Savepoint object
* @exception SQLException if a database access error occurs
* or this Connection object is currently in
* auto-commit mode
* @see Savepoint
* @since 1.4
*/
public Savepoint setSavepoint(String name) throws SQLException
{
checkClosed();
if (!haveMinimumServerVersion("8.0"))
throw new PSQLException(GT.tr("Server versions prior to 8.0 do not support savepoints."), PSQLState.NOT_IMPLEMENTED);
if (getAutoCommit())
throw new PSQLException(GT.tr("Cannot establish a savepoint in auto-commit mode."),
PSQLState.NO_ACTIVE_SQL_TRANSACTION);
PSQLSavepoint savepoint = new PSQLSavepoint(name);
// Note we can't use execSQLUpdate because we don't want
// to suppress BEGIN.
Statement stmt = createStatement();
stmt.executeUpdate("SAVEPOINT " + savepoint.getPGName());
stmt.close();
return savepoint;
}
/**
* Undoes all changes made after the given Savepoint object
* was set.
*
* This method should be used only when auto-commit has been disabled.
*
* @param savepoint the Savepoint object to roll back to
* @exception SQLException if a database access error occurs,
* the Savepoint object is no longer valid,
* or this Connection object is currently in
* auto-commit mode
* @see Savepoint
* @see #rollback
* @since 1.4
*/
public void rollback(Savepoint savepoint) throws SQLException
{
checkClosed();
if (!haveMinimumServerVersion("8.0"))
throw new PSQLException(GT.tr("Server versions prior to 8.0 do not support savepoints."), PSQLState.NOT_IMPLEMENTED);
PSQLSavepoint pgSavepoint = (PSQLSavepoint)savepoint;
execSQLUpdate("ROLLBACK TO SAVEPOINT " + pgSavepoint.getPGName());
}
/**
* Removes the given Savepoint object from the current
* transaction. Any reference to the savepoint after it have been removed
* will cause an SQLException to be thrown.
*
* @param savepoint the Savepoint object to be removed
* @exception SQLException if a database access error occurs or
* the given Savepoint object is not a valid
* savepoint in the current transaction
* @since 1.4
*/
public void releaseSavepoint(Savepoint savepoint) throws SQLException
{
checkClosed();
if (!haveMinimumServerVersion("8.0"))
throw new PSQLException(GT.tr("Server versions prior to 8.0 do not support savepoints."), PSQLState.NOT_IMPLEMENTED);
PSQLSavepoint pgSavepoint = (PSQLSavepoint)savepoint;
execSQLUpdate("RELEASE SAVEPOINT " + pgSavepoint.getPGName());
pgSavepoint.invalidate();
}
/**
* Creates a Statement object that will generate
* ResultSet objects with the given type, concurrency,
* and holdability.
* This method is the same as the createStatement method
* above, but it allows the default result set
* type, concurrency, and holdability to be overridden.
*
* @param resultSetType one of the following ResultSet
* constants:
* ResultSet.TYPE_FORWARD_ONLY,
* ResultSet.TYPE_SCROLL_INSENSITIVE, or
* ResultSet.TYPE_SCROLL_SENSITIVE
* @param resultSetConcurrency one of the following ResultSet
* constants:
* ResultSet.CONCUR_READ_ONLY or
* ResultSet.CONCUR_UPDATABLE
* @param resultSetHoldability one of the following ResultSet
* constants:
* ResultSet.HOLD_CURSORS_OVER_COMMIT or
* ResultSet.CLOSE_CURSORS_AT_COMMIT
* @return a new Statement object that will generate
* ResultSet objects with the given type,
* concurrency, and holdability
* @exception SQLException if a database access error occurs
* or the given parameters are not ResultSet
* constants indicating type, concurrency, and holdability
* @see ResultSet
* @since 1.4
*/
public abstract Statement createStatement(int resultSetType, int resultSetConcurrency,
int resultSetHoldability) throws SQLException;
public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException {
checkClosed();
return createStatement(resultSetType, resultSetConcurrency, getHoldability());
}
/**
* Creates a PreparedStatement object that will generate
* ResultSet objects with the given type, concurrency,
* and holdability.
*
* This method is the same as the prepareStatement method
* above, but it allows the default result set
* type, concurrency, and holdability to be overridden.
*
* @param sql a String object that is the SQL statement to
* be sent to the database; may contain one or more ? IN
* parameters
* @param resultSetType one of the following ResultSet
* constants:
* ResultSet.TYPE_FORWARD_ONLY,
* ResultSet.TYPE_SCROLL_INSENSITIVE, or
* ResultSet.TYPE_SCROLL_SENSITIVE
* @param resultSetConcurrency one of the following ResultSet
* constants:
* ResultSet.CONCUR_READ_ONLY or
* ResultSet.CONCUR_UPDATABLE
* @param resultSetHoldability one of the following ResultSet
* constants:
* ResultSet.HOLD_CURSORS_OVER_COMMIT or
* ResultSet.CLOSE_CURSORS_AT_COMMIT
* @return a new PreparedStatement object, containing the
* pre-compiled SQL statement, that will generate
* ResultSet objects with the given type,
* concurrency, and holdability
* @exception SQLException if a database access error occurs
* or the given parameters are not ResultSet
* constants indicating type, concurrency, and holdability
* @see ResultSet
* @since 1.4
*/
public abstract PreparedStatement prepareStatement(String sql, int resultSetType,
int resultSetConcurrency, int resultSetHoldability)
throws SQLException;
public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
checkClosed();
return prepareStatement(sql, resultSetType, resultSetConcurrency, getHoldability());
}
/**
* Creates a CallableStatement object that will generate
* ResultSet objects with the given type and concurrency.
* This method is the same as the prepareCall method
* above, but it allows the default result set
* type, result set concurrency type and holdability to be overridden.
*
* @param sql a String object that is the SQL statement to
* be sent to the database; may contain on or more ? parameters
* @param resultSetType one of the following ResultSet
* constants:
* ResultSet.TYPE_FORWARD_ONLY,
* ResultSet.TYPE_SCROLL_INSENSITIVE, or
* ResultSet.TYPE_SCROLL_SENSITIVE
* @param resultSetConcurrency one of the following ResultSet
* constants:
* ResultSet.CONCUR_READ_ONLY or
* ResultSet.CONCUR_UPDATABLE
* @param resultSetHoldability one of the following ResultSet
* constants:
* ResultSet.HOLD_CURSORS_OVER_COMMIT or
* ResultSet.CLOSE_CURSORS_AT_COMMIT
* @return a new CallableStatement object, containing the
* pre-compiled SQL statement, that will generate
* ResultSet objects with the given type,
* concurrency, and holdability
* @exception SQLException if a database access error occurs
* or the given parameters are not ResultSet
* constants indicating type, concurrency, and holdability
* @see ResultSet
* @since 1.4
*/
public abstract CallableStatement prepareCall(String sql, int resultSetType,
int resultSetConcurrency,
int resultSetHoldability) throws SQLException;
public CallableStatement prepareCall(String sql, int resultSetType,
int resultSetConcurrency) throws SQLException {
checkClosed();
return prepareCall(sql, resultSetType, resultSetConcurrency, getHoldability());
}
/**
* Creates a default PreparedStatement object that has
* the capability to retrieve auto-generated keys. The given constant
* tells the driver whether it should make auto-generated keys
* available for retrieval. This parameter is ignored if the SQL
* statement is not an INSERT statement.
*
* Note: This method is optimized for handling
* parametric SQL statements that benefit from precompilation. If
* the driver supports precompilation,
* the method prepareStatement will send
* the statement to the database for precompilation. Some drivers
* may not support precompilation. In this case, the statement may
* not be sent to the database until the PreparedStatement
* object is executed. This has no direct effect on users; however, it does
* affect which methods throw certain SQLExceptions.
*
* Result sets created using the returned PreparedStatement
* object will by default be type TYPE_FORWARD_ONLY
* and have a concurrency level of CONCUR_READ_ONLY.
*
* @param sql an SQL statement that may contain one or more '?' IN
* parameter placeholders
* @param autoGeneratedKeys a flag indicating whether auto-generated keys
* should be returned; one of the following Statement
* constants:
* Statement.RETURN_GENERATED_KEYS or
* Statement.NO_GENERATED_KEYS.
* @return a new PreparedStatement object, containing the
* pre-compiled SQL statement, that will have the capability of
* returning auto-generated keys
* @exception SQLException if a database access error occurs
* or the given parameter is not a Statement
* constant indicating whether auto-generated keys should be
* returned
* @since 1.4
*/
public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys)
throws SQLException
{
checkClosed();
if (autoGeneratedKeys != Statement.NO_GENERATED_KEYS)
sql = AbstractJdbc3Statement.addReturning(this, sql, new String[]{"*"}, false);
PreparedStatement ps = prepareStatement(sql);
if (autoGeneratedKeys != Statement.NO_GENERATED_KEYS)
((AbstractJdbc3Statement)ps).wantsGeneratedKeysAlways = true;
return ps;
}
/**
* Creates a default PreparedStatement object capable
* of returning the auto-generated keys designated by the given array.
* This array contains the indexes of the columns in the target
* table that contain the auto-generated keys that should be made
* available. This array is ignored if the SQL
* statement is not an INSERT statement.
*
* An SQL statement with or without IN parameters can be
* pre-compiled and stored in a PreparedStatement object. This
* object can then be used to efficiently execute this statement
* multiple times.
*
* Note: This method is optimized for handling
* parametric SQL statements that benefit from precompilation. If
* the driver supports precompilation,
* the method prepareStatement will send
* the statement to the database for precompilation. Some drivers
* may not support precompilation. In this case, the statement may
* not be sent to the database until the PreparedStatement
* object is executed. This has no direct effect on users; however, it does
* affect which methods throw certain SQLExceptions.
*
* Result sets created using the returned PreparedStatement
* object will by default be type TYPE_FORWARD_ONLY
* and have a concurrency level of CONCUR_READ_ONLY.
*
* @param sql an SQL statement that may contain one or more '?' IN
* parameter placeholders
* @param columnIndexes an array of column indexes indicating the columns
* that should be returned from the inserted row or rows
* @return a new PreparedStatement object, containing the
* pre-compiled statement, that is capable of returning the
* auto-generated keys designated by the given array of column
* indexes
* @exception SQLException if a database access error occurs
*
* @since 1.4
*/
public PreparedStatement prepareStatement(String sql, int columnIndexes[])
throws SQLException
{
if (columnIndexes == null || columnIndexes.length == 0)
return prepareStatement(sql);
checkClosed();
throw new PSQLException(GT.tr("Returning autogenerated keys is not supported."), PSQLState.NOT_IMPLEMENTED);
}
/**
* Creates a default PreparedStatement object capable
* of returning the auto-generated keys designated by the given array.
* This array contains the names of the columns in the target
* table that contain the auto-generated keys that should be returned.
* This array is ignored if the SQL
* statement is not an INSERT statement.
*
* An SQL statement with or without IN parameters can be
* pre-compiled and stored in a PreparedStatement object. This
* object can then be used to efficiently execute this statement
* multiple times.
*
* Note: This method is optimized for handling
* parametric SQL statements that benefit from precompilation. If
* the driver supports precompilation,
* the method prepareStatement will send
* the statement to the database for precompilation. Some drivers
* may not support precompilation. In this case, the statement may
* not be sent to the database until the PreparedStatement
* object is executed. This has no direct effect on users; however, it does
* affect which methods throw certain SQLExceptions.
*
* Result sets created using the returned PreparedStatement
* object will by default be type TYPE_FORWARD_ONLY
* and have a concurrency level of CONCUR_READ_ONLY.
*
* @param sql an SQL statement that may contain one or more '?' IN
* parameter placeholders
* @param columnNames an array of column names indicating the columns
* that should be returned from the inserted row or rows
* @return a new PreparedStatement object, containing the
* pre-compiled statement, that is capable of returning the
* auto-generated keys designated by the given array of column
* names
* @exception SQLException if a database access error occurs
*
* @since 1.4
*/
public PreparedStatement prepareStatement(String sql, String columnNames[])
throws SQLException
{
if (columnNames != null && columnNames.length != 0)
sql = AbstractJdbc3Statement.addReturning(this, sql, columnNames, true);
PreparedStatement ps = prepareStatement(sql);
if (columnNames != null && columnNames.length != 0)
((AbstractJdbc3Statement)ps).wantsGeneratedKeysAlways = true;
return ps;
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc3/AbstractJdbc3DatabaseMetaData.java 0000664 0000000 0000000 00000036067 12050675701 0030135 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc3;
import java.sql.*;
public abstract class AbstractJdbc3DatabaseMetaData extends org.postgresql.jdbc2.AbstractJdbc2DatabaseMetaData
{
public AbstractJdbc3DatabaseMetaData(AbstractJdbc3Connection conn)
{
super(conn);
}
/**
* Retrieves whether this database supports savepoints.
*
* @return true if savepoints are supported;
* false otherwise
* @exception SQLException if a database access error occurs
* @since 1.4
*/
public boolean supportsSavepoints() throws SQLException
{
return connection.haveMinimumServerVersion("8.0");
}
/**
* Retrieves whether this database supports named parameters to callable
* statements.
*
* @return true if named parameters are supported;
* false otherwise
* @exception SQLException if a database access error occurs
* @since 1.4
*/
public boolean supportsNamedParameters() throws SQLException
{
return false;
}
/**
* Retrieves whether it is possible to have multiple ResultSet objects
* returned from a CallableStatement object
* simultaneously.
*
* @return true if a CallableStatement object
* can return multiple ResultSet objects
* simultaneously; false otherwise
* @exception SQLException if a datanase access error occurs
* @since 1.4
*/
public boolean supportsMultipleOpenResults() throws SQLException
{
return false;
}
/**
* Retrieves whether auto-generated keys can be retrieved after
* a statement has been executed.
*
* @return true if auto-generated keys can be retrieved
* after a statement has executed; false otherwise
* @exception SQLException if a database access error occurs
* @since 1.4
*/
public boolean supportsGetGeneratedKeys() throws SQLException
{
// We don't support returning generated keys by column index,
// but that should be a rarer case than the ones we do support.
//
return connection.haveMinimumServerVersion("8.2");
}
/**
* Retrieves a description of the user-defined type (UDT) hierarchies defined in a
* particular schema in this database. Only the immediate super type/
* sub type relationship is modeled.
*
* Only supertype information for UDTs matching the catalog,
* schema, and type name is returned. The type name parameter
* may be a fully-qualified name. When the UDT name supplied is a
* fully-qualified name, the catalog and schemaPattern parameters are
* ignored.
*
* If a UDT does not have a direct super type, it is not listed here.
* A row of the ResultSet object returned by this method
* describes the designated UDT and a direct supertype. A row has the following
* columns:
*
*
TYPE_CAT String => the UDT's catalog (may be null)
*
TYPE_SCHEM String => UDT's schema (may be null)
*
TYPE_NAME String => type name of the UDT
*
SUPERTYPE_CAT String => the direct super type's catalog
* (may be null)
*
SUPERTYPE_SCHEM String => the direct super type's schema
* (may be null)
*
SUPERTYPE_NAME String => the direct super type's name
*
*
*
Note: If the driver does not support type hierarchies, an
* empty result set is returned.
*
* @param catalog a catalog name; "" retrieves those without a catalog;
* null means drop catalog name from the selection criteria
* @param schemaPattern a schema name pattern; "" retrieves those
* without a schema
* @param typeNamePattern a UDT name pattern; may be a fully-qualified
* name
* @return a ResultSet object in which a row gives information
* about the designated UDT
* @throws SQLException if a database access error occurs
* @since 1.4
*/
public ResultSet getSuperTypes(String catalog, String schemaPattern,
String typeNamePattern) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getSuperTypes(String,String,String)");
}
/**
* Retrieves a description of the table hierarchies defined in a particular
* schema in this database.
*
*
Only supertable information for tables matching the catalog, schema
* and table name are returned. The table name parameter may be a fully-
* qualified name, in which case, the catalog and schemaPattern parameters
* are ignored. If a table does not have a super table, it is not listed here.
* Supertables have to be defined in the same catalog and schema as the
* sub tables. Therefore, the type description does not need to include
* this information for the supertable.
*
*
Each type description has the following columns:
*
*
TABLE_CAT String => the type's catalog (may be null)
*
TABLE_SCHEM String => type's schema (may be null)
*
TABLE_NAME String => type name
*
SUPERTABLE_NAME String => the direct super type's name
*
*
*
Note: If the driver does not support type hierarchies, an
* empty result set is returned.
*
* @param catalog a catalog name; "" retrieves those without a catalog;
* null means drop catalog name from the selection criteria
* @param schemaPattern a schema name pattern; "" retrieves those
* without a schema
* @param tableNamePattern a table name pattern; may be a fully-qualified
* name
* @return a ResultSet object in which each row is a type description
* @throws SQLException if a database access error occurs
* @since 1.4
*/
public ResultSet getSuperTables(String catalog, String schemaPattern,
String tableNamePattern) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getSuperTables(String,String,String,String)");
}
/**
* Retrieves a description of the given attribute of the given type
* for a user-defined type (UDT) that is available in the given schema
* and catalog.
*
* Descriptions are returned only for attributes of UDTs matching the
* catalog, schema, type, and attribute name criteria. They are ordered by
* TYPE_SCHEM, TYPE_NAME and ORDINAL_POSITION. This description
* does not contain inherited attributes.
*
* The ResultSet object that is returned has the following
* columns:
*
*
TYPE_CAT String => type catalog (may be null)
*
TYPE_SCHEM String => type schema (may be null)
*
TYPE_NAME String => type name
*
ATTR_NAME String => attribute name
*
DATA_TYPE short => attribute type SQL type from java.sql.Types
*
ATTR_TYPE_NAME String => Data source dependent type name.
* For a UDT, the type name is fully qualified. For a REF, the type name is
* fully qualified and represents the target type of the reference type.
*
ATTR_SIZE int => column size. For char or date
* types this is the maximum number of characters; for numeric or
* decimal types this is precision.
*
DECIMAL_DIGITS int => the number of fractional digits
*
NUM_PREC_RADIX int => Radix (typically either 10 or 2)
*
REMARKS String => comment describing column (may be null)
*
ATTR_DEF String => default value (may be null)
*
SQL_DATA_TYPE int => unused
*
SQL_DATETIME_SUB int => unused
*
CHAR_OCTET_LENGTH int => for char types the
* maximum number of bytes in the column
*
ORDINAL_POSITION int => index of column in table
* (starting at 1)
*
IS_NULLABLE String => "NO" means column definitely
* does not allow NULL values; "YES" means the column might
* allow NULL values. An empty string means unknown.
*
SCOPE_CATALOG String => catalog of table that is the
* scope of a reference attribute (null if DATA_TYPE isn't REF)
*
SCOPE_SCHEMA String => schema of table that is the
* scope of a reference attribute (null if DATA_TYPE isn't REF)
*
SCOPE_TABLE String => table name that is the scope of a
* reference attribute (null if the DATA_TYPE isn't REF)
*
SOURCE_DATA_TYPE short => source type of a distinct type or user-generated
* Ref type,SQL type from java.sql.Types (null if DATA_TYPE
* isn't DISTINCT or user-generated REF)
*
* @param catalog a catalog name; must match the catalog name as it
* is stored in the database; "" retrieves those without a catalog;
* null means that the catalog name should not be used to narrow
* the search
* @param schemaPattern a schema name pattern; must match the schema name
* as it is stored in the database; "" retrieves those without a schema;
* null means that the schema name should not be used to narrow
* the search
* @param typeNamePattern a type name pattern; must match the
* type name as it is stored in the database
* @param attributeNamePattern an attribute name pattern; must match the attribute
* name as it is declared in the database
* @return a ResultSet object in which each row is an
* attribute description
* @exception SQLException if a database access error occurs
* @since 1.4
*/
public ResultSet getAttributes(String catalog, String schemaPattern,
String typeNamePattern, String attributeNamePattern)
throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getAttributes(String,String,String,String)");
}
/**
* Retrieves whether this database supports the given result set holdability.
*
* @param holdability one of the following constants:
* ResultSet.HOLD_CURSORS_OVER_COMMIT or
* ResultSet.CLOSE_CURSORS_AT_COMMIT
* @return true if so; false otherwise
* @exception SQLException if a database access error occurs
* @see Connection
* @since 1.4
*/
public boolean supportsResultSetHoldability(int holdability) throws SQLException
{
return true;
}
/**
* Retrieves the default holdability of this ResultSet
* object.
*
* @return the default holdability; either
* ResultSet.HOLD_CURSORS_OVER_COMMIT or
* ResultSet.CLOSE_CURSORS_AT_COMMIT
* @exception SQLException if a database access error occurs
* @since 1.4
*/
public int getResultSetHoldability() throws SQLException
{
return ResultSet.HOLD_CURSORS_OVER_COMMIT;
}
/**
* Retrieves the major version number of the underlying database.
*
* @return the underlying database's major version
* @exception SQLException if a database access error occurs
* @since 1.4
*/
public int getDatabaseMajorVersion() throws SQLException
{
return connection.getServerMajorVersion();
}
/**
* Retrieves the minor version number of the underlying database.
*
* @return underlying database's minor version
* @exception SQLException if a database access error occurs
* @since 1.4
*/
public int getDatabaseMinorVersion() throws SQLException
{
return connection.getServerMinorVersion();
}
/**
* Retrieves the major JDBC version number for this
* driver.
*
* @return JDBC version major number
* @exception SQLException if a database access error occurs
* @since 1.4
*/
public int getJDBCMajorVersion() throws SQLException
{
return 3; // This class implements JDBC 3.0
}
/**
* Retrieves the minor JDBC version number for this
* driver.
*
* @return JDBC version minor number
* @exception SQLException if a database access error occurs
* @since 1.4
*/
public int getJDBCMinorVersion() throws SQLException
{
return 0; // This class implements JDBC 3.0
}
/**
* Indicates whether the SQLSTATEs returned by SQLException.getSQLState
* is X/Open (now known as Open Group) SQL CLI or SQL99.
* @return the type of SQLSTATEs, one of:
* sqlStateXOpen or
* sqlStateSQL99
* @throws SQLException if a database access error occurs
* @since 1.4
*/
public int getSQLStateType() throws SQLException
{
return DatabaseMetaData.sqlStateSQL99;
}
/**
* Indicates whether updates made to a LOB are made on a copy or directly
* to the LOB.
* @return true if updates are made to a copy of the LOB;
* false if updates are made directly to the LOB
* @throws SQLException if a database access error occurs
* @since 1.4
*/
public boolean locatorsUpdateCopy() throws SQLException
{
/*
* Currently LOB's aren't updateable at all, so it doesn't
* matter what we return. We don't throw the notImplemented
* Exception because the 1.5 JDK's CachedRowSet calls this
* method regardless of wether large objects are used.
*/
return true;
}
/**
* Retrieves weather this database supports statement pooling.
*
* @return true is so;
false otherwise
* @throws SQLExcpetion if a database access error occurs
* @since 1.4
*/
public boolean supportsStatementPooling() throws SQLException
{
return false;
}
public ResultSet getColumns(String catalog, String schemaPattern, String tableNamePattern, String columnNamePattern) throws SQLException
{
return getColumns(3, catalog, schemaPattern, tableNamePattern, columnNamePattern);
}
public ResultSet getSchemas() throws SQLException
{
return getSchemas(3, null, null);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc3/AbstractJdbc3ParameterMetaData.java 0000664 0000000 0000000 00000005230 12050675701 0030335 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2005-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc3;
import java.sql.SQLException;
import java.sql.ParameterMetaData;
import org.postgresql.util.GT;
import org.postgresql.util.PSQLState;
import org.postgresql.util.PSQLException;
import org.postgresql.core.BaseConnection;
import org.postgresql.jdbc2.TypeInfoCache;
public abstract class AbstractJdbc3ParameterMetaData {
private final BaseConnection _connection;
private final int _oids[];
public AbstractJdbc3ParameterMetaData(BaseConnection connection, int oids[]) {
_connection = connection;
_oids = oids;
}
public String getParameterClassName(int param) throws SQLException {
checkParamIndex(param);
return _connection.getTypeInfo().getJavaClass(_oids[param-1]);
}
public int getParameterCount() {
return _oids.length;
}
// For now report all parameters as inputs. CallableStatements may
// have one output, but ignore that for now.
public int getParameterMode(int param) throws SQLException {
checkParamIndex(param);
return ParameterMetaData.parameterModeIn;
}
public int getParameterType(int param) throws SQLException {
checkParamIndex(param);
return _connection.getTypeInfo().getSQLType(_oids[param-1]);
}
public String getParameterTypeName(int param) throws SQLException {
checkParamIndex(param);
return _connection.getTypeInfo().getPGType(_oids[param-1]);
}
// we don't know this
public int getPrecision(int param) throws SQLException {
checkParamIndex(param);
return 0;
}
// we don't know this
public int getScale(int param) throws SQLException {
checkParamIndex(param);
return 0;
}
// we can't tell anything about nullability
public int isNullable(int param) throws SQLException {
checkParamIndex(param);
return ParameterMetaData.parameterNullableUnknown;
}
// pg doesn't have unsigned numbers
public boolean isSigned(int param) throws SQLException {
checkParamIndex(param);
return _connection.getTypeInfo().isSigned(_oids[param-1]);
}
private void checkParamIndex(int param) throws PSQLException {
if (param < 1 || param > _oids.length)
throw new PSQLException(GT.tr("The parameter index is out of range: {0}, number of parameters: {1}.", new Object[]{new Integer(param), new Integer(_oids.length)}), PSQLState.INVALID_PARAMETER_VALUE);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc3/AbstractJdbc3ResultSet.java 0000664 0000000 0000000 00000021305 12050675701 0026747 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc3;
import java.sql.*;
import java.util.List;
import org.postgresql.core.*;
/**
* This class defines methods of the jdbc3 specification. This class extends
* org.postgresql.jdbc2.AbstractJdbc2ResultSet which provides the jdbc2
* methods. The real Statement class (for jdbc3) is org.postgresql.jdbc3.Jdbc3ResultSet
*/
public abstract class AbstractJdbc3ResultSet extends org.postgresql.jdbc2.AbstractJdbc2ResultSet
{
public AbstractJdbc3ResultSet(Query originalQuery, BaseStatement statement, Field[] fields, List tuples,
ResultCursor cursor, int maxRows, int maxFieldSize, int rsType, int rsConcurrency, int rsHoldability) throws SQLException
{
super (originalQuery, statement, fields, tuples, cursor, maxRows, maxFieldSize, rsType, rsConcurrency);
}
// Overrides JDBC2 version to support Types.BOOLEAN.
protected Object internalGetObject(int columnIndex, Field field) throws SQLException
{
switch (getSQLType(columnIndex)) {
case Types.BOOLEAN:
return new Boolean(getBoolean(columnIndex));
default:
return super.internalGetObject(columnIndex, field);
}
}
/**
* Retrieves the value of the designated column in the current row
* of this ResultSet object as a java.net.URL
* object in the Java programming language.
*
* @param columnIndex the index of the column 1 is the first, 2 is the second,...
* @return the column value as a java.net.URL object;
* if the value is SQL NULL,
* the value returned is null in the Java programming language
* @exception SQLException if a database access error occurs,
* or if a URL is malformed
* @since 1.4
*/
public java.net.URL getURL(int columnIndex) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getURL(int)");
}
/**
* Retrieves the value of the designated column in the current row
* of this ResultSet object as a java.net.URL
* object in the Java programming language.
*
* @param columnName the SQL name of the column
* @return the column value as a java.net.URL object;
* if the value is SQL NULL,
* the value returned is null in the Java programming language
* @exception SQLException if a database access error occurs
* or if a URL is malformed
* @since 1.4
*/
public java.net.URL getURL(String columnName) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getURL(String)");
}
/**
* Updates the designated column with a java.sql.Ref value.
* The updater methods are used to update column values in the
* current row or the insert row. The updater methods do not
* update the underlying database; instead the updateRow or
* insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @exception SQLException if a database access error occurs
* @since 1.4
*/
public void updateRef(int columnIndex, java.sql.Ref x) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "updateRef(int,Ref)");
}
/**
* Updates the designated column with a java.sql.Ref value.
* The updater methods are used to update column values in the
* current row or the insert row. The updater methods do not
* update the underlying database; instead the updateRow or
* insertRow methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @exception SQLException if a database access error occurs
* @since 1.4
*/
public void updateRef(String columnName, java.sql.Ref x) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "updateRef(String,Ref)");
}
/**
* Updates the designated column with a java.sql.Blob value.
* The updater methods are used to update column values in the
* current row or the insert row. The updater methods do not
* update the underlying database; instead the updateRow or
* insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @exception SQLException if a database access error occurs
* @since 1.4
*/
public void updateBlob(int columnIndex, java.sql.Blob x) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "updateBlob(int,Blob)");
}
/**
* Updates the designated column with a java.sql.Blob value.
* The updater methods are used to update column values in the
* current row or the insert row. The updater methods do not
* update the underlying database; instead the updateRow or
* insertRow methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @exception SQLException if a database access error occurs
* @since 1.4
*/
public void updateBlob(String columnName, java.sql.Blob x) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "updateBlob(String,Blob)");
}
/**
* Updates the designated column with a java.sql.Clob value.
* The updater methods are used to update column values in the
* current row or the insert row. The updater methods do not
* update the underlying database; instead the updateRow or
* insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @exception SQLException if a database access error occurs
* @since 1.4
*/
public void updateClob(int columnIndex, java.sql.Clob x) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "updateClob(int,Clob)");
}
/**
* Updates the designated column with a java.sql.Clob value.
* The updater methods are used to update column values in the
* current row or the insert row. The updater methods do not
* update the underlying database; instead the updateRow or
* insertRow methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @exception SQLException if a database access error occurs
* @since 1.4
*/
public void updateClob(String columnName, java.sql.Clob x) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "updateClob(String,Clob)");
}
/**
* Updates the designated column with a java.sql.Array value.
* The updater methods are used to update column values in the
* current row or the insert row. The updater methods do not
* update the underlying database; instead the updateRow or
* insertRow methods are called to update the database.
*
* @param columnIndex the first column is 1, the second is 2, ...
* @param x the new column value
* @exception SQLException if a database access error occurs
* @since 1.4
*/
public void updateArray(int columnIndex, java.sql.Array x) throws SQLException
{
updateObject(columnIndex, x);
}
/**
* Updates the designated column with a java.sql.Array value.
* The updater methods are used to update column values in the
* current row or the insert row. The updater methods do not
* update the underlying database; instead the updateRow or
* insertRow methods are called to update the database.
*
* @param columnName the name of the column
* @param x the new column value
* @exception SQLException if a database access error occurs
* @since 1.4
*/
public void updateArray(String columnName, java.sql.Array x) throws SQLException
{
updateArray(findColumn(columnName), x);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc3/AbstractJdbc3Statement.java 0000664 0000000 0000000 00000174136 12050675701 0026774 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc3;
import java.math.BigDecimal;
import java.sql.*;
import java.util.ArrayList;
import java.util.Calendar;
import org.postgresql.util.PSQLException;
import org.postgresql.util.PSQLState;
import org.postgresql.core.Utils;
import org.postgresql.core.QueryExecutor;
import org.postgresql.core.Field;
import org.postgresql.core.BaseConnection;
import org.postgresql.util.GT;
/**
* This class defines methods of the jdbc3 specification. This class extends
* org.postgresql.jdbc2.AbstractJdbc2Statement which provides the jdbc2
* methods. The real Statement class (for jdbc2) is org.postgresql.jdbc3.Jdbc3Statement
*/
public abstract class AbstractJdbc3Statement extends org.postgresql.jdbc2.AbstractJdbc2Statement
{
private final int rsHoldability;
public AbstractJdbc3Statement (AbstractJdbc3Connection c, int rsType, int rsConcurrency, int rsHoldability) throws SQLException
{
super(c, rsType, rsConcurrency);
this.rsHoldability = rsHoldability;
}
public AbstractJdbc3Statement(AbstractJdbc3Connection connection, String sql, boolean isCallable, int rsType, int rsConcurrency, int rsHoldability) throws SQLException
{
super(connection, sql, isCallable, rsType, rsConcurrency);
this.rsHoldability = rsHoldability;
}
/**
* Moves to this Statement object's next result, deals with
* any current ResultSet object(s) according to the instructions
* specified by the given flag, and returns
* true if the next result is a ResultSet object.
*
*
There are no more results when the following is true:
*
*
* @param current one of the following Statement
* constants indicating what should happen to current
* ResultSet objects obtained using the method
* getResultSetCLOSE_CURRENT_RESULT,
* KEEP_CURRENT_RESULT, or
* CLOSE_ALL_RESULTS
* @return true if the next result is a ResultSet
* object; false if it is an update count or there are no
* more results
* @exception SQLException if a database access error occurs
* @since 1.4
* @see #execute
*/
public boolean getMoreResults(int current) throws SQLException
{
// CLOSE_CURRENT_RESULT
if (current == Statement.CLOSE_CURRENT_RESULT && result != null && result.getResultSet() != null)
result.getResultSet().close();
// Advance resultset.
if (result != null)
result = result.getNext();
// CLOSE_ALL_RESULTS
if (current == Statement.CLOSE_ALL_RESULTS)
{
// Close preceding resultsets.
while (firstUnclosedResult != result)
{
if (firstUnclosedResult.getResultSet() != null)
firstUnclosedResult.getResultSet().close();
firstUnclosedResult = firstUnclosedResult.getNext();
}
}
// Done.
return (result != null && result.getResultSet() != null);
}
/**
* Retrieves any auto-generated keys created as a result of executing this
* Statement object. If this Statement object did
* not generate any keys, an empty ResultSet
* object is returned.
*
* @return a ResultSet object containing the auto-generated key(s)
* generated by the execution of this Statement object
* @exception SQLException if a database access error occurs
* @since 1.4
*/
public ResultSet getGeneratedKeys() throws SQLException
{
checkClosed();
if (generatedKeys == null || generatedKeys.getResultSet() == null)
return createDriverResultSet(new Field[0], new ArrayList());
return generatedKeys.getResultSet();
}
/**
* Executes the given SQL statement and signals the driver with the
* given flag about whether the
* auto-generated keys produced by this Statement object
* should be made available for retrieval.
*
* @param sql must be an SQL INSERT, UPDATE or
* DELETE statement or an SQL statement that
* returns nothing
* @param autoGeneratedKeys a flag indicating whether auto-generated keys
* should be made available for retrieval;
* one of the following constants:
* Statement.RETURN_GENERATED_KEYS
* Statement.NO_GENERATED_KEYS
* @return either the row count for INSERT, UPDATE
* or DELETE statements, or 0 for SQL
* statements that return nothing
* @exception SQLException if a database access error occurs, the given
* SQL statement returns a ResultSet object, or
* the given constant is not one of those allowed
* @since 1.4
*/
public int executeUpdate(String sql, int autoGeneratedKeys) throws SQLException
{
if (autoGeneratedKeys == Statement.NO_GENERATED_KEYS)
return executeUpdate(sql);
sql = addReturning(connection, sql, new String[]{"*"}, false);
wantsGeneratedKeysOnce = true;
return executeUpdate(sql);
}
static String addReturning(BaseConnection connection, String sql, String columns[], boolean escape) throws SQLException
{
if (!connection.haveMinimumServerVersion("8.2"))
throw new PSQLException(GT.tr("Returning autogenerated keys is only supported for 8.2 and later servers."), PSQLState.NOT_IMPLEMENTED);
sql = sql.trim();
if (sql.endsWith(";"))
sql = sql.substring(0, sql.length()-1);
StringBuffer sb = new StringBuffer(sql);
sb.append(" RETURNING ");
for (int i=0; iINSERT statement.
*
* @param sql an SQL INSERT, UPDATE or
* DELETE statement or an SQL statement that returns nothing,
* such as an SQL DDL statement
* @param columnIndexes an array of column indexes indicating the columns
* that should be returned from the inserted row
* @return either the row count for INSERT, UPDATE,
* or DELETE statements, or 0 for SQL statements
* that return nothing
* @exception SQLException if a database access error occurs or the SQL
* statement returns a ResultSet object
* @since 1.4
*/
public int executeUpdate(String sql, int columnIndexes[]) throws SQLException
{
if (columnIndexes == null || columnIndexes.length == 0)
return executeUpdate(sql);
throw new PSQLException(GT.tr("Returning autogenerated keys by column index is not supported."), PSQLState.NOT_IMPLEMENTED);
}
/**
* Executes the given SQL statement and signals the driver that the
* auto-generated keys indicated in the given array should be made available
* for retrieval. The driver will ignore the array if the SQL statement
* is not an INSERT statement.
*
* @param sql an SQL INSERT, UPDATE or
* DELETE statement or an SQL statement that returns nothing
* @param columnNames an array of the names of the columns that should be
* returned from the inserted row
* @return either the row count for INSERT, UPDATE,
* or DELETE statements, or 0 for SQL statements
* that return nothing
* @exception SQLException if a database access error occurs
*
* @since 1.4
*/
public int executeUpdate(String sql, String columnNames[]) throws SQLException
{
if (columnNames == null || columnNames.length == 0)
return executeUpdate(sql);
sql = addReturning(connection, sql, columnNames, true);
wantsGeneratedKeysOnce = true;
return executeUpdate(sql);
}
/**
* Executes the given SQL statement, which may return multiple results,
* and signals the driver that any
* auto-generated keys should be made available
* for retrieval. The driver will ignore this signal if the SQL statement
* is not an INSERT statement.
*
* In some (uncommon) situations, a single SQL statement may return
* multiple result sets and/or update counts. Normally you can ignore
* this unless you are (1) executing a stored procedure that you know may
* return multiple results or (2) you are dynamically executing an
* unknown SQL string.
*
* The execute method executes an SQL statement and indicates the
* form of the first result. You must then use the methods
* getResultSet or getUpdateCount
* to retrieve the result, and getMoreResults to
* move to any subsequent result(s).
*
* @param sql any SQL statement
* @param autoGeneratedKeys a constant indicating whether auto-generated
* keys should be made available for retrieval using the method
* getGeneratedKeys; one of the following constants:
* Statement.RETURN_GENERATED_KEYS or
* Statement.NO_GENERATED_KEYS
* @return true if the first result is a ResultSet
* object; false if it is an update count or there are
* no results
* @exception SQLException if a database access error occurs
* @see #getResultSet
* @see #getUpdateCount
* @see #getMoreResults
* @see #getGeneratedKeys
*
* @since 1.4
*/
public boolean execute(String sql, int autoGeneratedKeys) throws SQLException
{
if (autoGeneratedKeys == Statement.NO_GENERATED_KEYS)
return execute(sql);
sql = addReturning(connection, sql, new String[]{"*"}, false);
wantsGeneratedKeysOnce = true;
return execute(sql);
}
/**
* Executes the given SQL statement, which may return multiple results,
* and signals the driver that the
* auto-generated keys indicated in the given array should be made available
* for retrieval. This array contains the indexes of the columns in the
* target table that contain the auto-generated keys that should be made
* available. The driver will ignore the array if the given SQL statement
* is not an INSERT statement.
*
* Under some (uncommon) situations, a single SQL statement may return
* multiple result sets and/or update counts. Normally you can ignore
* this unless you are (1) executing a stored procedure that you know may
* return multiple results or (2) you are dynamically executing an
* unknown SQL string.
*
* The execute method executes an SQL statement and indicates the
* form of the first result. You must then use the methods
* getResultSet or getUpdateCount
* to retrieve the result, and getMoreResults to
* move to any subsequent result(s).
*
* @param sql any SQL statement
* @param columnIndexes an array of the indexes of the columns in the
* inserted row that should be made available for retrieval by a
* call to the method getGeneratedKeys
* @return true if the first result is a ResultSet
* object; false if it is an update count or there
* are no results
* @exception SQLException if a database access error occurs
* @see #getResultSet
* @see #getUpdateCount
* @see #getMoreResults
*
* @since 1.4
*/
public boolean execute(String sql, int columnIndexes[]) throws SQLException
{
if (columnIndexes == null || columnIndexes.length == 0)
return execute(sql);
throw new PSQLException(GT.tr("Returning autogenerated keys by column index is not supported."), PSQLState.NOT_IMPLEMENTED);
}
/**
* Executes the given SQL statement, which may return multiple results,
* and signals the driver that the
* auto-generated keys indicated in the given array should be made available
* for retrieval. This array contains the names of the columns in the
* target table that contain the auto-generated keys that should be made
* available. The driver will ignore the array if the given SQL statement
* is not an INSERT statement.
*
* In some (uncommon) situations, a single SQL statement may return
* multiple result sets and/or update counts. Normally you can ignore
* this unless you are (1) executing a stored procedure that you know may
* return multiple results or (2) you are dynamically executing an
* unknown SQL string.
*
* The execute method executes an SQL statement and indicates the
* form of the first result. You must then use the methods
* getResultSet or getUpdateCount
* to retrieve the result, and getMoreResults to
* move to any subsequent result(s).
*
* @param sql any SQL statement
* @param columnNames an array of the names of the columns in the inserted
* row that should be made available for retrieval by a call to the
* method getGeneratedKeys
* @return true if the next result is a ResultSet
* object; false if it is an update count or there
* are no more results
* @exception SQLException if a database access error occurs
* @see #getResultSet
* @see #getUpdateCount
* @see #getMoreResults
* @see #getGeneratedKeys
*
* @since 1.4
*/
public boolean execute(String sql, String columnNames[]) throws SQLException
{
if (columnNames == null || columnNames.length == 0)
return execute(sql);
sql = addReturning(connection, sql, columnNames, true);
wantsGeneratedKeysOnce = true;
return execute(sql);
}
/**
* Retrieves the result set holdability for ResultSet objects
* generated by this Statement object.
*
* @return either ResultSet.HOLD_CURSORS_OVER_COMMIT or
* ResultSet.CLOSE_CURSORS_AT_COMMIT
* @exception SQLException if a database access error occurs
*
* @since 1.4
*/
public int getResultSetHoldability() throws SQLException
{
return rsHoldability;
}
/**
* Sets the designated parameter to the given java.net.URL value.
* The driver converts this to an SQL DATALINK value
* when it sends it to the database.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @param x the java.net.URL object to be set
* @exception SQLException if a database access error occurs
* @since 1.4
*/
public void setURL(int parameterIndex, java.net.URL x) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setURL(int,URL)");
}
/**
* Retrieves the number, types and properties of this
* PreparedStatement object's parameters.
*
* @return a ParameterMetaData object that contains information
* about the number, types and properties of this
* PreparedStatement object's parameters
* @exception SQLException if a database access error occurs
* @see ParameterMetaData
* @since 1.4
*/
public ParameterMetaData getParameterMetaData() throws SQLException
{
int flags = QueryExecutor.QUERY_ONESHOT | QueryExecutor.QUERY_DESCRIBE_ONLY | QueryExecutor.QUERY_SUPPRESS_BEGIN;
StatementResultHandler handler = new StatementResultHandler();
connection.getQueryExecutor().execute(preparedQuery, preparedParameters, handler, 0, 0, flags);
int oids[] = preparedParameters.getTypeOIDs();
if (oids != null)
return createParameterMetaData(connection, oids);
return null;
}
public abstract ParameterMetaData createParameterMetaData(BaseConnection conn, int oids[]) throws SQLException;
/**
* Registers the OUT parameter named
* parameterName to the JDBC type
* sqlType. All OUT parameters must be registered
* before a stored procedure is executed.
*
* The JDBC type specified by sqlType for an OUT
* parameter determines the Java type that must be used
* in the get method to read the value of that parameter.
*
* If the JDBC type expected to be returned to this output parameter
* is specific to this particular database, sqlType
* should be java.sql.Types.OTHER. The method
* {@link #getObject} retrieves the value.
* @param parameterName the name of the parameter
* @param sqlType the JDBC type code defined by java.sql.Types.
* If the parameter is of JDBC type NUMERIC
* or DECIMAL, the version of
* registerOutParameter that accepts a scale value
* should be used.
* @exception SQLException if a database access error occurs
* @since 1.4
* @see Types
*/
public void registerOutParameter(String parameterName, int sqlType)
throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "registerOutParameter(String,int)");
}
/**
* Registers the parameter named
* parameterName to be of JDBC type
* sqlType. This method must be called
* before a stored procedure is executed.
*
* The JDBC type specified by sqlType for an OUT
* parameter determines the Java type that must be used
* in the get method to read the value of that parameter.
*
* This version of registerOutParameter should be
* used when the parameter is of JDBC type NUMERIC
* or DECIMAL.
* @param parameterName the name of the parameter
* @param sqlType SQL type code defined by java.sql.Types.
* @param scale the desired number of digits to the right of the
* decimal point. It must be greater than or equal to zero.
* @exception SQLException if a database access error occurs
* @since 1.4
* @see Types
*/
public void registerOutParameter(String parameterName, int sqlType, int scale)
throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "registerOutParameter(String,int,int)");
}
/**
* Registers the designated output parameter. This version of
* the method registerOutParameter
* should be used for a user-named or REF output parameter. Examples
* of user-named types include: STRUCT, DISTINCT, JAVA_OBJECT, and
* named array types.
*
* Before executing a stored procedure call, you must explicitly
* call registerOutParameter to register the type from
* java.sql.Types for each
* OUT parameter. For a user-named parameter the fully-qualified SQL
* type name of the parameter should also be given, while a REF
* parameter requires that the fully-qualified type name of the
* referenced type be given. A JDBC driver that does not need the
* type code and type name information may ignore it. To be portable,
* however, applications should always provide these values for
* user-named and REF parameters.
*
* Although it is intended for user-named and REF parameters,
* this method may be used to register a parameter of any JDBC type.
* If the parameter does not have a user-named or REF type, the
* typeName parameter is ignored.
*
*
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.
*
* @param parameterName the name of the parameter
* @param sqlType a value from {@link java.sql.Types}
* @param typeName the fully-qualified name of an SQL structured type
* @exception SQLException if a database access error occurs
* @see Types
* @since 1.4
*/
public void registerOutParameter (String parameterName, int sqlType, String typeName)
throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "registerOutParameter(String,int,String)");
}
/**
* Retrieves the value of the designated JDBC DATALINK parameter as a
* java.net.URL object.
*
* @param parameterIndex the first parameter is 1, the second is 2,...
* @return a java.net.URL object that represents the
* JDBC DATALINK value used as the designated
* parameter
* @exception SQLException if a database access error occurs,
* or if the URL being returned is
* not a valid URL on the Java platform
* @see #setURL
* @since 1.4
*/
public java.net.URL getURL(int parameterIndex) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getURL(String)");
}
/**
* Sets the designated parameter to the given java.net.URL object.
* The driver converts this to an SQL DATALINK value when
* it sends it to the database.
*
* @param parameterName the name of the parameter
* @param val the parameter value
* @exception SQLException if a database access error occurs,
* or if a URL is malformed
* @see #getURL
* @since 1.4
*/
public void setURL(String parameterName, java.net.URL val) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setURL(String,URL)");
}
/**
* Sets the designated parameter to SQL NULL.
*
*
Note: You must specify the parameter's SQL type.
*
* @param parameterName the name of the parameter
* @param sqlType the SQL type code defined in java.sql.Types
* @exception SQLException if a database access error occurs
* @since 1.4
*/
public void setNull(String parameterName, int sqlType) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setNull(String,int)");
}
/**
* Sets the designated parameter to the given Java boolean value.
* The driver converts this
* to an SQL BIT value when it sends it to the database.
*
* @param parameterName the name of the parameter
* @param x the parameter value
* @exception SQLException if a database access error occurs
* @see #getBoolean
* @since 1.4
*/
public void setBoolean(String parameterName, boolean x) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setBoolean(String,boolean)");
}
/**
* Sets the designated parameter to the given Java byte value.
* The driver converts this
* to an SQL TINYINT value when it sends it to the database.
*
* @param parameterName the name of the parameter
* @param x the parameter value
* @exception SQLException if a database access error occurs
* @see #getByte
* @since 1.4
*/
public void setByte(String parameterName, byte x) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setByte(String,byte)");
}
/**
* Sets the designated parameter to the given Java short value.
* The driver converts this
* to an SQL SMALLINT value when it sends it to the database.
*
* @param parameterName the name of the parameter
* @param x the parameter value
* @exception SQLException if a database access error occurs
* @see #getShort
* @since 1.4
*/
public void setShort(String parameterName, short x) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setShort(String,short)");
}
/**
* Sets the designated parameter to the given Java int value.
* The driver converts this
* to an SQL INTEGER value when it sends it to the database.
*
* @param parameterName the name of the parameter
* @param x the parameter value
* @exception SQLException if a database access error occurs
* @see #getInt
* @since 1.4
*/
public void setInt(String parameterName, int x) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setInt(String,int)");
}
/**
* Sets the designated parameter to the given Java long value.
* The driver converts this
* to an SQL BIGINT value when it sends it to the database.
*
* @param parameterName the name of the parameter
* @param x the parameter value
* @exception SQLException if a database access error occurs
* @see #getLong
* @since 1.4
*/
public void setLong(String parameterName, long x) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setLong(String,long)");
}
/**
* Sets the designated parameter to the given Java float value.
* The driver converts this
* to an SQL FLOAT value when it sends it to the database.
*
* @param parameterName the name of the parameter
* @param x the parameter value
* @exception SQLException if a database access error occurs
* @see #getFloat
* @since 1.4
*/
public void setFloat(String parameterName, float x) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setFloat(String,float)");
}
/**
* Sets the designated parameter to the given Java double value.
* The driver converts this
* to an SQL DOUBLE value when it sends it to the database.
*
* @param parameterName the name of the parameter
* @param x the parameter value
* @exception SQLException if a database access error occurs
* @see #getDouble
* @since 1.4
*/
public void setDouble(String parameterName, double x) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setDouble(String,double)");
}
/**
* Sets the designated parameter to the given
* java.math.BigDecimal value.
* The driver converts this to an SQL NUMERIC value when
* it sends it to the database.
*
* @param parameterName the name of the parameter
* @param x the parameter value
* @exception SQLException if a database access error occurs
* @see #getBigDecimal
* @since 1.4
*/
public void setBigDecimal(String parameterName, BigDecimal x) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setBigDecimal(String,BigDecimal)");
}
/**
* Sets the designated parameter to the given Java String value.
* The driver converts this
* to an SQL VARCHAR or LONGVARCHAR value
* (depending on the argument's
* size relative to the driver's limits on VARCHAR values)
* when it sends it to the database.
*
* @param parameterName the name of the parameter
* @param x the parameter value
* @exception SQLException if a database access error occurs
* @see #getString
* @since 1.4
*/
public void setString(String parameterName, String x) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setString(String,String)");
}
/**
* Sets the designated parameter to the given Java array of bytes.
* The driver converts this to an SQL VARBINARY or
* LONGVARBINARY (depending on the argument's size relative
* to the driver's limits on VARBINARY values) when it sends
* it to the database.
*
* @param parameterName the name of the parameter
* @param x the parameter value
* @exception SQLException if a database access error occurs
* @see #getBytes
* @since 1.4
*/
public void setBytes(String parameterName, byte x[]) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setBytes(String,byte)");
}
/**
* Sets the designated parameter to the given java.sql.Date value.
* The driver converts this
* to an SQL DATE value when it sends it to the database.
*
* @param parameterName the name of the parameter
* @param x the parameter value
* @exception SQLException if a database access error occurs
* @see #getDate
* @since 1.4
*/
public void setDate(String parameterName, java.sql.Date x)
throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setDate(String,Date)");
}
/**
* Sets the designated parameter to the given java.sql.Time value.
* The driver converts this
* to an SQL TIME value when it sends it to the database.
*
* @param parameterName the name of the parameter
* @param x the parameter value
* @exception SQLException if a database access error occurs
* @see #getTime
* @since 1.4
*/
public void setTime(String parameterName, java.sql.Time x)
throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setTime(String,Time)");
}
/**
* Sets the designated parameter to the given java.sql.Timestamp value.
* The driver
* converts this to an SQL TIMESTAMP value when it sends it to the
* database.
*
* @param parameterName the name of the parameter
* @param x the parameter value
* @exception SQLException if a database access error occurs
* @see #getTimestamp
* @since 1.4
*/
public void setTimestamp(String parameterName, java.sql.Timestamp x)
throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setTimestamp(String,Timestamp)");
}
/**
* Sets the designated parameter to the given input stream, which will have
* the specified number of bytes.
* When a very large ASCII value is input to a LONGVARCHAR
* parameter, it may be more practical to send it via a
* java.io.InputStream. Data will be read from the stream
* as needed until end-of-file is reached. The JDBC driver will
* do any necessary conversion from ASCII to the database char format.
*
*
Note: This stream object can either be a standard
* Java stream object or your own subclass that implements the
* standard interface.
*
* @param parameterName the name of the parameter
* @param x the Java input stream that contains the ASCII parameter value
* @param length the number of bytes in the stream
* @exception SQLException if a database access error occurs
* @since 1.4
*/
public void setAsciiStream(String parameterName, java.io.InputStream x, int length)
throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setAsciiStream(String,InputStream,int)");
}
/**
* Sets the designated parameter to the given input stream, which will have
* the specified number of bytes.
* When a very large binary value is input to a LONGVARBINARY
* parameter, it may be more practical to send it via a
* java.io.InputStream object. The data will be read from the stream
* as needed until end-of-file is reached.
*
*
Note: This stream object can either be a standard
* Java stream object or your own subclass that implements the
* standard interface.
*
* @param parameterName the name of the parameter
* @param x the java input stream which contains the binary parameter value
* @param length the number of bytes in the stream
* @exception SQLException if a database access error occurs
* @since 1.4
*/
public void setBinaryStream(String parameterName, java.io.InputStream x,
int length) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setBinaryStream(String,InputStream,int)");
}
/**
* Sets the value of the designated parameter with the given object. The second
* argument must be an object type; for integral values, the
* java.lang equivalent objects should be used.
*
*
The given Java object will be converted to the given targetSqlType
* before being sent to the database.
*
* If the object has a custom mapping (is of a class implementing the
* interface SQLData),
* the JDBC driver should call the method SQLData.writeSQL to write it
* to the SQL data stream.
* If, on the other hand, the object is of a class implementing
* Ref, Blob, Clob, Struct,
* or Array, the driver should pass it to the database as a
* value of the corresponding SQL type.
*
* Note that this method may be used to pass datatabase-
* specific abstract data types.
*
* @param parameterName the name of the parameter
* @param x the object containing the input parameter value
* @param targetSqlType the SQL type (as defined in java.sql.Types) to be
* sent to the database. The scale argument may further qualify this type.
* @param scale for java.sql.Types.DECIMAL or java.sql.Types.NUMERIC types,
* this is the number of digits after the decimal point. For all other
* types, this value will be ignored.
* @exception SQLException if a database access error occurs
* @see Types
* @see #getObject
* @since 1.4
*/
public void setObject(String parameterName, Object x, int targetSqlType, int scale)
throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setObject(String,Object,int,int)");
}
/**
* Sets the value of the designated parameter with the given object.
* This method is like the method setObject
* above, except that it assumes a scale of zero.
*
* @param parameterName the name of the parameter
* @param x the object containing the input parameter value
* @param targetSqlType the SQL type (as defined in java.sql.Types) to be
* sent to the database
* @exception SQLException if a database access error occurs
* @see #getObject
* @since 1.4
*/
public void setObject(String parameterName, Object x, int targetSqlType)
throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setObject(String,Object,int)");
}
/**
* Sets the value of the designated parameter with the given object.
* The second parameter must be of type Object; therefore, the
* java.lang equivalent objects should be used for built-in types.
*
*
The JDBC specification specifies a standard mapping from
* Java Object types to SQL types. The given argument
* will be converted to the corresponding SQL type before being
* sent to the database.
*
*
Note that this method may be used to pass datatabase-
* specific abstract data types, by using a driver-specific Java
* type.
*
* If the object is of a class implementing the interface SQLData,
* the JDBC driver should call the method SQLData.writeSQL
* to write it to the SQL data stream.
* If, on the other hand, the object is of a class implementing
* Ref, Blob, Clob, Struct,
* or Array, the driver should pass it to the database as a
* value of the corresponding SQL type.
*
* This method throws an exception if there is an ambiguity, for example, if the
* object is of a class implementing more than one of the interfaces named above.
*
* @param parameterName the name of the parameter
* @param x the object containing the input parameter value
* @exception SQLException if a database access error occurs or if the given
* Object parameter is ambiguous
* @see #getObject
* @since 1.4
*/
public void setObject(String parameterName, Object x) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setObject(String,Object)");
}
/**
* Sets the designated parameter to the given Reader
* object, which is the given number of characters long.
* When a very large UNICODE value is input to a LONGVARCHAR
* parameter, it may be more practical to send it via a
* java.io.Reader object. The data will be read from the stream
* as needed until end-of-file is reached. The JDBC driver will
* do any necessary conversion from UNICODE to the database char format.
*
*
Note: This stream object can either be a standard
* Java stream object or your own subclass that implements the
* standard interface.
*
* @param parameterName the name of the parameter
* @param reader the java.io.Reader object that
* contains the UNICODE data used as the designated parameter
* @param length the number of characters in the stream
* @exception SQLException if a database access error occurs
* @since 1.4
*/
public void setCharacterStream(String parameterName,
java.io.Reader reader,
int length) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setCharacterStream(String,Reader,int)");
}
/**
* Sets the designated parameter to the given java.sql.Date value,
* using the given Calendar object. The driver uses
* the Calendar object to construct an SQL DATE value,
* which the driver then sends to the database. With a
* a Calendar object, the driver can calculate the date
* taking into account a custom timezone. If no
* Calendar object is specified, the driver uses the default
* timezone, which is that of the virtual machine running the application.
*
* @param parameterName the name of the parameter
* @param x the parameter value
* @param cal the Calendar object the driver will use
* to construct the date
* @exception SQLException if a database access error occurs
* @see #getDate
* @since 1.4
*/
public void setDate(String parameterName, java.sql.Date x, Calendar cal)
throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setDate(String,Date,Calendar)");
}
/**
* Sets the designated parameter to the given java.sql.Time value,
* using the given Calendar object. The driver uses
* the Calendar object to construct an SQL TIME value,
* which the driver then sends to the database. With a
* a Calendar object, the driver can calculate the time
* taking into account a custom timezone. If no
* Calendar object is specified, the driver uses the default
* timezone, which is that of the virtual machine running the application.
*
* @param parameterName the name of the parameter
* @param x the parameter value
* @param cal the Calendar object the driver will use
* to construct the time
* @exception SQLException if a database access error occurs
* @see #getTime
* @since 1.4
*/
public void setTime(String parameterName, java.sql.Time x, Calendar cal)
throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setTime(String,Time,Calendar)");
}
/**
* Sets the designated parameter to the given java.sql.Timestamp value,
* using the given Calendar object. The driver uses
* the Calendar object to construct an SQL TIMESTAMP value,
* which the driver then sends to the database. With a
* a Calendar object, the driver can calculate the timestamp
* taking into account a custom timezone. If no
* Calendar object is specified, the driver uses the default
* timezone, which is that of the virtual machine running the application.
*
* @param parameterName the name of the parameter
* @param x the parameter value
* @param cal the Calendar object the driver will use
* to construct the timestamp
* @exception SQLException if a database access error occurs
* @see #getTimestamp
* @since 1.4
*/
public void setTimestamp(String parameterName, java.sql.Timestamp x, Calendar cal)
throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setTimestamp(String,Timestamp,Calendar)");
}
/**
* Sets the designated parameter to SQL NULL.
* This version of the method setNull should
* be used for user-defined types and REF type parameters. Examples
* of user-defined types include: STRUCT, DISTINCT, JAVA_OBJECT, and
* named array types.
*
*
Note: To be portable, applications must give the
* SQL type code and the fully-qualified SQL type name when specifying
* a NULL user-defined or REF parameter. In the case of a user-defined type
* the name is the type name of the parameter itself. For a REF
* parameter, the name is the type name of the referenced type. If
* a JDBC driver does not need the type code or type name information,
* it may ignore it.
*
* Although it is intended for user-defined and Ref parameters,
* this method may be used to set a null parameter of any JDBC type.
* If the parameter does not have a user-defined or REF type, the given
* typeName is ignored.
*
*
* @param parameterName the name of the parameter
* @param sqlType a value from java.sql.Types
* @param typeName the fully-qualified name of an SQL user-defined type;
* ignored if the parameter is not a user-defined type or
* SQL REF value
* @exception SQLException if a database access error occurs
* @since 1.4
*/
public void setNull (String parameterName, int sqlType, String typeName)
throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setNull(String,int,String)");
}
/**
* Retrieves the value of a JDBC CHAR, VARCHAR,
* or LONGVARCHAR parameter as a String in
* the Java programming language.
*
* For the fixed-length type JDBC CHAR,
* the String object
* returned has exactly the same value the JDBC
* CHAR value had in the
* database, including any padding added by the database.
* @param parameterName the name of the parameter
* @return the parameter value. If the value is SQL NULL, the result
* is null.
* @exception SQLException if a database access error occurs
* @see #setString
* @since 1.4
*/
public String getString(String parameterName) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getString(String)");
}
/**
* Retrieves the value of a JDBC BIT parameter as a
* boolean in the Java programming language.
* @param parameterName the name of the parameter
* @return the parameter value. If the value is SQL NULL, the result
* is false.
* @exception SQLException if a database access error occurs
* @see #setBoolean
* @since 1.4
*/
public boolean getBoolean(String parameterName) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getBoolean(String)");
}
/**
* Retrieves the value of a JDBC TINYINT parameter as a byte
* in the Java programming language.
* @param parameterName the name of the parameter
* @return the parameter value. If the value is SQL NULL, the result
* is 0.
* @exception SQLException if a database access error occurs
* @see #setByte
* @since 1.4
*/
public byte getByte(String parameterName) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getByte(String)");
}
/**
* Retrieves the value of a JDBC SMALLINT parameter as a short
* in the Java programming language.
* @param parameterName the name of the parameter
* @return the parameter value. If the value is SQL NULL, the result
* is 0.
* @exception SQLException if a database access error occurs
* @see #setShort
* @since 1.4
*/
public short getShort(String parameterName) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getShort(String)");
}
/**
* Retrieves the value of a JDBC INTEGER parameter as an int
* in the Java programming language.
*
* @param parameterName the name of the parameter
* @return the parameter value. If the value is SQL NULL,
* the result is 0.
* @exception SQLException if a database access error occurs
* @see #setInt
* @since 1.4
*/
public int getInt(String parameterName) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getInt(String)");
}
/**
* Retrieves the value of a JDBC BIGINT parameter as a long
* in the Java programming language.
*
* @param parameterName the name of the parameter
* @return the parameter value. If the value is SQL NULL,
* the result is 0.
* @exception SQLException if a database access error occurs
* @see #setLong
* @since 1.4
*/
public long getLong(String parameterName) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getLong(String)");
}
/**
* Retrieves the value of a JDBC FLOAT parameter as a float
* in the Java programming language.
* @param parameterName the name of the parameter
* @return the parameter value. If the value is SQL NULL,
* the result is 0.
* @exception SQLException if a database access error occurs
* @see #setFloat
* @since 1.4
*/
public float getFloat(String parameterName) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getFloat(String)");
}
/**
* Retrieves the value of a JDBC DOUBLE parameter as a double
* in the Java programming language.
* @param parameterName the name of the parameter
* @return the parameter value. If the value is SQL NULL,
* the result is 0.
* @exception SQLException if a database access error occurs
* @see #setDouble
* @since 1.4
*/
public double getDouble(String parameterName) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getDouble(String)");
}
/**
* Retrieves the value of a JDBC BINARY or VARBINARY
* parameter as an array of byte values in the Java
* programming language.
* @param parameterName the name of the parameter
* @return the parameter value. If the value is SQL NULL, the result is
* null.
* @exception SQLException if a database access error occurs
* @see #setBytes
* @since 1.4
*/
public byte[] getBytes(String parameterName) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getBytes(String)");
}
/**
* Retrieves the value of a JDBC DATE parameter as a
* java.sql.Date object.
* @param parameterName the name of the parameter
* @return the parameter value. If the value is SQL NULL, the result
* is null.
* @exception SQLException if a database access error occurs
* @see #setDate
* @since 1.4
*/
public java.sql.Date getDate(String parameterName) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getDate(String)");
}
/**
* Retrieves the value of a JDBC TIME parameter as a
* java.sql.Time object.
* @param parameterName the name of the parameter
* @return the parameter value. If the value is SQL NULL, the result
* is null.
* @exception SQLException if a database access error occurs
* @see #setTime
* @since 1.4
*/
public java.sql.Time getTime(String parameterName) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getTime(String)");
}
/**
* Retrieves the value of a JDBC TIMESTAMP parameter as a
* java.sql.Timestamp object.
* @param parameterName the name of the parameter
* @return the parameter value. If the value is SQL NULL, the result
* is null.
* @exception SQLException if a database access error occurs
* @see #setTimestamp
* @since 1.4
*/
public java.sql.Timestamp getTimestamp(String parameterName) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getTimestamp(String)");
}
/**
* Retrieves the value of a parameter as an Object in the Java
* programming language. If the value is an SQL NULL, the
* driver returns a Java null.
*
* This method returns a Java object whose type corresponds to the JDBC
* type that was registered for this parameter using the method
* registerOutParameter. By registering the target JDBC
* type as java.sql.Types.OTHER, this method can be used
* to read database-specific abstract data types.
* @param parameterName the name of the parameter
* @return A java.lang.Object holding the OUT parameter value.
* @exception SQLException if a database access error occurs
* @see Types
* @see #setObject
* @since 1.4
*/
public Object getObject(String parameterName) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getObject(String)");
}
/**
* Retrieves the value of a JDBC NUMERIC parameter as a
* java.math.BigDecimal object with as many digits to the
* right of the decimal point as the value contains.
* @param parameterName the name of the parameter
* @return the parameter value in full precision. If the value is
* SQL NULL, the result is null.
* @exception SQLException if a database access error occurs
* @see #setBigDecimal
* @since 1.4
*/
public BigDecimal getBigDecimal(String parameterName) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getBigDecimal(String)");
}
/**
* Returns an object representing the value of OUT parameter
* i and uses map for the custom
* mapping of the parameter value.
*
* This method returns a Java object whose type corresponds to the
* JDBC type that was registered for this parameter using the method
* registerOutParameter. By registering the target
* JDBC type as java.sql.Types.OTHER, this method can
* be used to read database-specific abstract data types.
* @param parameterName the name of the parameter
* @param map the mapping from SQL type names to Java classes
* @return a java.lang.Object holding the OUT parameter value
* @exception SQLException if a database access error occurs
* @see #setObject
* @since 1.4
*/
public Object getObjectImpl (String parameterName, java.util.Map map) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getObject(String,Map)");
}
/**
* Retrieves the value of a JDBC REF(<structured-type>)
* parameter as a {@link Ref} object in the Java programming language.
*
* @param parameterName the name of the parameter
* @return the parameter value as a Ref object in the
* Java programming language. If the value was SQL NULL,
* the value null is returned.
* @exception SQLException if a database access error occurs
* @since 1.4
*/
public Ref getRef (String parameterName) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getRef(String)");
}
/**
* Retrieves the value of a JDBC BLOB parameter as a
* {@link Blob} object in the Java programming language.
*
* @param parameterName the name of the parameter
* @return the parameter value as a Blob object in the
* Java programming language. If the value was SQL NULL,
* the value null is returned.
* @exception SQLException if a database access error occurs
* @since 1.4
*/
public Blob getBlob (String parameterName) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getBlob(String)");
}
/**
* Retrieves the value of a JDBC CLOB parameter as a
* Clob object in the Java programming language.
* @param parameterName the name of the parameter
* @return the parameter value as a Clob object in the
* Java programming language. If the value was SQL NULL,
* the value null is returned.
* @exception SQLException if a database access error occurs
* @since 1.4
*/
public Clob getClob (String parameterName) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getClob(String)");
}
/**
* Retrieves the value of a JDBC ARRAY parameter as an
* {@link Array} object in the Java programming language.
*
* @param parameterName the name of the parameter
* @return the parameter value as an Array object in
* Java programming language. If the value was SQL NULL,
* the value null is returned.
* @exception SQLException if a database access error occurs
* @since 1.4
*/
public Array getArray (String parameterName) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getArray(String)");
}
/**
* Retrieves the value of a JDBC DATE parameter as a
* java.sql.Date object, using
* the given Calendar object
* to construct the date.
* With a Calendar object, the driver
* can calculate the date taking into account a custom timezone and locale.
* If no Calendar object is specified, the driver uses the
* default timezone and locale.
*
* @param parameterName the name of the parameter
* @param cal the Calendar object the driver will use
* to construct the date
* @return the parameter value. If the value is SQL NULL,
* the result is null.
* @exception SQLException if a database access error occurs
* @see #setDate
* @since 1.4
*/
public java.sql.Date getDate(String parameterName, Calendar cal)
throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getDate(String,Calendar)");
}
/**
* Retrieves the value of a JDBC TIME parameter as a
* java.sql.Time object, using
* the given Calendar object
* to construct the time.
* With a Calendar object, the driver
* can calculate the time taking into account a custom timezone and locale.
* If no Calendar object is specified, the driver uses the
* default timezone and locale.
*
* @param parameterName the name of the parameter
* @param cal the Calendar object the driver will use
* to construct the time
* @return the parameter value; if the value is SQL NULL, the result is
* null.
* @exception SQLException if a database access error occurs
* @see #setTime
* @since 1.4
*/
public java.sql.Time getTime(String parameterName, Calendar cal)
throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getTime(String,Calendar)");
}
/**
* Retrieves the value of a JDBC TIMESTAMP parameter as a
* java.sql.Timestamp object, using
* the given Calendar object to construct
* the Timestamp object.
* With a Calendar object, the driver
* can calculate the timestamp taking into account a custom timezone and locale.
* If no Calendar object is specified, the driver uses the
* default timezone and locale.
*
*
* @param parameterName the name of the parameter
* @param cal the Calendar object the driver will use
* to construct the timestamp
* @return the parameter value. If the value is SQL NULL, the result is
* null.
* @exception SQLException if a database access error occurs
* @see #setTimestamp
* @since 1.4
*/
public java.sql.Timestamp getTimestamp(String parameterName, Calendar cal)
throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getTimestamp(String,Calendar)");
}
/**
* Retrieves the value of a JDBC DATALINK parameter as a
* java.net.URL object.
*
* @param parameterName the name of the parameter
* @return the parameter value as a java.net.URL object in the
* Java programming language. If the value was SQL NULL, the
* value null is returned.
* @exception SQLException if a database access error occurs,
* or if there is a problem with the URL
* @see #setURL
* @since 1.4
*/
public java.net.URL getURL(String parameterName) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getURL(String)");
}
public void setObject(int parameterIndex, Object x, int targetSqlType, int scale) throws SQLException
{
if (targetSqlType == Types.BOOLEAN)
{
targetSqlType = Types.BIT;
}
super.setObject(parameterIndex, x, targetSqlType, scale);
}
public void setNull(int parameterIndex, int sqlType) throws SQLException
{
if (sqlType == Types.BOOLEAN)
{
sqlType = Types.BIT;
}
super.setNull(parameterIndex, sqlType);
}
protected boolean wantsHoldableResultSet() {
return rsHoldability == ResultSet.HOLD_CURSORS_OVER_COMMIT;
}
public void registerOutParameter( int parameterIndex, int sqlType ) throws SQLException
{
// if this isn't 8.1 or we are using protocol version 2 then we don't
// register the parameter
switch( sqlType )
{
case Types.BOOLEAN:
sqlType = Types.BIT;
break;
default:
}
super.registerOutParameter(parameterIndex, sqlType, !adjustIndex );
}
public void registerOutParameter(int parameterIndex, int sqlType,
int scale) throws SQLException
{
// ignore scale for now
registerOutParameter(parameterIndex, sqlType );
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc3/Jdbc3Array.java 0000664 0000000 0000000 00000002354 12050675701 0024412 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc3;
import java.util.Map;
import org.postgresql.core.*;
import java.sql.SQLException;
import java.sql.ResultSet;
public class Jdbc3Array extends org.postgresql.jdbc2.AbstractJdbc2Array implements java.sql.Array
{
public Jdbc3Array(BaseConnection conn, int oid, String fieldString) throws SQLException
{
super(conn, oid, fieldString);
}
public Jdbc3Array(BaseConnection conn, int oid, byte[] fieldBytes) throws SQLException
{
super(conn, oid, fieldBytes);
}
public Object getArray(Map map) throws SQLException
{
return getArrayImpl(map);
}
public Object getArray(long index, int count, Map map) throws SQLException
{
return getArrayImpl(index, count, map);
}
public ResultSet getResultSet(Map map) throws SQLException
{
return getResultSetImpl(map);
}
public ResultSet getResultSet(long index, int count, Map map) throws SQLException
{
return getResultSetImpl(index, count, map);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc3/Jdbc3Blob.java 0000664 0000000 0000000 00000000772 12050675701 0024214 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc3;
import java.sql.*;
public class Jdbc3Blob extends org.postgresql.jdbc3.AbstractJdbc3Blob implements java.sql.Blob
{
public Jdbc3Blob(org.postgresql.core.BaseConnection conn, long oid) throws SQLException
{
super(conn, oid);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc3/Jdbc3CallableStatement.java 0000664 0000000 0000000 00000002233 12050675701 0026714 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc3;
import java.sql.*;
import java.util.Map;
class Jdbc3CallableStatement extends Jdbc3PreparedStatement implements CallableStatement
{
Jdbc3CallableStatement(Jdbc3Connection connection, String sql, int rsType, int rsConcurrency, int rsHoldability) throws SQLException
{
super(connection, sql, true, rsType, rsConcurrency, rsHoldability);
if ( !connection.haveMinimumServerVersion("8.1") || connection.getProtocolVersion() == 2)
{
// if there is no out parameter before the function determined by modifyJdbcCall then do not
// set adjustIndex to true
adjustIndex = outParmBeforeFunc;
}
}
public Object getObject(int i, Map map) throws SQLException
{
return getObjectImpl(i, map);
}
public Object getObject(String s, Map map) throws SQLException
{
return getObjectImpl(s, map);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc3/Jdbc3Clob.java 0000664 0000000 0000000 00000000757 12050675701 0024220 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc3;
public class Jdbc3Clob extends org.postgresql.jdbc3.AbstractJdbc3Clob implements java.sql.Clob
{
public Jdbc3Clob(org.postgresql.core.BaseConnection conn, long oid) throws java.sql.SQLException
{
super(conn, oid);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc3/Jdbc3Connection.java 0000664 0000000 0000000 00000004462 12050675701 0025435 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc3;
import java.util.Map;
import java.util.Properties;
import java.sql.SQLException;
import org.postgresql.util.HostSpec;
/**
* This class implements the java.sql.Connection interface for JDBC3.
* However most of the implementation is really done in
* org.postgresql.jdbc3.AbstractJdbc3Connection or one of it's parents
*/
public class Jdbc3Connection extends org.postgresql.jdbc3.AbstractJdbc3Connection implements java.sql.Connection
{
public Jdbc3Connection(HostSpec[] hostSpecs,, String user, String database, Properties info, String url) throws SQLException {
super(hostSpecs, user, database, info, url);
}
public java.sql.Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException
{
checkClosed();
Jdbc3Statement s = new Jdbc3Statement(this, resultSetType, resultSetConcurrency, resultSetHoldability);
s.setPrepareThreshold(getPrepareThreshold());
return s;
}
public java.sql.PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException
{
checkClosed();
Jdbc3PreparedStatement s = new Jdbc3PreparedStatement(this, sql, resultSetType, resultSetConcurrency, resultSetHoldability);
s.setPrepareThreshold(getPrepareThreshold());
return s;
}
public java.sql.CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException
{
checkClosed();
Jdbc3CallableStatement s = new Jdbc3CallableStatement(this, sql, resultSetType, resultSetConcurrency, resultSetHoldability);
s.setPrepareThreshold(getPrepareThreshold());
return s;
}
public java.sql.DatabaseMetaData getMetaData() throws SQLException
{
checkClosed();
if (metadata == null)
metadata = new Jdbc3DatabaseMetaData(this);
return metadata;
}
public void setTypeMap(Map map) throws SQLException
{
setTypeMapImpl(map);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc3/Jdbc3ConnectionPool.java 0000664 0000000 0000000 00000000574 12050675701 0026267 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc3;
import org.postgresql.ds.PGConnectionPoolDataSource;
public class Jdbc3ConnectionPool extends PGConnectionPoolDataSource
{
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc3/Jdbc3DatabaseMetaData.java 0000664 0000000 0000000 00000000740 12050675701 0026436 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc3;
public class Jdbc3DatabaseMetaData extends org.postgresql.jdbc3.AbstractJdbc3DatabaseMetaData implements java.sql.DatabaseMetaData
{
public Jdbc3DatabaseMetaData(Jdbc3Connection conn)
{
super(conn);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc3/Jdbc3ParameterMetaData.java 0000664 0000000 0000000 00000001062 12050675701 0026650 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2005-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc3;
import java.sql.ParameterMetaData;
import org.postgresql.core.BaseConnection;
public class Jdbc3ParameterMetaData extends AbstractJdbc3ParameterMetaData implements ParameterMetaData {
public Jdbc3ParameterMetaData(BaseConnection connection, int oids[])
{
super(connection, oids);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc3/Jdbc3PoolingDataSource.java 0000664 0000000 0000000 00000000561 12050675701 0026714 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc3;
import org.postgresql.ds.PGPoolingDataSource;
public class Jdbc3PoolingDataSource extends PGPoolingDataSource
{
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc3/Jdbc3PreparedStatement.java 0000664 0000000 0000000 00000001516 12050675701 0026762 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc3;
import java.sql.*;
class Jdbc3PreparedStatement extends Jdbc3Statement implements PreparedStatement
{
Jdbc3PreparedStatement(Jdbc3Connection connection, String sql, int rsType, int rsConcurrency, int rsHoldability) throws SQLException
{
this(connection, sql, false, rsType, rsConcurrency, rsHoldability);
}
protected Jdbc3PreparedStatement(Jdbc3Connection connection, String sql, boolean isCallable, int rsType, int rsConcurrency, int rsHoldability) throws SQLException
{
super(connection, sql, isCallable, rsType, rsConcurrency, rsHoldability);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc3/Jdbc3ResultSet.java 0000664 0000000 0000000 00000003655 12050675701 0025273 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2008, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc3;
import java.sql.*;
import java.util.List;
import java.util.Map;
import org.postgresql.core.*;
/**
* This class implements the java.sql.ResultSet interface for JDBC3.
* However most of the implementation is really done in
* org.postgresql.jdbc3.AbstractJdbc3ResultSet or one of it's parents
*/
public class Jdbc3ResultSet extends org.postgresql.jdbc3.AbstractJdbc3ResultSet implements java.sql.ResultSet
{
Jdbc3ResultSet(Query originalQuery, BaseStatement statement, Field[] fields, List tuples, ResultCursor cursor,
int maxRows, int maxFieldSize, int rsType, int rsConcurrency, int rsHoldability) throws SQLException
{
super(originalQuery, statement, fields, tuples, cursor, maxRows, maxFieldSize, rsType, rsConcurrency, rsHoldability);
}
protected java.sql.ResultSetMetaData createMetaData() throws SQLException
{
return new Jdbc3ResultSetMetaData(connection, fields);
}
protected java.sql.Clob makeClob(long oid) throws SQLException
{
return new Jdbc3Clob(connection, oid);
}
protected java.sql.Blob makeBlob(long oid) throws SQLException
{
return new Jdbc3Blob(connection, oid);
}
protected Array makeArray(int oid, byte[] value) throws SQLException
{
return new Jdbc3Array(connection, oid, value);
}
protected Array makeArray(int oid, String value) throws SQLException
{
return new Jdbc3Array(connection, oid, value);
}
public Object getObject(String s, Map map) throws SQLException
{
return getObjectImpl(s, map);
}
public Object getObject(int i, Map map) throws SQLException
{
return getObjectImpl(i, map);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc3/Jdbc3ResultSetMetaData.java 0000664 0000000 0000000 00000001046 12050675701 0026664 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc3;
import org.postgresql.core.*;
public class Jdbc3ResultSetMetaData extends org.postgresql.jdbc2.AbstractJdbc2ResultSetMetaData implements java.sql.ResultSetMetaData
{
public Jdbc3ResultSetMetaData(BaseConnection connection, Field[] fields)
{
super(connection, fields);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc3/Jdbc3SimpleDataSource.java 0000664 0000000 0000000 00000000556 12050675701 0026542 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc3;
import org.postgresql.ds.PGSimpleDataSource;
public class Jdbc3SimpleDataSource extends PGSimpleDataSource
{
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc3/Jdbc3Statement.java 0000664 0000000 0000000 00000003350 12050675701 0025275 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc3;
import java.sql.*;
import java.util.List;
import org.postgresql.core.*;
/**
* This class implements the java.sql.Statement interface for JDBC3.
* However most of the implementation is really done in
* org.postgresql.jdbc3.AbstractJdbc3Statement or one of it's parents
*/
class Jdbc3Statement extends AbstractJdbc3Statement implements Statement
{
Jdbc3Statement (Jdbc3Connection c, int rsType, int rsConcurrency, int rsHoldability) throws SQLException
{
super(c, rsType, rsConcurrency, rsHoldability);
}
protected Jdbc3Statement(Jdbc3Connection connection, String sql, boolean isCallable, int rsType, int rsConcurrency, int rsHoldability) throws SQLException
{
super(connection, sql, isCallable, rsType, rsConcurrency, rsHoldability);
}
public ResultSet createResultSet (Query originalQuery, Field[] fields, List tuples, ResultCursor cursor)
throws SQLException
{
Jdbc3ResultSet newResult = new Jdbc3ResultSet(originalQuery, this, fields, tuples, cursor,
getMaxRows(), getMaxFieldSize(),
getResultSetType(), getResultSetConcurrency(), getResultSetHoldability());
newResult.setFetchSize(getFetchSize());
newResult.setFetchDirection(getFetchDirection());
return newResult;
}
public ParameterMetaData createParameterMetaData(BaseConnection conn, int oids[]) throws SQLException
{
return new Jdbc3ParameterMetaData(conn, oids);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc3/PSQLSavepoint.java 0000664 0000000 0000000 00000004545 12050675701 0025142 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc3;
import java.sql.SQLException;
import java.sql.Savepoint;
import org.postgresql.core.Utils;
import org.postgresql.util.PSQLException;
import org.postgresql.util.GT;
import org.postgresql.util.PSQLState;
public class PSQLSavepoint implements Savepoint {
private boolean _isValid;
private boolean _isNamed;
private int _id;
private String _name;
public PSQLSavepoint(int id) {
_isValid = true;
_isNamed = false;
_id = id;
}
public PSQLSavepoint(String name) {
_isValid = true;
_isNamed = true;
_name = name;
}
public int getSavepointId() throws SQLException {
if (!_isValid)
throw new PSQLException(GT.tr("Cannot reference a savepoint after it has been released."),
PSQLState.INVALID_SAVEPOINT_SPECIFICATION);
if (_isNamed)
throw new PSQLException(GT.tr("Cannot retrieve the id of a named savepoint."),
PSQLState.WRONG_OBJECT_TYPE);
return _id;
}
public String getSavepointName() throws SQLException {
if (!_isValid)
throw new PSQLException(GT.tr("Cannot reference a savepoint after it has been released."),
PSQLState.INVALID_SAVEPOINT_SPECIFICATION);
if (!_isNamed)
throw new PSQLException(GT.tr("Cannot retrieve the name of an unnamed savepoint."),
PSQLState.WRONG_OBJECT_TYPE);
return _name;
}
public void invalidate() {
_isValid = false;
}
public String getPGName() throws SQLException {
if (!_isValid)
throw new PSQLException(GT.tr("Cannot reference a savepoint after it has been released."),
PSQLState.INVALID_SAVEPOINT_SPECIFICATION);
if (_isNamed)
{
// We need to quote and escape the name in case it
// contains spaces/quotes/etc.
//
return Utils.appendEscapedIdentifier(null, _name).toString();
}
return "JDBC_SAVEPOINT_" + _id;
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc3g/ 0000775 0000000 0000000 00000000000 12050675701 0021766 5 ustar 00root root 0000000 0000000 postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc3g/AbstractJdbc3gConnection.java 0000664 0000000 0000000 00000001642 12050675701 0027434 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2008-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc3g;
import java.sql.SQLException;
import java.util.Properties;
import org.postgresql.core.Oid;
import org.postgresql.core.TypeInfo;
import org.postgresql.util.HostSpec;
public abstract class AbstractJdbc3gConnection extends org.postgresql.jdbc3.AbstractJdbc3Connection
{
public AbstractJdbc3gConnection(HostSpec[] hostSpecs, String user, String database, Properties info, String url) throws SQLException {
super(hostSpecs, user, database, info, url);
TypeInfo types = getTypeInfo();
if (haveMinimumServerVersion("8.3")) {
types.addCoreType("uuid", Oid.UUID, java.sql.Types.OTHER, "java.util.UUID", Oid.UUID_ARRAY);
}
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc3g/AbstractJdbc3gResultSet.java 0000664 0000000 0000000 00000002761 12050675701 0027272 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2008-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc3g;
import java.sql.*;
import java.util.List;
import java.util.UUID;
import org.postgresql.core.*;
import org.postgresql.util.ByteConverter;
import org.postgresql.util.GT;
import org.postgresql.util.PSQLState;
import org.postgresql.util.PSQLException;
public abstract class AbstractJdbc3gResultSet extends org.postgresql.jdbc3.AbstractJdbc3ResultSet
{
public AbstractJdbc3gResultSet(Query originalQuery, BaseStatement statement, Field[] fields, List tuples,
ResultCursor cursor, int maxRows, int maxFieldSize, int rsType, int rsConcurrency, int rsHoldability) throws SQLException
{
super (originalQuery, statement, fields, tuples, cursor, maxRows, maxFieldSize, rsType, rsConcurrency, rsHoldability);
}
protected Object getUUID(String data) throws SQLException
{
UUID uuid;
try {
uuid = UUID.fromString(data);
} catch (java.lang.IllegalArgumentException iae) {
throw new PSQLException(GT.tr("Invalid UUID data."), PSQLState.INVALID_PARAMETER_VALUE, iae);
}
return uuid;
}
protected Object getUUID(byte[] data) throws SQLException
{
return new UUID(ByteConverter.int8(data, 0), ByteConverter.int8(data, 8));
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc3g/AbstractJdbc3gStatement.java 0000664 0000000 0000000 00000004143 12050675701 0027300 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2008-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc3g;
import java.sql.*;
import java.util.UUID;
import org.postgresql.core.Oid;
import org.postgresql.jdbc3.AbstractJdbc3Connection;
import org.postgresql.util.ByteConverter;
public abstract class AbstractJdbc3gStatement extends org.postgresql.jdbc3.AbstractJdbc3Statement
{
public AbstractJdbc3gStatement (AbstractJdbc3Connection c, int rsType, int rsConcurrency, int rsHoldability) throws SQLException
{
super(c, rsType, rsConcurrency, rsHoldability);
}
public AbstractJdbc3gStatement(AbstractJdbc3Connection connection, String sql, boolean isCallable, int rsType, int rsConcurrency, int rsHoldability) throws SQLException
{
super(connection, sql, isCallable, rsType, rsConcurrency, rsHoldability);
}
public void setObject(int parameterIndex, Object x) throws SQLException
{
if (x instanceof UUID && connection.haveMinimumServerVersion("8.3"))
{
setUuid(parameterIndex, (UUID)x);
} else {
super.setObject(parameterIndex, x);
}
}
public void setObject(int parameterIndex, Object x, int targetSqlType, int scale) throws SQLException
{
if (targetSqlType == Types.OTHER && x instanceof UUID && connection.haveMinimumServerVersion("8.3"))
{
setUuid(parameterIndex, (UUID) x);
} else {
super.setObject(parameterIndex, x, targetSqlType, scale);
}
}
private void setUuid(int parameterIndex, UUID uuid) throws SQLException {
if (connection.binaryTransferSend(Oid.UUID)) {
byte[] val = new byte[16];
ByteConverter.int8(val, 0, uuid.getMostSignificantBits());
ByteConverter.int8(val, 8, uuid.getLeastSignificantBits());
bindBytes(parameterIndex, val, Oid.UUID);
} else {
bindLiteral(parameterIndex, uuid.toString(), Oid.UUID);
}
}
} postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc3g/Jdbc3gArray.java 0000664 0000000 0000000 00000002514 12050675701 0024726 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc3g;
import java.util.Map;
import org.postgresql.core.*;
import java.sql.SQLException;
import java.sql.ResultSet;
public class Jdbc3gArray extends org.postgresql.jdbc2.AbstractJdbc2Array implements java.sql.Array
{
public Jdbc3gArray(BaseConnection conn, int oid, String fieldString) throws SQLException
{
super(conn, oid, fieldString);
}
public Jdbc3gArray(BaseConnection conn, int oid, byte[] fieldBytes) throws SQLException
{
super(conn, oid, fieldBytes);
}
public Object getArray(Map < String, Class < ? >> map) throws SQLException
{
return getArrayImpl(map);
}
public Object getArray(long index, int count, Map < String, Class < ? >> map) throws SQLException
{
return getArrayImpl(index, count, map);
}
public ResultSet getResultSet(Map < String, Class < ? >> map) throws SQLException
{
return getResultSetImpl(map);
}
public ResultSet getResultSet(long index, int count, Map < String, Class < ? >> map) throws SQLException
{
return getResultSetImpl(index, count, map);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc3g/Jdbc3gBlob.java 0000664 0000000 0000000 00000000775 12050675701 0024535 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc3g;
import java.sql.*;
public class Jdbc3gBlob extends org.postgresql.jdbc3.AbstractJdbc3Blob implements java.sql.Blob
{
public Jdbc3gBlob(org.postgresql.core.BaseConnection conn, long oid) throws SQLException
{
super(conn, oid);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc3g/Jdbc3gCallableStatement.java 0000664 0000000 0000000 00000002266 12050675701 0027240 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc3g;
import java.sql.*;
import java.util.Map;
class Jdbc3gCallableStatement extends Jdbc3gPreparedStatement implements CallableStatement
{
Jdbc3gCallableStatement(Jdbc3gConnection connection, String sql, int rsType, int rsConcurrency, int rsHoldability) throws SQLException
{
super(connection, sql, true, rsType, rsConcurrency, rsHoldability);
if ( !connection.haveMinimumServerVersion("8.1") || connection.getProtocolVersion() == 2)
{
// if there is no out parameter before the function determined by modifyJdbcCall then do not
// set adjustIndex to true
adjustIndex = outParmBeforeFunc;
}
}
public Object getObject(int i, Map < String, Class < ? >> map) throws SQLException
{
return getObjectImpl(i, map);
}
public Object getObject(String s, Map < String, Class < ? >> map) throws SQLException
{
return getObjectImpl(s, map);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc3g/Jdbc3gClob.java 0000664 0000000 0000000 00000000762 12050675701 0024532 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc3g;
public class Jdbc3gClob extends org.postgresql.jdbc3.AbstractJdbc3Clob implements java.sql.Clob
{
public Jdbc3gClob(org.postgresql.core.BaseConnection conn, long oid) throws java.sql.SQLException
{
super(conn, oid);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc3g/Jdbc3gConnection.java 0000664 0000000 0000000 00000004524 12050675701 0025752 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc3g;
import java.util.Map;
import java.util.Properties;
import java.sql.SQLException;
import org.postgresql.util.HostSpec;
/**
* This class implements the java.sql.Connection interface for JDBC3.
* However most of the implementation is really done in
* org.postgresql.jdbc3.AbstractJdbc3Connection or one of it's parents
*/
public class Jdbc3gConnection extends org.postgresql.jdbc3g.AbstractJdbc3gConnection implements java.sql.Connection
{
public Jdbc3gConnection(HostSpec[] hostSpecs, String user, String database, Properties info, String url) throws SQLException {
super(hostSpecs, user, database, info, url);
}
public java.sql.Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException
{
checkClosed();
Jdbc3gStatement s = new Jdbc3gStatement(this, resultSetType, resultSetConcurrency, resultSetHoldability);
s.setPrepareThreshold(getPrepareThreshold());
return s;
}
public java.sql.PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException
{
checkClosed();
Jdbc3gPreparedStatement s = new Jdbc3gPreparedStatement(this, sql, resultSetType, resultSetConcurrency, resultSetHoldability);
s.setPrepareThreshold(getPrepareThreshold());
return s;
}
public java.sql.CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException
{
checkClosed();
Jdbc3gCallableStatement s = new Jdbc3gCallableStatement(this, sql, resultSetType, resultSetConcurrency, resultSetHoldability);
s.setPrepareThreshold(getPrepareThreshold());
return s;
}
public java.sql.DatabaseMetaData getMetaData() throws SQLException
{
checkClosed();
if (metadata == null)
metadata = new Jdbc3gDatabaseMetaData(this);
return metadata;
}
public void setTypeMap(Map < String, Class < ? >> map) throws SQLException
{
setTypeMapImpl(map);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc3g/Jdbc3gDatabaseMetaData.java 0000664 0000000 0000000 00000000744 12050675701 0026760 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc3g;
public class Jdbc3gDatabaseMetaData extends org.postgresql.jdbc3.AbstractJdbc3DatabaseMetaData implements java.sql.DatabaseMetaData
{
public Jdbc3gDatabaseMetaData(Jdbc3gConnection conn)
{
super(conn);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc3g/Jdbc3gParameterMetaData.java 0000664 0000000 0000000 00000001112 12050675701 0027162 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2005-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc3g;
import java.sql.ParameterMetaData;
import org.postgresql.core.BaseConnection;
public class Jdbc3gParameterMetaData extends org.postgresql.jdbc3.AbstractJdbc3ParameterMetaData implements ParameterMetaData {
public Jdbc3gParameterMetaData(BaseConnection connection, int oids[])
{
super(connection, oids);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc3g/Jdbc3gPreparedStatement.java 0000664 0000000 0000000 00000001525 12050675701 0027300 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc3g;
import java.sql.*;
class Jdbc3gPreparedStatement extends Jdbc3gStatement implements PreparedStatement
{
Jdbc3gPreparedStatement(Jdbc3gConnection connection, String sql, int rsType, int rsConcurrency, int rsHoldability) throws SQLException
{
this(connection, sql, false, rsType, rsConcurrency, rsHoldability);
}
protected Jdbc3gPreparedStatement(Jdbc3gConnection connection, String sql, boolean isCallable, int rsType, int rsConcurrency, int rsHoldability) throws SQLException
{
super(connection, sql, isCallable, rsType, rsConcurrency, rsHoldability);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc3g/Jdbc3gResultSet.java 0000664 0000000 0000000 00000003740 12050675701 0025604 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2008, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc3g;
import java.sql.*;
import java.util.List;
import java.util.Map;
import org.postgresql.core.*;
/**
* This class implements the java.sql.ResultSet interface for JDBC3.
* However most of the implementation is really done in
* org.postgresql.jdbc3.AbstractJdbc3ResultSet or one of it's parents
*/
public class Jdbc3gResultSet extends org.postgresql.jdbc3g.AbstractJdbc3gResultSet implements java.sql.ResultSet
{
Jdbc3gResultSet(Query originalQuery, BaseStatement statement, Field[] fields, List tuples, ResultCursor cursor,
int maxRows, int maxFieldSize, int rsType, int rsConcurrency, int rsHoldability) throws SQLException
{
super(originalQuery, statement, fields, tuples, cursor, maxRows, maxFieldSize, rsType, rsConcurrency, rsHoldability);
}
protected java.sql.ResultSetMetaData createMetaData() throws SQLException
{
return new Jdbc3gResultSetMetaData(connection, fields);
}
protected java.sql.Clob makeClob(long oid) throws SQLException
{
return new Jdbc3gClob(connection, oid);
}
protected java.sql.Blob makeBlob(long oid) throws SQLException
{
return new Jdbc3gBlob(connection, oid);
}
public Array makeArray(int oid, byte[] value) throws SQLException
{
return new Jdbc3gArray(connection, oid, value);
}
public Array makeArray(int oid, String value) throws SQLException
{
return new Jdbc3gArray(connection, oid, value);
}
public Object getObject(String s, Map < String, Class < ? >> map) throws SQLException
{
return getObjectImpl(s, map);
}
public Object getObject(int i, Map < String, Class < ? >> map) throws SQLException
{
return getObjectImpl(i, map);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc3g/Jdbc3gResultSetMetaData.java 0000664 0000000 0000000 00000001051 12050675701 0027176 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc3g;
import org.postgresql.core.*;
public class Jdbc3gResultSetMetaData extends org.postgresql.jdbc2.AbstractJdbc2ResultSetMetaData implements java.sql.ResultSetMetaData
{
public Jdbc3gResultSetMetaData(BaseConnection connection, Field[] fields)
{
super(connection, fields);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc3g/Jdbc3gStatement.java 0000664 0000000 0000000 00000003412 12050675701 0025612 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc3g;
import java.sql.*;
import java.util.List;
import org.postgresql.core.*;
/**
* This class implements the java.sql.Statement interface for JDBC3.
* However most of the implementation is really done in
* org.postgresql.jdbc3.AbstractJdbc3Statement or one of it's parents
*/
class Jdbc3gStatement extends org.postgresql.jdbc3g.AbstractJdbc3gStatement implements Statement
{
Jdbc3gStatement (Jdbc3gConnection c, int rsType, int rsConcurrency, int rsHoldability) throws SQLException
{
super(c, rsType, rsConcurrency, rsHoldability);
}
protected Jdbc3gStatement(Jdbc3gConnection connection, String sql, boolean isCallable, int rsType, int rsConcurrency, int rsHoldability) throws SQLException
{
super(connection, sql, isCallable, rsType, rsConcurrency, rsHoldability);
}
public ResultSet createResultSet (Query originalQuery, Field[] fields, List tuples, ResultCursor cursor)
throws SQLException
{
Jdbc3gResultSet newResult = new Jdbc3gResultSet(originalQuery, this, fields, tuples, cursor,
getMaxRows(), getMaxFieldSize(),
getResultSetType(), getResultSetConcurrency(), getResultSetHoldability());
newResult.setFetchSize(getFetchSize());
newResult.setFetchDirection(getFetchDirection());
return newResult;
}
public ParameterMetaData createParameterMetaData(BaseConnection conn, int oids[]) throws SQLException
{
return new Jdbc3gParameterMetaData(conn, oids);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc4/ 0000775 0000000 0000000 00000000000 12050675701 0021620 5 ustar 00root root 0000000 0000000 postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc4/AbstractJdbc4Blob.java 0000664 0000000 0000000 00000001351 12050675701 0025674 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc4;
import java.sql.*;
public abstract class AbstractJdbc4Blob extends org.postgresql.jdbc3.AbstractJdbc3Blob
{
public AbstractJdbc4Blob(org.postgresql.core.BaseConnection conn, long oid) throws SQLException
{
super(conn, oid);
}
public synchronized java.io.InputStream getBinaryStream(long pos, long length) throws SQLException
{
checkFreed();
throw org.postgresql.Driver.notImplemented(this.getClass(), "getBinaryStream(long, long)");
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc4/AbstractJdbc4Clob.java 0000664 0000000 0000000 00000001402 12050675701 0025672 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc4;
import java.io.Reader;
import java.sql.SQLException;
public abstract class AbstractJdbc4Clob extends org.postgresql.jdbc3.AbstractJdbc3Clob
{
public AbstractJdbc4Clob(org.postgresql.core.BaseConnection conn, long oid) throws SQLException
{
super(conn, oid);
}
public synchronized Reader getCharacterStream(long pos, long length) throws SQLException
{
checkFreed();
throw org.postgresql.Driver.notImplemented(this.getClass(), "getCharacterStream(long, long)");
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc4/AbstractJdbc4Connection.java 0000664 0000000 0000000 00000020371 12050675701 0027120 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc4;
import java.sql.*;
import java.util.Map;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Properties;
import java.util.concurrent.Executor;
import org.postgresql.core.Oid;
import org.postgresql.core.Utils;
import org.postgresql.core.TypeInfo;
import org.postgresql.util.GT;
import org.postgresql.util.HostSpec;
import org.postgresql.util.PSQLState;
import org.postgresql.util.PSQLException;
import org.postgresql.jdbc2.AbstractJdbc2Array;
abstract class AbstractJdbc4Connection extends org.postgresql.jdbc3g.AbstractJdbc3gConnection
{
private final Properties _clientInfo;
public AbstractJdbc4Connection(HostSpec[] hostSpecs, String user, String database, Properties info, String url) throws SQLException {
super(hostSpecs, user, database, info, url);
TypeInfo types = getTypeInfo();
if (haveMinimumServerVersion("8.3")) {
types.addCoreType("xml", Oid.XML, java.sql.Types.SQLXML, "java.sql.SQLXML", Oid.XML_ARRAY);
}
_clientInfo = new Properties();
if (haveMinimumServerVersion("9.0")) {
String appName = info.getProperty("ApplicationName");
if (appName == null) {
appName = "";
}
_clientInfo.put("ApplicationName", appName);
}
}
public Clob createClob() throws SQLException
{
checkClosed();
throw org.postgresql.Driver.notImplemented(this.getClass(), "createClob()");
}
public Blob createBlob() throws SQLException
{
checkClosed();
throw org.postgresql.Driver.notImplemented(this.getClass(), "createBlob()");
}
public NClob createNClob() throws SQLException
{
checkClosed();
throw org.postgresql.Driver.notImplemented(this.getClass(), "createNClob()");
}
public SQLXML createSQLXML() throws SQLException
{
checkClosed();
return new Jdbc4SQLXML(this);
}
public Struct createStruct(String typeName, Object[] attributes) throws SQLException
{
checkClosed();
throw org.postgresql.Driver.notImplemented(this.getClass(), "createStruct(String, Object[])");
}
public Array createArrayOf(String typeName, Object[] elements) throws SQLException
{
checkClosed();
int oid = getTypeInfo().getPGArrayType(typeName);
if (oid == Oid.UNSPECIFIED)
throw new PSQLException(GT.tr("Unable to find server array type for provided name {0}.", typeName), PSQLState.INVALID_NAME);
StringBuffer sb = new StringBuffer();
appendArray(sb, elements);
// This will not work once we have a JDBC 5,
// but it'll do for now.
return new Jdbc4Array(this, oid, sb.toString());
}
private static void appendArray(StringBuffer sb, Object elements)
{
sb.append('{');
int nElements = java.lang.reflect.Array.getLength(elements);
for (int i=0; i 0) {
sb.append(',');
}
Object o = java.lang.reflect.Array.get(elements, i);
if (o == null) {
sb.append("NULL");
} else if (o.getClass().isArray()) {
appendArray(sb, o);
} else {
String s = o.toString();
AbstractJdbc2Array.escapeArrayElement(sb, s);
}
}
sb.append('}');
}
public boolean isValid(int timeout) throws SQLException
{
checkClosed();
if (timeout < 0) {
throw new PSQLException(GT.tr("Invalid timeout ({0}<0).", timeout), PSQLState.INVALID_PARAMETER_VALUE);
}
boolean valid = false;
Statement stmt = null;
try {
if (!isClosed()) {
stmt = createStatement();
stmt.setQueryTimeout( timeout );
stmt.executeQuery( "SELECT 1" );
valid = true;
}
}
catch ( SQLException e) {
getLogger().log(GT.tr("Validating connection."),e);
}
finally
{
if(stmt!=null) try {stmt.close();}catch(Exception ex){}
}
return valid;
}
public void setClientInfo(String name, String value) throws SQLClientInfoException
{
if (haveMinimumServerVersion("9.0") && "ApplicationName".equals(name)) {
if (value == null)
value = "";
try {
StringBuffer sql = new StringBuffer("SET application_name = '");
Utils.appendEscapedLiteral(sql, value, getStandardConformingStrings());
sql.append("'");
execSQLUpdate(sql.toString());
} catch (SQLException sqle) {
Map failures = new HashMap();
failures.put(name, ClientInfoStatus.REASON_UNKNOWN);
throw new SQLClientInfoException(GT.tr("Failed to set ClientInfo property: {0}", "ApplicationName"), sqle.getSQLState(), failures, sqle);
}
_clientInfo.put(name, value);
return;
}
Map failures = new HashMap();
failures.put(name, ClientInfoStatus.REASON_UNKNOWN_PROPERTY);
throw new SQLClientInfoException(GT.tr("ClientInfo property not supported."), PSQLState.NOT_IMPLEMENTED.getState(), failures);
}
public void setClientInfo(Properties properties) throws SQLClientInfoException
{
if (properties == null || properties.size() == 0)
return;
Map failures = new HashMap();
Iterator i = properties.stringPropertyNames().iterator();
while (i.hasNext()) {
String name = i.next();
if (haveMinimumServerVersion("9.0") && "ApplicationName".equals(name)) {
String value = properties.getProperty(name);
setClientInfo(name, value);
} else {
failures.put(i.next(), ClientInfoStatus.REASON_UNKNOWN_PROPERTY);
}
}
if (!failures.isEmpty())
throw new SQLClientInfoException(GT.tr("ClientInfo property not supported."), PSQLState.NOT_IMPLEMENTED.getState(), failures);
}
public String getClientInfo(String name) throws SQLException
{
checkClosed();
return _clientInfo.getProperty(name);
}
public Properties getClientInfo() throws SQLException
{
checkClosed();
return _clientInfo;
}
public T createQueryObject(Class ifc) throws SQLException
{
checkClosed();
throw org.postgresql.Driver.notImplemented(this.getClass(), "createQueryObject(Class)");
}
public boolean isWrapperFor(Class iface) throws SQLException
{
checkClosed();
throw org.postgresql.Driver.notImplemented(this.getClass(), "isWrapperFor(Class)");
}
public T unwrap(Class iface) throws SQLException
{
checkClosed();
throw org.postgresql.Driver.notImplemented(this.getClass(), "unwrap(Class)");
}
public java.util.logging.Logger getParentLogger() throws SQLFeatureNotSupportedException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getParentLogger()");
}
public void setSchema(String schema) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setSchema(String)");
}
public String getSchema() throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getSchema()");
}
public void abort(Executor executor) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "abort(Executor)");
}
public void setNetworkTimeout(Executor executor, int milliseconds) throws SQLException {
throw org.postgresql.Driver.notImplemented(this.getClass(), "setNetworkTimeout(Executor, int)");
}
public int getNetworkTimeout() throws SQLException {
throw org.postgresql.Driver.notImplemented(this.getClass(), "getNetworkTimeout()");
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc4/AbstractJdbc4DatabaseMetaData.java 0000664 0000000 0000000 00000010162 12050675701 0030123 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc4;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import org.postgresql.core.*;
public abstract class AbstractJdbc4DatabaseMetaData extends org.postgresql.jdbc3.AbstractJdbc3DatabaseMetaData
{
public AbstractJdbc4DatabaseMetaData(AbstractJdbc4Connection conn)
{
super(conn);
}
public RowIdLifetime getRowIdLifetime() throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getRowIdLifetime()");
}
public ResultSet getSchemas(String catalog, String schemaPattern) throws SQLException
{
return getSchemas(4, catalog, schemaPattern);
}
public boolean supportsStoredFunctionsUsingCallSyntax() throws SQLException
{
return true;
}
public boolean autoCommitFailureClosesAllResultSets() throws SQLException
{
return false;
}
public ResultSet getClientInfoProperties() throws SQLException
{
Field f[] = new Field[4];
f[0] = new Field("NAME", Oid.VARCHAR);
f[1] = new Field("MAX_LEN", Oid.INT4);
f[2] = new Field("DEFAULT_VALUE", Oid.VARCHAR);
f[3] = new Field("DESCRIPTION", Oid.VARCHAR);
List v = new ArrayList();
if (connection.haveMinimumServerVersion("9.0")) {
byte[][] tuple = new byte[4][];
tuple[0] = connection.encodeString("ApplicationName");
tuple[1] = connection.encodeString(Integer.toString(getMaxNameLength()));
tuple[2] = connection.encodeString("");
tuple[3] = connection.encodeString("The name of the application currently utilizing the connection.");
v.add(tuple);
}
return (ResultSet) ((BaseStatement)createMetaDataStatement()).createDriverResultSet(f, v);
}
public boolean providesQueryObjectGenerator() throws SQLException
{
return false;
}
public boolean isWrapperFor(Class iface) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "isWrapperFor(Class)");
}
public T unwrap(Class iface) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "unwrap(Class)");
}
public ResultSet getFunctions(String catalog, String schemaPattern, String functionNamePattern) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getFunction(String, String, String)");
}
public ResultSet getFunctionColumns(String catalog, String schemaPattern, String functionNamePattern, String columnNamePattern) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getFunctionColumns(String, String, String, String)");
}
public int getJDBCMajorVersion() throws SQLException
{
return 4;
}
public ResultSet getColumns(String catalog, String schemaPattern, String tableNamePattern, String columnNamePattern) throws SQLException
{
return getColumns(4, catalog, schemaPattern, tableNamePattern, columnNamePattern);
}
public ResultSet getProcedures(String catalog, String schemaPattern, String procedureNamePattern) throws SQLException
{
return getProcedures(4, catalog, schemaPattern, procedureNamePattern);
}
public ResultSet getProcedureColumns(String catalog, String schemaPattern, String procedureNamePattern, String columnNamePattern) throws SQLException
{
return getProcedureColumns(4, catalog, schemaPattern, procedureNamePattern, columnNamePattern);
}
public ResultSet getPseudoColumns(String catalog, String schemaPattern, String tableNamePattern, String columnNamePattern) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getPseudoColumns(String, String, String, String)");
}
public boolean generatedKeyAlwaysReturned() throws SQLException {
return true;
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc4/AbstractJdbc4ParameterMetaData.java 0000664 0000000 0000000 00000001620 12050675701 0030336 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2005-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc4;
import java.sql.SQLException;
import org.postgresql.core.BaseConnection;
public abstract class AbstractJdbc4ParameterMetaData extends org.postgresql.jdbc3.AbstractJdbc3ParameterMetaData
{
public AbstractJdbc4ParameterMetaData(BaseConnection connection, int oids[])
{
super(connection, oids);
}
public boolean isWrapperFor(Class iface) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "isWrapperFor(Class)");
}
public T unwrap(Class iface) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "unwrap(Class)");
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc4/AbstractJdbc4ResultSet.java 0000664 0000000 0000000 00000025031 12050675701 0026751 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc4;
import java.sql.*;
import java.io.Reader;
import java.io.InputStream;
import java.util.List;
import org.postgresql.core.*;
abstract class AbstractJdbc4ResultSet extends org.postgresql.jdbc3g.AbstractJdbc3gResultSet
{
AbstractJdbc4ResultSet(Query originalQuery, BaseStatement statement, Field[] fields, List tuples, ResultCursor cursor,
int maxRows, int maxFieldSize, int rsType, int rsConcurrency, int rsHoldability) throws SQLException
{
super(originalQuery, statement, fields, tuples, cursor, maxRows, maxFieldSize, rsType, rsConcurrency, rsHoldability);
}
public RowId getRowId(int columnIndex) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getRowId(int)");
}
public RowId getRowId(String columnName) throws SQLException
{
return getRowId(findColumn(columnName));
}
public void updateRowId(int columnIndex, RowId x) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "updateRowId(int, RowId)");
}
public void updateRowId(String columnName, RowId x) throws SQLException
{
updateRowId(findColumn(columnName), x);
}
public int getHoldability() throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getHoldability()");
}
public boolean isClosed() throws SQLException
{
return (rows == null);
}
public void updateNString(int columnIndex, String nString) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "updateNString(int, String)");
}
public void updateNString(String columnName, String nString) throws SQLException
{
updateNString(findColumn(columnName), nString);
}
public void updateNClob(int columnIndex, NClob nClob) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "updateNClob(int, NClob)");
}
public void updateNClob(String columnName, NClob nClob) throws SQLException
{
updateNClob(findColumn(columnName), nClob);
}
public void updateNClob(int columnIndex, Reader reader) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "updateNClob(int, Reader)");
}
public void updateNClob(String columnName, Reader reader) throws SQLException
{
updateNClob(findColumn(columnName), reader);
}
public void updateNClob(int columnIndex, Reader reader, long length) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "updateNClob(int, Reader, long)");
}
public void updateNClob(String columnName, Reader reader, long length) throws SQLException
{
updateNClob(findColumn(columnName), reader, length);
}
public NClob getNClob(int columnIndex) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getNClob(int)");
}
public NClob getNClob(String columnName) throws SQLException
{
return getNClob(findColumn(columnName));
}
public void updateBlob(int columnIndex, InputStream inputStream, long length) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "updateBlob(int, InputStream, long)");
}
public void updateBlob(String columnName, InputStream inputStream, long length) throws SQLException
{
updateBlob(findColumn(columnName), inputStream, length);
}
public void updateBlob(int columnIndex, InputStream inputStream) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "updateBlob(int, InputStream)");
}
public void updateBlob(String columnName, InputStream inputStream) throws SQLException
{
updateBlob(findColumn(columnName), inputStream);
}
public void updateClob(int columnIndex, Reader reader, long length) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "updateClob(int, Reader, long)");
}
public void updateClob(String columnName, Reader reader, long length) throws SQLException
{
updateClob(findColumn(columnName), reader, length);
}
public void updateClob(int columnIndex, Reader reader) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "updateClob(int, Reader)");
}
public void updateClob(String columnName, Reader reader) throws SQLException
{
updateClob(findColumn(columnName), reader);
}
public SQLXML getSQLXML(int columnIndex) throws SQLException
{
String data = getString(columnIndex);
if (data == null)
return null;
return new Jdbc4SQLXML(connection, data);
}
public SQLXML getSQLXML(String columnName) throws SQLException
{
return getSQLXML(findColumn(columnName));
}
public void updateSQLXML(int columnIndex, SQLXML xmlObject) throws SQLException
{
updateValue(columnIndex, xmlObject);
}
public void updateSQLXML(String columnName, SQLXML xmlObject) throws SQLException
{
updateSQLXML(findColumn(columnName), xmlObject);
}
public String getNString(int columnIndex) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getNString(int)");
}
public String getNString(String columnName) throws SQLException
{
return getNString(findColumn(columnName));
}
public Reader getNCharacterStream(int columnIndex) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getNCharacterStream(int)");
}
public Reader getNCharacterStream(String columnName) throws SQLException
{
return getNCharacterStream(findColumn(columnName));
}
public void updateNCharacterStream(int columnIndex, Reader x, int length) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "updateNCharacterStream(int, Reader, int)");
}
public void updateNCharacterStream(String columnName, Reader x, int length) throws SQLException
{
updateNCharacterStream(findColumn(columnName), x, length);
}
public void updateNCharacterStream(int columnIndex, Reader x) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "updateNCharacterStream(int, Reader)");
}
public void updateNCharacterStream(String columnName, Reader x) throws SQLException
{
updateNCharacterStream(findColumn(columnName), x);
}
public void updateNCharacterStream(int columnIndex, Reader x, long length) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "updateNCharacterStream(int, Reader, long)");
}
public void updateNCharacterStream(String columnName, Reader x, long length) throws SQLException
{
updateNCharacterStream(findColumn(columnName), x, length);
}
public void updateCharacterStream(int columnIndex, Reader reader, long length) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "updateCharaceterStream(int, Reader, long)");
}
public void updateCharacterStream(String columnName, Reader reader, long length) throws SQLException
{
updateCharacterStream(findColumn(columnName), reader, length);
}
public void updateCharacterStream(int columnIndex, Reader reader) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "updateCharaceterStream(int, Reader)");
}
public void updateCharacterStream(String columnName, Reader reader) throws SQLException
{
updateCharacterStream(findColumn(columnName), reader);
}
public void updateBinaryStream(int columnIndex, InputStream inputStream, long length) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "updateBinaryStream(int, InputStream, long)");
}
public void updateBinaryStream(String columnName, InputStream inputStream, long length) throws SQLException
{
updateBinaryStream(findColumn(columnName), inputStream, length);
}
public void updateBinaryStream(int columnIndex, InputStream inputStream) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "updateBinaryStream(int, InputStream)");
}
public void updateBinaryStream(String columnName, InputStream inputStream) throws SQLException
{
updateBinaryStream(findColumn(columnName), inputStream);
}
public void updateAsciiStream(int columnIndex, InputStream inputStream, long length) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "updateAsciiStream(int, InputStream, long)");
}
public void updateAsciiStream(String columnName, InputStream inputStream, long length) throws SQLException
{
updateAsciiStream(findColumn(columnName), inputStream, length);
}
public void updateAsciiStream(int columnIndex, InputStream inputStream) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "updateAsciiStream(int, InputStream)");
}
public void updateAsciiStream(String columnName, InputStream inputStream) throws SQLException
{
updateAsciiStream(findColumn(columnName), inputStream);
}
public boolean isWrapperFor(Class iface) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "isWrapperFor(Class)");
}
public T unwrap(Class iface) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "unwrap(Class)");
}
protected Object internalGetObject(int columnIndex, Field field) throws SQLException
{
switch(getSQLType(columnIndex))
{
case Types.SQLXML:
return getSQLXML(columnIndex);
}
return super.internalGetObject(columnIndex, field);
}
public T getObject(int columnIndex, Class type) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getObject(int, Class)");
}
public T getObject(String columnLabel, Class type) throws SQLException
{
return getObject(findColumn(columnLabel), type);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc4/AbstractJdbc4ResultSetMetaData.java 0000664 0000000 0000000 00000001604 12050675701 0030352 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc4;
import org.postgresql.core.*;
import java.sql.SQLException;
abstract class AbstractJdbc4ResultSetMetaData extends org.postgresql.jdbc2.AbstractJdbc2ResultSetMetaData
{
public AbstractJdbc4ResultSetMetaData(BaseConnection connection, Field[] fields)
{
super(connection, fields);
}
public boolean isWrapperFor(Class iface) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "isWrapperFor(Class)");
}
public T unwrap(Class iface) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "unwrap(Class)");
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc4/AbstractJdbc4Statement.java 0000664 0000000 0000000 00000034007 12050675701 0026766 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc4;
import java.sql.*;
import java.io.Reader;
import java.io.InputStream;
import org.postgresql.core.Oid;
import org.postgresql.util.GT;
import org.postgresql.util.PSQLState;
import org.postgresql.util.PSQLException;
abstract class AbstractJdbc4Statement extends org.postgresql.jdbc3g.AbstractJdbc3gStatement
{
private boolean poolable;
AbstractJdbc4Statement (Jdbc4Connection c, int rsType, int rsConcurrency, int rsHoldability) throws SQLException
{
super(c, rsType, rsConcurrency, rsHoldability);
poolable = true;
}
public AbstractJdbc4Statement(Jdbc4Connection connection, String sql, boolean isCallable, int rsType, int rsConcurrency, int rsHoldability) throws SQLException
{
super(connection, sql, isCallable, rsType, rsConcurrency, rsHoldability);
}
public boolean isClosed() throws SQLException
{
return isClosed;
}
public void setObject(int parameterIndex, Object x) throws SQLException
{
if (x instanceof SQLXML)
{
setSQLXML(parameterIndex, (SQLXML)x);
} else {
super.setObject(parameterIndex, x);
}
}
public void setObject(int parameterIndex, Object x, int targetSqlType, int scale) throws SQLException
{
checkClosed();
if (x == null)
{
setNull(parameterIndex, targetSqlType);
return;
}
switch (targetSqlType) {
case Types.SQLXML:
if (x instanceof SQLXML) {
setSQLXML(parameterIndex, (SQLXML)x);
} else {
setSQLXML(parameterIndex, new Jdbc4SQLXML(connection, x.toString()));
}
break;
default:
super.setObject(parameterIndex, x, targetSqlType, scale);
}
}
public void setNull(int parameterIndex, int targetSqlType) throws SQLException
{
checkClosed();
int oid;
switch (targetSqlType)
{
case Types.SQLXML:
oid = Oid.XML;
break;
default:
super.setNull(parameterIndex, targetSqlType);
return;
}
if (adjustIndex)
parameterIndex--;
preparedParameters.setNull(parameterIndex, oid);
}
public void setRowId(int parameterIndex, RowId x) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setRowId(int, RowId)");
}
public void setNString(int parameterIndex, String value) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setNString(int, String)");
}
public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setNCharacterStream(int, Reader, long)");
}
public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setNCharacterStream(int, Reader)");
}
public void setCharacterStream(int parameterIndex, Reader value, long length) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setCharacterStream(int, Reader, long)");
}
public void setCharacterStream(int parameterIndex, Reader value) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setCharacterStream(int, Reader)");
}
public void setBinaryStream(int parameterIndex, InputStream value, long length) throws SQLException
{
if (length > Integer.MAX_VALUE)
{
throw new PSQLException(GT.tr("Object is too large to send over the protocol."), PSQLState.NUMERIC_CONSTANT_OUT_OF_RANGE);
}
preparedParameters.setBytea(parameterIndex, value, (int)length);
}
public void setBinaryStream(int parameterIndex, InputStream value) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setBinaryStream(int, InputStream)");
}
public void setAsciiStream(int parameterIndex, InputStream value, long length) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setAsciiStream(int, InputStream, long)");
}
public void setAsciiStream(int parameterIndex, InputStream value) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setAsciiStream(int, InputStream)");
}
public void setNClob(int parameterIndex, NClob value) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setNClob(int, NClob)");
}
public void setClob(int parameterIndex, Reader reader, long length) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setClob(int, Reader, long)");
}
public void setClob(int parameterIndex, Reader reader) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setClob(int, Reader)");
}
public void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setBlob(int, InputStream, long)");
}
public void setBlob(int parameterIndex, InputStream inputStream) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setBlob(int, InputStream)");
}
public void setNClob(int parameterIndex, Reader reader, long length) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setNClob(int, Reader, long)");
}
public void setNClob(int parameterIndex, Reader reader) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setNClob(int, Reader)");
}
public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException
{
checkClosed();
if (xmlObject == null || xmlObject.getString() == null)
setNull(parameterIndex, Types.SQLXML);
else
setString(parameterIndex, xmlObject.getString(), Oid.XML);
}
public void setPoolable(boolean poolable) throws SQLException
{
checkClosed();
this.poolable = poolable;
}
public boolean isPoolable() throws SQLException
{
checkClosed();
return poolable;
}
public RowId getRowId(int parameterIndex) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getRowId(int)");
}
public RowId getRowId(String parameterName) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getRowId(String)");
}
public void setRowId(String parameterName, RowId x) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setRowId(String, RowId)");
}
public void setNString(String parameterName, String value) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setNString(String, String)");
}
public void setNCharacterStream(String parameterName, Reader value, long length) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setNCharacterStream(String, Reader, long)");
}
public void setNCharacterStream(String parameterName, Reader value) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setNCharacterStream(String, Reader)");
}
public void setCharacterStream(String parameterName, Reader value, long length) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setCharacterStream(String, Reader, long)");
}
public void setCharacterStream(String parameterName, Reader value) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setCharacterStream(String, Reader)");
}
public void setBinaryStream(String parameterName, InputStream value, long length) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setBinaryStream(String, InputStream, long)");
}
public void setBinaryStream(String parameterName, InputStream value) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setBinaryStream(String, InputStream)");
}
public void setAsciiStream(String parameterName, InputStream value, long length) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setAsciiStream(String, InputStream, long)");
}
public void setAsciiStream(String parameterName, InputStream value) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setAsciiStream(String, InputStream)");
}
public void setNClob(String parameterName, NClob value) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setNClob(String, NClob)");
}
public void setClob(String parameterName, Reader reader, long length) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setClob(String, Reader, long)");
}
public void setClob(String parameterName, Reader reader) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setClob(String, Reader)");
}
public void setBlob(String parameterName, InputStream inputStream, long length) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setBlob(String, InputStream, long)");
}
public void setBlob(String parameterName, InputStream inputStream) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setBlob(String, InputStream)");
}
public void setNClob(String parameterName, Reader reader, long length) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setNClob(String, Reader, long)");
}
public void setNClob(String parameterName, Reader reader) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setNClob(String, Reader)");
}
public NClob getNClob(int parameterIndex) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getNClob(int)");
}
public NClob getNClob(String parameterName) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getNClob(String)");
}
public void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setSQLXML(String, SQLXML)");
}
public SQLXML getSQLXML(int parameterIndex) throws SQLException
{
checkClosed();
checkIndex(parameterIndex, Types.SQLXML, "SQLXML");
return (SQLXML)callResult[parameterIndex - 1];
}
public SQLXML getSQLXML(String parameterIndex) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getSQLXML(String)");
}
public String getNString(int parameterIndex) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getNString(int)");
}
public String getNString(String parameterName) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getNString(String)");
}
public Reader getNCharacterStream(int parameterIndex) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getNCharacterStream(int)");
}
public Reader getNCharacterStream(String parameterName) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getNCharacterStream(String)");
}
public Reader getCharacterStream(int parameterIndex) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getCharacterStream(int)");
}
public Reader getCharacterStream(String parameterName) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getCharacterStream(String)");
}
public void setBlob(String parameterName, Blob x) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setBlob(String, Blob)");
}
public void setClob(String parameterName, Clob x) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "setClob(String, Clob)");
}
public boolean isWrapperFor(Class iface) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "isWrapperFor(Class)");
}
public T unwrap(Class iface) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "unwrap(Class)");
}
public java.util.logging.Logger getParentLogger() throws SQLFeatureNotSupportedException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getParentLogger()");
}
public void closeOnCompletion() throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "closeOnCompletion()");
}
public boolean isCloseOnCompletion() throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "isCloseOnCompletion()");
}
public T getObject(int parameterIndex, Class type) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getObject(int, Class)");
}
public T getObject(String parameterName, Class type) throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "getObject(String, Class)");
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc4/Jdbc4Array.java 0000664 0000000 0000000 00000002717 12050675701 0024417 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc4;
import java.util.Map;
import org.postgresql.core.*;
import java.sql.SQLException;
import java.sql.ResultSet;
public class Jdbc4Array extends org.postgresql.jdbc2.AbstractJdbc2Array implements java.sql.Array
{
public Jdbc4Array(BaseConnection conn, int oid, String fieldString) throws SQLException
{
super(conn, oid, fieldString);
}
public Jdbc4Array(BaseConnection conn, int oid, byte[] fieldBytes) throws SQLException
{
super(conn, oid, fieldBytes);
}
public Object getArray(Map < String, Class < ? >> map) throws SQLException
{
return getArrayImpl(map);
}
public Object getArray(long index, int count, Map < String, Class < ? >> map) throws SQLException
{
return getArrayImpl(index, count, map);
}
public ResultSet getResultSet(Map < String, Class < ? >> map) throws SQLException
{
return getResultSetImpl(map);
}
public ResultSet getResultSet(long index, int count, Map < String, Class < ? >> map) throws SQLException
{
return getResultSetImpl(index, count, map);
}
public void free() throws SQLException
{
throw org.postgresql.Driver.notImplemented(this.getClass(), "free()");
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc4/Jdbc4Blob.java 0000664 0000000 0000000 00000000745 12050675701 0024216 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc4;
import java.sql.*;
public class Jdbc4Blob extends AbstractJdbc4Blob implements java.sql.Blob
{
public Jdbc4Blob(org.postgresql.core.BaseConnection conn, long oid) throws SQLException
{
super(conn, oid);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc4/Jdbc4CallableStatement.java 0000664 0000000 0000000 00000002261 12050675701 0026717 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc4;
import java.sql.*;
import java.util.Map;
class Jdbc4CallableStatement extends Jdbc4PreparedStatement implements CallableStatement
{
Jdbc4CallableStatement(Jdbc4Connection connection, String sql, int rsType, int rsConcurrency, int rsHoldability) throws SQLException
{
super(connection, sql, true, rsType, rsConcurrency, rsHoldability);
if ( !connection.haveMinimumServerVersion("8.1") || connection.getProtocolVersion() == 2)
{
// if there is no out parameter before the function determined by modifyJdbcCall then do not
// set adjustIndex to true
adjustIndex = outParmBeforeFunc;
}
}
public Object getObject(int i, Map < String, Class < ? >> map) throws SQLException
{
return getObjectImpl(i, map);
}
public Object getObject(String s, Map < String, Class < ? >> map) throws SQLException
{
return getObjectImpl(s, map);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc4/Jdbc4Clob.java 0000664 0000000 0000000 00000000732 12050675701 0024213 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc4;
public class Jdbc4Clob extends AbstractJdbc4Clob implements java.sql.Clob
{
public Jdbc4Clob(org.postgresql.core.BaseConnection conn, long oid) throws java.sql.SQLException
{
super(conn, oid);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc4/Jdbc4Connection.java 0000664 0000000 0000000 00000004463 12050675701 0025440 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc4;
import java.util.Map;
import java.util.Properties;
import java.sql.SQLException;
import org.postgresql.util.HostSpec;
/**
* This class implements the java.sql.Connection interface for JDBC4.
* However most of the implementation is really done in
* org.postgresql.jdbc4.AbstractJdbc4Connection or one of it's parents
*/
public class Jdbc4Connection extends AbstractJdbc4Connection implements java.sql.Connection
{
public Jdbc4Connection(HostSpec[] hostSpecs, String user, String database, Properties info, String url) throws SQLException {
super(hostSpecs, user, database, info, url);
}
public java.sql.Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException
{
checkClosed();
Jdbc4Statement s = new Jdbc4Statement(this, resultSetType, resultSetConcurrency, resultSetHoldability);
s.setPrepareThreshold(getPrepareThreshold());
return s;
}
public java.sql.PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException
{
checkClosed();
Jdbc4PreparedStatement s = new Jdbc4PreparedStatement(this, sql, resultSetType, resultSetConcurrency, resultSetHoldability);
s.setPrepareThreshold(getPrepareThreshold());
return s;
}
public java.sql.CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException
{
checkClosed();
Jdbc4CallableStatement s = new Jdbc4CallableStatement(this, sql, resultSetType, resultSetConcurrency, resultSetHoldability);
s.setPrepareThreshold(getPrepareThreshold());
return s;
}
public java.sql.DatabaseMetaData getMetaData() throws SQLException
{
checkClosed();
if (metadata == null)
metadata = new Jdbc4DatabaseMetaData(this);
return metadata;
}
public void setTypeMap(Map < String, Class < ? >> map) throws SQLException
{
setTypeMapImpl(map);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc4/Jdbc4DatabaseMetaData.java 0000664 0000000 0000000 00000000713 12050675701 0026440 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc4;
public class Jdbc4DatabaseMetaData extends AbstractJdbc4DatabaseMetaData implements java.sql.DatabaseMetaData
{
public Jdbc4DatabaseMetaData(Jdbc4Connection conn)
{
super(conn);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc4/Jdbc4ParameterMetaData.java 0000664 0000000 0000000 00000001062 12050675701 0026652 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2005-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc4;
import java.sql.ParameterMetaData;
import org.postgresql.core.BaseConnection;
public class Jdbc4ParameterMetaData extends AbstractJdbc4ParameterMetaData implements ParameterMetaData {
public Jdbc4ParameterMetaData(BaseConnection connection, int oids[])
{
super(connection, oids);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc4/Jdbc4PreparedStatement.java 0000664 0000000 0000000 00000001516 12050675701 0026764 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc4;
import java.sql.*;
class Jdbc4PreparedStatement extends Jdbc4Statement implements PreparedStatement
{
Jdbc4PreparedStatement(Jdbc4Connection connection, String sql, int rsType, int rsConcurrency, int rsHoldability) throws SQLException
{
this(connection, sql, false, rsType, rsConcurrency, rsHoldability);
}
protected Jdbc4PreparedStatement(Jdbc4Connection connection, String sql, boolean isCallable, int rsType, int rsConcurrency, int rsHoldability) throws SQLException
{
super(connection, sql, isCallable, rsType, rsConcurrency, rsHoldability);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc4/Jdbc4ResultSet.java 0000664 0000000 0000000 00000003707 12050675701 0025273 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc4;
import java.sql.*;
import java.util.List;
import java.util.Map;
import org.postgresql.core.*;
/**
* This class implements the java.sql.ResultSet interface for JDBC4.
* However most of the implementation is really done in
* org.postgresql.jdbc4.AbstractJdbc4ResultSet or one of it's parents
*/
public class Jdbc4ResultSet extends AbstractJdbc4ResultSet implements java.sql.ResultSet
{
Jdbc4ResultSet(Query originalQuery, BaseStatement statement, Field[] fields, List tuples, ResultCursor cursor,
int maxRows, int maxFieldSize, int rsType, int rsConcurrency, int rsHoldability) throws SQLException
{
super(originalQuery, statement, fields, tuples, cursor, maxRows, maxFieldSize, rsType, rsConcurrency, rsHoldability);
}
protected java.sql.ResultSetMetaData createMetaData() throws SQLException
{
return new Jdbc4ResultSetMetaData(connection, fields);
}
protected java.sql.Clob makeClob(long oid) throws SQLException
{
return new Jdbc4Clob(connection, oid);
}
protected java.sql.Blob makeBlob(long oid) throws SQLException
{
return new Jdbc4Blob(connection, oid);
}
protected Array makeArray(int oid, byte[] value) throws SQLException
{
return new Jdbc4Array(connection, oid, value);
}
protected Array makeArray(int oid, String value) throws SQLException
{
return new Jdbc4Array(connection, oid, value);
}
public Object getObject(String s, Map < String, Class < ? >> map) throws SQLException
{
return getObjectImpl(s, map);
}
public Object getObject(int i, Map < String, Class < ? >> map) throws SQLException
{
return getObjectImpl(i, map);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc4/Jdbc4ResultSetMetaData.java 0000664 0000000 0000000 00000001021 12050675701 0026657 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc4;
import org.postgresql.core.*;
public class Jdbc4ResultSetMetaData extends AbstractJdbc4ResultSetMetaData implements java.sql.ResultSetMetaData
{
public Jdbc4ResultSetMetaData(BaseConnection connection, Field[] fields)
{
super(connection, fields);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc4/Jdbc4SQLXML.java 0000664 0000000 0000000 00000025043 12050675701 0024356 0 ustar 00root root 0000000 0000000 package org.postgresql.jdbc4;
import org.postgresql.util.GT;
import org.postgresql.util.PSQLState;
import org.postgresql.util.PSQLException;
import org.postgresql.core.BaseConnection;
import java.io.*;
import java.sql.SQLXML;
import java.sql.SQLException;
import javax.xml.transform.Source;
import javax.xml.transform.Result;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.dom.DOMResult;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.TransformerException;
import javax.xml.transform.sax.SAXSource;
import javax.xml.transform.sax.SAXResult;
import org.xml.sax.InputSource;
import org.xml.sax.ErrorHandler;
import org.xml.sax.SAXParseException;
import javax.xml.transform.sax.SAXTransformerFactory;
import javax.xml.transform.sax.TransformerHandler;
import javax.xml.transform.stream.StreamSource;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stax.StAXSource;
import javax.xml.transform.stax.StAXResult;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.XMLStreamReader;
import javax.xml.stream.XMLStreamWriter;
import javax.xml.stream.XMLStreamException;
public class Jdbc4SQLXML implements SQLXML {
private final BaseConnection _conn;
private String _data; // The actual data contained.
private boolean _initialized; // Has someone assigned the data for this object?
private boolean _active; // Is anyone in the process of loading data into us?
private boolean _freed;
private ByteArrayOutputStream _byteArrayOutputStream;
private StringWriter _stringWriter;
private DOMResult _domResult;
public Jdbc4SQLXML(BaseConnection conn)
{
this(conn, null, false);
}
public Jdbc4SQLXML(BaseConnection conn, String data)
{
this(conn, data, true);
}
private Jdbc4SQLXML(BaseConnection conn, String data, boolean initialized)
{
_conn = conn;
_data = data;
_initialized = initialized;
_active = false;
_freed = false;
}
public synchronized void free()
{
_freed = true;
_data = null;
}
public synchronized InputStream getBinaryStream() throws SQLException
{
checkFreed();
ensureInitialized();
if (_data == null)
return null;
try {
return new ByteArrayInputStream(_conn.getEncoding().encode(_data));
} catch (IOException ioe) {
// This should be a can't happen exception. We just
// decoded this data, so it would be surprising that
// we couldn't encode it.
// For this reason don't make it translatable.
throw new PSQLException("Failed to re-encode xml data.", PSQLState.DATA_ERROR, ioe);
}
}
public synchronized Reader getCharacterStream() throws SQLException
{
checkFreed();
ensureInitialized();
if (_data == null)
return null;
return new StringReader(_data);
}
// We must implement this unsafely because that's what the
// interface requires. Because it says we're returning T
// which is unknown, none of the return values can satisfy it
// as Java isn't going to understand the if statements that
// ensure they are the same.
//
public synchronized Source getSource(Class sourceClass) throws SQLException
{
checkFreed();
ensureInitialized();
if (_data == null)
return null;
try {
if (sourceClass == null || DOMSource.class.equals(sourceClass))
{
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
builder.setErrorHandler(new NonPrintingErrorHandler());
InputSource input = new InputSource(new StringReader(_data));
return new DOMSource(builder.parse(input));
}
else if (SAXSource.class.equals(sourceClass))
{
InputSource is = new InputSource(new StringReader(_data));
return new SAXSource(is);
}
else if (StreamSource.class.equals(sourceClass))
{
return new StreamSource(new StringReader(_data));
}
else if (StAXSource.class.equals(sourceClass))
{
XMLInputFactory xif = XMLInputFactory.newInstance();
XMLStreamReader xsr = xif.createXMLStreamReader(new StringReader(_data));
return new StAXSource(xsr);
}
} catch (Exception e) {
throw new PSQLException(GT.tr("Unable to decode xml data."), PSQLState.DATA_ERROR, e);
}
throw new PSQLException(GT.tr("Unknown XML Source class: {0}", sourceClass), PSQLState.INVALID_PARAMETER_TYPE);
}
public synchronized String getString() throws SQLException
{
checkFreed();
ensureInitialized();
return _data;
}
public synchronized OutputStream setBinaryStream() throws SQLException
{
checkFreed();
initialize();
_active = true;
_byteArrayOutputStream = new ByteArrayOutputStream();
return _byteArrayOutputStream;
}
public synchronized Writer setCharacterStream() throws SQLException
{
checkFreed();
initialize();
_stringWriter = new StringWriter();
return _stringWriter;
}
public synchronized Result setResult(Class resultClass) throws SQLException
{
checkFreed();
initialize();
if (resultClass == null || DOMResult.class.equals(resultClass)) {
_domResult = new DOMResult();
_active = true;
return _domResult;
} else if (SAXResult.class.equals(resultClass)) {
try {
SAXTransformerFactory transformerFactory = (SAXTransformerFactory)SAXTransformerFactory.newInstance();
TransformerHandler transformerHandler = transformerFactory.newTransformerHandler();
_stringWriter = new StringWriter();
transformerHandler.setResult(new StreamResult(_stringWriter));
_active = true;
return new SAXResult(transformerHandler);
} catch (TransformerException te) {
throw new PSQLException(GT.tr("Unable to create SAXResult for SQLXML."), PSQLState.UNEXPECTED_ERROR, te);
}
} else if (StreamResult.class.equals(resultClass)) {
_stringWriter = new StringWriter();
_active = true;
return new StreamResult(_stringWriter);
} else if (StAXResult.class.equals(resultClass)) {
_stringWriter = new StringWriter();
try {
XMLOutputFactory xof = XMLOutputFactory.newInstance();
XMLStreamWriter xsw = xof.createXMLStreamWriter(_stringWriter);
_active = true;
return new StAXResult(xsw);
} catch (XMLStreamException xse) {
throw new PSQLException(GT.tr("Unable to create StAXResult for SQLXML"), PSQLState.UNEXPECTED_ERROR, xse);
}
}
throw new PSQLException(GT.tr("Unknown XML Result class: {0}", resultClass), PSQLState.INVALID_PARAMETER_TYPE);
}
public synchronized void setString(String value) throws SQLException
{
checkFreed();
initialize();
_data = value;
}
private void checkFreed() throws SQLException
{
if (_freed) {
throw new PSQLException(GT.tr("This SQLXML object has already been freed."), PSQLState.OBJECT_NOT_IN_STATE);
}
}
private void ensureInitialized() throws SQLException
{
if (!_initialized) {
throw new PSQLException(GT.tr("This SQLXML object has not been initialized, so you cannot retrieve data from it."), PSQLState.OBJECT_NOT_IN_STATE);
}
// Is anyone loading data into us at the moment?
if (!_active)
return;
if (_byteArrayOutputStream != null) {
try {
_data = _conn.getEncoding().decode(_byteArrayOutputStream.toByteArray());
} catch (IOException ioe) {
throw new PSQLException(GT.tr("Failed to convert binary xml data to encoding: {0}.", _conn.getEncoding().name()), PSQLState.DATA_ERROR, ioe);
} finally {
_byteArrayOutputStream = null;
_active = false;
}
} else if (_stringWriter != null) {
// This is also handling the work for Stream, SAX, and StAX Results
// as they will use the same underlying stringwriter variable.
//
_data = _stringWriter.toString();
_stringWriter = null;
_active = false;
} else if (_domResult != null) {
// Copy the content from the result to a source
// and use the identify transform to get it into a
// friendlier result format.
try {
TransformerFactory factory = TransformerFactory.newInstance();
Transformer transformer = factory.newTransformer();
DOMSource domSource = new DOMSource(_domResult.getNode());
StringWriter stringWriter = new StringWriter();
StreamResult streamResult = new StreamResult(stringWriter);
transformer.transform(domSource, streamResult);
_data = stringWriter.toString();
} catch (TransformerException te) {
throw new PSQLException(GT.tr("Unable to convert DOMResult SQLXML data to a string."), PSQLState.DATA_ERROR, te);
}
finally {
_domResult = null;
_active = false;
}
}
}
private void initialize() throws SQLException
{
if (_initialized) {
throw new PSQLException(GT.tr("This SQLXML object has already been initialized, so you cannot manipulate it further."), PSQLState.OBJECT_NOT_IN_STATE);
}
_initialized = true;
}
// Don't clutter System.err with errors the user can't silence.
// If something bad really happens an exception will be thrown.
static class NonPrintingErrorHandler implements ErrorHandler
{
public void error(SAXParseException e) { }
public void fatalError(SAXParseException e) { }
public void warning(SAXParseException e) { }
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/jdbc4/Jdbc4Statement.java 0000664 0000000 0000000 00000003352 12050675701 0025301 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.jdbc4;
import java.sql.*;
import java.util.List;
import org.postgresql.core.*;
/**
* This class implements the java.sql.Statement interface for JDBC4.
* However most of the implementation is really done in
* org.postgresql.jdbc4.AbstractJdbc4Statement or one of it's parents
*/
class Jdbc4Statement extends AbstractJdbc4Statement implements Statement
{
Jdbc4Statement (Jdbc4Connection c, int rsType, int rsConcurrency, int rsHoldability) throws SQLException
{
super(c, rsType, rsConcurrency, rsHoldability);
}
protected Jdbc4Statement(Jdbc4Connection connection, String sql, boolean isCallable, int rsType, int rsConcurrency, int rsHoldability) throws SQLException
{
super(connection, sql, isCallable, rsType, rsConcurrency, rsHoldability);
}
public ResultSet createResultSet (Query originalQuery, Field[] fields, List tuples, ResultCursor cursor)
throws SQLException
{
Jdbc4ResultSet newResult = new Jdbc4ResultSet(originalQuery, this, fields, tuples, cursor,
getMaxRows(), getMaxFieldSize(),
getResultSetType(), getResultSetConcurrency(), getResultSetHoldability());
newResult.setFetchSize(getFetchSize());
newResult.setFetchDirection(getFetchDirection());
return newResult;
}
public ParameterMetaData createParameterMetaData(BaseConnection conn, int oids[]) throws SQLException
{
return new Jdbc4ParameterMetaData(conn, oids);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/largeobject/ 0000775 0000000 0000000 00000000000 12050675701 0023113 5 ustar 00root root 0000000 0000000 postgresql-jdbc-9.2-1002.src/org/postgresql/largeobject/BlobInputStream.java 0000664 0000000 0000000 00000012224 12050675701 0027031 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2003-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.largeobject;
import java.io.InputStream;
import java.io.IOException;
import java.sql.SQLException;
/**
* This is an implementation of an InputStream from a large object.
*/
public class BlobInputStream extends InputStream
{
/**
* The parent LargeObject
*/
private LargeObject lo;
/**
* Buffer used to improve performance
*/
private byte[] buffer;
/**
* Position within buffer
*/
private int bpos;
/**
* The buffer size
*/
private int bsize;
/**
* The mark position
*/
private int mpos = 0;
/**
* @param lo LargeObject to read from
*/
public BlobInputStream(LargeObject lo)
{
this(lo, 1024);
}
/**
* @param lo LargeObject to read from
* @param bsize buffer size
*/
public BlobInputStream(LargeObject lo, int bsize)
{
this.lo = lo;
buffer = null;
bpos = 0;
this.bsize = bsize;
}
/**
* The minimum required to implement input stream
*/
public int read() throws java.io.IOException
{
checkClosed();
try
{
if (buffer == null || bpos >= buffer.length)
{
buffer = lo.read(bsize);
bpos = 0;
}
// Handle EOF
if (bpos >= buffer.length)
{
return -1;
}
int ret = (buffer[bpos] & 0x7F);
if ((buffer[bpos] &0x80) == 0x80)
{
ret |= 0x80;
}
bpos++;
return ret;
}
catch (SQLException se)
{
throw new IOException(se.toString());
}
}
/**
* Closes this input stream and releases any system resources associated
* with the stream.
*
*
The close method of InputStream does
* nothing.
*
* @exception IOException if an I/O error occurs.
*/
public void close() throws IOException
{
if (lo != null) {
try
{
lo.close();
lo = null;
}
catch (SQLException se)
{
throw new IOException(se.toString());
}
}
}
/**
* Marks the current position in this input stream. A subsequent call to
* the reset method repositions this stream at the last marked
* position so that subsequent reads re-read the same bytes.
*
*
The readlimit arguments tells this input stream to
* allow that many bytes to be read before the mark position gets
* invalidated.
*
*
The general contract of mark is that, if the method
* markSupported returns true, the stream somehow
* remembers all the bytes read after the call to mark and
* stands ready to supply those same bytes again if and whenever the method
* reset is called. However, the stream is not required to
* remember any data at all if more than readlimit bytes are
* read from the stream before reset is called.
*
*
Marking a closed stream should not have any effect on the stream.
*
* @param readlimit the maximum limit of bytes that can be read before
* the mark position becomes invalid.
* @see java.io.InputStream#reset()
*/
public synchronized void mark(int readlimit)
{
try
{
mpos = lo.tell();
}
catch (SQLException se)
{
// Can't throw this because mark API doesn't allow it.
// throw new IOException(se.toString());
}
}
/**
* Repositions this stream to the position at the time the
* mark method was last called on this input stream.
* NB: If mark is not called we move to the begining.
* @see java.io.InputStream#mark(int)
* @see java.io.IOException
*/
public synchronized void reset()
throws IOException
{
checkClosed();
try
{
lo.seek(mpos);
}
catch (SQLException se)
{
throw new IOException(se.toString());
}
}
/**
* Tests if this input stream supports the mark and
* reset methods. The markSupported method of
* InputStream returns false.
*
* @return true if this true type supports the mark and reset
* method; false otherwise.
* @see java.io.InputStream#mark(int)
* @see java.io.InputStream#reset()
*/
public boolean markSupported()
{
return true;
}
private void checkClosed() throws IOException
{
if (lo == null)
throw new IOException("BlobOutputStream is closed");
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/largeobject/BlobOutputStream.java 0000664 0000000 0000000 00000007477 12050675701 0027250 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2003-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.largeobject;
import java.io.IOException;
import java.io.OutputStream;
import java.sql.SQLException;
/**
* This implements a basic output stream that writes to a LargeObject
*/
public class BlobOutputStream extends OutputStream
{
/**
* The parent LargeObject
*/
private LargeObject lo;
/**
* Buffer
*/
private byte buf[];
/**
* Size of the buffer (default 1K)
*/
private int bsize;
/**
* Position within the buffer
*/
private int bpos;
/**
* Create an OutputStream to a large object
* @param lo LargeObject
*/
public BlobOutputStream(LargeObject lo)
{
this(lo, 1024);
}
/**
* Create an OutputStream to a large object
* @param lo LargeObject
* @param bsize The size of the buffer used to improve performance
*/
public BlobOutputStream(LargeObject lo, int bsize)
{
this.lo = lo;
this.bsize = bsize;
buf = new byte[bsize];
bpos = 0;
}
public void write(int b) throws java.io.IOException
{
checkClosed();
try
{
if (bpos >= bsize)
{
lo.write(buf);
bpos = 0;
}
buf[bpos++] = (byte)b;
}
catch (SQLException se)
{
throw new IOException(se.toString());
}
}
public void write(byte[] buf, int off, int len) throws java.io.IOException
{
checkClosed();
try
{
// If we have any internally buffered data, send it first
if ( bpos > 0 )
flush();
if ( off == 0 && len == buf.length )
lo.write(buf); // save a buffer creation and copy since full buffer written
else
lo.write(buf, off, len);
}
catch (SQLException se)
{
throw new IOException(se.toString());
}
}
/**
* Flushes this output stream and forces any buffered output bytes
* to be written out. The general contract of flush is
* that calling it is an indication that, if any bytes previously
* written have been buffered by the implementation of the output
* stream, such bytes should immediately be written to their
* intended destination.
*
* @exception IOException if an I/O error occurs.
*/
public void flush() throws IOException
{
checkClosed();
try
{
if (bpos > 0)
lo.write(buf, 0, bpos);
bpos = 0;
}
catch (SQLException se)
{
throw new IOException(se.toString());
}
}
/**
* Closes this output stream and releases any system resources
* associated with this stream. The general contract of close
* is that it closes the output stream. A closed stream cannot perform
* output operations and cannot be reopened.
*
* The close method of OutputStream does nothing.
*
* @exception IOException if an I/O error occurs.
*/
public void close() throws IOException
{
if (lo != null) {
try
{
flush();
lo.close();
lo = null;
}
catch (SQLException se)
{
throw new IOException(se.toString());
}
}
}
private void checkClosed() throws IOException
{
if (lo == null)
throw new IOException("BlobOutputStream is closed");
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/largeobject/LargeObject.java 0000664 0000000 0000000 00000024412 12050675701 0026142 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2003-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.largeobject;
import java.io.InputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.sql.SQLException;
import org.postgresql.util.PSQLException;
import org.postgresql.util.PSQLState;
import org.postgresql.fastpath.Fastpath;
import org.postgresql.fastpath.FastpathArg;
/**
* This class provides the basic methods required to run the interface, plus
* a pair of methods that provide InputStream and OutputStream classes
* for this object.
*
*
Normally, client code would use the getAsciiStream, getBinaryStream,
* or getUnicodeStream methods in ResultSet, or setAsciiStream,
* setBinaryStream, or setUnicodeStream methods in PreparedStatement to
* access Large Objects.
*
*
However, sometimes lower level access to Large Objects are required,
* that are not supported by the JDBC specification.
*
*
Refer to org.postgresql.largeobject.LargeObjectManager on how to gain access
* to a Large Object, or how to create one.
*
* @see org.postgresql.largeobject.LargeObjectManager
* @see java.sql.ResultSet#getAsciiStream
* @see java.sql.ResultSet#getBinaryStream
* @see java.sql.ResultSet#getUnicodeStream
* @see java.sql.PreparedStatement#setAsciiStream
* @see java.sql.PreparedStatement#setBinaryStream
* @see java.sql.PreparedStatement#setUnicodeStream
*
*/
public class LargeObject
{
/**
* Indicates a seek from the begining of a file
*/
public static final int SEEK_SET = 0;
/**
* Indicates a seek from the current position
*/
public static final int SEEK_CUR = 1;
/**
* Indicates a seek from the end of a file
*/
public static final int SEEK_END = 2;
private final Fastpath fp; // Fastpath API to use
private final long oid; // OID of this object
private final int mode; // read/write mode of this object
private final int fd; // the descriptor of the open large object
private BlobOutputStream os; // The current output stream
private boolean closed = false; // true when we are closed
/**
* This opens a large object.
*
*
If the object does not exist, then an SQLException is thrown.
*
* @param fp FastPath API for the connection to use
* @param oid of the Large Object to open
* @param mode Mode of opening the large object
* (defined in LargeObjectManager)
* @exception SQLException if a database-access error occurs.
* @see org.postgresql.largeobject.LargeObjectManager
*/
protected LargeObject(Fastpath fp, long oid, int mode) throws SQLException
{
this.fp = fp;
this.oid = oid;
this.mode = mode;
FastpathArg args[] = new FastpathArg[2];
args[0] = Fastpath.createOIDArg(oid);
args[1] = new FastpathArg(mode);
this.fd = fp.getInteger("lo_open", args);
}
public LargeObject copy() throws SQLException
{
return new LargeObject(fp, oid, mode);
}
/* Release large object resources during garbage cleanup.
*
* This code used to call close() however that was problematic
* because the scope of the fd is a transaction, thus if commit
* or rollback was called before garbage collection ran then
* the call to close would error out with an invalid large object
* handle. So this method now does nothing and lets the server
* handle cleanup when it ends the transaction.
*
* protected void finalize() throws SQLException
* {
* }
*/
/**
* @return the OID of this LargeObject
* @deprecated As of 8.3, replaced by {@link #getLongOID()}
*/
public int getOID()
{
return (int)oid;
}
/**
* @return the OID of this LargeObject
*/
public long getLongOID()
{
return oid;
}
/**
* This method closes the object. You must not call methods in this
* object after this is called.
* @exception SQLException if a database-access error occurs.
*/
public void close() throws SQLException
{
if (!closed)
{
// flush any open output streams
if (os != null)
{
try
{
// we can't call os.close() otherwise we go into an infinite loop!
os.flush();
}
catch (IOException ioe)
{
throw new PSQLException("Exception flushing output stream",
PSQLState.DATA_ERROR, ioe);
}
finally
{
os = null;
}
}
// finally close
FastpathArg args[] = new FastpathArg[1];
args[0] = new FastpathArg(fd);
fp.fastpath("lo_close", false, args); // true here as we dont care!!
closed = true;
}
}
/**
* Reads some data from the object, and return as a byte[] array
*
* @param len number of bytes to read
* @return byte[] array containing data read
* @exception SQLException if a database-access error occurs.
*/
public byte[] read(int len) throws SQLException
{
// This is the original method, where the entire block (len bytes)
// is retrieved in one go.
FastpathArg args[] = new FastpathArg[2];
args[0] = new FastpathArg(fd);
args[1] = new FastpathArg(len);
return fp.getData("loread", args);
}
/**
* Reads some data from the object into an existing array
*
* @param buf destination array
* @param off offset within array
* @param len number of bytes to read
* @return the number of bytes actually read
* @exception SQLException if a database-access error occurs.
*/
public int read(byte buf[], int off, int len) throws SQLException
{
byte b[] = read(len);
if (b.length < len)
len = b.length;
System.arraycopy(b, 0, buf, off, len);
return len;
}
/**
* Writes an array to the object
*
* @param buf array to write
* @exception SQLException if a database-access error occurs.
*/
public void write(byte buf[]) throws SQLException
{
FastpathArg args[] = new FastpathArg[2];
args[0] = new FastpathArg(fd);
args[1] = new FastpathArg(buf);
fp.fastpath("lowrite", false, args);
}
/**
* Writes some data from an array to the object
*
* @param buf destination array
* @param off offset within array
* @param len number of bytes to write
* @exception SQLException if a database-access error occurs.
*/
public void write(byte buf[], int off, int len) throws SQLException
{
FastpathArg args[] = new FastpathArg[2];
args[0] = new FastpathArg(fd);
args[1] = new FastpathArg(buf, off, len);
fp.fastpath("lowrite", false, args);
}
/**
* Sets the current position within the object.
*
*
This is similar to the fseek() call in the standard C library. It
* allows you to have random access to the large object.
*
* @param pos position within object
* @param ref Either SEEK_SET, SEEK_CUR or SEEK_END
* @exception SQLException if a database-access error occurs.
*/
public void seek(int pos, int ref) throws SQLException
{
FastpathArg args[] = new FastpathArg[3];
args[0] = new FastpathArg(fd);
args[1] = new FastpathArg(pos);
args[2] = new FastpathArg(ref);
fp.fastpath("lo_lseek", false, args);
}
/**
* Sets the current position within the object.
*
*
This is similar to the fseek() call in the standard C library. It
* allows you to have random access to the large object.
*
* @param pos position within object from begining
* @exception SQLException if a database-access error occurs.
*/
public void seek(int pos) throws SQLException
{
seek(pos, SEEK_SET);
}
/**
* @return the current position within the object
* @exception SQLException if a database-access error occurs.
*/
public int tell() throws SQLException
{
FastpathArg args[] = new FastpathArg[1];
args[0] = new FastpathArg(fd);
return fp.getInteger("lo_tell", args);
}
/**
* This method is inefficient, as the only way to find out the size of
* the object is to seek to the end, record the current position, then
* return to the original position.
*
*
A better method will be found in the future.
*
* @return the size of the large object
* @exception SQLException if a database-access error occurs.
*/
public int size() throws SQLException
{
int cp = tell();
seek(0, SEEK_END);
int sz = tell();
seek(cp, SEEK_SET);
return sz;
}
/**
* Truncates the large object to the given length in bytes.
* If the number of bytes is larger than the current large
* object length, the large object will be filled with zero
* bytes. This method does not modify the current file offset.
*/
public void truncate(int len) throws SQLException
{
FastpathArg args[] = new FastpathArg[2];
args[0] = new FastpathArg(fd);
args[1] = new FastpathArg(len);
fp.getInteger("lo_truncate", args);
}
/**
* Returns an InputStream from this object.
*
*
This InputStream can then be used in any method that requires an
* InputStream.
*
* @exception SQLException if a database-access error occurs.
*/
public InputStream getInputStream() throws SQLException
{
return new BlobInputStream(this, 4096);
}
/**
* Returns an OutputStream to this object.
*
*
This OutputStream can then be used in any method that requires an
* OutputStream.
*
* @exception SQLException if a database-access error occurs.
*/
public OutputStream getOutputStream() throws SQLException
{
if (os == null)
os = new BlobOutputStream(this, 4096);
return os;
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/largeobject/LargeObjectManager.java 0000664 0000000 0000000 00000022733 12050675701 0027441 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2003-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.largeobject;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.postgresql.core.BaseConnection;
import org.postgresql.fastpath.Fastpath;
import org.postgresql.fastpath.FastpathArg;
import org.postgresql.util.PSQLException;
import org.postgresql.util.GT;
import org.postgresql.util.PSQLState;
/**
* This class implements the large object interface to org.postgresql.
*
*
It provides methods that allow client code to create, open and delete
* large objects from the database. When opening an object, an instance of
* org.postgresql.largeobject.LargeObject is returned, and its methods then allow
* access to the object.
*
*
This class can only be created by org.postgresql.Connection
*
*
To get access to this class, use the following segment of code:
*
Normally, client code would use the getAsciiStream, getBinaryStream,
* or getUnicodeStream methods in ResultSet, or setAsciiStream,
* setBinaryStream, or setUnicodeStream methods in PreparedStatement to
* access Large Objects.
*
*
However, sometimes lower level access to Large Objects are required,
* that are not supported by the JDBC specification.
*
*
Refer to org.postgresql.largeobject.LargeObject on how to manipulate the
* contents of a Large Object.
*
* @see java.sql.ResultSet#getAsciiStream
* @see java.sql.ResultSet#getBinaryStream
* @see java.sql.ResultSet#getUnicodeStream
* @see java.sql.PreparedStatement#setAsciiStream
* @see java.sql.PreparedStatement#setBinaryStream
* @see java.sql.PreparedStatement#setUnicodeStream
*/
public class LargeObjectManager
{
// the fastpath api for this connection
private Fastpath fp;
private BaseConnection conn;
/**
* This mode indicates we want to write to an object
*/
public static final int WRITE = 0x00020000;
/**
* This mode indicates we want to read an object
*/
public static final int READ = 0x00040000;
/**
* This mode is the default. It indicates we want read and write access to
* a large object
*/
public static final int READWRITE = READ | WRITE;
/**
* This prevents us being created by mere mortals
*/
private LargeObjectManager()
{
}
/**
* Constructs the LargeObject API.
*
*
Important Notice
* This method should only be called by org.postgresql.Connection
*
*
There should only be one LargeObjectManager per Connection. The
* org.postgresql.Connection class keeps track of the various extension API's
* and it's advised you use those to gain access, and not going direct.
*/
public LargeObjectManager(BaseConnection conn) throws SQLException
{
this.conn = conn;
// We need Fastpath to do anything
this.fp = conn.getFastpathAPI();
// Now get the function oid's for the api
//
// This is an example of Fastpath.addFunctions();
//
String sql;
if (conn.getMetaData().supportsSchemasInTableDefinitions())
{
sql = "SELECT p.proname,p.oid " +
" FROM pg_catalog.pg_proc p, pg_catalog.pg_namespace n " +
" WHERE p.pronamespace=n.oid AND n.nspname='pg_catalog' AND (";
}
else
{
sql = "SELECT proname,oid FROM pg_proc WHERE ";
}
sql += " proname = 'lo_open'" +
" or proname = 'lo_close'" +
" or proname = 'lo_creat'" +
" or proname = 'lo_unlink'" +
" or proname = 'lo_lseek'" +
" or proname = 'lo_tell'" +
" or proname = 'loread'" +
" or proname = 'lowrite'" +
" or proname = 'lo_truncate'";
if (conn.getMetaData().supportsSchemasInTableDefinitions())
{
sql += ")";
}
ResultSet res = conn.createStatement().executeQuery(sql);
if (res == null)
throw new PSQLException(GT.tr("Failed to initialize LargeObject API"), PSQLState.SYSTEM_ERROR);
fp.addFunctions(res);
res.close();
conn.getLogger().debug("Large Object initialised");
}
/**
* This opens an existing large object, based on its OID. This method
* assumes that READ and WRITE access is required (the default).
*
* @param oid of large object
* @return LargeObject instance providing access to the object
* @exception SQLException on error
* @deprecated As of 8.3, replaced by {@link #open(long)}
*/
public LargeObject open(int oid) throws SQLException
{
return open((long)oid);
}
/**
* This opens an existing large object, based on its OID. This method
* assumes that READ and WRITE access is required (the default).
*
* @param oid of large object
* @return LargeObject instance providing access to the object
* @exception SQLException on error
*/
public LargeObject open(long oid) throws SQLException
{
return open(oid, READWRITE);
}
/**
* This opens an existing large object, based on its OID
*
* @param oid of large object
* @param mode mode of open
* @return LargeObject instance providing access to the object
* @exception SQLException on error
* @deprecated As of 8.3, replaced by {@link #open(long, int)}
*/
public LargeObject open(int oid, int mode) throws SQLException
{
return open((long)oid, mode);
}
/**
* This opens an existing large object, based on its OID
*
* @param oid of large object
* @param mode mode of open
* @return LargeObject instance providing access to the object
* @exception SQLException on error
*/
public LargeObject open(long oid, int mode) throws SQLException
{
if (conn.getAutoCommit())
throw new PSQLException(GT.tr("Large Objects may not be used in auto-commit mode."),
PSQLState.NO_ACTIVE_SQL_TRANSACTION);
return new LargeObject(fp, oid, mode);
}
/**
* This creates a large object, returning its OID.
*
*
It defaults to READWRITE for the new object's attributes.
*
* @return oid of new object
* @exception SQLException on error
* @deprecated As of 8.3, replaced by {@link #createLO()}
*/
public int create() throws SQLException
{
return create(READWRITE);
}
/**
* This creates a large object, returning its OID.
*
*
It defaults to READWRITE for the new object's attributes.
*
* @return oid of new object
*/
public long createLO() throws SQLException
{
return createLO(READWRITE);
}
/**
* This creates a large object, returning its OID
*
* @param mode a bitmask describing different attributes of the new object
* @return oid of new object
* @exception SQLException on error
*/
public long createLO(int mode) throws SQLException
{
if (conn.getAutoCommit())
throw new PSQLException(GT.tr("Large Objects may not be used in auto-commit mode."),
PSQLState.NO_ACTIVE_SQL_TRANSACTION);
FastpathArg args[] = new FastpathArg[1];
args[0] = new FastpathArg(mode);
return fp.getOID("lo_creat", args);
}
/**
* This creates a large object, returning its OID
*
* @param mode a bitmask describing different attributes of the new object
* @return oid of new object
* @exception SQLException on error
* @deprecated As of 8.3, replaced by {@link #createLO(int)}
*/
public int create(int mode) throws SQLException
{
long oid = createLO(mode);
return (int)oid;
}
/**
* This deletes a large object.
*
* @param oid describing object to delete
* @exception SQLException on error
*/
public void delete(long oid) throws SQLException
{
FastpathArg args[] = new FastpathArg[1];
args[0] = Fastpath.createOIDArg(oid);
fp.fastpath("lo_unlink", false, args);
}
/**
* This deletes a large object.
*
*
It is identical to the delete method, and is supplied as the C API uses
* unlink.
*
* @param oid describing object to delete
* @exception SQLException on error
* @deprecated As of 8.3, replaced by {@link #unlink(long)}
*/
public void unlink(int oid) throws SQLException
{
delete((long)oid);
}
/**
* This deletes a large object.
*
*
It is identical to the delete method, and is supplied as the C API uses
* unlink.
*
* @param oid describing object to delete
* @exception SQLException on error
*/
public void unlink(long oid) throws SQLException
{
delete(oid);
}
/**
* This deletes a large object.
*
* @param oid describing object to delete
* @exception SQLException on error
* @deprecated As of 8.3, replaced by {@link #delete(long)}
*/
public void delete(int oid) throws SQLException
{
delete((long)oid);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/ssl/ 0000775 0000000 0000000 00000000000 12050675701 0021433 5 ustar 00root root 0000000 0000000 postgresql-jdbc-9.2-1002.src/org/postgresql/ssl/.gitignore 0000664 0000000 0000000 00000000015 12050675701 0023417 0 ustar 00root root 0000000 0000000 MakeSSL.java
postgresql-jdbc-9.2-1002.src/org/postgresql/ssl/MakeSSL.java.in 0000664 0000000 0000000 00000000465 12050675701 0024147 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.ssl;
public class MakeSSL extends @MAKE_SSL_CLASS@
{
}
postgresql-jdbc-9.2-1002.src/org/postgresql/ssl/NonValidatingFactory.java 0000664 0000000 0000000 00000003272 12050675701 0026367 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.ssl;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import java.security.cert.X509Certificate;
import java.security.GeneralSecurityException;
/**
* Provide a SSLSocketFactory that allows SSL connections to be
* made without validating the server's certificate. This is more
* convenient for some applications, but is less secure as it allows
* "man in the middle" attacks.
*/
public class NonValidatingFactory extends WrappedFactory {
/**
* We provide a constructor that takes an unused argument solely
* because the ssl calling code will look for this constructor
* first and then fall back to the no argument constructor, so
* we avoid an exception and additional reflection lookups.
*/
public NonValidatingFactory(String arg) throws GeneralSecurityException {
SSLContext ctx = SSLContext.getInstance("TLS"); // or "SSL" ?
ctx.init(null,
new TrustManager[] { new NonValidatingTM() },
null);
_factory = ctx.getSocketFactory();
}
public static class NonValidatingTM implements X509TrustManager {
public X509Certificate[] getAcceptedIssuers() {
return new X509Certificate[0];
}
public void checkClientTrusted(X509Certificate[] certs, String authType) {
}
public void checkServerTrusted(X509Certificate[] certs, String authType) {
}
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/ssl/WrappedFactory.java 0000664 0000000 0000000 00000003313 12050675701 0025230 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.ssl;
import java.io.IOException;
import java.net.Socket;
import java.net.InetAddress;
import javax.net.ssl.SSLSocketFactory;
/**
* Provide a wrapper to a real SSLSocketFactory delegating all calls
* to the contained instance. A subclass needs only provide a
* constructor for the wrapped SSLSocketFactory.
*/
public abstract class WrappedFactory extends SSLSocketFactory {
protected SSLSocketFactory _factory;
public Socket createSocket(InetAddress host, int port) throws IOException {
return _factory.createSocket(host, port);
}
public Socket createSocket(String host, int port) throws IOException {
return _factory.createSocket(host, port);
}
public Socket createSocket(String host, int port, InetAddress localHost, int localPort) throws IOException {
return _factory.createSocket(host, port, localHost, localPort);
}
public Socket createSocket(InetAddress address, int port, InetAddress localAddress, int localPort) throws IOException {
return _factory.createSocket(address, port, localAddress, localPort);
}
public Socket createSocket(Socket socket, String host, int port, boolean autoClose) throws IOException {
return _factory.createSocket(socket, host, port, autoClose);
}
public String[] getDefaultCipherSuites() {
return _factory.getDefaultCipherSuites();
}
public String[] getSupportedCipherSuites() {
return _factory.getSupportedCipherSuites();
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/ssl/jdbc3/ 0000775 0000000 0000000 00000000000 12050675701 0022420 5 ustar 00root root 0000000 0000000 postgresql-jdbc-9.2-1002.src/org/postgresql/ssl/jdbc3/AbstractJdbc3MakeSSL.java 0000664 0000000 0000000 00000004233 12050675701 0027056 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.ssl.jdbc3;
import java.util.Properties;
import java.io.IOException;
import java.net.Socket;
import java.lang.reflect.Constructor;
import javax.net.ssl.SSLSocketFactory;
import org.postgresql.core.PGStream;
import org.postgresql.core.Logger;
import org.postgresql.util.GT;
import org.postgresql.util.PSQLState;
import org.postgresql.util.PSQLException;
public class AbstractJdbc3MakeSSL {
public static void convert(PGStream stream, Properties info, Logger logger) throws IOException, PSQLException {
logger.debug("converting regular socket connection to ssl");
SSLSocketFactory factory;
// Use the default factory if no specific factory is requested
//
String classname = info.getProperty("sslfactory");
if (classname == null)
{
factory = (SSLSocketFactory)SSLSocketFactory.getDefault();
}
else
{
Object[] args = {info.getProperty("sslfactoryarg")};
Constructor ctor;
Class factoryClass;
try
{
factoryClass = Class.forName(classname);
try
{
ctor = factoryClass.getConstructor(new Class[]{String.class});
}
catch (NoSuchMethodException nsme)
{
ctor = factoryClass.getConstructor((Class[])null);
args = null;
}
factory = (SSLSocketFactory)ctor.newInstance(args);
}
catch (Exception e)
{
throw new PSQLException(GT.tr("The SSLSocketFactory class provided {0} could not be instantiated.", classname), PSQLState.CONNECTION_FAILURE, e);
}
}
Socket newConnection = factory.createSocket(stream.getSocket(), stream.getHostSpec().getHost(), stream.getHostSpec().getPort(), true);
stream.changeSocket(newConnection);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/ssl/jdbc4/ 0000775 0000000 0000000 00000000000 12050675701 0022421 5 ustar 00root root 0000000 0000000 postgresql-jdbc-9.2-1002.src/org/postgresql/ssl/jdbc4/AbstractJdbc4MakeSSL.java 0000664 0000000 0000000 00000013255 12050675701 0027064 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.ssl.jdbc4;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.Properties;
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.SSLSocket;
import javax.net.ssl.SSLSocketFactory;
import org.postgresql.core.Logger;
import org.postgresql.core.PGStream;
import org.postgresql.util.GT;
import org.postgresql.util.PSQLException;
import org.postgresql.util.PSQLState;
public class AbstractJdbc4MakeSSL {
/**
* Instantiates a class using the appropriate constructor.
* If a constructor with a single Propertiesparameter exists, it is
* used. Otherwise, if tryString is true a constructor with
* a single String argument is searched if it fails, or tryString is true
* a no argument constructor is tried.
* @param classname Nam of the class to instantiate
* @param info parameter to pass as Properties
* @param tryString weather to look for a single String argument constructor
* @param stringarg parameter to pass as String
* @return the instantiated class
* @throws ClassNotFoundException
* @throws SecurityException
* @throws NoSuchMethodException
* @throws IllegalArgumentException
* @throws InstantiationException
* @throws IllegalAccessException
* @throws InvocationTargetException
*/
public static Object instantiate(String classname, Properties info, boolean tryString, String stringarg)
throws ClassNotFoundException, SecurityException, NoSuchMethodException, IllegalArgumentException,
InstantiationException, IllegalAccessException, InvocationTargetException
{
Object[] args = {info};
Constructor ctor = null;
Class cls;
cls = Class.forName(classname);
try
{
ctor = cls.getConstructor(new Class[]{Properties.class});
}
catch (NoSuchMethodException nsme)
{
if (tryString)
{
try
{
ctor = cls.getConstructor(new Class[]{String.class});
args = new String[]{stringarg};
}
catch (NoSuchMethodException nsme2)
{
tryString = false;
}
}
if (!tryString)
{
ctor = cls.getConstructor((Class[])null);
args = null;
}
}
return ctor.newInstance(args);
}
public static void convert(PGStream stream, Properties info, Logger logger) throws PSQLException, IOException {
logger.debug("converting regular socket connection to ssl");
SSLSocketFactory factory;
String sslmode = info.getProperty("sslmode");
// Use the default factory if no specific factory is requested
// unless sslmode is set
String classname = info.getProperty("sslfactory");
if (classname == null)
{
//If sslmode is set, use the libp compatible factory
if (sslmode!=null)
{
factory = new LibPQFactory(info);
}
else
{
factory = (SSLSocketFactory)SSLSocketFactory.getDefault();
}
}
else
{
try
{
factory = (SSLSocketFactory)instantiate(classname, info, true, info.getProperty("sslfactoryarg"));
}
catch (Exception e)
{
throw new PSQLException(GT.tr("The SSLSocketFactory class provided {0} could not be instantiated.", classname), PSQLState.CONNECTION_FAILURE, e);
}
}
SSLSocket newConnection;
try
{
newConnection = (SSLSocket)factory.createSocket(stream.getSocket(), stream.getHostSpec().getHost(), stream.getHostSpec().getPort(), true);
newConnection.startHandshake(); //We must invoke manually, otherwise the exceptions are hidden
}
catch (IOException ex) {
if (factory instanceof LibPQFactory)
{ //throw any KeyManager exception
((LibPQFactory)factory).throwKeyManagerException();
}
throw new PSQLException(GT.tr("SSL error: {0}", ex.getMessage()), PSQLState.CONNECTION_FAILURE, ex);
}
String sslhostnameverifier = info.getProperty("sslhostnameverifier");
if (sslhostnameverifier!=null)
{
HostnameVerifier hvn;
try
{
hvn = (HostnameVerifier)instantiate(sslhostnameverifier, info, false, null);
}
catch (Exception e)
{
throw new PSQLException(GT.tr("The HostnameVerifier class provided {0} could not be instantiated.", sslhostnameverifier), PSQLState.CONNECTION_FAILURE, e);
}
if (!hvn.verify(stream.getHostSpec().getHost(), newConnection.getSession()))
{
throw new PSQLException(GT.tr("The hostname {0} could not be verified by hostnameverifier {1}.", new Object[]{stream.getHostSpec().getHost(), sslhostnameverifier}), PSQLState.CONNECTION_FAILURE);
}
} else {
if ("verify-full".equals(sslmode) && factory instanceof LibPQFactory)
{
if (!(((LibPQFactory)factory).verify(stream.getHostSpec().getHost(), newConnection.getSession())))
{
throw new PSQLException(GT.tr("The hostname {0} could not be verified.", stream.getHostSpec().getHost()), PSQLState.CONNECTION_FAILURE);
}
}
}
stream.changeSocket(newConnection);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/ssl/jdbc4/LazyKeyManager.java 0000664 0000000 0000000 00000022113 12050675701 0026146 0 ustar 00root root 0000000 0000000 package org.postgresql.ssl.jdbc4;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.net.Socket;
import java.security.AlgorithmParameters;
import java.security.GeneralSecurityException;
import java.security.Key;
import java.security.KeyFactory;
import java.security.NoSuchAlgorithmException;
import java.security.Principal;
import java.security.PrivateKey;
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.KeySpec;
import java.security.spec.PKCS8EncodedKeySpec;
import java.util.Collection;
import javax.crypto.Cipher;
import javax.crypto.EncryptedPrivateKeyInfo;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;
import javax.net.ssl.X509KeyManager;
import javax.security.auth.callback.Callback;
import javax.security.auth.callback.CallbackHandler;
import javax.security.auth.callback.PasswordCallback;
import javax.security.auth.callback.UnsupportedCallbackException;
import javax.security.auth.x500.X500Principal;
import org.postgresql.util.GT;
import org.postgresql.util.PSQLException;
import org.postgresql.util.PSQLState;
/**
* A Key manager that only loads the keys, if necessary.
*
*/
public class LazyKeyManager implements X509KeyManager {
private X509Certificate[] cert = null;
private PrivateKey key = null;
private String certfile;
private String keyfile;
private CallbackHandler cbh;
private boolean defaultfile;
private PSQLException error = null;
/**
* Constructor. certfile and keyfile can be null, in that case no
* certificate is presented to the server.
* @param certfile
* @param keyfile
* @param cbh
* @param defaultfile
*/
public LazyKeyManager(String certfile, String keyfile, CallbackHandler cbh, boolean defaultfile) {
this.certfile = certfile;
this.keyfile = keyfile;
this.cbh = cbh;
this.defaultfile = defaultfile;
}
/**
* getCertificateChain and getPrivateKey cannot throw exeptions,
* therefore any exception is stored in this.error and can be raised
* by this method
* @throws PSQLException
*/
public void throwKeyManagerException() throws PSQLException
{
if (error!=null) throw error;
}
public String chooseClientAlias(String[] keyType, Principal[] issuers,
Socket socket) {
if (certfile==null)
{
return null;
} else {
if (issuers==null || issuers.length==0)
{ //Postgres 8.4 and earlier do not send the list of accepted certificate authorities
//to the client. See BUG #5468. We only hope, that our certificate will be accepted.
return "user";
} else { //Sending a wrong certificate makes the connection rejected, even, if clientcert=0 in pg_hba.conf.
//therefore we only send our certificate, if the issuer is listed in issuers
X509Certificate[] certchain = getCertificateChain("user");
if (certchain==null)
{
return null;
} else {
X500Principal ourissuer = certchain[certchain.length-1].getIssuerX500Principal();
boolean found = false;
for (int i=0; i -1)
{ //It is Windows
defaultdir = System.getenv("APPDATA")+pathsep+"postgresql"+pathsep;
} else {
defaultdir = System.getProperty("user.home")+pathsep+".postgresql"+pathsep;
}
//Load the client's certificate and key
String sslcertfile = info.getProperty("sslcert");
if (sslcertfile == null)
{ //Fall back to default
defaultfile = true;
sslcertfile = defaultdir + "postgresql.crt";
}
String sslkeyfile = info.getProperty("sslkey");
if (sslkeyfile == null)
{ //Fall back to default
defaultfile = true;
sslkeyfile = defaultdir + "postgresql.pk8";
}
//Determine the callback handler
CallbackHandler cbh;
String sslpasswordcallback = info.getProperty("sslpasswordcallback");
if (sslpasswordcallback != null)
{
try
{
cbh = (CallbackHandler)AbstractJdbc4MakeSSL.instantiate(sslpasswordcallback, info, false, null);
}
catch (Exception e)
{
throw new PSQLException(GT.tr("The password callback class provided {0} could not be instantiated.", sslpasswordcallback), PSQLState.CONNECTION_FAILURE, e);
}
} else {
cbh = new ConsoleCallbackHandler(info.getProperty("sslpassword"));
}
//If the properies are empty, give null to prevent client key selection
km = new LazyKeyManager(("".equals(sslcertfile) ? null : sslcertfile), ("".equals(sslkeyfile) ? null : sslkeyfile), cbh, defaultfile);
TrustManager[] tm;
if("verify-ca".equals(sslmode) || "verify-full".equals(sslmode))
{
//Load the server certificate
TrustManagerFactory tmf = TrustManagerFactory.getInstance("PKIX");
KeyStore ks;
try
{
ks = KeyStore.getInstance("jks");
} catch (KeyStoreException e)
{
throw new NoSuchAlgorithmException("jks KeyStore not available"); //this should never happen
}
String sslrootcertfile = info.getProperty("sslrootcert");
if (sslrootcertfile == null)
{ //Fall back to default
sslrootcertfile = defaultdir + "root.crt";
}
FileInputStream fis;
try
{
fis = new FileInputStream(sslrootcertfile);
} catch (FileNotFoundException ex)
{
throw new PSQLException(GT.tr("Could not open SSL root certificate file {0}.", new Object[]{sslrootcertfile}), PSQLState.CONNECTION_FAILURE, ex);
}
try
{
CertificateFactory cf = CertificateFactory.getInstance("X.509");
//Certificate[] certs = cf.generateCertificates(fis).toArray(new Certificate[]{}); //Does not work in java 1.4
Object[] certs = cf.generateCertificates(fis).toArray(new Certificate[]{});
fis.close();
ks.load(null, null);
for(int i=0; i
J2EE_HOME=
JAVA_HOME=
NO_JAVATEST=Y
LOCAL_CLASSES=
4. In $J2EE_HOME/config/default.properties:
jdbc.drivers=org.postgresql.Driver
jdbc.datasources=jdbc/DB1|jdbc:postgresql://localhost:5432/DB1|jdbc/DB2|jdbc:postgresq://localhost:5432/DB2
Of course, if PostgreSQL is running on a computer different from
the one running the application server, localhost should be changed
to the proper host. Also, 5432 should be changed to whatever port
PostgreSQL is listening on (5432 is the default).
In $J2EE_HOME/bin/userconfig.sh:
Add $CTS_HOME/lib/harness.jar, $CTS_HOME/lib/moo.jar,
$CTS_HOME/lib/util.jar to J2EE_CLASSPATH. Also add the path to
the PostgreSQL JDBC jar to J2EE_CLASSPATH. Set the JAVA_HOME
variable to where you installed the J2SE. You should end up with
something like this:
CTS_HOME=/home/liams/linux/java/jdbccts
J2EE_CLASSPATH=/home/liams/work/inst/postgresql-7.1.2/share/java/postgresql.jar:$CTS_HOME/lib/harness.jar:$CTS_HOME/lib/moo.jar:$CTS_HOME/lib/util.jar
export J2EE_CLASSPATH
JAVA_HOME=/home/liams/linux/java/jdk1.3.1
export JAVA_HOME
In $CTS_HOME/bin/cts.jte:
webServerHost=localhost
webServerPort=8000
servletServerHost=localhost
servletServerPort=8000
5. Start the application server (j2ee):
$ cd $J2EE_HOME
$ bin/j2ee -verbose
The server can be stopped after the tests have finished:
$ cd $J2EE_HOME
$ bin/j2ee -stop
6. Run the JDBC tests:
$ cd $CTS_HOME/tests/jdbc/ee
$ make jdbc-tests
At the time of writing of this document, a great number of tests
in this test suite fail.
9 Credits, feedback
-------------------
The parts of this document describing the PostgreSQL test suite
were originally written by Rene Pijlman. Liam Stewart contributed
the section on the Sun JDBC 2 test suite.
Please send your questions about the JDBC test suites or suggestions
for improvement to the pgsql-jdbc@postgresql.org mailing list.
The source of this document is maintained in
org/postgresql/test/README in CVS. Patches for
improvement can be send to the mailing list
pgsql-jdbc@postgresql.org.
postgresql-jdbc-9.2-1002.src/org/postgresql/test/TestUtil.java 0000664 0000000 0000000 00000030274 12050675701 0024237 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.sql.*;
import java.util.Properties;
import org.postgresql.jdbc2.AbstractJdbc2Connection;
/**
* Utility class for JDBC tests
*/
public class TestUtil
{
/*
* Returns the Test database JDBC URL
*/
public static String getURL()
{
String protocolVersion = "";
if (getProtocolVersion() != 0) {
protocolVersion = "&protocolVersion=" + getProtocolVersion();
}
String binaryTransfer = "";
if (getBinaryTransfer() != null && !getBinaryTransfer().equals("")) {
binaryTransfer = "&binaryTransfer=" + getBinaryTransfer();
}
String receiveBufferSize = "";
if (getReceiveBufferSize() != -1 ){
receiveBufferSize = "&receiveBufferSize="+getReceiveBufferSize();
}
String sendBufferSize = "";
if (getSendBufferSize() != -1 ){
sendBufferSize = "&sendBufferSize="+getSendBufferSize();
}
return "jdbc:postgresql://"
+ getServer() + ":"
+ getPort() + "/"
+ getDatabase()
+ "?prepareThreshold=" + getPrepareThreshold()
+ "&loglevel=" + getLogLevel()
+ protocolVersion
+ binaryTransfer
+ receiveBufferSize
+ sendBufferSize;
}
/*
* Returns the Test server
*/
public static String getServer()
{
return System.getProperty("server", "localhost");
}
/*
* Returns the Test port
*/
public static int getPort()
{
return Integer.parseInt(System.getProperty("port", System.getProperty("def_pgport")));
}
/*
* Returns the server side prepared statement threshold.
*/
public static int getPrepareThreshold()
{
return Integer.parseInt(System.getProperty("preparethreshold", "5"));
}
public static int getProtocolVersion()
{
return Integer.parseInt(System.getProperty("protocolVersion", "0"));
}
/*
* Returns the Test database
*/
public static String getDatabase()
{
return System.getProperty("database");
}
/*
* Returns the Postgresql username
*/
public static String getUser()
{
return System.getProperty("username");
}
/*
* Returns the user's password
*/
public static String getPassword()
{
return System.getProperty("password");
}
/*
* Returns the log level to use
*/
public static int getLogLevel()
{
return Integer.parseInt(System.getProperty("loglevel", "0"));
}
/*
* Returns the binary transfer mode to use
*/
public static String getBinaryTransfer()
{
return System.getProperty("binaryTransfer");
}
public static int getSendBufferSize()
{
return Integer.parseInt(System.getProperty("sendBufferSize", "-1"));
}
public static int getReceiveBufferSize()
{
return Integer.parseInt(System.getProperty("receiveBufferSize","-1"));
}
private static boolean initialized = false;
public static void initDriver() throws Exception
{
synchronized (TestUtil.class) {
if (initialized)
return;
Properties p = new Properties();
try {
p.load(new FileInputStream("build.properties"));
p.load(new FileInputStream("build.local.properties"));
} catch (IOException ex) {
// ignore
}
p.putAll(System.getProperties());
System.getProperties().putAll(p);
if (getLogLevel() > 0) {
// Ant's junit task likes to buffer stdout/stderr and tends to run out of memory.
// So we put debugging output to a file instead.
java.io.Writer output = new java.io.FileWriter("postgresql-jdbc-tests.debug.txt", true);
java.sql.DriverManager.setLogWriter(new java.io.PrintWriter(output,true));
}
org.postgresql.Driver.setLogLevel(getLogLevel()); // Also loads and registers driver.
initialized = true;
}
}
/*
* Helper - opens a connection.
*/
public static java.sql.Connection openDB() throws Exception
{
return openDB(new Properties());
}
/*
* Helper - opens a connection with the allowance for passing
* additional parameters, like "compatible".
*/
public static java.sql.Connection openDB(Properties props) throws Exception
{
initDriver();
props.setProperty("user", getUser());
props.setProperty("password", getPassword());
return DriverManager.getConnection(getURL(), props);
}
/*
* Helper - closes an open connection.
*/
public static void closeDB(Connection con) throws SQLException
{
if (con != null)
con.close();
}
/*
* Helper - creates a test table for use by a test
*/
public static void createTable(Connection con,
String table,
String columns) throws SQLException
{
// by default we don't request oids.
createTable(con,table,columns,false);
}
/*
* Helper - creates a test table for use by a test
*/
public static void createTable(Connection con,
String table,
String columns,
boolean withOids) throws SQLException
{
Statement st = con.createStatement();
try
{
// Drop the table
dropTable(con, table);
// Now create the table
String sql = "CREATE TABLE " + table + " (" + columns + ") ";
// Starting with 8.0 oids may be turned off by default.
// Some tests need them, so they flag that here.
if (withOids && haveMinimumServerVersion(con,"8.0")) {
sql += " WITH OIDS";
}
st.executeUpdate(sql);
}
finally
{
st.close();
}
}
/**
* Helper creates a temporary table
* @param con Connection
* @param table String
* @param columns String
* @throws SQLException
*/
public static void createTempTable( Connection con,
String table,
String columns) throws SQLException
{
Statement st = con.createStatement();
try
{
// Drop the table
dropTable(con, table);
// Now create the table
st.executeUpdate("create temp table " + table + " (" + columns + ")");
}
finally
{
st.close();
}
}
/*
* drop a sequence because older versions don't have dependency
* information for serials
*/
public static void dropSequence(Connection con, String sequence) throws SQLException
{
Statement stmt = con.createStatement();
try
{
String sql = "DROP SEQUENCE " + sequence;
stmt.executeUpdate(sql);
}
catch (SQLException sqle)
{
if (!con.getAutoCommit())
throw sqle;
}
}
/*
* Helper - drops a table
*/
public static void dropTable(Connection con, String table) throws SQLException
{
Statement stmt = con.createStatement();
try
{
String sql = "DROP TABLE " + table;
if (haveMinimumServerVersion(con, "7.3"))
{
sql += " CASCADE ";
}
stmt.executeUpdate(sql);
}
catch (SQLException ex)
{
// Since every create table issues a drop table
// it's easy to get a table doesn't exist error.
// we want to ignore these, but if we're in a
// transaction then we've got trouble
if (!con.getAutoCommit())
throw ex;
}
}
/*
* Helper - generates INSERT SQL - very simple
*/
public static String insertSQL(String table, String values)
{
return insertSQL(table, null, values);
}
public static String insertSQL(String table, String columns, String values)
{
String s = "INSERT INTO " + table;
if (columns != null)
s = s + " (" + columns + ")";
return s + " VALUES (" + values + ")";
}
/*
* Helper - generates SELECT SQL - very simple
*/
public static String selectSQL(String table, String columns)
{
return selectSQL(table, columns, null, null);
}
public static String selectSQL(String table, String columns, String where)
{
return selectSQL(table, columns, where, null);
}
public static String selectSQL(String table, String columns, String where, String other)
{
String s = "SELECT " + columns + " FROM " + table;
if (where != null)
s = s + " WHERE " + where;
if (other != null)
s = s + " " + other;
return s;
}
/*
* Helper to prefix a number with leading zeros - ugly but it works...
* @param v value to prefix
* @param l number of digits (0-10)
*/
public static String fix(int v, int l)
{
String s = "0000000000".substring(0, l) + Integer.toString(v);
return s.substring(s.length() - l);
}
public static String escapeString(Connection con, String value) throws SQLException
{
if (con instanceof org.postgresql.jdbc2.AbstractJdbc2Connection)
{
return ((org.postgresql.jdbc2.AbstractJdbc2Connection)con).escapeString(value);
}
return value;
}
public static boolean getStandardConformingStrings(Connection con)
{
if (con instanceof org.postgresql.jdbc2.AbstractJdbc2Connection)
{
return ((org.postgresql.jdbc2.AbstractJdbc2Connection)con).getStandardConformingStrings();
}
return false;
}
/**
* Determine if the given connection is connected to a server with
* a version of at least the given version.
* This is convenient because we are working with a java.sql.Connection,
* not an Postgres connection.
*/
public static boolean haveMinimumServerVersion(Connection con, String version) throws SQLException {
if (con instanceof org.postgresql.jdbc2.AbstractJdbc2Connection)
{
return ((org.postgresql.jdbc2.AbstractJdbc2Connection)con).haveMinimumServerVersion(version);
}
return false;
}
public static boolean haveMinimumJVMVersion(String version) {
String jvm = java.lang.System.getProperty("java.version");
return (jvm.compareTo(version) >= 0);
}
public static boolean isProtocolVersion( Connection con, int version )
{
if ( con instanceof AbstractJdbc2Connection )
{
return (version == ((AbstractJdbc2Connection)con).getProtocolVersion());
}
return false;
}
/**
* Print a ResultSet to System.out.
* This is useful for debugging tests.
*/
public static void printResultSet(ResultSet rs) throws SQLException {
ResultSetMetaData rsmd = rs.getMetaData();
for (int i = 1; i <= rsmd.getColumnCount(); i++)
{
if (i != 1)
{
System.out.print(", ");
}
System.out.print(rsmd.getColumnName(i));
}
System.out.println();
while (rs.next())
{
for (int i = 1; i <= rsmd.getColumnCount(); i++)
{
if (i != 1)
{
System.out.print(", ");
}
System.out.print(rs.getString(i));
}
System.out.println();
}
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/extensions/ 0000775 0000000 0000000 00000000000 12050675701 0024010 5 ustar 00root root 0000000 0000000 postgresql-jdbc-9.2-1002.src/org/postgresql/test/extensions/ExtensionsSuite.java 0000664 0000000 0000000 00000002634 12050675701 0030031 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2007-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.extensions;
import junit.framework.TestSuite;
import java.sql.*;
import org.postgresql.test.TestUtil;
/*
* Executes all known tests for PostgreSQL extensions supported by JDBC driver
*/
public class ExtensionsSuite extends TestSuite
{
/*
* The main entry point for JUnit
*/
public static TestSuite suite() throws Exception
{
Class.forName("org.postgresql.Driver");
TestSuite suite = new TestSuite();
Connection connection = TestUtil.openDB();
try
{
if (isHStoreEnabled(connection)) {
suite.addTestSuite(HStoreTest.class);
}
}
finally
{
connection.close();
}
return suite;
}
/**
* Not all servers have hstore extensions installed.
*/
private static boolean isHStoreEnabled(Connection conn) {
try {
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT 'a=>1'::hstore::text");
rs.close();
stmt.close();
return true;
} catch (SQLException sqle) {
return false;
}
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/extensions/HStoreTest.java 0000664 0000000 0000000 00000005112 12050675701 0026716 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2007-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.extensions;
import java.sql.*;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import junit.framework.TestCase;
import org.postgresql.test.TestUtil;
// SELECT 'hstore'::regtype::oid
// SELECT 'hstore[]'::regtype::oid
public class HStoreTest extends TestCase {
private Connection _conn;
public HStoreTest(String name) {
super(name);
}
protected void setUp() throws Exception {
_conn = TestUtil.openDB();
}
protected void tearDown() throws SQLException {
TestUtil.closeDB(_conn);
}
public void testHStoreSelect() throws SQLException {
PreparedStatement pstmt = _conn.prepareStatement("SELECT 'a=>1,b=>2'::hstore");
ResultSet rs = pstmt.executeQuery();
assertTrue(rs.next());
String str = rs.getString(1);
if (!("\"a\"=>\"1\", \"b\"=>\"2\"".equals(str) || "\"b\"=>\"2\", \"a\"=>\"1\"".equals(str))) {
fail("Expected " + "\"a\"=>\"1\", \"b\"=>\"2\"" + " but got " + str);
}
Map correct = new HashMap();
correct.put("a", "1");
correct.put("b", "2");
assertEquals(correct, rs.getObject(1));
}
public void testHStoreSelectNullValue() throws SQLException {
PreparedStatement pstmt = _conn.prepareStatement("SELECT 'a=>NULL'::hstore");
ResultSet rs = pstmt.executeQuery();
assertTrue(rs.next());
assertEquals("\"a\"=>NULL", rs.getString(1));
Map correct = Collections.singletonMap("a", null);
assertEquals(correct, rs.getObject(1));
}
public void testHStoreSend() throws SQLException {
Map correct = Collections.singletonMap("a", new Integer(1));
PreparedStatement pstmt = _conn.prepareStatement("SELECT ?::text");
pstmt.setObject(1, correct);
ResultSet rs = pstmt.executeQuery();
assertTrue(rs.next());
assertEquals("\"a\"=>\"1\"", rs.getString(1));
}
public void testHStoreSendEscaped() throws SQLException {
Map correct = Collections.singletonMap("a", "t'e\ns\"t");
PreparedStatement pstmt = _conn.prepareStatement("SELECT ?");
pstmt.setObject(1, correct);
ResultSet rs = pstmt.executeQuery();
assertTrue(rs.next());
assertEquals(correct, rs.getObject(1));
assertEquals("\"a\"=>\"t'e\ns\\\"t\"", rs.getString(1));
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc2/ 0000775 0000000 0000000 00000000000 12050675701 0022575 5 ustar 00root root 0000000 0000000 postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc2/ANTTest.java 0000664 0000000 0000000 00000001551 12050675701 0024724 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc2;
import junit.framework.TestCase;
public class ANTTest extends TestCase
{
public ANTTest(String name)
{
super(name);
}
/*
* This tests the acceptsURL() method with a couple of good and badly formed
* jdbc urls
*/
public void testANT()
{
String url = System.getProperty("database");
String usr = System.getProperty("username");
String psw = System.getProperty("password");
assertNotNull(url);
assertNotNull(usr);
assertNotNull(psw);
assertTrue(! url.equals(""));
assertTrue(! usr.equals(""));
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc2/ArrayTest.java 0000664 0000000 0000000 00000033453 12050675701 0025366 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc2;
import org.postgresql.test.TestUtil;
import java.sql.*;
import java.math.BigDecimal;
import org.postgresql.geometric.PGbox;
import org.postgresql.geometric.PGpoint;
import junit.framework.TestCase;
public class ArrayTest extends TestCase
{
private Connection conn;
public ArrayTest(String name)
{
super(name);
}
protected void setUp() throws Exception
{
conn = TestUtil.openDB();
TestUtil.createTable(conn, "arrtest", "intarr int[], decarr decimal(2,1)[], strarr text[]");
}
protected void tearDown() throws SQLException
{
TestUtil.dropTable(conn, "arrtest");
TestUtil.closeDB(conn);
}
public void testSetNull() throws SQLException {
PreparedStatement pstmt = conn.prepareStatement("INSERT INTO arrtest VALUES (?,?,?)");
pstmt.setNull(1, Types.ARRAY);
pstmt.setNull(2, Types.ARRAY);
pstmt.setNull(3, Types.ARRAY);
pstmt.executeUpdate();
pstmt.setObject(1, null, Types.ARRAY);
pstmt.setObject(2, null);
pstmt.setObject(3, null);
pstmt.executeUpdate();
pstmt.setArray(1, null);
pstmt.setArray(2, null);
pstmt.setArray(3, null);
pstmt.executeUpdate();
pstmt.close();
}
public void testRetrieveArrays() throws SQLException {
Statement stmt = conn.createStatement();
// you need a lot of backslashes to get a double quote in.
stmt.executeUpdate("INSERT INTO arrtest VALUES ('{1,2,3}','{3.1,1.4}', '"
+ TestUtil.escapeString(conn, "{abc,f'a,\"fa\\\"b\",def}") + "')");
ResultSet rs = stmt.executeQuery("SELECT intarr, decarr, strarr FROM arrtest");
assertTrue(rs.next());
Array arr = rs.getArray(1);
assertEquals(Types.INTEGER, arr.getBaseType());
Integer intarr[] = (Integer[])arr.getArray();
assertEquals(3, intarr.length);
assertEquals(1, intarr[0].intValue());
assertEquals(2, intarr[1].intValue());
assertEquals(3, intarr[2].intValue());
arr = rs.getArray(2);
assertEquals(Types.NUMERIC, arr.getBaseType());
BigDecimal decarr[] = (BigDecimal[])arr.getArray();
assertEquals(2, decarr.length);
assertEquals(new BigDecimal("3.1"), decarr[0]);
assertEquals(new BigDecimal("1.4"), decarr[1]);
arr = rs.getArray(3);
assertEquals(Types.VARCHAR, arr.getBaseType());
String strarr[] = (String[])arr.getArray(2, 2);
assertEquals(2, strarr.length);
assertEquals("f'a", strarr[0]);
assertEquals("fa\"b", strarr[1]);
rs.close();
stmt.close();
}
public void testRetrieveResultSets() throws SQLException {
Statement stmt = conn.createStatement();
// you need a lot of backslashes to get a double quote in.
stmt.executeUpdate("INSERT INTO arrtest VALUES ('{1,2,3}','{3.1,1.4}', '" +
TestUtil.escapeString(conn, "{abc,f'a,\"fa\\\"b\",def}") + "')");
ResultSet rs = stmt.executeQuery("SELECT intarr, decarr, strarr FROM arrtest");
assertTrue(rs.next());
Array arr = rs.getArray(1);
assertEquals(Types.INTEGER, arr.getBaseType());
ResultSet arrrs = arr.getResultSet();
assertTrue(arrrs.next());
assertEquals(1, arrrs.getInt(1));
assertEquals(1, arrrs.getInt(2));
assertTrue(arrrs.next());
assertEquals(2, arrrs.getInt(1));
assertEquals(2, arrrs.getInt(2));
assertTrue(arrrs.next());
assertEquals(3, arrrs.getInt(1));
assertEquals(3, arrrs.getInt(2));
assertTrue(!arrrs.next());
assertTrue(arrrs.previous());
assertEquals(3, arrrs.getInt(2));
arrrs.first();
assertEquals(1, arrrs.getInt(2));
arrrs.close();
arr = rs.getArray(2);
assertEquals(Types.NUMERIC, arr.getBaseType());
arrrs = arr.getResultSet();
assertTrue(arrrs.next());
assertEquals(new BigDecimal("3.1"), arrrs.getBigDecimal(2));
assertTrue(arrrs.next());
assertEquals(new BigDecimal("1.4"), arrrs.getBigDecimal(2));
arrrs.close();
arr = rs.getArray(3);
assertEquals(Types.VARCHAR, arr.getBaseType());
arrrs = arr.getResultSet(2, 2);
assertTrue(arrrs.next());
assertEquals(2, arrrs.getInt(1));
assertEquals("f'a", arrrs.getString(2));
assertTrue(arrrs.next());
assertEquals(3, arrrs.getInt(1));
assertEquals("fa\"b", arrrs.getString(2));
assertTrue(!arrrs.next());
arrrs.close();
rs.close();
stmt.close();
}
public void testSetArray() throws SQLException {
Statement stmt = conn.createStatement();
ResultSet arrRS = stmt.executeQuery("SELECT '{1,2,3}'::int4[]");
assertTrue(arrRS.next());
Array arr = arrRS.getArray(1);
arrRS.close();
stmt.close();
PreparedStatement pstmt = conn.prepareStatement("INSERT INTO arrtest(intarr) VALUES (?)");
pstmt.setArray(1, arr);
pstmt.executeUpdate();
pstmt.setObject(1, arr, Types.ARRAY);
pstmt.executeUpdate();
pstmt.setObject(1, arr);
pstmt.executeUpdate();
pstmt.close();
Statement select = conn.createStatement();
ResultSet rs = select.executeQuery("SELECT intarr FROM arrtest");
int resultCount = 0;
while(rs.next()) {
resultCount++;
Array result = rs.getArray(1);
assertEquals(Types.INTEGER, result.getBaseType());
assertEquals("int4", result.getBaseTypeName());
Integer intarr[] = (Integer[])result.getArray();
assertEquals(3, intarr.length);
assertEquals(1, intarr[0].intValue());
assertEquals(2, intarr[1].intValue());
assertEquals(3, intarr[2].intValue());
}
assertEquals(3, resultCount);
}
/**
* Starting with 8.0 non-standard (beginning index isn't 1) bounds
* the dimensions are returned in the data. The following should
* return "[0:3]={0,1,2,3,4}" when queried. Older versions simply
* do not return the bounds.
*/
public void testNonStandardBounds() throws SQLException {
Statement stmt = conn.createStatement();
stmt.executeUpdate("INSERT INTO arrtest (intarr) VALUES ('{1,2,3}')");
stmt.executeUpdate("UPDATE arrtest SET intarr[0] = 0");
ResultSet rs = stmt.executeQuery("SELECT intarr FROM arrtest");
assertTrue(rs.next());
Array result = rs.getArray(1);
Integer intarr[] = (Integer[])result.getArray();
assertEquals(4, intarr.length);
for (int i = 0; i < intarr.length; i++)
{
assertEquals(i, intarr[i].intValue());
}
}
public void testMultiDimensionalArray() throws SQLException {
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT '{{1,2},{3,4}}'::int[]");
assertTrue(rs.next());
Array arr = rs.getArray(1);
Object oa[] = (Object [])arr.getArray();
assertEquals(2, oa.length);
Integer i0[] = (Integer []) oa[0];
assertEquals(2, i0.length);
assertEquals(1, i0[0].intValue());
assertEquals(2, i0[1].intValue());
Integer i1[] = (Integer []) oa[1];
assertEquals(2, i1.length);
assertEquals(3, i1[0].intValue());
assertEquals(4, i1[1].intValue());
rs.close();
stmt.close();
}
public void testNullValues() throws SQLException {
if (!TestUtil.haveMinimumServerVersion(conn, "8.2"))
return;
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT ARRAY[1,NULL,3]");
assertTrue(rs.next());
Array arr = rs.getArray(1);
Integer i[] = (Integer[])arr.getArray();
assertEquals(3, i.length);
assertEquals(1, i[0].intValue());
assertNull(i[1]);
assertEquals(3, i[2].intValue());
}
public void testUnknownArrayType() throws SQLException {
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT relacl FROM pg_class WHERE relacl IS NOT NULL LIMIT 1");
ResultSetMetaData rsmd = rs.getMetaData();
assertEquals(Types.ARRAY, rsmd.getColumnType(1));
assertTrue(rs.next());
Array arr = rs.getArray(1);
assertEquals("aclitem", arr.getBaseTypeName());
ResultSet arrRS = arr.getResultSet();
ResultSetMetaData arrRSMD = arrRS.getMetaData();
assertEquals("aclitem", arrRSMD.getColumnTypeName(2));
}
public void testRecursiveResultSets() throws SQLException {
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT '{{1,2},{3,4}}'::int[]");
assertTrue(rs.next());
Array arr = rs.getArray(1);
ResultSet arrRS = arr.getResultSet();
ResultSetMetaData arrRSMD = arrRS.getMetaData();
assertEquals(Types.ARRAY, arrRSMD.getColumnType(2));
assertEquals("_int4", arrRSMD.getColumnTypeName(2));
assertTrue(arrRS.next());
assertEquals(1, arrRS.getInt(1));
Array a1 = arrRS.getArray(2);
ResultSet a1RS = a1.getResultSet();
ResultSetMetaData a1RSMD = a1RS.getMetaData();
assertEquals(Types.INTEGER, a1RSMD.getColumnType(2));
assertEquals("int4", a1RSMD.getColumnTypeName(2));
assertTrue(a1RS.next());
assertEquals(1, a1RS.getInt(2));
assertTrue(a1RS.next());
assertEquals(2, a1RS.getInt(2));
assertTrue(!a1RS.next());
a1RS.close();
assertTrue(arrRS.next());
assertEquals(2, arrRS.getInt(1));
Array a2 = arrRS.getArray(2);
ResultSet a2RS = a2.getResultSet();
assertTrue(a2RS.next());
assertEquals(3, a2RS.getInt(2));
assertTrue(a2RS.next());
assertEquals(4, a2RS.getInt(2));
assertTrue(!a2RS.next());
a2RS.close();
arrRS.close();
rs.close();
stmt.close();
}
public void testNullString() throws SQLException
{
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT '{a,NULL}'::text[]");
assertTrue(rs.next());
Array arr = rs.getArray(1);
String s[] = (String [])arr.getArray();
assertEquals(2, s.length);
assertEquals("a", s[0]);
if (TestUtil.haveMinimumServerVersion(conn, "8.2")) {
assertNull(s[1]);
} else {
assertEquals("NULL", s[1]);
}
}
public void testEscaping() throws SQLException
{
Statement stmt = conn.createStatement();
String sql = "SELECT ";
if (TestUtil.haveMinimumServerVersion(conn, "8.1")) {
sql += 'E';
}
// Uggg. Three levels of escaping: Java, string literal, array.
sql += "'{{c\\\\\"d, ''}, {\"\\\\\\\\\",\"''\"}}'::text[]";
ResultSet rs = stmt.executeQuery(sql);
assertTrue(rs.next());
Array arr = rs.getArray(1);
String s[][] = (String[][])arr.getArray();
assertEquals("c\"d", s[0][0]);
assertEquals("'", s[0][1]);
assertEquals("\\", s[1][0]);
assertEquals("'", s[1][1]);
ResultSet arrRS = arr.getResultSet();
assertTrue(arrRS.next());
Array a1 = arrRS.getArray(2);
ResultSet rs1 = a1.getResultSet();
assertTrue(rs1.next());
assertEquals("c\"d", rs1.getString(2));
assertTrue(rs1.next());
assertEquals("'", rs1.getString(2));
assertTrue(!rs1.next());
assertTrue(arrRS.next());
Array a2 = arrRS.getArray(2);
ResultSet rs2 = a2.getResultSet();
assertTrue(rs2.next());
assertEquals("\\", rs2.getString(2));
assertTrue(rs2.next());
assertEquals("'", rs2.getString(2));
assertTrue(!rs2.next());
}
public void testWriteMultiDimensional() throws SQLException
{
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT '{{1,2},{3,4}}'::int[]");
assertTrue(rs.next());
Array arr = rs.getArray(1);
rs.close();
stmt.close();
String sql = "SELECT ?";
if (TestUtil.isProtocolVersion(conn, 2)) {
sql = "SELECT ?::int[]";
}
PreparedStatement pstmt = conn.prepareStatement(sql);
pstmt.setArray(1, arr);
rs = pstmt.executeQuery();
assertTrue(rs.next());
arr = rs.getArray(1);
Integer i[][] = (Integer[][])arr.getArray();
assertEquals(1, i[0][0].intValue());
assertEquals(2, i[0][1].intValue());
assertEquals(3, i[1][0].intValue());
assertEquals(4, i[1][1].intValue());
}
/*
* The box data type uses a semicolon as the array element
* delimiter instead of a comma which pretty much everything
* else uses.
*/
public void testNonStandardDelimiter() throws SQLException
{
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT '{(3,4),(1,2);(7,8),(5,6)}'::box[]");
assertTrue(rs.next());
Array arr = rs.getArray(1);
ResultSet arrRS = arr.getResultSet();
assertTrue(arrRS.next());
PGbox box1 = (PGbox)arrRS.getObject(2);
PGpoint p1 = box1.point[0];
assertEquals(3, p1.x, 0.001);
assertEquals(4, p1.y, 0.001);
assertTrue(arrRS.next());
PGbox box2 = (PGbox)arrRS.getObject(2);
PGpoint p2 = box2.point[1];
assertEquals(5, p2.x, 0.001);
assertEquals(6, p2.y, 0.001);
assertTrue(!arrRS.next());
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc2/BatchExecuteTest.java 0000664 0000000 0000000 00000022046 12050675701 0026650 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc2;
import org.postgresql.test.TestUtil;
import junit.framework.TestCase;
import java.sql.*;
/* TODO tests that can be added to this test case
* - SQLExceptions chained to a BatchUpdateException
* - test PreparedStatement as thoroughly as Statement
*/
/*
* Test case for Statement.batchExecute()
*/
public class BatchExecuteTest extends TestCase
{
private Connection con;
public BatchExecuteTest(String name)
{
super(name);
try
{
Class.forName("org.postgresql.Driver");
}
catch( Exception ex){}
}
// Set up the fixture for this testcase: a connection to a database with
// a table for this test.
protected void setUp() throws Exception
{
con = TestUtil.openDB();
Statement stmt = con.createStatement();
// Drop the test table if it already exists for some reason. It is
// not an error if it doesn't exist.
TestUtil.createTable(con, "testbatch", "pk INTEGER, col1 INTEGER");
stmt.executeUpdate("INSERT INTO testbatch VALUES (1, 0)");
// Generally recommended with batch updates. By default we run all
// tests in this test case with autoCommit disabled.
con.setAutoCommit(false);
}
// Tear down the fixture for this test case.
protected void tearDown() throws Exception
{
con.setAutoCommit(true);
TestUtil.dropTable(con, "testbatch");
TestUtil.closeDB(con);
}
public void testSupportsBatchUpdates() throws Exception
{
DatabaseMetaData dbmd = con.getMetaData();
assertTrue(dbmd.supportsBatchUpdates());
}
public void testEmptyClearBatch() throws Exception
{
Statement stmt = con.createStatement();
stmt.clearBatch(); // No-op.
PreparedStatement ps = con.prepareStatement("SELECT ?");
ps.clearBatch(); // No-op.
}
private void assertCol1HasValue(int expected) throws Exception
{
Statement getCol1 = con.createStatement();
ResultSet rs =
getCol1.executeQuery("SELECT col1 FROM testbatch WHERE pk = 1");
assertTrue(rs.next());
int actual = rs.getInt("col1");
assertEquals(expected, actual);
assertEquals(false, rs.next());
rs.close();
getCol1.close();
}
public void testExecuteEmptyBatch() throws Exception
{
Statement stmt = con.createStatement();
int[] updateCount = stmt.executeBatch();
assertEquals(0, updateCount.length);
stmt.addBatch("UPDATE testbatch SET col1 = col1 + 1 WHERE pk = 1");
stmt.clearBatch();
updateCount = stmt.executeBatch();
assertEquals(0, updateCount.length);
stmt.close();
}
public void testClearBatch() throws Exception
{
Statement stmt = con.createStatement();
stmt.addBatch("UPDATE testbatch SET col1 = col1 + 1 WHERE pk = 1");
assertCol1HasValue(0);
stmt.addBatch("UPDATE testbatch SET col1 = col1 + 2 WHERE pk = 1");
assertCol1HasValue(0);
stmt.clearBatch();
assertCol1HasValue(0);
stmt.addBatch("UPDATE testbatch SET col1 = col1 + 4 WHERE pk = 1");
assertCol1HasValue(0);
stmt.executeBatch();
assertCol1HasValue(4);
con.commit();
assertCol1HasValue(4);
stmt.close();
}
public void testSelectThrowsException() throws Exception
{
Statement stmt = con.createStatement();
stmt.addBatch("UPDATE testbatch SET col1 = col1 + 1 WHERE pk = 1");
stmt.addBatch("SELECT col1 FROM testbatch WHERE pk = 1");
stmt.addBatch("UPDATE testbatch SET col1 = col1 + 2 WHERE pk = 1");
try
{
stmt.executeBatch();
fail("Should raise a BatchUpdateException because of the SELECT");
}
catch (BatchUpdateException e)
{
int [] updateCounts = e.getUpdateCounts();
assertEquals(1, updateCounts.length);
assertEquals(1, updateCounts[0]);
}
catch (SQLException e)
{
fail( "Should throw a BatchUpdateException instead of " +
"a generic SQLException: " + e);
}
stmt.close();
}
public void testStringAddBatchOnPreparedStatement() throws Exception
{
PreparedStatement pstmt = con.prepareStatement("UPDATE testbatch SET col1 = col1 + ? WHERE PK = ?" );
pstmt.setInt(1, 1);
pstmt.setInt(2, 1);
pstmt.addBatch();
try
{
pstmt.addBatch("UPDATE testbatch SET col1 = 3");
fail("Should have thrown an exception about using the string addBatch method on a prepared statement.");
}
catch (SQLException sqle)
{
}
pstmt.close();
}
public void testPreparedStatement() throws Exception
{
PreparedStatement pstmt = con.prepareStatement(
"UPDATE testbatch SET col1 = col1 + ? WHERE PK = ?" );
// Note that the first parameter changes for every statement in the
// batch, whereas the second parameter remains constant.
pstmt.setInt(1, 1);
pstmt.setInt(2, 1);
pstmt.addBatch();
assertCol1HasValue(0);
pstmt.setInt(1, 2);
pstmt.addBatch();
assertCol1HasValue(0);
pstmt.setInt(1, 4);
pstmt.addBatch();
assertCol1HasValue(0);
pstmt.executeBatch();
assertCol1HasValue(7);
//now test to see that we can still use the statement after the execute
pstmt.setInt(1, 3);
pstmt.addBatch();
assertCol1HasValue(7);
pstmt.executeBatch();
assertCol1HasValue(10);
con.commit();
assertCol1HasValue(10);
con.rollback();
assertCol1HasValue(10);
pstmt.close();
}
public void testTransactionalBehaviour() throws Exception
{
Statement stmt = con.createStatement();
stmt.addBatch("UPDATE testbatch SET col1 = col1 + 1 WHERE pk = 1");
stmt.addBatch("UPDATE testbatch SET col1 = col1 + 2 WHERE pk = 1");
stmt.executeBatch();
con.rollback();
assertCol1HasValue(0);
stmt.addBatch("UPDATE testbatch SET col1 = col1 + 4 WHERE pk = 1");
stmt.addBatch("UPDATE testbatch SET col1 = col1 + 8 WHERE pk = 1");
// The statement has been added to the batch, but it should not yet
// have been executed.
assertCol1HasValue(0);
int[] updateCounts = stmt.executeBatch();
assertEquals(2, updateCounts.length);
assertEquals(1, updateCounts[0]);
assertEquals(1, updateCounts[1]);
assertCol1HasValue(12);
con.commit();
assertCol1HasValue(12);
con.rollback();
assertCol1HasValue(12);
stmt.close();
}
public void testWarningsAreCleared() throws SQLException
{
Statement stmt = con.createStatement();
stmt.addBatch("CREATE TEMP TABLE unused (a int primary key)");
stmt.executeBatch();
// Execute an empty batch to clear warnings.
stmt.executeBatch();
assertNull(stmt.getWarnings());
stmt.close();
}
public void testBatchEscapeProcessing() throws SQLException
{
Statement stmt = con.createStatement();
stmt.execute("CREATE TEMP TABLE batchescape (d date)");
stmt.addBatch("INSERT INTO batchescape (d) VALUES ({d '2007-11-20'})");
stmt.executeBatch();
PreparedStatement pstmt = con.prepareStatement("INSERT INTO batchescape (d) VALUES ({d '2007-11-20'})");
pstmt.addBatch();
pstmt.executeBatch();
pstmt.close();
ResultSet rs = stmt.executeQuery("SELECT d FROM batchescape");
assertTrue(rs.next());
assertEquals("2007-11-20", rs.getString(1));
assertTrue(rs.next());
assertEquals("2007-11-20", rs.getString(1));
assertTrue(!rs.next());
rs.close();
stmt.close();
}
public void testBatchWithEmbeddedNulls() throws SQLException
{
Statement stmt = con.createStatement();
stmt.execute("CREATE TEMP TABLE batchstring (a text)");
con.commit();
PreparedStatement pstmt = con.prepareStatement("INSERT INTO batchstring VALUES (?)");
try {
pstmt.setString(1, "a");
pstmt.addBatch();
pstmt.setString(1, "\u0000");
pstmt.addBatch();
pstmt.setString(1, "b");
pstmt.addBatch();
pstmt.executeBatch();
fail("Should have thrown an exception.");
} catch (SQLException sqle) {
con.rollback();
}
pstmt.close();
ResultSet rs = stmt.executeQuery("SELECT COUNT(*) FROM batchstring");
assertTrue(rs.next());
assertEquals(0, rs.getInt(1));
rs.close();
stmt.close();
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc2/BlobTest.java 0000664 0000000 0000000 00000025402 12050675701 0025161 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc2;
import org.postgresql.test.TestUtil;
import junit.framework.TestCase;
import java.io.*;
import java.sql.*;
import org.postgresql.largeobject.*;
/**
* Some simple tests based on problems reported by users. Hopefully these will
* help prevent previous problems from re-occuring ;-)
*
*/
public class BlobTest extends TestCase
{
private Connection con;
private static final int LOOP = 0; // LargeObject API using loop
private static final int NATIVE_STREAM = 1; // LargeObject API using OutputStream
public BlobTest(String name)
{
super(name);
}
protected void setUp() throws Exception
{
con = TestUtil.openDB();
TestUtil.createTable(con, "testblob", "id name,lo oid");
con.setAutoCommit(false);
}
protected void tearDown() throws Exception
{
con.setAutoCommit(true);
TestUtil.dropTable(con, "testblob");
TestUtil.closeDB(con);
}
public void testSetNull() throws Exception
{
PreparedStatement pstmt = con.prepareStatement("INSERT INTO testblob(lo) VALUES (?)");
pstmt.setBlob(1, (Blob)null);
pstmt.executeUpdate();
pstmt.setNull(1, Types.BLOB);
pstmt.executeUpdate();
pstmt.setObject(1, null, Types.BLOB);
pstmt.executeUpdate();
pstmt.setClob(1, (Clob)null);
pstmt.executeUpdate();
pstmt.setNull(1, Types.CLOB);
pstmt.executeUpdate();
pstmt.setObject(1, null, Types.CLOB);
pstmt.executeUpdate();
}
public void testSet() throws SQLException {
Statement stmt = con.createStatement();
stmt.execute("INSERT INTO testblob(id,lo) VALUES ('1', lo_creat(-1))");
ResultSet rs = stmt.executeQuery("SELECT lo FROM testblob");
assertTrue(rs.next());
PreparedStatement pstmt = con.prepareStatement("INSERT INTO testblob(id, lo) VALUES(?,?)");
Blob blob = rs.getBlob(1);
pstmt.setString(1,"setObjectTypeBlob");
pstmt.setObject(2, blob, Types.BLOB);
assertEquals(1, pstmt.executeUpdate());
blob = rs.getBlob(1);
pstmt.setString(1,"setObjectBlob");
pstmt.setObject(2, blob);
assertEquals(1, pstmt.executeUpdate());
blob = rs.getBlob(1);
pstmt.setString(1,"setBlob");
pstmt.setBlob(2, blob);
assertEquals(1, pstmt.executeUpdate());
Clob clob = rs.getClob(1);
pstmt.setString(1,"setObjectTypeClob");
pstmt.setObject(2, clob, Types.CLOB);
assertEquals(1, pstmt.executeUpdate());
clob = rs.getClob(1);
pstmt.setString(1,"setObjectClob");
pstmt.setObject(2, clob);
assertEquals(1, pstmt.executeUpdate());
clob = rs.getClob(1);
pstmt.setString(1,"setClob");
pstmt.setClob(2, clob);
assertEquals(1, pstmt.executeUpdate());
}
/*
* Tests one method of uploading a blob to the database
*/
public void testUploadBlob_LOOP() throws Exception
{
assertTrue(uploadFile("build.xml", LOOP) > 0);
// Now compare the blob & the file. Note this actually tests the
// InputStream implementation!
assertTrue(compareBlobsLOAPI());
assertTrue(compareBlobs());
assertTrue(compareClobs());
}
/*
* Tests one method of uploading a blob to the database
*/
public void testUploadBlob_NATIVE() throws Exception
{
assertTrue(uploadFile("build.xml", NATIVE_STREAM) > 0);
// Now compare the blob & the file. Note this actually tests the
// InputStream implementation!
assertTrue(compareBlobs());
}
public void testGetBytesOffset() throws Exception
{
assertTrue(uploadFile("build.xml", NATIVE_STREAM) > 0);
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery("SELECT lo FROM testblob");
assertTrue(rs.next());
Blob lob = rs.getBlob(1);
byte data[] = lob.getBytes(2,4);
assertEquals(data.length, 4);
assertEquals(data[0], '?');
assertEquals(data[1], 'x');
assertEquals(data[2], 'm');
assertEquals(data[3], 'l');
}
public void testMultipleStreams() throws Exception
{
assertTrue(uploadFile("build.xml", NATIVE_STREAM) > 0);
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery("SELECT lo FROM testblob");
assertTrue(rs.next());
Blob lob = rs.getBlob(1);
byte data[] = new byte[2];
InputStream is = lob.getBinaryStream();
assertEquals(data.length, is.read(data));
assertEquals(data[0], '<');
assertEquals(data[1], '?');
is.close();
is = lob.getBinaryStream();
assertEquals(data.length, is.read(data));
assertEquals(data[0], '<');
assertEquals(data[1], '?');
is.close();
}
public void testParallelStreams() throws Exception
{
assertTrue(uploadFile("build.xml", NATIVE_STREAM) > 0);
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery("SELECT lo FROM testblob");
assertTrue(rs.next());
Blob lob = rs.getBlob(1);
InputStream is1 = lob.getBinaryStream();
InputStream is2 = lob.getBinaryStream();
while (true) {
int i1 = is1.read();
int i2 = is2.read();
assertEquals(i1, i2);
if (i1 == -1)
break;
}
is1.close();
is2.close();
}
/*
* Helper - uploads a file into a blob using old style methods. We use this
* because it always works, and we can use it as a base to test the new
* methods.
*/
private long uploadFile(String file, int method) throws Exception
{
LargeObjectManager lom = ((org.postgresql.PGConnection)con).getLargeObjectAPI();
FileInputStream fis = new FileInputStream(file);
long oid = lom.createLO(LargeObjectManager.READWRITE);
LargeObject blob = lom.open(oid);
int s, t;
byte buf[];
OutputStream os;
switch (method)
{
case LOOP:
buf = new byte[2048];
t = 0;
while ((s = fis.read(buf, 0, buf.length)) > 0)
{
t += s;
blob.write(buf, 0, s);
}
break;
case NATIVE_STREAM:
os = blob.getOutputStream();
s = fis.read();
while (s > -1)
{
os.write(s);
s = fis.read();
}
os.close();
break;
default:
assertTrue("Unknown method in uploadFile", false);
}
blob.close();
fis.close();
// Insert into the table
Statement st = con.createStatement();
st.executeUpdate(TestUtil.insertSQL("testblob", "id,lo", "'" + file + "'," + oid));
con.commit();
st.close();
return oid;
}
/*
* Helper - compares the blobs in a table with a local file. Note this uses
* the postgresql specific Large Object API
*/
private boolean compareBlobsLOAPI() throws Exception
{
boolean result = true;
LargeObjectManager lom = ((org.postgresql.PGConnection)con).getLargeObjectAPI();
Statement st = con.createStatement();
ResultSet rs = st.executeQuery(TestUtil.selectSQL("testblob", "id,lo"));
assertNotNull(rs);
while (rs.next())
{
String file = rs.getString(1);
long oid = rs.getLong(2);
FileInputStream fis = new FileInputStream(file);
LargeObject blob = lom.open(oid);
InputStream bis = blob.getInputStream();
int f = fis.read();
int b = bis.read();
int c = 0;
while (f >= 0 && b >= 0 & result)
{
result = (f == b);
f = fis.read();
b = bis.read();
c++;
}
result = result && f == -1 && b == -1;
if (!result)
assertTrue("Large Object API Blob compare failed at " + c + " of " + blob.size(), false);
blob.close();
fis.close();
}
rs.close();
st.close();
return result;
}
/*
* Helper - compares the blobs in a table with a local file. This uses the
* jdbc java.sql.Blob api
*/
private boolean compareBlobs() throws Exception
{
boolean result = true;
Statement st = con.createStatement();
ResultSet rs = st.executeQuery(TestUtil.selectSQL("testblob", "id,lo"));
assertNotNull(rs);
while (rs.next())
{
String file = rs.getString(1);
Blob blob = rs.getBlob(2);
FileInputStream fis = new FileInputStream(file);
InputStream bis = blob.getBinaryStream();
int f = fis.read();
int b = bis.read();
int c = 0;
while (f >= 0 && b >= 0 & result)
{
result = (f == b);
f = fis.read();
b = bis.read();
c++;
}
result = result && f == -1 && b == -1;
if (!result)
assertTrue("JDBC API Blob compare failed at " + c + " of " + blob.length(), false);
bis.close();
fis.close();
}
rs.close();
st.close();
return result;
}
/*
* Helper - compares the clobs in a table with a local file.
*/
private boolean compareClobs() throws Exception
{
boolean result = true;
Statement st = con.createStatement();
ResultSet rs = st.executeQuery(TestUtil.selectSQL("testblob", "id,lo"));
assertNotNull(rs);
while (rs.next())
{
String file = rs.getString(1);
Clob clob = rs.getClob(2);
FileInputStream fis = new FileInputStream(file);
InputStream bis = clob.getAsciiStream();
int f = fis.read();
int b = bis.read();
int c = 0;
while (f >= 0 && b >= 0 & result)
{
result = (f == b);
f = fis.read();
b = bis.read();
c++;
}
result = result && f == -1 && b == -1;
if (!result)
assertTrue("Clob compare failed at " + c + " of " + clob.length(), false);
bis.close();
fis.close();
}
rs.close();
st.close();
return result;
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc2/CallableStmtTest.java 0000664 0000000 0000000 00000024666 12050675701 0026665 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc2;
import org.postgresql.test.TestUtil;
import java.sql.*;
import junit.framework.TestCase;
/*
* CallableStatement tests.
* @author Paul Bethe
*/
public class CallableStmtTest extends TestCase
{
private Connection con;
public CallableStmtTest (String name)
{
super(name);
}
protected void setUp() throws Exception
{
con = TestUtil.openDB();
TestUtil.createTable(con, "int_table", "id int");
Statement stmt = con.createStatement ();
stmt.execute ("CREATE OR REPLACE FUNCTION testspg__getString (varchar) " +
"RETURNS varchar AS ' DECLARE inString alias for $1; begin " +
"return ''bob''; end; ' LANGUAGE plpgsql;");
stmt.execute ("CREATE OR REPLACE FUNCTION testspg__getDouble (float) " +
"RETURNS float AS ' DECLARE inString alias for $1; begin " +
"return 42.42; end; ' LANGUAGE plpgsql;");
if (TestUtil.haveMinimumServerVersion(con, "7.3")) {
stmt.execute ("CREATE OR REPLACE FUNCTION testspg__getVoid (float) " +
"RETURNS void AS ' DECLARE inString alias for $1; begin " +
" return; end; ' LANGUAGE plpgsql;");
}
stmt.execute ("CREATE OR REPLACE FUNCTION testspg__getInt (int) RETURNS int " +
" AS 'DECLARE inString alias for $1; begin " +
"return 42; end;' LANGUAGE plpgsql;");
stmt.execute ("CREATE OR REPLACE FUNCTION testspg__getShort (int2) RETURNS int2 " +
" AS 'DECLARE inString alias for $1; begin " +
"return 42; end;' LANGUAGE plpgsql;");
stmt.execute ("CREATE OR REPLACE FUNCTION testspg__getNumeric (numeric) " +
"RETURNS numeric AS ' DECLARE inString alias for $1; " +
"begin return 42; end; ' LANGUAGE plpgsql;");
stmt.execute ("CREATE OR REPLACE FUNCTION testspg__getNumericWithoutArg() " +
"RETURNS numeric AS ' " +
"begin return 42; end; ' LANGUAGE plpgsql;");
stmt.execute("CREATE OR REPLACE FUNCTION testspg__getarray() RETURNS int[] as 'SELECT ''{1,2}''::int[];' LANGUAGE sql");
stmt.execute("CREATE OR REPLACE FUNCTION testspg__raisenotice() RETURNS int as 'BEGIN RAISE NOTICE ''hello''; RAISE NOTICE ''goodbye''; RETURN 1; END;' LANGUAGE plpgsql");
stmt.execute("CREATE OR REPLACE FUNCTION testspg__insertInt(int) RETURNS int as 'BEGIN INSERT INTO int_table(id) VALUES ($1); RETURN 1; END;' LANGUAGE plpgsql");
stmt.close ();
}
protected void tearDown() throws Exception
{
Statement stmt = con.createStatement ();
TestUtil.dropTable(con, "int_table");
stmt.execute ("drop FUNCTION testspg__getString (varchar);");
stmt.execute ("drop FUNCTION testspg__getDouble (float);");
if (TestUtil.haveMinimumServerVersion(con, "7.3")) {
stmt.execute( "drop FUNCTION testspg__getVoid(float);");
}
stmt.execute ("drop FUNCTION testspg__getInt (int);");
stmt.execute ("drop FUNCTION testspg__getShort(int2)");
stmt.execute ("drop FUNCTION testspg__getNumeric (numeric);");
stmt.execute ("drop FUNCTION testspg__getNumericWithoutArg ();");
stmt.execute ("DROP FUNCTION testspg__getarray();");
stmt.execute ("DROP FUNCTION testspg__raisenotice();");
stmt.execute ("DROP FUNCTION testspg__insertInt(int);");
TestUtil.closeDB(con);
}
final String func = "{ ? = call ";
final String pkgName = "testspg__";
public void testGetUpdateCount() throws SQLException
{
CallableStatement call = con.prepareCall (func + pkgName + "getDouble (?) }");
call.setDouble (2, (double)3.04);
call.registerOutParameter (1, Types.DOUBLE);
call.execute ();
assertEquals(-1, call.getUpdateCount());
assertNull(call.getResultSet());
assertEquals(42.42, call.getDouble(1), 0.00001);
call.close();
// test without an out parameter
call = con.prepareCall( "{ call " + pkgName + "getDouble(?) }");
call.setDouble( 1, (double)3.04 );
call.execute();
assertEquals(-1, call.getUpdateCount());
ResultSet rs = call.getResultSet();
assertNotNull(rs);
assertTrue(rs.next());
assertEquals(42.42, rs.getDouble(1), 0.00001);
assertTrue(!rs.next());
rs.close();
assertEquals(-1, call.getUpdateCount());
assertTrue(!call.getMoreResults());
call.close();
}
public void testGetDouble () throws Throwable
{
CallableStatement call = con.prepareCall (func + pkgName + "getDouble (?) }");
call.setDouble (2, (double)3.04);
call.registerOutParameter (1, Types.DOUBLE);
call.execute ();
assertEquals(42.42, call.getDouble(1), 0.00001);
// test without an out parameter
call = con.prepareCall( "{ call " + pkgName + "getDouble(?) }");
call.setDouble( 1, (double)3.04 );
call.execute();
if (TestUtil.haveMinimumServerVersion(con, "7.3")) {
call = con.prepareCall( "{ call " + pkgName + "getVoid(?) }");
call.setDouble( 1, (double)3.04 );
call.execute();
}
}
public void testGetInt () throws Throwable
{
CallableStatement call = con.prepareCall (func + pkgName + "getInt (?) }");
call.setInt (2, 4);
call.registerOutParameter (1, Types.INTEGER);
call.execute ();
assertEquals(42, call.getInt(1));
}
public void testGetShort () throws Throwable
{
if ( TestUtil.isProtocolVersion(con, 3) )
{
CallableStatement call = con.prepareCall (func + pkgName + "getShort (?) }");
call.setShort (2, (short)4);
call.registerOutParameter (1, Types.SMALLINT);
call.execute ();
assertEquals(42, call.getShort(1));
}
}
public void testGetNumeric () throws Throwable
{
CallableStatement call = con.prepareCall (func + pkgName + "getNumeric (?) }");
call.setBigDecimal (2, new java.math.BigDecimal(4));
call.registerOutParameter (1, Types.NUMERIC);
call.execute ();
assertEquals(new java.math.BigDecimal(42), call.getBigDecimal(1));
}
public void testGetNumericWithoutArg () throws Throwable
{
CallableStatement call = con.prepareCall (func + pkgName + "getNumericWithoutArg () }");
call.registerOutParameter (1, Types.NUMERIC);
call.execute ();
assertEquals(new java.math.BigDecimal(42), call.getBigDecimal(1));
}
public void testGetString () throws Throwable
{
CallableStatement call = con.prepareCall (func + pkgName + "getString (?) }");
call.setString (2, "foo");
call.registerOutParameter (1, Types.VARCHAR);
call.execute ();
assertEquals("bob", call.getString(1));
}
public void testGetArray() throws SQLException
{
CallableStatement call = con.prepareCall(func + pkgName + "getarray()}");
call.registerOutParameter(1, Types.ARRAY);
call.execute();
Array arr = call.getArray(1);
ResultSet rs = arr.getResultSet();
assertTrue(rs.next());
assertEquals(1, rs.getInt(1));
assertTrue(rs.next());
assertEquals(2, rs.getInt(1));
assertTrue(!rs.next());
}
public void testRaiseNotice() throws SQLException
{
CallableStatement call = con.prepareCall(func + pkgName + "raisenotice()}");
call.registerOutParameter(1, Types.INTEGER);
call.execute();
SQLWarning warn = call.getWarnings();
assertNotNull(warn);
assertEquals("hello", warn.getMessage());
warn = warn.getNextWarning();
assertNotNull(warn);
assertEquals("goodbye", warn.getMessage());
assertEquals(1, call.getInt(1));
}
public void testWasNullBeforeFetch() throws SQLException {
CallableStatement cs = con.prepareCall("{? = call lower(?)}");
cs.registerOutParameter(1, Types.VARCHAR);
cs.setString(2, "Hi");
try {
cs.wasNull();
fail("expected exception");
} catch(Exception e) {
assertTrue(e instanceof SQLException);
}
}
public void testFetchBeforeExecute() throws SQLException {
CallableStatement cs = con.prepareCall("{? = call lower(?)}");
cs.registerOutParameter(1, Types.VARCHAR);
cs.setString(2, "Hi");
try {
cs.getString(1);
fail("expected exception");
} catch(Exception e) {
assertTrue(e instanceof SQLException);
}
}
public void testFetchWithNoResults() throws SQLException {
CallableStatement cs = con.prepareCall("{call now()}");
cs.execute();
try {
cs.getObject(1);
fail("expected exception");
} catch(Exception e) {
assertTrue(e instanceof SQLException);
}
}
public void testBadStmt () throws Throwable
{
tryOneBadStmt ("{ ?= " + pkgName + "getString (?) }");
tryOneBadStmt ("{ ?= call getString (?) ");
tryOneBadStmt ("{ = ? call getString (?); }");
}
protected void tryOneBadStmt (String sql) throws SQLException
{
try
{
con.prepareCall (sql);
fail("Bad statement (" + sql + ") was not caught.");
}
catch (SQLException e)
{
}
}
public void testBatchCall() throws SQLException
{
CallableStatement call = con.prepareCall ("{ call " + pkgName + "insertInt(?) }");
call.setInt(1, 1);
call.addBatch();
call.setInt(1, 2);
call.addBatch();
call.setInt(1, 3);
call.addBatch();
call.executeBatch();
call.close();
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery("SELECT id FROM int_table ORDER BY id");
assertTrue(rs.next());
assertEquals(1, rs.getInt(1));
assertTrue(rs.next());
assertEquals(2, rs.getInt(1));
assertTrue(rs.next());
assertEquals(3, rs.getInt(1));
assertTrue(!rs.next());
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc2/ConnectionTest.java 0000664 0000000 0000000 00000021034 12050675701 0026377 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc2;
import org.postgresql.test.TestUtil;
import junit.framework.TestCase;
import java.sql.*;
/*
* TestCase to test the internal functionality of org.postgresql.jdbc2.Connection
* and it's superclass.
*
*/
public class ConnectionTest extends TestCase
{
private Connection con;
/*
* Constructor
*/
public ConnectionTest(String name)
{
super(name);
}
// Set up the fixture for this testcase: the tables for this test.
protected void setUp() throws Exception
{
con = TestUtil.openDB();
TestUtil.createTable(con, "test_a", "imagename name,image oid,id int4");
TestUtil.createTable(con, "test_c", "source text,cost money,imageid int4");
TestUtil.closeDB(con);
}
// Tear down the fixture for this test case.
protected void tearDown() throws Exception
{
TestUtil.closeDB(con);
con = TestUtil.openDB();
TestUtil.dropTable(con, "test_a");
TestUtil.dropTable(con, "test_c");
TestUtil.closeDB(con);
}
/*
* Tests the two forms of createStatement()
*/
public void testCreateStatement() throws Exception
{
con = TestUtil.openDB();
// A standard Statement
Statement stat = con.createStatement();
assertNotNull(stat);
stat.close();
// Ask for Updateable ResultSets
stat = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE);
assertNotNull(stat);
stat.close();
}
/*
* Tests the two forms of prepareStatement()
*/
public void testPrepareStatement() throws Exception
{
con = TestUtil.openDB();
String sql = "select source,cost,imageid from test_c";
// A standard Statement
PreparedStatement stat = con.prepareStatement(sql);
assertNotNull(stat);
stat.close();
// Ask for Updateable ResultSets
stat = con.prepareStatement(sql, ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE);
assertNotNull(stat);
stat.close();
}
/*
* Put the test for createPrepareCall here
*/
public void testPrepareCall()
{
}
/*
* Test nativeSQL
*/
public void testNativeSQL() throws Exception
{
// test a simple escape
con = TestUtil.openDB();
assertEquals("DATE '2005-01-24'",con.nativeSQL("{d '2005-01-24'}"));
}
/*
* Test autoCommit (both get & set)
*/
public void testTransactions() throws Exception
{
con = TestUtil.openDB();
Statement st;
ResultSet rs;
// Turn it off
con.setAutoCommit(false);
assertTrue(!con.getAutoCommit());
// Turn it back on
con.setAutoCommit(true);
assertTrue(con.getAutoCommit());
// Now test commit
st = con.createStatement();
st.executeUpdate("insert into test_a (imagename,image,id) values ('comttest',1234,5678)");
con.setAutoCommit(false);
// Now update image to 9876 and commit
st.executeUpdate("update test_a set image=9876 where id=5678");
con.commit();
rs = st.executeQuery("select image from test_a where id=5678");
assertTrue(rs.next());
assertEquals(9876, rs.getInt(1));
rs.close();
// Now try to change it but rollback
st.executeUpdate("update test_a set image=1111 where id=5678");
con.rollback();
rs = st.executeQuery("select image from test_a where id=5678");
assertTrue(rs.next());
assertEquals(9876, rs.getInt(1)); // Should not change!
rs.close();
TestUtil.closeDB(con);
}
/*
* Simple test to see if isClosed works.
*/
public void testIsClosed() throws Exception
{
con = TestUtil.openDB();
// Should not say closed
assertTrue(!con.isClosed());
TestUtil.closeDB(con);
// Should now say closed
assertTrue(con.isClosed());
}
/*
* Test the warnings system
*/
public void testWarnings() throws Exception
{
con = TestUtil.openDB();
String testStr = "This Is OuR TeSt message";
// The connection must be ours!
assertTrue(con instanceof org.postgresql.PGConnection);
// Clear any existing warnings
con.clearWarnings();
// Set the test warning
((org.postgresql.jdbc2.AbstractJdbc2Connection)con).addWarning(new SQLWarning(testStr));
// Retrieve it
SQLWarning warning = con.getWarnings();
assertNotNull(warning);
assertEquals(testStr, warning.getMessage());
// Finally test clearWarnings() this time there must be something to delete
con.clearWarnings();
assertTrue(con.getWarnings() == null);
TestUtil.closeDB(con);
}
/*
* Transaction Isolation Levels
*/
public void testTransactionIsolation() throws Exception
{
con = TestUtil.openDB();
int defaultLevel = con.getTransactionIsolation();
// Begin a transaction
con.setAutoCommit(false);
// The isolation level should not have changed
assertEquals(defaultLevel, con.getTransactionIsolation());
// Now run some tests with autocommit enabled.
con.setAutoCommit(true);
assertEquals(defaultLevel, con.getTransactionIsolation());
con.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
assertEquals(Connection.TRANSACTION_SERIALIZABLE,
con.getTransactionIsolation());
con.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
assertEquals(Connection.TRANSACTION_READ_COMMITTED, con.getTransactionIsolation());
// Test if a change of isolation level before beginning the
// transaction affects the isolation level inside the transaction.
con.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
assertEquals(Connection.TRANSACTION_SERIALIZABLE,
con.getTransactionIsolation());
con.setAutoCommit(false);
assertEquals(Connection.TRANSACTION_SERIALIZABLE,
con.getTransactionIsolation());
con.setAutoCommit(true);
assertEquals(Connection.TRANSACTION_SERIALIZABLE,
con.getTransactionIsolation());
con.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
assertEquals(Connection.TRANSACTION_READ_COMMITTED,
con.getTransactionIsolation());
con.setAutoCommit(false);
assertEquals(Connection.TRANSACTION_READ_COMMITTED,
con.getTransactionIsolation());
con.commit();
// Test that getTransactionIsolation() does not actually start a new txn.
con.getTransactionIsolation(); // Shouldn't start a new transaction.
con.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE); // Should be ok -- we're not in a transaction.
con.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED); // Should still be ok.
// Test that we can't change isolation mid-transaction
Statement stmt = con.createStatement();
stmt.executeQuery("SELECT 1"); // Start transaction.
stmt.close();
try
{
con.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
fail("Expected an exception when changing transaction isolation mid-transaction");
}
catch (SQLException e)
{
// Ok.
}
con.rollback();
TestUtil.closeDB(con);
}
/*
* JDBC2 Type mappings
*/
public void testTypeMaps() throws Exception
{
con = TestUtil.openDB();
// preserve the current map
java.util.Map oldmap = con.getTypeMap();
// now change it for an empty one
java.util.Map newmap = new java.util.HashMap();
con.setTypeMap(newmap);
assertEquals(newmap, con.getTypeMap());
// restore the old one
con.setTypeMap(oldmap);
assertEquals(oldmap, con.getTypeMap());
TestUtil.closeDB(con);
}
/**
* Closing a Connection more than once is not an error.
*/
public void testDoubleClose() throws Exception
{
con = TestUtil.openDB();
con.close();
con.close();
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc2/CopyTest.java 0000664 0000000 0000000 00000022153 12050675701 0025215 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2008-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc2;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.io.IOException;
import java.io.StringReader;
import junit.framework.TestCase;
import org.postgresql.PGConnection;
import org.postgresql.copy.*;
import org.postgresql.test.TestUtil;
import org.postgresql.util.PSQLState;
/**
* @author kato@iki.fi
*
*/
public class CopyTest extends TestCase {
private Connection con;
private CopyManager copyAPI;
private String[] origData =
{ "First Row\t1\t1.10\n", // 0's required to match DB output for numeric(5,2)
"Second Row\t2\t-22.20\n",
"\\N\t\\N\t\\N\n",
"\t4\t444.40\n" };
private int dataRows = origData.length;
public CopyTest(String name) {
super(name);
}
private byte[] getData(String[] origData) {
ByteArrayOutputStream buf = new ByteArrayOutputStream();
PrintStream ps = new PrintStream(buf);
for(int i=0; i 0) {
at = "buffering";
InputStream ins = new ByteArrayInputStream(getData(origData));
at = "skipping";
ins.skip(skip++);
skipChar = ins.read();
at = "copying";
copyAPI.copyIn(sql, ins, 3);
at = "using connection after writing copy";
rowCount = getCount();
}
} catch(Exception e) {
if( !( skipChar=='\t' ) ) // error expected when field separator consumed
fail("testSkipping at " + at + " round " + skip + ": " + e.toString());
}
assertEquals(dataRows*(skip-1), rowCount);
}
public void testCopyOutByRow() throws SQLException, IOException {
testCopyInByRow(); // ensure we have some data.
String sql = "COPY copytest TO STDOUT";
CopyOut cp = copyAPI.copyOut(sql);
int count = 0;
byte buf[];
while ( (buf = cp.readFromCopy()) != null) {
count++;
}
assertEquals(false, cp.isActive());
assertEquals(dataRows, count);
long rowCount = cp.getHandledRowCount();
long expectedResult = -1;
if (TestUtil.haveMinimumServerVersion(con, "8.2")) {
expectedResult = dataRows;
}
assertEquals(expectedResult, rowCount);
assertEquals(dataRows, getCount());
}
public void testCopyOut() throws SQLException, IOException {
testCopyInByRow(); // ensure we have some data.
String sql = "COPY copytest TO STDOUT";
ByteArrayOutputStream copydata = new ByteArrayOutputStream();
copyAPI.copyOut(sql, copydata);
assertEquals(dataRows, getCount());
// deep comparison of data written and read
byte[] copybytes = copydata.toByteArray();
assertTrue(copybytes != null);
for(int i=0, l=0; i= l + origBytes.length);
for(int j=0; j> 12)&15));
sb.append(Integer.toHexString((c >> 8)&15));
sb.append(Integer.toHexString((c >> 4)&15));
sb.append(Integer.toHexString(c&15));
}
return sb.toString();
}
public void testEncoding() throws Exception {
// Check that we have a UTF8 server encoding, or we must skip this test.
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery("SELECT getdatabaseencoding()");
assertTrue(rs.next());
String dbEncoding = rs.getString(1);
if (!dbEncoding.equals("UTF8"))
{
System.err.println("DatabaseEncodingTest: Skipping UTF8 database tests as test database encoding is " + dbEncoding);
rs.close();
return ; // not a UTF8 database.
}
rs.close();
boolean testHighUnicode = TestUtil.haveMinimumServerVersion(con, "8.1");
// Create data.
// NB: we avoid d800-dfff as those are reserved for surrogates in UTF-16
PreparedStatement insert = con.prepareStatement("INSERT INTO testdbencoding(unicode_ordinal, unicode_string) VALUES (?,?)");
for (int i = 1; i < 0xd800; i += STEP)
{
int count = (i + STEP) > 0xd800 ? 0xd800 - i : STEP;
char[] testChars = new char[count];
for (int j = 0; j < count; ++j)
testChars[j] = (char)(i + j);
String testString = new String(testChars);
insert.setInt(1, i);
insert.setString(2, testString);
assertEquals(1, insert.executeUpdate());
}
for (int i = 0xe000; i < 0x10000; i += STEP)
{
int count = (i + STEP) > 0x10000 ? 0x10000 - i : STEP;
char[] testChars = new char[count];
for (int j = 0; j < count; ++j)
testChars[j] = (char)(i + j);
String testString = new String(testChars);
insert.setInt(1, i);
insert.setString(2, testString);
assertEquals(1, insert.executeUpdate());
}
if (testHighUnicode) {
for (int i = 0x10000; i < 0x110000; i += STEP)
{
int count = (i + STEP) > 0x110000 ? 0x110000 - i : STEP;
char[] testChars = new char[count*2];
for (int j = 0; j < count; ++j) {
testChars[j*2] = (char)(0xd800 + ((i + j - 0x10000) >> 10));
testChars[j*2+1] = (char)(0xdc00 + ((i + j - 0x10000) & 0x3ff));
}
String testString = new String(testChars);
insert.setInt(1, i);
insert.setString(2, testString);
//System.err.println("Inserting: " + dumpString(testString));
assertEquals(1, insert.executeUpdate());
}
}
con.commit();
// Check data.
stmt.setFetchSize(1);
rs = stmt.executeQuery("SELECT unicode_ordinal, unicode_string FROM testdbencoding ORDER BY unicode_ordinal");
for (int i = 1; i < 0xd800; i += STEP)
{
assertTrue(rs.next());
assertEquals(i, rs.getInt(1));
int count = (i + STEP) > 0xd800 ? 0xd800 - i : STEP;
char[] testChars = new char[count];
for (int j = 0; j < count; ++j)
testChars[j] = (char)(i + j);
String testString = new String(testChars);
assertEquals("Test string: " + dumpString(testString), dumpString(testString), dumpString(rs.getString(2)));
}
for (int i = 0xe000; i < 0x10000; i += STEP)
{
assertTrue(rs.next());
assertEquals(i, rs.getInt(1));
int count = (i + STEP) > 0x10000 ? 0x10000 - i : STEP;
char[] testChars = new char[count];
for (int j = 0; j < count; ++j)
testChars[j] = (char)(i + j);
String testString = new String(testChars);
assertEquals("Test string: " + dumpString(testString), dumpString(testString), dumpString(rs.getString(2)));
}
if (testHighUnicode) {
for (int i = 0x10000; i < 0x110000; i += STEP)
{
assertTrue(rs.next());
assertEquals(i, rs.getInt(1));
int count = (i + STEP) > 0x110000 ? 0x110000 - i : STEP;
char[] testChars = new char[count*2];
for (int j = 0; j < count; ++j) {
testChars[j*2] = (char)(0xd800 + ((i + j - 0x10000) >> 10));
testChars[j*2+1] = (char)(0xdc00 + ((i + j - 0x10000) & 0x3ff));
}
String testString = new String(testChars);
assertEquals("Test string: " + dumpString(testString), dumpString(testString), dumpString(rs.getString(2)));
}
}
}
public void testUTF8Decode() throws Exception {
// Tests for our custom UTF-8 decoder.
Encoding utf8Encoding = Encoding.getJVMEncoding("UTF-8");
for (int ch = 0; ch < 0x110000; ++ch) {
if (ch >= 0xd800 && ch < 0xe000)
continue; // Surrogate range.
String testString;
if (ch >= 0x10000) {
testString = new String(new char[] {
(char) (0xd800 + ((ch-0x10000) >> 10)),
(char) (0xdc00 + ((ch-0x10000) & 0x3ff)) });
} else {
testString = new String(new char[] { (char)ch });
}
byte[] jvmEncoding = testString.getBytes("UTF-8");
String jvmDecoding = new String(jvmEncoding, 0, jvmEncoding.length, "UTF-8");
String ourDecoding = utf8Encoding.decode(jvmEncoding, 0, jvmEncoding.length);
assertEquals("Test string: " + dumpString(testString), dumpString(testString), dumpString(jvmDecoding));
assertEquals("Test string: " + dumpString(testString), dumpString(testString), dumpString(ourDecoding));
}
}
public void testBadUTF8Decode() throws Exception {
Encoding utf8Encoding = Encoding.getJVMEncoding("UTF-8");
byte[][] badSequences = new byte[][] {
// One-byte illegal sequences
{ (byte)0x80 }, // First byte may not be 10xxxxxx
// Two-byte illegal sequences
{ (byte)0xc0, (byte)0x00 }, // Second byte must be 10xxxxxx
{ (byte)0xc0, (byte)0x80 }, // Can't represent a value < 0x80
// Three-byte illegal sequences
{ (byte)0xe0, (byte)0x00 }, // Second byte must be 10xxxxxx
{ (byte)0xe0, (byte)0x80, (byte)0x00 }, // Third byte must be 10xxxxxx
{ (byte)0xe0, (byte)0x80, (byte)0x80 }, // Can't represent a value < 0x800
{ (byte)0xed, (byte)0xa0, (byte)0x80 }, // Not allowed to encode the range d800..dfff
// Four-byte illegal sequences
{ (byte)0xf0, (byte)0x00 }, // Second byte must be 10xxxxxx
{ (byte)0xf0, (byte)0x80, (byte)0x00 }, // Third byte must be 10xxxxxx
{ (byte)0xf0, (byte)0x80, (byte)0x80, (byte)0x00 }, // Fourth byte must be 10xxxxxx
{ (byte)0xf0, (byte)0x80, (byte)0x80, (byte)0x80 }, // Can't represent a value < 0x10000
// Five-byte illegal sequences
{ (byte)0xf8 }, // Can't have a five-byte sequence.
// Six-byte illegal sequences
{ (byte)0xfc }, // Can't have a six-byte sequence.
// Seven-byte illegal sequences
{ (byte)0xfe }, // Can't have a seven-byte sequence.
// Eigth-byte illegal sequences
{ (byte)0xff }, // Can't have an eight-byte sequence.
};
byte[] paddedSequence = new byte[32];
for (int i = 0; i < badSequences.length; ++i) {
byte[] sequence = badSequences[i];
try {
String str = utf8Encoding.decode(sequence, 0, sequence.length);
fail("Expected an IOException on sequence " + i + ", but decoded to <" + str + ">");
} catch (IOException ioe) {
// Expected exception.
}
// Try it with padding.
Arrays.fill(paddedSequence, (byte)0);
System.arraycopy(sequence, 0, paddedSequence, 0, sequence.length);
try {
String str = utf8Encoding.decode(paddedSequence, 0, paddedSequence.length);
fail("Expected an IOException on sequence " + i + ", but decoded to <" + str + ">");
} catch (IOException ioe) {
// Expected exception.
}
}
}
public void testTruncatedUTF8Decode() throws Exception {
Encoding utf8Encoding = Encoding.getJVMEncoding("UTF-8");
byte[][] shortSequences = new byte[][] {
{ (byte)0xc0 }, // Second byte must be present
{ (byte)0xe0 }, // Second byte must be present
{ (byte)0xe0, (byte)0x80 }, // Third byte must be present
{ (byte)0xf0 }, // Second byte must be present
{ (byte)0xf0, (byte)0x80 }, // Third byte must be present
{ (byte)0xf0, (byte)0x80, (byte)0x80 }, // Fourth byte must be present
};
byte[] paddedSequence = new byte[32];
for (int i = 0; i < shortSequences.length; ++i) {
byte[] sequence = shortSequences[i];
try {
String str = utf8Encoding.decode(sequence, 0, sequence.length);
fail("Expected an IOException on sequence " + i + ", but decoded to <" + str + ">");
} catch (IOException ioe) {
// Expected exception.
}
// Try it with padding and a truncated length.
Arrays.fill(paddedSequence, (byte)0);
System.arraycopy(sequence, 0, paddedSequence, 0, sequence.length);
try {
String str = utf8Encoding.decode(paddedSequence, 0, sequence.length);
fail("Expected an IOException on sequence " + i + ", but decoded to <" + str + ">");
} catch (IOException ioe) {
// Expected exception.
}
}
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc2/DatabaseMetaDataPropertiesTest.java 0000664 0000000 0000000 00000015756 12050675701 0031500 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc2;
import org.postgresql.test.TestUtil;
import junit.framework.TestCase;
import java.sql.*;
/*
* TestCase to test the internal functionality of
* org.postgresql.jdbc2.DatabaseMetaData's various properties.
* Methods which return a ResultSet are tested elsewhere.
* This avoids a complicated setUp/tearDown for something like
* assertTrue(dbmd.nullPlusNonNullIsNull());
*/
public class DatabaseMetaDataPropertiesTest extends TestCase
{
private Connection con;
/*
* Constructor
*/
public DatabaseMetaDataPropertiesTest(String name)
{
super(name);
}
protected void setUp() throws Exception
{
con = TestUtil.openDB();
}
protected void tearDown() throws Exception
{
TestUtil.closeDB( con );
}
/*
* The spec says this may return null, but we always do!
*/
public void testGetMetaData() throws SQLException
{
DatabaseMetaData dbmd = con.getMetaData();
assertNotNull(dbmd);
}
/*
* Test default capabilities
*/
public void testCapabilities() throws SQLException
{
DatabaseMetaData dbmd = con.getMetaData();
assertNotNull(dbmd);
assertTrue(dbmd.allProceduresAreCallable());
assertTrue(dbmd.allTablesAreSelectable()); // not true all the time
// This should always be false for postgresql (at least for 7.x)
assertTrue(!dbmd.isReadOnly());
// we support multiple resultsets via multiple statements in one execute() now
assertTrue(dbmd.supportsMultipleResultSets());
// yes, as multiple backends can have transactions open
assertTrue(dbmd.supportsMultipleTransactions());
assertTrue(dbmd.supportsMinimumSQLGrammar());
assertTrue(!dbmd.supportsCoreSQLGrammar());
assertTrue(!dbmd.supportsExtendedSQLGrammar());
if (TestUtil.haveMinimumServerVersion(con, "7.3"))
assertTrue(dbmd.supportsANSI92EntryLevelSQL());
else
assertTrue(!dbmd.supportsANSI92EntryLevelSQL());
assertTrue(!dbmd.supportsANSI92IntermediateSQL());
assertTrue(!dbmd.supportsANSI92FullSQL());
assertTrue(dbmd.supportsIntegrityEnhancementFacility());
}
public void testJoins() throws SQLException
{
DatabaseMetaData dbmd = con.getMetaData();
assertNotNull(dbmd);
assertTrue(dbmd.supportsOuterJoins());
assertTrue(dbmd.supportsFullOuterJoins());
assertTrue(dbmd.supportsLimitedOuterJoins());
}
public void testCursors() throws SQLException
{
DatabaseMetaData dbmd = con.getMetaData();
assertNotNull(dbmd);
assertTrue(!dbmd.supportsPositionedDelete());
assertTrue(!dbmd.supportsPositionedUpdate());
}
public void testValues() throws SQLException
{
DatabaseMetaData dbmd = con.getMetaData();
assertNotNull(dbmd);
int indexMaxKeys = dbmd.getMaxColumnsInIndex();
if (TestUtil.haveMinimumServerVersion(con, "7.3"))
{
assertEquals(32, indexMaxKeys);
}
else
{
assertEquals(16, indexMaxKeys);
}
}
public void testNulls() throws SQLException
{
DatabaseMetaData dbmd = con.getMetaData();
assertNotNull(dbmd);
assertTrue(!dbmd.nullsAreSortedAtStart());
assertTrue( dbmd.nullsAreSortedAtEnd() != TestUtil.haveMinimumServerVersion(con, "7.2"));
assertTrue( dbmd.nullsAreSortedHigh() == TestUtil.haveMinimumServerVersion(con, "7.2"));
assertTrue(!dbmd.nullsAreSortedLow());
assertTrue(dbmd.nullPlusNonNullIsNull());
assertTrue(dbmd.supportsNonNullableColumns());
}
public void testLocalFiles() throws SQLException
{
DatabaseMetaData dbmd = con.getMetaData();
assertNotNull(dbmd);
assertTrue(!dbmd.usesLocalFilePerTable());
assertTrue(!dbmd.usesLocalFiles());
}
public void testIdentifiers() throws SQLException
{
DatabaseMetaData dbmd = con.getMetaData();
assertNotNull(dbmd);
assertTrue(!dbmd.supportsMixedCaseIdentifiers()); // always false
assertTrue(dbmd.supportsMixedCaseQuotedIdentifiers()); // always true
assertTrue(!dbmd.storesUpperCaseIdentifiers()); // always false
assertTrue(dbmd.storesLowerCaseIdentifiers()); // always true
assertTrue(!dbmd.storesUpperCaseQuotedIdentifiers()); // always false
assertTrue(!dbmd.storesLowerCaseQuotedIdentifiers()); // always false
assertTrue(!dbmd.storesMixedCaseQuotedIdentifiers()); // always false
assertTrue(dbmd.getIdentifierQuoteString().equals("\""));
}
public void testTables() throws SQLException
{
DatabaseMetaData dbmd = con.getMetaData();
assertNotNull(dbmd);
// we can add columns
assertTrue(dbmd.supportsAlterTableWithAddColumn());
// we can only drop columns in >= 7.3
if (TestUtil.haveMinimumServerVersion(con, "7.3"))
{
assertTrue(dbmd.supportsAlterTableWithDropColumn());
}
else
{
assertTrue(!dbmd.supportsAlterTableWithDropColumn());
}
}
public void testSelect() throws SQLException
{
DatabaseMetaData dbmd = con.getMetaData();
assertNotNull(dbmd);
// yes we can?: SELECT col a FROM a;
assertTrue(dbmd.supportsColumnAliasing());
// yes we can have expressions in ORDERBY
assertTrue(dbmd.supportsExpressionsInOrderBy());
// Yes, an ORDER BY clause can contain columns that are not in the
// SELECT clause.
assertTrue(dbmd.supportsOrderByUnrelated());
assertTrue(dbmd.supportsGroupBy());
assertTrue(dbmd.supportsGroupByUnrelated());
assertTrue(dbmd.supportsGroupByBeyondSelect()); // needs checking
}
public void testDBParams() throws SQLException
{
DatabaseMetaData dbmd = con.getMetaData();
assertNotNull(dbmd);
assertTrue(dbmd.getURL().equals(TestUtil.getURL()));
assertTrue(dbmd.getUserName().equals(TestUtil.getUser()));
}
public void testDbProductDetails() throws SQLException
{
assertTrue(con instanceof org.postgresql.PGConnection);
DatabaseMetaData dbmd = con.getMetaData();
assertNotNull(dbmd);
assertTrue(dbmd.getDatabaseProductName().equals("PostgreSQL"));
}
public void testDriverVersioning() throws SQLException
{
DatabaseMetaData dbmd = con.getMetaData();
assertNotNull(dbmd);
assertTrue(dbmd.getDriverVersion().equals(org.postgresql.Driver.getVersion()));
assertTrue(dbmd.getDriverMajorVersion() == org.postgresql.Driver.MAJORVERSION);
assertTrue(dbmd.getDriverMinorVersion() == org.postgresql.Driver.MINORVERSION);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc2/DatabaseMetaDataTest.java 0000664 0000000 0000000 00000113404 12050675701 0027410 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc2;
import org.postgresql.test.TestUtil;
import junit.framework.TestCase;
import java.sql.*;
/*
* TestCase to test the internal functionality of org.postgresql.jdbc2.DatabaseMetaData
*
*/
public class DatabaseMetaDataTest extends TestCase
{
private Connection con;
/*
* Constructor
*/
public DatabaseMetaDataTest(String name)
{
super(name);
}
protected void setUp() throws Exception
{
con = TestUtil.openDB();
TestUtil.createTable( con, "metadatatest", "id int4, name text, updated timestamptz, colour text, quest text" );
TestUtil.dropSequence( con, "sercoltest_b_seq");
TestUtil.dropSequence( con, "sercoltest_c_seq");
TestUtil.createTable( con, "sercoltest", "a int, b serial, c bigserial");
TestUtil.createTable( con, "\"a\\\"", "a int4");
TestUtil.createTable( con, "\"a'\"", "a int4");
TestUtil.createTable( con, "arraytable", "a numeric(5,2)[], b varchar(100)[]");
Statement stmt = con.createStatement();
//we add the following comments to ensure the joins to the comments
//are done correctly. This ensures we correctly test that case.
stmt.execute("comment on table metadatatest is 'this is a table comment'");
stmt.execute("comment on column metadatatest.id is 'this is a column comment'");
stmt.execute("CREATE OR REPLACE FUNCTION f1(int, varchar) RETURNS int AS 'SELECT 1;' LANGUAGE SQL");
if (TestUtil.haveMinimumServerVersion(con, "8.0")) {
stmt.execute("CREATE OR REPLACE FUNCTION f2(a int, b varchar) RETURNS int AS 'SELECT 1;' LANGUAGE SQL");
}
if (TestUtil.haveMinimumServerVersion(con, "8.1")) {
stmt.execute("CREATE OR REPLACE FUNCTION f3(IN a int, INOUT b varchar, OUT c timestamptz) AS $f$ BEGIN b := 'a'; c := now(); return; END; $f$ LANGUAGE plpgsql");
}
stmt.execute("CREATE OR REPLACE FUNCTION f4(int) RETURNS metadatatest AS 'SELECT 1, ''a''::text, now(), ''c''::text, ''q''::text' LANGUAGE SQL");
if (TestUtil.haveMinimumServerVersion(con, "7.3")) {
stmt.execute("CREATE DOMAIN nndom AS int not null");
stmt.execute("CREATE TABLE domaintable (id nndom)");
}
stmt.close();
}
protected void tearDown() throws Exception
{
// Drop function first because it depends on the
// metadatatest table's type
Statement stmt = con.createStatement();
stmt.execute("DROP FUNCTION f4(int)");
TestUtil.dropTable( con, "metadatatest" );
TestUtil.dropTable( con, "sercoltest");
TestUtil.dropSequence( con, "sercoltest_b_seq");
TestUtil.dropSequence( con, "sercoltest_c_seq");
TestUtil.dropTable( con, "\"a\\\"");
TestUtil.dropTable( con, "\"a'\"");
TestUtil.dropTable( con, "arraytable");
stmt.execute("DROP FUNCTION f1(int, varchar)");
if (TestUtil.haveMinimumServerVersion(con, "8.0")) {
stmt.execute("DROP FUNCTION f2(int, varchar)");
}
if (TestUtil.haveMinimumServerVersion(con, "8.1")) {
stmt.execute("DROP FUNCTION f3(int, varchar)");
}
if (TestUtil.haveMinimumServerVersion(con, "7.3")) {
stmt.execute("DROP TABLE domaintable");
stmt.execute("DROP DOMAIN nndom");
}
TestUtil.closeDB( con );
}
public void testTables() throws Exception
{
DatabaseMetaData dbmd = con.getMetaData();
assertNotNull(dbmd);
ResultSet rs = dbmd.getTables( null, null, "metadatates%", new String[] {"TABLE"});
assertTrue( rs.next() );
String tableName = rs.getString("TABLE_NAME");
assertEquals( "metadatatest", tableName );
String tableType = rs.getString("TABLE_TYPE");
assertEquals( "TABLE", tableType );
//There should only be one row returned
assertTrue( "getTables() returned too many rows", rs.next() == false);
rs.close();
rs = dbmd.getColumns("", "", "meta%", "%" );
assertTrue( rs.next() );
assertEquals( "metadatatest", rs.getString("TABLE_NAME") );
assertEquals( "id", rs.getString("COLUMN_NAME") );
assertEquals( java.sql.Types.INTEGER, rs.getInt("DATA_TYPE") );
assertTrue( rs.next() );
assertEquals( "metadatatest", rs.getString("TABLE_NAME") );
assertEquals( "name", rs.getString("COLUMN_NAME") );
assertEquals( java.sql.Types.VARCHAR, rs.getInt("DATA_TYPE") );
assertTrue( rs.next() );
assertEquals( "metadatatest", rs.getString("TABLE_NAME") );
assertEquals( "updated", rs.getString("COLUMN_NAME") );
assertEquals( java.sql.Types.TIMESTAMP, rs.getInt("DATA_TYPE") );
}
public void testCrossReference() throws Exception
{
Connection con1 = TestUtil.openDB();
TestUtil.createTable( con1, "vv", "a int not null, b int not null, primary key ( a, b )" );
TestUtil.createTable( con1, "ww", "m int not null, n int not null, primary key ( m, n ), foreign key ( m, n ) references vv ( a, b )" );
DatabaseMetaData dbmd = con.getMetaData();
assertNotNull(dbmd);
ResultSet rs = dbmd.getCrossReference(null, "", "vv", null, "", "ww" );
for (int j = 1; rs.next(); j++ )
{
String pkTableName = rs.getString( "PKTABLE_NAME" );
assertEquals ( "vv", pkTableName );
String pkColumnName = rs.getString( "PKCOLUMN_NAME" );
assertTrue( pkColumnName.equals("a") || pkColumnName.equals("b"));
String fkTableName = rs.getString( "FKTABLE_NAME" );
assertEquals( "ww", fkTableName );
String fkColumnName = rs.getString( "FKCOLUMN_NAME" );
assertTrue( fkColumnName.equals( "m" ) || fkColumnName.equals( "n" ) ) ;
String fkName = rs.getString( "FK_NAME" );
if (TestUtil.haveMinimumServerVersion(con1, "8.0"))
{
assertEquals("ww_m_fkey", fkName);
}
else if (TestUtil.haveMinimumServerVersion(con1, "7.3"))
{
assertTrue(fkName.startsWith("$1"));
}
else
{
assertTrue( fkName.startsWith( "") );
}
String pkName = rs.getString( "PK_NAME" );
assertEquals( "vv_pkey", pkName );
int keySeq = rs.getInt( "KEY_SEQ" );
assertEquals( j, keySeq );
}
TestUtil.dropTable( con1, "vv" );
TestUtil.dropTable( con1, "ww" );
TestUtil.closeDB(con1);
}
public void testForeignKeyActions() throws Exception
{
Connection conn = TestUtil.openDB();
TestUtil.createTable(conn, "pkt", "id int primary key");
TestUtil.createTable(conn, "fkt1", "id int references pkt on update restrict on delete cascade");
TestUtil.createTable(conn, "fkt2", "id int references pkt on update set null on delete set default");
DatabaseMetaData dbmd = conn.getMetaData();
ResultSet rs = dbmd.getImportedKeys(null, "", "fkt1");
assertTrue(rs.next());
assertTrue(rs.getInt("UPDATE_RULE") == DatabaseMetaData.importedKeyRestrict);
assertTrue(rs.getInt("DELETE_RULE") == DatabaseMetaData.importedKeyCascade);
rs.close();
rs = dbmd.getImportedKeys(null, "", "fkt2");
assertTrue(rs.next());
assertTrue(rs.getInt("UPDATE_RULE") == DatabaseMetaData.importedKeySetNull);
assertTrue(rs.getInt("DELETE_RULE") == DatabaseMetaData.importedKeySetDefault);
rs.close();
TestUtil.dropTable(conn, "fkt2");
TestUtil.dropTable(conn, "fkt1");
TestUtil.dropTable(conn, "pkt");
TestUtil.closeDB(conn);
}
public void testForeignKeysToUniqueIndexes() throws Exception
{
if (!TestUtil.haveMinimumServerVersion(con, "7.4"))
return ;
Connection con1 = TestUtil.openDB();
TestUtil.createTable( con1, "pkt", "a int not null, b int not null, CONSTRAINT pkt_pk_a PRIMARY KEY (a), CONSTRAINT pkt_un_b UNIQUE (b)");
TestUtil.createTable( con1, "fkt", "c int, d int, CONSTRAINT fkt_fk_c FOREIGN KEY (c) REFERENCES pkt(b)");
DatabaseMetaData dbmd = con.getMetaData();
ResultSet rs = dbmd.getImportedKeys("", "", "fkt");
int j = 0;
for (; rs.next(); j++)
{
assertTrue("pkt".equals(rs.getString("PKTABLE_NAME")));
assertTrue("fkt".equals(rs.getString("FKTABLE_NAME")));
assertTrue("pkt_un_b".equals(rs.getString("PK_NAME")));
assertTrue("b".equals(rs.getString("PKCOLUMN_NAME")));
}
assertTrue(j == 1);
TestUtil.dropTable(con1, "fkt");
TestUtil.dropTable(con1, "pkt");
con1.close();
}
public void testMultiColumnForeignKeys() throws Exception
{
Connection con1 = TestUtil.openDB();
TestUtil.createTable( con1, "pkt", "a int not null, b int not null, CONSTRAINT pkt_pk PRIMARY KEY (a,b)");
TestUtil.createTable( con1, "fkt", "c int, d int, CONSTRAINT fkt_fk_pkt FOREIGN KEY (c,d) REFERENCES pkt(b,a)");
DatabaseMetaData dbmd = con.getMetaData();
ResultSet rs = dbmd.getImportedKeys("", "", "fkt");
int j = 0;
for (; rs.next(); j++)
{
assertTrue("pkt".equals(rs.getString("PKTABLE_NAME")));
assertTrue("fkt".equals(rs.getString("FKTABLE_NAME")));
assertTrue(j + 1 == rs.getInt("KEY_SEQ"));
if (j == 0)
{
assertTrue("b".equals(rs.getString("PKCOLUMN_NAME")));
assertTrue("c".equals(rs.getString("FKCOLUMN_NAME")));
}
else
{
assertTrue("a".equals(rs.getString("PKCOLUMN_NAME")));
assertTrue("d".equals(rs.getString("FKCOLUMN_NAME")));
}
}
assertTrue(j == 2);
TestUtil.dropTable(con1, "fkt");
TestUtil.dropTable(con1, "pkt");
con1.close();
}
public void testForeignKeys() throws Exception
{
Connection con1 = TestUtil.openDB();
TestUtil.createTable( con1, "people", "id int4 primary key, name text" );
TestUtil.createTable( con1, "policy", "id int4 primary key, name text" );
TestUtil.createTable( con1, "users", "id int4 primary key, people_id int4, policy_id int4," +
"CONSTRAINT people FOREIGN KEY (people_id) references people(id)," +
"constraint policy FOREIGN KEY (policy_id) references policy(id)" );
DatabaseMetaData dbmd = con.getMetaData();
assertNotNull(dbmd);
ResultSet rs = dbmd.getImportedKeys(null, "", "users" );
int j = 0;
for (; rs.next(); j++ )
{
String pkTableName = rs.getString( "PKTABLE_NAME" );
assertTrue ( pkTableName.equals("people") || pkTableName.equals("policy") );
String pkColumnName = rs.getString( "PKCOLUMN_NAME" );
assertEquals( "id", pkColumnName );
String fkTableName = rs.getString( "FKTABLE_NAME" );
assertEquals( "users", fkTableName );
String fkColumnName = rs.getString( "FKCOLUMN_NAME" );
assertTrue( fkColumnName.equals( "people_id" ) || fkColumnName.equals( "policy_id" ) ) ;
String fkName = rs.getString( "FK_NAME" );
assertTrue( fkName.startsWith( "people") || fkName.startsWith( "policy" ) );
String pkName = rs.getString( "PK_NAME" );
assertTrue( pkName.equals( "people_pkey") || pkName.equals( "policy_pkey" ) );
}
assertTrue ( j == 2 );
rs = dbmd.getExportedKeys( null, "", "people" );
// this is hacky, but it will serve the purpose
assertTrue ( rs.next() );
assertEquals( "people", rs.getString( "PKTABLE_NAME" ) );
assertEquals( "id", rs.getString( "PKCOLUMN_NAME" ) );
assertEquals( "users", rs.getString( "FKTABLE_NAME" ) );
assertEquals( "people_id", rs.getString( "FKCOLUMN_NAME" ) );
assertTrue( rs.getString( "FK_NAME" ).startsWith( "people" ) );
TestUtil.dropTable( con1, "users" );
TestUtil.dropTable( con1, "people" );
TestUtil.dropTable( con1, "policy" );
TestUtil.closeDB(con1);
}
public void testColumns() throws SQLException
{
// At the moment just test that no exceptions are thrown KJ
DatabaseMetaData dbmd = con.getMetaData();
assertNotNull(dbmd);
ResultSet rs = dbmd.getColumns(null, null, "pg_class", null);
rs.close();
}
public void testDroppedColumns() throws SQLException
{
if (!TestUtil.haveMinimumServerVersion(con, "8.4"))
return;
Statement stmt = con.createStatement();
stmt.execute("ALTER TABLE metadatatest DROP name");
stmt.execute("ALTER TABLE metadatatest DROP colour");
stmt.close();
DatabaseMetaData dbmd = con.getMetaData();
ResultSet rs = dbmd.getColumns(null, null, "metadatatest", null);
assertTrue(rs.next());
assertEquals("id", rs.getString("COLUMN_NAME"));
assertEquals(1, rs.getInt("ORDINAL_POSITION"));
assertTrue(rs.next());
assertEquals("updated", rs.getString("COLUMN_NAME"));
assertEquals(2, rs.getInt("ORDINAL_POSITION"));
assertTrue(rs.next());
assertEquals("quest", rs.getString("COLUMN_NAME"));
assertEquals(3, rs.getInt("ORDINAL_POSITION"));
rs.close();
rs = dbmd.getColumns(null, null, "metadatatest", "quest");
assertTrue(rs.next());
assertEquals("quest", rs.getString("COLUMN_NAME"));
assertEquals(3, rs.getInt("ORDINAL_POSITION"));
assertTrue(!rs.next());
rs.close();
}
public void testSerialColumns() throws SQLException
{
DatabaseMetaData dbmd = con.getMetaData();
ResultSet rs = dbmd.getColumns(null, null, "sercoltest", null);
int rownum = 0;
while (rs.next())
{
assertEquals("sercoltest", rs.getString("TABLE_NAME"));
assertEquals(rownum + 1, rs.getInt("ORDINAL_POSITION"));
if (rownum == 0)
{
assertEquals("int4", rs.getString("TYPE_NAME"));
}
else if (rownum == 1)
{
assertEquals("serial", rs.getString("TYPE_NAME"));
}
else if (rownum == 2)
{
assertEquals("bigserial", rs.getString("TYPE_NAME"));
}
rownum++;
}
assertEquals(3, rownum);
rs.close();
}
public void testColumnPrivileges() throws SQLException
{
// At the moment just test that no exceptions are thrown KJ
DatabaseMetaData dbmd = con.getMetaData();
assertNotNull(dbmd);
ResultSet rs = dbmd.getColumnPrivileges(null, null, "pg_statistic", null);
rs.close();
}
public void testTablePrivileges() throws SQLException
{
DatabaseMetaData dbmd = con.getMetaData();
assertNotNull(dbmd);
ResultSet rs = dbmd.getTablePrivileges(null, null, "metadatatest");
boolean l_foundSelect = false;
while (rs.next())
{
if (rs.getString("GRANTEE").equals(TestUtil.getUser())
&& rs.getString("PRIVILEGE").equals("SELECT"))
l_foundSelect = true;
}
rs.close();
//Test that the table owner has select priv
assertTrue("Couldn't find SELECT priv on table metadatatest for " + TestUtil.getUser(), l_foundSelect);
}
public void testNoTablePrivileges() throws SQLException
{
Statement stmt = con.createStatement();
stmt.execute("REVOKE ALL ON metadatatest FROM PUBLIC");
stmt.execute("REVOKE ALL ON metadatatest FROM " + TestUtil.getUser());
DatabaseMetaData dbmd = con.getMetaData();
ResultSet rs = dbmd.getTablePrivileges(null, null, "metadatatest");
assertTrue(!rs.next());
}
public void testPrimaryKeys() throws SQLException
{
// At the moment just test that no exceptions are thrown KJ
DatabaseMetaData dbmd = con.getMetaData();
assertNotNull(dbmd);
ResultSet rs = dbmd.getPrimaryKeys(null, null, "pg_class");
rs.close();
}
public void testIndexInfo() throws SQLException
{
Statement stmt = con.createStatement();
stmt.execute("create index idx_id on metadatatest (id)");
stmt.execute("create index idx_func_single on metadatatest (upper(colour))");
stmt.execute("create unique index idx_un_id on metadatatest(id)");
if (TestUtil.haveMinimumServerVersion(con, "7.4")) {
stmt.execute("create index idx_func_multi on metadatatest (upper(colour), upper(quest))");
stmt.execute("create index idx_func_mixed on metadatatest (colour, upper(quest))");
}
DatabaseMetaData dbmd = con.getMetaData();
assertNotNull(dbmd);
ResultSet rs = dbmd.getIndexInfo(null, null, "metadatatest", false, false);
assertTrue(rs.next());
assertEquals("idx_un_id", rs.getString("INDEX_NAME"));
assertEquals(1, rs.getInt("ORDINAL_POSITION"));
assertEquals("id", rs.getString("COLUMN_NAME"));
assertTrue(!rs.getBoolean("NON_UNIQUE"));
if (TestUtil.haveMinimumServerVersion(con, "7.4")) {
assertTrue(rs.next());
assertEquals("idx_func_mixed", rs.getString("INDEX_NAME"));
assertEquals(1, rs.getInt("ORDINAL_POSITION"));
assertEquals("colour", rs.getString("COLUMN_NAME"));
assertTrue(rs.next());
assertEquals("idx_func_mixed", rs.getString("INDEX_NAME"));
assertEquals(2, rs.getInt("ORDINAL_POSITION"));
assertEquals("upper(quest)", rs.getString("COLUMN_NAME"));
assertTrue(rs.next());
assertEquals("idx_func_multi", rs.getString("INDEX_NAME"));
assertEquals(1, rs.getInt("ORDINAL_POSITION"));
assertEquals("upper(colour)", rs.getString("COLUMN_NAME"));
assertTrue(rs.next());
assertEquals("idx_func_multi", rs.getString("INDEX_NAME"));
assertEquals(2, rs.getInt("ORDINAL_POSITION"));
assertEquals("upper(quest)", rs.getString("COLUMN_NAME"));
}
assertTrue(rs.next());
assertEquals("idx_func_single", rs.getString("INDEX_NAME"));
assertEquals(1, rs.getInt("ORDINAL_POSITION"));
assertEquals("upper(colour)", rs.getString("COLUMN_NAME"));
assertTrue(rs.next());
assertEquals("idx_id", rs.getString("INDEX_NAME"));
assertEquals(1, rs.getInt("ORDINAL_POSITION"));
assertEquals("id", rs.getString("COLUMN_NAME"));
assertTrue(rs.getBoolean("NON_UNIQUE"));
assertTrue(!rs.next());
rs.close();
}
public void testNotNullDomainColumn() throws SQLException
{
if (!TestUtil.haveMinimumServerVersion(con, "7.3"))
return;
DatabaseMetaData dbmd = con.getMetaData();
ResultSet rs = dbmd.getColumns("", "", "domaintable", "");
assertTrue(rs.next());
assertEquals("id", rs.getString("COLUMN_NAME"));
assertEquals("NO", rs.getString("IS_NULLABLE"));
assertTrue(!rs.next());
}
public void testAscDescIndexInfo() throws SQLException
{
if (!TestUtil.haveMinimumServerVersion(con, "8.3"))
return;
Statement stmt = con.createStatement();
stmt.execute("CREATE INDEX idx_a_d ON metadatatest (id ASC, quest DESC)");
stmt.close();
DatabaseMetaData dbmd = con.getMetaData();
ResultSet rs = dbmd.getIndexInfo(null, null, "metadatatest", false, false);
assertTrue(rs.next());
assertEquals("idx_a_d", rs.getString("INDEX_NAME"));
assertEquals("id", rs.getString("COLUMN_NAME"));
assertEquals("A", rs.getString("ASC_OR_DESC"));
assertTrue(rs.next());
assertEquals("idx_a_d", rs.getString("INDEX_NAME"));
assertEquals("quest", rs.getString("COLUMN_NAME"));
assertEquals("D", rs.getString("ASC_OR_DESC"));
}
public void testPartialIndexInfo() throws SQLException
{
Statement stmt = con.createStatement();
stmt.execute("create index idx_p_name_id on metadatatest (name) where id > 5");
stmt.close();
DatabaseMetaData dbmd = con.getMetaData();
ResultSet rs = dbmd.getIndexInfo(null, null, "metadatatest", false, false);
assertTrue(rs.next());
assertEquals("idx_p_name_id", rs.getString("INDEX_NAME"));
assertEquals(1, rs.getInt("ORDINAL_POSITION"));
assertEquals("name", rs.getString("COLUMN_NAME"));
assertEquals("(id > 5)", rs.getString("FILTER_CONDITION"));
assertTrue(rs.getBoolean("NON_UNIQUE"));
rs.close();
}
public void testTableTypes() throws SQLException
{
// At the moment just test that no exceptions are thrown KJ
DatabaseMetaData dbmd = con.getMetaData();
assertNotNull(dbmd);
ResultSet rs = dbmd.getTableTypes();
rs.close();
}
public void testFuncWithoutNames() throws SQLException
{
DatabaseMetaData dbmd = con.getMetaData();
assertNotNull(dbmd);
ResultSet rs = dbmd.getProcedureColumns(null, null, "f1", null);
assertTrue(rs.next());
assertEquals("returnValue", rs.getString(4));
assertEquals(DatabaseMetaData.procedureColumnReturn, rs.getInt(5));
assertTrue(rs.next());
assertEquals("$1", rs.getString(4));
assertEquals(DatabaseMetaData.procedureColumnIn, rs.getInt(5));
assertEquals(Types.INTEGER, rs.getInt(6));
assertTrue(rs.next());
assertEquals("$2", rs.getString(4));
assertEquals(DatabaseMetaData.procedureColumnIn, rs.getInt(5));
assertEquals(Types.VARCHAR, rs.getInt(6));
assertTrue(!rs.next());
rs.close();
}
public void testFuncWithNames() throws SQLException
{
if (!TestUtil.haveMinimumServerVersion(con, "8.0"))
return;
DatabaseMetaData dbmd = con.getMetaData();
ResultSet rs = dbmd.getProcedureColumns(null, null, "f2", null);
assertTrue(rs.next());
assertTrue(rs.next());
assertEquals("a", rs.getString(4));
assertTrue(rs.next());
assertEquals("b", rs.getString(4));
assertTrue(!rs.next());
rs.close();
}
public void testFuncWithDirection() throws SQLException
{
if (!TestUtil.haveMinimumServerVersion(con, "8.1"))
return;
DatabaseMetaData dbmd = con.getMetaData();
ResultSet rs = dbmd.getProcedureColumns(null, null, "f3", null);
assertTrue(rs.next());
assertEquals("a", rs.getString(4));
assertEquals(DatabaseMetaData.procedureColumnIn, rs.getInt(5));
assertEquals(Types.INTEGER, rs.getInt(6));
assertTrue(rs.next());
assertEquals("b", rs.getString(4));
assertEquals(DatabaseMetaData.procedureColumnInOut, rs.getInt(5));
assertEquals(Types.VARCHAR, rs.getInt(6));
assertTrue(rs.next());
assertEquals("c", rs.getString(4));
assertEquals(DatabaseMetaData.procedureColumnOut, rs.getInt(5));
assertEquals(Types.TIMESTAMP, rs.getInt(6));
rs.close();
}
public void testFuncReturningComposite() throws SQLException
{
DatabaseMetaData dbmd = con.getMetaData();
ResultSet rs = dbmd.getProcedureColumns(null, null, "f4", null);
assertTrue(rs.next());
assertEquals("$1", rs.getString(4));
assertEquals(DatabaseMetaData.procedureColumnIn, rs.getInt(5));
assertEquals(Types.INTEGER, rs.getInt(6));
assertTrue(rs.next());
assertEquals("id", rs.getString(4));
assertEquals(DatabaseMetaData.procedureColumnResult, rs.getInt(5));
assertEquals(Types.INTEGER, rs.getInt(6));
assertTrue(rs.next());
assertEquals("name", rs.getString(4));
assertEquals(DatabaseMetaData.procedureColumnResult, rs.getInt(5));
assertEquals(Types.VARCHAR, rs.getInt(6));
assertTrue(rs.next());
assertEquals("updated", rs.getString(4));
assertEquals(DatabaseMetaData.procedureColumnResult, rs.getInt(5));
assertEquals(Types.TIMESTAMP, rs.getInt(6));
assertTrue(rs.next());
assertEquals("colour", rs.getString(4));
assertEquals(DatabaseMetaData.procedureColumnResult, rs.getInt(5));
assertEquals(Types.VARCHAR, rs.getInt(6));
assertTrue(rs.next());
assertEquals("quest", rs.getString(4));
assertEquals(DatabaseMetaData.procedureColumnResult, rs.getInt(5));
assertEquals(Types.VARCHAR, rs.getInt(6));
assertTrue(!rs.next());
rs.close();
}
public void testVersionColumns() throws SQLException
{
// At the moment just test that no exceptions are thrown KJ
DatabaseMetaData dbmd = con.getMetaData();
assertNotNull(dbmd);
ResultSet rs = dbmd.getVersionColumns(null, null, "pg_class");
rs.close();
}
public void testBestRowIdentifier() throws SQLException
{
// At the moment just test that no exceptions are thrown KJ
DatabaseMetaData dbmd = con.getMetaData();
assertNotNull(dbmd);
ResultSet rs = dbmd.getBestRowIdentifier(null, null, "pg_type", DatabaseMetaData.bestRowSession, false);
rs.close();
}
public void testProcedures() throws SQLException
{
// At the moment just test that no exceptions are thrown KJ
DatabaseMetaData dbmd = con.getMetaData();
assertNotNull(dbmd);
ResultSet rs = dbmd.getProcedures(null, null, null);
rs.close();
}
public void testCatalogs() throws SQLException
{
DatabaseMetaData dbmd = con.getMetaData();
ResultSet rs = dbmd.getCatalogs();
assertTrue(rs.next());
assertEquals(con.getCatalog(), rs.getString(1));
assertTrue(!rs.next());
}
public void testSchemas() throws Exception
{
DatabaseMetaData dbmd = con.getMetaData();
assertNotNull(dbmd);
ResultSet rs = dbmd.getSchemas();
boolean foundPublic = false;
boolean foundEmpty = false;
boolean foundPGCatalog = false;
int count;
for (count = 0; rs.next(); count++)
{
String schema = rs.getString("TABLE_SCHEM");
if ("public".equals(schema))
{
foundPublic = true;
}
else if ("".equals(schema))
{
foundEmpty = true;
}
else if ("pg_catalog".equals(schema))
{
foundPGCatalog = true;
}
}
rs.close();
if (TestUtil.haveMinimumServerVersion(con, "7.3"))
{
assertTrue(count >= 2);
assertTrue(foundPublic);
assertTrue(foundPGCatalog);
assertTrue(!foundEmpty);
}
else
{
assertEquals(count, 1);
assertTrue(foundEmpty);
assertTrue(!foundPublic);
assertTrue(!foundPGCatalog);
}
}
public void testEscaping() throws SQLException {
DatabaseMetaData dbmd = con.getMetaData();
ResultSet rs = dbmd.getTables( null, null, "a'", new String[] {"TABLE"});
assertTrue(rs.next());
rs = dbmd.getTables( null, null, "a\\\\", new String[] {"TABLE"});
assertTrue(rs.next());
rs = dbmd.getTables( null, null, "a\\", new String[] {"TABLE"});
assertTrue(!rs.next());
}
public void testSearchStringEscape() throws Exception {
DatabaseMetaData dbmd = con.getMetaData();
String pattern = dbmd.getSearchStringEscape() + "_";
PreparedStatement pstmt = con.prepareStatement("SELECT 'a' LIKE ?, '_' LIKE ?");
pstmt.setString(1, pattern);
pstmt.setString(2, pattern);
ResultSet rs = pstmt.executeQuery();
assertTrue (rs.next());
assertTrue(!rs.getBoolean(1));
assertTrue(rs.getBoolean(2));
rs.close();
pstmt.close();
}
public void testGetUDTQualified() throws Exception
{
if (!TestUtil.haveMinimumServerVersion(con, "7.3"))
return ;
Statement stmt = null;
try
{
stmt = con.createStatement();
stmt.execute("create schema jdbc");
stmt.execute("create type jdbc.testint8 as (i int8)");
DatabaseMetaData dbmd = con.getMetaData();
ResultSet rs = dbmd.getUDTs(null, null , "jdbc.testint8" , null);
assertTrue(rs.next());
String cat, schema, typeName, remarks, className;
int dataType;
int baseType;
cat = rs.getString("type_cat");
schema = rs.getString("type_schem");
typeName = rs.getString( "type_name");
className = rs.getString("class_name");
dataType = rs.getInt("data_type");
remarks = rs.getString( "remarks" );
baseType = rs.getInt("base_type");
this.assertEquals("type name ", "testint8", typeName);
this.assertEquals("schema name ", "jdbc", schema);
// now test to see if the fully qualified stuff works as planned
rs = dbmd.getUDTs("catalog", "public" , "catalog.jdbc.testint8" , null);
assertTrue(rs.next());
cat = rs.getString("type_cat");
schema = rs.getString("type_schem");
typeName = rs.getString( "type_name");
className = rs.getString("class_name");
dataType = rs.getInt("data_type");
remarks = rs.getString( "remarks" );
baseType = rs.getInt("base_type");
this.assertEquals("type name ", "testint8", typeName);
this.assertEquals("schema name ", "jdbc", schema);
}
finally
{
try
{
if (stmt != null )
stmt.close();
stmt = con.createStatement();
stmt.execute("drop type jdbc.testint8");
stmt.execute("drop schema jdbc");
}
catch ( Exception ex )
{
}
}
}
public void testGetUDT1() throws Exception
{
if (!TestUtil.haveMinimumServerVersion(con, "7.3"))
return ;
try
{
Statement stmt = con.createStatement();
stmt.execute("create domain testint8 as int8");
stmt.execute("comment on domain testint8 is 'jdbc123'" );
DatabaseMetaData dbmd = con.getMetaData();
ResultSet rs = dbmd.getUDTs(null, null , "testint8" , null);
assertTrue(rs.next());
String cat, schema, typeName, remarks, className;
int dataType;
int baseType;
cat = rs.getString("type_cat");
schema = rs.getString("type_schem");
typeName = rs.getString( "type_name");
className = rs.getString("class_name");
dataType = rs.getInt("data_type");
remarks = rs.getString( "remarks" );
baseType = rs.getInt("base_type");
this.assertTrue("base type", !rs.wasNull() );
this.assertEquals("data type", Types.DISTINCT, dataType );
this.assertEquals("type name ", "testint8", typeName);
this.assertEquals("remarks", "jdbc123", remarks);
}
finally
{
try
{
Statement stmt = con.createStatement();
stmt.execute("drop domain testint8");
}
catch ( Exception ex )
{
}
}
}
public void testGetUDT2() throws Exception
{
if (!TestUtil.haveMinimumServerVersion(con, "7.3"))
return ;
try
{
Statement stmt = con.createStatement();
stmt.execute("create domain testint8 as int8");
stmt.execute("comment on domain testint8 is 'jdbc123'");
DatabaseMetaData dbmd = con.getMetaData();
ResultSet rs = dbmd.getUDTs(null, null, "testint8", new int[]
{Types.DISTINCT, Types.STRUCT});
assertTrue(rs.next());
String cat, schema, typeName, remarks, className;
int dataType;
int baseType;
cat = rs.getString("type_cat");
schema = rs.getString("type_schem");
typeName = rs.getString("type_name");
className = rs.getString("class_name");
dataType = rs.getInt("data_type");
remarks = rs.getString("remarks");
baseType = rs.getInt("base_type");
this.assertTrue("base type", !rs.wasNull());
this.assertEquals("data type", Types.DISTINCT, dataType);
this.assertEquals("type name ", "testint8", typeName);
this.assertEquals("remarks", "jdbc123", remarks);
}
finally
{
try
{
Statement stmt = con.createStatement();
stmt.execute("drop domain testint8");
}
catch (Exception ex)
{
}
}
}
public void testGetUDT3() throws Exception
{
if (!TestUtil.haveMinimumServerVersion(con, "7.3"))
return ;
try
{
Statement stmt = con.createStatement();
stmt.execute("create domain testint8 as int8");
stmt.execute("comment on domain testint8 is 'jdbc123'");
DatabaseMetaData dbmd = con.getMetaData();
ResultSet rs = dbmd.getUDTs(null, null, "testint8", new int[]
{Types.DISTINCT});
assertTrue(rs.next());
String cat, schema, typeName, remarks, className;
int dataType;
int baseType;
cat = rs.getString("type_cat");
schema = rs.getString("type_schem");
typeName = rs.getString("type_name");
className = rs.getString("class_name");
dataType = rs.getInt("data_type");
remarks = rs.getString("remarks");
baseType = rs.getInt("base_type");
this.assertTrue("base type", !rs.wasNull());
this.assertEquals("data type", Types.DISTINCT, dataType);
this.assertEquals("type name ", "testint8", typeName);
this.assertEquals("remarks", "jdbc123", remarks);
}
finally
{
try
{
Statement stmt = con.createStatement();
stmt.execute("drop domain testint8");
}
catch (Exception ex)
{
}
}
}
public void testGetUDT4() throws Exception
{
if (!TestUtil.haveMinimumServerVersion(con, "7.3"))
return ;
try
{
Statement stmt = con.createStatement();
stmt.execute("create type testint8 as (i int8)");
DatabaseMetaData dbmd = con.getMetaData();
ResultSet rs = dbmd.getUDTs(null, null , "testint8" , null);
assertTrue(rs.next());
String cat, schema, typeName, remarks, className;
int dataType;
int baseType;
cat = rs.getString("type_cat");
schema = rs.getString("type_schem");
typeName = rs.getString( "type_name");
className = rs.getString("class_name");
dataType = rs.getInt("data_type");
remarks = rs.getString( "remarks" );
baseType = rs.getInt("base_type");
this.assertTrue("base type", rs.wasNull() );
this.assertEquals("data type", Types.STRUCT, dataType );
this.assertEquals("type name ", "testint8", typeName);
}
finally
{
try
{
Statement stmt = con.createStatement();
stmt.execute("drop type testint8");
}
catch ( Exception ex )
{
}
}
}
public void testTypeInfoSigned() throws SQLException
{
DatabaseMetaData dbmd = con.getMetaData();
ResultSet rs = dbmd.getTypeInfo();
while (rs.next()) {
if ("int4".equals(rs.getString("TYPE_NAME"))) {
assertEquals(false, rs.getBoolean("UNSIGNED_ATTRIBUTE"));
} else if ("float8".equals(rs.getString("TYPE_NAME"))) {
assertEquals(false, rs.getBoolean("UNSIGNED_ATTRIBUTE"));
} else if ("text".equals(rs.getString("TYPE_NAME"))) {
assertEquals(true, rs.getBoolean("UNSIGNED_ATTRIBUTE"));
}
}
}
public void testTypeInfoQuoting() throws SQLException
{
DatabaseMetaData dbmd = con.getMetaData();
ResultSet rs = dbmd.getTypeInfo();
while (rs.next()) {
if ("int4".equals(rs.getString("TYPE_NAME"))) {
assertNull(rs.getString("LITERAL_PREFIX"));
} else if ("text".equals(rs.getString("TYPE_NAME"))) {
assertEquals("'", rs.getString("LITERAL_PREFIX"));
assertEquals("'", rs.getString("LITERAL_SUFFIX"));
}
}
}
public void testInformationAboutArrayTypes() throws SQLException
{
DatabaseMetaData dbmd = con.getMetaData();
ResultSet rs = dbmd.getColumns("", "", "arraytable", "");
assertTrue(rs.next());
assertEquals("a", rs.getString("COLUMN_NAME"));
assertEquals(5, rs.getInt("COLUMN_SIZE"));
assertEquals(2, rs.getInt("DECIMAL_DIGITS"));
assertTrue(rs.next());
assertEquals("b", rs.getString("COLUMN_NAME"));
assertEquals(100, rs.getInt("COLUMN_SIZE"));
assertTrue(!rs.next());
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc2/DateTest.java 0000664 0000000 0000000 00000020311 12050675701 0025152 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc2;
import org.postgresql.test.TestUtil;
import junit.framework.TestCase;
import java.sql.*;
/*
* Some simple tests based on problems reported by users. Hopefully these will
* help prevent previous problems from re-occuring ;-)
*
*/
public class DateTest extends TestCase
{
private Connection con;
public DateTest(String name)
{
super(name);
}
protected void setUp() throws Exception
{
con = TestUtil.openDB();
TestUtil.createTable(con, "testdate", "dt date");
}
protected void tearDown() throws Exception
{
TestUtil.dropTable(con, "testdate");
TestUtil.closeDB(con);
}
/*
* Tests the time methods in ResultSet
*/
public void testGetDate() throws SQLException
{
Statement stmt = con.createStatement();
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testdate", "'1950-02-07'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testdate", "'1970-06-02'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testdate", "'1999-08-11'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testdate", "'2001-02-13'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testdate", "'1950-04-02'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testdate", "'1970-11-30'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testdate", "'1988-01-01'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testdate", "'2003-07-09'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testdate", "'1934-02-28'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testdate", "'1969-04-03'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testdate", "'1982-08-03'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testdate", "'2012-03-15'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testdate", "'1912-05-01'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testdate", "'1971-12-15'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testdate", "'1984-12-03'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testdate", "'2000-01-01'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testdate", "'3456-01-01'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testdate", "'0101-01-01 BC'")));
/* dateTest() contains all of the tests */
dateTest();
assertEquals(18, stmt.executeUpdate("DELETE FROM " + "testdate"));
stmt.close();
}
/*
* Tests the time methods in PreparedStatement
*/
public void testSetDate() throws SQLException
{
Statement stmt = con.createStatement();
PreparedStatement ps = con.prepareStatement(TestUtil.insertSQL("testdate", "?"));
ps.setDate(1, makeDate(1950, 2, 7));
assertEquals(1, ps.executeUpdate());
ps.setDate(1, makeDate(1970, 6, 2));
assertEquals(1, ps.executeUpdate());
ps.setDate(1, makeDate(1999, 8, 11));
assertEquals(1, ps.executeUpdate());
ps.setDate(1, makeDate(2001, 2, 13));
assertEquals(1, ps.executeUpdate());
ps.setObject(1, java.sql.Timestamp.valueOf("1950-04-02 12:00:00"), java.sql.Types.DATE);
assertEquals(1, ps.executeUpdate());
ps.setObject(1, java.sql.Timestamp.valueOf("1970-11-30 3:00:00"), java.sql.Types.DATE);
assertEquals(1, ps.executeUpdate());
ps.setObject(1, java.sql.Timestamp.valueOf("1988-01-01 13:00:00"), java.sql.Types.DATE);
assertEquals(1, ps.executeUpdate());
ps.setObject(1, java.sql.Timestamp.valueOf("2003-07-09 12:00:00"), java.sql.Types.DATE);
assertEquals(1, ps.executeUpdate());
ps.setObject(1, "1934-02-28", java.sql.Types.DATE);
assertEquals(1, ps.executeUpdate());
ps.setObject(1, "1969-04-03", java.sql.Types.DATE);
assertEquals(1, ps.executeUpdate());
ps.setObject(1, "1982-08-03", java.sql.Types.DATE);
assertEquals(1, ps.executeUpdate());
ps.setObject(1, "2012-03-15", java.sql.Types.DATE);
assertEquals(1, ps.executeUpdate());
ps.setObject(1, java.sql.Date.valueOf("1912-05-01"), java.sql.Types.DATE);
assertEquals(1, ps.executeUpdate());
ps.setObject(1, java.sql.Date.valueOf("1971-12-15"), java.sql.Types.DATE);
assertEquals(1, ps.executeUpdate());
ps.setObject(1, java.sql.Date.valueOf("1984-12-03"), java.sql.Types.DATE);
assertEquals(1, ps.executeUpdate());
ps.setObject(1, java.sql.Date.valueOf("2000-01-01"), java.sql.Types.DATE);
assertEquals(1, ps.executeUpdate());
ps.setObject(1, java.sql.Date.valueOf("3456-01-01"), java.sql.Types.DATE);
assertEquals(1, ps.executeUpdate());
// We can't use valueOf on BC dates.
ps.setObject(1, makeDate(-100,1,1));
assertEquals(1, ps.executeUpdate());
ps.close();
dateTest();
assertEquals(18, stmt.executeUpdate("DELETE FROM testdate"));
stmt.close();
}
/*
* Helper for the date tests. It tests what should be in the db
*/
private void dateTest() throws SQLException
{
Statement st = con.createStatement();
ResultSet rs;
java.sql.Date d;
rs = st.executeQuery(TestUtil.selectSQL("testdate", "dt"));
assertNotNull(rs);
assertTrue(rs.next());
d = rs.getDate(1);
assertNotNull(d);
assertEquals(makeDate(1950, 2, 7), d);
assertTrue(rs.next());
d = rs.getDate(1);
assertNotNull(d);
assertEquals(makeDate(1970, 6, 2), d);
assertTrue(rs.next());
d = rs.getDate(1);
assertNotNull(d);
assertEquals(makeDate(1999, 8, 11), d);
assertTrue(rs.next());
d = rs.getDate(1);
assertNotNull(d);
assertEquals(makeDate(2001, 2, 13), d);
assertTrue(rs.next());
d = rs.getDate(1);
assertNotNull(d);
assertEquals(makeDate(1950, 4, 2), d);
assertTrue(rs.next());
d = rs.getDate(1);
assertNotNull(d);
assertEquals(makeDate(1970, 11, 30), d);
assertTrue(rs.next());
d = rs.getDate(1);
assertNotNull(d);
assertEquals(makeDate(1988, 1, 1), d);
assertTrue(rs.next());
d = rs.getDate(1);
assertNotNull(d);
assertEquals(makeDate(2003, 7, 9), d);
assertTrue(rs.next());
d = rs.getDate(1);
assertNotNull(d);
assertEquals(makeDate(1934, 2, 28), d);
assertTrue(rs.next());
d = rs.getDate(1);
assertNotNull(d);
assertEquals(makeDate(1969, 4, 3), d);
assertTrue(rs.next());
d = rs.getDate(1);
assertNotNull(d);
assertEquals(makeDate(1982, 8, 3), d);
assertTrue(rs.next());
d = rs.getDate(1);
assertNotNull(d);
assertEquals(makeDate(2012, 3, 15), d);
assertTrue(rs.next());
d = rs.getDate(1);
assertNotNull(d);
assertEquals(makeDate(1912, 5, 1), d);
assertTrue(rs.next());
d = rs.getDate(1);
assertNotNull(d);
assertEquals(makeDate(1971, 12, 15), d);
assertTrue(rs.next());
d = rs.getDate(1);
assertNotNull(d);
assertEquals(makeDate(1984, 12, 3), d);
assertTrue(rs.next());
d = rs.getDate(1);
assertNotNull(d);
assertEquals(makeDate(2000, 1, 1), d);
assertTrue(rs.next());
d = rs.getDate(1);
assertNotNull(d);
assertEquals(makeDate(3456, 1, 1), d);
assertTrue(rs.next());
d = rs.getDate(1);
assertNotNull(d);
assertEquals(makeDate(-100, 1, 1), d);
assertTrue(!rs.next());
rs.close();
st.close();
}
private java.sql.Date makeDate(int y, int m, int d)
{
return new java.sql.Date(y - 1900, m - 1, d);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc2/DriverTest.java 0000664 0000000 0000000 00000007615 12050675701 0025544 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc2;
import org.postgresql.Driver;
import org.postgresql.test.TestUtil;
import junit.framework.TestCase;
import java.lang.reflect.Method;
import java.sql.*;
import java.util.Properties;
/*
* Tests the dynamically created class org.postgresql.Driver
*
*/
public class DriverTest extends TestCase
{
public DriverTest(String name)
{
super(name);
}
/*
* This tests the acceptsURL() method with a couple of well and poorly
* formed jdbc urls.
*/
public void testAcceptsURL() throws Exception
{
TestUtil.initDriver(); // Set up log levels, etc.
// Load the driver (note clients should never do it this way!)
org.postgresql.Driver drv = new org.postgresql.Driver();
assertNotNull(drv);
// These are always correct
verifyUrl(drv, "jdbc:postgresql:test", "localhost", "5432", "test");
verifyUrl(drv, "jdbc:postgresql://localhost/test", "localhost", "5432", "test");
verifyUrl(drv, "jdbc:postgresql://localhost:5432/test", "localhost", "5432", "test");
verifyUrl(drv, "jdbc:postgresql://127.0.0.1/anydbname", "127.0.0.1", "5432", "anydbname");
verifyUrl(drv, "jdbc:postgresql://127.0.0.1:5433/hidden", "127.0.0.1", "5433", "hidden");
verifyUrl(drv, "jdbc:postgresql://[::1]:5740/db", "[::1]", "5740", "db");
// Badly formatted url's
assertTrue(!drv.acceptsURL("jdbc:postgres:test"));
assertTrue(!drv.acceptsURL("postgresql:test"));
assertTrue(!drv.acceptsURL("db"));
assertTrue(!drv.acceptsURL("jdbc:postgresql://localhost:5432a/test"));
// failover urls
verifyUrl(drv, "jdbc:postgresql://localhost,127.0.0.1:5432/test", "localhost,127.0.0.1", "5432,5432", "test");
verifyUrl(drv, "jdbc:postgresql://localhost:5433,127.0.0.1:5432/test", "localhost,127.0.0.1", "5433,5432", "test");
verifyUrl(drv, "jdbc:postgresql://[::1],[::1]:5432/db", "[::1],[::1]", "5432,5432", "db");
verifyUrl(drv, "jdbc:postgresql://[::1]:5740,127.0.0.1:5432/db", "[::1],127.0.0.1", "5740,5432", "db");
}
private void verifyUrl(Driver drv, String url, String hosts, String ports, String dbName) throws Exception {
assertTrue(url, drv.acceptsURL(url));
Method parseMethod = drv.getClass().getDeclaredMethod("parseURL", new Class[]{String.class, Properties.class});
parseMethod.setAccessible(true);
Properties p = (Properties) parseMethod.invoke(drv, new Object[]{url, null});
assertEquals(url, dbName, p.getProperty("PGDBNAME"));
assertEquals(url, hosts, p.getProperty("PGHOST"));
assertEquals(url, ports, p.getProperty("PGPORT"));
}
/*
* Tests parseURL (internal)
*/
/*
* Tests the connect method by connecting to the test database
*/
public void testConnect() throws Exception
{
TestUtil.initDriver(); // Set up log levels, etc.
// Test with the url, username & password
Connection con = DriverManager.getConnection(TestUtil.getURL(), TestUtil.getUser(), TestUtil.getPassword());
assertNotNull(con);
con.close();
// Test with the username in the url
con = DriverManager.getConnection(TestUtil.getURL() + "&user=" + TestUtil.getUser() + "&password=" + TestUtil.getPassword());
assertNotNull(con);
con.close();
// Test with failover url
String url = "jdbc:postgresql://invalidhost.not.here," + TestUtil.getServer() + ":" + TestUtil.getPort() + "/" + TestUtil.getDatabase();
con = DriverManager.getConnection(url, TestUtil.getUser(), TestUtil.getPassword());
assertNotNull(con);
con.close();
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc2/EncodingTest.java 0000664 0000000 0000000 00000004036 12050675701 0026031 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc2;
import junit.framework.*;
import org.postgresql.core.Encoding;
import java.io.*;
import java.util.Locale;
/*
* Tests for the Encoding class.
*
*/
public class EncodingTest extends TestCase
{
public EncodingTest(String name)
{
super(name);
}
public void testCreation() throws Exception
{
Encoding encoding;
encoding = Encoding.getDatabaseEncoding("UTF8");
assertEquals("UTF", encoding.name().substring(0, 3).toUpperCase(Locale.US));
encoding = Encoding.getDatabaseEncoding("SQL_ASCII");
assertTrue(encoding.name().toUpperCase(Locale.US).indexOf("ASCII") != -1);
assertEquals("When encoding is unknown the default encoding should be used",
Encoding.defaultEncoding(),
Encoding.getDatabaseEncoding("UNKNOWN"));
}
public void testTransformations() throws Exception
{
Encoding encoding = Encoding.getDatabaseEncoding("UTF8");
assertEquals("ab", encoding.decode(new byte[] { 97, 98 }));
assertEquals(2, encoding.encode("ab").length);
assertEquals(97, encoding.encode("a")[0]);
assertEquals(98, encoding.encode("b")[0]);
encoding = Encoding.defaultEncoding();
assertEquals("a".getBytes()[0], encoding.encode("a")[0]);
assertEquals(new String(new byte[] { 97 }),
encoding.decode(new byte[] { 97 }));
}
public void testReader() throws Exception
{
Encoding encoding = Encoding.getDatabaseEncoding("SQL_ASCII");
InputStream stream = new ByteArrayInputStream(new byte[] { 97, 98 });
Reader reader = encoding.getDecodingReader(stream);
assertEquals(97, reader.read());
assertEquals(98, reader.read());
assertEquals( -1, reader.read());
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc2/GeometricTest.java 0000664 0000000 0000000 00000007736 12050675701 0026233 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc2;
import org.postgresql.test.TestUtil;
import org.postgresql.util.PGobject;
import org.postgresql.geometric.*;
import junit.framework.TestCase;
import java.sql.*;
/*
* Test case for geometric type I/O
*/
public class GeometricTest extends TestCase
{
private Connection con;
public GeometricTest(String name)
{
super(name);
}
// Set up the fixture for this testcase: a connection to a database with
// a table for this test.
protected void setUp() throws Exception
{
con = TestUtil.openDB();
TestUtil.createTable(con,
"testgeometric",
"boxval box, circleval circle, lsegval lseg, pathval path, polygonval polygon, pointval point");
}
// Tear down the fixture for this test case.
protected void tearDown() throws Exception
{
TestUtil.dropTable(con, "testgeometric");
TestUtil.closeDB(con);
}
private void checkReadWrite(PGobject obj, String column) throws Exception {
PreparedStatement insert = con.prepareStatement("INSERT INTO testgeometric(" + column + ") VALUES (?)");
insert.setObject(1, obj);
insert.executeUpdate();
insert.close();
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery("SELECT " + column + " FROM testgeometric");
assertTrue(rs.next());
assertEquals(obj, rs.getObject(1));
rs.close();
stmt.executeUpdate("DELETE FROM testgeometric");
stmt.close();
}
public void testPGbox() throws Exception {
checkReadWrite(new PGbox(1.0, 2.0, 3.0, 4.0), "boxval");
checkReadWrite(new PGbox( -1.0, 2.0, 3.0, 4.0), "boxval");
checkReadWrite(new PGbox(1.0, -2.0, 3.0, 4.0), "boxval");
checkReadWrite(new PGbox(1.0, 2.0, -3.0, 4.0), "boxval");
checkReadWrite(new PGbox(1.0, 2.0, 3.0, -4.0), "boxval");
}
public void testPGcircle() throws Exception {
checkReadWrite(new PGcircle(1.0, 2.0, 3.0), "circleval");
checkReadWrite(new PGcircle( -1.0, 2.0, 3.0), "circleval");
checkReadWrite(new PGcircle(1.0, -2.0, 3.0), "circleval");
}
public void testPGlseg() throws Exception {
checkReadWrite(new PGlseg(1.0, 2.0, 3.0, 4.0), "lsegval");
checkReadWrite(new PGlseg( -1.0, 2.0, 3.0, 4.0), "lsegval");
checkReadWrite(new PGlseg(1.0, -2.0, 3.0, 4.0), "lsegval");
checkReadWrite(new PGlseg(1.0, 2.0, -3.0, 4.0), "lsegval");
checkReadWrite(new PGlseg(1.0, 2.0, 3.0, -4.0), "lsegval");
}
public void testPGpath() throws Exception {
PGpoint[] points = new PGpoint[] {
new PGpoint(0.0, 0.0),
new PGpoint(0.0, 5.0),
new PGpoint(5.0, 5.0),
new PGpoint(5.0, -5.0),
new PGpoint( -5.0, -5.0),
new PGpoint( -5.0, 5.0),
};
checkReadWrite(new PGpath(points, true), "pathval");
checkReadWrite(new PGpath(points, false), "pathval");
}
public void testPGpolygon() throws Exception {
PGpoint[] points = new PGpoint[] {
new PGpoint(0.0, 0.0),
new PGpoint(0.0, 5.0),
new PGpoint(5.0, 5.0),
new PGpoint(5.0, -5.0),
new PGpoint( -5.0, -5.0),
new PGpoint( -5.0, 5.0),
};
checkReadWrite(new PGpolygon(points), "polygonval");
}
public void testPGpoint() throws Exception {
checkReadWrite(new PGpoint(1.0, 2.0), "pointval");
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc2/GetXXXTest.java 0000664 0000000 0000000 00000004475 12050675701 0025441 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc2;
import org.postgresql.test.TestUtil;
import java.util.Calendar;
import junit.framework.*;
import java.sql.*;
import java.util.HashMap;
/*
* Test for getObject
*/
public class GetXXXTest extends TestCase
{
Connection con = null;
public GetXXXTest(String name )
{
super(name);
}
protected void setUp() throws Exception
{
super.setUp();
con = TestUtil.openDB();
TestUtil.createTempTable(con, "test_interval",
"initial timestamp with time zone, final timestamp with time zone");
PreparedStatement pstmt = con.prepareStatement(
"insert into test_interval values (?,?)");
Calendar cal = Calendar.getInstance();
cal.add(Calendar.DAY_OF_YEAR, -1);
pstmt.setTimestamp(1, new Timestamp(cal.getTime().getTime()));
pstmt.setTimestamp(2, new Timestamp(System.currentTimeMillis()));
assertTrue(pstmt.executeUpdate() == 1);
pstmt.close();
}
protected void tearDown() throws Exception
{
super.tearDown();
TestUtil.dropTable( con, "test_interval" );
con.close();
}
public void testGetObject() throws SQLException
{
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery(
"select (final-initial) as diff from test_interval");
while (rs.next())
{
String str = (String) rs.getString(1);
assertNotNull(str);
Object obj = rs.getObject(1);
assertNotNull(obj);
}
}
public void testGetUDT() throws SQLException
{
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery("select (final-initial) as diff from test_interval");
while (rs.next() )
{
// make this return a PGobject
Object obj = rs.getObject(1, new HashMap());
// it should not be an instance of PGInterval
assertTrue(obj instanceof org.postgresql.util.PGInterval);
}
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc2/IntervalTest.java 0000664 0000000 0000000 00000017113 12050675701 0026067 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2005-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc2;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.sql.*;
import junit.framework.TestCase;
import org.postgresql.util.PGInterval;
import org.postgresql.test.TestUtil;
public class IntervalTest extends TestCase
{
private Connection _conn;
public IntervalTest(String name)
{
super(name);
}
protected void setUp() throws Exception
{
_conn = TestUtil.openDB();
TestUtil.createTable(_conn, "testinterval", "v interval");
}
protected void tearDown() throws Exception
{
TestUtil.dropTable(_conn, "testinterval");
TestUtil.closeDB(_conn);
}
public void testOnlineTests() throws SQLException
{
PreparedStatement pstmt = _conn.prepareStatement("INSERT INTO testinterval VALUES (?)");
pstmt.setObject(1, new PGInterval(2004, 13, 28, 0, 0, 43000.9013));
pstmt.executeUpdate();
pstmt.close();
Statement stmt = _conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT v FROM testinterval");
assertTrue(rs.next());
PGInterval pgi = (PGInterval)rs.getObject(1);
assertEquals(2005, pgi.getYears());
assertEquals(1, pgi.getMonths());
assertEquals(28, pgi.getDays());
assertEquals(11, pgi.getHours());
assertEquals(56, pgi.getMinutes());
assertEquals(40.9013, pgi.getSeconds(), 0.000001);
assertTrue(!rs.next());
rs.close();
stmt.close();
}
public void testDaysHours() throws SQLException
{
Statement stmt = _conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT '101:12:00'::interval");
assertTrue(rs.next());
PGInterval i = (PGInterval)rs.getObject(1);
// 8.1 servers store hours and days separately.
if (TestUtil.haveMinimumServerVersion(_conn, "8.1")) {
assertEquals(0, i.getDays());
assertEquals(101, i.getHours());
} else {
assertEquals(4, i.getDays());
assertEquals(5, i.getHours());
}
assertEquals(12, i.getMinutes());
}
public void testAddRounding() {
PGInterval pgi = new PGInterval(0, 0, 0, 0, 0, 0.6006);
Calendar cal = Calendar.getInstance();
long origTime = cal.getTime().getTime();
pgi.add(cal);
long newTime = cal.getTime().getTime();
assertEquals(601, newTime - origTime);
pgi.setSeconds(-0.6006);
pgi.add(cal);
assertEquals(origTime, cal.getTime().getTime());
}
public void testOfflineTests()
throws Exception
{
PGInterval pgi = new PGInterval(2004, 4, 20, 15, 57, 12.1);
assertEquals(2004, pgi.getYears());
assertEquals(4, pgi.getMonths());
assertEquals(20, pgi.getDays());
assertEquals(15, pgi.getHours());
assertEquals(57, pgi.getMinutes());
assertEquals(12.1, pgi.getSeconds(), 0);
PGInterval pgi2 = new PGInterval("@ 2004 years 4 mons 20 days 15 hours 57 mins 12.1 secs");
assertEquals(pgi, pgi2);
// Singular units
PGInterval pgi3 = new PGInterval("@ 2004 year 4 mon 20 day 15 hour 57 min 12.1 sec");
assertEquals(pgi, pgi3);
PGInterval pgi4 = new PGInterval("2004 years 4 mons 20 days 15:57:12.1");
assertEquals(pgi, pgi4);
// Ago test
pgi = new PGInterval("@ 2004 years 4 mons 20 days 15 hours 57 mins 12.1 secs ago");
assertEquals(-2004, pgi.getYears());
assertEquals(-4, pgi.getMonths());
assertEquals(-20, pgi.getDays());
assertEquals(-15, pgi.getHours());
assertEquals(-57, pgi.getMinutes());
assertEquals(-12.1, pgi.getSeconds(), 0);
// Char test
pgi = new PGInterval("@ +2004 years -4 mons +20 days -15 hours +57 mins -12.1 secs");
assertEquals(2004, pgi.getYears());
assertEquals(-4, pgi.getMonths());
assertEquals(20, pgi.getDays());
assertEquals(-15, pgi.getHours());
assertEquals(57, pgi.getMinutes());
assertEquals(-12.1, pgi.getSeconds(), 0);
}
Calendar getStartCalendar()
{
Calendar cal = new GregorianCalendar();
cal.set(Calendar.YEAR, 2005);
cal.set(Calendar.MONTH, 4);
cal.set(Calendar.DAY_OF_MONTH, 29);
cal.set(Calendar.HOUR_OF_DAY, 15);
cal.set(Calendar.MINUTE, 35);
cal.set(Calendar.SECOND, 42);
cal.set(Calendar.MILLISECOND, 100);
return cal;
}
public void testCalendar()
throws Exception
{
Calendar cal = getStartCalendar();
PGInterval pgi = new PGInterval("@ 1 year 1 mon 1 day 1 hour 1 minute 1 secs");
pgi.add(cal);
assertEquals(2006, cal.get(Calendar.YEAR));
assertEquals(5, cal.get(Calendar.MONTH));
assertEquals(30, cal.get(Calendar.DAY_OF_MONTH));
assertEquals(16, cal.get(Calendar.HOUR_OF_DAY));
assertEquals(36, cal.get(Calendar.MINUTE));
assertEquals(43, cal.get(Calendar.SECOND));
assertEquals(100, cal.get(Calendar.MILLISECOND));
pgi = new PGInterval("@ 1 year 1 mon 1 day 1 hour 1 minute 1 secs ago");
pgi.add(cal);
assertEquals(2005, cal.get(Calendar.YEAR));
assertEquals(4, cal.get(Calendar.MONTH));
assertEquals(29, cal.get(Calendar.DAY_OF_MONTH));
assertEquals(15, cal.get(Calendar.HOUR_OF_DAY));
assertEquals(35, cal.get(Calendar.MINUTE));
assertEquals(42, cal.get(Calendar.SECOND));
assertEquals(100, cal.get(Calendar.MILLISECOND));
cal = getStartCalendar();
pgi = new PGInterval("@ 1 year -23 hours -3 mins -3.30 secs");
pgi.add(cal);
assertEquals(2006, cal.get(Calendar.YEAR));
assertEquals(4, cal.get(Calendar.MONTH));
assertEquals(28, cal.get(Calendar.DAY_OF_MONTH));
assertEquals(16, cal.get(Calendar.HOUR_OF_DAY));
assertEquals(32, cal.get(Calendar.MINUTE));
assertEquals(38, cal.get(Calendar.SECOND));
assertEquals(800, cal.get(Calendar.MILLISECOND));
pgi = new PGInterval("@ 1 year -23 hours -3 mins -3.30 secs ago");
pgi.add(cal);
assertEquals(2005, cal.get(Calendar.YEAR));
assertEquals(4, cal.get(Calendar.MONTH));
assertEquals(29, cal.get(Calendar.DAY_OF_MONTH));
assertEquals(15, cal.get(Calendar.HOUR_OF_DAY));
assertEquals(35, cal.get(Calendar.MINUTE));
assertEquals(42, cal.get(Calendar.SECOND));
assertEquals(100, cal.get(Calendar.MILLISECOND));
}
public void testDate()
throws Exception
{
Date date = getStartCalendar().getTime();
Date date2 = getStartCalendar().getTime();
PGInterval pgi = new PGInterval("@ +2004 years -4 mons +20 days -15 hours +57 mins -12.1 secs");
pgi.add(date);
PGInterval pgi2 = new PGInterval("@ +2004 years -4 mons +20 days -15 hours +57 mins -12.1 secs ago");
pgi2.add(date);
assertEquals(date2, date);
}
public void testISODate()
throws Exception
{
Date date = getStartCalendar().getTime();
Date date2 = getStartCalendar().getTime();
PGInterval pgi = new PGInterval("+2004 years -4 mons +20 days -15:57:12.1");
pgi.add(date);
PGInterval pgi2 = new PGInterval("-2004 years 4 mons -20 days 15:57:12.1");
pgi2.add(date);
assertEquals(date2, date);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc2/JBuilderTest.java 0000664 0000000 0000000 00000003103 12050675701 0025775 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc2;
import org.postgresql.test.TestUtil;
import java.sql.*;
import junit.framework.TestCase;
/*
* Some simple tests to check that the required components needed for JBuilder
* stay working
*
*/
public class JBuilderTest extends TestCase
{
public JBuilderTest(String name)
{
super(name);
}
// Set up the fixture for this testcase: the tables for this test.
protected void setUp() throws Exception
{
Connection con = TestUtil.openDB();
TestUtil.createTable( con, "test_c",
"source text,cost money,imageid int4" );
TestUtil.closeDB(con);
}
// Tear down the fixture for this test case.
protected void tearDown() throws Exception
{
Connection con = TestUtil.openDB();
TestUtil.dropTable(con, "test_c");
TestUtil.closeDB(con);
}
/*
* This tests that Money types work. JDBCExplorer barfs if this fails.
*/
public void testMoney() throws Exception
{
Connection con = TestUtil.openDB();
Statement st = con.createStatement();
ResultSet rs = st.executeQuery("select cost from test_c");
assertNotNull(rs);
while (rs.next())
{
rs.getDouble(1);
}
rs.close();
st.close();
TestUtil.closeDB(con);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc2/Jdbc2TestSuite.java 0000664 0000000 0000000 00000006056 12050675701 0026245 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc2;
import java.sql.Connection;
import junit.framework.TestSuite;
import org.postgresql.test.TestUtil;
/*
* Executes all known tests for JDBC2 and includes some utility methods.
*/
public class Jdbc2TestSuite extends TestSuite
{
/*
* The main entry point for JUnit
*/
public static TestSuite suite() throws Exception
{
TestSuite suite = new TestSuite();
//
// Add one line per class in our test cases. These should be in order of
// complexity.
// ANTTest should be first as it ensures that test parameters are
// being sent to the suite.
//
suite.addTestSuite(ANTTest.class);
// Basic Driver internals
suite.addTestSuite(DriverTest.class);
suite.addTestSuite(ConnectionTest.class);
suite.addTestSuite(DatabaseMetaDataTest.class);
suite.addTestSuite(DatabaseMetaDataPropertiesTest.class);
suite.addTestSuite(EncodingTest.class);
// Connectivity/Protocols
// ResultSet
suite.addTestSuite(ResultSetTest.class);
suite.addTestSuite(ResultSetMetaDataTest.class);
suite.addTestSuite(ArrayTest.class);
suite.addTestSuite(RefCursorTest.class);
// Time, Date, Timestamp
suite.addTestSuite(DateTest.class);
suite.addTestSuite(TimeTest.class);
suite.addTestSuite(TimestampTest.class);
suite.addTestSuite(TimezoneTest.class);
// PreparedStatement
suite.addTestSuite(PreparedStatementTest.class);
suite.addTestSuite(StatementTest.class);
// ServerSide Prepared Statements
suite.addTestSuite(ServerPreparedStmtTest.class);
// BatchExecute
suite.addTestSuite(BatchExecuteTest.class);
// Other misc tests, based on previous problems users have had or specific
// features some applications require.
suite.addTestSuite(JBuilderTest.class);
suite.addTestSuite(MiscTest.class);
suite.addTestSuite(NotifyTest.class);
suite.addTestSuite(DatabaseEncodingTest.class);
// Fastpath/LargeObject
suite.addTestSuite(BlobTest.class);
suite.addTestSuite(OID74Test.class);
suite.addTestSuite(UpdateableResultTest.class );
suite.addTestSuite(CallableStmtTest.class );
suite.addTestSuite(CursorFetchTest.class);
suite.addTestSuite(ServerCursorTest.class);
suite.addTestSuite(IntervalTest.class);
suite.addTestSuite(GeometricTest.class);
suite.addTestSuite(LoginTimeoutTest.class);
suite.addTestSuite(TestACL.class);
Connection conn = TestUtil.openDB();
if (TestUtil.isProtocolVersion(conn, 3)) {
suite.addTestSuite(CopyTest.class);
}
conn.close();
// That's all folks
return suite;
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc2/LoginTimeoutTest.java 0000664 0000000 0000000 00000012235 12050675701 0026722 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2005-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc2;
import org.postgresql.test.TestUtil;
import junit.framework.TestCase;
import java.sql.*;
import java.net.Socket;
import java.net.ServerSocket;
import java.net.InetAddress;
import java.io.IOException;
import java.util.Properties;
public class LoginTimeoutTest extends TestCase
{
public LoginTimeoutTest(String name)
{
super(name);
}
public void setUp() throws Exception {
TestUtil.initDriver(); // Set up log levels, etc.
}
public void testIntTimeout() throws Exception {
Properties props = new Properties();
props.setProperty("user", TestUtil.getUser());
props.setProperty("password", TestUtil.getPassword());
props.setProperty("loginTimeout", "10");
Connection conn = java.sql.DriverManager.getConnection(TestUtil.getURL(), props);
conn.close();
}
public void testFloatTimeout() throws Exception {
Properties props = new Properties();
props.setProperty("user", TestUtil.getUser());
props.setProperty("password", TestUtil.getPassword());
props.setProperty("loginTimeout", "10.0");
Connection conn = java.sql.DriverManager.getConnection(TestUtil.getURL(), props);
conn.close();
}
public void testZeroTimeout() throws Exception {
Properties props = new Properties();
props.setProperty("user", TestUtil.getUser());
props.setProperty("password", TestUtil.getPassword());
props.setProperty("loginTimeout", "0");
Connection conn = java.sql.DriverManager.getConnection(TestUtil.getURL(), props);
conn.close();
}
public void testNegativeTimeout() throws Exception {
Properties props = new Properties();
props.setProperty("user", TestUtil.getUser());
props.setProperty("password", TestUtil.getPassword());
props.setProperty("loginTimeout", "-1");
Connection conn = java.sql.DriverManager.getConnection(TestUtil.getURL(), props);
conn.close();
}
public void testBadTimeout() throws Exception {
Properties props = new Properties();
props.setProperty("user", TestUtil.getUser());
props.setProperty("password", TestUtil.getPassword());
props.setProperty("loginTimeout", "zzzz");
Connection conn = java.sql.DriverManager.getConnection(TestUtil.getURL(), props);
conn.close();
}
private static class TimeoutHelper implements Runnable {
TimeoutHelper() throws IOException {
InetAddress localAddr;
try {
localAddr = InetAddress.getLocalHost();
} catch (java.net.UnknownHostException ex) {
System.err.println("WARNING: Could not resolve local host name, trying 'localhost'. " + ex);
localAddr = InetAddress.getByName("localhost");
}
this.listenSocket = new ServerSocket(0, 1, localAddr);
}
String getHost() {
return listenSocket.getInetAddress().getHostAddress();
}
int getPort() {
return listenSocket.getLocalPort();
}
public void run() {
try {
Socket newSocket = listenSocket.accept();
try {
Thread.sleep(30000);
} catch (InterruptedException e) {
// Ignore it.
}
newSocket.close();
} catch (IOException e) {
// Ignore it.
}
}
void kill() {
try {
listenSocket.close();
} catch (IOException e) {}
}
private final ServerSocket listenSocket;
}
public void testTimeoutOccurs() throws Exception {
// Spawn a helper thread to accept a connection and do nothing with it;
// this should trigger a timeout.
TimeoutHelper helper = new TimeoutHelper();
new Thread(helper, "timeout listen helper").start();
try {
String url = "jdbc:postgresql://" + helper.getHost() + ":" + helper.getPort() + "/dummy";
Properties props = new Properties();
props.setProperty("user", "dummy");
props.setProperty("loginTimeout", "5");
// This is a pretty crude check, but should help distinguish
// "can't connect" from "timed out".
long startTime = System.currentTimeMillis();
Connection conn = null;
try {
conn = java.sql.DriverManager.getConnection(url, props);
fail("connection was unexpectedly successful");
} catch (SQLException e) {
// Ignored.
} finally {
if (conn != null)
conn.close();
}
long endTime = System.currentTimeMillis();
assertTrue(endTime > startTime + 2500);
} finally {
helper.kill();
}
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc2/MiscTest.java 0000664 0000000 0000000 00000007437 12050675701 0025206 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc2;
import org.postgresql.test.TestUtil;
import junit.framework.TestCase;
import java.sql.*;
import java.io.*;
/*
* Some simple tests based on problems reported by users. Hopefully these will
* help prevent previous problems from re-occuring ;-)
*
*/
public class MiscTest extends TestCase
{
public MiscTest(String name)
{
super(name);
}
/*
* Some versions of the driver would return rs as a null?
*
* Sasha was having this problem.
*
* Added Feb 13 2001
*/
public void testDatabaseSelectNullBug() throws Exception
{
Connection con = TestUtil.openDB();
Statement st = con.createStatement();
ResultSet rs = st.executeQuery("select datname from pg_database");
assertNotNull(rs);
while (rs.next())
{
rs.getString(1);
}
rs.close();
st.close();
TestUtil.closeDB(con);
}
/**
* Ensure the cancel call does not return before it has completed.
* Previously it did which cancelled future queries.
*/
public void testSingleThreadCancel() throws Exception
{
Connection con = TestUtil.openDB();
Statement stmt = con.createStatement();
for (int i=0; i<100; i++) {
ResultSet rs = stmt.executeQuery("SELECT 1");
rs.close();
stmt.cancel();
}
TestUtil.closeDB(con);
}
public void testError() throws Exception
{
Connection con = TestUtil.openDB();
try
{
// transaction mode
con.setAutoCommit(false);
Statement stmt = con.createStatement();
stmt.execute("select 1/0");
fail( "Should not execute this, as a SQLException s/b thrown" );
con.commit();
}
catch ( SQLException ex )
{
// Verify that the SQLException is serializable.
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(ex);
oos.close();
}
con.commit();
con.close();
}
public void testWarning() throws Exception
{
Connection con = TestUtil.openDB();
Statement stmt = con.createStatement();
stmt.execute("CREATE TEMP TABLE t(a int primary key)");
SQLWarning warning = stmt.getWarnings();
// We should get a warning about primary key index creation
// it's possible we won't depending on the server's
// client_min_messages setting.
while (warning != null) {
// Verify that the SQLWarning is serializable.
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(warning);
oos.close();
warning = warning.getNextWarning();
}
stmt.close();
con.close();
}
public void xtestLocking() throws Exception
{
Connection con = TestUtil.openDB();
Connection con2 = TestUtil.openDB();
TestUtil.createTable(con, "test_lock", "name text");
Statement st = con.createStatement();
Statement st2 = con2.createStatement();
con.setAutoCommit(false);
st.execute("lock table test_lock");
st2.executeUpdate( "insert into test_lock ( name ) values ('hello')" );
con.commit();
TestUtil.dropTable(con, "test_lock");
con.close();
con2.close();
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc2/NotifyTest.java 0000664 0000000 0000000 00000005601 12050675701 0025552 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc2;
import org.postgresql.test.TestUtil;
import junit.framework.TestCase;
import java.sql.*;
import org.postgresql.PGNotification;
public class NotifyTest extends TestCase
{
private Connection conn;
public NotifyTest(String name)
{
super(name);
}
protected void setUp() throws Exception
{
conn = TestUtil.openDB();
}
protected void tearDown() throws SQLException
{
TestUtil.closeDB(conn);
}
public void testNotify() throws SQLException
{
Statement stmt = conn.createStatement();
stmt.executeUpdate("LISTEN mynotification");
stmt.executeUpdate("NOTIFY mynotification");
PGNotification notifications[] = ((org.postgresql.PGConnection)conn).getNotifications();
assertNotNull(notifications);
assertEquals(1, notifications.length);
assertEquals("mynotification", notifications[0].getName());
assertEquals("", notifications[0].getParameter());
stmt.close();
}
public void testNotifyArgument() throws Exception
{
if (!TestUtil.haveMinimumServerVersion(conn, "9.0") || TestUtil.isProtocolVersion(conn, 2))
return;
Statement stmt = conn.createStatement();
stmt.executeUpdate("LISTEN mynotification");
stmt.executeUpdate("NOTIFY mynotification, 'message'");
PGNotification notifications[] = ((org.postgresql.PGConnection)conn).getNotifications();
assertNotNull(notifications);
assertEquals(1, notifications.length);
assertEquals("mynotification", notifications[0].getName());
assertEquals("message", notifications[0].getParameter());
stmt.close();
}
public void testAsyncNotify() throws Exception
{
Statement stmt = conn.createStatement();
stmt.executeUpdate("LISTEN mynotification");
// Notify on a separate connection to get an async notify on the first.
Connection conn2 = TestUtil.openDB();
try {
Statement stmt2 = conn2.createStatement();
stmt2.executeUpdate("NOTIFY mynotification");
stmt2.close();
} finally {
conn2.close();
}
// Wait a bit to let the notify come through..
try {
Thread.sleep(2000);
} catch (InterruptedException ie) {}
PGNotification notifications[] = ((org.postgresql.PGConnection)conn).getNotifications();
assertNotNull(notifications);
assertEquals(1, notifications.length);
assertEquals("mynotification", notifications[0].getName());
assertEquals("", notifications[0].getParameter());
stmt.close();
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc2/OID74Test.java 0000664 0000000 0000000 00000004216 12050675701 0025071 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc2;
import org.postgresql.test.TestUtil;
import junit.framework.TestCase;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.util.Properties;
import java.sql.*;
/**
* User: alexei
*/
public class OID74Test extends TestCase
{
private Connection conn;
public OID74Test( String name )
{
super(name);
}
public void setUp() throws Exception
{
//set up conection here
Properties props = new Properties();
props.setProperty("compatible", "7.1");
conn = TestUtil.openDB(props);
TestUtil.createTable(conn, "temp", "col oid");
conn.setAutoCommit(false);
}
public void tearDown() throws Exception
{
conn.setAutoCommit(true);
TestUtil.dropTable(conn, "temp");
TestUtil.closeDB(conn);
}
public void testSetNull() throws SQLException {
PreparedStatement pstmt = conn.prepareStatement("INSERT INTO temp VALUES (?)");
pstmt.setNull(1, Types.VARBINARY);
pstmt.executeUpdate();
pstmt.setNull(1, Types.BLOB);
pstmt.executeUpdate();
pstmt.setNull(1, Types.CLOB);
pstmt.executeUpdate();
pstmt.close();
}
public void testBinaryStream() throws Exception
{
PreparedStatement pstmt = null;
pstmt = conn.prepareStatement("INSERT INTO temp VALUES (?)");
pstmt.setBinaryStream(1, new ByteArrayInputStream(new byte[]{1, 2, 3, 4, 5}), 5);
assertTrue( (pstmt.executeUpdate() == 1) );
pstmt.close();
pstmt = conn.prepareStatement("SELECT col FROM temp LIMIT 1");
ResultSet rs = pstmt.executeQuery();
assertTrue("No results from query", rs.next() );
InputStream in = rs.getBinaryStream(1);
int data;
int i = 1;
while ((data = in.read()) != -1)
assertEquals(i++, data);
rs.close();
pstmt.close();
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc2/PreparedStatementTest.java 0000664 0000000 0000000 00000075430 12050675701 0027740 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc2;
import org.postgresql.test.TestUtil;
import org.postgresql.test.util.BrokenInputStream;
import junit.framework.TestCase;
import java.io.*;
import java.sql.*;
import java.math.BigDecimal;
public class PreparedStatementTest extends TestCase
{
private Connection conn;
public PreparedStatementTest(String name)
{
super(name);
try
{
org.postgresql.Driver driver = new org.postgresql.Driver();
}
catch (Exception ex)
{;}
}
protected void setUp() throws Exception
{
conn = TestUtil.openDB();
TestUtil.createTable(conn, "streamtable", "bin bytea, str text");
TestUtil.createTable(conn, "texttable", "ch char(3), te text, vc varchar(3)");
TestUtil.createTable(conn, "intervaltable", "i interval");
}
protected void tearDown() throws SQLException
{
TestUtil.dropTable(conn, "streamtable");
TestUtil.dropTable(conn, "texttable");
TestUtil.dropTable(conn, "intervaltable");
TestUtil.closeDB(conn);
}
public void testSetBinaryStream() throws SQLException
{
ByteArrayInputStream bais;
byte buf[] = new byte[10];
for (int i = 0; i < buf.length; i++)
{
buf[i] = (byte)i;
}
bais = null;
doSetBinaryStream(bais, 0);
bais = new ByteArrayInputStream(new byte[0]);
doSetBinaryStream(bais, 0);
bais = new ByteArrayInputStream(buf);
doSetBinaryStream(bais, 0);
bais = new ByteArrayInputStream(buf);
doSetBinaryStream(bais, 10);
}
public void testSetAsciiStream() throws Exception
{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
PrintWriter pw = new PrintWriter(new OutputStreamWriter(baos, "ASCII"));
pw.println("Hello");
pw.flush();
ByteArrayInputStream bais;
bais = new ByteArrayInputStream(baos.toByteArray());
doSetAsciiStream(bais, 0);
bais = new ByteArrayInputStream(baos.toByteArray());
doSetAsciiStream(bais, 6);
bais = new ByteArrayInputStream(baos.toByteArray());
doSetAsciiStream(bais, 100);
}
public void testExecuteStringOnPreparedStatement() throws Exception {
PreparedStatement pstmt = conn.prepareStatement("SELECT 1");
try
{
pstmt.executeQuery("SELECT 2");
fail("Expected an exception when executing a new SQL query on a prepared statement");
}
catch (SQLException e)
{
}
try
{
pstmt.executeUpdate("UPDATE streamtable SET bin=bin");
fail("Expected an exception when executing a new SQL update on a prepared statement");
}
catch (SQLException e)
{
}
try
{
pstmt.execute("UPDATE streamtable SET bin=bin");
fail("Expected an exception when executing a new SQL statement on a prepared statement");
}
catch (SQLException e)
{
}
}
public void testBinaryStreamErrorsRestartable() throws SQLException {
// The V2 protocol does not have the ability to recover when
// streaming data to the server. We could potentially try
// introducing a syntax error to force the query to fail, but
// that seems dangerous.
//
if (!TestUtil.isProtocolVersion(conn, 3))
{
return ;
}
byte buf[] = new byte[10];
for (int i = 0; i < buf.length; i++)
{
buf[i] = (byte)i;
}
// InputStream is shorter than the length argument implies.
InputStream is = new ByteArrayInputStream(buf);
runBrokenStream(is, buf.length + 1);
// InputStream throws an Exception during read.
is = new BrokenInputStream(new ByteArrayInputStream(buf), buf.length / 2);
runBrokenStream(is, buf.length);
// Invalid length < 0.
is = new ByteArrayInputStream(buf);
runBrokenStream(is, -1);
// Total Bind message length too long.
is = new ByteArrayInputStream(buf);
runBrokenStream(is, Integer.MAX_VALUE);
}
private void runBrokenStream(InputStream is, int length) throws SQLException
{
PreparedStatement pstmt = null;
try
{
pstmt = conn.prepareStatement("INSERT INTO streamtable (bin,str) VALUES (?,?)");
pstmt.setBinaryStream(1, is, length);
pstmt.setString(2, "Other");
pstmt.executeUpdate();
fail("This isn't supposed to work.");
}
catch (SQLException sqle)
{
// don't need to rollback because we're in autocommit mode
pstmt.close();
// verify the connection is still valid and the row didn't go in.
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT COUNT(*) FROM streamtable");
assertTrue(rs.next());
assertEquals(0, rs.getInt(1));
rs.close();
stmt.close();
}
}
private void doSetBinaryStream(ByteArrayInputStream bais, int length) throws SQLException
{
PreparedStatement pstmt = conn.prepareStatement("INSERT INTO streamtable (bin,str) VALUES (?,?)");
pstmt.setBinaryStream(1, bais, length);
pstmt.setString(2, null);
pstmt.executeUpdate();
pstmt.close();
}
private void doSetAsciiStream(InputStream is, int length) throws SQLException
{
PreparedStatement pstmt = conn.prepareStatement("INSERT INTO streamtable (bin,str) VALUES (?,?)");
pstmt.setBytes(1, null);
pstmt.setAsciiStream(2, is, length);
pstmt.executeUpdate();
pstmt.close();
}
public void testTrailingSpaces() throws SQLException {
PreparedStatement pstmt = conn.prepareStatement("INSERT INTO texttable (ch, te, vc) VALUES (?, ?, ?) ");
String str = "a ";
pstmt.setString(1, str);
pstmt.setString(2, str);
pstmt.setString(3, str);
pstmt.executeUpdate();
pstmt.close();
pstmt = conn.prepareStatement("SELECT ch, te, vc FROM texttable WHERE ch=? AND te=? AND vc=?");
pstmt.setString(1, str);
pstmt.setString(2, str);
pstmt.setString(3, str);
ResultSet rs = pstmt.executeQuery();
assertTrue(rs.next());
assertEquals(str, rs.getString(1));
assertEquals(str, rs.getString(2));
assertEquals(str, rs.getString(3));
rs.close();
pstmt.close();
}
public void testSetNull() throws SQLException {
// valid: fully qualified type to setNull()
PreparedStatement pstmt = conn.prepareStatement("INSERT INTO texttable (te) VALUES (?)");
pstmt.setNull(1, Types.VARCHAR);
pstmt.executeUpdate();
// valid: fully qualified type to setObject()
pstmt.setObject(1, null, Types.VARCHAR);
pstmt.executeUpdate();
// valid: setObject() with partial type info and a typed "null object instance"
org.postgresql.util.PGobject dummy = new org.postgresql.util.PGobject();
dummy.setType("text");
dummy.setValue(null);
pstmt.setObject(1, dummy, Types.OTHER);
pstmt.executeUpdate();
// setObject() with no type info
pstmt.setObject(1, null);
pstmt.executeUpdate();
// setObject() with insufficient type info
pstmt.setObject(1, null, Types.OTHER);
pstmt.executeUpdate();
// setNull() with insufficient type info
pstmt.setNull(1, Types.OTHER);
pstmt.executeUpdate();
pstmt.close();
}
public void testSingleQuotes() throws SQLException {
String[] testStrings = new String[] {
"bare ? question mark",
"quoted \\' single quote",
"doubled '' single quote",
"octal \\060 constant",
"escaped \\? question mark",
"double \\\\ backslash",
"double \" quote",
};
String[] testStringsStdConf = new String[] {
"bare ? question mark",
"quoted '' single quote",
"doubled '' single quote",
"octal 0 constant",
"escaped ? question mark",
"double \\ backslash",
"double \" quote",
};
String[] expected = new String[] {
"bare ? question mark",
"quoted ' single quote",
"doubled ' single quote",
"octal 0 constant",
"escaped ? question mark",
"double \\ backslash",
"double \" quote",
};
if (! TestUtil.haveMinimumServerVersion(conn, "8.2"))
{
for (int i = 0; i < testStrings.length; ++i)
{
PreparedStatement pstmt = conn.prepareStatement("SELECT '" + testStrings[i] + "'");
ResultSet rs = pstmt.executeQuery();
assertTrue(rs.next());
assertEquals(expected[i], rs.getString(1));
rs.close();
pstmt.close();
}
}
else
{
boolean oldStdStrings = TestUtil.getStandardConformingStrings(conn);
Statement stmt = conn.createStatement();
// Test with standard_conforming_strings turned off.
stmt.execute("SET standard_conforming_strings TO off");
for (int i = 0; i < testStrings.length; ++i)
{
PreparedStatement pstmt = conn.prepareStatement("SELECT '" + testStrings[i] + "'");
ResultSet rs = pstmt.executeQuery();
assertTrue(rs.next());
assertEquals(expected[i], rs.getString(1));
rs.close();
pstmt.close();
}
// Test with standard_conforming_strings turned off...
// ... using the escape string syntax (E'').
stmt.execute("SET standard_conforming_strings TO on");
for (int i = 0; i < testStrings.length; ++i)
{
PreparedStatement pstmt = conn.prepareStatement("SELECT E'" + testStrings[i] + "'");
ResultSet rs = pstmt.executeQuery();
assertTrue(rs.next());
assertEquals(expected[i], rs.getString(1));
rs.close();
pstmt.close();
}
// ... using standard conforming input strings.
for (int i = 0; i < testStrings.length; ++i)
{
PreparedStatement pstmt = conn.prepareStatement("SELECT '" + testStringsStdConf[i] + "'");
ResultSet rs = pstmt.executeQuery();
assertTrue(rs.next());
assertEquals(expected[i], rs.getString(1));
rs.close();
pstmt.close();
}
stmt.execute("SET standard_conforming_strings TO " + (oldStdStrings ? "on" : "off"));
stmt.close();
}
}
public void testDoubleQuotes() throws SQLException {
String[] testStrings = new String[] {
"bare ? question mark",
"single ' quote",
"doubled '' single quote",
"doubled \"\" double quote",
"no backslash interpretation here: \\",
};
for (int i = 0; i < testStrings.length; ++i)
{
PreparedStatement pstmt = conn.prepareStatement("CREATE TABLE \"" + testStrings[i] + "\" (i integer)");
pstmt.executeUpdate();
pstmt.close();
pstmt = conn.prepareStatement("DROP TABLE \"" + testStrings[i] + "\"");
pstmt.executeUpdate();
pstmt.close();
}
}
public void testDollarQuotes() throws SQLException {
// dollar-quotes are supported in the backend since version 8.0
if (!TestUtil.haveMinimumServerVersion(conn, "8.0"))
return;
PreparedStatement st;
ResultSet rs;
st = conn.prepareStatement("SELECT $$;$$ WHERE $x$?$x$=$_0$?$_0$ AND $$?$$=?");
st.setString(1, "?");
rs = st.executeQuery();
assertTrue(rs.next());
assertEquals(";", rs.getString(1));
assertFalse(rs.next());
st.close();
st = conn.prepareStatement(
"SELECT $__$;$__$ WHERE ''''=$q_1$'$q_1$ AND ';'=?;"
+ "SELECT $x$$a$;$x $a$$x$ WHERE $$;$$=? OR ''=$c$c$;$c$;"
+ "SELECT ?");
st.setString(1, ";");
st.setString(2, ";");
st.setString(3, "$a$ $a$");
assertTrue(st.execute());
rs = st.getResultSet();
assertTrue(rs.next());
assertEquals(";", rs.getString(1));
assertFalse(rs.next());
assertTrue(st.getMoreResults());
rs = st.getResultSet();
assertTrue(rs.next());
assertEquals("$a$;$x $a$", rs.getString(1));
assertFalse(rs.next());
assertTrue(st.getMoreResults());
rs = st.getResultSet();
assertTrue(rs.next());
assertEquals("$a$ $a$", rs.getString(1));
assertFalse(rs.next());
st.close();
}
public void testDollarQuotesAndIdentifiers() throws SQLException {
// dollar-quotes are supported in the backend since version 8.0
if (!TestUtil.haveMinimumServerVersion(conn, "8.0"))
return;
PreparedStatement st;
conn.createStatement().execute("CREATE TEMP TABLE a$b$c(a varchar, b varchar)");
st = conn.prepareStatement("INSERT INTO a$b$c (a, b) VALUES (?, ?)");
st.setString(1, "a");
st.setString(2, "b");
st.executeUpdate();
st.close();
conn.createStatement().execute("CREATE TEMP TABLE e$f$g(h varchar, e$f$g varchar) ");
st = conn.prepareStatement("UPDATE e$f$g SET h = ? || e$f$g");
st.setString(1, "a");
st.executeUpdate();
st.close();
}
public void testComments() throws SQLException {
PreparedStatement st;
ResultSet rs;
st = conn.prepareStatement("SELECT /*?*/ /*/*/*/**/*/*/*/1;SELECT ?;--SELECT ?");
st.setString(1, "a");
assertTrue(st.execute());
assertTrue(st.getMoreResults());
assertFalse(st.getMoreResults());
st.close();
st = conn.prepareStatement("SELECT /**/'?'/*/**/*/ WHERE '?'=/*/*/*?*/*/*/--?\n?");
st.setString(1, "?");
rs = st.executeQuery();
assertTrue(rs.next());
assertEquals("?", rs.getString(1));
assertFalse(rs.next());
st.close();
}
public void testDouble() throws SQLException
{
PreparedStatement pstmt = conn.prepareStatement("CREATE TEMP TABLE double_tab (max_double float, min_double float, null_value float)");
pstmt.executeUpdate();
pstmt.close();
pstmt = conn.prepareStatement( "insert into double_tab values (?,?,?)");
pstmt.setDouble(1, 1.0E125);
pstmt.setDouble(2, 1.0E-130);
pstmt.setNull(3,Types.DOUBLE);
pstmt.executeUpdate();
pstmt.close();
pstmt = conn.prepareStatement( "select * from double_tab");
ResultSet rs = pstmt.executeQuery();
assertTrue( rs.next());
double d = rs.getDouble(1);
assertTrue( rs.getDouble(1) == 1.0E125 );
assertTrue( rs.getDouble(2) == 1.0E-130 );
rs.getDouble(3);
assertTrue( rs.wasNull() );
rs.close();
pstmt.close();
}
public void testFloat() throws SQLException
{
PreparedStatement pstmt = conn.prepareStatement("CREATE TEMP TABLE float_tab (max_float real, min_float real, null_value real)");
pstmt.executeUpdate();
pstmt.close();
pstmt = conn.prepareStatement( "insert into float_tab values (?,?,?)");
pstmt.setFloat(1,(float)1.0E37 );
pstmt.setFloat(2, (float)1.0E-37);
pstmt.setNull(3,Types.FLOAT);
pstmt.executeUpdate();
pstmt.close();
pstmt = conn.prepareStatement( "select * from float_tab");
ResultSet rs = pstmt.executeQuery();
assertTrue( rs.next());
float f = rs.getFloat(1);
assertTrue( "expected 1.0E37,received " + rs.getFloat(1), rs.getFloat(1) == (float)1.0E37 );
assertTrue( "expected 1.0E-37,received " + rs.getFloat(2), rs.getFloat(2) == (float)1.0E-37 );
rs.getDouble(3);
assertTrue( rs.wasNull() );
rs.close();
pstmt.close();
}
public void testBoolean() throws SQLException
{
PreparedStatement pstmt = conn.prepareStatement("CREATE TEMP TABLE bool_tab (max_val boolean, min_val boolean, null_val boolean)");
pstmt.executeUpdate();
pstmt.close();
pstmt = conn.prepareStatement( "insert into bool_tab values (?,?,?)");
pstmt.setBoolean(1,true );
pstmt.setBoolean(2, false);
pstmt.setNull(3,Types.BIT);
pstmt.executeUpdate();
pstmt.close();
pstmt = conn.prepareStatement( "select * from bool_tab");
ResultSet rs = pstmt.executeQuery();
assertTrue( rs.next());
assertTrue( "expected true,received " + rs.getBoolean(1), rs.getBoolean(1) == true );
assertTrue( "expected false,received " + rs.getBoolean(2), rs.getBoolean(2) == false );
rs.getFloat(3);
assertTrue( rs.wasNull() );
rs.close();
pstmt.close();
}
public void testSetFloatInteger() throws SQLException
{
PreparedStatement pstmt = conn.prepareStatement("CREATE temp TABLE float_tab (max_val float8, min_val float, null_val float8)");
pstmt.executeUpdate();
pstmt.close();
Integer maxInteger= new Integer(2147483647), minInteger = new Integer(-2147483648);
Double maxFloat=new Double( 2147483647), minFloat = new Double( -2147483648 );
pstmt = conn.prepareStatement( "insert into float_tab values (?,?,?)");
pstmt.setObject(1,maxInteger,Types.FLOAT );
pstmt.setObject(2,minInteger,Types.FLOAT);
pstmt.setNull(3,Types.FLOAT);
pstmt.executeUpdate();
pstmt.close();
pstmt = conn.prepareStatement( "select * from float_tab");
ResultSet rs = pstmt.executeQuery();
assertTrue( rs.next());
assertTrue( "expected "+maxFloat+" ,received " + rs.getObject(1), ((Double)rs.getObject(1)).equals(maxFloat) );
assertTrue( "expected "+minFloat+" ,received " + rs.getObject(2), ((Double)rs.getObject(2)).equals( minFloat) );
rs.getFloat(3);
assertTrue( rs.wasNull() );
rs.close();
pstmt.close();
}
public void testSetFloatString() throws SQLException
{
PreparedStatement pstmt = conn.prepareStatement("CREATE temp TABLE float_tab (max_val float8, min_val float8, null_val float8)");
pstmt.executeUpdate();
pstmt.close();
String maxStringFloat = new String("1.0E37"), minStringFloat = new String("1.0E-37");
Double maxFloat=new Double(1.0E37), minFloat = new Double( 1.0E-37 );
pstmt = conn.prepareStatement( "insert into float_tab values (?,?,?)");
pstmt.setObject(1,maxStringFloat,Types.FLOAT );
pstmt.setObject(2,minStringFloat,Types.FLOAT );
pstmt.setNull(3,Types.FLOAT);
pstmt.executeUpdate();
pstmt.close();
pstmt = conn.prepareStatement( "select * from float_tab");
ResultSet rs = pstmt.executeQuery();
assertTrue( rs.next());
assertTrue( "expected true,received " + rs.getObject(1), ((Double)rs.getObject(1)).equals(maxFloat) );
assertTrue( "expected false,received " + rs.getBoolean(2), ((Double)rs.getObject(2)).equals( minFloat) );
rs.getFloat(3);
assertTrue( rs.wasNull() );
rs.close();
pstmt.close();
}
public void testSetFloatBigDecimal() throws SQLException
{
PreparedStatement pstmt = conn.prepareStatement("CREATE temp TABLE float_tab (max_val float8, min_val float8, null_val float8)");
pstmt.executeUpdate();
pstmt.close();
BigDecimal maxBigDecimalFloat = new BigDecimal("1.0E37"), minBigDecimalFloat = new BigDecimal("1.0E-37");
Double maxFloat=new Double(1.0E37), minFloat = new Double( 1.0E-37 );
pstmt = conn.prepareStatement( "insert into float_tab values (?,?,?)");
pstmt.setObject(1,maxBigDecimalFloat,Types.FLOAT );
pstmt.setObject(2,minBigDecimalFloat,Types.FLOAT );
pstmt.setNull(3,Types.FLOAT);
pstmt.executeUpdate();
pstmt.close();
pstmt = conn.prepareStatement( "select * from float_tab");
ResultSet rs = pstmt.executeQuery();
assertTrue( rs.next());
assertTrue( "expected " + maxFloat + " ,received " + rs.getObject(1), ((Double)rs.getObject(1)).equals(maxFloat) );
assertTrue( "expected " + minFloat + " ,received " + rs.getObject(2), ((Double)rs.getObject(2)).equals( minFloat) );
rs.getFloat(3);
assertTrue( rs.wasNull() );
rs.close();
pstmt.close();
}
public void testSetTinyIntFloat() throws SQLException
{
PreparedStatement pstmt = conn.prepareStatement("CREATE temp TABLE tiny_int (max_val int4, min_val int4, null_val int4)");
pstmt.executeUpdate();
pstmt.close();
Integer maxInt = new Integer( 127 ), minInt = new Integer(-127);
Float maxIntFloat = new Float( 127 ), minIntFloat = new Float( -127 );
pstmt = conn.prepareStatement( "insert into tiny_int values (?,?,?)");
pstmt.setObject(1,maxIntFloat,Types.TINYINT );
pstmt.setObject(2,minIntFloat,Types.TINYINT );
pstmt.setNull(3,Types.TINYINT);
pstmt.executeUpdate();
pstmt.close();
pstmt = conn.prepareStatement( "select * from tiny_int");
ResultSet rs = pstmt.executeQuery();
assertTrue( rs.next());
assertTrue( "expected " + maxInt+" ,received " + rs.getObject(1), ((Integer)rs.getObject(1)).equals( maxInt ) );
assertTrue( "expected " + minInt+" ,received " + rs.getObject(2), ((Integer)rs.getObject(2)).equals( minInt ) );
rs.getFloat(3);
assertTrue( rs.wasNull() );
rs.close();
pstmt.close();
}
public void testSetSmallIntFloat() throws SQLException
{
PreparedStatement pstmt = conn.prepareStatement("CREATE temp TABLE small_int (max_val int4, min_val int4, null_val int4)");
pstmt.executeUpdate();
pstmt.close();
Integer maxInt = new Integer( 32767 ), minInt = new Integer(-32768);
Float maxIntFloat = new Float( 32767 ), minIntFloat = new Float( -32768 );
pstmt = conn.prepareStatement( "insert into small_int values (?,?,?)");
pstmt.setObject(1,maxIntFloat,Types.SMALLINT );
pstmt.setObject(2,minIntFloat,Types.SMALLINT );
pstmt.setNull(3,Types.TINYINT);
pstmt.executeUpdate();
pstmt.close();
pstmt = conn.prepareStatement( "select * from small_int");
ResultSet rs = pstmt.executeQuery();
assertTrue( rs.next());
assertTrue( "expected " + maxInt+" ,received " + rs.getObject(1), ((Integer)rs.getObject(1)).equals( maxInt ) );
assertTrue( "expected " + minInt+" ,received " + rs.getObject(2), ((Integer)rs.getObject(2)).equals( minInt ) );
rs.getFloat(3);
assertTrue( rs.wasNull() );
rs.close();
pstmt.close();
}
public void testSetIntFloat() throws SQLException
{
PreparedStatement pstmt = conn.prepareStatement("CREATE temp TABLE int_TAB (max_val int4, min_val int4, null_val int4)");
pstmt.executeUpdate();
pstmt.close();
Integer maxInt = new Integer( 1000 ), minInt = new Integer(-1000);
Float maxIntFloat = new Float( 1000 ), minIntFloat = new Float( -1000 );
pstmt = conn.prepareStatement( "insert into int_tab values (?,?,?)");
pstmt.setObject(1,maxIntFloat,Types.INTEGER );
pstmt.setObject(2,minIntFloat,Types.INTEGER );
pstmt.setNull(3,Types.INTEGER);
pstmt.executeUpdate();
pstmt.close();
pstmt = conn.prepareStatement( "select * from int_tab");
ResultSet rs = pstmt.executeQuery();
assertTrue( rs.next());
assertTrue( "expected " + maxInt+" ,received " + rs.getObject(1), ((Integer)rs.getObject(1)).equals( maxInt ) );
assertTrue( "expected " + minInt+" ,received " + rs.getObject(2), ((Integer)rs.getObject(2)).equals( minInt ) );
rs.getFloat(3);
assertTrue( rs.wasNull() );
rs.close();
pstmt.close();
}
public void testSetBooleanDouble() throws SQLException
{
PreparedStatement pstmt = conn.prepareStatement("CREATE temp TABLE double_tab (max_val float, min_val float, null_val float)");
pstmt.executeUpdate();
pstmt.close();
Boolean trueVal = Boolean.TRUE, falseVal = Boolean.FALSE;
Double dBooleanTrue = new Double(1), dBooleanFalse = new Double( 0 );
pstmt = conn.prepareStatement( "insert into double_tab values (?,?,?)");
pstmt.setObject(1,trueVal,Types.DOUBLE );
pstmt.setObject(2,falseVal,Types.DOUBLE );
pstmt.setNull(3,Types.DOUBLE);
pstmt.executeUpdate();
pstmt.close();
pstmt = conn.prepareStatement( "select * from double_tab");
ResultSet rs = pstmt.executeQuery();
assertTrue( rs.next());
assertTrue( "expected " + dBooleanTrue + " ,received " + rs.getObject(1), ((Double)rs.getObject(1)).equals( dBooleanTrue ) );
assertTrue( "expected " + dBooleanFalse + " ,received " + rs.getObject(2), ((Double)rs.getObject(2)).equals( dBooleanFalse ) );
rs.getFloat(3);
assertTrue( rs.wasNull() );
rs.close();
pstmt.close();
}
public void testSetBooleanNumeric() throws SQLException
{
PreparedStatement pstmt = conn.prepareStatement("CREATE temp TABLE numeric_tab (max_val numeric(30,15), min_val numeric(30,15), null_val numeric(30,15))");
pstmt.executeUpdate();
pstmt.close();
Boolean trueVal = Boolean.TRUE, falseVal = Boolean.FALSE;
BigDecimal dBooleanTrue = new BigDecimal(1), dBooleanFalse = new BigDecimal( 0 );
pstmt = conn.prepareStatement( "insert into numeric_tab values (?,?,?)");
pstmt.setObject(1,trueVal,Types.NUMERIC,2 );
pstmt.setObject(2,falseVal,Types.NUMERIC,2 );
pstmt.setNull(3,Types.DOUBLE);
pstmt.executeUpdate();
pstmt.close();
pstmt = conn.prepareStatement( "select * from numeric_tab");
ResultSet rs = pstmt.executeQuery();
assertTrue( rs.next());
assertTrue( "expected " + dBooleanTrue + " ,received " + rs.getObject(1), ((BigDecimal)rs.getObject(1)).compareTo( dBooleanTrue )==0 );
assertTrue( "expected " + dBooleanFalse + " ,received " + rs.getObject(2), ((BigDecimal)rs.getObject(2)).compareTo( dBooleanFalse )==0 );
rs.getFloat(3);
assertTrue( rs.wasNull() );
rs.close();
pstmt.close();
}
public void testSetBooleanDecimal() throws SQLException
{
PreparedStatement pstmt = conn.prepareStatement("CREATE temp TABLE DECIMAL_TAB (max_val numeric(30,15), min_val numeric(30,15), null_val numeric(30,15))");
pstmt.executeUpdate();
pstmt.close();
Boolean trueVal = Boolean.TRUE, falseVal = Boolean.FALSE;
BigDecimal dBooleanTrue = new BigDecimal(1), dBooleanFalse = new BigDecimal( 0 );
pstmt = conn.prepareStatement( "insert into DECIMAL_TAB values (?,?,?)");
pstmt.setObject(1,trueVal,Types.DECIMAL,2 );
pstmt.setObject(2,falseVal,Types.DECIMAL,2 );
pstmt.setNull(3,Types.DOUBLE);
pstmt.executeUpdate();
pstmt.close();
pstmt = conn.prepareStatement( "select * from DECIMAL_TAB");
ResultSet rs = pstmt.executeQuery();
assertTrue( rs.next());
assertTrue( "expected " + dBooleanTrue + " ,received " + rs.getObject(1), ((BigDecimal)rs.getObject(1)).compareTo( dBooleanTrue )==0 );
assertTrue( "expected " + dBooleanFalse + " ,received " + rs.getObject(2), ((BigDecimal)rs.getObject(2)).compareTo( dBooleanFalse )==0 );
rs.getFloat(3);
assertTrue( rs.wasNull() );
rs.close();
pstmt.close();
}
public void testUnknownSetObject() throws SQLException
{
PreparedStatement pstmt = conn.prepareStatement("INSERT INTO intervaltable(i) VALUES (?)");
if (TestUtil.isProtocolVersion(conn, 3))
{
pstmt.setString(1, "1 week");
try {
pstmt.executeUpdate();
fail("Should have failed with type mismatch.");
} catch (SQLException sqle) {
}
}
pstmt.setObject(1, "1 week", Types.OTHER);
pstmt.executeUpdate();
pstmt.close();
}
/**
* With autoboxing this apparently happens more often now.
*/
public void testSetObjectCharacter() throws SQLException
{
PreparedStatement ps = conn.prepareStatement("INSERT INTO texttable(te) VALUES (?)");
ps.setObject(1, new Character('z'));
ps.executeUpdate();
ps.close();
}
/**
* When we have parameters of unknown type and it's not using
* the unnamed statement, we issue a protocol level statment
* describe message for the V3 protocol. This test just makes
* sure that works.
*/
public void testStatementDescribe() throws SQLException
{
PreparedStatement pstmt = conn.prepareStatement("SELECT ?::int");
pstmt.setObject(1, new Integer(2), Types.OTHER);
for (int i=0; i<10; i++) {
ResultSet rs = pstmt.executeQuery();
assertTrue(rs.next());
assertEquals(2, rs.getInt(1));
rs.close();
}
pstmt.close();
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc2/RefCursorTest.java 0000664 0000000 0000000 00000011045 12050675701 0026213 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc2;
import org.postgresql.test.TestUtil;
import java.sql.*;
import junit.framework.TestCase;
/*
* RefCursor ResultSet tests.
* This test case is basically the same as the ResultSet test case.
*
* @author Nic Ferrier
*/
public class RefCursorTest extends TestCase
{
private Connection con;
public RefCursorTest(String name)
{
super(name);
}
protected void setUp() throws Exception
{
// this is the same as the ResultSet setup.
con = TestUtil.openDB();
Statement stmt = con.createStatement();
TestUtil.createTable(con, "testrs", "id integer primary key");
stmt.executeUpdate("INSERT INTO testrs VALUES (1)");
stmt.executeUpdate("INSERT INTO testrs VALUES (2)");
stmt.executeUpdate("INSERT INTO testrs VALUES (3)");
stmt.executeUpdate("INSERT INTO testrs VALUES (4)");
stmt.executeUpdate("INSERT INTO testrs VALUES (6)");
stmt.executeUpdate("INSERT INTO testrs VALUES (9)");
// Create the functions.
stmt.execute ("CREATE OR REPLACE FUNCTION testspg__getRefcursor () RETURNS refcursor AS '"
+ "declare v_resset refcursor; begin open v_resset for select id from testrs order by id; "
+ "return v_resset; end;' LANGUAGE plpgsql;");
stmt.execute ("CREATE OR REPLACE FUNCTION testspg__getEmptyRefcursor () RETURNS refcursor AS '"
+ "declare v_resset refcursor; begin open v_resset for select id from testrs where id < 1 order by id; "
+ "return v_resset; end;' LANGUAGE plpgsql;");
stmt.close();
con.setAutoCommit(false);
}
protected void tearDown() throws Exception
{
con.setAutoCommit(true);
Statement stmt = con.createStatement ();
stmt.execute ("drop FUNCTION testspg__getRefcursor ();");
stmt.execute ("drop FUNCTION testspg__getEmptyRefcursor ();");
TestUtil.dropTable(con, "testrs");
TestUtil.closeDB(con);
}
public void testResult() throws SQLException
{
CallableStatement call = con.prepareCall("{ ? = call testspg__getRefcursor () }");
call.registerOutParameter(1, Types.OTHER);
call.execute();
ResultSet rs = (ResultSet) call.getObject(1);
assertTrue(rs.next());
assertTrue(rs.getInt(1) == 1);
assertTrue(rs.next());
assertTrue(rs.getInt(1) == 2);
assertTrue(rs.next());
assertTrue(rs.getInt(1) == 3);
assertTrue(rs.next());
assertTrue(rs.getInt(1) == 4);
assertTrue(rs.next());
assertTrue(rs.getInt(1) == 6);
assertTrue(rs.next());
assertTrue(rs.getInt(1) == 9);
assertTrue(!rs.next());
call.close();
}
public void testEmptyResult() throws SQLException
{
CallableStatement call = con.prepareCall("{ ? = call testspg__getEmptyRefcursor () }");
call.registerOutParameter(1, Types.OTHER);
call.execute();
ResultSet rs = (ResultSet) call.getObject(1);
assertTrue(!rs.next());
call.close();
}
public void testMetaData() throws SQLException
{
if (!TestUtil.haveMinimumServerVersion(con, "7.4"))
return;
CallableStatement call = con.prepareCall("{ ? = call testspg__getRefcursor () }");
call.registerOutParameter(1, Types.OTHER);
call.execute();
ResultSet rs = (ResultSet) call.getObject(1);
ResultSetMetaData rsmd = rs.getMetaData();
assertNotNull(rsmd);
assertEquals(1, rsmd.getColumnCount());
assertEquals(Types.INTEGER, rsmd.getColumnType(1));
assertEquals("int4", rsmd.getColumnTypeName(1));
rs.close();
call.close();
}
public void testResultType() throws SQLException
{
CallableStatement call = con.prepareCall("{ ? = call testspg__getRefcursor () }", ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
call.registerOutParameter(1, Types.OTHER);
call.execute();
ResultSet rs = (ResultSet) call.getObject(1);
assertEquals(rs.getType(), ResultSet.TYPE_SCROLL_INSENSITIVE);
assertEquals(rs.getConcurrency(), ResultSet.CONCUR_READ_ONLY);
assertTrue(rs.last());
assertEquals(6, rs.getRow());
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc2/ResultSetMetaDataTest.java 0000664 0000000 0000000 00000021773 12050675701 0027645 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc2;
import org.postgresql.PGResultSetMetaData;
import org.postgresql.test.TestUtil;
import junit.framework.TestCase;
import java.sql.*;
public class ResultSetMetaDataTest extends TestCase
{
private Connection conn;
public ResultSetMetaDataTest(String name)
{
super(name);
}
protected void setUp() throws Exception
{
conn = TestUtil.openDB();
TestUtil.createTable(conn, "rsmd1", "a int primary key, b text, c decimal(10,2)", true);
TestUtil.createTable(conn, "timetest", "tm time(3), tmtz timetz, ts timestamp without time zone, tstz timestamp(6) with time zone");
TestUtil.dropSequence( conn, "serialtest_a_seq");
TestUtil.dropSequence( conn, "serialtest_b_seq");
TestUtil.createTable(conn, "serialtest", "a serial, b bigserial, c int");
TestUtil.createTable(conn, "alltypes", "bool boolean, i2 int2, i4 int4, i8 int8, num numeric(10,2), re real, fl float, ch char(3), vc varchar(3), tx text, d date, t time without time zone, tz time with time zone, ts timestamp without time zone, tsz timestamp with time zone, bt bytea");
TestUtil.createTable(conn, "sizetest", "fixedchar char(5), fixedvarchar varchar(5), unfixedvarchar varchar, txt text, bytearr bytea, num64 numeric(6,4), num60 numeric(6,0), num numeric, ip inet");
TestUtil.createTable(conn, "compositetest", "col rsmd1");
}
protected void tearDown() throws Exception
{
TestUtil.dropTable(conn, "compositetest");
TestUtil.dropTable(conn, "rsmd1");
TestUtil.dropTable(conn, "timetest");
TestUtil.dropTable(conn, "serialtest");
TestUtil.dropTable(conn, "alltypes");
TestUtil.dropTable(conn, "sizetest");
TestUtil.dropSequence( conn, "serialtest_a_seq");
TestUtil.dropSequence( conn, "serialtest_b_seq");
TestUtil.closeDB(conn);
}
public void testStandardResultSet() throws SQLException {
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT a,b,c,a+c as total,oid,b as d FROM rsmd1");
runStandardTests(rs.getMetaData());
rs.close();
stmt.close();
}
public void testPreparedResultSet() throws SQLException {
if (!TestUtil.isProtocolVersion(conn, 3))
return;
PreparedStatement pstmt = conn.prepareStatement("SELECT a,b,c,a+c as total,oid,b as d FROM rsmd1 WHERE b = ?");
runStandardTests(pstmt.getMetaData());
pstmt.close();
}
private void runStandardTests(ResultSetMetaData rsmd) throws SQLException {
PGResultSetMetaData pgrsmd = (PGResultSetMetaData)rsmd;
assertEquals(6, rsmd.getColumnCount());
assertEquals("a", rsmd.getColumnLabel(1));
assertEquals("total", rsmd.getColumnLabel(4));
assertEquals("a", rsmd.getColumnName(1));
assertEquals("oid", rsmd.getColumnName(5));
if (TestUtil.isProtocolVersion(conn, 3))
{
assertEquals("", pgrsmd.getBaseColumnName(4));
assertEquals("b", pgrsmd.getBaseColumnName(6));
}
assertEquals(Types.INTEGER, rsmd.getColumnType(1));
assertEquals(Types.VARCHAR, rsmd.getColumnType(2));
assertEquals("int4", rsmd.getColumnTypeName(1));
assertEquals("text", rsmd.getColumnTypeName(2));
assertEquals(10, rsmd.getPrecision(3));
assertEquals(2, rsmd.getScale(3));
assertEquals("", rsmd.getSchemaName(1));
assertEquals("", rsmd.getSchemaName(4));
if (TestUtil.isProtocolVersion(conn, 3))
{
assertEquals("public", pgrsmd.getBaseSchemaName(1));
assertEquals("", pgrsmd.getBaseSchemaName(4));
}
assertEquals("", rsmd.getTableName(1));
assertEquals("", rsmd.getTableName(4));
if (TestUtil.isProtocolVersion(conn, 3))
{
assertEquals("rsmd1", pgrsmd.getBaseTableName(1));
assertEquals("", pgrsmd.getBaseTableName(4));
}
if (TestUtil.isProtocolVersion(conn, 3))
{
assertEquals(ResultSetMetaData.columnNoNulls, rsmd.isNullable(1));
assertEquals(ResultSetMetaData.columnNullable, rsmd.isNullable(2));
assertEquals(ResultSetMetaData.columnNullableUnknown, rsmd.isNullable(4));
}
else
{
assertEquals(ResultSetMetaData.columnNullableUnknown, rsmd.isNullable(1));
}
}
// verify that a prepared update statement returns no metadata and doesn't execute.
public void testPreparedUpdate() throws SQLException {
PreparedStatement pstmt = conn.prepareStatement("INSERT INTO rsmd1(a,b) VALUES(?,?)");
pstmt.setInt(1,1);
pstmt.setString(2,"hello");
ResultSetMetaData rsmd = pstmt.getMetaData();
assertNull(rsmd);
pstmt.close();
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT COUNT(*) FROM rsmd1");
assertTrue(rs.next());
assertEquals(0, rs.getInt(1));
rs.close();
stmt.close();
}
public void testDatabaseMetaDataNames() throws SQLException {
DatabaseMetaData databaseMetaData = conn.getMetaData();
ResultSet resultSet = databaseMetaData.getTableTypes();
ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
assertEquals(1, resultSetMetaData.getColumnCount());
assertEquals("TABLE_TYPE", resultSetMetaData.getColumnName(1));
resultSet.close();
}
public void testTimestampInfo() throws SQLException {
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT tm, tmtz, ts, tstz FROM timetest");
ResultSetMetaData rsmd = rs.getMetaData();
// For reference:
// TestUtil.createTable(conn, "timetest", "tm time(3), tmtz timetz, ts timestamp without time zone, tstz timestamp(6) with time zone");
assertEquals(3, rsmd.getScale(1));
assertEquals(6, rsmd.getScale(2));
assertEquals(6, rsmd.getScale(3));
assertEquals(6, rsmd.getScale(4));
assertEquals(12, rsmd.getColumnDisplaySize(1));
assertEquals(21, rsmd.getColumnDisplaySize(2));
assertEquals(29, rsmd.getColumnDisplaySize(3));
assertEquals(35, rsmd.getColumnDisplaySize(4));
rs.close();
stmt.close();
}
public void testColumnDisplaySize() throws SQLException {
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT fixedchar, fixedvarchar, unfixedvarchar, txt, bytearr, num64, num60, num, ip FROM sizetest");
ResultSetMetaData rsmd = rs.getMetaData();
assertEquals(5, rsmd.getColumnDisplaySize(1));
assertEquals(5, rsmd.getColumnDisplaySize(2));
assertEquals(Integer.MAX_VALUE, rsmd.getColumnDisplaySize(3));
assertEquals(Integer.MAX_VALUE, rsmd.getColumnDisplaySize(4));
assertEquals(Integer.MAX_VALUE, rsmd.getColumnDisplaySize(5));
assertEquals(8, rsmd.getColumnDisplaySize(6));
assertEquals(7, rsmd.getColumnDisplaySize(7));
assertEquals(131089, rsmd.getColumnDisplaySize(8));
assertEquals(Integer.MAX_VALUE, rsmd.getColumnDisplaySize(9));
}
public void testIsAutoIncrement() throws SQLException {
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT c,b,a FROM serialtest");
ResultSetMetaData rsmd = rs.getMetaData();
assertTrue(!rsmd.isAutoIncrement(1));
if (TestUtil.isProtocolVersion(conn, 3))
{
assertTrue(rsmd.isAutoIncrement(2));
assertTrue(rsmd.isAutoIncrement(3));
assertEquals("bigserial", rsmd.getColumnTypeName(2));
assertEquals("serial", rsmd.getColumnTypeName(3));
}
rs.close();
stmt.close();
}
public void testClassesMatch() throws SQLException {
Statement stmt = conn.createStatement();
stmt.executeUpdate("INSERT INTO alltypes (bool, i2, i4, i8, num, re, fl, ch, vc, tx, d, t, tz, ts, tsz, bt) VALUES ('t', 2, 4, 8, 3.1, 3.14, 3.141, 'c', 'vc', 'tx', '2004-04-09', '09:01:00', '11:11:00-01','2004-04-09 09:01:00','1999-09-19 14:23:12-09', '\\\\123')");
ResultSet rs = stmt.executeQuery("SELECT * FROM alltypes");
ResultSetMetaData rsmd = rs.getMetaData();
assertTrue(rs.next());
for (int i=0; i= 4);
//max should apply to the following since the column is
//a varchar column
rs = stmt.executeQuery("select * from teststring");
rs.next();
assertEquals("12", rs.getString(1));
assertEquals("12", new String(rs.getBytes(1)));
}
public void booleanTests(boolean useServerPrepare) throws SQLException
{
java.sql.PreparedStatement pstmt = con.prepareStatement("insert into testbool values (?)");
if (useServerPrepare)
((org.postgresql.PGStatement)pstmt).setUseServerPrepare(true);
pstmt.setObject(1, new Float(0), java.sql.Types.BIT);
pstmt.executeUpdate();
pstmt.setObject(1, new Float(1), java.sql.Types.BIT);
pstmt.executeUpdate();
pstmt.setObject(1, "False", java.sql.Types.BIT);
pstmt.executeUpdate();
pstmt.setObject(1, "True", java.sql.Types.BIT);
pstmt.executeUpdate();
ResultSet rs = con.createStatement().executeQuery("select * from testbool");
for (int i = 0; i < 2; i++)
{
assertTrue(rs.next());
assertEquals(false, rs.getBoolean(1));
assertTrue(rs.next());
assertEquals(true, rs.getBoolean(1));
}
/*
pstmt = con.prepareStatement("insert into testbit values (?)");
pstmt.setObject(1, new Float(0), java.sql.Types.BIT);
pstmt.executeUpdate();
pstmt.setObject(1, new Float(1), java.sql.Types.BIT);
pstmt.executeUpdate();
pstmt.setObject(1, "false", java.sql.Types.BIT);
pstmt.executeUpdate();
pstmt.setObject(1, "true", java.sql.Types.BIT);
pstmt.executeUpdate();
rs = con.createStatement().executeQuery("select * from testbit");
for (int i = 0;i<2; i++)
{
assertTrue(rs.next());
assertEquals(false, rs.getBoolean(1));
assertTrue(rs.next());
assertEquals(true, rs.getBoolean(1));
}
*/
rs = con.createStatement().executeQuery("select * from testboolstring");
for (int i = 0;i < 4; i++)
{
assertTrue(rs.next());
assertEquals(true, rs.getBoolean(1));
assertTrue(rs.next());
assertEquals(false, rs.getBoolean(1));
}
}
public void testBoolean() throws SQLException
{
booleanTests(true);
booleanTests(false);
}
public void testgetByte() throws SQLException
{
ResultSet rs = con.createStatement().executeQuery(
"select * from testnumeric");
assertTrue(rs.next());
assertEquals(1, rs.getByte(1));
assertTrue(rs.next());
assertEquals(0, rs.getByte(1));
assertTrue(rs.next());
assertEquals( -1, rs.getByte(1));
assertTrue(rs.next());
assertEquals(1, rs.getByte(1));
assertTrue(rs.next());
assertEquals( -2, rs.getByte(1));
while (rs.next())
{
try
{
rs.getByte(1);
fail("Exception expected.");
}
catch (Exception e)
{
}
}
rs.close();
}
public void testgetShort() throws SQLException
{
ResultSet rs = con.createStatement().executeQuery(
"select * from testnumeric");
assertTrue(rs.next());
assertEquals(1, rs.getShort(1));
assertTrue(rs.next());
assertEquals(0, rs.getShort(1));
assertTrue(rs.next());
assertEquals( -1, rs.getShort(1));
assertTrue(rs.next());
assertEquals(1, rs.getShort(1));
assertTrue(rs.next());
assertEquals( -2, rs.getShort(1));
while (rs.next())
{
try
{
rs.getShort(1);
fail("Exception expected.");
}
catch (Exception e)
{
}
}
rs.close();
}
public void testgetInt() throws SQLException
{
ResultSet rs = con.createStatement().executeQuery(
"select * from testnumeric");
assertTrue(rs.next());
assertEquals(1, rs.getInt(1));
assertTrue(rs.next());
assertEquals(0, rs.getInt(1));
assertTrue(rs.next());
assertEquals( -1, rs.getInt(1));
assertTrue(rs.next());
assertEquals(1, rs.getInt(1));
assertTrue(rs.next());
assertEquals( -2, rs.getInt(1));
assertTrue(rs.next());
assertEquals(99999, rs.getInt(1));
assertTrue(rs.next());
assertEquals(99999, rs.getInt(1));
assertTrue(rs.next());
assertEquals( -99999, rs.getInt(1));
assertTrue(rs.next());
assertEquals( -99999, rs.getInt(1));
assertTrue(rs.next());
assertEquals(Integer.MAX_VALUE, rs.getInt(1));
assertTrue(rs.next());
assertEquals(Integer.MIN_VALUE, rs.getInt(1));
while (rs.next())
{
try
{
rs.getInt(1);
fail("Exception expected." + rs.getString(1));
}
catch (Exception e)
{
}
}
rs.close();
}
public void testgetLong() throws SQLException
{
ResultSet rs = con.createStatement().executeQuery(
"select * from testnumeric");
assertTrue(rs.next());
assertEquals(1, rs.getLong(1));
assertTrue(rs.next());
assertEquals(0, rs.getLong(1));
assertTrue(rs.next());
assertEquals( -1, rs.getLong(1));
assertTrue(rs.next());
assertEquals(1, rs.getLong(1));
assertTrue(rs.next());
assertEquals( -2, rs.getLong(1));
assertTrue(rs.next());
assertEquals(99999, rs.getLong(1));
assertTrue(rs.next());
assertEquals(99999, rs.getLong(1));
assertTrue(rs.next());
assertEquals( -99999, rs.getLong(1));
assertTrue(rs.next());
assertEquals( -99999, rs.getLong(1));
assertTrue(rs.next());
assertEquals( ((long)Integer.MAX_VALUE), rs.getLong(1));
assertTrue(rs.next());
assertEquals( ((long)Integer.MIN_VALUE), rs.getLong(1));
assertTrue(rs.next());
assertEquals( ((long)Integer.MAX_VALUE) + 1, rs.getLong(1));
assertTrue(rs.next());
assertEquals( ((long)Integer.MIN_VALUE) - 1, rs.getLong(1));
assertTrue(rs.next());
assertEquals( Long.MAX_VALUE, rs.getLong(1));
assertTrue(rs.next());
assertEquals( Long.MIN_VALUE, rs.getLong(1));
while (rs.next())
{
try
{
rs.getLong(1);
fail("Exception expected." + rs.getString(1) );
}
catch (Exception e)
{
}
}
rs.close();
}
public void testParameters() throws SQLException
{
Statement stmt = con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE);
stmt.setFetchSize(100);
stmt.setFetchDirection(ResultSet.FETCH_UNKNOWN);
ResultSet rs = stmt.executeQuery("SELECT * FROM testrs");
assertEquals(ResultSet.CONCUR_UPDATABLE, stmt.getResultSetConcurrency());
assertEquals(ResultSet.TYPE_SCROLL_SENSITIVE, stmt.getResultSetType());
assertEquals(100, stmt.getFetchSize());
assertEquals(ResultSet.FETCH_UNKNOWN, stmt.getFetchDirection());
assertEquals(ResultSet.CONCUR_UPDATABLE, rs.getConcurrency());
assertEquals(ResultSet.TYPE_SCROLL_SENSITIVE, rs.getType());
assertEquals(100, rs.getFetchSize());
assertEquals(ResultSet.FETCH_UNKNOWN, rs.getFetchDirection());
rs.close();
stmt.close();
}
public void testZeroRowResultPositioning() throws SQLException
{
Statement stmt = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE);
ResultSet rs = stmt.executeQuery("SELECT * FROM pg_database WHERE datname='nonexistantdatabase'");
assertTrue(!rs.previous());
assertTrue(!rs.previous());
assertTrue(!rs.next());
assertTrue(!rs.next());
assertTrue(!rs.next());
assertTrue(!rs.next());
assertTrue(!rs.next());
assertTrue(!rs.previous());
assertTrue(!rs.first());
assertTrue(!rs.last());
assertEquals(0, rs.getRow());
assertTrue(!rs.absolute(1));
assertTrue(!rs.relative(1));
assertTrue(!rs.isBeforeFirst());
assertTrue(!rs.isAfterLast());
assertTrue(!rs.isFirst());
assertTrue(!rs.isLast());
rs.close();
stmt.close();
}
public void testRowResultPositioning() throws SQLException
{
Statement stmt = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE);
// Create a one row result set.
ResultSet rs = stmt.executeQuery("SELECT * FROM pg_database WHERE datname='template1'");
assertTrue(rs.isBeforeFirst());
assertTrue(!rs.isAfterLast());
assertTrue(!rs.isFirst());
assertTrue(!rs.isLast());
assertTrue(rs.next());
assertTrue(!rs.isBeforeFirst());
assertTrue(!rs.isAfterLast());
assertTrue(rs.isFirst());
assertTrue(rs.isLast());
assertTrue(!rs.next());
assertTrue(!rs.isBeforeFirst());
assertTrue(rs.isAfterLast());
assertTrue(!rs.isFirst());
assertTrue(!rs.isLast());
assertTrue(rs.previous());
assertTrue(!rs.isBeforeFirst());
assertTrue(!rs.isAfterLast());
assertTrue(rs.isFirst());
assertTrue(rs.isLast());
assertTrue(rs.absolute(1));
assertTrue(!rs.isBeforeFirst());
assertTrue(!rs.isAfterLast());
assertTrue(rs.isFirst());
assertTrue(rs.isLast());
assertTrue(!rs.absolute(0));
assertTrue(rs.isBeforeFirst());
assertTrue(!rs.isAfterLast());
assertTrue(!rs.isFirst());
assertTrue(!rs.isLast());
assertTrue(!rs.absolute(2));
assertTrue(!rs.isBeforeFirst());
assertTrue(rs.isAfterLast());
assertTrue(!rs.isFirst());
assertTrue(!rs.isLast());
rs.close();
stmt.close();
}
public void testForwardOnlyExceptions() throws SQLException
{
// Test that illegal operations on a TYPE_FORWARD_ONLY resultset
// correctly result in throwing an exception.
Statement stmt = con.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
ResultSet rs = stmt.executeQuery("SELECT * FROM testnumeric");
try
{
rs.absolute(1);
fail("absolute() on a TYPE_FORWARD_ONLY resultset did not throw an exception");
}
catch (SQLException e)
{
}
try
{
rs.afterLast();
fail("afterLast() on a TYPE_FORWARD_ONLY resultset did not throw an exception on a TYPE_FORWARD_ONLY resultset");
}
catch (SQLException e)
{
}
try
{
rs.beforeFirst();
fail("beforeFirst() on a TYPE_FORWARD_ONLY resultset did not throw an exception");
}
catch (SQLException e)
{
}
try
{
rs.first();
fail("first() on a TYPE_FORWARD_ONLY resultset did not throw an exception");
}
catch (SQLException e)
{
}
try
{
rs.last();
fail("last() on a TYPE_FORWARD_ONLY resultset did not throw an exception");
}
catch (SQLException e)
{
}
try
{
rs.previous();
fail("previous() on a TYPE_FORWARD_ONLY resultset did not throw an exception");
}
catch (SQLException e)
{
}
try
{
rs.relative(1);
fail("relative() on a TYPE_FORWARD_ONLY resultset did not throw an exception");
}
catch (SQLException e)
{
}
try
{
rs.setFetchDirection(ResultSet.FETCH_REVERSE);
fail("setFetchDirection(FETCH_REVERSE) on a TYPE_FORWARD_ONLY resultset did not throw an exception");
}
catch (SQLException e)
{
}
try
{
rs.setFetchDirection(ResultSet.FETCH_UNKNOWN);
fail("setFetchDirection(FETCH_UNKNOWN) on a TYPE_FORWARD_ONLY resultset did not throw an exception");
}
catch (SQLException e)
{
}
rs.close();
stmt.close();
}
public void testCaseInsensitiveFindColumn() throws SQLException
{
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery("SELECT id, id AS \"ID2\" FROM testrs");
assertEquals(1, rs.findColumn("id"));
assertEquals(1, rs.findColumn("ID"));
assertEquals(1, rs.findColumn("Id"));
assertEquals(2, rs.findColumn("id2"));
assertEquals(2, rs.findColumn("ID2"));
assertEquals(2, rs.findColumn("Id2"));
try
{
rs.findColumn("id3");
fail("There isn't an id3 column in the ResultSet.");
}
catch (SQLException sqle)
{
}
}
public void testGetOutOfBounds() throws SQLException
{
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery("SELECT id FROM testrs");
assertTrue(rs.next());
try {
rs.getInt(-9);
} catch (SQLException sqle) {
}
try {
rs.getInt(1000);
} catch (SQLException sqle) {
}
}
public void testClosedResult() throws SQLException
{
Statement stmt = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE);
ResultSet rs = stmt.executeQuery("SELECT id FROM testrs");
rs.close();
rs.close(); // Closing twice is allowed.
try { rs.getInt(1); fail("Expected SQLException"); }
catch (SQLException e) { }
try { rs.getInt("id"); fail("Expected SQLException"); }
catch (SQLException e) { }
try { rs.getType(); fail("Expected SQLException"); }
catch (SQLException e) { }
try { rs.wasNull(); fail("Expected SQLException"); }
catch (SQLException e) { }
try { rs.absolute(3); fail("Expected SQLException"); }
catch (SQLException e) { }
try { rs.isBeforeFirst(); fail("Expected SQLException"); }
catch (SQLException e) { }
try { rs.setFetchSize(10); fail("Expected SQLException"); }
catch (SQLException e) { }
try { rs.getMetaData(); fail("Expected SQLException"); }
catch (SQLException e) { }
try { rs.rowUpdated(); fail("Expected SQLException"); }
catch (SQLException e) { }
try { rs.updateInt(1,1); fail("Expected SQLException"); }
catch (SQLException e) { }
try { rs.moveToInsertRow(); fail("Expected SQLException"); }
catch (SQLException e) { }
try { rs.clearWarnings(); fail("Expected SQLException"); }
catch (SQLException e) { }
}
/*
* The JDBC spec says when you have duplicate column names,
* the first one should be returned.
*/
public void testDuplicateColumnNameOrder() throws SQLException
{
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery("SELECT 1 AS a, 2 AS a");
assertTrue(rs.next());
assertEquals(1, rs.getInt("a"));
}
public void testTurkishLocale() throws SQLException
{
Locale current = Locale.getDefault();
try {
Locale.setDefault(new Locale("tr", "TR"));
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery("SELECT id FROM testrs");
int sum = 0;
while (rs.next()) {
sum += rs.getInt("ID");
}
rs.close();
assertEquals(25, sum);
} finally {
Locale.setDefault(current);
}
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc2/ServerCursorTest.java 0000664 0000000 0000000 00000005623 12050675701 0026752 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc2;
import java.sql.*;
import junit.framework.TestCase;
import org.postgresql.test.TestUtil;
/*
* Tests for using non-zero setFetchSize().
*/
public class ServerCursorTest extends TestCase
{
private Connection con;
public ServerCursorTest(String name)
{
super(name);
}
protected void setUp() throws Exception
{
con = TestUtil.openDB();
TestUtil.createTable(con, "test_fetch", "value integer,data bytea");
con.setAutoCommit(false);
}
protected void tearDown() throws Exception
{
con.rollback();
con.setAutoCommit(true);
TestUtil.dropTable(con, "test_fetch");
TestUtil.closeDB(con);
}
protected void createRows(int count) throws Exception
{
PreparedStatement stmt = con.prepareStatement("insert into test_fetch(value,data) values(?,?)");
for (int i = 0; i < count; ++i)
{
stmt.setInt(1, i + 1);
stmt.setBytes(2, DATA_STRING.getBytes("UTF8"));
stmt.executeUpdate();
}
con.commit();
}
//Test regular cursor fetching
public void testBasicFetch() throws Exception
{
createRows(1);
PreparedStatement stmt = con.prepareStatement("declare test_cursor cursor for select * from test_fetch");
stmt.execute();
stmt = con.prepareStatement("fetch forward from test_cursor");
ResultSet rs = stmt.executeQuery();
while (rs.next())
{
//there should only be one row returned
assertEquals("query value error", 1, rs.getInt(1));
byte[] dataBytes = rs.getBytes(2);
assertEquals("binary data got munged", DATA_STRING, new String(dataBytes, "UTF8"));
}
}
//Test binary cursor fetching
public void testBinaryFetch() throws Exception
{
createRows(1);
PreparedStatement stmt = con.prepareStatement("declare test_cursor binary cursor for select * from test_fetch");
stmt.execute();
stmt = con.prepareStatement("fetch forward from test_cursor");
ResultSet rs = stmt.executeQuery();
while (rs.next())
{
//there should only be one row returned
byte[] dataBytes = rs.getBytes(2);
assertEquals("binary data got munged", DATA_STRING, new String(dataBytes, "UTF8"));
}
}
//This string contains a variety different data:
// three japanese characters representing "japanese" in japanese
// the four characters "\000"
// a null character
// the seven ascii characters "english"
private static final String DATA_STRING = "\u65E5\u672C\u8A9E\\000\u0000english";
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc2/ServerPreparedStmtTest.java 0000664 0000000 0000000 00000023450 12050675701 0030105 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc2;
import org.postgresql.PGStatement;
import org.postgresql.jdbc2.AbstractJdbc2Statement;
import org.postgresql.test.TestUtil;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.Statement;
import junit.framework.TestCase;
/*
* Tests for using server side prepared statements
*/
public class ServerPreparedStmtTest extends TestCase
{
private Connection con;
public ServerPreparedStmtTest(String name)
{
super(name);
}
protected void setUp() throws Exception
{
con = TestUtil.openDB();
Statement stmt = con.createStatement();
TestUtil.createTable(con, "testsps", "id integer, value boolean");
stmt.executeUpdate("INSERT INTO testsps VALUES (1,'t')");
stmt.executeUpdate("INSERT INTO testsps VALUES (2,'t')");
stmt.executeUpdate("INSERT INTO testsps VALUES (3,'t')");
stmt.executeUpdate("INSERT INTO testsps VALUES (4,'t')");
stmt.executeUpdate("INSERT INTO testsps VALUES (6,'t')");
stmt.executeUpdate("INSERT INTO testsps VALUES (9,'f')");
stmt.close();
}
protected void tearDown() throws Exception
{
TestUtil.dropTable(con, "testsps");
TestUtil.closeDB(con);
}
public void testEmptyResults() throws Exception
{
PreparedStatement pstmt = con.prepareStatement("SELECT * FROM testsps WHERE id = ?");
((PGStatement)pstmt).setUseServerPrepare(true);
for (int i=0; i<10; ++i) {
pstmt.setInt(1, -1);
ResultSet rs = pstmt.executeQuery();
assertFalse(rs.next());
rs.close();
}
pstmt.close();
}
public void testPreparedExecuteCount() throws Exception
{
PreparedStatement pstmt = con.prepareStatement("UPDATE testsps SET id = id + 44");
((PGStatement)pstmt).setUseServerPrepare(true);
int count = pstmt.executeUpdate();
assertEquals(6, count);
pstmt.close();
}
public void testPreparedStatementsNoBinds() throws Exception
{
PreparedStatement pstmt = con.prepareStatement("SELECT * FROM testsps WHERE id = 2");
((PGStatement)pstmt).setUseServerPrepare(true);
assertTrue(((PGStatement)pstmt).isUseServerPrepare());
//Test that basic functionality works
ResultSet rs = pstmt.executeQuery();
assertTrue(rs.next());
assertEquals(2, rs.getInt(1));
rs.close();
//Verify that subsequent calls still work
rs = pstmt.executeQuery();
assertTrue(rs.next());
assertEquals(2, rs.getInt(1));
rs.close();
//Verify that using the statement still works after turning off prepares
if (AbstractJdbc2Statement.ForceBinaryTransfers) {
return;
}
((PGStatement)pstmt).setUseServerPrepare(false);
assertTrue(!((PGStatement)pstmt).isUseServerPrepare());
rs = pstmt.executeQuery();
assertTrue(rs.next());
assertEquals(2, rs.getInt(1));
rs.close();
pstmt.close();
}
public void testPreparedStatementsWithOneBind() throws Exception
{
PreparedStatement pstmt = con.prepareStatement("SELECT * FROM testsps WHERE id = ?");
((PGStatement)pstmt).setUseServerPrepare(true);
assertTrue(((PGStatement)pstmt).isUseServerPrepare());
//Test that basic functionality works
pstmt.setInt(1, 2);
ResultSet rs = pstmt.executeQuery();
assertTrue(rs.next());
assertEquals(2, rs.getInt(1));
rs.close();
//Verify that subsequent calls still work
rs = pstmt.executeQuery();
assertTrue(rs.next());
assertEquals(2, rs.getInt(1));
rs.close();
//Verify that using the statement still works after turning off prepares
if (AbstractJdbc2Statement.ForceBinaryTransfers) {
return;
}
((PGStatement)pstmt).setUseServerPrepare(false);
assertTrue(!((PGStatement)pstmt).isUseServerPrepare());
pstmt.setInt(1, 9);
rs = pstmt.executeQuery();
assertTrue(rs.next());
assertEquals(9, rs.getInt(1));
rs.close();
pstmt.close();
}
// Verify we can bind booleans-as-objects ok.
public void testBooleanObjectBind() throws Exception
{
PreparedStatement pstmt = con.prepareStatement("SELECT * FROM testsps WHERE value = ?");
((PGStatement)pstmt).setUseServerPrepare(true);
assertTrue(((PGStatement)pstmt).isUseServerPrepare());
pstmt.setObject(1, new Boolean(false), java.sql.Types.BIT);
ResultSet rs = pstmt.executeQuery();
assertTrue(rs.next());
assertEquals(9, rs.getInt(1));
rs.close();
}
// Verify we can bind booleans-as-integers ok.
public void testBooleanIntegerBind() throws Exception
{
PreparedStatement pstmt = con.prepareStatement("SELECT * FROM testsps WHERE id = ?");
((PGStatement)pstmt).setUseServerPrepare(true);
assertTrue(((PGStatement)pstmt).isUseServerPrepare());
pstmt.setObject(1, new Boolean(true), java.sql.Types.INTEGER);
ResultSet rs = pstmt.executeQuery();
assertTrue(rs.next());
assertEquals(1, rs.getInt(1));
rs.close();
}
// Verify we can bind booleans-as-native-types ok.
public void testBooleanBind() throws Exception
{
PreparedStatement pstmt = con.prepareStatement("SELECT * FROM testsps WHERE value = ?");
((PGStatement)pstmt).setUseServerPrepare(true);
assertTrue(((PGStatement)pstmt).isUseServerPrepare());
pstmt.setBoolean(1, false);
ResultSet rs = pstmt.executeQuery();
assertTrue(rs.next());
assertEquals(9, rs.getInt(1));
rs.close();
}
public void testPreparedStatementsWithBinds() throws Exception
{
PreparedStatement pstmt = con.prepareStatement("SELECT * FROM testsps WHERE id = ? or id = ?");
((PGStatement)pstmt).setUseServerPrepare(true);
assertTrue(((PGStatement)pstmt).isUseServerPrepare());
//Test that basic functionality works
//bind different datatypes
pstmt.setInt(1, 2);
pstmt.setLong(2, 2);
ResultSet rs = pstmt.executeQuery();
assertTrue(rs.next());
assertEquals(2, rs.getInt(1));
rs.close();
//Verify that subsequent calls still work
rs = pstmt.executeQuery();
assertTrue(rs.next());
assertEquals(2, rs.getInt(1));
rs.close();
pstmt.close();
}
public void testSPSToggle() throws Exception
{
// Verify we can toggle UseServerPrepare safely before a query is executed.
PreparedStatement pstmt = con.prepareStatement("SELECT * FROM testsps WHERE id = 2");
((PGStatement)pstmt).setUseServerPrepare(true);
((PGStatement)pstmt).setUseServerPrepare(false);
}
public void testBytea() throws Exception
{
// Verify we can use setBytes() with a server-prepared update.
try
{
TestUtil.createTable(con, "testsps_bytea", "data bytea");
PreparedStatement pstmt = con.prepareStatement("INSERT INTO testsps_bytea(data) VALUES (?)");
((PGStatement)pstmt).setUseServerPrepare(true);
pstmt.setBytes(1, new byte[100]);
pstmt.executeUpdate();
}
finally
{
TestUtil.dropTable(con, "testsps_bytea");
}
}
// Check statements are not transformed when they shouldn't be.
public void testCreateTable() throws Exception {
// CREATE TABLE isn't supported by PREPARE; the driver should realize this and
// still complete without error.
PreparedStatement pstmt = con.prepareStatement("CREATE TABLE testsps_bad(data int)");
((PGStatement)pstmt).setUseServerPrepare(true);
pstmt.executeUpdate();
TestUtil.dropTable(con, "testsps_bad");
}
public void testMultistatement() throws Exception {
// Shouldn't try to PREPARE this one, if we do we get:
// PREPARE x(int,int) AS INSERT .... $1 ; INSERT ... $2 -- syntax error
try
{
TestUtil.createTable(con, "testsps_multiple", "data int");
PreparedStatement pstmt = con.prepareStatement("INSERT INTO testsps_multiple(data) VALUES (?); INSERT INTO testsps_multiple(data) VALUES (?)");
((PGStatement)pstmt).setUseServerPrepare(true);
pstmt.setInt(1, 1);
pstmt.setInt(2, 2);
pstmt.executeUpdate(); // Two inserts.
pstmt.setInt(1, 3);
pstmt.setInt(2, 4);
pstmt.executeUpdate(); // Two more inserts.
ResultSet check = con.createStatement().executeQuery("SELECT COUNT(*) FROM testsps_multiple");
assertTrue(check.next());
assertEquals(4, check.getInt(1));
}
finally
{
TestUtil.dropTable(con, "testsps_multiple");
}
}
public void testTypeChange() throws Exception {
PreparedStatement pstmt = con.prepareStatement("SELECT CAST (? AS TEXT)");
((PGStatement)pstmt).setUseServerPrepare(true);
// Prepare with int parameter.
pstmt.setInt(1, 1);
ResultSet rs = pstmt.executeQuery();
assertTrue(rs.next());
assertEquals(1, rs.getInt(1));
assertTrue(!rs.next());
// Change to text parameter, check it still works.
pstmt.setString(1, "test string");
rs = pstmt.executeQuery();
assertTrue(rs.next());
assertEquals("test string", rs.getString(1));
assertTrue(!rs.next());
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc2/StatementTest.java 0000664 0000000 0000000 00000046135 12050675701 0026255 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc2;
import org.postgresql.test.TestUtil;
import junit.framework.*;
import java.sql.*;
import java.util.Timer;
import java.util.TimerTask;
/*
* Test for getObject
*/
public class StatementTest extends TestCase
{
Connection con = null;
public StatementTest(String name )
{
super(name);
}
protected void setUp() throws Exception
{
super.setUp();
con = TestUtil.openDB();
TestUtil.createTempTable(con, "test_statement",
"i int");
TestUtil.createTempTable(con, "escapetest",
"ts timestamp, d date, t time, \")\" varchar(5), \"\"\"){a}'\" text ");
TestUtil.createTempTable(con, "comparisontest","str1 varchar(5), str2 varchar(15)");
Statement stmt = con.createStatement();
stmt.executeUpdate(TestUtil.insertSQL("comparisontest","str1,str2","'_abcd','_found'"));
stmt.executeUpdate(TestUtil.insertSQL("comparisontest","str1,str2","'%abcd','%found'"));
stmt.close();
}
protected void tearDown() throws Exception
{
super.tearDown();
TestUtil.dropTable( con, "test_statement" );
TestUtil.dropTable( con, "escapetest" );
TestUtil.dropTable(con,"comparisontest");
con.close();
}
public void testClose() throws SQLException
{
Statement stmt = null;
stmt = con.createStatement();
stmt.close();
try
{
stmt.getResultSet();
this.fail( "statements should not be re-used after close" );
}
catch (SQLException ex)
{
}
}
/**
* Closing a Statement twice is not an error.
*/
public void testDoubleClose() throws SQLException
{
Statement stmt = con.createStatement();
stmt.close();
stmt.close();
}
public void testMultiExecute() throws SQLException
{
Statement stmt = con.createStatement();
assertTrue(stmt.execute("SELECT 1; UPDATE test_statement SET i=1; SELECT 2"));
ResultSet rs = stmt.getResultSet();
assertTrue(rs.next());
assertEquals(1, rs.getInt(1));
rs.close();
assertTrue(!stmt.getMoreResults());
assertEquals(0, stmt.getUpdateCount());
assertTrue(stmt.getMoreResults());
rs = stmt.getResultSet();
assertTrue(rs.next());
assertEquals(2, rs.getInt(1));
rs.close();
assertTrue(!stmt.getMoreResults());
assertEquals(-1, stmt.getUpdateCount());
stmt.close();
}
public void testEmptyQuery() throws SQLException
{
Statement stmt = con.createStatement();
stmt.execute("");
assertNull(stmt.getResultSet());
assertTrue(!stmt.getMoreResults());
}
public void testUpdateCount() throws SQLException
{
Statement stmt = con.createStatement();
int count;
count = stmt.executeUpdate("INSERT INTO test_statement VALUES (3)");
assertEquals(1, count);
count = stmt.executeUpdate("INSERT INTO test_statement VALUES (3)");
assertEquals(1, count);
count = stmt.executeUpdate("UPDATE test_statement SET i=4");
assertEquals(2, count);
count = stmt.executeUpdate("CREATE TEMP TABLE another_table (a int)");
assertEquals(0, count);
}
public void testEscapeProcessing() throws SQLException
{
Statement stmt = con.createStatement();
int count;
count = stmt.executeUpdate("insert into escapetest (ts) values ({ts '1900-01-01 00:00:00'})");
assertEquals(1, count);
count = stmt.executeUpdate("insert into escapetest (d) values ({d '1900-01-01'})");
assertEquals(1, count);
count = stmt.executeUpdate("insert into escapetest (t) values ({t '00:00:00'})");
assertEquals(1, count);
ResultSet rs = stmt.executeQuery( "select {fn version()} as version" );
assertTrue(rs.next());
// check nested and multiple escaped functions
rs = stmt.executeQuery( "select {fn version()} as version, {fn log({fn log(3.0)})} as log" );
assertTrue(rs.next());
assertEquals(Math.log(Math.log(3)), rs.getDouble(2), 0.00001);
stmt.executeUpdate("UPDATE escapetest SET \")\" = 'a', \"\"\"){a}'\" = 'b'");
// check "difficult" values
rs = stmt.executeQuery("select {fn concat(')',escapetest.\")\")} as concat" +
", {fn concat('{','}')} " +
", {fn concat('''','\"')} " +
", {fn concat(\"\"\"){a}'\", '''}''')} " +
" FROM escapetest");
assertTrue(rs.next());
assertEquals(")a", rs.getString(1));
assertEquals("{}", rs.getString(2));
assertEquals("'\"", rs.getString(3));
assertEquals("b'}'", rs.getString(4));
count = stmt.executeUpdate( "create temp table b (i int)" );
assertEquals(0, count);
rs = stmt.executeQuery( "select * from {oj test_statement a left outer join b on (a.i=b.i)} ");
assertTrue(!rs.next());
// test escape escape character
rs = stmt.executeQuery("select str2 from comparisontest where str1 like '|_abcd' {escape '|'} ");
assertTrue(rs.next());
assertEquals("_found",rs.getString(1));
rs = stmt.executeQuery("select str2 from comparisontest where str1 like '|%abcd' {escape '|'} ");
assertTrue(rs.next());
assertEquals("%found",rs.getString(1));
}
public void testPreparedFunction() throws SQLException
{
PreparedStatement pstmt = con.prepareStatement("SELECT {fn concat('a', ?)}");
pstmt.setInt(1, 5);
ResultSet rs = pstmt.executeQuery();
assertTrue(rs.next());
assertEquals("a5", rs.getString(1));
}
public void testNumericFunctions() throws SQLException
{
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery("select {fn abs(-2.3)} as abs ");
assertTrue(rs.next());
assertEquals(2.3f, rs.getFloat(1), 0.00001);
rs = stmt.executeQuery("select {fn acos(-0.6)} as acos ");
assertTrue(rs.next());
assertEquals(Math.acos(-0.6), rs.getDouble(1), 0.00001);
rs = stmt.executeQuery("select {fn asin(-0.6)} as asin ");
assertTrue(rs.next());
assertEquals(Math.asin(-0.6), rs.getDouble(1), 0.00001);
rs = stmt.executeQuery("select {fn atan(-0.6)} as atan ");
assertTrue(rs.next());
assertEquals(Math.atan(-0.6), rs.getDouble(1), 0.00001);
rs = stmt.executeQuery("select {fn atan2(-2.3,7)} as atan2 ");
assertTrue(rs.next());
assertEquals(Math.atan2(-2.3,7), rs.getDouble(1), 0.00001);
rs = stmt.executeQuery("select {fn ceiling(-2.3)} as ceiling ");
assertTrue(rs.next());
assertEquals(-2, rs.getDouble(1), 0.00001);
rs = stmt.executeQuery("select {fn cos(-2.3)} as cos, {fn cot(-2.3)} as cot ");
assertTrue(rs.next());
assertEquals(Math.cos(-2.3), rs.getDouble(1), 0.00001);
assertEquals(1/Math.tan(-2.3), rs.getDouble(2), 0.00001);
rs = stmt.executeQuery("select {fn degrees({fn pi()})} as degrees ");
assertTrue(rs.next());
assertEquals(180, rs.getDouble(1), 0.00001);
rs = stmt.executeQuery("select {fn exp(-2.3)}, {fn floor(-2.3)}," +
" {fn log(2.3)},{fn log10(2.3)},{fn mod(3,2)}");
assertTrue(rs.next());
assertEquals(Math.exp(-2.3), rs.getDouble(1), 0.00001);
assertEquals(-3, rs.getDouble(2), 0.00001);
assertEquals(Math.log(2.3), rs.getDouble(3), 0.00001);
assertEquals(Math.log(2.3)/Math.log(10), rs.getDouble(4), 0.00001);
assertEquals(1, rs.getDouble(5), 0.00001);
rs = stmt.executeQuery("select {fn pi()}, {fn power(7,-2.3)}," +
" {fn radians(-180)},{fn round(3.1294,2)}");
assertTrue(rs.next());
assertEquals(Math.PI, rs.getDouble(1), 0.00001);
assertEquals(Math.pow(7,-2.3), rs.getDouble(2), 0.00001);
assertEquals(-Math.PI, rs.getDouble(3), 0.00001);
assertEquals(3.13, rs.getDouble(4), 0.00001);
rs = stmt.executeQuery("select {fn sign(-2.3)}, {fn sin(-2.3)}," +
" {fn sqrt(2.3)},{fn tan(-2.3)},{fn truncate(3.1294,2)}");
assertTrue(rs.next());
assertEquals(-1, rs.getInt(1));
assertEquals(Math.sin(-2.3), rs.getDouble(2), 0.00001);
assertEquals(Math.sqrt(2.3), rs.getDouble(3), 0.00001);
assertEquals(Math.tan(-2.3), rs.getDouble(4), 0.00001);
assertEquals(3.12, rs.getDouble(5), 0.00001);
}
public void testStringFunctions() throws SQLException
{
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery("select {fn ascii(' test')},{fn char(32)}" +
",{fn concat('ab','cd')}" +
",{fn lcase('aBcD')},{fn left('1234',2)},{fn length('123 ')}" +
",{fn locate('bc','abc')},{fn locate('bc','abc',3)}");
assertTrue(rs.next());
assertEquals(32,rs.getInt(1));
assertEquals(" ",rs.getString(2));
assertEquals("abcd",rs.getString(3));
assertEquals("abcd",rs.getString(4));
assertEquals("12",rs.getString(5));
assertEquals(3,rs.getInt(6));
assertEquals(2,rs.getInt(7));
assertEquals(0,rs.getInt(8));
if (TestUtil.haveMinimumServerVersion(con, "7.3")) {
rs = stmt.executeQuery("SELECT {fn insert('abcdef',3,2,'xxxx')}" +
",{fn replace('abcdbc','bc','x')}");
assertTrue(rs.next());
assertEquals("abxxxxef",rs.getString(1));
assertEquals("axdx",rs.getString(2));
}
rs = stmt.executeQuery("select {fn ltrim(' ab')},{fn repeat('ab',2)}" +
",{fn right('abcde',2)},{fn rtrim('ab ')}" +
",{fn space(3)},{fn substring('abcd',2,2)}" +
",{fn ucase('aBcD')}");
assertTrue(rs.next());
assertEquals("ab",rs.getString(1));
assertEquals("abab",rs.getString(2));
assertEquals("de",rs.getString(3));
assertEquals("ab",rs.getString(4));
assertEquals(" ",rs.getString(5));
assertEquals("bc",rs.getString(6));
assertEquals("ABCD",rs.getString(7));
}
public void testDateFuncWithParam() throws SQLException
{
// Prior to 8.0 there is not an interval + timestamp operator,
// so timestampadd does not work.
//
if (!TestUtil.haveMinimumServerVersion(con, "8.0"))
return;
PreparedStatement ps = con.prepareStatement("SELECT {fn timestampadd(SQL_TSI_QUARTER, ? ,{fn now()})}, {fn timestampadd(SQL_TSI_MONTH, ?, {fn now()})} ");
ps.setInt(1, 4);
ps.setInt(2, 12);
ResultSet rs = ps.executeQuery();
assertTrue(rs.next());
assertEquals(rs.getTimestamp(1), rs.getTimestamp(2));
}
public void testDateFunctions() throws SQLException
{
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery("select {fn curdate()},{fn curtime()}" +
",{fn dayname({fn now()})}, {fn dayofmonth({fn now()})}" +
",{fn dayofweek({ts '2005-01-17 12:00:00'})},{fn dayofyear({fn now()})}" +
",{fn hour({fn now()})},{fn minute({fn now()})}" +
",{fn month({fn now()})}" +
",{fn monthname({fn now()})},{fn quarter({fn now()})}" +
",{fn second({fn now()})},{fn week({fn now()})}" +
",{fn year({fn now()})} ");
assertTrue(rs.next());
// ensure sunday =>1 and monday =>2
assertEquals(2,rs.getInt(5));
// Prior to 8.0 there is not an interval + timestamp operator,
// so timestampadd does not work.
//
if (!TestUtil.haveMinimumServerVersion(con, "8.0"))
return;
// second
rs = stmt.executeQuery("select {fn timestampdiff(SQL_TSI_SECOND,{fn now()},{fn timestampadd(SQL_TSI_SECOND,3,{fn now()})})} ");
assertTrue(rs.next());
assertEquals(3,rs.getInt(1));
// MINUTE
rs = stmt.executeQuery("select {fn timestampdiff(SQL_TSI_MINUTE,{fn now()},{fn timestampadd(SQL_TSI_MINUTE,3,{fn now()})})} ");
assertTrue(rs.next());
assertEquals(3,rs.getInt(1));
// HOUR
rs = stmt.executeQuery("select {fn timestampdiff(SQL_TSI_HOUR,{fn now()},{fn timestampadd(SQL_TSI_HOUR,3,{fn now()})})} ");
assertTrue(rs.next());
assertEquals(3,rs.getInt(1));
// day
rs = stmt.executeQuery("select {fn timestampdiff(SQL_TSI_DAY,{fn now()},{fn timestampadd(SQL_TSI_DAY,-3,{fn now()})})} ");
assertTrue(rs.next());
assertEquals(-3,rs.getInt(1));
// WEEK => extract week from interval is not supported by backend
//rs = stmt.executeQuery("select {fn timestampdiff(SQL_TSI_WEEK,{fn now()},{fn timestampadd(SQL_TSI_WEEK,3,{fn now()})})} ");
//assertTrue(rs.next());
//assertEquals(3,rs.getInt(1));
// MONTH => backend assume there are 0 month in an interval of 92 days...
//rs = stmt.executeQuery("select {fn timestampdiff(SQL_TSI_MONTH,{fn now()},{fn timestampadd(SQL_TSI_MONTH,3,{fn now()})})} ");
//assertTrue(rs.next());
//assertEquals(3,rs.getInt(1));
// QUARTER => backend assume there are 1 quater even in 270 days...
//rs = stmt.executeQuery("select {fn timestampdiff(SQL_TSI_QUARTER,{fn now()},{fn timestampadd(SQL_TSI_QUARTER,3,{fn now()})})} ");
//assertTrue(rs.next());
//assertEquals(3,rs.getInt(1));
// YEAR
//rs = stmt.executeQuery("select {fn timestampdiff(SQL_TSI_YEAR,{fn now()},{fn timestampadd(SQL_TSI_YEAR,3,{fn now()})})} ");
//assertTrue(rs.next());
//assertEquals(3,rs.getInt(1));
}
public void testSystemFunctions() throws SQLException
{
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery("select {fn ifnull(null,'2')}" +
",{fn user()} ");
assertTrue(rs.next());
assertEquals("2",rs.getString(1));
assertEquals(TestUtil.getUser(),rs.getString(2));
if (TestUtil.haveMinimumServerVersion(con, "7.3")) {
rs = stmt.executeQuery("select {fn database()} ");
assertTrue(rs.next());
assertEquals(TestUtil.getDatabase(),rs.getString(1));
}
}
public void testWarningsAreCleared() throws SQLException
{
Statement stmt = con.createStatement();
// Will generate a NOTICE: for primary key index creation
stmt.execute("CREATE TEMP TABLE unused (a int primary key)");
stmt.executeQuery("SELECT 1");
// Executing another query should clear the warning from the first one.
assertNull(stmt.getWarnings());
stmt.close();
}
/**
* The parser tries to break multiple statements into individual
* queries as required by the V3 extended query protocol. It can
* be a little overzealous sometimes and this test ensures we
* keep multiple rule actions together in one statement.
*/
public void testParsingSemiColons() throws SQLException
{
Statement stmt = con.createStatement();
stmt.execute("CREATE RULE r1 AS ON INSERT TO escapetest DO (DELETE FROM test_statement ; INSERT INTO test_statement VALUES (1); INSERT INTO test_statement VALUES (2); );");
stmt.executeUpdate("INSERT INTO escapetest(ts) VALUES (NULL)");
ResultSet rs = stmt.executeQuery("SELECT i from test_statement ORDER BY i");
assertTrue(rs.next());
assertEquals(1, rs.getInt(1));
assertTrue(rs.next());
assertEquals(2, rs.getInt(1));
assertTrue(!rs.next());
}
public void testParsingDollarQuotes() throws SQLException
{
// dollar-quotes are supported in the backend since version 8.0
if (!TestUtil.haveMinimumServerVersion(con, "8.0"))
return;
Statement st = con.createStatement();
ResultSet rs;
rs = st.executeQuery("SELECT '$a$ ; $a$'");
assertTrue(rs.next());
assertEquals("$a$ ; $a$", rs.getObject(1));
rs.close();
rs = st.executeQuery("SELECT $$;$$");
assertTrue(rs.next());
assertEquals(";", rs.getObject(1));
rs.close();
rs = st.executeQuery("SELECT $OR$$a$'$b$a$$OR$ WHERE '$a$''$b$a$'=$OR$$a$'$b$a$$OR$OR ';'=''");
assertTrue(rs.next());
assertEquals("$a$'$b$a$", rs.getObject(1));
assertFalse(rs.next());
rs.close();
rs = st.executeQuery("SELECT $B$;$b$B$");
assertTrue(rs.next());
assertEquals(";$b", rs.getObject(1));
rs.close();
rs = st.executeQuery("SELECT $c$c$;$c$");
assertTrue(rs.next());
assertEquals("c$;", rs.getObject(1));
rs.close();
rs = st.executeQuery("SELECT $A0$;$A0$ WHERE ''=$t$t$t$ OR ';$t$'=';$t$'");
assertTrue(rs.next());
assertEquals(";", rs.getObject(1));
assertFalse(rs.next());
rs.close();
st.executeQuery("SELECT /* */$$;$$/**//*;*/").close();
st.executeQuery("SELECT /* */--;\n$$a$$/**/--\n--;\n").close();
st.close();
}
public void testUnbalancedParensParseError() throws SQLException
{
Statement stmt = con.createStatement();
try {
stmt.executeQuery("SELECT i FROM test_statement WHERE (1 > 0)) ORDER BY i");
fail("Should have thrown a parse error.");
} catch (SQLException sqle) { }
}
public void testExecuteUpdateFailsOnSelect() throws SQLException
{
Statement stmt = con.createStatement();
try {
stmt.executeUpdate("SELECT 1");
fail("Should have thrown an error.");
} catch (SQLException sqle) { }
}
public void testExecuteUpdateFailsOnMultiStatementSelect() throws SQLException
{
Statement stmt = con.createStatement();
try {
stmt.executeUpdate("/* */; SELECT 1");
fail("Should have thrown an error.");
} catch (SQLException sqle) { }
}
public void testSetQueryTimeout() throws SQLException
{
Statement stmt = con.createStatement();
Timer timer = new Timer(true);
try
{
timer.schedule( new TimerTask(){
public void run()
{
fail("Query timeout should have occured and cleaned this up");
}
}, 5000);
stmt.setQueryTimeout(1);
stmt.execute("select pg_sleep(10)");
}catch( SQLException sqle )
{
// state for cancel
if (sqle.getSQLState().compareTo("57014") == 0)
timer.cancel();
}
}
public void testResultSetTwice() throws SQLException
{
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery("select {fn abs(-2.3)} as abs ");
assertNotNull(rs);
ResultSet rsOther = stmt.getResultSet();
assertNotNull(rsOther);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc2/TestACL.java 0000664 0000000 0000000 00000002374 12050675701 0024705 0 ustar 00root root 0000000 0000000 package org.postgresql.test.jdbc2;
import org.postgresql.jdbc2.AbstractJdbc2Connection;
import org.postgresql.jdbc2.AbstractJdbc2DatabaseMetaData;
import junit.framework.TestCase;
public class TestACL extends TestCase {
@Override
protected void setUp() throws Exception {
// TODO Auto-generated method stub
super.setUp();
}
@Override
protected void tearDown() throws Exception {
// TODO Auto-generated method stub
super.tearDown();
}
public void testParseACL()
{
AbstractJdbc2Connection _a = null;
AbstractJdbc2DatabaseMetaData a = new AbstractJdbc2DatabaseMetaData(_a) {
};
a.parseACL("{jurka=arwdRxt/jurka,permuser=rw*/jurka}","jurka");
a.parseACL("{jurka=a*r*w*d*R*x*t*/jurka,permuser=rw*/jurka}", "jurka");
a.parseACL("{=,jurka=arwdRxt,permuser=rw}","jurka");
a.parseACL("{jurka=arwdRxt/jurka,permuser=rw*/jurka,grantuser=w/permuser}","jurka");
a.parseACL("{jurka=a*r*w*d*R*x*t*/jurka,permuser=rw*/jurka,grantuser=w/permuser}","jurka");
a.parseACL("{jurka=arwdRxt/jurka,permuser=rw*/jurka,grantuser=w/permuser,\"group permgroup=a/jurka\"}", "jurka");
a.parseACL("{jurka=a*r*w*d*R*x*t*/jurka,permuser=rw*/jurka,grantuser=w/permuser,\"group permgroup=a/jurka\"}","jurka");
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc2/TimeTest.java 0000664 0000000 0000000 00000022570 12050675701 0025204 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc2;
import org.postgresql.test.TestUtil;
import junit.framework.TestCase;
import java.sql.*;
import java.util.Calendar;
import java.util.TimeZone;
/*
* Some simple tests based on problems reported by users. Hopefully these will
* help prevent previous problems from re-occuring ;-)
*
*/
public class TimeTest extends TestCase
{
private Connection con;
private boolean testSetTime = false;
public TimeTest(String name)
{
super(name);
}
protected void setUp() throws Exception
{
con = TestUtil.openDB();
TestUtil.createTempTable(con, "testtime", "tm time, tz time with time zone");
}
protected void tearDown() throws Exception
{
TestUtil.dropTable(con, "testtime");
TestUtil.closeDB(con);
}
private long extractMillis(long time) {
return (time >= 0) ? (time % 1000) : (time % 1000 + 1000);
}
/*
*
* Test use of calendar
*/
public void testGetTimeZone() throws Exception
{
final Time midnight = new Time(0, 0, 0);
Statement stmt = con.createStatement();
Calendar cal = Calendar.getInstance();
cal.setTimeZone(TimeZone.getTimeZone("GMT"));
int localOffset=Calendar.getInstance().getTimeZone().getOffset(midnight.getTime());
// set the time to midnight to make this easy
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testtime", "'00:00:00','00:00:00'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testtime", "'00:00:00.1','00:00:00.01'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testtime", "CAST(CAST(now() AS timestamp without time zone) AS time),now()")));
ResultSet rs = stmt.executeQuery(TestUtil.selectSQL("testtime", "tm,tz"));
assertNotNull(rs);
assertTrue(rs.next());
Time time = rs.getTime(1);
Timestamp timestamp = rs.getTimestamp(1);
assertNotNull(timestamp);
Timestamp timestamptz = rs.getTimestamp(2);
assertNotNull(timestamptz);
Time timetz = rs.getTime(2);
assertEquals(midnight, time);
time = rs.getTime(1, cal);
assertEquals(midnight.getTime() , time.getTime() - localOffset);
assertTrue(rs.next());
time = rs.getTime(1);
assertNotNull(time);
assertEquals(100, extractMillis(time.getTime()));
timestamp = rs.getTimestamp(1);
assertNotNull(timestamp);
// Pre 1.4 JVM's considered the nanos field completely separate
// and wouldn't return it in getTime()
if (TestUtil.haveMinimumJVMVersion("1.4"))
{
assertEquals(100, extractMillis(timestamp.getTime()));
}
else
{
assertEquals(100, extractMillis(timestamp.getTime() + timestamp.getNanos() / 1000000));
}
assertEquals(100000000, timestamp.getNanos());
timetz = rs.getTime(2);
assertNotNull(timetz);
assertEquals(10, extractMillis(timetz.getTime()));
timestamptz = rs.getTimestamp(2);
assertNotNull(timestamptz);
// Pre 1.4 JVM's considered the nanos field completely separate
// and wouldn't return it in getTime()
if (TestUtil.haveMinimumJVMVersion("1.4"))
{
assertEquals(10, extractMillis(timestamptz.getTime()));
}
else
{
assertEquals(10, extractMillis(timestamptz.getTime() + timestamptz.getNanos() / 1000000));
}
assertEquals(10000000, timestamptz.getNanos());
assertTrue(rs.next());
time = rs.getTime(1);
assertNotNull(time);
timestamp = rs.getTimestamp(1);
assertNotNull(timestamp);
timetz = rs.getTime(2);
assertNotNull(timetz);
timestamptz = rs.getTimestamp(2);
assertNotNull(timestamptz);
}
/*
* Tests the time methods in ResultSet
*/
public void testGetTime() throws SQLException
{
Statement stmt = con.createStatement();
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testtime", "'01:02:03'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testtime", "'23:59:59'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testtime", "'12:00:00'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testtime", "'05:15:21'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testtime", "'16:21:51'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testtime", "'12:15:12'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testtime", "'22:12:01'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL("testtime", "'08:46:44'")));
// Fall through helper
timeTest();
assertEquals(8, stmt.executeUpdate("DELETE FROM testtime"));
stmt.close();
}
/*
* Tests the time methods in PreparedStatement
*/
public void testSetTime() throws SQLException
{
PreparedStatement ps = con.prepareStatement(TestUtil.insertSQL("testtime", "?"));
Statement stmt = con.createStatement();
ps.setTime(1, makeTime(1, 2, 3));
assertEquals(1, ps.executeUpdate());
ps.setTime(1, makeTime(23, 59, 59));
assertEquals(1, ps.executeUpdate());
ps.setObject(1, java.sql.Time.valueOf("12:00:00"), java.sql.Types.TIME);
assertEquals(1, ps.executeUpdate());
ps.setObject(1, java.sql.Time.valueOf("05:15:21"), java.sql.Types.TIME);
assertEquals(1, ps.executeUpdate());
ps.setObject(1, java.sql.Time.valueOf("16:21:51"), java.sql.Types.TIME);
assertEquals(1, ps.executeUpdate());
ps.setObject(1, java.sql.Time.valueOf("12:15:12"), java.sql.Types.TIME);
assertEquals(1, ps.executeUpdate());
ps.setObject(1, "22:12:1", java.sql.Types.TIME);
assertEquals(1, ps.executeUpdate());
ps.setObject(1, "8:46:44", java.sql.Types.TIME);
assertEquals(1, ps.executeUpdate());
ps.setObject(1, "5:1:2-03", java.sql.Types.TIME);
assertEquals(1, ps.executeUpdate());
ps.setObject(1, "23:59:59+11", java.sql.Types.TIME);
assertEquals(1, ps.executeUpdate());
// Need to let the test know this one has extra test cases.
testSetTime = true;
// Fall through helper
timeTest();
testSetTime = false;
assertEquals(10, stmt.executeUpdate("DELETE FROM testtime"));
stmt.close();
ps.close();
}
/*
* Helper for the TimeTests. It tests what should be in the db
*/
private void timeTest() throws SQLException
{
Statement st = con.createStatement();
ResultSet rs;
java.sql.Time t;
rs = st.executeQuery(TestUtil.selectSQL("testtime", "tm"));
assertNotNull(rs);
assertTrue(rs.next());
t = rs.getTime(1);
assertNotNull(t);
assertEquals(makeTime(1, 2, 3), t);
assertTrue(rs.next());
t = rs.getTime(1);
assertNotNull(t);
assertEquals(makeTime(23, 59, 59), t);
assertTrue(rs.next());
t = rs.getTime(1);
assertNotNull(t);
assertEquals(makeTime(12, 0, 0), t);
assertTrue(rs.next());
t = rs.getTime(1);
assertNotNull(t);
assertEquals(makeTime(5, 15, 21), t);
assertTrue(rs.next());
t = rs.getTime(1);
assertNotNull(t);
assertEquals(makeTime(16, 21, 51), t);
assertTrue(rs.next());
t = rs.getTime(1);
assertNotNull(t);
assertEquals(makeTime(12, 15, 12), t);
assertTrue(rs.next());
t = rs.getTime(1);
assertNotNull(t);
assertEquals(makeTime(22, 12, 1), t);
assertTrue(rs.next());
t = rs.getTime(1);
assertNotNull(t);
assertEquals(makeTime(8, 46, 44), t);
// If we're checking for timezones.
if (testSetTime)
{
assertTrue(rs.next());
t = rs.getTime(1);
assertNotNull(t);
java.sql.Time tmpTime = java.sql.Time.valueOf("5:1:2");
int localoffset=java.util.Calendar.getInstance().getTimeZone().getOffset(tmpTime.getTime());
int Timeoffset = 3 * 60 * 60 * 1000;
tmpTime.setTime(tmpTime.getTime() + Timeoffset + localoffset);
assertEquals(makeTime(tmpTime.getHours(), tmpTime.getMinutes(), tmpTime.getSeconds()), t);
assertTrue(rs.next());
t = rs.getTime(1);
assertNotNull(t);
tmpTime = java.sql.Time.valueOf("23:59:59");
localoffset=java.util.Calendar.getInstance().getTimeZone().getOffset(tmpTime.getTime());
Timeoffset = -11 * 60 * 60 * 1000;
tmpTime.setTime(tmpTime.getTime() + Timeoffset + localoffset);
assertEquals(makeTime(tmpTime.getHours(), tmpTime.getMinutes(), tmpTime.getSeconds()), t);
}
assertTrue(! rs.next());
rs.close();
}
private java.sql.Time makeTime(int h, int m, int s)
{
return java.sql.Time.valueOf(TestUtil.fix(h, 2) + ":" +
TestUtil.fix(m, 2) + ":" +
TestUtil.fix(s, 2));
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc2/TimestampTest.java 0000664 0000000 0000000 00000072472 12050675701 0026257 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc2;
import org.postgresql.test.TestUtil;
import junit.framework.TestCase;
import java.sql.*;
import java.util.TimeZone;
import java.util.Calendar;
import java.util.GregorianCalendar;
import org.postgresql.PGStatement;
import org.postgresql.jdbc2.TimestampUtils;
import org.postgresql.core.BaseConnection;
/*
* Test get/setTimestamp for both timestamp with time zone and
* timestamp without time zone datatypes
*
*/
public class TimestampTest extends TestCase
{
private Connection con;
public TimestampTest(String name)
{
super(name);
}
protected void setUp() throws Exception
{
con = TestUtil.openDB();
TestUtil.createTable(con, TSWTZ_TABLE, "ts timestamp with time zone");
TestUtil.createTable(con, TSWOTZ_TABLE, "ts timestamp without time zone");
TestUtil.createTable(con, DATE_TABLE, "ts date");
}
protected void tearDown() throws Exception
{
TestUtil.dropTable(con, TSWTZ_TABLE);
TestUtil.dropTable(con, TSWOTZ_TABLE);
TestUtil.dropTable(con, DATE_TABLE);
TestUtil.closeDB(con);
}
/**
* Ensure the driver doesn't modify a Calendar that is passed in.
*/
public void testCalendarModification() throws SQLException
{
Calendar cal = Calendar.getInstance();
Calendar origCal = (Calendar)cal.clone();
PreparedStatement ps = con.prepareStatement("INSERT INTO " + TSWOTZ_TABLE + " VALUES (?)");
ps.setDate(1, new Date(0), cal);
ps.executeUpdate();
assertEquals(origCal, cal);
ps.setTimestamp(1, new Timestamp(0), cal);
ps.executeUpdate();
assertEquals(origCal, cal);
ps.setTime(1, new Time(0), cal);
// Can't actually execute this one because of type mismatch,
// but all we're really concerned about is the set call.
// ps.executeUpdate();
assertEquals(origCal, cal);
ps.close();
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery("SELECT ts FROM " + TSWOTZ_TABLE);
assertTrue(rs.next());
rs.getDate(1, cal);
assertEquals(origCal, cal);
rs.getTimestamp(1, cal);
assertEquals(origCal, cal);
rs.getTime(1, cal);
assertEquals(origCal, cal);
rs.close();
stmt.close();
}
public void testInfinity() throws SQLException
{
runInfinityTests(TSWTZ_TABLE, PGStatement.DATE_POSITIVE_INFINITY);
runInfinityTests(TSWTZ_TABLE, PGStatement.DATE_NEGATIVE_INFINITY);
runInfinityTests(TSWOTZ_TABLE, PGStatement.DATE_POSITIVE_INFINITY);
runInfinityTests(TSWOTZ_TABLE, PGStatement.DATE_NEGATIVE_INFINITY);
if (TestUtil.haveMinimumServerVersion(con, "8.4"))
{
runInfinityTests(DATE_TABLE, PGStatement.DATE_POSITIVE_INFINITY);
runInfinityTests(DATE_TABLE, PGStatement.DATE_NEGATIVE_INFINITY);
}
}
private void runInfinityTests(String table, long value) throws SQLException
{
GregorianCalendar cal = new GregorianCalendar();
// Pick some random timezone that is hopefully different than ours
// and exists in this JVM.
cal.setTimeZone(TimeZone.getTimeZone("Europe/Warsaw"));
String strValue;
if (value == PGStatement.DATE_POSITIVE_INFINITY) {
strValue = "infinity";
} else {
strValue = "-infinity";
}
Statement stmt = con.createStatement();
stmt.executeUpdate(TestUtil.insertSQL(table, "'" + strValue + "'"));
stmt.close();
PreparedStatement ps = con.prepareStatement(TestUtil.insertSQL(table, "?"));
ps.setTimestamp(1, new Timestamp(value));
ps.executeUpdate();
ps.setTimestamp(1, new Timestamp(value), cal);
ps.executeUpdate();
ps.close();
stmt = con.createStatement();
ResultSet rs = stmt.executeQuery("select ts from " + table);
while (rs.next()) {
assertEquals(strValue, rs.getString(1));
Timestamp ts = rs.getTimestamp(1);
assertEquals(value, ts.getTime());
Date d = rs.getDate(1);
assertEquals(value, d.getTime());
Timestamp tscal = rs.getTimestamp(1, cal);
assertEquals(value, tscal.getTime());
}
rs.close();
assertEquals(3, stmt.executeUpdate("DELETE FROM " + table));
stmt.close();
}
/*
* Tests the timestamp methods in ResultSet on timestamp with time zone
* we insert a known string value (don't use setTimestamp) then see that
* we get back the same value from getTimestamp
*/
public void testGetTimestampWTZ() throws SQLException
{
Statement stmt = con.createStatement();
TimestampUtils tsu = ((BaseConnection)con).getTimestampUtils();
//Insert the three timestamp values in raw pg format
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + TS1WTZ_PGFORMAT + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + TS2WTZ_PGFORMAT + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + TS3WTZ_PGFORMAT + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + TS4WTZ_PGFORMAT + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + TS1WTZ_PGFORMAT + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + TS2WTZ_PGFORMAT + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + TS3WTZ_PGFORMAT + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + TS4WTZ_PGFORMAT + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + TS1WTZ_PGFORMAT + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + TS2WTZ_PGFORMAT + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + TS3WTZ_PGFORMAT + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + TS4WTZ_PGFORMAT + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + tsu.toString(null, new java.sql.Timestamp(tmpDate1.getTime())) + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + tsu.toString(null, new java.sql.Timestamp(tmpDate2.getTime())) + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + tsu.toString(null, new java.sql.Timestamp(tmpDate3.getTime())) + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + tsu.toString(null, new java.sql.Timestamp(tmpDate4.getTime())) + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + tsu.toString(null, new java.sql.Timestamp(tmpTime1.getTime())) + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + tsu.toString(null, new java.sql.Timestamp(tmpTime2.getTime())) + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + tsu.toString(null, new java.sql.Timestamp(tmpTime3.getTime())) + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + tsu.toString(null, new java.sql.Timestamp(tmpTime4.getTime())) + "'")));
// Fall through helper
timestampTestWTZ();
assertEquals(20, stmt.executeUpdate("DELETE FROM " + TSWTZ_TABLE));
stmt.close();
}
/*
* Tests the timestamp methods in PreparedStatement on timestamp with time zone
* we insert a value using setTimestamp then see that
* we get back the same value from getTimestamp (which we know works as it was tested
* independently of setTimestamp
*/
public void testSetTimestampWTZ() throws SQLException
{
Statement stmt = con.createStatement();
PreparedStatement pstmt = con.prepareStatement(TestUtil.insertSQL(TSWTZ_TABLE, "?"));
pstmt.setTimestamp(1, TS1WTZ);
assertEquals(1, pstmt.executeUpdate());
pstmt.setTimestamp(1, TS2WTZ);
assertEquals(1, pstmt.executeUpdate());
pstmt.setTimestamp(1, TS3WTZ);
assertEquals(1, pstmt.executeUpdate());
pstmt.setTimestamp(1, TS4WTZ);
assertEquals(1, pstmt.executeUpdate());
// With java.sql.Timestamp
pstmt.setObject(1, TS1WTZ, java.sql.Types.TIMESTAMP);
assertEquals(1, pstmt.executeUpdate());
pstmt.setObject(1, TS2WTZ, java.sql.Types.TIMESTAMP);
assertEquals(1, pstmt.executeUpdate());
pstmt.setObject(1, TS3WTZ, java.sql.Types.TIMESTAMP);
assertEquals(1, pstmt.executeUpdate());
pstmt.setObject(1, TS4WTZ, java.sql.Types.TIMESTAMP);
assertEquals(1, pstmt.executeUpdate());
// With Strings
pstmt.setObject(1, TS1WTZ_PGFORMAT, java.sql.Types.TIMESTAMP);
assertEquals(1, pstmt.executeUpdate());
pstmt.setObject(1, TS2WTZ_PGFORMAT, java.sql.Types.TIMESTAMP);
assertEquals(1, pstmt.executeUpdate());
pstmt.setObject(1, TS3WTZ_PGFORMAT, java.sql.Types.TIMESTAMP);
assertEquals(1, pstmt.executeUpdate());
pstmt.setObject(1, TS4WTZ_PGFORMAT, java.sql.Types.TIMESTAMP);
assertEquals(1, pstmt.executeUpdate());
// With java.sql.Date
pstmt.setObject(1, tmpDate1, java.sql.Types.TIMESTAMP);
assertEquals(1, pstmt.executeUpdate());
pstmt.setObject(1, tmpDate2, java.sql.Types.TIMESTAMP);
assertEquals(1, pstmt.executeUpdate());
pstmt.setObject(1, tmpDate3, java.sql.Types.TIMESTAMP);
assertEquals(1, pstmt.executeUpdate());
pstmt.setObject(1, tmpDate4, java.sql.Types.TIMESTAMP);
assertEquals(1, pstmt.executeUpdate());
// With java.sql.Time
pstmt.setObject(1, tmpTime1, java.sql.Types.TIMESTAMP);
assertEquals(1, pstmt.executeUpdate());
pstmt.setObject(1, tmpTime2, java.sql.Types.TIMESTAMP);
assertEquals(1, pstmt.executeUpdate());
pstmt.setObject(1, tmpTime3, java.sql.Types.TIMESTAMP);
assertEquals(1, pstmt.executeUpdate());
pstmt.setObject(1, tmpTime4, java.sql.Types.TIMESTAMP);
assertEquals(1, pstmt.executeUpdate());
// Fall through helper
timestampTestWTZ();
assertEquals(20, stmt.executeUpdate("DELETE FROM " + TSWTZ_TABLE));
pstmt.close();
stmt.close();
}
/*
* Tests the timestamp methods in ResultSet on timestamp without time zone
* we insert a known string value (don't use setTimestamp) then see that
* we get back the same value from getTimestamp
*/
public void testGetTimestampWOTZ() throws SQLException
{
Statement stmt = con.createStatement();
TimestampUtils tsu = ((BaseConnection)con).getTimestampUtils();
//Insert the three timestamp values in raw pg format
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS1WOTZ_PGFORMAT + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS2WOTZ_PGFORMAT + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS3WOTZ_PGFORMAT + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS4WOTZ_PGFORMAT + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS5WOTZ_PGFORMAT + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS6WOTZ_PGFORMAT + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS1WOTZ_PGFORMAT + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS2WOTZ_PGFORMAT + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS3WOTZ_PGFORMAT + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS4WOTZ_PGFORMAT + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS5WOTZ_PGFORMAT + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS6WOTZ_PGFORMAT + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS1WOTZ_PGFORMAT + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS2WOTZ_PGFORMAT + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS3WOTZ_PGFORMAT + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS4WOTZ_PGFORMAT + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS5WOTZ_PGFORMAT + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS6WOTZ_PGFORMAT + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + tsu.toString(null, new java.sql.Timestamp(tmpDate1WOTZ.getTime())) + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + tsu.toString(null, new java.sql.Timestamp(tmpDate2WOTZ.getTime())) + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + tsu.toString(null, new java.sql.Timestamp(tmpDate3WOTZ.getTime())) + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + tsu.toString(null, new java.sql.Timestamp(tmpDate4WOTZ.getTime())) + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + tsu.toString(null, new java.sql.Timestamp(tmpDate5WOTZ.getTime())) + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + tsu.toString(null, new java.sql.Timestamp(tmpDate6WOTZ.getTime())) + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + tsu.toString(null, new java.sql.Timestamp(tmpTime1WOTZ.getTime())) + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + tsu.toString(null, new java.sql.Timestamp(tmpTime2WOTZ.getTime())) + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + tsu.toString(null, new java.sql.Timestamp(tmpTime3WOTZ.getTime())) + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + tsu.toString(null, new java.sql.Timestamp(tmpTime4WOTZ.getTime())) + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + tsu.toString(null, new java.sql.Timestamp(tmpTime5WOTZ.getTime())) + "'")));
assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + tsu.toString(null, new java.sql.Timestamp(tmpTime6WOTZ.getTime())) + "'")));
// Fall through helper
timestampTestWOTZ();
assertEquals(30, stmt.executeUpdate("DELETE FROM " + TSWOTZ_TABLE));
stmt.close();
}
/*
* Tests the timestamp methods in PreparedStatement on timestamp without time zone
* we insert a value using setTimestamp then see that
* we get back the same value from getTimestamp (which we know works as it was tested
* independently of setTimestamp
*/
public void testSetTimestampWOTZ() throws SQLException
{
Statement stmt = con.createStatement();
PreparedStatement pstmt = con.prepareStatement(TestUtil.insertSQL(TSWOTZ_TABLE, "?"));
pstmt.setTimestamp(1, TS1WOTZ);
assertEquals(1, pstmt.executeUpdate());
pstmt.setTimestamp(1, TS2WOTZ);
assertEquals(1, pstmt.executeUpdate());
pstmt.setTimestamp(1, TS3WOTZ);
assertEquals(1, pstmt.executeUpdate());
pstmt.setTimestamp(1, TS4WOTZ);
assertEquals(1, pstmt.executeUpdate());
pstmt.setTimestamp(1, TS5WOTZ);
assertEquals(1, pstmt.executeUpdate());
pstmt.setTimestamp(1, TS6WOTZ);
assertEquals(1, pstmt.executeUpdate());
// With java.sql.Timestamp
pstmt.setObject(1, TS1WOTZ, java.sql.Types.TIMESTAMP);
assertEquals(1, pstmt.executeUpdate());
pstmt.setObject(1, TS2WOTZ, java.sql.Types.TIMESTAMP);
assertEquals(1, pstmt.executeUpdate());
pstmt.setObject(1, TS3WOTZ, java.sql.Types.TIMESTAMP);
assertEquals(1, pstmt.executeUpdate());
pstmt.setObject(1, TS4WOTZ, java.sql.Types.TIMESTAMP);
assertEquals(1, pstmt.executeUpdate());
pstmt.setObject(1, TS5WOTZ, java.sql.Types.TIMESTAMP);
assertEquals(1, pstmt.executeUpdate());
pstmt.setObject(1, TS6WOTZ, java.sql.Types.TIMESTAMP);
assertEquals(1, pstmt.executeUpdate());
// With Strings
pstmt.setObject(1, TS1WOTZ_PGFORMAT, java.sql.Types.TIMESTAMP);
assertEquals(1, pstmt.executeUpdate());
pstmt.setObject(1, TS2WOTZ_PGFORMAT, java.sql.Types.TIMESTAMP);
assertEquals(1, pstmt.executeUpdate());
pstmt.setObject(1, TS3WOTZ_PGFORMAT, java.sql.Types.TIMESTAMP);
assertEquals(1, pstmt.executeUpdate());
pstmt.setObject(1, TS4WOTZ_PGFORMAT, java.sql.Types.TIMESTAMP);
assertEquals(1, pstmt.executeUpdate());
pstmt.setObject(1, TS5WOTZ_PGFORMAT, java.sql.Types.TIMESTAMP);
assertEquals(1, pstmt.executeUpdate());
pstmt.setObject(1, TS6WOTZ_PGFORMAT, java.sql.Types.TIMESTAMP);
assertEquals(1, pstmt.executeUpdate());
// With java.sql.Date
pstmt.setObject(1, tmpDate1WOTZ, java.sql.Types.TIMESTAMP);
assertEquals(1, pstmt.executeUpdate());
pstmt.setObject(1, tmpDate2WOTZ, java.sql.Types.TIMESTAMP);
assertEquals(1, pstmt.executeUpdate());
pstmt.setObject(1, tmpDate3WOTZ, java.sql.Types.TIMESTAMP);
assertEquals(1, pstmt.executeUpdate());
pstmt.setObject(1, tmpDate4WOTZ, java.sql.Types.TIMESTAMP);
assertEquals(1, pstmt.executeUpdate());
pstmt.setObject(1, tmpDate5WOTZ, java.sql.Types.TIMESTAMP);
assertEquals(1, pstmt.executeUpdate());
pstmt.setObject(1, tmpDate6WOTZ, java.sql.Types.TIMESTAMP);
assertEquals(1, pstmt.executeUpdate());
// With java.sql.Time
pstmt.setObject(1, tmpTime1WOTZ, java.sql.Types.TIMESTAMP);
assertEquals(1, pstmt.executeUpdate());
pstmt.setObject(1, tmpTime2WOTZ, java.sql.Types.TIMESTAMP);
assertEquals(1, pstmt.executeUpdate());
pstmt.setObject(1, tmpTime3WOTZ, java.sql.Types.TIMESTAMP);
assertEquals(1, pstmt.executeUpdate());
pstmt.setObject(1, tmpTime4WOTZ, java.sql.Types.TIMESTAMP);
assertEquals(1, pstmt.executeUpdate());
pstmt.setObject(1, tmpTime5WOTZ, java.sql.Types.TIMESTAMP);
assertEquals(1, pstmt.executeUpdate());
pstmt.setObject(1, tmpTime6WOTZ, java.sql.Types.TIMESTAMP);
assertEquals(1, pstmt.executeUpdate());
// Fall through helper
timestampTestWOTZ();
assertEquals(30, stmt.executeUpdate("DELETE FROM " + TSWOTZ_TABLE));
pstmt.close();
stmt.close();
}
/*
* Helper for the TimestampTests. It tests what should be in the db
*/
private void timestampTestWTZ() throws SQLException
{
Statement stmt = con.createStatement();
ResultSet rs;
java.sql.Timestamp t;
rs = stmt.executeQuery("select ts from " + TSWTZ_TABLE); //removed the order by ts
assertNotNull(rs);
for (int i = 0; i < 3; i++)
{
assertTrue(rs.next());
t = rs.getTimestamp(1);
assertNotNull(t);
assertEquals(TS1WTZ, t);
assertTrue(rs.next());
t = rs.getTimestamp(1);
assertNotNull(t);
assertEquals(TS2WTZ, t);
assertTrue(rs.next());
t = rs.getTimestamp(1);
assertNotNull(t);
assertEquals(TS3WTZ, t);
assertTrue(rs.next());
t = rs.getTimestamp(1);
assertNotNull(t);
assertEquals(TS4WTZ, t);
}
// Testing for Date
assertTrue(rs.next());
t = rs.getTimestamp(1);
assertNotNull(t);
assertEquals(tmpDate1.getTime(), t.getTime());
assertTrue(rs.next());
t = rs.getTimestamp(1);
assertNotNull(t);
assertEquals(tmpDate2.getTime(), t.getTime());
assertTrue(rs.next());
t = rs.getTimestamp(1);
assertNotNull(t);
assertEquals(tmpDate3.getTime(), t.getTime());
assertTrue(rs.next());
t = rs.getTimestamp(1);
assertNotNull(t);
assertEquals(tmpDate4.getTime(), t.getTime());
// Testing for Time
assertTrue(rs.next());
t = rs.getTimestamp(1);
assertNotNull(t);
assertEquals(tmpTime1.getTime(), t.getTime());
assertTrue(rs.next());
t = rs.getTimestamp(1);
assertNotNull(t);
assertEquals(tmpTime2.getTime(), t.getTime());
assertTrue(rs.next());
t = rs.getTimestamp(1);
assertNotNull(t);
assertEquals(tmpTime3.getTime(), t.getTime());
assertTrue(rs.next());
t = rs.getTimestamp(1);
assertNotNull(t);
assertEquals(tmpTime4.getTime(), t.getTime());
assertTrue(! rs.next()); // end of table. Fail if more entries exist.
rs.close();
stmt.close();
}
/*
* Helper for the TimestampTests. It tests what should be in the db
*/
private void timestampTestWOTZ() throws SQLException
{
Statement stmt = con.createStatement();
ResultSet rs;
java.sql.Timestamp t;
rs = stmt.executeQuery("select ts from " + TSWOTZ_TABLE); //removed the order by ts
assertNotNull(rs);
for (int i = 0; i < 3; i++)
{
assertTrue(rs.next());
t = rs.getTimestamp(1);
assertNotNull(t);
assertTrue(t.equals(TS1WOTZ));
assertTrue(rs.next());
t = rs.getTimestamp(1);
assertNotNull(t);
assertTrue(t.equals(TS2WOTZ));
assertTrue(rs.next());
t = rs.getTimestamp(1);
assertNotNull(t);
assertTrue(t.equals(TS3WOTZ));
assertTrue(rs.next());
t = rs.getTimestamp(1);
assertNotNull(t);
assertTrue(t.equals(TS4WOTZ));
assertTrue(rs.next());
t = rs.getTimestamp(1);
assertNotNull(t);
assertTrue(t.equals(TS5WOTZ));
assertTrue(rs.next());
t = rs.getTimestamp(1);
assertNotNull(t);
assertTrue(t.equals(TS6WOTZ));
}
// Testing for Date
assertTrue(rs.next());
t = rs.getTimestamp(1);
assertNotNull(t);
assertEquals(tmpDate1WOTZ.getTime(), t.getTime());
assertTrue(rs.next());
t = rs.getTimestamp(1);
assertNotNull(t);
assertEquals(tmpDate2WOTZ.getTime(), t.getTime());
assertTrue(rs.next());
t = rs.getTimestamp(1);
assertNotNull(t);
assertEquals(tmpDate3WOTZ.getTime(), t.getTime());
assertTrue(rs.next());
t = rs.getTimestamp(1);
assertNotNull(t);
assertEquals(tmpDate4WOTZ.getTime(), t.getTime());
assertTrue(rs.next());
t = rs.getTimestamp(1);
assertNotNull(t);
assertEquals(tmpDate5WOTZ.getTime(), t.getTime());
assertTrue(rs.next());
t = rs.getTimestamp(1);
assertNotNull(t);
assertEquals(tmpDate6WOTZ.getTime(), t.getTime());
// Testing for Time
assertTrue(rs.next());
t = rs.getTimestamp(1);
assertNotNull(t);
assertEquals(tmpTime1WOTZ.getTime(), t.getTime());
assertTrue(rs.next());
t = rs.getTimestamp(1);
assertNotNull(t);
assertEquals(tmpTime2WOTZ.getTime(), t.getTime());
assertTrue(rs.next());
t = rs.getTimestamp(1);
assertNotNull(t);
assertEquals(tmpTime3WOTZ.getTime(), t.getTime());
assertTrue(rs.next());
t = rs.getTimestamp(1);
assertNotNull(t);
assertEquals(tmpTime4WOTZ.getTime(), t.getTime());
assertTrue(rs.next());
t = rs.getTimestamp(1);
assertNotNull(t);
assertEquals(tmpTime5WOTZ.getTime(), t.getTime());
assertTrue(rs.next());
t = rs.getTimestamp(1);
assertNotNull(t);
assertEquals(tmpTime6WOTZ.getTime(), t.getTime());
assertTrue(! rs.next()); // end of table. Fail if more entries exist.
rs.close();
stmt.close();
}
private static java.sql.Timestamp getTimestamp(int y, int m, int d, int h, int mn, int se, int f, String tz)
{
java.sql.Timestamp l_return = null;
java.text.DateFormat l_df;
try
{
String l_ts;
l_ts = TestUtil.fix(y, 4) + "-" +
TestUtil.fix(m, 2) + "-" +
TestUtil.fix(d, 2) + " " +
TestUtil.fix(h, 2) + ":" +
TestUtil.fix(mn, 2) + ":" +
TestUtil.fix(se, 2) + " ";
if (tz == null)
{
l_df = new java.text.SimpleDateFormat("y-M-d H:m:s");
}
else
{
l_ts = l_ts + tz;
l_df = new java.text.SimpleDateFormat("y-M-d H:m:s z");
}
java.util.Date l_date = l_df.parse(l_ts);
l_return = new java.sql.Timestamp(l_date.getTime());
l_return.setNanos(f);
}
catch (Exception ex)
{
fail(ex.getMessage());
}
return l_return;
}
private static final java.sql.Timestamp TS1WTZ = getTimestamp(1950, 2, 7, 15, 0, 0, 100000000, "PST");
private static final String TS1WTZ_PGFORMAT = "1950-02-07 15:00:00.1-08";
private static final java.sql.Timestamp TS2WTZ = getTimestamp(2000, 2, 7, 15, 0, 0, 120000000, "GMT");
private static final String TS2WTZ_PGFORMAT = "2000-02-07 15:00:00.12+00";
private static final java.sql.Timestamp TS3WTZ = getTimestamp(2000, 7, 7, 15, 0, 0, 123000000, "GMT");
private static final String TS3WTZ_PGFORMAT = "2000-07-07 15:00:00.123+00";
private static final java.sql.Timestamp TS4WTZ = getTimestamp(2000, 7, 7, 15, 0, 0, 123456000, "GMT");
private static final String TS4WTZ_PGFORMAT = "2000-07-07 15:00:00.123456+00";
private static final java.sql.Timestamp TS1WOTZ = getTimestamp(1950, 2, 7, 15, 0, 0, 100000000, null);
private static final String TS1WOTZ_PGFORMAT = "1950-02-07 15:00:00.1";
private static final java.sql.Timestamp TS2WOTZ = getTimestamp(2000, 2, 7, 15, 0, 0, 120000000, null);
private static final String TS2WOTZ_PGFORMAT = "2000-02-07 15:00:00.12";
private static final java.sql.Timestamp TS3WOTZ = getTimestamp(2000, 7, 7, 15, 0, 0, 123000000, null);
private static final String TS3WOTZ_PGFORMAT = "2000-07-07 15:00:00.123";
private static final java.sql.Timestamp TS4WOTZ = getTimestamp(2000, 7, 7, 15, 0, 0, 123456000, null);
private static final String TS4WOTZ_PGFORMAT = "2000-07-07 15:00:00.123456";
private static final java.sql.Timestamp TS5WOTZ = new Timestamp(PGStatement.DATE_NEGATIVE_INFINITY);
private static final String TS5WOTZ_PGFORMAT = "-infinity";
private static final java.sql.Timestamp TS6WOTZ = new Timestamp(PGStatement.DATE_POSITIVE_INFINITY);
private static final String TS6WOTZ_PGFORMAT = "infinity";
private static final String TSWTZ_TABLE = "testtimestampwtz";
private static final String TSWOTZ_TABLE = "testtimestampwotz";
private static final String DATE_TABLE = "testtimestampdate";
private static final java.sql.Date tmpDate1 = new java.sql.Date(TS1WTZ.getTime());
private static final java.sql.Time tmpTime1 = new java.sql.Time(TS1WTZ.getTime());
private static final java.sql.Date tmpDate2 = new java.sql.Date(TS2WTZ.getTime());
private static final java.sql.Time tmpTime2 = new java.sql.Time(TS2WTZ.getTime());
private static final java.sql.Date tmpDate3 = new java.sql.Date(TS3WTZ.getTime());
private static final java.sql.Time tmpTime3 = new java.sql.Time(TS3WTZ.getTime());
private static final java.sql.Date tmpDate4 = new java.sql.Date(TS4WTZ.getTime());
private static final java.sql.Time tmpTime4 = new java.sql.Time(TS4WTZ.getTime());
private static final java.sql.Date tmpDate1WOTZ = new java.sql.Date(TS1WOTZ.getTime());
private static final java.sql.Time tmpTime1WOTZ = new java.sql.Time(TS1WOTZ.getTime());
private static final java.sql.Date tmpDate2WOTZ = new java.sql.Date(TS2WOTZ.getTime());
private static final java.sql.Time tmpTime2WOTZ = new java.sql.Time(TS2WOTZ.getTime());
private static final java.sql.Date tmpDate3WOTZ = new java.sql.Date(TS3WOTZ.getTime());
private static final java.sql.Time tmpTime3WOTZ = new java.sql.Time(TS3WOTZ.getTime());
private static final java.sql.Date tmpDate4WOTZ = new java.sql.Date(TS4WOTZ.getTime());
private static final java.sql.Time tmpTime4WOTZ = new java.sql.Time(TS4WOTZ.getTime());
private static final java.sql.Date tmpDate5WOTZ = new java.sql.Date(TS5WOTZ.getTime());
private static final java.sql.Date tmpTime5WOTZ = new java.sql.Date(TS5WOTZ.getTime());
private static final java.sql.Date tmpDate6WOTZ = new java.sql.Date(TS6WOTZ.getTime());
private static final java.sql.Date tmpTime6WOTZ = new java.sql.Date(TS6WOTZ.getTime());
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc2/TimezoneTest.java 0000664 0000000 0000000 00000102621 12050675701 0026074 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2005-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc2;
import org.postgresql.test.TestUtil;
import junit.framework.TestCase;
import java.sql.*;
import java.util.TimeZone;
import java.util.Calendar;
/*
* Tests for time and date types with calendars involved.
* TimestampTest was melting my brain, so I started afresh. -O
*
* Conversions that this code tests:
*
* setTimestamp -> timestamp, timestamptz, date, time, timetz
* setDate -> timestamp, timestamptz, date
* setTime -> time, timetz
*
* getTimestamp <- timestamp, timestamptz, date, time, timetz
* getDate <- timestamp, timestamptz, date
* getTime <- timestamp, timestamptz, time, timetz
*
* (this matches what we must support per JDBC 3.0, tables B-5 and B-6)
*/
public class TimezoneTest extends TestCase
{
private static final int DAY = 24 * 3600 * 1000;
private Connection con;
private static final TimeZone saveTZ = TimeZone.getDefault();;
//
// We set up everything in different timezones to try to exercise many cases:
//
// default JVM timezone: GMT+0100
// server timezone: GMT+0300
// test timezones: GMT+0000 GMT+0100 GMT+0300 GMT+1300 GMT-0500
private Calendar cUTC;
private Calendar cGMT03;
private Calendar cGMT05;
private Calendar cGMT13;
private boolean min73;
private boolean min74;
public TimezoneTest(String name)
{
super(name);
TimeZone UTC = TimeZone.getTimeZone("UTC"); // +0000 always
TimeZone GMT03 = TimeZone.getTimeZone("GMT+03"); // +0300 always
TimeZone GMT05 = TimeZone.getTimeZone("GMT-05"); // -0500 always
TimeZone GMT13 = TimeZone.getTimeZone("GMT+13"); // +1000 always
cUTC = Calendar.getInstance(UTC);
cGMT03 = Calendar.getInstance(GMT03);
cGMT05 = Calendar.getInstance(GMT05);
cGMT13 = Calendar.getInstance(GMT13);
}
protected void setUp() throws Exception
{
// We must change the default TZ before establishing the connection.
TimeZone.setDefault(TimeZone.getTimeZone("GMT+01")); // Arbitary timezone that doesn't match our test timezones
con = TestUtil.openDB();
TestUtil.createTable(con, "testtimezone",
"seq int4, tstz timestamp with time zone, ts timestamp without time zone, t time without time zone, tz time with time zone, d date");
// This is not obvious, but the "gmt-3" timezone is actually 3 hours *ahead* of GMT
// so will produce +03 timestamptz output
con.createStatement().executeUpdate("set timezone = 'gmt-3'");
min73 = TestUtil.haveMinimumServerVersion(con, "7.3");
min74 = TestUtil.haveMinimumServerVersion(con, "7.4");
//System.err.println("++++++ TESTS START (" + getName() + ") ++++++");
}
protected void tearDown() throws Exception
{
//System.err.println("++++++ TESTS END (" + getName() + ") ++++++");
TimeZone.setDefault(saveTZ);
TestUtil.dropTable(con, "testtimezone");
TestUtil.closeDB(con);
}
public void testGetTimestamp() throws Exception
{
con.createStatement().executeUpdate("INSERT INTO testtimezone(tstz,ts,t,tz,d) VALUES('2005-01-01 15:00:00 +0300', '2005-01-01 15:00:00', '15:00:00', '15:00:00 +0300', '2005-01-01')");
ResultSet rs = con.createStatement().executeQuery("SELECT tstz,ts,t,tz,d from testtimezone");
assertTrue(rs.next());
checkDatabaseContents("SELECT tstz::text,ts::text,t::text,tz::text,d::text from testtimezone",
new String[]{"2005-01-01 12:00:00+00",
"2005-01-01 15:00:00",
"15:00:00",
"15:00:00+03",
"2005-01-01"});
Timestamp ts;
// timestamptz: 2005-01-01 15:00:00+03
ts = rs.getTimestamp(1); // Represents an instant in time, timezone is irrelevant.
assertEquals(1104580800000L, ts.getTime()); // 2005-01-01 12:00:00 UTC
ts = rs.getTimestamp(1, cUTC); // Represents an instant in time, timezone is irrelevant.
assertEquals(1104580800000L, ts.getTime()); // 2005-01-01 12:00:00 UTC
ts = rs.getTimestamp(1, cGMT03); // Represents an instant in time, timezone is irrelevant.
assertEquals(1104580800000L, ts.getTime()); // 2005-01-01 12:00:00 UTC
ts = rs.getTimestamp(1, cGMT05); // Represents an instant in time, timezone is irrelevant.
assertEquals(1104580800000L, ts.getTime()); // 2005-01-01 12:00:00 UTC
ts = rs.getTimestamp(1, cGMT13); // Represents an instant in time, timezone is irrelevant.
assertEquals(1104580800000L, ts.getTime()); // 2005-01-01 12:00:00 UTC
// timestamp: 2005-01-01 15:00:00
ts = rs.getTimestamp(2); // Convert timestamp to +0100
assertEquals(1104588000000L, ts.getTime()); // 2005-01-01 15:00:00 +0100
ts = rs.getTimestamp(2, cUTC); // Convert timestamp to UTC
assertEquals(1104591600000L, ts.getTime()); // 2005-01-01 15:00:00 +0000
ts = rs.getTimestamp(2, cGMT03); // Convert timestamp to +0300
assertEquals(1104580800000L, ts.getTime()); // 2005-01-01 15:00:00 +0300
ts = rs.getTimestamp(2, cGMT05); // Convert timestamp to -0500
assertEquals(1104609600000L, ts.getTime()); // 2005-01-01 15:00:00 -0500
ts = rs.getTimestamp(2, cGMT13); // Convert timestamp to +1300
assertEquals(1104544800000L, ts.getTime()); // 2005-01-01 15:00:00 +1300
// time: 15:00:00
ts = rs.getTimestamp(3);
assertEquals(50400000L, ts.getTime()); // 1970-01-01 15:00:00 +0100
ts = rs.getTimestamp(3, cUTC);
assertEquals(54000000L, ts.getTime()); // 1970-01-01 15:00:00 +0000
ts = rs.getTimestamp(3, cGMT03);
assertEquals(43200000L, ts.getTime()); // 1970-01-01 15:00:00 +0300
ts = rs.getTimestamp(3, cGMT05);
assertEquals(72000000L, ts.getTime()); // 1970-01-01 15:00:00 -0500
ts = rs.getTimestamp(3, cGMT13);
assertEquals(7200000L, ts.getTime()); // 1970-01-01 15:00:00 +1300
// timetz: 15:00:00+03
ts = rs.getTimestamp(4);
assertEquals(43200000L, ts.getTime()); // 1970-01-01 15:00:00 +0300 -> 1970-01-01 13:00:00 +0100
ts = rs.getTimestamp(4, cUTC);
assertEquals(43200000L, ts.getTime()); // 1970-01-01 15:00:00 +0300 -> 1970-01-01 12:00:00 +0000
ts = rs.getTimestamp(4, cGMT03);
assertEquals(43200000L, ts.getTime()); // 1970-01-01 15:00:00 +0300 -> 1970-01-01 15:00:00 +0300
ts = rs.getTimestamp(4, cGMT05);
assertEquals(43200000L, ts.getTime()); // 1970-01-01 15:00:00 +0300 -> 1970-01-01 07:00:00 -0500
ts = rs.getTimestamp(4, cGMT13);
assertEquals(43200000L, ts.getTime()); // 1970-01-01 15:00:00 +0300 -> 1970-01-02 01:00:00 +1300 (CHECK ME)
// date: 2005-01-01
ts = rs.getTimestamp(5);
assertEquals(1104534000000L, ts.getTime()); // 2005-01-01 00:00:00 +0100
ts = rs.getTimestamp(5, cUTC);
assertEquals(1104537600000L, ts.getTime()); // 2005-01-01 00:00:00 +0000
ts = rs.getTimestamp(5, cGMT03);
assertEquals(1104526800000L, ts.getTime()); // 2005-01-01 00:00:00 +0300
ts = rs.getTimestamp(5, cGMT05);
assertEquals(1104555600000L, ts.getTime()); // 2005-01-01 00:00:00 -0500
ts = rs.getTimestamp(5, cGMT13);
assertEquals(1104490800000L, ts.getTime()); // 2005-01-01 00:00:00 +1300
assertTrue(!rs.next());
}
public void testGetDate() throws Exception
{
con.createStatement().executeUpdate("INSERT INTO testtimezone(tstz,ts,d) VALUES('2005-01-01 15:00:00 +0300', '2005-01-01 15:00:00', '2005-01-01')");
ResultSet rs = con.createStatement().executeQuery("SELECT tstz,ts,d from testtimezone");
assertTrue(rs.next());
checkDatabaseContents("SELECT tstz::text,ts::text,d::text from testtimezone",
new String[]{"2005-01-01 12:00:00+00",
"2005-01-01 15:00:00",
"2005-01-01"});
Date d;
// timestamptz: 2005-01-01 15:00:00+03
d = rs.getDate(1); // 2005-01-01 13:00:00 +0100 -> 2005-01-01 00:00:00 +0100
assertEquals(1104534000000L, d.getTime());
d = rs.getDate(1, cUTC); // 2005-01-01 12:00:00 +0000 -> 2005-01-01 00:00:00 +0000
assertEquals(1104537600000L, d.getTime());
d = rs.getDate(1, cGMT03); // 2005-01-01 15:00:00 +0300 -> 2005-01-01 00:00:00 +0300
assertEquals(1104526800000L, d.getTime());
d = rs.getDate(1, cGMT05); // 2005-01-01 07:00:00 -0500 -> 2005-01-01 00:00:00 -0500
assertEquals(1104555600000L, d.getTime());
d = rs.getDate(1, cGMT13); // 2005-01-02 01:00:00 +1300 -> 2005-01-02 00:00:00 +1300
assertEquals(1104577200000L, d.getTime());
// timestamp: 2005-01-01 15:00:00
d = rs.getDate(2); // 2005-01-01 00:00:00 +0100
assertEquals(1104534000000L, d.getTime());
d = rs.getDate(2, cUTC); // 2005-01-01 00:00:00 +0000
assertEquals(1104537600000L, d.getTime());
d = rs.getDate(2, cGMT03); // 2005-01-01 00:00:00 +0300
assertEquals(1104526800000L, d.getTime());
d = rs.getDate(2, cGMT05); // 2005-01-01 00:00:00 -0500
assertEquals(1104555600000L, d.getTime());
d = rs.getDate(2, cGMT13); // 2005-01-01 00:00:00 +1300
assertEquals(1104490800000L, d.getTime());
// date: 2005-01-01
d = rs.getDate(3); // 2005-01-01 00:00:00 +0100
assertEquals(1104534000000L, d.getTime());
d = rs.getDate(3, cUTC); // 2005-01-01 00:00:00 +0000
assertEquals(1104537600000L, d.getTime());
d = rs.getDate(3, cGMT03); // 2005-01-01 00:00:00 +0300
assertEquals(1104526800000L, d.getTime());
d = rs.getDate(3, cGMT05); // 2005-01-01 00:00:00 -0500
assertEquals(1104555600000L, d.getTime());
d = rs.getDate(3, cGMT13); // 2005-01-01 00:00:00 +1300
assertEquals(1104490800000L, d.getTime());
assertTrue(!rs.next());
}
public void testGetTime() throws Exception
{
con.createStatement().executeUpdate("INSERT INTO testtimezone(tstz,ts,t,tz) VALUES('2005-01-01 15:00:00 +0300', '2005-01-01 15:00:00', '15:00:00', '15:00:00 +0300')");
ResultSet rs = con.createStatement().executeQuery("SELECT tstz,ts,t,tz from testtimezone");
assertTrue(rs.next());
checkDatabaseContents("SELECT tstz::text,ts::text,t::text,tz::text,d::text from testtimezone",
new String[]{"2005-01-01 12:00:00+00",
"2005-01-01 15:00:00",
"15:00:00",
"15:00:00+03"});
Time t;
// timestamptz: 2005-01-01 15:00:00+03
t = rs.getTime(1);
assertEquals(43200000L, t.getTime()); // 2005-01-01 13:00:00 +0100 -> 1970-01-01 13:00:00 +0100
t = rs.getTime(1, cUTC);
assertEquals(43200000L, t.getTime()); // 2005-01-01 12:00:00 +0000 -> 1970-01-01 12:00:00 +0000
t = rs.getTime(1, cGMT03);
assertEquals(43200000L, t.getTime()); // 2005-01-01 15:00:00 +0300 -> 1970-01-01 15:00:00 +0300
t = rs.getTime(1, cGMT05);
assertEquals(43200000L, t.getTime()); // 2005-01-01 07:00:00 -0500 -> 1970-01-01 07:00:00 -0500
t = rs.getTime(1, cGMT13);
assertEquals(-43200000L, t.getTime()); // 2005-01-02 01:00:00 +1300 -> 1970-01-01 01:00:00 +1300
// timestamp: 2005-01-01 15:00:00
t = rs.getTime(2);
assertEquals(50400000L, t.getTime()); // 1970-01-01 15:00:00 +0100
t = rs.getTime(2, cUTC);
assertEquals(54000000L, t.getTime()); // 1970-01-01 15:00:00 +0000
t = rs.getTime(2, cGMT03);
assertEquals(43200000L, t.getTime()); // 1970-01-01 15:00:00 +0300
t = rs.getTime(2, cGMT05);
assertEquals(72000000L, t.getTime()); // 1970-01-01 15:00:00 -0500
t = rs.getTime(2, cGMT13);
assertEquals(7200000L, t.getTime()); // 1970-01-01 15:00:00 +1300
// time: 15:00:00
t = rs.getTime(3);
assertEquals(50400000L, t.getTime()); // 1970-01-01 15:00:00 +0100
t = rs.getTime(3, cUTC);
assertEquals(54000000L, t.getTime()); // 1970-01-01 15:00:00 +0000
t = rs.getTime(3, cGMT03);
assertEquals(43200000L, t.getTime()); // 1970-01-01 15:00:00 +0300
t = rs.getTime(3, cGMT05);
assertEquals(72000000L, t.getTime()); // 1970-01-01 15:00:00 -0500
t = rs.getTime(3, cGMT13);
assertEquals(7200000L, t.getTime()); // 1970-01-01 15:00:00 +1300
// timetz: 15:00:00+03
t = rs.getTime(4);
assertEquals(43200000L, t.getTime()); // 1970-01-01 13:00:00 +0100
t = rs.getTime(4, cUTC);
assertEquals(43200000L, t.getTime()); // 1970-01-01 12:00:00 +0000
t = rs.getTime(4, cGMT03);
assertEquals(43200000L, t.getTime()); // 1970-01-01 15:00:00 +0300
t = rs.getTime(4, cGMT05);
assertEquals(43200000L, t.getTime()); // 1970-01-01 07:00:00 -0500
t = rs.getTime(4, cGMT13);
assertEquals(43200000L, t.getTime()); // 1970-01-01 01:00:00 +1300
}
/**
* This test is broken off from testSetTimestamp because it does not work
* for pre-7.4 servers and putting tons of conditionals in that test makes
* it largely unreadable. The time data type does not accept timestamp
* with time zone style input on these servers.
*/
public void testSetTimestampOnTime() throws Exception
{
// Pre-7.4 servers cannot convert timestamps with timezones to times.
if (!min74)
return;
PreparedStatement insertTimestamp = con.prepareStatement("INSERT INTO testtimezone(seq,t) VALUES (?,?)");
int seq = 1;
Timestamp instant = new Timestamp(1104580800000L); // 2005-01-01 12:00:00 UTC
Timestamp instantTime = new Timestamp(instant.getTime() % DAY);
// +0100 (JVM default)
insertTimestamp.setInt(1, seq++);
insertTimestamp.setTimestamp(2,instant); // 13:00:00
insertTimestamp.executeUpdate();
// UTC
insertTimestamp.setInt(1, seq++);
insertTimestamp.setTimestamp(2,instant,cUTC); // 12:00:00
insertTimestamp.executeUpdate();
// +0300
insertTimestamp.setInt(1, seq++);
insertTimestamp.setTimestamp(2,instant,cGMT03); // 15:00:00
insertTimestamp.executeUpdate();
// -0500
insertTimestamp.setInt(1, seq++);
insertTimestamp.setTimestamp(2,instant,cGMT05); // 07:00:00
insertTimestamp.executeUpdate();
if (min73) {
// +1300
insertTimestamp.setInt(1, seq++);
insertTimestamp.setTimestamp(2,instant,cGMT13); // 01:00:00
insertTimestamp.executeUpdate();
}
checkDatabaseContents("SELECT seq::text,t::text from testtimezone ORDER BY seq",
new String[][]{new String[]{"1", "13:00:00"},
new String[]{"2", "12:00:00"},
new String[]{"3", "15:00:00"},
new String[]{"4", "07:00:00"},
new String[]{"5", "01:00:00"}});
seq = 1;
ResultSet rs = con.createStatement().executeQuery("SELECT seq,t FROM testtimezone ORDER BY seq");
assertTrue(rs.next());
assertEquals(seq++, rs.getInt(1));
assertEquals(instantTime, rs.getTimestamp(2));
assertTrue(rs.next());
assertEquals(seq++, rs.getInt(1));
assertEquals(instantTime, rs.getTimestamp(2, cUTC));
assertTrue(rs.next());
assertEquals(seq++, rs.getInt(1));
assertEquals(instantTime, rs.getTimestamp(2, cGMT03));
assertTrue(rs.next());
assertEquals(seq++, rs.getInt(1));
assertEquals(instantTime, rs.getTimestamp(2, cGMT05));
assertTrue(rs.next());
assertEquals(seq++, rs.getInt(1));
assertEquals(normalizeTimeOfDayPart(instantTime, cGMT13), rs.getTimestamp(2, cGMT13));
assertTrue(!rs.next());
}
public void testSetTimestamp() throws Exception
{
PreparedStatement insertTimestamp = con.prepareStatement("INSERT INTO testtimezone(seq,tstz,ts,tz,d) VALUES (?,?,?,?,?)");
int seq = 1;
Timestamp instant = new Timestamp(1104580800000L); // 2005-01-01 12:00:00 UTC
Timestamp instantTime = new Timestamp(instant.getTime() % DAY);
Timestamp instantDateJVM = new Timestamp(instant.getTime() - (instant.getTime() % DAY) - TimeZone.getDefault().getRawOffset());
Timestamp instantDateUTC = new Timestamp(instant.getTime() - (instant.getTime() % DAY) - cUTC.getTimeZone().getRawOffset());
Timestamp instantDateGMT03 = new Timestamp(instant.getTime() - (instant.getTime() % DAY) - cGMT03.getTimeZone().getRawOffset());
Timestamp instantDateGMT05 = new Timestamp(instant.getTime() - (instant.getTime() % DAY) - cGMT05.getTimeZone().getRawOffset());
Timestamp instantDateGMT13 = new Timestamp(instant.getTime() - (instant.getTime() % DAY) - cGMT13.getTimeZone().getRawOffset() + DAY);
// +0100 (JVM default)
insertTimestamp.setInt(1,seq++);
insertTimestamp.setTimestamp(2,instant); // 2005-01-01 13:00:00 +0100
insertTimestamp.setTimestamp(3,instant); // 2005-01-01 13:00:00
insertTimestamp.setTimestamp(4,instant); // 13:00:00 +0100
insertTimestamp.setTimestamp(5,instant); // 2005-01-01
insertTimestamp.executeUpdate();
// UTC
insertTimestamp.setInt(1,seq++);
insertTimestamp.setTimestamp(2,instant,cUTC); // 2005-01-01 12:00:00 +0000
insertTimestamp.setTimestamp(3,instant,cUTC); // 2005-01-01 12:00:00
insertTimestamp.setTimestamp(4,instant,cUTC); // 12:00:00 +0000
insertTimestamp.setTimestamp(5,instant,cUTC); // 2005-01-01
insertTimestamp.executeUpdate();
// +0300
insertTimestamp.setInt(1,seq++);
insertTimestamp.setTimestamp(2,instant,cGMT03); // 2005-01-01 15:00:00 +0300
insertTimestamp.setTimestamp(3,instant,cGMT03); // 2005-01-01 15:00:00
insertTimestamp.setTimestamp(4,instant,cGMT03); // 15:00:00 +0300
insertTimestamp.setTimestamp(5,instant,cGMT03); // 2005-01-01
insertTimestamp.executeUpdate();
// -0500
insertTimestamp.setInt(1,seq++);
insertTimestamp.setTimestamp(2,instant,cGMT05); // 2005-01-01 07:00:00 -0500
insertTimestamp.setTimestamp(3,instant,cGMT05); // 2005-01-01 07:00:00
insertTimestamp.setTimestamp(4,instant,cGMT05); // 07:00:00 -0500
insertTimestamp.setTimestamp(5,instant,cGMT05); // 2005-01-01
insertTimestamp.executeUpdate();
if (min73) {
// +1300
insertTimestamp.setInt(1,seq++);
insertTimestamp.setTimestamp(2,instant,cGMT13); // 2005-01-02 01:00:00 +1300
insertTimestamp.setTimestamp(3,instant,cGMT13); // 2005-01-02 01:00:00
insertTimestamp.setTimestamp(4,instant,cGMT13); // 01:00:00 +1300
insertTimestamp.setTimestamp(5,instant,cGMT13); // 2005-01-02
insertTimestamp.executeUpdate();
}
insertTimestamp.close();
// check that insert went correctly by parsing the raw contents in UTC
checkDatabaseContents("SELECT seq::text,tstz::text,ts::text,tz::text,d::text from testtimezone ORDER BY seq",
new String[][]{new String[]{"1", "2005-01-01 12:00:00+00", "2005-01-01 13:00:00", "13:00:00+01", "2005-01-01"},
new String[]{"2", "2005-01-01 12:00:00+00", "2005-01-01 12:00:00", "12:00:00+00", "2005-01-01"},
new String[]{"3", "2005-01-01 12:00:00+00", "2005-01-01 15:00:00", "15:00:00+03", "2005-01-01"},
new String[]{"4", "2005-01-01 12:00:00+00", "2005-01-01 07:00:00", "07:00:00-05", "2005-01-01"},
new String[]{"5", "2005-01-01 12:00:00+00", "2005-01-02 01:00:00", "01:00:00+13", "2005-01-02"}});
//
// check results
//
seq = 1;
ResultSet rs = con.createStatement().executeQuery("SELECT seq,tstz,ts,tz,d FROM testtimezone ORDER BY seq");
assertTrue(rs.next());
assertEquals(seq++, rs.getInt(1));
assertEquals(instant, rs.getTimestamp(2));
assertEquals(instant, rs.getTimestamp(3));
assertEquals(instantTime, rs.getTimestamp(4));
assertEquals(instantDateJVM, rs.getTimestamp(5));
assertTrue(rs.next());
assertEquals(seq++, rs.getInt(1));
assertEquals(instant, rs.getTimestamp(2, cUTC));
assertEquals(instant, rs.getTimestamp(3, cUTC));
assertEquals(instantTime, rs.getTimestamp(4, cUTC));
assertEquals(instantDateUTC, rs.getTimestamp(5, cUTC));
assertTrue(rs.next());
assertEquals(seq++, rs.getInt(1));
assertEquals(instant, rs.getTimestamp(2, cGMT03));
assertEquals(instant, rs.getTimestamp(3, cGMT03));
assertEquals(instantTime, rs.getTimestamp(4, cGMT03));
assertEquals(instantDateGMT03, rs.getTimestamp(5, cGMT03));
assertTrue(rs.next());
assertEquals(seq++, rs.getInt(1));
assertEquals(instant, rs.getTimestamp(2, cGMT05));
assertEquals(instant, rs.getTimestamp(3, cGMT05));
assertEquals(instantTime, rs.getTimestamp(4, cGMT05));
assertEquals(instantDateGMT05, rs.getTimestamp(5, cGMT05));
if (min73) {
assertTrue(rs.next());
assertEquals(seq++, rs.getInt(1));
assertEquals(instant, rs.getTimestamp(2, cGMT13));
assertEquals(instant, rs.getTimestamp(3, cGMT13));
assertEquals(normalizeTimeOfDayPart(instantTime, cGMT13), rs.getTimestamp(4, cGMT13));
assertEquals(instantDateGMT13, rs.getTimestamp(5, cGMT13));
}
assertTrue(!rs.next());
}
public void testSetDate() throws Exception
{
PreparedStatement insertTimestamp = con.prepareStatement("INSERT INTO testtimezone(seq,tstz,ts,d) VALUES (?,?,?,?)");
int seq = 1;
Date dJVM, dUTC, dGMT03, dGMT05, dGMT13 = null;
// +0100 (JVM default)
dJVM = new Date(1104534000000L); // 2005-01-01 00:00:00 +0100
insertTimestamp.setInt(1,seq++);
insertTimestamp.setDate(2,dJVM); // 2005-01-01 00:00:00 +0100
insertTimestamp.setDate(3,dJVM); // 2005-01-01 00:00:00
insertTimestamp.setDate(4,dJVM); // 2005-01-01
insertTimestamp.executeUpdate();
// UTC
dUTC = new Date(1104537600000L); // 2005-01-01 00:00:00 +0000
insertTimestamp.setInt(1,seq++);
insertTimestamp.setDate(2,dUTC,cUTC); // 2005-01-01 00:00:00 +0000
insertTimestamp.setDate(3,dUTC,cUTC); // 2005-01-01 00:00:00
insertTimestamp.setDate(4,dUTC,cUTC); // 2005-01-01
insertTimestamp.executeUpdate();
// +0300
dGMT03 = new Date(1104526800000L); // 2005-01-01 00:00:00 +0300
insertTimestamp.setInt(1,seq++);
insertTimestamp.setDate(2,dGMT03,cGMT03); // 2005-01-01 00:00:00 +0300
insertTimestamp.setDate(3,dGMT03,cGMT03); // 2005-01-01 00:00:00
insertTimestamp.setDate(4,dGMT03,cGMT03); // 2005-01-01
insertTimestamp.executeUpdate();
// -0500
dGMT05 = new Date(1104555600000L); // 2005-01-01 00:00:00 -0500
insertTimestamp.setInt(1,seq++);
insertTimestamp.setDate(2,dGMT05,cGMT05); // 2005-01-01 00:00:00 -0500
insertTimestamp.setDate(3,dGMT05,cGMT05); // 2005-01-01 00:00:00
insertTimestamp.setDate(4,dGMT05,cGMT05); // 2005-01-01
insertTimestamp.executeUpdate();
if (min73) {
// +1300
dGMT13 = new Date(1104490800000L); // 2005-01-01 00:00:00 +1300
insertTimestamp.setInt(1,seq++);
insertTimestamp.setDate(2,dGMT13,cGMT13); // 2005-01-01 00:00:00 +1300
insertTimestamp.setDate(3,dGMT13,cGMT13); // 2005-01-01 00:00:00
insertTimestamp.setDate(4,dGMT13,cGMT13); // 2005-01-01
insertTimestamp.executeUpdate();
}
insertTimestamp.close();
// check that insert went correctly by parsing the raw contents in UTC
checkDatabaseContents("SELECT seq::text,tstz::text,ts::text,d::text from testtimezone ORDER BY seq",
new String[][]{new String[]{"1", "2004-12-31 23:00:00+00", "2005-01-01 00:00:00", "2005-01-01"},
new String[]{"2", "2005-01-01 00:00:00+00", "2005-01-01 00:00:00", "2005-01-01"},
new String[]{"3", "2004-12-31 21:00:00+00", "2005-01-01 00:00:00", "2005-01-01"},
new String[]{"4", "2005-01-01 05:00:00+00", "2005-01-01 00:00:00", "2005-01-01"},
new String[]{"5", "2004-12-31 11:00:00+00", "2005-01-01 00:00:00", "2005-01-01"}});
//
// check results
//
seq = 1;
ResultSet rs = con.createStatement().executeQuery("SELECT seq,tstz,ts,d FROM testtimezone ORDER BY seq");
assertTrue(rs.next());
assertEquals(seq++, rs.getInt(1));
assertEquals(dJVM, rs.getDate(2));
assertEquals(dJVM, rs.getDate(3));
assertEquals(dJVM, rs.getDate(4));
assertTrue(rs.next());
assertEquals(seq++, rs.getInt(1));
assertEquals(dUTC, rs.getDate(2, cUTC));
assertEquals(dUTC, rs.getDate(3, cUTC));
assertEquals(dUTC, rs.getDate(4, cUTC));
assertTrue(rs.next());
assertEquals(seq++, rs.getInt(1));
assertEquals(dGMT03, rs.getDate(2, cGMT03));
assertEquals(dGMT03, rs.getDate(3, cGMT03));
assertEquals(dGMT03, rs.getDate(4, cGMT03));
assertTrue(rs.next());
assertEquals(seq++, rs.getInt(1));
assertEquals(dGMT05, rs.getDate(2, cGMT05));
assertEquals(dGMT05, rs.getDate(3, cGMT05));
assertEquals(dGMT05, rs.getDate(4, cGMT05));
if (min73) {
assertTrue(rs.next());
assertEquals(seq++, rs.getInt(1));
assertEquals(dGMT13, rs.getDate(2, cGMT13));
assertEquals(dGMT13, rs.getDate(3, cGMT13));
assertEquals(dGMT13, rs.getDate(4, cGMT13));
}
assertTrue(!rs.next());
}
public void testSetTime() throws Exception
{
if (!min74) {
// We can't do timezones properly for time/timetz values before 7.4
System.err.println("Skipping TimezoneTest.testSetTime on a pre-7.4 server");
return;
}
PreparedStatement insertTimestamp = con.prepareStatement("INSERT INTO testtimezone(seq,t,tz) VALUES (?,?,?)");
int seq = 1;
Time tJVM, tUTC, tGMT03, tGMT05, tGMT13;
// +0100 (JVM default)
tJVM = new Time(50400000L); // 1970-01-01 15:00:00 +0100
insertTimestamp.setInt(1,seq++);
insertTimestamp.setTime(2,tJVM); // 15:00:00
insertTimestamp.setTime(3,tJVM); // 15:00:00+03
insertTimestamp.executeUpdate();
// UTC
tUTC = new Time(54000000L); // 1970-01-01 15:00:00 +0000
insertTimestamp.setInt(1,seq++);
insertTimestamp.setTime(2,tUTC,cUTC); // 15:00:00
insertTimestamp.setTime(3,tUTC,cUTC); // 15:00:00+00
insertTimestamp.executeUpdate();
// +0300
tGMT03 = new Time(43200000L); // 1970-01-01 15:00:00 +0300
insertTimestamp.setInt(1,seq++);
insertTimestamp.setTime(2,tGMT03,cGMT03); // 15:00:00
insertTimestamp.setTime(3,tGMT03,cGMT03); // 15:00:00+03
insertTimestamp.executeUpdate();
// -0500
tGMT05 = new Time(72000000L); // 1970-01-01 15:00:00 -0500
insertTimestamp.setInt(1,seq++);
insertTimestamp.setTime(2,tGMT05,cGMT05); // 15:00:00
insertTimestamp.setTime(3,tGMT05,cGMT05); // 15:00:00-05
insertTimestamp.executeUpdate();
// +1300
tGMT13 = new Time(7200000L); // 1970-01-01 15:00:00 +1300
insertTimestamp.setInt(1,seq++);
insertTimestamp.setTime(2,tGMT13,cGMT13); // 15:00:00
insertTimestamp.setTime(3,tGMT13,cGMT13); // 15:00:00+13
insertTimestamp.executeUpdate();
insertTimestamp.close();
// check that insert went correctly by parsing the raw contents in UTC
checkDatabaseContents("SELECT seq::text,t::text,tz::text from testtimezone ORDER BY seq",
new String[][]{new String[]{"1", "15:00:00", "15:00:00+01",},
new String[]{"2", "15:00:00", "15:00:00+00",},
new String[]{"3", "15:00:00", "15:00:00+03",},
new String[]{"4", "15:00:00", "15:00:00-05",},
new String[]{"5", "15:00:00", "15:00:00+13",}});
//
// check results
//
seq = 1;
ResultSet rs = con.createStatement().executeQuery("SELECT seq,t,tz FROM testtimezone ORDER BY seq");
assertTrue(rs.next());
assertEquals(seq++, rs.getInt(1));
assertEquals(tJVM, rs.getTime(2));
assertEquals(tJVM, rs.getTime(3));
assertTrue(rs.next());
assertEquals(seq++, rs.getInt(1));
assertEquals(tUTC, rs.getTime(2, cUTC));
assertEquals(tUTC, rs.getTime(2, cUTC));
assertTrue(rs.next());
assertEquals(seq++, rs.getInt(1));
assertEquals(tGMT03, rs.getTime(2, cGMT03));
assertEquals(tGMT03, rs.getTime(2, cGMT03));
assertTrue(rs.next());
assertEquals(seq++, rs.getInt(1));
assertEquals(tGMT05, rs.getTime(2, cGMT05));
assertEquals(tGMT05, rs.getTime(2, cGMT05));
assertTrue(rs.next());
assertEquals(seq++, rs.getInt(1));
assertEquals(tGMT13, rs.getTime(2, cGMT13));
assertEquals(tGMT13, rs.getTime(2, cGMT13));
assertTrue(!rs.next());
}
public void testHalfHourTimezone() throws Exception
{
Statement stmt = con.createStatement();
stmt.execute("SET TimeZone = 'GMT+3:30'");
ResultSet rs = stmt.executeQuery("SELECT '1969-12-31 20:30:00'::timestamptz");
assertTrue(rs.next());
assertEquals(0L, rs.getTimestamp(1).getTime());
}
public void testTimezoneWithSeconds() throws SQLException
{
if (!TestUtil.haveMinimumServerVersion(con, "8.2"))
return;
Statement stmt = con.createStatement();
stmt.execute("SET TimeZone = 'Europe/Helsinki'");
ResultSet rs = stmt.executeQuery("SELECT '1920-01-01'::timestamptz");
rs.next();
// select extract(epoch from '1920-01-01'::timestamptz - 'epoch'::timestamptz) * 1000;
assertEquals(-1577929192000L, rs.getTimestamp(1).getTime());
}
/**
* Does a query in UTC time zone to database to check that the
* inserted values are correct.
*
* @param query The query to run.
* @param correct The correct answers in UTC time zone as formatted by backend.
*/
private void checkDatabaseContents(String query, String[] correct) throws Exception {
checkDatabaseContents(query, new String[][]{correct});
}
private void checkDatabaseContents(String query, String[][] correct) throws Exception {
Connection con2 = TestUtil.openDB();
Statement s = con2.createStatement();
assertFalse(s.execute("set time zone 'UTC'"));
assertTrue(s.execute(query));
ResultSet rs = s.getResultSet();
for (int j = 0; j < correct.length; ++j) {
assertTrue(rs.next());
for (int i = 0; i < correct[j].length; ++i) {
assertEquals("On row " + (j+1), correct[j][i], rs.getString(i+1));
}
}
assertFalse(rs.next());
rs.close();
s.close();
con2.close();
}
/**
* Converts the given time
*
* @param t The time of day. Must be within -24 and + 24 hours of epoc.
* @param tz The timezone to normalize to.
* @return the Time nomralized to 0 to 24 hours of epoc adjusted with given timezone.
*/
private Timestamp normalizeTimeOfDayPart(Timestamp t, Calendar tz) {
return new Timestamp(normalizeTimeOfDayPart(t.getTime(), tz.getTimeZone()));
}
private long normalizeTimeOfDayPart(long t, TimeZone tz) {
long millis = t;
long low = - tz.getOffset(millis);
long high = low + DAY;
if (millis < low) {
do { millis += DAY; } while (millis < low);
} else if (millis >= high) {
do { millis -= DAY; } while (millis > high);
}
return millis;
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc2/UpdateableResultTest.java 0000664 0000000 0000000 00000037206 12050675701 0027555 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2001-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc2;
import java.sql.*;
import java.util.Arrays;
import junit.framework.TestCase;
import java.io.InputStream;
import java.io.ByteArrayInputStream;
import java.io.Reader;
import java.io.StringReader;
import java.io.UnsupportedEncodingException;
import java.util.TimeZone;
import org.postgresql.test.TestUtil;
public class UpdateableResultTest extends TestCase
{
private Connection con;
public UpdateableResultTest( String name )
{
super( name );
try
{
Class.forName("org.postgresql.Driver");
}
catch( Exception ex ){}
}
protected void setUp() throws Exception
{
con = TestUtil.openDB();
TestUtil.createTable(con, "updateable", "id int primary key, name text, notselected text, ts timestamp with time zone, intarr int[]", true);
TestUtil.createTable(con, "second", "id1 int primary key, name1 text");
TestUtil.createTable(con, "stream", "id int primary key, asi text, chr text, bin bytea");
// put some dummy data into second
Statement st2 = con.createStatement();
st2.execute( "insert into second values (1,'anyvalue' )");
st2.close();
}
protected void tearDown() throws Exception
{
TestUtil.dropTable(con, "updateable");
TestUtil.dropTable(con, "second");
TestUtil.dropTable(con, "stream");
TestUtil.closeDB(con);
}
public void testDeleteRows() throws SQLException
{
Statement st = con.createStatement();
st.executeUpdate("INSERT INTO second values (2,'two')");
st.executeUpdate("INSERT INTO second values (3,'three')");
st.executeUpdate("INSERT INTO second values (4,'four')");
st.close();
st = con.createStatement( ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE );
ResultSet rs = st.executeQuery( "select id1,name1 from second order by id1");
assertTrue(rs.next());
assertEquals(1, rs.getInt("id1"));
rs.deleteRow();
assertTrue(rs.isBeforeFirst());
assertTrue(rs.next());
assertTrue(rs.next());
assertEquals(3, rs.getInt("id1"));
rs.deleteRow();
assertEquals(2, rs.getInt("id1"));
rs.close();
st.close();
}
public void testCancelRowUpdates() throws Exception
{
Statement st = con.createStatement( ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE );
ResultSet rs = st.executeQuery( "select * from second");
// make sure we're dealing with the correct row.
rs.first();
assertEquals(1, rs.getInt(1));
assertEquals("anyvalue", rs.getString(2));
// update, cancel and make sure nothings changed.
rs.updateInt(1, 99);
rs.cancelRowUpdates();
assertEquals(1, rs.getInt(1));
assertEquals("anyvalue", rs.getString(2));
// real update
rs.updateInt(1, 999);
rs.updateRow();
assertEquals(999, rs.getInt(1));
assertEquals("anyvalue", rs.getString(2));
// scroll some and make sure the update is still there
rs.beforeFirst();
rs.next();
assertEquals(999, rs.getInt(1));
assertEquals("anyvalue", rs.getString(2));
// make sure the update got to the db and the driver isn't lying to us.
rs.close();
rs = st.executeQuery( "select * from second");
rs.first();
assertEquals(999, rs.getInt(1));
assertEquals("anyvalue", rs.getString(2));
rs.close();
st.close();
}
private void checkPositioning(ResultSet rs) throws SQLException
{
try
{
rs.getInt(1);
fail("Can't use an incorrectly positioned result set.");
}
catch (SQLException sqle)
{
}
try
{
rs.updateInt(1, 2);
fail("Can't use an incorrectly positioned result set.");
}
catch (SQLException sqle)
{
}
try
{
rs.updateRow();
fail("Can't use an incorrectly positioned result set.");
}
catch (SQLException sqle)
{
}
try
{
rs.deleteRow();
fail("Can't use an incorrectly positioned result set.");
}
catch (SQLException sqle)
{
}
}
public void testPositioning() throws SQLException
{
Statement stmt = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE);
ResultSet rs = stmt.executeQuery("SELECT id1,name1 FROM second");
checkPositioning(rs);
assertTrue(rs.next());
rs.beforeFirst();
checkPositioning(rs);
rs.afterLast();
checkPositioning(rs);
rs.beforeFirst();
assertTrue(rs.next());
assertTrue(!rs.next());
checkPositioning(rs);
rs.afterLast();
assertTrue(rs.previous());
assertTrue(!rs.previous());
checkPositioning(rs);
rs.close();
stmt.close();
}
public void testUpdateTimestamp() throws SQLException
{
TimeZone origTZ = TimeZone.getDefault();
try {
// We choose a timezone which has a partial hour portion
// Asia/Tehran is +3:30
TimeZone.setDefault(TimeZone.getTimeZone("Asia/Tehran"));
Timestamp ts = Timestamp.valueOf("2006-11-20 16:17:18");
Statement stmt = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE);
ResultSet rs = stmt.executeQuery("SELECT id, ts FROM updateable");
rs.moveToInsertRow();
rs.updateInt(1,1);
rs.updateTimestamp(2,ts);
rs.insertRow();
rs.first();
assertEquals(ts, rs.getTimestamp(2));
} finally {
TimeZone.setDefault(origTZ);
}
}
public void testUpdateStreams() throws SQLException, UnsupportedEncodingException
{
String string = "Hello";
byte[] bytes = new byte[]{0,'\\',(byte) 128,(byte) 255};
Statement stmt = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE);
ResultSet rs = stmt.executeQuery("SELECT id, asi, chr, bin FROM stream");
rs.moveToInsertRow();
rs.updateInt(1, 1);
rs.updateAsciiStream("asi", null, 17);
rs.updateCharacterStream("chr", null, 81);
rs.updateBinaryStream("bin", null, 0);
rs.insertRow();
rs.moveToInsertRow();
rs.updateInt(1, 3);
rs.updateAsciiStream("asi", new ByteArrayInputStream(string.getBytes("US-ASCII")), 5);
rs.updateCharacterStream("chr", new StringReader(string), 5);
rs.updateBinaryStream("bin", new ByteArrayInputStream(bytes), bytes.length);
rs.insertRow();
rs.beforeFirst();
rs.next();
assertEquals(1, rs.getInt(1));
assertNull(rs.getString(2));
assertNull(rs.getString(3));
assertNull(rs.getBytes(4));
rs.updateInt("id", 2);
rs.updateAsciiStream("asi", new ByteArrayInputStream(string.getBytes("US-ASCII")), 5);
rs.updateCharacterStream("chr", new StringReader(string), 5);
rs.updateBinaryStream("bin", new ByteArrayInputStream(bytes), bytes.length);
rs.updateRow();
assertEquals(2, rs.getInt(1));
assertEquals(string, rs.getString(2));
assertEquals(string, rs.getString(3));
assertTrue(Arrays.equals(bytes, rs.getBytes(4)));
rs.refreshRow();
assertEquals(2, rs.getInt(1));
assertEquals(string, rs.getString(2));
assertEquals(string, rs.getString(3));
assertTrue(Arrays.equals(bytes, rs.getBytes(4)));
rs.next();
assertEquals(3, rs.getInt(1));
assertEquals(string, rs.getString(2));
assertEquals(string, rs.getString(3));
assertTrue(Arrays.equals(bytes, rs.getBytes(4)));
rs.close();
stmt.close();
}
public void testZeroRowResult() throws SQLException
{
Statement st = con.createStatement( ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE );
ResultSet rs = st.executeQuery( "select * from updateable WHERE 0 > 1");
assertTrue(!rs.next());
rs.moveToInsertRow();
rs.moveToCurrentRow();
}
public void testUpdateable() throws SQLException
{
Statement st = con.createStatement( ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE );
ResultSet rs = st.executeQuery( "select * from updateable");
assertNotNull( rs );
rs.moveToInsertRow();
rs.updateInt( 1, 1 );
rs.updateString( 2, "jake" );
rs.updateString( 3, "avalue" );
rs.insertRow();
rs.first();
rs.updateInt( "id", 2 );
rs.updateString( "name", "dave" );
rs.updateRow();
assertEquals(2, rs.getInt("id"));
assertEquals("dave", rs.getString("name"));
assertEquals("avalue", rs.getString("notselected"));
rs.deleteRow();
rs.moveToInsertRow();
rs.updateInt("id", 3);
rs.updateString("name", "paul");
rs.insertRow();
try
{
rs.refreshRow();
fail("Can't refresh when on the insert row.");
}
catch (SQLException sqle)
{
}
assertEquals(3, rs.getInt("id"));
assertEquals("paul", rs.getString("name"));
assertNull(rs.getString("notselected"));
rs.close();
rs = st.executeQuery("select id1, id, name, name1 from updateable, second" );
try
{
while ( rs.next() )
{
rs.updateInt( "id", 2 );
rs.updateString( "name", "dave" );
rs.updateRow();
}
fail("should not get here, update should fail");
}
catch (SQLException ex)
{
}
rs = st.executeQuery("select oid,* from updateable");
assertTrue(rs.first());
rs.updateInt( "id", 3 );
rs.updateString( "name", "dave3");
rs.updateRow();
assertEquals(3, rs.getInt("id"));
assertEquals("dave3", rs.getString("name"));
rs.moveToInsertRow();
rs.updateInt( "id", 4 );
rs.updateString( "name", "dave4" );
rs.insertRow();
rs.updateInt("id", 5 );
rs.updateString( "name", "dave5" );
rs.insertRow();
rs.moveToCurrentRow();
assertEquals(3, rs.getInt("id"));
assertEquals("dave3", rs.getString("name"));
assertTrue( rs.next() );
assertEquals(4, rs.getInt("id"));
assertEquals("dave4", rs.getString("name"));
assertTrue( rs.next() );
assertEquals(5, rs.getInt("id"));
assertEquals("dave5", rs.getString("name"));
rs.close();
st.close();
}
public void testInsertRowIllegalMethods() throws Exception
{
Statement st = con.createStatement( ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE );
ResultSet rs = st.executeQuery( "select * from updateable");
assertNotNull(rs);
rs.moveToInsertRow();
try {
rs.cancelRowUpdates();
fail("expected an exception when calling cancelRowUpdates() on the insert row");
} catch (SQLException e) {}
try {
rs.updateRow();
fail("expected an exception when calling updateRow() on the insert row");
} catch (SQLException e) {}
try {
rs.deleteRow();
fail("expected an exception when calling deleteRow() on the insert row");
} catch (SQLException e) {}
try {
rs.refreshRow();
fail("expected an exception when calling refreshRow() on the insert row");
} catch (SQLException e) {}
rs.close();
st.close();
}
public void testUpdateablePreparedStatement() throws Exception
{
// No args.
PreparedStatement st = con.prepareStatement("select * from updateable",
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
ResultSet rs = st.executeQuery();
rs.moveToInsertRow();
rs.close();
st.close();
// With args.
st = con.prepareStatement("select * from updateable where id = ?",
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
st.setInt(1, 1);
rs = st.executeQuery();
rs.moveToInsertRow();
rs.close();
st.close();
}
public void testUpdateSelectOnly() throws Exception
{
Statement st = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
ResultSet rs = st.executeQuery( "select * from only second");
assertTrue(rs.next());
rs.updateInt(1, 2);
rs.updateRow();
}
public void testUpdateReadOnlyResultSet() throws Exception
{
Statement st = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_READ_ONLY);
ResultSet rs = st.executeQuery( "select * from updateable");
try {
rs.moveToInsertRow();
fail("expected an exception when calling moveToInsertRow() on a read-only resultset");
} catch (SQLException e) {}
}
public void testBadColumnIndexes() throws Exception
{
Statement st = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
ResultSet rs = st.executeQuery( "select * from updateable");
rs.moveToInsertRow();
try {
rs.updateInt(0,1);
fail("Should have thrown an exception on bad column index.");
} catch (SQLException sqle) { }
try {
rs.updateString(1000,"hi");
fail("Should have thrown an exception on bad column index.");
} catch (SQLException sqle) { }
try {
rs.updateNull(1000);
fail("Should have thrown an exception on bad column index.");
} catch (SQLException sqle) { }
}
public void testArray() throws SQLException {
Statement stmt = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE);
stmt.executeUpdate("INSERT INTO updateable (id, intarr) VALUES (1, '{1,2,3}'::int4[])");
ResultSet rs = stmt.executeQuery("SELECT id, intarr FROM updateable");
assertTrue(rs.next());
rs.updateObject(2, rs.getArray(2));
rs.updateRow();
Array arr = rs.getArray(2);
assertEquals(Types.INTEGER, arr.getBaseType());
Integer intarr[] = (Integer[])arr.getArray();
assertEquals(3, intarr.length);
assertEquals(1, intarr[0].intValue());
assertEquals(2, intarr[1].intValue());
assertEquals(3, intarr[2].intValue());
rs.close();
rs = stmt.executeQuery("SELECT id,intarr FROM updateable");
assertTrue(rs.next());
arr = rs.getArray(2);
assertEquals(Types.INTEGER, arr.getBaseType());
intarr = (Integer[])arr.getArray();
assertEquals(3, intarr.length);
assertEquals(1, intarr[0].intValue());
assertEquals(2, intarr[1].intValue());
assertEquals(3, intarr[2].intValue());
rs.close();
stmt.close();
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc2/optional/ 0000775 0000000 0000000 00000000000 12050675701 0024422 5 ustar 00root root 0000000 0000000 postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc2/optional/BaseDataSourceTest.java 0000664 0000000 0000000 00000017217 12050675701 0030762 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc2.optional;
import junit.framework.TestCase;
import org.postgresql.test.TestUtil;
import org.postgresql.test.util.MiniJndiContextFactory;
import org.postgresql.ds.common.BaseDataSource;
import org.postgresql.PGConnection;
import java.sql.*;
import java.util.*;
import javax.naming.*;
/**
* Common tests for all the BaseDataSource implementations. This is
* a small variety to make sure that a connection can be opened and
* some basic queries run. The different BaseDataSource subclasses
* have different subclasses of this which add additional custom
* tests.
*
* @author Aaron Mulder (ammulder@chariotsolutions.com)
*/
public abstract class BaseDataSourceTest extends TestCase
{
public static String DATA_SOURCE_JNDI = "BaseDataSource";
protected Connection con;
protected BaseDataSource bds;
/**
* Constructor required by JUnit
*/
public BaseDataSourceTest(String name)
{
super(name);
}
/**
* Creates a test table using a standard connection (not from a
* DataSource).
*/
protected void setUp() throws Exception
{
con = TestUtil.openDB();
TestUtil.createTable(con, "poolingtest", "id int4 not null primary key, name varchar(50)");
Statement stmt = con.createStatement();
stmt.executeUpdate("INSERT INTO poolingtest VALUES (1, 'Test Row 1')");
stmt.executeUpdate("INSERT INTO poolingtest VALUES (2, 'Test Row 2')");
TestUtil.closeDB(con);
}
/**
* Removes the test table using a standard connection (not from
* a DataSource)
*/
protected void tearDown() throws Exception
{
TestUtil.closeDB(con);
con = TestUtil.openDB();
TestUtil.dropTable(con, "poolingtest");
TestUtil.closeDB(con);
}
/**
* Gets a connection from the current BaseDataSource
*/
protected Connection getDataSourceConnection() throws SQLException
{
if (bds == null)
{
initializeDataSource();
}
return bds.getConnection();
}
/**
* Creates an instance of the current BaseDataSource for
* testing. Must be customized by each subclass.
*/
protected abstract void initializeDataSource();
public static void setupDataSource(BaseDataSource bds)
{
bds.setServerName(TestUtil.getServer());
bds.setPortNumber(TestUtil.getPort());
bds.setDatabaseName(TestUtil.getDatabase());
bds.setUser(TestUtil.getUser());
bds.setPassword(TestUtil.getPassword());
bds.setPrepareThreshold(TestUtil.getPrepareThreshold());
bds.setLogLevel(TestUtil.getLogLevel());
bds.setProtocolVersion(TestUtil.getProtocolVersion());
}
/**
* Test to make sure you can instantiate and configure the
* appropriate DataSource
*/
public void testCreateDataSource()
{
initializeDataSource();
}
/**
* Test to make sure you can get a connection from the DataSource,
* which in turn means the DataSource was able to open it.
*/
public void testGetConnection()
{
try
{
con = getDataSourceConnection();
con.close();
}
catch (SQLException e)
{
fail(e.getMessage());
}
}
/**
* A simple test to make sure you can execute SQL using the
* Connection from the DataSource
*/
public void testUseConnection()
{
try
{
con = getDataSourceConnection();
Statement st = con.createStatement();
ResultSet rs = st.executeQuery("SELECT COUNT(*) FROM poolingtest");
if (rs.next())
{
int count = rs.getInt(1);
if (rs.next())
{
fail("Should only have one row in SELECT COUNT result set");
}
if (count != 2)
{
fail("Count returned " + count + " expecting 2");
}
}
else
{
fail("Should have one row in SELECT COUNT result set");
}
rs.close();
st.close();
con.close();
}
catch (SQLException e)
{
fail(e.getMessage());
}
}
/**
* A test to make sure you can execute DDL SQL using the
* Connection from the DataSource.
*/
public void testDdlOverConnection()
{
try
{
con = getDataSourceConnection();
TestUtil.createTable(con, "poolingtest", "id int4 not null primary key, name varchar(50)");
con.close();
}
catch (SQLException e)
{
fail(e.getMessage());
}
}
/**
* A test to make sure the connections are not being pooled by the
* current DataSource. Obviously need to be overridden in the case
* of a pooling Datasource.
*/
public void testNotPooledConnection() throws SQLException
{
con = getDataSourceConnection();
String name = con.toString();
con.close();
con = getDataSourceConnection();
String name2 = con.toString();
con.close();
assertTrue(!name.equals(name2));
}
/**
* Test to make sure that PGConnection methods can be called on the
* pooled Connection.
*/
public void testPGConnection()
{
try
{
con = getDataSourceConnection();
((PGConnection)con).getNotifications();
con.close();
}
catch (Exception e)
{
fail("Unable to call PGConnection method on pooled connection due to " + e.getClass().getName() + " (" + e.getMessage() + ")");
}
}
/**
* Uses the mini-JNDI implementation for testing purposes
*/
protected InitialContext getInitialContext()
{
Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY, MiniJndiContextFactory.class.getName());
try
{
return new InitialContext(env);
}
catch (NamingException e)
{
fail("Unable to create InitialContext: " + e.getMessage());
return null;
}
}
/**
* Eventually, we must test stuffing the DataSource in JNDI and
* then getting it back out and make sure it's still usable. This
* should ideally test both Serializable and Referenceable
* mechanisms. Will probably be multiple tests when implemented.
*/
public void testJndi()
{
initializeDataSource();
BaseDataSource oldbds = bds;
InitialContext ic = getInitialContext();
try
{
ic.rebind(DATA_SOURCE_JNDI, bds);
bds = (BaseDataSource)ic.lookup(DATA_SOURCE_JNDI);
assertTrue("Got null looking up DataSource from JNDI!", bds != null);
compareJndiDataSource(oldbds, bds);
}
catch (NamingException e)
{
fail(e.getMessage());
}
oldbds = bds;
testUseConnection();
assertTrue("Test should not have changed DataSource (" + bds + " != " + oldbds + ")!", bds == oldbds);
}
/**
* Check whether a DS was dereferenced from JNDI or recreated.
*/
protected void compareJndiDataSource(BaseDataSource oldbds, BaseDataSource bds) {
assertTrue("DataSource was dereferenced, should have been serialized or recreated", bds != oldbds);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc2/optional/ConnectionPoolTest.java 0000664 0000000 0000000 00000043125 12050675701 0031063 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc2.optional;
import org.postgresql.jdbc2.optional.ConnectionPool;
import org.postgresql.ds.PGConnectionPoolDataSource;
import org.postgresql.test.TestUtil;
import javax.sql.*;
import java.sql.*;
import java.util.*;
import java.io.*;
/**
* Tests for the ConnectionPoolDataSource and PooledConnection
* implementations. They are tested together because the only client
* interface to the PooledConnection is through the CPDS.
*
* @author Aaron Mulder (ammulder@chariotsolutions.com)
*/
public class ConnectionPoolTest extends BaseDataSourceTest
{
private ArrayList connections = new ArrayList();
/**
* Constructor required by JUnit
*/
public ConnectionPoolTest(String name)
{
super(name);
}
/**
* Creates and configures a ConnectionPool
*/
protected void initializeDataSource()
{
if (bds == null)
{
bds = new ConnectionPool();
setupDataSource(bds);
}
}
protected void tearDown() throws Exception
{
for (Iterator i = connections.iterator(); i.hasNext(); ) {
PooledConnection c = (PooledConnection) i.next();
try {
c.close();
} catch (Exception ex) {
// close throws nullptr or other evil things if the connection
// is already closed
}
}
}
/**
* Though the normal client interface is to grab a Connection, in
* order to test the middleware/server interface, we need to deal
* with PooledConnections. Some tests use each.
*/
protected PooledConnection getPooledConnection() throws SQLException
{
initializeDataSource();
// we need to recast to PGConnectionPool rather than
// jdbc.optional.ConnectionPool because our ObjectFactory
// returns only the top level class, not the specific
// jdbc2/jdbc3 implementations.
PooledConnection c = ((PGConnectionPoolDataSource)bds).getPooledConnection();
connections.add(c);
return c;
}
/**
* Instead of just fetching a Connection from the ConnectionPool,
* get a PooledConnection, add a listener to close it when the
* Connection is closed, and then get the Connection. Without
* the listener the PooledConnection (and thus the physical connection)
* would never by closed. Probably not a disaster during testing, but
* you never know.
*/
protected Connection getDataSourceConnection() throws SQLException
{
initializeDataSource();
final PooledConnection pc = getPooledConnection();
// Since the pooled connection won't be reused in these basic tests, close it when the connection is closed
pc.addConnectionEventListener(new ConnectionEventListener()
{
public void connectionClosed(ConnectionEvent event)
{
try
{
pc.close();
}
catch (SQLException e)
{
fail("Unable to close PooledConnection: " + e);
}
}
public void connectionErrorOccurred(ConnectionEvent event)
{
}
}
);
return pc.getConnection();
}
/**
* Makes sure that if you get a connection from a PooledConnection,
* close it, and then get another one, you're really using the same
* physical connection. Depends on the implementation of toString
* for the connection handle.
*/
public void testPoolReuse()
{
try
{
PooledConnection pc = getPooledConnection();
con = pc.getConnection();
String name = con.toString();
con.close();
con = pc.getConnection();
String name2 = con.toString();
con.close();
pc.close();
assertTrue("Physical connection doesn't appear to be reused across PooledConnection wrappers", name.equals(name2));
}
catch (SQLException e)
{
fail(e.getMessage());
}
}
/**
* Makes sure that when you request a connection from the
* PooledConnection, and previous connection it might have given
* out is closed. See JDBC 2.0 Optional Package spec section
* 6.2.3
*/
public void testPoolCloseOldWrapper()
{
try
{
PooledConnection pc = getPooledConnection();
con = pc.getConnection();
Connection con2 = pc.getConnection();
try
{
con.createStatement();
fail("Original connection wrapper should be closed when new connection wrapper is generated");
}
catch (SQLException e)
{
}
con2.close();
pc.close();
}
catch (SQLException e)
{
fail(e.getMessage());
}
}
/**
* Makes sure that if you get two connection wrappers from the same
* PooledConnection, they are different, even though the represent
* the same physical connection. See JDBC 2.0 Optional Pacakge spec
* section 6.2.2
*/
public void testPoolNewWrapper()
{
try
{
PooledConnection pc = getPooledConnection();
con = pc.getConnection();
Connection con2 = pc.getConnection();
con2.close();
pc.close();
assertTrue("Two calls to PooledConnection.getConnection should not return the same connection wrapper", con != con2);
}
catch (SQLException e)
{
fail(e.getMessage());
}
}
/**
* Makes sure that exactly one close event is fired for each time a
* connection handle is closed. Also checks that events are not
* fired after a given handle has been closed once.
*/
public void testCloseEvent()
{
try
{
PooledConnection pc = getPooledConnection();
CountClose cc = new CountClose();
pc.addConnectionEventListener(cc);
con = pc.getConnection();
assertTrue(cc.getCount() == 0);
assertTrue(cc.getErrorCount() == 0);
con.close();
assertTrue(cc.getCount() == 1);
assertTrue(cc.getErrorCount() == 0);
con = pc.getConnection();
assertTrue(cc.getCount() == 1);
assertTrue(cc.getErrorCount() == 0);
con.close();
assertTrue(cc.getCount() == 2);
assertTrue(cc.getErrorCount() == 0);
// a double close shouldn't fire additional events
con.close();
assertTrue(cc.getCount() == 2);
assertTrue(cc.getErrorCount() == 0);
pc.close();
}
catch (SQLException e)
{
fail(e.getMessage());
}
}
/**
* Makes sure that close events are not fired after a listener has
* been removed.
*/
public void testNoCloseEvent()
{
try
{
PooledConnection pc = getPooledConnection();
CountClose cc = new CountClose();
pc.addConnectionEventListener(cc);
con = pc.getConnection();
assertTrue(cc.getCount() == 0);
assertTrue(cc.getErrorCount() == 0);
con.close();
assertTrue(cc.getCount() == 1);
assertTrue(cc.getErrorCount() == 0);
pc.removeConnectionEventListener(cc);
con = pc.getConnection();
assertTrue(cc.getCount() == 1);
assertTrue(cc.getErrorCount() == 0);
con.close();
assertTrue(cc.getCount() == 1);
assertTrue(cc.getErrorCount() == 0);
}
catch (SQLException e)
{
fail(e.getMessage());
}
}
/**
* Makes sure that a listener can be removed while dispatching
* events. Sometimes this causes a ConcurrentModificationException
* or something.
*/
public void testInlineCloseEvent()
{
try
{
PooledConnection pc = getPooledConnection();
RemoveClose rc1 = new RemoveClose();
RemoveClose rc2 = new RemoveClose();
RemoveClose rc3 = new RemoveClose();
pc.addConnectionEventListener(rc1);
pc.addConnectionEventListener(rc2);
pc.addConnectionEventListener(rc3);
con = pc.getConnection();
con.close();
con = pc.getConnection();
con.close();
}
catch (Exception e)
{
fail(e.getMessage());
}
}
/**
* Tests that a close event is not generated when a connection
* handle is closed automatically due to a new connection handle
* being opened for the same PooledConnection. See JDBC 2.0
* Optional Package spec section 6.3
*/
public void testAutomaticCloseEvent()
{
try
{
PooledConnection pc = getPooledConnection();
CountClose cc = new CountClose();
pc.addConnectionEventListener(cc);
con = pc.getConnection();
assertTrue(cc.getCount() == 0);
assertTrue(cc.getErrorCount() == 0);
con.close();
assertTrue(cc.getCount() == 1);
assertTrue(cc.getErrorCount() == 0);
con = pc.getConnection();
assertTrue(cc.getCount() == 1);
assertTrue(cc.getErrorCount() == 0);
// Open a 2nd connection, causing the first to be closed. No even should be generated.
Connection con2 = pc.getConnection();
assertTrue("Connection handle was not closed when new handle was opened", con.isClosed());
assertTrue(cc.getCount() == 1);
assertTrue(cc.getErrorCount() == 0);
con2.close();
assertTrue(cc.getCount() == 2);
assertTrue(cc.getErrorCount() == 0);
pc.close();
}
catch (SQLException e)
{
fail(e.getMessage());
}
}
/**
* Makes sure the isClosed method on a connection wrapper does what
* you'd expect. Checks the usual case, as well as automatic
* closure when a new handle is opened on the same physical connection.
*/
public void testIsClosed()
{
try
{
PooledConnection pc = getPooledConnection();
con = pc.getConnection();
assertTrue(!con.isClosed());
con.close();
assertTrue(con.isClosed());
con = pc.getConnection();
Connection con2 = pc.getConnection();
assertTrue(con.isClosed());
assertTrue(!con2.isClosed());
con2.close();
assertTrue(con.isClosed());
pc.close();
}
catch (SQLException e)
{
fail(e.getMessage());
}
}
/**
* Ensures that a statement generated by a proxied connection returns the
* proxied connection from getConnection() [not the physical connection].
*/
public void testStatementConnection() {
try
{
PooledConnection pc = getPooledConnection();
con = pc.getConnection();
Statement s = con.createStatement();
Connection conRetrieved = s.getConnection();
assertTrue(con.getClass().equals(conRetrieved.getClass()));
assertTrue(con.equals(conRetrieved));
}
catch (SQLException e)
{
fail(e.getMessage());
}
}
/**
* Ensures that the Statement proxy generated by the Connection handle
* throws the correct kind of exception.
*/
public void testStatementProxy() {
Statement s = null;
try
{
PooledConnection pc = getPooledConnection();
con = pc.getConnection();
s = con.createStatement();
}
catch (SQLException e)
{
fail(e.getMessage());
}
try
{
s.executeQuery("SELECT * FROM THIS_TABLE_SHOULD_NOT_EXIST");
fail("An SQL exception was not thrown that should have been");
}
catch (SQLException e)
{
; // This is the expected and correct path
}
catch (Exception e)
{
fail("bad exception; was expecting SQLException, not" +
e.getClass().getName());
}
}
/**
* Ensures that a prepared statement generated by a proxied connection
* returns the proxied connection from getConnection() [not the physical
* connection].
*/
public void testPreparedStatementConnection() {
try
{
PooledConnection pc = getPooledConnection();
con = pc.getConnection();
PreparedStatement s = con.prepareStatement("select 'x'");
Connection conRetrieved = s.getConnection();
assertTrue(con.getClass().equals(conRetrieved.getClass()));
assertTrue(con.equals(conRetrieved));
}
catch (SQLException e)
{
fail(e.getMessage());
}
}
/**
* Ensures that a callable statement generated by a proxied connection
* returns the proxied connection from getConnection() [not the physical
* connection].
*/
public void testCallableStatementConnection() {
try
{
PooledConnection pc = getPooledConnection();
con = pc.getConnection();
CallableStatement s = con.prepareCall("select 'x'");
Connection conRetrieved = s.getConnection();
assertTrue(con.getClass().equals(conRetrieved.getClass()));
assertTrue(con.equals(conRetrieved));
}
catch (SQLException e)
{
fail(e.getMessage());
}
}
/**
* Ensure that a statement created from a pool can be used
* like any other statement in regard to pg extensions.
*/
public void testStatementsProxyPGStatement() {
try
{
PooledConnection pc = getPooledConnection();
con = pc.getConnection();
Statement s = con.createStatement();
boolean b = ((org.postgresql.PGStatement)s).isUseServerPrepare();
PreparedStatement ps = con.prepareStatement("select 'x'");
b = ((org.postgresql.PGStatement)ps).isUseServerPrepare();
CallableStatement cs = con.prepareCall("select 'x'");
b = ((org.postgresql.PGStatement)cs).isUseServerPrepare();
}
catch (SQLException e)
{
fail(e.getMessage());
}
}
/**
* Helper class to remove a listener during event dispatching.
*/
private class RemoveClose implements ConnectionEventListener
{
public void connectionClosed(ConnectionEvent event)
{
((PooledConnection)event.getSource()).removeConnectionEventListener(this);
}
public void connectionErrorOccurred(ConnectionEvent event)
{
((PooledConnection)event.getSource()).removeConnectionEventListener(this);
}
}
/**
* Helper class that implements the event listener interface, and
* counts the number of events it sees.
*/
private class CountClose implements ConnectionEventListener
{
private int count = 0, errorCount = 0;
public void connectionClosed(ConnectionEvent event)
{
count++;
}
public void connectionErrorOccurred(ConnectionEvent event)
{
errorCount++;
}
public int getCount()
{
return count;
}
public int getErrorCount()
{
return errorCount;
}
public void clear()
{
count = errorCount = 0;
}
}
public void testSerializable() throws IOException, ClassNotFoundException
{
ConnectionPool pool = new ConnectionPool();
pool.setDefaultAutoCommit(false);
pool.setServerName("db.myhost.com");
pool.setDatabaseName("mydb");
pool.setUser("user");
pool.setPassword("pass");
pool.setPortNumber(1111);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(pool);
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bais);
ConnectionPool pool2 = (ConnectionPool)ois.readObject();
assertEquals(pool.isDefaultAutoCommit(), pool2.isDefaultAutoCommit());
assertEquals(pool.getServerName(), pool2.getServerName());
assertEquals(pool.getDatabaseName(), pool2.getDatabaseName());
assertEquals(pool.getUser(), pool2.getUser());
assertEquals(pool.getPassword(), pool2.getPassword());
assertEquals(pool.getPortNumber(), pool2.getPortNumber());
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc2/optional/OptionalTestSuite.java 0000664 0000000 0000000 00000002020 12050675701 0030716 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc2.optional;
import junit.framework.TestSuite;
/**
* Test suite for the JDBC 2.0 Optional Package implementation. This
* includes the DataSource, ConnectionPoolDataSource, and
* PooledConnection implementations.
*
* @author Aaron Mulder (ammulder@chariotsolutions.com)
*/
public class OptionalTestSuite extends TestSuite
{
/**
* Gets the test suite for the entire JDBC 2.0 Optional Package
* implementation.
*/
public static TestSuite suite() throws Exception
{
Class.forName("org.postgresql.Driver");
TestSuite suite = new TestSuite();
suite.addTestSuite(SimpleDataSourceTest.class);
suite.addTestSuite(ConnectionPoolTest.class);
suite.addTestSuite(PoolingDataSourceTest.class);
return suite;
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc2/optional/PoolingDataSourceTest.java 0000664 0000000 0000000 00000007762 12050675701 0031523 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc2.optional;
import java.sql.*;
import org.postgresql.test.TestUtil;
import org.postgresql.jdbc2.optional.PoolingDataSource;
import org.postgresql.ds.common.BaseDataSource;
/**
* Minimal tests for pooling DataSource. Needs many more.
*
* @author Aaron Mulder (ammulder@chariotsolutions.com)
*/
public class PoolingDataSourceTest extends BaseDataSourceTest
{
private final static String DS_NAME = "JDBC 2 SE Test DataSource";
/**
* Constructor required by JUnit
*/
public PoolingDataSourceTest(String name)
{
super(name);
}
protected void tearDown() throws Exception
{
if (bds instanceof PoolingDataSource)
{
((PoolingDataSource) bds).close();
}
super.tearDown();
}
/**
* Creates and configures a new SimpleDataSource.
*/
protected void initializeDataSource()
{
if (bds == null)
{
bds = new PoolingDataSource();
setupDataSource(bds);
((PoolingDataSource) bds).setDataSourceName(DS_NAME);
((PoolingDataSource) bds).setInitialConnections(2);
((PoolingDataSource) bds).setMaxConnections(10);
}
}
/**
* In this case, we *do* want it to be pooled.
*/
public void testNotPooledConnection() throws SQLException
{
con = getDataSourceConnection();
String name = con.toString();
con.close();
con = getDataSourceConnection();
String name2 = con.toString();
con.close();
assertTrue("Pooled DS doesn't appear to be pooling connections!", name.equals(name2));
}
/**
* In this case, the desired behavior is dereferencing.
*/
protected void compareJndiDataSource(BaseDataSource oldbds, BaseDataSource bds)
{
assertTrue("DataSource was serialized or recreated, should have been dereferenced", bds == oldbds);
}
/**
* Check that 2 DS instances can't use the same name.
*/
public void testCantReuseName()
{
initializeDataSource();
PoolingDataSource pds = new PoolingDataSource();
try
{
pds.setDataSourceName(DS_NAME);
fail("Should have denied 2nd DataSource with same name");
}
catch (IllegalArgumentException e)
{
}
}
/**
* Closing a Connection twice is not an error.
*/
public void testDoubleConnectionClose() throws SQLException
{
con = getDataSourceConnection();
con.close();
con.close();
}
/**
* Closing a Statement twice is not an error.
*/
public void testDoubleStatementClose() throws SQLException
{
con = getDataSourceConnection();
Statement stmt = con.createStatement();
stmt.close();
stmt.close();
con.close();
}
public void testConnectionObjectMethods() throws SQLException
{
con = getDataSourceConnection();
Connection conRef = con;
assertEquals(con, conRef);
int hc1 = con.hashCode();
con.close();
int hc2 = con.hashCode();
assertEquals(con, conRef);
assertEquals(hc1, hc2);
}
public void testStatementObjectMethods() throws SQLException
{
con = getDataSourceConnection();
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery("SELECT 1");
Statement stmtRef = stmt;
assertEquals(stmt, stmtRef);
// Currently we aren't proxying ResultSet, so this doesn't
// work, see Bug #1010542.
// assertEquals(stmt, rs.getStatement());
int hc1 = stmt.hashCode();
stmt.close();
int hc2 = stmt.hashCode();
assertEquals(stmt, stmtRef);
assertEquals(hc1, hc2);
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc2/optional/SimpleDataSourceTest.java 0000664 0000000 0000000 00000001703 12050675701 0031332 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc2.optional;
import org.postgresql.test.TestUtil;
import org.postgresql.jdbc2.optional.SimpleDataSource;
/**
* Performs the basic tests defined in the superclass. Just adds the
* configuration logic.
*
* @author Aaron Mulder (ammulder@chariotsolutions.com)
*/
public class SimpleDataSourceTest extends BaseDataSourceTest
{
/**
* Constructor required by JUnit
*/
public SimpleDataSourceTest(String name)
{
super(name);
}
/**
* Creates and configures a new SimpleDataSource.
*/
protected void initializeDataSource()
{
if (bds == null)
{
bds = new SimpleDataSource();
setupDataSource(bds);
}
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc3/ 0000775 0000000 0000000 00000000000 12050675701 0022576 5 ustar 00root root 0000000 0000000 postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc3/DatabaseMetaDataTest.java 0000664 0000000 0000000 00000003322 12050675701 0027406 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2008-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc3;
import org.postgresql.test.TestUtil;
import junit.framework.TestCase;
import java.sql.*;
public class DatabaseMetaDataTest extends TestCase
{
private Connection _conn;
public DatabaseMetaDataTest(String name)
{
super(name);
}
protected void setUp() throws Exception
{
_conn = TestUtil.openDB();
if (TestUtil.haveMinimumServerVersion(_conn, "7.3")) {
Statement stmt = _conn.createStatement();
stmt.execute("CREATE DOMAIN mydom AS int");
stmt.execute("CREATE TABLE domtab (a mydom)");
}
}
protected void tearDown() throws Exception
{
if (TestUtil.haveMinimumServerVersion(_conn, "7.3")) {
Statement stmt = _conn.createStatement();
stmt.execute("DROP TABLE domtab");
stmt.execute("DROP DOMAIN mydom");
}
TestUtil.closeDB(_conn);
}
public void testGetColumnsForDomain() throws Exception
{
if (!TestUtil.haveMinimumServerVersion(_conn, "7.3"))
return;
DatabaseMetaData dbmd = _conn.getMetaData();
ResultSet rs = dbmd.getColumns("%","%","domtab", "%");
assertTrue( rs.next() );
assertEquals("a", rs.getString("COLUMN_NAME"));
assertEquals(Types.DISTINCT, rs.getInt("DATA_TYPE"));
assertEquals("mydom", rs.getString("TYPE_NAME"));
assertEquals(Types.INTEGER, rs.getInt("SOURCE_DATA_TYPE"));
assertTrue( !rs.next() );
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc3/GeneratedKeysTest.java 0000664 0000000 0000000 00000020143 12050675701 0027033 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2008-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc3;
import java.sql.*;
import junit.framework.TestCase;
import org.postgresql.test.TestUtil;
public class GeneratedKeysTest extends TestCase {
private Connection _conn;
public GeneratedKeysTest(String name) throws Exception {
super(name);
}
protected void setUp() throws Exception {
_conn = TestUtil.openDB();
Statement stmt = _conn.createStatement();
stmt.execute("CREATE TEMP TABLE genkeys(a serial, b text, c int)");
stmt.close();
}
protected void tearDown() throws SQLException {
Statement stmt = _conn.createStatement();
stmt.execute("DROP TABLE genkeys");
stmt.close();
TestUtil.closeDB(_conn);
}
public void testExecuteUpdateAllColumns() throws SQLException
{
Statement stmt = _conn.createStatement();
int count = stmt.executeUpdate("INSERT INTO genkeys VALUES (1, 'a', 2)", Statement.RETURN_GENERATED_KEYS);
assertEquals(1, count);
ResultSet rs = stmt.getGeneratedKeys();
assertTrue(rs.next());
assertEquals(1, rs.getInt(1));
assertEquals("a", rs.getString(2));
assertEquals(2, rs.getInt(3));
assertEquals(1, rs.getInt("a"));
assertEquals("a", rs.getString("b"));
assertEquals(2, rs.getInt("c"));
assertTrue(!rs.next());
}
public void testStatementUpdateCount() throws SQLException
{
Statement stmt = _conn.createStatement();
stmt.executeUpdate("INSERT INTO genkeys VALUES (1, 'a', 2)", Statement.RETURN_GENERATED_KEYS);
assertEquals(1, stmt.getUpdateCount());
assertNull(stmt.getResultSet());
assertTrue(!stmt.getMoreResults());
}
public void testCloseStatementClosesRS() throws SQLException
{
Statement stmt = _conn.createStatement();
stmt.executeUpdate("INSERT INTO genkeys VALUES (1, 'a', 2)", Statement.RETURN_GENERATED_KEYS);
ResultSet rs = stmt.getGeneratedKeys();
stmt.close();
try {
rs.next();
fail("Can't operate on a closed result set.");
} catch (SQLException sqle) {}
}
public void testReturningWithTrailingSemicolon() throws SQLException
{
Statement stmt = _conn.createStatement();
stmt.executeUpdate("INSERT INTO genkeys VALUES (1, 'a', 2); ", Statement.RETURN_GENERATED_KEYS);
ResultSet rs = stmt.getGeneratedKeys();
assertTrue(rs.next());
assertEquals("a", rs.getString(2));
assertTrue(!rs.next());
}
public void testEmptyRSWithoutReturning() throws SQLException
{
Statement stmt = _conn.createStatement();
int count = stmt.executeUpdate("INSERT INTO genkeys VALUES (1, 'a', 2); ", Statement.NO_GENERATED_KEYS);
assertEquals(1, count);
ResultSet rs = stmt.getGeneratedKeys();
assertTrue(!rs.next());
}
public void testColumnsByName() throws SQLException
{
Statement stmt = _conn.createStatement();
int count = stmt.executeUpdate("INSERT INTO genkeys VALUES (1, 'a', 2); ", new String[]{"c","a"});
assertEquals(1, count);
ResultSet rs = stmt.getGeneratedKeys();
assertTrue(rs.next());
assertEquals(2, rs.getInt(1));
assertEquals(1, rs.getInt(2));
assertEquals(1, rs.getInt("a"));
assertEquals(2, rs.getInt("c"));
assertTrue(!rs.next());
}
public void testMultipleRows() throws SQLException
{
Statement stmt = _conn.createStatement();
int count = stmt.executeUpdate("INSERT INTO genkeys VALUES (1, 'a', 2), (3, 'b', 4); ", new String[]{"c"});
assertEquals(2, count);
ResultSet rs = stmt.getGeneratedKeys();
assertTrue(rs.next());
assertEquals(2, rs.getInt(1));
assertTrue(rs.next());
assertEquals(4, rs.getInt(1));
assertTrue(!rs.next());
}
public void testSerialWorks() throws SQLException
{
Statement stmt = _conn.createStatement();
int count = stmt.executeUpdate("INSERT INTO genkeys (b,c) VALUES ('a', 2), ('b', 4); ", new String[]{"a"});
assertEquals(2, count);
ResultSet rs = stmt.getGeneratedKeys();
assertTrue(rs.next());
assertEquals(1, rs.getInt(1));
assertTrue(rs.next());
assertEquals(2, rs.getInt(1));
assertTrue(!rs.next());
}
public void testUpdate() throws SQLException
{
Statement stmt = _conn.createStatement();
stmt.executeUpdate("INSERT INTO genkeys VALUES (1, 'a', 2)");
stmt.executeUpdate("INSERT INTO genkeys VALUES (2, 'b', 4)");
stmt.executeUpdate("UPDATE genkeys SET c=3 WHERE a = 1", new String[]{"c", "b"});
ResultSet rs = stmt.getGeneratedKeys();
assertTrue(rs.next());
assertEquals(3, rs.getInt(1));
assertEquals("a", rs.getString(2));
assertTrue(!rs.next());
}
public void testDelete() throws SQLException
{
Statement stmt = _conn.createStatement();
stmt.executeUpdate("INSERT INTO genkeys VALUES (1, 'a', 2)");
stmt.executeUpdate("INSERT INTO genkeys VALUES (2, 'b', 4)");
stmt.executeUpdate("DELETE FROM genkeys WHERE a = 1", new String[]{"c", "b"});
ResultSet rs = stmt.getGeneratedKeys();
assertTrue(rs.next());
assertEquals(2, rs.getInt(1));
assertEquals("a", rs.getString(2));
assertTrue(!rs.next());
}
public void testPSUpdate() throws SQLException
{
Statement stmt = _conn.createStatement();
stmt.executeUpdate("INSERT INTO genkeys VALUES (1, 'a', 2)");
stmt.executeUpdate("INSERT INTO genkeys VALUES (2, 'b', 4)");
stmt.close();
PreparedStatement ps = _conn.prepareStatement("UPDATE genkeys SET c=? WHERE a = ?", new String[]{"c", "b"});
ps.setInt(1,3);
ps.setInt(2,1);
assertEquals(1, ps.executeUpdate());
ResultSet rs = ps.getGeneratedKeys();
assertTrue(rs.next());
assertEquals(3, rs.getInt(1));
assertEquals("a", rs.getString(2));
assertTrue(!rs.next());
}
public void testPSDelete() throws SQLException
{
Statement stmt = _conn.createStatement();
stmt.executeUpdate("INSERT INTO genkeys VALUES (1, 'a', 2)");
stmt.executeUpdate("INSERT INTO genkeys VALUES (2, 'b', 4)");
stmt.close();
PreparedStatement ps = _conn.prepareStatement("DELETE FROM genkeys WHERE a = ?", new String[]{"c", "b"});
ps.setInt(1,1);
assertEquals(1, ps.executeUpdate());
ResultSet rs = ps.getGeneratedKeys();
assertTrue(rs.next());
assertEquals(2, rs.getInt(1));
assertEquals("a", rs.getString(2));
assertTrue(!rs.next());
ps.setInt(1,2);
assertEquals(1, ps.executeUpdate());
rs = ps.getGeneratedKeys();
assertTrue(rs.next());
assertEquals(4, rs.getInt(1));
assertEquals("b", rs.getString(2));
assertTrue(!rs.next());
}
public void testGeneratedKeysCleared() throws SQLException {
Statement stmt = _conn.createStatement();
stmt.executeUpdate("INSERT INTO genkeys VALUES (1, 'a', 2); ", Statement.RETURN_GENERATED_KEYS);
ResultSet rs = stmt.getGeneratedKeys();
assertTrue(rs.next());
stmt.executeUpdate("INSERT INTO genkeys VALUES (2, 'b', 3)");
rs = stmt.getGeneratedKeys();
assertTrue(!rs.next());
}
public void testBatchGeneratedKeys() throws SQLException {
PreparedStatement ps = _conn.prepareStatement("INSERT INTO genkeys(c) VALUES (?)", Statement.RETURN_GENERATED_KEYS);
ps.setInt(1,4);
ps.addBatch();
ps.setInt(1,7);
ps.addBatch();
ps.executeBatch();
ResultSet rs = ps.getGeneratedKeys();
assertTrue(rs.next());
assertEquals(1, rs.getInt("a"));
assertTrue(rs.next());
assertEquals(2, rs.getInt("a"));
assertTrue(!rs.next());
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc3/Jdbc3BlobTest.java 0000664 0000000 0000000 00000020313 12050675701 0026024 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2005-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc3;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.sql.Blob;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Arrays;
import junit.framework.TestCase;
import org.postgresql.test.TestUtil;
/**
* @author Michael Barker
*
*/
public class Jdbc3BlobTest extends TestCase
{
Connection _conn;
private final static String TABLE = "blobtest";
private final static String INSERT = "INSERT INTO " + TABLE + " VALUES (1, lo_creat(-1))";
private final static String SELECT = "SELECT ID, DATA FROM " + TABLE + " WHERE ID = 1";
public Jdbc3BlobTest(String name)
{
super(name);
}
protected void setUp() throws Exception
{
_conn = TestUtil.openDB();
TestUtil.createTable(_conn, TABLE, "ID INT PRIMARY KEY, DATA OID");
_conn.setAutoCommit(false);
}
protected void tearDown() throws SQLException
{
_conn.setAutoCommit(true);
TestUtil.dropTable(_conn, TABLE);
TestUtil.closeDB(_conn);
}
/**
* Test the writing and reading of a single byte.
*
* @throws SQLException
*/
public void test1Byte() throws SQLException
{
byte[] data = { (byte) 'a' };
readWrite(data);
}
/**
* Test the writing and reading of a few bytes.
* @throws SQLException
*/
public void testManyBytes() throws SQLException
{
byte[] data = "aaaaaaaaaa".getBytes();
readWrite(data);
}
/**
* Test writing a single byte with an offset.
*
* @throws SQLException
*/
public void test1ByteOffset() throws SQLException
{
byte[] data = { (byte) 'a' };
readWrite(10, data);
}
/**
* Test the writing and reading of a few bytes with an offset.
*
* @throws SQLException
*/
public void testManyBytesOffset() throws SQLException
{
byte[] data = "aaaaaaaaaa".getBytes();
readWrite(10, data);
}
/**
* Tests all of the byte values from 0 - 255.
*
* @throws SQLException
*/
public void testAllBytes() throws SQLException
{
byte[] data = new byte[256];
for (int i = 0; i < data.length; i++)
{
data[i] = (byte) i;
}
readWrite(data);
}
public void testTruncate() throws SQLException
{
if (!TestUtil.haveMinimumServerVersion(_conn, "8.3"))
return;
byte data[] = new byte[100];
for (byte i=0; i^ ? ");
ParameterMetaData pmd = pstmt.getParameterMetaData();
assertEquals(3, pmd.getParameterCount());
assertEquals(Types.DOUBLE, pmd.getParameterType(1));
assertEquals("float8", pmd.getParameterTypeName(1));
assertEquals("java.lang.Double", pmd.getParameterClassName(1));
assertEquals(Types.VARCHAR, pmd.getParameterType(2));
assertEquals("text", pmd.getParameterTypeName(2));
assertEquals("java.lang.String", pmd.getParameterClassName(2));
assertEquals(Types.OTHER, pmd.getParameterType(3));
assertEquals("point", pmd.getParameterTypeName(3));
assertEquals("org.postgresql.geometric.PGpoint", pmd.getParameterClassName(3));
pstmt.close();
}
public void testFailsOnBadIndex() throws SQLException {
if (!TestUtil.isProtocolVersion(_conn, 3))
return;
PreparedStatement pstmt = _conn.prepareStatement("SELECT a FROM parametertest WHERE b = ? AND c = ?");
ParameterMetaData pmd = pstmt.getParameterMetaData();
try {
pmd.getParameterType(0);
fail("Can't get parameter for index < 1.");
} catch (SQLException sqle) { }
try {
pmd.getParameterType(3);
fail("Can't get parameter for index 3 with only two parameters.");
} catch (SQLException sqle) { }
}
// Make sure we work when mashing two queries into a single statement.
public void testMultiStatement() throws SQLException {
if (!TestUtil.isProtocolVersion(_conn, 3))
return;
PreparedStatement pstmt = _conn.prepareStatement("SELECT a FROM parametertest WHERE b = ? AND c = ? ; SELECT b FROM parametertest WHERE a = ?");
ParameterMetaData pmd = pstmt.getParameterMetaData();
assertEquals(3, pmd.getParameterCount());
assertEquals(Types.DOUBLE, pmd.getParameterType(1));
assertEquals("float8", pmd.getParameterTypeName(1));
assertEquals(Types.VARCHAR, pmd.getParameterType(2));
assertEquals("text", pmd.getParameterTypeName(2));
assertEquals(Types.INTEGER, pmd.getParameterType(3));
assertEquals("int4", pmd.getParameterTypeName(3));
pstmt.close();
}
// Here we test that we can legally change the resolved type
// from text to varchar with the complicating factor that there
// is also an unknown parameter.
//
public void testTypeChangeWithUnknown() throws SQLException {
if (!TestUtil.isProtocolVersion(_conn, 3))
return;
PreparedStatement pstmt = _conn.prepareStatement("SELECT a FROM parametertest WHERE c = ? AND e = ?");
ParameterMetaData pmd = pstmt.getParameterMetaData();
pstmt.setString(1, "Hi");
pstmt.setTimestamp(2, new Timestamp(0L));
ResultSet rs = pstmt.executeQuery();
rs.close();
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc3/ResultSetTest.java 0000664 0000000 0000000 00000003122 12050675701 0026231 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc3;
import java.sql.*;
import junit.framework.TestCase;
import org.postgresql.test.TestUtil;
public class ResultSetTest extends TestCase {
private Connection _conn;
public ResultSetTest(String name) {
super(name);
}
protected void setUp() throws Exception {
_conn = TestUtil.openDB();
Statement stmt = _conn.createStatement();
stmt.execute("CREATE TEMP TABLE hold(a int)");
stmt.execute("INSERT INTO hold VALUES (1)");
stmt.execute("INSERT INTO hold VALUES (2)");
stmt.close();
}
protected void tearDown() throws SQLException {
Statement stmt = _conn.createStatement();
stmt.execute("DROP TABLE hold");
stmt.close();
TestUtil.closeDB(_conn);
}
public void testHoldableResultSet() throws SQLException {
Statement stmt = _conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, ResultSet.HOLD_CURSORS_OVER_COMMIT);
_conn.setAutoCommit(false);
stmt.setFetchSize(1);
ResultSet rs = stmt.executeQuery("SELECT a FROM hold ORDER BY a");
assertTrue(rs.next());
assertEquals(1, rs.getInt(1));
_conn.commit();
assertTrue(rs.next());
assertEquals(2, rs.getInt(1));
assertTrue(!rs.next());
rs.close();
stmt.close();
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc3/SendRecvBufferSizeTest.java 0000664 0000000 0000000 00000002526 12050675701 0030004 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc3;
import java.sql.*;
import junit.framework.TestCase;
import org.postgresql.jdbc2.AbstractJdbc2Connection;
import org.postgresql.test.TestUtil;
public class SendRecvBufferSizeTest extends TestCase {
private Connection _conn;
public SendRecvBufferSizeTest(String name) {
super(name);
}
protected void setUp() throws Exception {
System.setProperty("sendBufferSize", "1024");
System.setProperty("receiveBufferSize","1024");
_conn = TestUtil.openDB();
Statement stmt = _conn.createStatement();
stmt.execute("CREATE TEMP TABLE hold(a int)");
stmt.execute("INSERT INTO hold VALUES (1)");
stmt.execute("INSERT INTO hold VALUES (2)");
stmt.close();
}
protected void tearDown() throws SQLException {
Statement stmt = _conn.createStatement();
stmt.execute("DROP TABLE hold");
stmt.close();
TestUtil.closeDB(_conn);
}
// dummy test
public void testSelect() throws SQLException {
Statement stmt = _conn.createStatement();
stmt.execute("select * from hold");
stmt.close();
}
} postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc3/TypesTest.java 0000664 0000000 0000000 00000006302 12050675701 0025406 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc3;
import java.sql.*;
import junit.framework.TestCase;
import org.postgresql.test.TestUtil;
public class TypesTest extends TestCase {
private Connection _conn;
public TypesTest(String name) {
super(name);
try
{
Class.forName("org.postgresql.Driver");
}
catch (Exception ex )
{
}
}
protected void setUp() throws Exception {
_conn = TestUtil.openDB();
Statement stmt = _conn.createStatement();
stmt.execute("CREATE OR REPLACE FUNCTION return_bool(boolean) RETURNS boolean AS 'BEGIN RETURN $1; END;' LANGUAGE plpgsql");
stmt.close();
}
protected void tearDown() throws SQLException {
Statement stmt = _conn.createStatement();
stmt.execute("DROP FUNCTION return_bool(boolean)");
stmt.close();
TestUtil.closeDB(_conn);
}
public void testPreparedBoolean() throws SQLException {
PreparedStatement pstmt = _conn.prepareStatement("SELECT ?,?,?,?");
pstmt.setNull(1, Types.BOOLEAN);
pstmt.setObject(2, null, Types.BOOLEAN);
pstmt.setBoolean(3, true);
pstmt.setObject(4, Boolean.FALSE);
ResultSet rs = pstmt.executeQuery();
assertTrue(rs.next());
assertTrue(!rs.getBoolean(1));
assertTrue(rs.wasNull());
assertNull(rs.getObject(2));
assertTrue(rs.getBoolean(3));
// Only the V3 protocol return will be strongly typed.
// The V2 path will return a String because it doesn't know
// any better.
if (TestUtil.isProtocolVersion(_conn, 3))
{
assertTrue(!((Boolean)rs.getObject(4)).booleanValue());
}
}
public void testPreparedByte() throws SQLException {
PreparedStatement pstmt = _conn.prepareStatement("SELECT ?,?");
pstmt.setByte(1, (byte)1);
pstmt.setObject(2, new Byte((byte)2));
ResultSet rs = pstmt.executeQuery();
assertTrue(rs.next());
assertEquals((byte)1, rs.getByte(1));
assertFalse(rs.wasNull());
assertEquals((byte)2, rs.getByte(2));
assertFalse(rs.wasNull());
rs.close();
pstmt.close();
}
public void testCallableBoolean() throws SQLException {
CallableStatement cs = _conn.prepareCall("{? = call return_bool(?)}");
cs.registerOutParameter(1, Types.BOOLEAN);
cs.setBoolean(2, true);
cs.execute();
assertEquals(true, cs.getBoolean(1));
cs.close();
}
public void testUnknownType() throws SQLException {
Statement stmt = _conn.createStatement();
ResultSet rs = stmt.executeQuery("select 'foo1' as icon1, 'foo2' as icon2 ");
assertTrue(rs.next());
assertTrue("failed returned [" + rs.getString("icon1")+"]",rs.getString("icon1").equalsIgnoreCase("foo1"));
assertTrue("failed returned [" + rs.getString("icon2")+"]",rs.getString("icon2").equalsIgnoreCase("foo2"));
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc4/ 0000775 0000000 0000000 00000000000 12050675701 0022577 5 ustar 00root root 0000000 0000000 postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc4/ArrayTest.java 0000664 0000000 0000000 00000013505 12050675701 0025364 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2007-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc4;
import java.sql.*;
import junit.framework.TestCase;
import org.postgresql.test.TestUtil;
public class ArrayTest extends TestCase {
private Connection _conn;
public ArrayTest(String name) {
super(name);
}
protected void setUp() throws Exception {
_conn = TestUtil.openDB();
TestUtil.createTable(_conn, "arrtest", "intarr int[], decarr decimal(2,1)[], strarr text[]");
}
protected void tearDown() throws SQLException {
TestUtil.dropTable(_conn, "arrtest");
TestUtil.closeDB(_conn);
}
public void testCreateArrayOfInt() throws SQLException {
PreparedStatement pstmt = _conn.prepareStatement("SELECT ?::int[]");
Integer in[] = new Integer[3];
in[0] = 0;
in[1] = -1;
in[2] = 2;
pstmt.setArray(1, _conn.createArrayOf("int4", in));
ResultSet rs = pstmt.executeQuery();
assertTrue(rs.next());
Array arr = rs.getArray(1);
Integer out[] = (Integer [])arr.getArray();
assertEquals(3, out.length);
assertEquals(0, out[0].intValue());
assertEquals(-1, out[1].intValue());
assertEquals(2, out[2].intValue());
}
public void testCreateArrayOfMultiString() throws SQLException {
PreparedStatement pstmt = _conn.prepareStatement("SELECT ?::text[]");
String in[][] = new String[2][2];
in[0][0] = "a";
in[0][1] = "";
in[1][0] = "\\";
in[1][1] = "\"\\'z";
pstmt.setArray(1, _conn.createArrayOf("text", in));
ResultSet rs = pstmt.executeQuery();
assertTrue(rs.next());
Array arr = rs.getArray(1);
String out[][] = (String [][])arr.getArray();
assertEquals(2, out.length);
assertEquals(2, out[0].length);
assertEquals("a", out[0][0]);
assertEquals("", out[0][1]);
assertEquals("\\", out[1][0]);
assertEquals("\"\\'z", out[1][1]);
}
public void testCreateArrayOfNull() throws SQLException {
if (!TestUtil.haveMinimumServerVersion(_conn, "8.2"))
return;
String sql = "SELECT ?";
// We must provide the type information for V2 protocol
if (TestUtil.isProtocolVersion(_conn, 2)) {
sql = "SELECT ?::int8[]";
}
PreparedStatement pstmt = _conn.prepareStatement(sql);
String in[] = new String[2];
in[0] = null;
in[1] = null;
pstmt.setArray(1, _conn.createArrayOf("int8", in));
ResultSet rs = pstmt.executeQuery();
assertTrue(rs.next());
Array arr = rs.getArray(1);
Long out[] = (Long [])arr.getArray();
assertEquals(2, out.length);
assertNull(out[0]);
assertNull(out[1]);
}
public void testCreateEmptyArrayOfIntViaAlias() throws SQLException {
PreparedStatement pstmt = _conn.prepareStatement("SELECT ?::int[]");
Integer in[] = new Integer[0];
pstmt.setArray(1, _conn.createArrayOf("integer", in));
ResultSet rs = pstmt.executeQuery();
assertTrue(rs.next());
Array arr = rs.getArray(1);
Integer out[] = (Integer [])arr.getArray();
assertEquals(0, out.length);
ResultSet arrRs = arr.getResultSet();
assertFalse(arrRs.next());
}
public void testCreateArrayWithoutServer() throws SQLException {
String in[][] = new String[2][2];
in[0][0] = "a";
in[0][1] = "";
in[1][0] = "\\";
in[1][1] = "\"\\'z";
Array arr = _conn.createArrayOf("varchar", in);
String out[][] = (String [][])arr.getArray();
assertEquals(2, out.length);
assertEquals(2, out[0].length);
assertEquals("a", out[0][0]);
assertEquals("", out[0][1]);
assertEquals("\\", out[1][0]);
assertEquals("\"\\'z", out[1][1]);
}
public void testCreatePrimitiveArray() throws SQLException {
double in[][] = new double[2][2];
in[0][0] = 3.5;
in[0][1] = -4.5;
in[1][0] = 10.0/3;
in[1][1] = 77;
Array arr = _conn.createArrayOf("float8", in);
Double out[][] = (Double [][])arr.getArray();
assertEquals(2, out.length);
assertEquals(2, out[0].length);
assertEquals(3.5, out[0][0], 0.00001);
assertEquals(-4.5, out[0][1], 0.00001);
assertEquals(10.0/3, out[1][0], 0.00001);
assertEquals(77, out[1][1], 0.00001);
}
public void testSetObjectFromJavaArray() throws SQLException {
String[] strArray = new String[]{"a","b","c"};
PreparedStatement pstmt = _conn.prepareStatement("INSERT INTO arrtest(strarr) VALUES (?)");
// Incorrect, but commonly attempted by many ORMs:
try {
pstmt.setObject(1, strArray, Types.ARRAY);
pstmt.executeUpdate();
fail("setObject() with a Java array parameter and Types.ARRAY shouldn't succeed");
} catch (org.postgresql.util.PSQLException ex) {
// Expected failure.
}
// Also incorrect, but commonly attempted by many ORMs:
try {
pstmt.setObject(1, strArray);
pstmt.executeUpdate();
fail("setObject() with a Java array parameter and no Types argument shouldn't succeed");
} catch (org.postgresql.util.PSQLException ex) {
// Expected failure.
}
// Correct way, though the use of "text" as a type is non-portable.
// Only supported for JDK 1.6 and JDBC4
Array sqlArray = _conn.createArrayOf("text", strArray);
pstmt.setArray(1, sqlArray);
pstmt.executeUpdate();
pstmt.close();
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc4/ConnectionTest.java 0000664 0000000 0000000 00000003567 12050675701 0026414 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2010-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc4;
import java.sql.*;
import java.util.Properties;
import junit.framework.TestCase;
import org.postgresql.test.TestUtil;
public class ConnectionTest extends TestCase {
private Connection _conn;
public ConnectionTest(String name) {
super(name);
}
protected void setUp() throws Exception {
_conn = TestUtil.openDB();
}
protected void tearDown() throws SQLException {
TestUtil.closeDB(_conn);
}
private String getAppName() throws SQLException {
Statement stmt = _conn.createStatement();
ResultSet rs = stmt.executeQuery("SHOW application_name");
rs.next();
String appName = rs.getString(1);
rs.close();
stmt.close();
return appName;
}
public void testSetAppName() throws SQLException
{
if (!TestUtil.haveMinimumServerVersion(_conn, "9.0"))
return;
_conn.setClientInfo("ApplicationName", "my app");
assertEquals("my app", getAppName());
assertEquals("my app", _conn.getClientInfo("ApplicationName"));
assertEquals("my app", _conn.getClientInfo().getProperty("ApplicationName"));
}
public void testSetAppNameProps() throws SQLException
{
if (!TestUtil.haveMinimumServerVersion(_conn, "9.0"))
return;
Properties props = new Properties();
props.put("ApplicationName", "my app");
_conn.setClientInfo(props);
assertEquals("my app", getAppName());
assertEquals("my app", _conn.getClientInfo("ApplicationName"));
assertEquals("my app", _conn.getClientInfo().getProperty("ApplicationName"));
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc4/DatabaseMetaDataTest.java 0000664 0000000 0000000 00000004477 12050675701 0027423 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2007-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc4;
import org.postgresql.test.TestUtil;
import junit.framework.TestCase;
import java.sql.*;
public class DatabaseMetaDataTest extends TestCase
{
private Connection _conn;
public DatabaseMetaDataTest(String name)
{
super(name);
}
protected void setUp() throws Exception
{
_conn = TestUtil.openDB();
TestUtil.dropSequence(_conn, "sercoltest_a_seq");
TestUtil.createTable(_conn, "sercoltest", "a serial, b int");
}
protected void tearDown() throws Exception
{
TestUtil.dropSequence(_conn, "sercoltest_a_seq");
TestUtil.dropTable(_conn, "sercoltest");
TestUtil.closeDB( _conn );
}
public void testGetClientInfoProperties() throws Exception
{
DatabaseMetaData dbmd = _conn.getMetaData();
ResultSet rs = dbmd.getClientInfoProperties();
if (!TestUtil.haveMinimumServerVersion(_conn, "9.0")) {
assertTrue( !rs.next() );
return;
}
assertTrue(rs.next());
assertEquals("ApplicationName", rs.getString("NAME"));
}
public void testGetColumnsForAutoIncrement() throws Exception
{
DatabaseMetaData dbmd = _conn.getMetaData();
ResultSet rs = dbmd.getColumns("%","%","sercoltest", "%");
assertTrue( rs.next() );
assertEquals("a", rs.getString("COLUMN_NAME"));
assertEquals("YES", rs.getString("IS_AUTOINCREMENT"));
assertTrue( rs.next() );
assertEquals("b", rs.getString("COLUMN_NAME"));
assertEquals("NO", rs.getString("IS_AUTOINCREMENT"));
assertTrue( !rs.next() );
}
public void testGetSchemas() throws SQLException
{
DatabaseMetaData dbmd = _conn.getMetaData();
ResultSet rs = dbmd.getSchemas("", "publ%");
if (!TestUtil.haveMinimumServerVersion(_conn, "7.3")) {
assertTrue(!rs.next());
return;
}
assertTrue(rs.next());
assertEquals("public", rs.getString("TABLE_SCHEM"));
assertNull(rs.getString("TABLE_CATALOG"));
assertTrue(!rs.next());
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc4/Jdbc4TestSuite.java 0000664 0000000 0000000 00000003313 12050675701 0026242 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2007-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc4;
import junit.framework.TestSuite;
import java.sql.*;
import org.postgresql.test.TestUtil;
/*
* Executes all known tests for JDBC4
*/
public class Jdbc4TestSuite extends TestSuite
{
/*
* The main entry point for JUnit
*/
public static TestSuite suite() throws Exception
{
Class.forName("org.postgresql.Driver");
TestSuite suite = new TestSuite();
suite.addTestSuite(LOBTest.class);
suite.addTestSuite(DatabaseMetaDataTest.class);
suite.addTestSuite(ArrayTest.class);
suite.addTestSuite(ConnectionTest.class);
Connection connection = TestUtil.openDB();
try
{
if (TestUtil.haveMinimumServerVersion(connection, "8.3"))
{
suite.addTestSuite(UUIDTest.class);
if (isXmlEnabled(connection)) {
suite.addTestSuite(XmlTest.class);
}
}
}
finally
{
connection.close();
}
return suite;
}
/**
* Not all servers will have been complied --with-libxml.
*/
private static boolean isXmlEnabled(Connection conn) {
try {
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT 'b'::xml");
rs.close();
stmt.close();
return true;
} catch (SQLException sqle) {
return false;
}
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc4/LOBTest.java 0000664 0000000 0000000 00000002634 12050675701 0024723 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2007-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc4;
import java.sql.*;
import junit.framework.TestCase;
import org.postgresql.test.TestUtil;
public class LOBTest extends TestCase {
private Connection _conn;
public LOBTest(String name) {
super(name);
}
protected void setUp() throws Exception {
_conn = TestUtil.openDB();
Statement stmt = _conn.createStatement();
stmt.execute("CREATE TEMP TABLE lotest(lo oid)");
stmt.execute("INSERT INTO lotest VALUES(lo_creat(-1))");
stmt.close();
}
protected void tearDown() throws SQLException {
Statement stmt = _conn.createStatement();
stmt.execute("DROP TABLE lotest");
stmt.close();
TestUtil.closeDB(_conn);
}
public void testFree() throws SQLException {
_conn.setAutoCommit(false);
Statement stmt = _conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT lo FROM lotest");
assertTrue(rs.next());
Blob blob = rs.getBlob(1);
blob.free();
try {
blob.length();
fail("Should have thrown an Exception because it was freed.");
} catch (SQLException sqle) {
}
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc4/UUIDTest.java 0000664 0000000 0000000 00000003030 12050675701 0025044 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2008-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc4;
import java.sql.*;
import java.util.UUID;
import junit.framework.TestCase;
import org.postgresql.test.TestUtil;
public class UUIDTest extends TestCase {
private Connection _conn;
public UUIDTest(String name) {
super(name);
}
protected void setUp() throws Exception {
_conn = TestUtil.openDB();
Statement stmt = _conn.createStatement();
stmt.execute("CREATE TEMP TABLE uuidtest(id uuid)");
stmt.close();
}
protected void tearDown() throws SQLException {
Statement stmt = _conn.createStatement();
stmt.execute("DROP TABLE uuidtest");
stmt.close();
TestUtil.closeDB(_conn);
}
public void testUUID() throws SQLException {
UUID uuid = UUID.randomUUID();
PreparedStatement ps = _conn.prepareStatement("INSERT INTO uuidtest VALUES (?)");
ps.setObject(1, uuid, Types.OTHER);
ps.executeUpdate();
ps.close();
Statement stmt = _conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT id FROM uuidtest");
assertTrue(rs.next());
UUID uuid2 = (UUID)rs.getObject(1);
assertEquals(uuid, rs.getObject(1));
assertEquals(uuid.toString(), rs.getString(1));
rs.close();
stmt.close();
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/jdbc4/XmlTest.java 0000664 0000000 0000000 00000022347 12050675701 0025052 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2008-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.jdbc4;
import java.sql.*;
import junit.framework.TestCase;
import org.postgresql.test.TestUtil;
import java.io.StringReader;
import java.io.StringWriter;
import java.io.Reader;
import java.io.InputStream;
import java.io.IOException;
import javax.xml.transform.Source;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.sax.SAXSource;
import javax.xml.transform.stream.StreamSource;
import javax.xml.transform.stax.StAXSource;
import org.w3c.dom.Node;
import javax.xml.transform.Transformer;
import javax.xml.transform.ErrorListener;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.TransformerException;
import javax.xml.transform.Result;
import javax.xml.transform.dom.DOMResult;
import javax.xml.transform.sax.SAXResult;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stax.StAXResult;
public class XmlTest extends TestCase {
private Connection _conn;
private final Transformer _xslTransformer;
private final Transformer _identityTransformer;
private final static String _xsl = "B";
private final static String _xmlDocument = "12";
private final static String _xmlFragment = "fg";
public XmlTest(String name) throws Exception {
super(name);
TransformerFactory factory = TransformerFactory.newInstance();
_xslTransformer = factory.newTransformer(new StreamSource(new StringReader(_xsl)));
_xslTransformer.setErrorListener(new Ignorer());
_identityTransformer = factory.newTransformer();
}
protected void setUp() throws Exception {
_conn = TestUtil.openDB();
Statement stmt = _conn.createStatement();
stmt.execute("CREATE TEMP TABLE xmltest(id int primary key, val xml)");
stmt.execute("INSERT INTO xmltest VALUES (1, '" + _xmlDocument + "')");
stmt.execute("INSERT INTO xmltest VALUES (2, '" + _xmlFragment + "')");
stmt.close();
}
protected void tearDown() throws SQLException {
Statement stmt = _conn.createStatement();
stmt.execute("DROP TABLE xmltest");
stmt.close();
TestUtil.closeDB(_conn);
}
private ResultSet getRS() throws SQLException {
Statement stmt = _conn.createStatement();
return stmt.executeQuery("SELECT val FROM xmltest");
}
public void testUpdateRS() throws SQLException {
Statement stmt = _conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
ResultSet rs = stmt.executeQuery("SELECT id, val FROM xmltest");
assertTrue(rs.next());
SQLXML xml = rs.getSQLXML(2);
rs.updateSQLXML(2, xml);
rs.updateRow();
}
public void testDOMParse() throws SQLException {
ResultSet rs = getRS();
assertTrue(rs.next());
SQLXML xml = rs.getSQLXML(1);
DOMSource source = xml.getSource(DOMSource.class);
Node doc = source.getNode();
Node root = doc.getFirstChild();
assertEquals("a", root.getNodeName());
Node first = root.getFirstChild();
assertEquals("b", first.getNodeName());
assertEquals("1", first.getTextContent());
Node last = root.getLastChild();
assertEquals("b", last.getNodeName());
assertEquals("2", last.getTextContent());
assertTrue(rs.next());
try {
xml = rs.getSQLXML(1);
source = xml.getSource(DOMSource.class);
fail("Can't retrieve a fragment.");
} catch (SQLException sqle) {
}
}
private void transform(Source source) throws Exception {
StringWriter writer = new StringWriter();
StreamResult result = new StreamResult(writer);
_xslTransformer.transform(source, result);
assertEquals("B1B2", writer.toString());
}
private void testRead(Class sourceClass) throws Exception
{
ResultSet rs = getRS();
assertTrue(rs.next());
SQLXML xml = rs.getSQLXML(1);
Source source = xml.getSource(sourceClass);
transform(source);
assertTrue(rs.next());
xml = rs.getSQLXML(1);
try {
source = xml.getSource(sourceClass);
transform(source);
fail("Can't transform a fragment.");
} catch (Exception sqle) { }
}
public void testDOMRead() throws Exception
{
testRead(DOMSource.class);
}
public void testSAXRead() throws Exception
{
testRead(SAXSource.class);
}
public void testStAXRead() throws Exception
{
testRead(StAXSource.class);
}
public void testStreamRead() throws Exception
{
testRead(StreamSource.class);
}
private void testWrite(Class resultClass) throws Exception
{
Statement stmt = _conn.createStatement();
stmt.execute("DELETE FROM xmltest");
stmt.close();
PreparedStatement ps = _conn.prepareStatement("INSERT INTO xmltest VALUES (?,?)");
SQLXML xml = _conn.createSQLXML();
Result result = xml.setResult(resultClass);
Source source = new StreamSource(new StringReader(_xmlDocument));
_identityTransformer.transform(source, result);
ps.setInt(1, 1);
ps.setSQLXML(2, xml);
ps.executeUpdate();
ps.close();
ResultSet rs = getRS();
assertTrue(rs.next());
// DOMResults tack on the additional header.
//
String header = "";
if (DOMResult.class.equals(resultClass)) {
header = "";
}
assertEquals(header + _xmlDocument, rs.getString(1));
xml = rs.getSQLXML(1);
assertEquals(header + _xmlDocument, xml.getString());
assertTrue(!rs.next());
}
public void testDomWrite() throws Exception
{
testWrite(DOMResult.class);
}
public void testStAXWrite() throws Exception
{
testWrite(StAXResult.class);
}
public void testStreamWrite() throws Exception
{
testWrite(StreamResult.class);
}
public void testSAXWrite() throws Exception
{
testWrite(SAXResult.class);
}
public void testFree() throws SQLException
{
ResultSet rs = getRS();
assertTrue(rs.next());
SQLXML xml = rs.getSQLXML(1);
xml.free();
xml.free();
try {
xml.getString();
fail("Not freed.");
} catch (SQLException sqle) { }
}
public void testGetObject() throws SQLException
{
ResultSet rs = getRS();
assertTrue(rs.next());
SQLXML xml = (SQLXML)rs.getObject(1);
}
public void testSetNull() throws SQLException
{
Statement stmt = _conn.createStatement();
stmt.execute("DELETE FROM xmltest");
stmt.close();
PreparedStatement ps = _conn.prepareStatement("INSERT INTO xmltest VALUES (?,?)");
ps.setInt(1, 1);
ps.setNull(2, Types.SQLXML);
ps.executeUpdate();
ps.setInt(1, 2);
ps.setObject(2, null, Types.SQLXML);
ps.executeUpdate();
SQLXML xml = _conn.createSQLXML();
xml.setString(null);
ps.setInt(1, 3);
ps.setObject(2, xml);
ps.executeUpdate();
ps.close();
ResultSet rs = getRS();
assertTrue(rs.next());
assertNull(rs.getObject(1));
assertTrue(rs.next());
assertNull(rs.getSQLXML(1));
assertTrue(rs.next());
assertNull(rs.getSQLXML("val"));
assertTrue(!rs.next());
}
public void testEmpty() throws SQLException, IOException {
SQLXML xml = _conn.createSQLXML();
try {
xml.getString();
fail("Cannot retrieve data from an uninitialized object.");
} catch (SQLException sqle) { }
try {
xml.getSource(null);
fail("Cannot retrieve data from an uninitialized object.");
} catch (SQLException sqle) { }
}
public void testDoubleSet() throws SQLException
{
SQLXML xml = _conn.createSQLXML();
xml.setString("");
try {
xml.setString("");
fail("Can't set a value after its been initialized.");
} catch (SQLException sqle) { }
ResultSet rs = getRS();
assertTrue(rs.next());
xml = rs.getSQLXML(1);
try {
xml.setString("");
fail("Can't set a value after its been initialized.");
} catch (SQLException sqle) { }
}
// Don't print warning and errors to System.err, it just
// clutters the display.
static class Ignorer implements ErrorListener {
public void error(TransformerException t) { }
public void fatalError(TransformerException t) { }
public void warning(TransformerException t) { }
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/ssl/ 0000775 0000000 0000000 00000000000 12050675701 0022412 5 ustar 00root root 0000000 0000000 postgresql-jdbc-9.2-1002.src/org/postgresql/test/ssl/SslTest.java 0000664 0000000 0000000 00000042670 12050675701 0024667 0 ustar 00root root 0000000 0000000 package org.postgresql.test.ssl;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Map;
import java.util.Properties;
import java.util.TreeMap;
import junit.framework.TestCase;
import junit.framework.TestSuite;
import org.postgresql.test.TestUtil;
public class SslTest extends TestCase {
/**
* Tries to connect to the database.
* @param connstr Connection string for the database
* @param expected Expected values. the first element is a String holding the expected message of PSQLException
* or null, if no exception is expected, the second indicates weather ssl is to be used (Boolean)
* @throws SQLException
*/
protected void driver(String connstr, Object[] expected) throws SQLException
{
Connection conn = null;
String exmsg = (String)expected[0];
try
{
conn = DriverManager.getConnection(connstr, TestUtil.getUser(), TestUtil.getPassword());
if (exmsg!=null)
{
fail("Exception did not occur: "+exmsg);
}
//
ResultSet rs = conn.createStatement().executeQuery("select ssl_is_used()");
assertTrue(rs.next());
assertEquals("ssl_is_used: ",((Boolean)expected[1]).booleanValue(), rs.getBoolean(1));
conn.close();
}
catch (SQLException ex) {
if (conn!=null) { conn.close(); }
if (exmsg==null)
{ //no exception is excepted
fail("Exception thrown: "+ex.getMessage());
} else {
assertTrue("expected: "+exmsg+" actual: "+ex.getMessage(), ex.getMessage().matches(exmsg));
return;
}
}
}
protected String certdir;
protected String connstr;
protected String sslmode;
protected int protocol;
protected boolean goodclient;
protected boolean goodserver;
protected String prefix;
protected Object[] expected;
private String makeConnStr(String sslmode, boolean goodclient, boolean goodserver, int protocol)
{
return connstr+"&protocolVersion="+protocol+"&sslmode="+sslmode+
"&sslcert="+certdir+"/"+prefix+(goodclient?"goodclient.crt":"badclient.crt")+
"&sslkey="+certdir+"/"+prefix+(goodclient?"goodclient.pk8":"badclient.pk8")+
"&sslrootcert="+certdir+"/"+prefix+(goodserver?"goodroot.crt":"badroot.crt")+
"&loglevel="+TestUtil.getLogLevel();
}
public SslTest(String name, String certdir, String connstr, String sslmode, int protocol, boolean goodclient, boolean goodserver, String prefix, Object[] expected)
{
super(name);
this.certdir = certdir;
this.connstr = connstr;
this.sslmode = sslmode;
this.protocol = protocol;
this.goodclient = goodclient;
this.goodserver = goodserver;
this.prefix = prefix;
this.expected = expected;
}
static TestSuite getSuite(Properties prop, String param)
{
String certdir = prop.getProperty("certdir");
String sconnstr = prop.getProperty(param);
String sprefix = prop.getProperty(param + "prefix");
String[] csslmode = {"disable","allow","prefer","require","verify-ca","verify-full"};
TestSuite suite = new TestSuite();
Map expected = (Map)expectedmap.get(param);
if (expected == null) {;expected = defaultexpected;}
int j=0;
for (int i=0; i _numRead++)
{
throw new IOException("I was told to break on " + _breakOn);
}
return _is.read();
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/util/MiniJndiContext.java 0000664 0000000 0000000 00000013207 12050675701 0026502 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.util;
import java.util.*;
import java.rmi.MarshalledObject;
import java.io.Serializable;
import javax.naming.*;
import javax.naming.spi.ObjectFactory;
/**
* The Context for a trivial JNDI implementation. This is not meant to
* be very useful, beyond testing JNDI features of the connection
* pools. It is not a complete JNDI implementations.
*
* @author Aaron Mulder (ammulder@chariotsolutions.com)
*/
public class MiniJndiContext implements Context
{
private Map map = new HashMap();
public MiniJndiContext()
{
}
public Object lookup(Name name) throws NamingException
{
return lookup(name.get(0));
}
public Object lookup(String name) throws NamingException
{
Object o = map.get(name);
if (o == null)
{
return null;
}
if (o instanceof Reference)
{
Reference ref = (Reference) o;
try
{
Class factoryClass = Class.forName(ref.getFactoryClassName());
ObjectFactory fac = (ObjectFactory) factoryClass.newInstance();
Object result = fac.getObjectInstance(ref, null, this, null);
return result;
}
catch (Exception e)
{
throw new NamingException("Unable to dereference to object: " + e);
}
}
else if (o instanceof MarshalledObject)
{
try
{
Object result = ((MarshalledObject) o).get();
return result;
}
catch (java.io.IOException e)
{
throw new NamingException("Unable to deserialize object: " + e);
}
catch (ClassNotFoundException e)
{
throw new NamingException("Unable to deserialize object: " + e);
}
}
else
{
throw new NamingException("JNDI Object is neither Referenceable nor Serializable");
}
}
public void bind(Name name, Object obj) throws NamingException
{
rebind(name.get(0), obj);
}
public void bind(String name, Object obj) throws NamingException
{
rebind(name, obj);
}
public void rebind(Name name, Object obj) throws NamingException
{
rebind(name.get(0), obj);
}
public void rebind(String name, Object obj) throws NamingException
{
if (obj instanceof Referenceable)
{
Reference ref = ((Referenceable) obj).getReference();
map.put(name, ref);
}
else if (obj instanceof Serializable)
{
try
{
MarshalledObject mo = new MarshalledObject(obj);
map.put(name, mo);
}
catch (java.io.IOException e)
{
throw new NamingException("Unable to serialize object to JNDI: " + e);
}
}
else
{
throw new NamingException("Object to store in JNDI is neither Referenceable nor Serializable");
}
}
public void unbind(Name name) throws NamingException
{
unbind(name.get(0));
}
public void unbind(String name) throws NamingException
{
map.remove(name);
}
public void rename(Name oldName, Name newName) throws NamingException
{
rename(oldName.get(0), newName.get(0));
}
public void rename(String oldName, String newName) throws NamingException
{
map.put(newName, map.remove(oldName));
}
public NamingEnumeration list(Name name) throws NamingException
{
return null;
}
public NamingEnumeration list(String name) throws NamingException
{
return null;
}
public NamingEnumeration listBindings(Name name) throws NamingException
{
return null;
}
public NamingEnumeration listBindings(String name) throws NamingException
{
return null;
}
public void destroySubcontext(Name name) throws NamingException
{
}
public void destroySubcontext(String name) throws NamingException
{
}
public Context createSubcontext(Name name) throws NamingException
{
return null;
}
public Context createSubcontext(String name) throws NamingException
{
return null;
}
public Object lookupLink(Name name) throws NamingException
{
return null;
}
public Object lookupLink(String name) throws NamingException
{
return null;
}
public NameParser getNameParser(Name name) throws NamingException
{
return null;
}
public NameParser getNameParser(String name) throws NamingException
{
return null;
}
public Name composeName(Name name, Name prefix) throws NamingException
{
return null;
}
public String composeName(String name, String prefix)
throws NamingException
{
return null;
}
public Object addToEnvironment(String propName, Object propVal)
throws NamingException
{
return null;
}
public Object removeFromEnvironment(String propName)
throws NamingException
{
return null;
}
public Hashtable getEnvironment() throws NamingException
{
return null;
}
public void close() throws NamingException
{
}
public String getNameInNamespace() throws NamingException
{
return null;
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/util/MiniJndiContextFactory.java 0000664 0000000 0000000 00000001402 12050675701 0030024 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2004-2011, PostgreSQL Global Development Group
*
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.util;
import java.util.*;
import javax.naming.*;
import javax.naming.spi.InitialContextFactory;
/**
* The ICF for a trivial JNDI implementation. This is not meant to
* be very useful, beyond testing JNDI features of the connection
* pools.
*
* @author Aaron Mulder (ammulder@chariotsolutions.com)
*/
public class MiniJndiContextFactory implements InitialContextFactory
{
public Context getInitialContext(Hashtable environment)
throws NamingException
{
return new MiniJndiContext();
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/xa/ 0000775 0000000 0000000 00000000000 12050675701 0022221 5 ustar 00root root 0000000 0000000 postgresql-jdbc-9.2-1002.src/org/postgresql/test/xa/XADataSourceTest.java 0000664 0000000 0000000 00000025732 12050675701 0026220 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2009-2011, PostgreSQL Global Development Group
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.xa;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Arrays;
import java.util.Random;
import javax.sql.XAConnection;
import javax.sql.XADataSource;
import javax.transaction.xa.XAException;
import javax.transaction.xa.XAResource;
import javax.transaction.xa.Xid;
import org.postgresql.test.TestUtil;
import org.postgresql.test.jdbc2.optional.BaseDataSourceTest;
import org.postgresql.xa.PGXADataSource;
import junit.framework.TestCase;
public class XADataSourceTest extends TestCase {
private XADataSource _ds;
private Connection _conn;
private XAConnection xaconn;
private XAResource xaRes;
private Connection conn;
public XADataSourceTest(String name) {
super(name);
_ds = new PGXADataSource();
BaseDataSourceTest.setupDataSource((PGXADataSource)_ds);
}
protected void setUp() throws Exception {
_conn = TestUtil.openDB();
TestUtil.createTable(_conn, "testxa1", "foo int");
clearAllPrepared();
xaconn = _ds.getXAConnection();
xaRes = xaconn.getXAResource();
conn = xaconn.getConnection();
}
protected void tearDown() throws SQLException {
xaconn.close();
clearAllPrepared();
TestUtil.dropTable(_conn, "testxa1");
TestUtil.closeDB(_conn);
}
private void clearAllPrepared() throws SQLException
{
Statement st = _conn.createStatement();
try
{
ResultSet rs = st.executeQuery("SELECT gid FROM pg_prepared_xacts");
Statement st2 = _conn.createStatement();
while (rs.next())
{
st2.executeUpdate("ROLLBACK PREPARED '" + rs.getString(1) + "'");
}
st2.close();
}
finally
{
st.close();
}
}
static class CustomXid implements Xid {
private static Random rand = new Random(System.currentTimeMillis());
byte[] gtrid = new byte[Xid.MAXGTRIDSIZE];
byte[] bqual = new byte[Xid.MAXBQUALSIZE];
CustomXid(int i)
{
rand.nextBytes(gtrid);
gtrid[0] = (byte)i;
gtrid[1] = (byte)i;
gtrid[2] = (byte)i;
gtrid[3] = (byte)i;
gtrid[4] = (byte)i;
bqual[0] = 4;
bqual[1] = 5;
bqual[2] = 6;
}
public int getFormatId() {
return 0;
}
public byte[] getGlobalTransactionId() {
return gtrid;
}
public byte[] getBranchQualifier() {
return bqual;
}
public boolean equals(Object o) {
Xid other = (Xid)o;
if (other.getFormatId() != this.getFormatId())
return false;
if (!Arrays.equals(other.getBranchQualifier(), this.getBranchQualifier()))
return false;
if (!Arrays.equals(other.getGlobalTransactionId(), this.getGlobalTransactionId()))
return false;
return true;
}
}
public void testOnePhase() throws Exception {
Xid xid = new CustomXid(1);
xaRes.start(xid, XAResource.TMNOFLAGS);
conn.createStatement().executeQuery("SELECT * FROM testxa1");
xaRes.end(xid, XAResource.TMSUCCESS);
xaRes.commit(xid, true);
}
public void testTwoPhaseCommit() throws Exception {
Xid xid = new CustomXid(1);
xaRes.start(xid, XAResource.TMNOFLAGS);
conn.createStatement().executeQuery("SELECT * FROM testxa1");
xaRes.end(xid, XAResource.TMSUCCESS);
xaRes.prepare(xid);
xaRes.commit(xid, false);
}
public void testCloseBeforeCommit() throws Exception {
Xid xid = new CustomXid(5);
xaRes.start(xid, XAResource.TMNOFLAGS);
assertEquals(1, conn.createStatement().executeUpdate("INSERT INTO testxa1 VALUES (1)"));
conn.close();
xaRes.end(xid, XAResource.TMSUCCESS);
xaRes.commit(xid, true);
ResultSet rs = _conn.createStatement().executeQuery("SELECT foo FROM testxa1");
assertTrue(rs.next());
assertEquals(1, rs.getInt(1));
}
public void testRecover() throws Exception {
Xid xid = new CustomXid(12345);
xaRes.start(xid, XAResource.TMNOFLAGS);
conn.createStatement().executeQuery("SELECT * FROM testxa1");
xaRes.end(xid, XAResource.TMSUCCESS);
xaRes.prepare(xid);
{
Xid[] recoveredXidArray = xaRes.recover(XAResource.TMSTARTRSCAN);
boolean recoveredXid = false;
for (int i = 0; i < recoveredXidArray.length; i++)
{
if (xid.equals(recoveredXidArray[i]))
{
recoveredXid = true;
break;
}
}
assertTrue("Did not recover prepared xid", recoveredXid);
assertEquals(0, xaRes.recover(XAResource.TMNOFLAGS).length);
}
xaRes.rollback(xid);
{
Xid[] recoveredXidArray = xaRes.recover(XAResource.TMSTARTRSCAN);
boolean recoveredXid = false;
for (int c = 0; c < recoveredXidArray.length; c++)
{
if (xaRes.equals(recoveredXidArray[c]))
{
recoveredXid = true;
break;
}
}
assertFalse("Recovered rolled back xid", recoveredXid);
}
}
public void testRollback() throws XAException {
Xid xid = new CustomXid(3);
xaRes.start(xid, XAResource.TMNOFLAGS);
xaRes.end(xid, XAResource.TMSUCCESS);
xaRes.prepare(xid);
xaRes.rollback(xid);
}
public void testRollbackWithoutPrepare() throws XAException {
Xid xid = new CustomXid(4);
xaRes.start(xid, XAResource.TMNOFLAGS);
xaRes.end(xid, XAResource.TMSUCCESS);
xaRes.rollback(xid);
}
public void testAutoCommit() throws Exception {
Xid xid = new CustomXid(6);
// When not in an XA transaction, autocommit should be true
// per normal JDBC rules.
assertTrue(conn.getAutoCommit());
// When in an XA transaction, autocommit should be false
xaRes.start(xid, XAResource.TMNOFLAGS);
assertFalse(conn.getAutoCommit());
xaRes.end(xid, XAResource.TMSUCCESS);
assertFalse(conn.getAutoCommit());
xaRes.commit(xid, true);
assertTrue(conn.getAutoCommit());
xaRes.start(xid, XAResource.TMNOFLAGS);
xaRes.end(xid, XAResource.TMSUCCESS);
xaRes.prepare(xid);
assertTrue(conn.getAutoCommit());
xaRes.commit(xid, false);
assertTrue(conn.getAutoCommit());
// Check that autocommit is reset to true after a 1-phase rollback
xaRes.start(xid, XAResource.TMNOFLAGS);
xaRes.end(xid, XAResource.TMSUCCESS);
xaRes.rollback(xid);
assertTrue(conn.getAutoCommit());
// Check that autocommit is reset to true after a 2-phase rollback
xaRes.start(xid, XAResource.TMNOFLAGS);
xaRes.end(xid, XAResource.TMSUCCESS);
xaRes.prepare(xid);
xaRes.rollback(xid);
assertTrue(conn.getAutoCommit());
// Check that autoCommit is set correctly after a getConnection-call
conn = xaconn.getConnection();
assertTrue(conn.getAutoCommit());
xaRes.start(xid, XAResource.TMNOFLAGS);
conn.createStatement().executeQuery("SELECT * FROM testxa1");
java.sql.Timestamp ts1 = getTransactionTimestamp(conn);
conn.close();
conn = xaconn.getConnection();
assertFalse(conn.getAutoCommit());
java.sql.Timestamp ts2 = getTransactionTimestamp(conn);
/* Check that we're still in the same transaction.
* close+getConnection() should not rollback the XA-transaction
* implicitly.
*/
assertEquals(ts1, ts2);
xaRes.end(xid, XAResource.TMSUCCESS);
xaRes.prepare(xid);
xaRes.rollback(xid);
assertTrue(conn.getAutoCommit());
}
/**
* Get the time the current transaction was started from the server.
*
* This can be used to check that transaction doesn't get committed/
* rolled back inadvertently, by calling this once before and after the
* suspected piece of code, and check that they match. It's a bit iffy,
* conceivably you might get the same timestamp anyway if the
* suspected piece of code runs fast enough, and/or the server clock
* is very coarse grained. But it'll do for testing purposes.
*/
private static java.sql.Timestamp getTransactionTimestamp(Connection conn) throws SQLException
{
ResultSet rs = conn.createStatement().executeQuery("SELECT now()");
rs.next();
return rs.getTimestamp(1);
}
public void testEndThenJoin() throws XAException {
Xid xid = new CustomXid(5);
xaRes.start(xid, XAResource.TMNOFLAGS);
xaRes.end(xid, XAResource.TMSUCCESS);
xaRes.start(xid, XAResource.TMJOIN);
xaRes.end(xid, XAResource.TMSUCCESS);
xaRes.commit(xid, true);
}
public void testRestoreOfAutoCommit() throws Exception {
conn.setAutoCommit(false);
Xid xid = new CustomXid(14);
xaRes.start(xid, XAResource.TMNOFLAGS);
xaRes.end(xid, XAResource.TMSUCCESS);
xaRes.commit(xid, true);
assertTrue(!conn.getAutoCommit());
}
/* We don't support transaction interleaving.
public void testInterleaving1() throws Exception {
Xid xid1 = new CustomXid(1);
Xid xid2 = new CustomXid(2);
xaRes.start(xid1, XAResource.TMNOFLAGS);
conn.createStatement().executeUpdate("UPDATE testxa1 SET foo = 'ccc'");
xaRes.end(xid1, XAResource.TMSUCCESS);
xaRes.start(xid2, XAResource.TMNOFLAGS);
conn.createStatement().executeUpdate("UPDATE testxa2 SET foo = 'bbb'");
xaRes.commit(xid1, true);
xaRes.end(xid2, XAResource.TMSUCCESS);
xaRes.commit(xid2, true);
}
public void testInterleaving2() throws Exception {
Xid xid1 = new CustomXid(1);
Xid xid2 = new CustomXid(2);
Xid xid3 = new CustomXid(3);
xaRes.start(xid1, XAResource.TMNOFLAGS);
conn.createStatement().executeUpdate("UPDATE testxa1 SET foo = 'aa'");
xaRes.end(xid1, XAResource.TMSUCCESS);
xaRes.start(xid2, XAResource.TMNOFLAGS);
conn.createStatement().executeUpdate("UPDATE testxa2 SET foo = 'bb'");
xaRes.end(xid2, XAResource.TMSUCCESS);
xaRes.start(xid3, XAResource.TMNOFLAGS);
conn.createStatement().executeUpdate("UPDATE testxa3 SET foo = 'cc'");
xaRes.end(xid3, XAResource.TMSUCCESS);
xaRes.commit(xid1, true);
xaRes.commit(xid2, true);
xaRes.commit(xid3, true);
}
*/
}
postgresql-jdbc-9.2-1002.src/org/postgresql/test/xa/XATestSuite.java 0000664 0000000 0000000 00000002557 12050675701 0025257 0 ustar 00root root 0000000 0000000 /*-------------------------------------------------------------------------
*
* Copyright (c) 2009-2011, PostgreSQL Global Development Group
*
*-------------------------------------------------------------------------
*/
package org.postgresql.test.xa;
import java.sql.Connection;
import java.sql.Statement;
import java.sql.ResultSet;
import junit.framework.TestSuite;
import org.postgresql.test.TestUtil;
public class XATestSuite extends TestSuite {
public static TestSuite suite() throws Exception {
Class.forName("org.postgresql.Driver");
TestSuite suite = new TestSuite();
Connection connection = TestUtil.openDB();
try
{
if (TestUtil.haveMinimumServerVersion(connection, "8.1"))
{
Statement stmt = connection.createStatement();
ResultSet rs = stmt.executeQuery("SHOW max_prepared_transactions");
rs.next();
int mpt = rs.getInt(1);
if (mpt > 0) {
suite.addTestSuite(XADataSourceTest.class);
} else {
System.out.println("Skipping XA tests because max_prepared_transactions = 0.");
}
rs.close();
stmt.close();
}
}
finally
{
connection.close();
}
return suite;
}
}
postgresql-jdbc-9.2-1002.src/org/postgresql/translation/ 0000775 0000000 0000000 00000000000 12050675701 0023170 5 ustar 00root root 0000000 0000000 postgresql-jdbc-9.2-1002.src/org/postgresql/translation/bg.po 0000775 0000000 0000000 00000205053 12050675701 0024130 0 ustar 00root root 0000000 0000000 # Bulgarian language translation for the PostgreSQL JDBC driver
# This file is distributed under the same license as the package.
# First author: Viktor Usunov , 2009.
#
msgid ""
msgstr ""
"Project-Id-Version: JDBC Driver for PostgreSQL 8.x\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2012-09-10 19:32-0400\n"
"PO-Revision-Date: 2009-12-28 00:01+0100\n"
"Last-Translator: \n"
"Language-Team: \n"
"Language: \n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Poedit-Language: Bulgarian\n"
"X-Poedit-Country: BULGARIA\n"
#: bin/org/postgresql/Driver.java.in:235 org/postgresql/Driver.java.in:235
msgid "Error loading default settings from driverconfig.properties"
msgstr ""
"Грешка при зареждане на настройките по подразбиране от файла driverconfig."
"properties"
#: bin/org/postgresql/Driver.java.in:282 org/postgresql/Driver.java.in:282
msgid ""
"Your security policy has prevented the connection from being attempted. You "
"probably need to grant the connect java.net.SocketPermission to the database "
"server host and port that you wish to connect to."
msgstr ""
"Връзката не бе осъществена, поради вашите настройки за сигурност. Може би "
"трябва да предоставите java.net.SocketPermission права на сървъра и порта с "
"базата данни, към който искате да се свържете."
#: bin/org/postgresql/Driver.java.in:287 bin/org/postgresql/Driver.java.in:351
#: org/postgresql/Driver.java.in:287 org/postgresql/Driver.java.in:351
msgid ""
"Something unusual has occured to cause the driver to fail. Please report "
"this exception."
msgstr ""
"Възникна неочаквана грешка с драйвъра. Моля докадвайте това изключение. "
#: bin/org/postgresql/Driver.java.in:359 org/postgresql/Driver.java.in:359
msgid "Connection attempt timed out."
msgstr "Времето за осъществяване на връзката изтече (таймаут)."
#: bin/org/postgresql/Driver.java.in:367 org/postgresql/Driver.java.in:367
msgid "Interrupted while attempting to connect."
msgstr "Опита за осъществяване на връзка бе своевременно прекъснат. "
#: bin/org/postgresql/Driver.java.in:710 org/postgresql/Driver.java.in:710
#, java-format
msgid "Method {0} is not yet implemented."
msgstr "Методът {0} все още не е функционален."
#: org/postgresql/copy/CopyManager.java:56
#, java-format
msgid "Requested CopyIn but got {0}"
msgstr "Зададено CopyIn но получено {0}"
#: org/postgresql/copy/CopyManager.java:67
#, java-format
msgid "Requested CopyOut but got {0}"
msgstr "Зададено CopyOut но получено {0}"
#: org/postgresql/copy/PGCopyInputStream.java:51
#, java-format
msgid "Copying from database failed: {0}"
msgstr "Копирането от базата данни бе неуспешно: {0}"
#: org/postgresql/copy/PGCopyInputStream.java:67
#: org/postgresql/copy/PGCopyOutputStream.java:90
msgid "This copy stream is closed."
msgstr "Потока за копиране на данните е затворен."
#: org/postgresql/copy/PGCopyInputStream.java:108
msgid "Read from copy failed."
msgstr "Четене от копието неуспешно."
#: org/postgresql/copy/PGCopyOutputStream.java:68
#, java-format
msgid "Cannot write to copy a byte of value {0}"
msgstr "Няма пишещи права, за да копира байтова стойност {0}"
#: org/postgresql/core/ConnectionFactory.java:70
#, java-format
msgid "A connection could not be made using the requested protocol {0}."
msgstr "Не може да осъществи връзка, ползвайки искания протокол {0}."
#: org/postgresql/core/Oid.java:113
#, java-format
msgid "oid type {0} not known and not a number"
msgstr ""
#: org/postgresql/core/PGStream.java:490
#, java-format
msgid "Premature end of input stream, expected {0} bytes, but only read {1}."
msgstr ""
"Преждевременен край на входящ поток на данни, очаквани {0} байта, но "
"прочетени само {1}."
#: org/postgresql/core/PGStream.java:530
#, java-format
msgid "Expected an EOF from server, got: {0}"
msgstr "Очакван край на файла от сървъра, но получено: {0}"
#: org/postgresql/core/SetupQueryRunner.java:86
msgid "An unexpected result was returned by a query."
msgstr "Заявката върна неочакван резултат."
#: org/postgresql/core/UTF8Encoding.java:28
#, java-format
msgid ""
"Illegal UTF-8 sequence: byte {0} of {1} byte sequence is not 10xxxxxx: {2}"
msgstr ""
"Невалидна UTF-8 последователност: байта {0} от байтова последователност {1} "
"не е 10xxxxxx: {2}"
#: org/postgresql/core/UTF8Encoding.java:61
#, java-format
msgid "Illegal UTF-8 sequence: {0} bytes used to encode a {1} byte value: {2}"
msgstr ""
"Невалидна UTF-8 последователност: {0} байта използвани за кодирането на {1} "
"байтова стойност: {2}"
#: org/postgresql/core/UTF8Encoding.java:98
#: org/postgresql/core/UTF8Encoding.java:125
#, java-format
msgid "Illegal UTF-8 sequence: initial byte is {0}: {1}"
msgstr "Невалидна UTF-8 последователност: първоначален байт е {0}: {1}"
#: org/postgresql/core/UTF8Encoding.java:130
#, java-format
msgid "Illegal UTF-8 sequence: final value is out of range: {0}"
msgstr ""
"Невалидна UTF-8 последователност: крайната стойност е извън стойностните "
"граници: {0}"
#: org/postgresql/core/UTF8Encoding.java:145
#, java-format
msgid "Illegal UTF-8 sequence: final value is a surrogate value: {0}"
msgstr ""
"Невалидна UTF-8 последователност: крайната стойност е заместителна стойност: "
"{0}"
#: org/postgresql/core/Utils.java:95 org/postgresql/core/Utils.java:112
msgid "Zero bytes may not occur in string parameters."
msgstr "Не може да има нула байта в низ параметрите."
#: org/postgresql/core/Utils.java:145
msgid "Zero bytes may not occur in identifiers."
msgstr "Не може да има нула байта в идентификаторите."
#: org/postgresql/core/types/PGBigDecimal.java:63
#: org/postgresql/core/types/PGBoolean.java:62
#: org/postgresql/core/types/PGByte.java:63
#: org/postgresql/core/types/PGDouble.java:64
#: org/postgresql/core/types/PGFloat.java:64
#: org/postgresql/core/types/PGInteger.java:61
#: org/postgresql/core/types/PGLong.java:62
#: org/postgresql/core/types/PGNumber.java:62
#: org/postgresql/core/types/PGShort.java:58
#: org/postgresql/core/types/PGString.java:73
#, java-format
msgid "Cannot convert an instance of {0} to type {1}"
msgstr "Не може да преобразува инстанцията на {0} във вида {1}"
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:66
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:74
#, fuzzy, java-format
msgid "Invalid sslmode value: {0}"
msgstr "Невалидна дължина {0} на потока данни."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:134
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:168
msgid ""
"Connection refused. Check that the hostname and port are correct and that "
"the postmaster is accepting TCP/IP connections."
msgstr ""
"Връзката отказана. Проверете дали името на хоста и порта са верни и дали "
"postmaster приема ТСР / IP връзки."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:153
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:186
msgid "The connection attempt failed."
msgstr "Опита за връзка бе неуспешен."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:175
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:207
#, fuzzy
msgid "The connection url is invalid."
msgstr "Опита за връзка бе неуспешен."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:198
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:210
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:256
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:268
msgid "The server does not support SSL."
msgstr "Сървърът не поддържа SSL."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:223
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:281
msgid "An error occured while setting up the SSL connection."
msgstr "Възникна грешка при осъществяване на SSL връзката."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:272
#, java-format
msgid "Connection rejected: {0}."
msgstr "Връзката отказана: {0}."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:290
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:312
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:332
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:380
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:405
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:432
msgid ""
"The server requested password-based authentication, but no password was "
"provided."
msgstr "Сървърът изисква идентифициране с парола, но парола не бе въведена."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:356
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:465
#, java-format
msgid ""
"The authentication type {0} is not supported. Check that you have configured "
"the pg_hba.conf file to include the client''s IP address or subnet, and that "
"it is using an authentication scheme supported by the driver."
msgstr ""
"Тип на удостоверяване {0} не се поддържа. Проверете дали сте конфигурирали "
"pg_hba.conf файла, да включва IP адреса на клиента или подмрежата, и че се "
"използва схема за удостоверяване, поддържана от драйвъра."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:362
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:400
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:471
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:514
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:560
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:570
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:579
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:587
#: org/postgresql/gss/MakeGSS.java:158
msgid "Protocol error. Session setup failed."
msgstr "Грешка в протокола. Неуспешна настройка на сесията."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:390
#, java-format
msgid "Backend start-up failed: {0}."
msgstr "Неуспешен опит за стартиране на backend: {0}."
#: org/postgresql/core/v2/FastpathParameterList.java:55
#: org/postgresql/core/v2/FastpathParameterList.java:77
#: org/postgresql/core/v2/FastpathParameterList.java:84
#: org/postgresql/core/v2/SimpleParameterList.java:57
#: org/postgresql/core/v2/SimpleParameterList.java:76
#: org/postgresql/core/v2/SimpleParameterList.java:83
#: org/postgresql/core/v2/SimpleParameterList.java:90
#: org/postgresql/core/v3/CompositeParameterList.java:35
#: org/postgresql/core/v3/SimpleParameterList.java:47
#: org/postgresql/core/v3/SimpleParameterList.java:54
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2845
#: org/postgresql/jdbc2/AbstractJdbc2ResultSetMetaData.java:419
#, java-format
msgid "The column index is out of range: {0}, number of columns: {1}."
msgstr "Индексът на колоната е извън стойностен обхват: {0}, брой колони: {1}."
#: org/postgresql/core/v2/FastpathParameterList.java:142
#: org/postgresql/core/v2/SimpleParameterList.java:155
#: org/postgresql/core/v3/SimpleParameterList.java:183
#, java-format
msgid "No value specified for parameter {0}."
msgstr "Няма стойност, определена за параметър {0}."
#: org/postgresql/core/v2/QueryExecutorImpl.java:72
#: org/postgresql/core/v2/QueryExecutorImpl.java:337
#: org/postgresql/core/v3/QueryExecutorImpl.java:443
#: org/postgresql/core/v3/QueryExecutorImpl.java:507
#, java-format
msgid "Expected command status BEGIN, got {0}."
msgstr "Очаквана команда BEGIN, получена {0}."
#: org/postgresql/core/v2/QueryExecutorImpl.java:78
#: org/postgresql/core/v3/QueryExecutorImpl.java:513
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1828
#, java-format
msgid "Unexpected command status: {0}."
msgstr "Неочакван статус на команда: {0}."
#: org/postgresql/core/v2/QueryExecutorImpl.java:118
#: org/postgresql/core/v2/QueryExecutorImpl.java:129
#: org/postgresql/core/v2/QueryExecutorImpl.java:174
#: org/postgresql/core/v2/QueryExecutorImpl.java:369
#: org/postgresql/core/v3/QueryExecutorImpl.java:281
#: org/postgresql/core/v3/QueryExecutorImpl.java:411
#: org/postgresql/core/v3/QueryExecutorImpl.java:485
#: org/postgresql/core/v3/QueryExecutorImpl.java:551
#: org/postgresql/core/v3/QueryExecutorImpl.java:631
#: org/postgresql/core/v3/QueryExecutorImpl.java:2094
msgid "An I/O error occured while sending to the backend."
msgstr "Входно/изходна грешка при изпращане към backend."
#: org/postgresql/core/v2/QueryExecutorImpl.java:170
#: org/postgresql/core/v2/QueryExecutorImpl.java:225
#: org/postgresql/core/v2/QueryExecutorImpl.java:236
#: org/postgresql/core/v3/QueryExecutorImpl.java:627
#: org/postgresql/core/v3/QueryExecutorImpl.java:685
#, java-format
msgid "Unknown Response Type {0}."
msgstr "Неизвестен тип на отговор {0}."
#: org/postgresql/core/v2/QueryExecutorImpl.java:430
#: org/postgresql/core/v2/QueryExecutorImpl.java:475
#: org/postgresql/core/v3/QueryExecutorImpl.java:1857
msgid "Ran out of memory retrieving query results."
msgstr "Недостатъчна памет при представяна на резултатите от заявката."
#: org/postgresql/core/v2/QueryExecutorImpl.java:597
#: org/postgresql/core/v3/QueryExecutorImpl.java:2199
#, java-format
msgid "Unable to interpret the update count in command completion tag: {0}."
msgstr ""
"Не може да осъществи актуализация на брояча при командно допълнение: {0}."
#: org/postgresql/core/v2/QueryExecutorImpl.java:610
msgid "Copy not implemented for protocol version 2"
msgstr "Копирането не е възможно при версия 2 на протокола"
#: org/postgresql/core/v3/CopyOperationImpl.java:56
msgid "CommandComplete expected COPY but got: "
msgstr "Очаквано командно допълнение COPY но получено: "
#: org/postgresql/core/v3/QueryExecutorImpl.java:66
msgid "Tried to obtain lock while already holding it"
msgstr "Опит за получаване на заключване/резервация докато вече е получено"
#: org/postgresql/core/v3/QueryExecutorImpl.java:78
msgid "Tried to break lock on database connection"
msgstr ""
"Опит за премахване на заключването/резервацията при връзка към базата данни"
#: org/postgresql/core/v3/QueryExecutorImpl.java:93
msgid "Interrupted while waiting to obtain lock on database connection"
msgstr ""
"Прекъсване при чакане да получи заключване/резервация при връзка към базата "
"данни"
#: org/postgresql/core/v3/QueryExecutorImpl.java:275
msgid "Unable to bind parameter values for statement."
msgstr "Не може да подготви параметрите на командата."
#: org/postgresql/core/v3/QueryExecutorImpl.java:726
msgid "Database connection failed when starting copy"
msgstr "Неосъществена връзка към базата данни при започване на копирането"
#: org/postgresql/core/v3/QueryExecutorImpl.java:757
msgid "Tried to cancel an inactive copy operation"
msgstr "Опит за прекъсване на неактивно копиране"
#: org/postgresql/core/v3/QueryExecutorImpl.java:794
msgid "Database connection failed when canceling copy operation"
msgstr "Неосъществена връзка към базата данни при прекъсване на копирането"
#: org/postgresql/core/v3/QueryExecutorImpl.java:799
msgid "Missing expected error response to copy cancel request"
msgstr "Липсва очакван отговор при грешка да прекъсне копирането"
#: org/postgresql/core/v3/QueryExecutorImpl.java:801
#, java-format
msgid "Got {0} error responses to single copy cancel request"
msgstr ""
"Получени {0} отговори за грешка при единствено искане да се прекъсне "
"копирането"
#: org/postgresql/core/v3/QueryExecutorImpl.java:814
msgid "Tried to end inactive copy"
msgstr "Опит за прекъсване на неактивно копиране"
#: org/postgresql/core/v3/QueryExecutorImpl.java:827
msgid "Database connection failed when ending copy"
msgstr "Неосъществена връзка към базата данни при завършване на копирането"
#: org/postgresql/core/v3/QueryExecutorImpl.java:842
#: org/postgresql/core/v3/QueryExecutorImpl.java:860
msgid "Tried to write to an inactive copy operation"
msgstr "Опит за писане при неактивна операция за копиране"
#: org/postgresql/core/v3/QueryExecutorImpl.java:854
#: org/postgresql/core/v3/QueryExecutorImpl.java:866
msgid "Database connection failed when writing to copy"
msgstr "Неосъществена връзка към базата данни при опит за копиране"
#: org/postgresql/core/v3/QueryExecutorImpl.java:878
msgid "Tried to read from inactive copy"
msgstr "Опит за четене при неактивно копиране"
#: org/postgresql/core/v3/QueryExecutorImpl.java:883
msgid "Database connection failed when reading from copy"
msgstr "Неосъществена връзка към базата данни при четене от копие"
#: org/postgresql/core/v3/QueryExecutorImpl.java:951
#, java-format
msgid "Received CommandComplete ''{0}'' without an active copy operation"
msgstr "Получено командно допълнение ''{0}'' без активна команда за копиране"
#: org/postgresql/core/v3/QueryExecutorImpl.java:975
#, java-format
msgid "Got CopyInResponse from server during an active {0}"
msgstr "Получен CopyInResponse отговор от сървъра при активно {0}"
#: org/postgresql/core/v3/QueryExecutorImpl.java:988
#, java-format
msgid "Got CopyOutResponse from server during an active {0}"
msgstr "Получен CopyOutResponse отговор от сървъра при активно {0}"
#: org/postgresql/core/v3/QueryExecutorImpl.java:1003
msgid "Got CopyData without an active copy operation"
msgstr "Получено CopyData без наличие на активна операция за копиране"
#: org/postgresql/core/v3/QueryExecutorImpl.java:1005
#, java-format
msgid "Unexpected copydata from server for {0}"
msgstr "Неочаквано CopyData от сървъра за {0}"
#: org/postgresql/core/v3/QueryExecutorImpl.java:1056
#, java-format
msgid "Unexpected packet type during copy: {0}"
msgstr "Неочакван тип пакет при копиране: {0}"
#: org/postgresql/core/v3/QueryExecutorImpl.java:1310
#, java-format
msgid ""
"Bind message length {0} too long. This can be caused by very large or "
"incorrect length specifications on InputStream parameters."
msgstr ""
"Прекалено голяма дължина {0} на съобщението. Това може да е причинено от "
"прекалено голяма или неправилно зададена дължина на InputStream параметри."
#: org/postgresql/core/v3/QueryExecutorImpl.java:1925
#, fuzzy, java-format
msgid ""
"The server''s client_encoding parameter was changed to {0}. The JDBC driver "
"requires client_encoding to be UTF8 for correct operation."
msgstr ""
"Параметърът client_encoding при сървъра бе променен на {0}. JDBC драйвъра "
"изисква client_encoding да бъде UNICODE за да функционира правилно."
#: org/postgresql/core/v3/QueryExecutorImpl.java:1932
#, java-format
msgid ""
"The server''s DateStyle parameter was changed to {0}. The JDBC driver "
"requires DateStyle to begin with ISO for correct operation."
msgstr ""
"Параметърът DateStyle при сървъра бе променен на {0}. JDBC драйвъра изисква "
"DateStyle започва с ISO за да функционира правилно."
#: org/postgresql/core/v3/QueryExecutorImpl.java:1945
#, java-format
msgid ""
"The server''s standard_conforming_strings parameter was reported as {0}. The "
"JDBC driver expected on or off."
msgstr ""
"Параметърът standard_conforming_strings при сървъра бе докладван като {0}. "
"JDBC драйвъра очаква този параметър да бъде on или off."
#: org/postgresql/core/v3/QueryExecutorImpl.java:2015
msgid "The driver currently does not support COPY operations."
msgstr "За момента драйвъра не поддържа COPY команди."
#: org/postgresql/ds/jdbc23/AbstractJdbc23PooledConnection.java:112
msgid "This PooledConnection has already been closed."
msgstr "Тази PooledConnection връзка бе вече прекъсната."
#: org/postgresql/ds/jdbc23/AbstractJdbc23PooledConnection.java:295
msgid ""
"Connection has been closed automatically because a new connection was opened "
"for the same PooledConnection or the PooledConnection has been closed."
msgstr ""
"Връзката бе автоматично прекъсната, защото нова връзка за същата беше "
"осъществена или PooledConnection връзката е вече прекъсната."
#: org/postgresql/ds/jdbc23/AbstractJdbc23PooledConnection.java:295
msgid "Connection has been closed."
msgstr "Връзката бе прекъсната."
#: org/postgresql/ds/jdbc23/AbstractJdbc23PooledConnection.java:442
msgid "Statement has been closed."
msgstr "Командата е завършена."
#: org/postgresql/ds/jdbc23/AbstractJdbc23PoolingDataSource.java:291
msgid "Failed to setup DataSource."
msgstr ""
#: org/postgresql/ds/jdbc23/AbstractJdbc23PoolingDataSource.java:414
msgid "DataSource has been closed."
msgstr "Източникът на данни е прекъснат."
#: org/postgresql/fastpath/Fastpath.java:81
#: org/postgresql/fastpath/Fastpath.java:128
#, java-format
msgid "Fastpath call {0} - No result was returned and we expected an integer."
msgstr "Извикване на {0} - няма резултати и а бе очаквано цяло число."
#: org/postgresql/fastpath/Fastpath.java:237
#, java-format
msgid "The fastpath function {0} is unknown."
msgstr "Функцията {0} е неизвестна."
#: org/postgresql/geometric/PGbox.java:83
#: org/postgresql/geometric/PGcircle.java:82
#: org/postgresql/geometric/PGcircle.java:91
#: org/postgresql/geometric/PGline.java:80
#: org/postgresql/geometric/PGlseg.java:77
#: org/postgresql/geometric/PGpoint.java:85
#, java-format
msgid "Conversion to type {0} failed: {1}."
msgstr "Неуспешно преобразуване към тип {0}: {1}."
#: org/postgresql/geometric/PGpath.java:81
#, java-format
msgid "Cannot tell if path is open or closed: {0}."
msgstr "Не може да определи дали адреса е отворен или затворен: {0}."
#: org/postgresql/gss/MakeGSS.java:47 org/postgresql/gss/MakeGSS.java:55
#: org/postgresql/gss/MakeGSS.java:168
msgid "GSS Authentication failed"
msgstr "GSS удостоверяването бе неуспешно"
#: org/postgresql/jdbc2/AbstractJdbc2Array.java:153
#: org/postgresql/jdbc2/AbstractJdbc2Array.java:790
#, java-format
msgid "The array index is out of range: {0}"
msgstr "Индексът на масив е извън обхвата: {0}"
#: org/postgresql/jdbc2/AbstractJdbc2Array.java:168
#: org/postgresql/jdbc2/AbstractJdbc2Array.java:807
#, java-format
msgid "The array index is out of range: {0}, number of elements: {1}."
msgstr "Индексът на масив е извън обхвата: {0}, брой елементи: {1}."
#: org/postgresql/jdbc2/AbstractJdbc2Array.java:196
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1982
#: org/postgresql/util/HStoreConverter.java:34
#: org/postgresql/util/HStoreConverter.java:61
msgid ""
"Invalid character data was found. This is most likely caused by stored data "
"containing characters that are invalid for the character set the database "
"was created in. The most common example of this is storing 8bit data in a "
"SQL_ASCII database."
msgstr ""
"Бяха намерени невалидни данни. Това най-вероятно се дължи на съхранявани "
"данни, съдържащи символи, които са невалидни за набора от знаци при "
"създаване на базата данни. Чест пример за това е съхраняване на 8bit данни в "
"SQL_ASCII бази данни."
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:73
msgid ""
"Truncation of large objects is only implemented in 8.3 and later servers."
msgstr "Скъсяване на големи обекти LOB е осъществено само във версии след 8.3."
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:77
msgid "Cannot truncate LOB to a negative length."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:81
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:235
#, java-format
msgid "PostgreSQL LOBs can only index to: {0}"
msgstr "PostgreSQL индексира големи обекти LOB само до: {0}"
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:231
msgid "LOB positioning offsets start at 1."
msgstr "Позиционалният офсет при големи обекти LOB започва от 1."
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:246
msgid "free() was called on this LOB previously"
msgstr "Функцията free() бе вече извикана за този голям обект LOB"
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:229
#, java-format
msgid "Unsupported value for stringtype parameter: {0}"
msgstr "Непозволена стойност за StringType параметър: {0}"
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:249
msgid "unknownLength parameter value must be an integer"
msgstr "Стойността на параметъра unknownLength трябва да бъде цяло число"
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:357
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:284
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:303
#: org/postgresql/jdbc2/TypeInfoCache.java:201
#: org/postgresql/jdbc2/TypeInfoCache.java:249
#: org/postgresql/jdbc2/TypeInfoCache.java:287
#: org/postgresql/jdbc2/TypeInfoCache.java:344
#: org/postgresql/jdbc2/TypeInfoCache.java:348
#: org/postgresql/jdbc2/TypeInfoCache.java:384
#: org/postgresql/jdbc2/TypeInfoCache.java:388
msgid "No results were returned by the query."
msgstr "Няма намерени резултати за заявката."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:371
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:336
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:368
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2695
msgid "A result was returned when none was expected."
msgstr "Бе получен резултат, когато такъв не бе очакван."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:523
msgid "Custom type maps are not supported."
msgstr "Специфични типови съответствия не се поддържат."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:571
#, java-format
msgid "Failed to create object for: {0}."
msgstr "Неуспешно създаване на обект за: {0}."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:633
#, java-format
msgid "Unable to load the class {0} responsible for the datatype {1}"
msgstr "Невъзможно е зареждането на клас {0}, отговарящ за типа данни {1}"
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:729
msgid ""
"Cannot change transaction read-only property in the middle of a transaction."
msgstr ""
"Не може да променяте правата на транзакцията по време на нейното извършване."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:817
msgid "Cannot commit when autoCommit is enabled."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:826
#, fuzzy
msgid "This connection has been closed."
msgstr "Връзката бе прекъсната."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:846
msgid "Cannot rollback when autoCommit is enabled."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:933
msgid ""
"Cannot change transaction isolation level in the middle of a transaction."
msgstr ""
"Не може да променяте изолационното ниво на транзакцията по време на нейното "
"извършване."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:938
#, java-format
msgid "Transaction isolation level {0} not supported."
msgstr "Изолационно ниво на транзакциите {0} не се поддържа."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:1005
msgid "Finalizing a Connection that was never closed:"
msgstr "Приключване на връзка, която не бе прекъсната:"
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:1107
msgid "Unable to translate data into the desired encoding."
msgstr "Невъзможно преобразуване на данни в желаното кодиране."
#: org/postgresql/jdbc2/AbstractJdbc2DatabaseMetaData.java:63
msgid ""
"Unable to determine a value for MaxIndexKeys due to missing system catalog "
"data."
msgstr ""
"Невъзможно е да се определи стойността за MaxIndexKeys поради липса на "
"системния каталог с данни."
#: org/postgresql/jdbc2/AbstractJdbc2DatabaseMetaData.java:86
msgid "Unable to find name datatype in the system catalogs."
msgstr "Не може да се намери името на типа данни в системните каталози."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:235
msgid ""
"Operation requires a scrollable ResultSet, but this ResultSet is "
"FORWARD_ONLY."
msgstr ""
"Операцията изисква резултатите да са scrollable, но този ResultSet е "
"FORWARD_ONLY."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:416
msgid "Unexpected error while decoding character data from a large object."
msgstr "Неочаквана грешка при декодиране на символите от голям обект LOB."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:462
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:491
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:525
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3129
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3174
#, fuzzy, java-format
msgid "Cannot convert the column of type {0} to requested type {1}."
msgstr "Не може да преобразува инстанцията на {0} във вида {1}"
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:744
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:768
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1892
msgid "Can''t use relative move methods while on the insert row."
msgstr ""
"Не може да се използват относителни методи за движение, когато се намираме "
"при редицата на въвеждане."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:788
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2949
#, java-format
msgid "Invalid fetch direction constant: {0}."
msgstr "Невалидна константа за fetch посоката: {0}."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:802
msgid "Cannot call cancelRowUpdates() when on the insert row."
msgstr ""
"Не може да се изпълни cancelRowUpdates() метода, когато се намираме при "
"редицата на въвеждане."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:822
msgid "Cannot call deleteRow() when on the insert row."
msgstr ""
"Не може да се изпълни deleteRow() метода, когато се намираме при редицата на "
"въвеждане."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:828
msgid ""
"Currently positioned before the start of the ResultSet. You cannot call "
"deleteRow() here."
msgstr ""
"В момента се намираме в началото на ResultSet. Тук не може да се изпълни "
"deleteRow() метода."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:833
msgid ""
"Currently positioned after the end of the ResultSet. You cannot call "
"deleteRow() here."
msgstr ""
"В момента се намираме преди края на ResultSet. Тук не може да се изпълни "
"deleteRow() метода."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:838
msgid "There are no rows in this ResultSet."
msgstr "В този ResultSet няма редове."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:885
msgid "Not on the insert row."
msgstr "Не сме в редицата на въвеждане."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:889
msgid "You must specify at least one column value to insert a row."
msgstr "Трябва да посочите поне една стойност за колона, за да вмъкнете ред."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1074
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1805
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2494
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2524
#, java-format
msgid "The JVM claims not to support the encoding: {0}"
msgstr "JVM не поддържа тази кодова таблица за момента: {0}"
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1078
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1121
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1527
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1656
msgid "Provided InputStream failed."
msgstr "Зададения InputStream поток е неуспешен."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1191
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3130
msgid "Provided Reader failed."
msgstr "Грешка с ползвания четец."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1259
msgid "Can''t refresh the insert row."
msgstr "Не може да обнови въведения ред."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1327
msgid "Cannot call updateRow() when on the insert row."
msgstr ""
"Не може да се изпълни updateRow() метода, когато се намираме при редицата на "
"въвеждане."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1333
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3190
msgid ""
"Cannot update the ResultSet because it is either before the start or after "
"the end of the results."
msgstr ""
"Не може да се обнови ResultSet, когато се намираме преди началото или след "
"края на резултатите."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1582
msgid "ResultSets with concurrency CONCUR_READ_ONLY cannot be updated."
msgstr ""
"ResultSets с concurrency CONCUR_READ_ONLY не могат да бъдат актуализирани."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1650
#, java-format
msgid "No primary key found for table {0}."
msgstr "Няма първичен ключ за таблица {0}."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1876
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2958
msgid "Fetch size must be a value greater to or equal to 0."
msgstr "Размера за fetch size трябва да бъде по-голям или равен на 0."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2044
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2051
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2098
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2106
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2926
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2934
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2964
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2971
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2991
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3002
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3020
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3038
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3179
#: org/postgresql/jdbc2/TimestampUtils.java:258
#, java-format
msgid "Bad value for type {0} : {1}"
msgstr "Невалидна стойност за тип {0} : {1}"
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2727
#, java-format
msgid "The column name {0} was not found in this ResultSet."
msgstr "Името на колоната {0} не бе намерено в този ResultSet."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2827
msgid ""
"ResultSet is not updateable. The query that generated this result set must "
"select only one table, and must select all primary keys from that table. See "
"the JDBC 2.1 API Specification, section 5.6 for more details."
msgstr ""
"ResultSet не може да се обновява. Заявката генерираща този резултат трябва "
"да селектира само една таблица, както и всички първични ключове в нея. За "
"повече информация, вижте раздел 5.6 на JDBC 2.1 API Specification."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2839
msgid "This ResultSet is closed."
msgstr "Операциите по този ResultSet са били прекратени."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2860
msgid "ResultSet not positioned properly, perhaps you need to call next."
msgstr ""
"ResultSet не е референциран правилно. Вероятно трябва да придвижите курсора "
"посредством next."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:259
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:323
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:392
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2648
msgid ""
"Can''t use query methods that take a query string on a PreparedStatement."
msgstr ""
"Не може да се употребяват методи за заявка, които ползват низове на "
"PreparedStatement."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:287
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:306
msgid "Multiple ResultSets were returned by the query."
msgstr "Заявката върна няколко ResultSets."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:425
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:429
msgid "A CallableStatement was executed with nothing returned."
msgstr "CallableStatement функция бе обработена, но няма резултати."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:437
msgid "A CallableStatement was executed with an invalid number of parameters"
msgstr ""
"CallableStatement функция бе обработена, но с непозволен брой параметри."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:468
#, java-format
msgid ""
"A CallableStatement function was executed and the out parameter {0} was of "
"type {1} however type {2} was registered."
msgstr ""
"CallableStatement функция бе обработена и изходния параметър {0} бе от тип "
"{1}, обаче тип {2} бе използван."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:670
msgid "Maximum number of rows must be a value grater than or equal to 0."
msgstr ""
"Максималният брой редове трябва да бъде стойност по-голяма или равна на 0."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:713
msgid "Query timeout must be a value greater than or equals to 0."
msgstr ""
"Времето за изпълнение на заявката трябва да бъде стойност по-голяма или "
"равна на 0."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:804
msgid "The maximum field size must be a value greater than or equal to 0."
msgstr ""
"Максималният размер на полето трябва да бъде стойност по-голяма или равна на "
"0."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1219
msgid "Unknown Types value."
msgstr "Стойност от неизвестен тип."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1492
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1617
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3101
#, java-format
msgid "Invalid stream length {0}."
msgstr "Невалидна дължина {0} на потока данни."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1523
#, java-format
msgid "The JVM claims not to support the {0} encoding."
msgstr "JVM не поддържа за момента {0} кодовата таблица."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1698
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3023
#, java-format
msgid "Unknown type {0}."
msgstr "Неизвестен тип {0}."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1713
msgid "No hstore extension installed."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1838
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1844
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1850
#, java-format
msgid "Cannot cast an instance of {0} to type {1}"
msgstr "Не може да преобразува инстанция на {0} към тип {1}"
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1862
#, java-format
msgid "Unsupported Types value: {0}"
msgstr "Неподдържана стойност за тип: {0}"
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1920
#, java-format
msgid ""
"Can''t infer the SQL type to use for an instance of {0}. Use setObject() "
"with an explicit Types value to specify the type to use."
msgstr ""
"Не може да се определи SQL тип, който да се използва за инстанцията на {0}. "
"Ползвайте метода setObject() с точни стойности, за да определите типа."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1968
msgid ""
"This statement does not declare an OUT parameter. Use '{' ?= call ... '}' "
"to declare one."
msgstr ""
"Тази заявка не декларира изходен параметър. Ползвайте '{' ?= call ... '}' за "
"да декларирате такъв."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2018
msgid "wasNull cannot be call before fetching a result."
msgstr "wasNull не може да бьде изпълнен, преди наличието на резултата."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2514
#, java-format
msgid "Malformed function or procedure escape syntax at offset {0}."
msgstr "Непозволен синтаксис на функция или процедура при офсет {0}."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2564
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2578
#, java-format
msgid ""
"Parameter of type {0} was registered, but call to get{1} (sqltype={2}) was "
"made."
msgstr ""
"Отчетен параметър от тип {0}, но обработено като get{1} (sqltype={2}). "
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2597
msgid ""
"A CallableStatement was declared, but no call to registerOutParameter(1, "
") was made."
msgstr ""
"CallableStatement функция бе декларирана, но обработена като "
"registerOutParameter(1, ) "
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2601
msgid "No function outputs were registered."
msgstr "Резултати от функцията не бяха регистрирани."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2604
msgid ""
"Results cannot be retrieved from a CallableStatement before it is executed."
msgstr ""
"Резултати от CallableStatement функция не могат да бъдат получени, преди тя "
"да бъде обработена."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2637
msgid "This statement has been closed."
msgstr "Командата е извършена."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2717
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2787
msgid "Too many update results were returned."
msgstr "Твърде много резултати бяха получени при актуализацията."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2746
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2816
#, java-format
msgid ""
"Batch entry {0} {1} was aborted. Call getNextException to see the cause."
msgstr ""
"Партида {0} {1} беше прекратена. Изпълнете функция getNextException за да "
"видите причината."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3071
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3160
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3200
msgid "Unexpected error writing large object to database."
msgstr "Неочаквана грешка при записване на голям обект LOB в базата данни."
#: org/postgresql/jdbc2/EscapedFunctions.java:145
#: org/postgresql/jdbc2/EscapedFunctions.java:157
#: org/postgresql/jdbc2/EscapedFunctions.java:169
#: org/postgresql/jdbc2/EscapedFunctions.java:206
#: org/postgresql/jdbc2/EscapedFunctions.java:243
#: org/postgresql/jdbc2/EscapedFunctions.java:267
#: org/postgresql/jdbc2/EscapedFunctions.java:292
#: org/postgresql/jdbc2/EscapedFunctions.java:316
#: org/postgresql/jdbc2/EscapedFunctions.java:328
#: org/postgresql/jdbc2/EscapedFunctions.java:352
#: org/postgresql/jdbc2/EscapedFunctions.java:380
#: org/postgresql/jdbc2/EscapedFunctions.java:389
#: org/postgresql/jdbc2/EscapedFunctions.java:399
#: org/postgresql/jdbc2/EscapedFunctions.java:408
#: org/postgresql/jdbc2/EscapedFunctions.java:417
#: org/postgresql/jdbc2/EscapedFunctions.java:426
#: org/postgresql/jdbc2/EscapedFunctions.java:435
#: org/postgresql/jdbc2/EscapedFunctions.java:444
#: org/postgresql/jdbc2/EscapedFunctions.java:453
#: org/postgresql/jdbc2/EscapedFunctions.java:462
#: org/postgresql/jdbc2/EscapedFunctions.java:471
#: org/postgresql/jdbc2/EscapedFunctions.java:480
#, java-format
msgid "{0} function takes one and only one argument."
msgstr "Функцията {0} може да приеме само един единствен аргумент."
#: org/postgresql/jdbc2/EscapedFunctions.java:181
#: org/postgresql/jdbc2/EscapedFunctions.java:193
#: org/postgresql/jdbc2/EscapedFunctions.java:255
#: org/postgresql/jdbc2/EscapedFunctions.java:304
#: org/postgresql/jdbc2/EscapedFunctions.java:582
#, java-format
msgid "{0} function takes two and only two arguments."
msgstr "Функцията {0} може да приеме два и само два аргумента."
#: org/postgresql/jdbc2/EscapedFunctions.java:230
#, java-format
msgid "{0} function takes four and only four argument."
msgstr "Функцията {0} може да приеме четири и само четири аргумента."
#: org/postgresql/jdbc2/EscapedFunctions.java:282
#: org/postgresql/jdbc2/EscapedFunctions.java:342
#, java-format
msgid "{0} function takes two or three arguments."
msgstr "Функцията {0} може да приеме два или три аргумента."
#: org/postgresql/jdbc2/EscapedFunctions.java:362
#: org/postgresql/jdbc2/EscapedFunctions.java:371
#: org/postgresql/jdbc2/EscapedFunctions.java:573
#: org/postgresql/jdbc2/EscapedFunctions.java:591
#, java-format
msgid "{0} function doesn''t take any argument."
msgstr "Функцията {0} не може да приема аргументи."
#: org/postgresql/jdbc2/EscapedFunctions.java:489
#: org/postgresql/jdbc2/EscapedFunctions.java:531
#, java-format
msgid "{0} function takes three and only three arguments."
msgstr "Функцията {0} може да приеме три и само три аргумента."
#: org/postgresql/jdbc2/EscapedFunctions.java:501
#: org/postgresql/jdbc2/EscapedFunctions.java:521
#: org/postgresql/jdbc2/EscapedFunctions.java:523
#: org/postgresql/jdbc2/EscapedFunctions.java:543
#: org/postgresql/jdbc2/EscapedFunctions.java:564
#: org/postgresql/jdbc2/EscapedFunctions.java:566
#, java-format
msgid "Interval {0} not yet implemented"
msgstr "Интервалът {0} не е валиден все още."
#: org/postgresql/jdbc2/TimestampUtils.java:360
msgid ""
"Infinite value found for timestamp/date. This cannot be represented as time."
msgstr ""
"Безкрайна стойност за време или дата. Не може да бъде представена като "
"времева стойност."
#: org/postgresql/jdbc2/TimestampUtils.java:648
#: org/postgresql/jdbc2/TimestampUtils.java:680
#: org/postgresql/jdbc2/TimestampUtils.java:727
#, fuzzy, java-format
msgid "Unsupported binary encoding of {0}."
msgstr "Неподдържана стойност за тип: {0}"
#: org/postgresql/jdbc2/TypeInfoCache.java:161
#, java-format
msgid "The class {0} does not implement org.postgresql.util.PGobject."
msgstr "Клас {0} не изпълнява org.postgresql.util.PGobject."
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:60
#, java-format
msgid "Unknown ResultSet holdability setting: {0}."
msgstr "Неизвестна ResultSet holdability настройка: {0}."
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:98
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:130
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:165
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:187
msgid "Server versions prior to 8.0 do not support savepoints."
msgstr "Сървър версии преди 8.0 не поддържат savepoints."
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:100
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:132
msgid "Cannot establish a savepoint in auto-commit mode."
msgstr "Не може да се установи savepoint в auto-commit модус."
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:419
msgid "Returning autogenerated keys is not supported."
msgstr "Автоматично генерирани ключове не се поддържат."
#: org/postgresql/jdbc3/AbstractJdbc3ParameterMetaData.java:81
#, java-format
msgid "The parameter index is out of range: {0}, number of parameters: {1}."
msgstr "Параметърният индекс е извън обхват: {0}, брой параметри: {1}."
#: org/postgresql/jdbc3/AbstractJdbc3Statement.java:151
msgid ""
"Returning autogenerated keys is only supported for 8.2 and later servers."
msgstr ""
"Автоматично генерирани ключове се поддържат за версии на сървъра след 8.2."
#: org/postgresql/jdbc3/AbstractJdbc3Statement.java:199
#: org/postgresql/jdbc3/AbstractJdbc3Statement.java:317
msgid "Returning autogenerated keys by column index is not supported."
msgstr ""
"Автоматично генерирани ключове спрямо индекс на колона не се поддържат."
#: org/postgresql/jdbc3/PSQLSavepoint.java:38
#: org/postgresql/jdbc3/PSQLSavepoint.java:50
#: org/postgresql/jdbc3/PSQLSavepoint.java:66
msgid "Cannot reference a savepoint after it has been released."
msgstr "Не може да референцира savepoint, след като е била освободена."
#: org/postgresql/jdbc3/PSQLSavepoint.java:42
msgid "Cannot retrieve the id of a named savepoint."
msgstr "Не може да определи ID на спомената savepoint."
#: org/postgresql/jdbc3/PSQLSavepoint.java:54
msgid "Cannot retrieve the name of an unnamed savepoint."
msgstr "Не може да определи името на неупомената savepoint."
#: org/postgresql/jdbc3g/AbstractJdbc3gResultSet.java:37
msgid "Invalid UUID data."
msgstr "Невалидни UUID данни."
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:83
#, java-format
msgid "Unable to find server array type for provided name {0}."
msgstr "Не може да се намери типа на сървърен масив за зададеното име {0}."
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:120
#, fuzzy, java-format
msgid "Invalid timeout ({0}<0)."
msgstr "Невалидна дължина {0} на потока данни."
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:133
msgid "Validating connection."
msgstr ""
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:156
#, fuzzy, java-format
msgid "Failed to set ClientInfo property: {0}"
msgstr "Неуспешно създаване на обект за: {0}."
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:165
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:187
msgid "ClientInfo property not supported."
msgstr "Информацията за ClientInfo не се поддържа."
#: org/postgresql/jdbc4/AbstractJdbc4Statement.java:127
msgid "Object is too large to send over the protocol."
msgstr ""
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:147
msgid "Unable to decode xml data."
msgstr "Не може да декодира XML данните."
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:150
#, java-format
msgid "Unknown XML Source class: {0}"
msgstr "Неизвестен XML входящ клас: {0}"
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:195
msgid "Unable to create SAXResult for SQLXML."
msgstr "Не може да се създаде SAXResult за SQLXML."
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:209
msgid "Unable to create StAXResult for SQLXML"
msgstr "Не може да се създаде StAXResult за SQLXML."
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:213
#, java-format
msgid "Unknown XML Result class: {0}"
msgstr "Неизвестен XML изходящ клас: {0}"
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:226
msgid "This SQLXML object has already been freed."
msgstr "Този SQLXML обект вече е освободен."
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:233
msgid ""
"This SQLXML object has not been initialized, so you cannot retrieve data "
"from it."
msgstr ""
"Този SQLXML обект не е инициализиран, така че не могат да се извличат данни "
"от него."
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:244
#, java-format
msgid "Failed to convert binary xml data to encoding: {0}."
msgstr ""
"Неуспешно преобразуване на двоични XML данни за кодиране съгласно: {0}."
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:269
msgid "Unable to convert DOMResult SQLXML data to a string."
msgstr "Не може да преобразува DOMResult SQLXML данни в низ."
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:282
msgid ""
"This SQLXML object has already been initialized, so you cannot manipulate it "
"further."
msgstr "Този SQLXML обект вече е инициализиран и не може да бъде променен."
#: org/postgresql/largeobject/LargeObjectManager.java:138
msgid "Failed to initialize LargeObject API"
msgstr "Не може да инициализира LargeObject API"
#: org/postgresql/largeobject/LargeObjectManager.java:198
#: org/postgresql/largeobject/LargeObjectManager.java:239
msgid "Large Objects may not be used in auto-commit mode."
msgstr "Големи обекти LOB не могат да се използват в auto-commit модус."
#: org/postgresql/ssl/jdbc3/AbstractJdbc3MakeSSL.java:58
#: org/postgresql/ssl/jdbc4/AbstractJdbc4MakeSSL.java:110
#, java-format
msgid "The SSLSocketFactory class provided {0} could not be instantiated."
msgstr "Класът SSLSocketFactory връща {0} и не може да бъде инстанцииран."
#: org/postgresql/ssl/jdbc4/AbstractJdbc4MakeSSL.java:125
#, java-format
msgid "SSL error: {0}"
msgstr ""
#: org/postgresql/ssl/jdbc4/AbstractJdbc4MakeSSL.java:138
#, fuzzy, java-format
msgid "The HostnameVerifier class provided {0} could not be instantiated."
msgstr "Класът SSLSocketFactory връща {0} и не може да бъде инстанцииран."
#: org/postgresql/ssl/jdbc4/AbstractJdbc4MakeSSL.java:142
#, java-format
msgid "The hostname {0} could not be verified by hostnameverifier {1}."
msgstr ""
#: org/postgresql/ssl/jdbc4/AbstractJdbc4MakeSSL.java:149
#, java-format
msgid "The hostname {0} could not be verified."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:121
msgid ""
"Could not find a java cryptographic algorithm: X.509 CertificateFactory not "
"available."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:132
#, java-format
msgid "Could not open SSL certificate file {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:137
#, java-format
msgid "Loading the SSL certificate {0} into a KeyManager failed."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:194
msgid "Enter SSL password: "
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:202
msgid "Could not read password for SSL key file, console is not available."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:204
#, java-format
msgid "Could not read password for SSL key file by callbackhandler {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:223
#, java-format
msgid "Could not decrypt SSL key file {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:231
#, java-format
msgid "Could not read SSL key file {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:235
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:173
#, java-format
msgid "Could not find a java cryptographic algorithm: {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:99
#, fuzzy, java-format
msgid "The password callback class provided {0} could not be instantiated."
msgstr "Класът SSLSocketFactory връща {0} и не може да бъде инстанцииран."
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:133
#, java-format
msgid "Could not open SSL root certificate file {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:150
#, java-format
msgid "Could not read SSL root certificate file {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:153
#, java-format
msgid "Loading the SSL root certificate {0} into a TrustManager failed."
msgstr ""
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:166
msgid "Could not initialize SSL context."
msgstr ""
#: org/postgresql/util/PGInterval.java:164
msgid "Conversion of interval failed"
msgstr "Неуспешно преобразуване на интервал"
#: org/postgresql/util/PGmoney.java:73
msgid "Conversion of money failed."
msgstr "Неуспешно валутно преобразуване."
#: org/postgresql/util/ServerErrorMessage.java:155
#, java-format
msgid "Detail: {0}"
msgstr "Подробност: {0}"
#: org/postgresql/util/ServerErrorMessage.java:159
#, java-format
msgid "Hint: {0}"
msgstr "Забележка: {0}"
#: org/postgresql/util/ServerErrorMessage.java:162
#, java-format
msgid "Position: {0}"
msgstr "Позиция: {0}"
#: org/postgresql/util/ServerErrorMessage.java:165
#, java-format
msgid "Where: {0}"
msgstr "Където: {0}"
#: org/postgresql/util/ServerErrorMessage.java:171
#, java-format
msgid "Internal Query: {0}"
msgstr "Вътрешна заявка: {0}"
#: org/postgresql/util/ServerErrorMessage.java:174
#, java-format
msgid "Internal Position: {0}"
msgstr "Вътрешна позиция: {0}"
#: org/postgresql/util/ServerErrorMessage.java:180
#, java-format
msgid "Location: File: {0}, Routine: {1}, Line: {2}"
msgstr "Местоположение: Файл: {0}, Функция: {1}, Ред: {2}"
#: org/postgresql/util/ServerErrorMessage.java:183
#, java-format
msgid "Server SQLState: {0}"
msgstr "SQL статус на сървъра: {0}"
#: org/postgresql/xa/PGXAConnection.java:148
msgid ""
"Transaction control methods setAutoCommit(true), commit, rollback and "
"setSavePoint not allowed while an XA transaction is active."
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:186
#: org/postgresql/xa/PGXAConnection.java:245
msgid "Invalid flags"
msgstr "Невалидни флагове"
#: org/postgresql/xa/PGXAConnection.java:189
#: org/postgresql/xa/PGXAConnection.java:248
#: org/postgresql/xa/PGXAConnection.java:425
msgid "xid must not be null"
msgstr "xid не може да бъде null"
#: org/postgresql/xa/PGXAConnection.java:192
msgid "Connection is busy with another transaction"
msgstr "Връзката е заета с друга транзакция"
#: org/postgresql/xa/PGXAConnection.java:198
#: org/postgresql/xa/PGXAConnection.java:255
msgid "suspend/resume not implemented"
msgstr "спиране / започване не се поддържа за момента"
#: org/postgresql/xa/PGXAConnection.java:204
#: org/postgresql/xa/PGXAConnection.java:207
#: org/postgresql/xa/PGXAConnection.java:209
msgid "Transaction interleaving not implemented"
msgstr "Транзакция в транзакция не се поддържа за момента"
#: org/postgresql/xa/PGXAConnection.java:218
msgid "Error disabling autocommit"
msgstr "Грешка при изключване на autocommit"
#: org/postgresql/xa/PGXAConnection.java:251
msgid "tried to call end without corresponding start call"
msgstr "опита да извика end без съответстващо извикване на start"
#: org/postgresql/xa/PGXAConnection.java:282
msgid ""
"Not implemented: Prepare must be issued using the same connection that "
"started the transaction"
msgstr ""
"Невъзможна комбинация: Prepare трябва да бъде издадено чрез използване на "
"същата връзка, при която е започната транзакцията"
#: org/postgresql/xa/PGXAConnection.java:286
msgid "Prepare called before end"
msgstr "Prepare извикано преди края"
#: org/postgresql/xa/PGXAConnection.java:292
msgid "Server versions prior to 8.1 do not support two-phase commit."
msgstr "Сървър версии преди 8.1 не поддържат дву-фазов commit."
#: org/postgresql/xa/PGXAConnection.java:313
msgid "Error preparing transaction"
msgstr "Грешка при подготвяне на транзакция"
#: org/postgresql/xa/PGXAConnection.java:328
msgid "Invalid flag"
msgstr "Невалиден флаг"
#: org/postgresql/xa/PGXAConnection.java:368
msgid "Error during recover"
msgstr "Грешка при възстановяване"
#: org/postgresql/xa/PGXAConnection.java:416
msgid "Error rolling back prepared transaction"
msgstr "Грешка при възстановяване на състоянието преди подготвена транзакция"
#: org/postgresql/xa/PGXAConnection.java:451
msgid ""
"Not implemented: one-phase commit must be issued using the same connection "
"that was used to start it"
msgstr ""
"Невъзможна комбинация: едно-фазов commit трябва да бъде издаден чрез "
"използване на същата връзка, при която е започнал"
#: org/postgresql/xa/PGXAConnection.java:455
msgid "commit called before end"
msgstr "commit извикан преди end"
#: org/postgresql/xa/PGXAConnection.java:466
msgid "Error during one-phase commit"
msgstr "Грешка при едно-фазов commit"
#: org/postgresql/xa/PGXAConnection.java:487
msgid ""
"Not implemented: 2nd phase commit must be issued using an idle connection"
msgstr ""
"Невъзможна комбинация: втората фаза на commit задължително трябва да бъде "
"издадена при свободна връзка"
#: org/postgresql/xa/PGXAConnection.java:507
#, fuzzy
msgid "Error committing prepared transaction"
msgstr "Грешка при възстановяване на състоянието преди подготвена транзакция"
#: org/postgresql/xa/PGXAConnection.java:522
msgid "Heuristic commit/rollback not supported"
msgstr "Евристичен commit или rollback не се поддържа"
#~ msgid "Query returning autogenerated keys didn't return anything."
#~ msgstr ""
#~ "Заявката за автоматично генериране на ключове не предостави резултат."
#~ msgid "The driver does not support SSL."
#~ msgstr "Драйвъра не поддържа SSL."
#~ msgid "Multi-dimensional arrays are currently not supported."
#~ msgstr "Многомерни низове не се поддържат за момента."
#~ msgid "Exception: {0}"
#~ msgstr "Изключение: {0}"
#~ msgid "Stack Trace:"
#~ msgstr "Stack Trace:"
#~ msgid "End of Stack Trace"
#~ msgstr "Край на stack trace"
#~ msgid "Exception generating stacktrace for: {0} encountered: {1}"
#~ msgstr "Stacktrace изключение при генериране на: {0} възникнали: {1}"
#~ msgid "rand function only takes zero or one argument(the seed)."
#~ msgstr ""
#~ "функцията за рандомизиране не приема аргументи или приема само един "
#~ "аргумент (seed)."
#~ msgid "suspend/resume and join not implemented"
#~ msgstr "спиране / продължаване или съединяване не се поддържа за момента"
postgresql-jdbc-9.2-1002.src/org/postgresql/translation/cs.po 0000664 0000000 0000000 00000142044 12050675701 0024142 0 ustar 00root root 0000000 0000000 # Just Czech translation ;o)
# Copyright (C) 2005
# This file is distributed under the same license as the PACKAGE package.
# Petr Dittrich , 2005
#
msgid ""
msgstr ""
"Project-Id-Version: PostgreSQL JDBC Driver 8.0\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2012-09-10 19:32-0400\n"
"PO-Revision-Date: 2005-08-21 20:00+0200\n"
"Last-Translator: Petr Dittrich \n"
"Language-Team: \n"
"Language: \n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=ISO-8859-2\n"
"Content-Transfer-Encoding: 8bit\n"
#: bin/org/postgresql/Driver.java.in:235 org/postgresql/Driver.java.in:235
msgid "Error loading default settings from driverconfig.properties"
msgstr "Chyba natn standardnho nastaven z driverconfig.properties"
#: bin/org/postgresql/Driver.java.in:282 org/postgresql/Driver.java.in:282
msgid ""
"Your security policy has prevented the connection from being attempted. You "
"probably need to grant the connect java.net.SocketPermission to the database "
"server host and port that you wish to connect to."
msgstr ""
#: bin/org/postgresql/Driver.java.in:287 bin/org/postgresql/Driver.java.in:351
#: org/postgresql/Driver.java.in:287 org/postgresql/Driver.java.in:351
msgid ""
"Something unusual has occured to cause the driver to fail. Please report "
"this exception."
msgstr ""
"Nco neobvyklho pinutilo ovlada selhat. Prosm nahlaste tuto vyjmku."
#: bin/org/postgresql/Driver.java.in:359 org/postgresql/Driver.java.in:359
#, fuzzy
msgid "Connection attempt timed out."
msgstr "Pokus o pipojen selhal."
#: bin/org/postgresql/Driver.java.in:367 org/postgresql/Driver.java.in:367
#, fuzzy
msgid "Interrupted while attempting to connect."
msgstr "Nastala chyba pi nastaven SSL spojen."
#: bin/org/postgresql/Driver.java.in:710 org/postgresql/Driver.java.in:710
#, java-format
msgid "Method {0} is not yet implemented."
msgstr "Metoda {0} nen implementovna."
#: org/postgresql/copy/CopyManager.java:56
#, java-format
msgid "Requested CopyIn but got {0}"
msgstr ""
#: org/postgresql/copy/CopyManager.java:67
#, java-format
msgid "Requested CopyOut but got {0}"
msgstr ""
#: org/postgresql/copy/PGCopyInputStream.java:51
#, java-format
msgid "Copying from database failed: {0}"
msgstr ""
#: org/postgresql/copy/PGCopyInputStream.java:67
#: org/postgresql/copy/PGCopyOutputStream.java:90
#, fuzzy
msgid "This copy stream is closed."
msgstr "Tento ResultSet je uzaven."
#: org/postgresql/copy/PGCopyInputStream.java:108
msgid "Read from copy failed."
msgstr ""
#: org/postgresql/copy/PGCopyOutputStream.java:68
#, java-format
msgid "Cannot write to copy a byte of value {0}"
msgstr ""
#: org/postgresql/core/ConnectionFactory.java:70
#, java-format
msgid "A connection could not be made using the requested protocol {0}."
msgstr "Spojen nelze vytvoit s pouitm danho protokolu {0}."
#: org/postgresql/core/Oid.java:113
#, java-format
msgid "oid type {0} not known and not a number"
msgstr ""
#: org/postgresql/core/PGStream.java:490
#, java-format
msgid "Premature end of input stream, expected {0} bytes, but only read {1}."
msgstr ""
#: org/postgresql/core/PGStream.java:530
#, java-format
msgid "Expected an EOF from server, got: {0}"
msgstr ""
#: org/postgresql/core/SetupQueryRunner.java:86
msgid "An unexpected result was returned by a query."
msgstr "Obdren neoekvan vsledek dotazu."
#: org/postgresql/core/UTF8Encoding.java:28
#, java-format
msgid ""
"Illegal UTF-8 sequence: byte {0} of {1} byte sequence is not 10xxxxxx: {2}"
msgstr ""
#: org/postgresql/core/UTF8Encoding.java:61
#, java-format
msgid "Illegal UTF-8 sequence: {0} bytes used to encode a {1} byte value: {2}"
msgstr ""
#: org/postgresql/core/UTF8Encoding.java:98
#: org/postgresql/core/UTF8Encoding.java:125
#, java-format
msgid "Illegal UTF-8 sequence: initial byte is {0}: {1}"
msgstr ""
#: org/postgresql/core/UTF8Encoding.java:130
#, java-format
msgid "Illegal UTF-8 sequence: final value is out of range: {0}"
msgstr ""
#: org/postgresql/core/UTF8Encoding.java:145
#, java-format
msgid "Illegal UTF-8 sequence: final value is a surrogate value: {0}"
msgstr ""
#: org/postgresql/core/Utils.java:95 org/postgresql/core/Utils.java:112
msgid "Zero bytes may not occur in string parameters."
msgstr ""
#: org/postgresql/core/Utils.java:145
msgid "Zero bytes may not occur in identifiers."
msgstr ""
#: org/postgresql/core/types/PGBigDecimal.java:63
#: org/postgresql/core/types/PGBoolean.java:62
#: org/postgresql/core/types/PGByte.java:63
#: org/postgresql/core/types/PGDouble.java:64
#: org/postgresql/core/types/PGFloat.java:64
#: org/postgresql/core/types/PGInteger.java:61
#: org/postgresql/core/types/PGLong.java:62
#: org/postgresql/core/types/PGNumber.java:62
#: org/postgresql/core/types/PGShort.java:58
#: org/postgresql/core/types/PGString.java:73
#, fuzzy, java-format
msgid "Cannot convert an instance of {0} to type {1}"
msgstr "Nemohu petypovat instanci {0} na typ {1}"
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:66
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:74
#, fuzzy, java-format
msgid "Invalid sslmode value: {0}"
msgstr "Vadn dlka proudu {0}."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:134
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:168
msgid ""
"Connection refused. Check that the hostname and port are correct and that "
"the postmaster is accepting TCP/IP connections."
msgstr ""
"Spojen odmtnuto. Zkontrolujte zda je jmno hosta a port sprvn a zda "
"postmaster pijm TCP/IP spojen."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:153
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:186
msgid "The connection attempt failed."
msgstr "Pokus o pipojen selhal."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:175
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:207
#, fuzzy
msgid "The connection url is invalid."
msgstr "Pokus o pipojen selhal."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:198
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:210
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:256
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:268
msgid "The server does not support SSL."
msgstr "Server nepodporuje SSL."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:223
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:281
msgid "An error occured while setting up the SSL connection."
msgstr "Nastala chyba pi nastaven SSL spojen."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:272
#, java-format
msgid "Connection rejected: {0}."
msgstr "Spojen odmtnuto: {0}."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:290
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:312
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:332
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:380
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:405
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:432
msgid ""
"The server requested password-based authentication, but no password was "
"provided."
msgstr "Server vyaduje oven heslem, ale dn nebylo poslno."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:356
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:465
#, java-format
msgid ""
"The authentication type {0} is not supported. Check that you have configured "
"the pg_hba.conf file to include the client''s IP address or subnet, and that "
"it is using an authentication scheme supported by the driver."
msgstr ""
"Oven typu {0} nen podporovno. Zkontrolujte zda konfiguran soubor "
"pg_hba.conf obsahuje klientskou IP adresu i pods a zda je pouit "
"ovenovac schma podporovno ovladaem."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:362
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:400
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:471
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:514
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:560
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:570
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:579
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:587
#: org/postgresql/gss/MakeGSS.java:158
msgid "Protocol error. Session setup failed."
msgstr "Chyba protokolu. Nastaven relace selhalo."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:390
#, java-format
msgid "Backend start-up failed: {0}."
msgstr "Selhal start backendu: {0}."
#: org/postgresql/core/v2/FastpathParameterList.java:55
#: org/postgresql/core/v2/FastpathParameterList.java:77
#: org/postgresql/core/v2/FastpathParameterList.java:84
#: org/postgresql/core/v2/SimpleParameterList.java:57
#: org/postgresql/core/v2/SimpleParameterList.java:76
#: org/postgresql/core/v2/SimpleParameterList.java:83
#: org/postgresql/core/v2/SimpleParameterList.java:90
#: org/postgresql/core/v3/CompositeParameterList.java:35
#: org/postgresql/core/v3/SimpleParameterList.java:47
#: org/postgresql/core/v3/SimpleParameterList.java:54
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2845
#: org/postgresql/jdbc2/AbstractJdbc2ResultSetMetaData.java:419
#, java-format
msgid "The column index is out of range: {0}, number of columns: {1}."
msgstr "Index sloupece je mimo rozsah: {0}, poet sloupc: {1}."
#: org/postgresql/core/v2/FastpathParameterList.java:142
#: org/postgresql/core/v2/SimpleParameterList.java:155
#: org/postgresql/core/v3/SimpleParameterList.java:183
#, java-format
msgid "No value specified for parameter {0}."
msgstr "Nespecifikovna hodnota parametru {0}."
#: org/postgresql/core/v2/QueryExecutorImpl.java:72
#: org/postgresql/core/v2/QueryExecutorImpl.java:337
#: org/postgresql/core/v3/QueryExecutorImpl.java:443
#: org/postgresql/core/v3/QueryExecutorImpl.java:507
#, java-format
msgid "Expected command status BEGIN, got {0}."
msgstr "Oekvn pkaz BEGIN, obdren {0}."
#: org/postgresql/core/v2/QueryExecutorImpl.java:78
#: org/postgresql/core/v3/QueryExecutorImpl.java:513
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1828
#, java-format
msgid "Unexpected command status: {0}."
msgstr "Neoekvan stav pkazu: {0}."
#: org/postgresql/core/v2/QueryExecutorImpl.java:118
#: org/postgresql/core/v2/QueryExecutorImpl.java:129
#: org/postgresql/core/v2/QueryExecutorImpl.java:174
#: org/postgresql/core/v2/QueryExecutorImpl.java:369
#: org/postgresql/core/v3/QueryExecutorImpl.java:281
#: org/postgresql/core/v3/QueryExecutorImpl.java:411
#: org/postgresql/core/v3/QueryExecutorImpl.java:485
#: org/postgresql/core/v3/QueryExecutorImpl.java:551
#: org/postgresql/core/v3/QueryExecutorImpl.java:631
#: org/postgresql/core/v3/QueryExecutorImpl.java:2094
msgid "An I/O error occured while sending to the backend."
msgstr "Vystupn/vstupn chyba pi odesln k backend."
#: org/postgresql/core/v2/QueryExecutorImpl.java:170
#: org/postgresql/core/v2/QueryExecutorImpl.java:225
#: org/postgresql/core/v2/QueryExecutorImpl.java:236
#: org/postgresql/core/v3/QueryExecutorImpl.java:627
#: org/postgresql/core/v3/QueryExecutorImpl.java:685
#, java-format
msgid "Unknown Response Type {0}."
msgstr "Neznm typ odpovdi {0}."
#: org/postgresql/core/v2/QueryExecutorImpl.java:430
#: org/postgresql/core/v2/QueryExecutorImpl.java:475
#: org/postgresql/core/v3/QueryExecutorImpl.java:1857
msgid "Ran out of memory retrieving query results."
msgstr ""
#: org/postgresql/core/v2/QueryExecutorImpl.java:597
#: org/postgresql/core/v3/QueryExecutorImpl.java:2199
#, java-format
msgid "Unable to interpret the update count in command completion tag: {0}."
msgstr ""
#: org/postgresql/core/v2/QueryExecutorImpl.java:610
msgid "Copy not implemented for protocol version 2"
msgstr ""
#: org/postgresql/core/v3/CopyOperationImpl.java:56
msgid "CommandComplete expected COPY but got: "
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:66
msgid "Tried to obtain lock while already holding it"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:78
msgid "Tried to break lock on database connection"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:93
#, fuzzy
msgid "Interrupted while waiting to obtain lock on database connection"
msgstr "Nastala chyba pi nastaven SSL spojen."
#: org/postgresql/core/v3/QueryExecutorImpl.java:275
msgid "Unable to bind parameter values for statement."
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:726
msgid "Database connection failed when starting copy"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:757
msgid "Tried to cancel an inactive copy operation"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:794
msgid "Database connection failed when canceling copy operation"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:799
msgid "Missing expected error response to copy cancel request"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:801
#, java-format
msgid "Got {0} error responses to single copy cancel request"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:814
msgid "Tried to end inactive copy"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:827
msgid "Database connection failed when ending copy"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:842
#: org/postgresql/core/v3/QueryExecutorImpl.java:860
msgid "Tried to write to an inactive copy operation"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:854
#: org/postgresql/core/v3/QueryExecutorImpl.java:866
msgid "Database connection failed when writing to copy"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:878
msgid "Tried to read from inactive copy"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:883
msgid "Database connection failed when reading from copy"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:951
#, java-format
msgid "Received CommandComplete ''{0}'' without an active copy operation"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:975
#, java-format
msgid "Got CopyInResponse from server during an active {0}"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:988
#, java-format
msgid "Got CopyOutResponse from server during an active {0}"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:1003
msgid "Got CopyData without an active copy operation"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:1005
#, fuzzy, java-format
msgid "Unexpected copydata from server for {0}"
msgstr "Neoekvan stav pkazu: {0}."
#: org/postgresql/core/v3/QueryExecutorImpl.java:1056
#, java-format
msgid "Unexpected packet type during copy: {0}"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:1310
#, java-format
msgid ""
"Bind message length {0} too long. This can be caused by very large or "
"incorrect length specifications on InputStream parameters."
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:1925
#, java-format
msgid ""
"The server''s client_encoding parameter was changed to {0}. The JDBC driver "
"requires client_encoding to be UTF8 for correct operation."
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:1932
#, java-format
msgid ""
"The server''s DateStyle parameter was changed to {0}. The JDBC driver "
"requires DateStyle to begin with ISO for correct operation."
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:1945
#, java-format
msgid ""
"The server''s standard_conforming_strings parameter was reported as {0}. The "
"JDBC driver expected on or off."
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:2015
msgid "The driver currently does not support COPY operations."
msgstr "Ovlada nyn nepodporuje pkaz COPY."
#: org/postgresql/ds/jdbc23/AbstractJdbc23PooledConnection.java:112
msgid "This PooledConnection has already been closed."
msgstr "Tento PooledConnection byl uzaven."
#: org/postgresql/ds/jdbc23/AbstractJdbc23PooledConnection.java:295
msgid ""
"Connection has been closed automatically because a new connection was opened "
"for the same PooledConnection or the PooledConnection has been closed."
msgstr ""
#: org/postgresql/ds/jdbc23/AbstractJdbc23PooledConnection.java:295
msgid "Connection has been closed."
msgstr "Spojeni bylo uzaveno."
#: org/postgresql/ds/jdbc23/AbstractJdbc23PooledConnection.java:442
msgid "Statement has been closed."
msgstr "Statement byl uzaven."
#: org/postgresql/ds/jdbc23/AbstractJdbc23PoolingDataSource.java:291
msgid "Failed to setup DataSource."
msgstr ""
#: org/postgresql/ds/jdbc23/AbstractJdbc23PoolingDataSource.java:414
msgid "DataSource has been closed."
msgstr "DataSource byl uzaven."
#: org/postgresql/fastpath/Fastpath.java:81
#: org/postgresql/fastpath/Fastpath.java:128
#, java-format
msgid "Fastpath call {0} - No result was returned and we expected an integer."
msgstr ""
#: org/postgresql/fastpath/Fastpath.java:237
#, java-format
msgid "The fastpath function {0} is unknown."
msgstr ""
#: org/postgresql/geometric/PGbox.java:83
#: org/postgresql/geometric/PGcircle.java:82
#: org/postgresql/geometric/PGcircle.java:91
#: org/postgresql/geometric/PGline.java:80
#: org/postgresql/geometric/PGlseg.java:77
#: org/postgresql/geometric/PGpoint.java:85
#, java-format
msgid "Conversion to type {0} failed: {1}."
msgstr ""
#: org/postgresql/geometric/PGpath.java:81
#, java-format
msgid "Cannot tell if path is open or closed: {0}."
msgstr ""
#: org/postgresql/gss/MakeGSS.java:47 org/postgresql/gss/MakeGSS.java:55
#: org/postgresql/gss/MakeGSS.java:168
msgid "GSS Authentication failed"
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Array.java:153
#: org/postgresql/jdbc2/AbstractJdbc2Array.java:790
#, java-format
msgid "The array index is out of range: {0}"
msgstr "Index pole mimo rozsah: {0}"
#: org/postgresql/jdbc2/AbstractJdbc2Array.java:168
#: org/postgresql/jdbc2/AbstractJdbc2Array.java:807
#, java-format
msgid "The array index is out of range: {0}, number of elements: {1}."
msgstr "Index pole mimo rozsah: {0}, poet prvk: {1}."
#: org/postgresql/jdbc2/AbstractJdbc2Array.java:196
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1982
#: org/postgresql/util/HStoreConverter.java:34
#: org/postgresql/util/HStoreConverter.java:61
msgid ""
"Invalid character data was found. This is most likely caused by stored data "
"containing characters that are invalid for the character set the database "
"was created in. The most common example of this is storing 8bit data in a "
"SQL_ASCII database."
msgstr ""
"Nalezena vada ve znakovch datech. Toto me bt zpsobeno uloenmi daty "
"obsahujcmi znaky, kter jsou zvadn pro znakovou sadu nastavenou pi "
"zakldn databze. Nejznmej pklad je ukldn 8bitovch dat vSQL_ASCII "
"databzi."
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:73
msgid ""
"Truncation of large objects is only implemented in 8.3 and later servers."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:77
msgid "Cannot truncate LOB to a negative length."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:81
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:235
#, java-format
msgid "PostgreSQL LOBs can only index to: {0}"
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:231
msgid "LOB positioning offsets start at 1."
msgstr "Zatek pozicovn LOB zana na 1."
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:246
msgid "free() was called on this LOB previously"
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:229
#, fuzzy, java-format
msgid "Unsupported value for stringtype parameter: {0}"
msgstr "Nepodporovan hodnota typu: {0}"
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:249
msgid "unknownLength parameter value must be an integer"
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:357
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:284
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:303
#: org/postgresql/jdbc2/TypeInfoCache.java:201
#: org/postgresql/jdbc2/TypeInfoCache.java:249
#: org/postgresql/jdbc2/TypeInfoCache.java:287
#: org/postgresql/jdbc2/TypeInfoCache.java:344
#: org/postgresql/jdbc2/TypeInfoCache.java:348
#: org/postgresql/jdbc2/TypeInfoCache.java:384
#: org/postgresql/jdbc2/TypeInfoCache.java:388
msgid "No results were returned by the query."
msgstr "Neobdren dn vsledek dotazu."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:371
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:336
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:368
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2695
msgid "A result was returned when none was expected."
msgstr "Obdren vsledek, ikdy dn nebyl oekvn."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:523
msgid "Custom type maps are not supported."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:571
#, java-format
msgid "Failed to create object for: {0}."
msgstr "Selhalo vytvoen objektu: {0}."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:633
#, java-format
msgid "Unable to load the class {0} responsible for the datatype {1}"
msgstr "Nemohu nast tdu {0} odpovdnou za typ {1}"
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:729
msgid ""
"Cannot change transaction read-only property in the middle of a transaction."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:817
msgid "Cannot commit when autoCommit is enabled."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:826
#, fuzzy
msgid "This connection has been closed."
msgstr "Spojeni bylo uzaveno."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:846
msgid "Cannot rollback when autoCommit is enabled."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:933
msgid ""
"Cannot change transaction isolation level in the middle of a transaction."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:938
#, java-format
msgid "Transaction isolation level {0} not supported."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:1005
#, fuzzy
msgid "Finalizing a Connection that was never closed:"
msgstr "Spojeni bylo uzaveno."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:1107
msgid "Unable to translate data into the desired encoding."
msgstr "Nemohu peloit data do poadovanho kdovn."
#: org/postgresql/jdbc2/AbstractJdbc2DatabaseMetaData.java:63
#, fuzzy
msgid ""
"Unable to determine a value for MaxIndexKeys due to missing system catalog "
"data."
msgstr "Nemohu najt oid a oidvector typu v systmovm katalogu."
#: org/postgresql/jdbc2/AbstractJdbc2DatabaseMetaData.java:86
msgid "Unable to find name datatype in the system catalogs."
msgstr "Nemohu najt nzev typu v systmovm katalogu."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:235
msgid ""
"Operation requires a scrollable ResultSet, but this ResultSet is "
"FORWARD_ONLY."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:416
msgid "Unexpected error while decoding character data from a large object."
msgstr "Neoekvan chyba bham dekdovn znaku z velkho objektu."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:462
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:491
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:525
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3129
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3174
#, fuzzy, java-format
msgid "Cannot convert the column of type {0} to requested type {1}."
msgstr "Nemohu petypovat instanci {0} na typ {1}"
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:744
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:768
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1892
msgid "Can''t use relative move methods while on the insert row."
msgstr "Nemete pouvat relativn pesuny pi vkldn dku."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:788
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2949
#, java-format
msgid "Invalid fetch direction constant: {0}."
msgstr "patn smr ten: {0}."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:802
msgid "Cannot call cancelRowUpdates() when on the insert row."
msgstr "Nemete volat cancelRowUpdates() pi vkldn dku."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:822
msgid "Cannot call deleteRow() when on the insert row."
msgstr "Nemete volat deleteRow() pi vkldn dku."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:828
msgid ""
"Currently positioned before the start of the ResultSet. You cannot call "
"deleteRow() here."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:833
msgid ""
"Currently positioned after the end of the ResultSet. You cannot call "
"deleteRow() here."
msgstr ""
"Prv jste za pozic konce ResultSetu. Zde nemete volat deleteRow().s"
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:838
msgid "There are no rows in this ResultSet."
msgstr "dn dek v ResultSet."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:885
msgid "Not on the insert row."
msgstr "Ne na vkldanm dku."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:889
msgid "You must specify at least one column value to insert a row."
msgstr "Muste vyplnit alespo jeden sloupec pro vloen dku."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1074
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1805
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2494
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2524
#, java-format
msgid "The JVM claims not to support the encoding: {0}"
msgstr "JVM tvrd, e nepodporuje kodovn: {0}"
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1078
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1121
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1527
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1656
msgid "Provided InputStream failed."
msgstr "Selhal poskytnut InputStream."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1191
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3130
msgid "Provided Reader failed."
msgstr "Selhal poskytnut Reader."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1259
msgid "Can''t refresh the insert row."
msgstr "Nemohu obnovit vkldan dek."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1327
msgid "Cannot call updateRow() when on the insert row."
msgstr "Nemohu volat updateRow() na vlkdanm dku."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1333
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3190
msgid ""
"Cannot update the ResultSet because it is either before the start or after "
"the end of the results."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1582
msgid "ResultSets with concurrency CONCUR_READ_ONLY cannot be updated."
msgstr "ResultSets se soubnost CONCUR_READ_ONLY neme bt aktualizovno"
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1650
#, java-format
msgid "No primary key found for table {0}."
msgstr "Nenalezen primrn kl pro tabulku {0}."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1876
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2958
msgid "Fetch size must be a value greater to or equal to 0."
msgstr "Nabran velikost mus bt nezporn."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2044
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2051
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2098
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2106
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2926
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2934
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2964
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2971
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2991
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3002
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3020
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3038
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3179
#: org/postgresql/jdbc2/TimestampUtils.java:258
#, java-format
msgid "Bad value for type {0} : {1}"
msgstr "patn hodnota pro typ {0} : {1}"
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2727
#, java-format
msgid "The column name {0} was not found in this ResultSet."
msgstr "Sloupec pojmenovan {0} nebyl nalezen v ResultSet."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2827
msgid ""
"ResultSet is not updateable. The query that generated this result set must "
"select only one table, and must select all primary keys from that table. See "
"the JDBC 2.1 API Specification, section 5.6 for more details."
msgstr ""
"ResultSet nen aktualizavateln. Dotaz mus vybrat pouze z jedn tabulky a "
"mus obsahovat vechny primrn kle tabulky. Koukni do JDBC 2.1 API "
"Specifikace, sekce 5.6 pro vce podrobnost."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2839
msgid "This ResultSet is closed."
msgstr "Tento ResultSet je uzaven."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2860
msgid "ResultSet not positioned properly, perhaps you need to call next."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:259
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:323
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:392
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2648
msgid ""
"Can''t use query methods that take a query string on a PreparedStatement."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:287
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:306
msgid "Multiple ResultSets were returned by the query."
msgstr "Vcensobn ResultSet byl vrcen dotazem."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:425
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:429
msgid "A CallableStatement was executed with nothing returned."
msgstr "CallableStatement byl sputn, le nic nebylo vrceno."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:437
#, fuzzy
msgid "A CallableStatement was executed with an invalid number of parameters"
msgstr "CallableStatement byl sputn, le nic nebylo vrceno."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:468
#, java-format
msgid ""
"A CallableStatement function was executed and the out parameter {0} was of "
"type {1} however type {2} was registered."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:670
msgid "Maximum number of rows must be a value grater than or equal to 0."
msgstr "Maximln poet dek mus bt nezporn slo."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:713
msgid "Query timeout must be a value greater than or equals to 0."
msgstr "asov limit dotazu mus bt nezporn slo."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:804
msgid "The maximum field size must be a value greater than or equal to 0."
msgstr "Maximln velikost pole mus bt nezporn slo."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1219
msgid "Unknown Types value."
msgstr "Neznm hodnota typu."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1492
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1617
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3101
#, java-format
msgid "Invalid stream length {0}."
msgstr "Vadn dlka proudu {0}."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1523
#, java-format
msgid "The JVM claims not to support the {0} encoding."
msgstr "JVM tvrd, e nepodporuje kodovn {0}."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1698
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3023
#, java-format
msgid "Unknown type {0}."
msgstr "Neznm typ {0}."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1713
msgid "No hstore extension installed."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1838
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1844
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1850
#, java-format
msgid "Cannot cast an instance of {0} to type {1}"
msgstr "Nemohu petypovat instanci {0} na typ {1}"
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1862
#, java-format
msgid "Unsupported Types value: {0}"
msgstr "Nepodporovan hodnota typu: {0}"
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1920
#, java-format
msgid ""
"Can''t infer the SQL type to use for an instance of {0}. Use setObject() "
"with an explicit Types value to specify the type to use."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1968
msgid ""
"This statement does not declare an OUT parameter. Use '{' ?= call ... '}' "
"to declare one."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2018
msgid "wasNull cannot be call before fetching a result."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2514
#, java-format
msgid "Malformed function or procedure escape syntax at offset {0}."
msgstr "Pokozen funkce nebo oputn procedury na pozici {0}."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2564
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2578
#, java-format
msgid ""
"Parameter of type {0} was registered, but call to get{1} (sqltype={2}) was "
"made."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2597
msgid ""
"A CallableStatement was declared, but no call to registerOutParameter(1, "
") was made."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2601
msgid "No function outputs were registered."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2604
msgid ""
"Results cannot be retrieved from a CallableStatement before it is executed."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2637
msgid "This statement has been closed."
msgstr "Pkaz byl uzaven."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2717
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2787
msgid "Too many update results were returned."
msgstr "Bylo vrceno pli mnoho vsledk aktualizac."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2746
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2816
#, java-format
msgid ""
"Batch entry {0} {1} was aborted. Call getNextException to see the cause."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3071
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3160
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3200
msgid "Unexpected error writing large object to database."
msgstr "Neoekvan chyba pi zapisovn velkho objektu do databze."
#: org/postgresql/jdbc2/EscapedFunctions.java:145
#: org/postgresql/jdbc2/EscapedFunctions.java:157
#: org/postgresql/jdbc2/EscapedFunctions.java:169
#: org/postgresql/jdbc2/EscapedFunctions.java:206
#: org/postgresql/jdbc2/EscapedFunctions.java:243
#: org/postgresql/jdbc2/EscapedFunctions.java:267
#: org/postgresql/jdbc2/EscapedFunctions.java:292
#: org/postgresql/jdbc2/EscapedFunctions.java:316
#: org/postgresql/jdbc2/EscapedFunctions.java:328
#: org/postgresql/jdbc2/EscapedFunctions.java:352
#: org/postgresql/jdbc2/EscapedFunctions.java:380
#: org/postgresql/jdbc2/EscapedFunctions.java:389
#: org/postgresql/jdbc2/EscapedFunctions.java:399
#: org/postgresql/jdbc2/EscapedFunctions.java:408
#: org/postgresql/jdbc2/EscapedFunctions.java:417
#: org/postgresql/jdbc2/EscapedFunctions.java:426
#: org/postgresql/jdbc2/EscapedFunctions.java:435
#: org/postgresql/jdbc2/EscapedFunctions.java:444
#: org/postgresql/jdbc2/EscapedFunctions.java:453
#: org/postgresql/jdbc2/EscapedFunctions.java:462
#: org/postgresql/jdbc2/EscapedFunctions.java:471
#: org/postgresql/jdbc2/EscapedFunctions.java:480
#, java-format
msgid "{0} function takes one and only one argument."
msgstr "Funkce {0} bere jeden argument."
#: org/postgresql/jdbc2/EscapedFunctions.java:181
#: org/postgresql/jdbc2/EscapedFunctions.java:193
#: org/postgresql/jdbc2/EscapedFunctions.java:255
#: org/postgresql/jdbc2/EscapedFunctions.java:304
#: org/postgresql/jdbc2/EscapedFunctions.java:582
#, java-format
msgid "{0} function takes two and only two arguments."
msgstr "Funkce {0} bere prv dva argumenty."
#: org/postgresql/jdbc2/EscapedFunctions.java:230
#, java-format
msgid "{0} function takes four and only four argument."
msgstr "Funkce {0} bere pesn tyi argumenty."
#: org/postgresql/jdbc2/EscapedFunctions.java:282
#: org/postgresql/jdbc2/EscapedFunctions.java:342
#, java-format
msgid "{0} function takes two or three arguments."
msgstr "Funkce {0} bere dva nebo ti argumenty."
#: org/postgresql/jdbc2/EscapedFunctions.java:362
#: org/postgresql/jdbc2/EscapedFunctions.java:371
#: org/postgresql/jdbc2/EscapedFunctions.java:573
#: org/postgresql/jdbc2/EscapedFunctions.java:591
#, java-format
msgid "{0} function doesn''t take any argument."
msgstr "Funkce {0} nebere dn argument."
#: org/postgresql/jdbc2/EscapedFunctions.java:489
#: org/postgresql/jdbc2/EscapedFunctions.java:531
#, fuzzy, java-format
msgid "{0} function takes three and only three arguments."
msgstr "Funkce {0} bere prv dva argumenty."
#: org/postgresql/jdbc2/EscapedFunctions.java:501
#: org/postgresql/jdbc2/EscapedFunctions.java:521
#: org/postgresql/jdbc2/EscapedFunctions.java:523
#: org/postgresql/jdbc2/EscapedFunctions.java:543
#: org/postgresql/jdbc2/EscapedFunctions.java:564
#: org/postgresql/jdbc2/EscapedFunctions.java:566
#, fuzzy, java-format
msgid "Interval {0} not yet implemented"
msgstr "Metoda {0} nen implementovna."
#: org/postgresql/jdbc2/TimestampUtils.java:360
msgid ""
"Infinite value found for timestamp/date. This cannot be represented as time."
msgstr "Nekonen hodnota pro timestamp/date. Toto neme reprezentovat as."
#: org/postgresql/jdbc2/TimestampUtils.java:648
#: org/postgresql/jdbc2/TimestampUtils.java:680
#: org/postgresql/jdbc2/TimestampUtils.java:727
#, fuzzy, java-format
msgid "Unsupported binary encoding of {0}."
msgstr "Nepodporovan hodnota typu: {0}"
#: org/postgresql/jdbc2/TypeInfoCache.java:161
#, java-format
msgid "The class {0} does not implement org.postgresql.util.PGobject."
msgstr "Tda {0} nepodporuje org.postgresql.util.PGobject."
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:60
#, java-format
msgid "Unknown ResultSet holdability setting: {0}."
msgstr ""
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:98
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:130
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:165
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:187
msgid "Server versions prior to 8.0 do not support savepoints."
msgstr "Verze serveru ni ne 8.0 nepodporuj savepoints."
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:100
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:132
msgid "Cannot establish a savepoint in auto-commit mode."
msgstr "Nemohu vytvoit savepoint v auto-commit modu."
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:419
msgid "Returning autogenerated keys is not supported."
msgstr "Vrcen automaticky generovanch kl nen podporovno."
#: org/postgresql/jdbc3/AbstractJdbc3ParameterMetaData.java:81
#, java-format
msgid "The parameter index is out of range: {0}, number of parameters: {1}."
msgstr "Index parametru mimo rozsah: {0}, poet parametr {1}."
#: org/postgresql/jdbc3/AbstractJdbc3Statement.java:151
#, fuzzy
msgid ""
"Returning autogenerated keys is only supported for 8.2 and later servers."
msgstr "Vrcen automaticky generovanch kl nen podporovno."
#: org/postgresql/jdbc3/AbstractJdbc3Statement.java:199
#: org/postgresql/jdbc3/AbstractJdbc3Statement.java:317
#, fuzzy
msgid "Returning autogenerated keys by column index is not supported."
msgstr "Vrcen automaticky generovanch kl nen podporovno."
#: org/postgresql/jdbc3/PSQLSavepoint.java:38
#: org/postgresql/jdbc3/PSQLSavepoint.java:50
#: org/postgresql/jdbc3/PSQLSavepoint.java:66
msgid "Cannot reference a savepoint after it has been released."
msgstr "Nemohu zskat odkaz na savepoint, kdy byl uvolnn."
#: org/postgresql/jdbc3/PSQLSavepoint.java:42
msgid "Cannot retrieve the id of a named savepoint."
msgstr "Nemohu zskat id nepojmenovanho savepointu."
#: org/postgresql/jdbc3/PSQLSavepoint.java:54
msgid "Cannot retrieve the name of an unnamed savepoint."
msgstr "Nemohu zskat nzev nepojmenovanho savepointu."
#: org/postgresql/jdbc3g/AbstractJdbc3gResultSet.java:37
msgid "Invalid UUID data."
msgstr ""
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:83
#, java-format
msgid "Unable to find server array type for provided name {0}."
msgstr ""
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:120
#, fuzzy, java-format
msgid "Invalid timeout ({0}<0)."
msgstr "Vadn dlka proudu {0}."
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:133
msgid "Validating connection."
msgstr ""
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:156
#, fuzzy, java-format
msgid "Failed to set ClientInfo property: {0}"
msgstr "Selhalo vytvoen objektu: {0}."
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:165
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:187
#, fuzzy
msgid "ClientInfo property not supported."
msgstr "Vrcen automaticky generovanch kl nen podporovno."
#: org/postgresql/jdbc4/AbstractJdbc4Statement.java:127
msgid "Object is too large to send over the protocol."
msgstr ""
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:147
msgid "Unable to decode xml data."
msgstr ""
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:150
#, java-format
msgid "Unknown XML Source class: {0}"
msgstr ""
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:195
#, fuzzy
msgid "Unable to create SAXResult for SQLXML."
msgstr "Selhalo vytvoen objektu: {0}."
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:209
msgid "Unable to create StAXResult for SQLXML"
msgstr ""
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:213
#, java-format
msgid "Unknown XML Result class: {0}"
msgstr ""
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:226
#, fuzzy
msgid "This SQLXML object has already been freed."
msgstr "Tento PooledConnection byl uzaven."
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:233
msgid ""
"This SQLXML object has not been initialized, so you cannot retrieve data "
"from it."
msgstr ""
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:244
#, java-format
msgid "Failed to convert binary xml data to encoding: {0}."
msgstr ""
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:269
msgid "Unable to convert DOMResult SQLXML data to a string."
msgstr ""
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:282
msgid ""
"This SQLXML object has already been initialized, so you cannot manipulate it "
"further."
msgstr ""
#: org/postgresql/largeobject/LargeObjectManager.java:138
msgid "Failed to initialize LargeObject API"
msgstr "Selhala inicializace LargeObject API"
#: org/postgresql/largeobject/LargeObjectManager.java:198
#: org/postgresql/largeobject/LargeObjectManager.java:239
msgid "Large Objects may not be used in auto-commit mode."
msgstr "Velk objecky nemohou bt pouity v auto-commit modu."
#: org/postgresql/ssl/jdbc3/AbstractJdbc3MakeSSL.java:58
#: org/postgresql/ssl/jdbc4/AbstractJdbc4MakeSSL.java:110
#, java-format
msgid "The SSLSocketFactory class provided {0} could not be instantiated."
msgstr "Tda SSLSocketFactory poskytla {0} co neme bt instancionizovno."
#: org/postgresql/ssl/jdbc4/AbstractJdbc4MakeSSL.java:125
#, java-format
msgid "SSL error: {0}"
msgstr ""
#: org/postgresql/ssl/jdbc4/AbstractJdbc4MakeSSL.java:138
#, fuzzy, java-format
msgid "The HostnameVerifier class provided {0} could not be instantiated."
msgstr "Tda SSLSocketFactory poskytla {0} co neme bt instancionizovno."
#: org/postgresql/ssl/jdbc4/AbstractJdbc4MakeSSL.java:142
#, java-format
msgid "The hostname {0} could not be verified by hostnameverifier {1}."
msgstr ""
#: org/postgresql/ssl/jdbc4/AbstractJdbc4MakeSSL.java:149
#, java-format
msgid "The hostname {0} could not be verified."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:121
msgid ""
"Could not find a java cryptographic algorithm: X.509 CertificateFactory not "
"available."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:132
#, java-format
msgid "Could not open SSL certificate file {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:137
#, java-format
msgid "Loading the SSL certificate {0} into a KeyManager failed."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:194
msgid "Enter SSL password: "
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:202
msgid "Could not read password for SSL key file, console is not available."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:204
#, java-format
msgid "Could not read password for SSL key file by callbackhandler {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:223
#, java-format
msgid "Could not decrypt SSL key file {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:231
#, java-format
msgid "Could not read SSL key file {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:235
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:173
#, java-format
msgid "Could not find a java cryptographic algorithm: {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:99
#, fuzzy, java-format
msgid "The password callback class provided {0} could not be instantiated."
msgstr "Tda SSLSocketFactory poskytla {0} co neme bt instancionizovno."
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:133
#, java-format
msgid "Could not open SSL root certificate file {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:150
#, java-format
msgid "Could not read SSL root certificate file {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:153
#, java-format
msgid "Loading the SSL root certificate {0} into a TrustManager failed."
msgstr ""
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:166
msgid "Could not initialize SSL context."
msgstr ""
#: org/postgresql/util/PGInterval.java:164
#, fuzzy
msgid "Conversion of interval failed"
msgstr "Pevod penz selhal."
#: org/postgresql/util/PGmoney.java:73
msgid "Conversion of money failed."
msgstr "Pevod penz selhal."
#: org/postgresql/util/ServerErrorMessage.java:155
#, java-format
msgid "Detail: {0}"
msgstr "Detail: {0}"
#: org/postgresql/util/ServerErrorMessage.java:159
#, java-format
msgid "Hint: {0}"
msgstr "Rada: {0}"
#: org/postgresql/util/ServerErrorMessage.java:162
#, java-format
msgid "Position: {0}"
msgstr "Pozice: {0}"
#: org/postgresql/util/ServerErrorMessage.java:165
#, java-format
msgid "Where: {0}"
msgstr "Kde: {0}"
#: org/postgresql/util/ServerErrorMessage.java:171
#, java-format
msgid "Internal Query: {0}"
msgstr ""
#: org/postgresql/util/ServerErrorMessage.java:174
#, fuzzy, java-format
msgid "Internal Position: {0}"
msgstr "Pozice: {0}"
#: org/postgresql/util/ServerErrorMessage.java:180
#, java-format
msgid "Location: File: {0}, Routine: {1}, Line: {2}"
msgstr "Poloha: Soubor: {0}, Rutina: {1}, dek: {2}"
#: org/postgresql/util/ServerErrorMessage.java:183
#, java-format
msgid "Server SQLState: {0}"
msgstr "Server SQLState: {0}"
#: org/postgresql/xa/PGXAConnection.java:148
msgid ""
"Transaction control methods setAutoCommit(true), commit, rollback and "
"setSavePoint not allowed while an XA transaction is active."
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:186
#: org/postgresql/xa/PGXAConnection.java:245
msgid "Invalid flags"
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:189
#: org/postgresql/xa/PGXAConnection.java:248
#: org/postgresql/xa/PGXAConnection.java:425
msgid "xid must not be null"
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:192
msgid "Connection is busy with another transaction"
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:198
#: org/postgresql/xa/PGXAConnection.java:255
msgid "suspend/resume not implemented"
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:204
#: org/postgresql/xa/PGXAConnection.java:207
#: org/postgresql/xa/PGXAConnection.java:209
msgid "Transaction interleaving not implemented"
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:218
msgid "Error disabling autocommit"
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:251
msgid "tried to call end without corresponding start call"
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:282
msgid ""
"Not implemented: Prepare must be issued using the same connection that "
"started the transaction"
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:286
msgid "Prepare called before end"
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:292
#, fuzzy
msgid "Server versions prior to 8.1 do not support two-phase commit."
msgstr "Verze serveru ni ne 8.0 nepodporuj savepoints."
#: org/postgresql/xa/PGXAConnection.java:313
msgid "Error preparing transaction"
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:328
msgid "Invalid flag"
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:368
msgid "Error during recover"
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:416
msgid "Error rolling back prepared transaction"
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:451
msgid ""
"Not implemented: one-phase commit must be issued using the same connection "
"that was used to start it"
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:455
msgid "commit called before end"
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:466
msgid "Error during one-phase commit"
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:487
msgid ""
"Not implemented: 2nd phase commit must be issued using an idle connection"
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:507
msgid "Error committing prepared transaction"
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:522
msgid "Heuristic commit/rollback not supported"
msgstr ""
#~ msgid "The driver does not support SSL."
#~ msgstr "Ovlada nepodporuje SSL."
#~ msgid "Multi-dimensional arrays are currently not supported."
#~ msgstr "Vce-rozmrn pole nejsou nyn podporovny."
#~ msgid "rand function only takes zero or one argument(the seed)."
#~ msgstr "Funkce rand bere dn nebo jen jeden argument(seed)."
#~ msgid "Exception: {0}"
#~ msgstr "Vyjmka: {0}"
#~ msgid "Stack Trace:"
#~ msgstr "Vpis zsobnku:"
#~ msgid "End of Stack Trace"
#~ msgstr "Konec vpisu zsobnku"
#~ msgid "Exception generating stacktrace for: {0} encountered: {1}"
#~ msgstr "Vyjmka tvoc vpis zsobnku pro: {0} encountered: {1}"
#~ msgid ""
#~ "PostgreSQL only supports a single OUT function return value at index 1."
#~ msgstr ""
#~ "PostgreSQL podporuje pouze funkce s jednou navratovou hodnotou na indexu "
#~ "1."
postgresql-jdbc-9.2-1002.src/org/postgresql/translation/de.po 0000664 0000000 0000000 00000165465 12050675701 0024141 0 ustar 00root root 0000000 0000000 # translation of head-de.po to Deutsch
# German message translation for the PostgreSQL JDBC driver
# This file is distributed under the same license as the package.
#
# Andre Bialojahn , 2005, 2006, 2008.
#
msgid ""
msgstr ""
"Project-Id-Version: head-de\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2012-09-10 19:32-0400\n"
"PO-Revision-Date: 2008-09-12 14:22+0200\n"
"Last-Translator: Andre Bialojahn \n"
"Language-Team: Deutsch\n"
"Language: \n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=ISO-8859-1\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: KBabel 1.0.2\n"
"X-Poedit-Language: German\n"
"X-Poedit-Country: GERMANY\n"
#: bin/org/postgresql/Driver.java.in:235 org/postgresql/Driver.java.in:235
msgid "Error loading default settings from driverconfig.properties"
msgstr "Fehler beim Laden der Voreinstellungen aus driverconfig.properties"
#: bin/org/postgresql/Driver.java.in:282 org/postgresql/Driver.java.in:282
msgid ""
"Your security policy has prevented the connection from being attempted. You "
"probably need to grant the connect java.net.SocketPermission to the database "
"server host and port that you wish to connect to."
msgstr ""
"Ihre Sicherheitsrichtlinie hat den Versuch des Verbindungsaufbaus "
"verhindert. Sie mssen wahrscheinlich der Verbindung zum Datenbankrechner "
"java.net.SocketPermission gewhren, um den Rechner auf dem gewhlten Port zu "
"erreichen."
#: bin/org/postgresql/Driver.java.in:287 bin/org/postgresql/Driver.java.in:351
#: org/postgresql/Driver.java.in:287 org/postgresql/Driver.java.in:351
msgid ""
"Something unusual has occured to cause the driver to fail. Please report "
"this exception."
msgstr ""
"Etwas Ungewhnliches ist passiert, das den Treiber fehlschlagen lie. Bitte "
"teilen Sie diesen Fehler mit."
#: bin/org/postgresql/Driver.java.in:359 org/postgresql/Driver.java.in:359
msgid "Connection attempt timed out."
msgstr "Keine Verbindung innerhalb des Zeitintervalls mglich."
#: bin/org/postgresql/Driver.java.in:367 org/postgresql/Driver.java.in:367
msgid "Interrupted while attempting to connect."
msgstr "Beim Verbindungsversuch trat eine Unterbrechung auf."
#: bin/org/postgresql/Driver.java.in:710 org/postgresql/Driver.java.in:710
#, java-format
msgid "Method {0} is not yet implemented."
msgstr "Die Methode {0} ist noch nicht implementiert."
#: org/postgresql/copy/CopyManager.java:56
#, java-format
msgid "Requested CopyIn but got {0}"
msgstr ""
#: org/postgresql/copy/CopyManager.java:67
#, java-format
msgid "Requested CopyOut but got {0}"
msgstr ""
#: org/postgresql/copy/PGCopyInputStream.java:51
#, fuzzy, java-format
msgid "Copying from database failed: {0}"
msgstr "Konnte {0} nicht in Typ box umwandeln"
#: org/postgresql/copy/PGCopyInputStream.java:67
#: org/postgresql/copy/PGCopyOutputStream.java:90
#, fuzzy
msgid "This copy stream is closed."
msgstr "Dieses ResultSet ist geschlossen."
#: org/postgresql/copy/PGCopyInputStream.java:108
msgid "Read from copy failed."
msgstr ""
#: org/postgresql/copy/PGCopyOutputStream.java:68
#, java-format
msgid "Cannot write to copy a byte of value {0}"
msgstr ""
#: org/postgresql/core/ConnectionFactory.java:70
#, java-format
msgid "A connection could not be made using the requested protocol {0}."
msgstr ""
"Es konnte keine Verbindung unter Verwendung des Protokolls {0} hergestellt "
"werden."
#: org/postgresql/core/Oid.java:113
#, java-format
msgid "oid type {0} not known and not a number"
msgstr ""
#: org/postgresql/core/PGStream.java:490
#, java-format
msgid "Premature end of input stream, expected {0} bytes, but only read {1}."
msgstr ""
"Vorzeitiges Ende des Eingabedatenstroms. Es wurden {0} Bytes erwartet, "
"jedoch nur {1} gelesen."
#: org/postgresql/core/PGStream.java:530
#, java-format
msgid "Expected an EOF from server, got: {0}"
msgstr "Vom Server wurde ein EOF erwartet, jedoch {0} gelesen."
#: org/postgresql/core/SetupQueryRunner.java:86
msgid "An unexpected result was returned by a query."
msgstr "Eine Abfrage lieferte ein unerwartetes Resultat."
#: org/postgresql/core/UTF8Encoding.java:28
#, java-format
msgid ""
"Illegal UTF-8 sequence: byte {0} of {1} byte sequence is not 10xxxxxx: {2}"
msgstr ""
"Ungltige UTF-8-Sequenz: Byte {0} der {1} Bytesequenz ist nicht 10xxxxxx: {2}"
#: org/postgresql/core/UTF8Encoding.java:61
#, java-format
msgid "Illegal UTF-8 sequence: {0} bytes used to encode a {1} byte value: {2}"
msgstr ""
"Ungltige UTF-8-Sequenz: {0} Bytes wurden verwendet um einen {1} Bytewert zu "
"kodieren: {2}"
#: org/postgresql/core/UTF8Encoding.java:98
#: org/postgresql/core/UTF8Encoding.java:125
#, java-format
msgid "Illegal UTF-8 sequence: initial byte is {0}: {1}"
msgstr "Ungltige UTF-8-Sequenz: das erste Byte ist {0}: {1}"
#: org/postgresql/core/UTF8Encoding.java:130
#, java-format
msgid "Illegal UTF-8 sequence: final value is out of range: {0}"
msgstr ""
"Ungltige UTF-8-Sequenz: Der letzte Wert ist auerhalb des zulssigen "
"Bereichs: {0}"
#: org/postgresql/core/UTF8Encoding.java:145
#, java-format
msgid "Illegal UTF-8 sequence: final value is a surrogate value: {0}"
msgstr "Ungltige UTF-8-Sequenz: der letzte Wert ist ein Ersatzwert: {0}"
#: org/postgresql/core/Utils.java:95 org/postgresql/core/Utils.java:112
msgid "Zero bytes may not occur in string parameters."
msgstr "Stringparameter drfen keine Nullbytes enthalten."
#: org/postgresql/core/Utils.java:145
msgid "Zero bytes may not occur in identifiers."
msgstr "Nullbytes drfen in Bezeichnern nicht vorkommen."
#: org/postgresql/core/types/PGBigDecimal.java:63
#: org/postgresql/core/types/PGBoolean.java:62
#: org/postgresql/core/types/PGByte.java:63
#: org/postgresql/core/types/PGDouble.java:64
#: org/postgresql/core/types/PGFloat.java:64
#: org/postgresql/core/types/PGInteger.java:61
#: org/postgresql/core/types/PGLong.java:62
#: org/postgresql/core/types/PGNumber.java:62
#: org/postgresql/core/types/PGShort.java:58
#: org/postgresql/core/types/PGString.java:73
#, java-format
msgid "Cannot convert an instance of {0} to type {1}"
msgstr "Die Typwandlung fr eine Instanz von {0} nach {1} ist nicht mglich."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:66
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:74
#, fuzzy, java-format
msgid "Invalid sslmode value: {0}"
msgstr "Ungltige Lnge des Datenstroms: {0}."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:134
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:168
msgid ""
"Connection refused. Check that the hostname and port are correct and that "
"the postmaster is accepting TCP/IP connections."
msgstr ""
"Verbindung verweigert. berprfen Sie die Korrektheit von Hostnamen und der "
"Portnummer und dass der Datenbankserver TCP/IP-Verbindungen annimmt."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:153
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:186
msgid "The connection attempt failed."
msgstr "Der Verbindungsversuch schlug fehl."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:175
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:207
#, fuzzy
msgid "The connection url is invalid."
msgstr "Der Verbindungsversuch schlug fehl."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:198
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:210
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:256
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:268
msgid "The server does not support SSL."
msgstr "Der Server untersttzt SSL nicht."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:223
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:281
msgid "An error occured while setting up the SSL connection."
msgstr "Beim Aufbau der SSL-Verbindung trat ein Fehler auf."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:272
#, java-format
msgid "Connection rejected: {0}."
msgstr "Verbindung abgewiesen: {0}."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:290
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:312
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:332
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:380
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:405
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:432
msgid ""
"The server requested password-based authentication, but no password was "
"provided."
msgstr ""
"Der Server verlangt passwortbasierte Authentifizierung, jedoch wurde kein "
"Passwort angegeben."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:356
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:465
#, java-format
msgid ""
"The authentication type {0} is not supported. Check that you have configured "
"the pg_hba.conf file to include the client''s IP address or subnet, and that "
"it is using an authentication scheme supported by the driver."
msgstr ""
"Der Authentifizierungstyp {0} wird nicht untersttzt. Stellen Sie sicher, "
"dass die Datei ''pg_hba.conf'' die IP-Adresse oder das Subnetz des Clients "
"enthlt und dass der Client ein Authentifizierungsschema nutzt, das vom "
"Treiber untersttzt wird."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:362
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:400
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:471
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:514
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:560
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:570
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:579
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:587
#: org/postgresql/gss/MakeGSS.java:158
msgid "Protocol error. Session setup failed."
msgstr "Protokollfehler. Die Sitzung konnte nicht gestartet werden."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:390
#, java-format
msgid "Backend start-up failed: {0}."
msgstr "Das Backend konnte nicht gestartet werden: {0}."
#: org/postgresql/core/v2/FastpathParameterList.java:55
#: org/postgresql/core/v2/FastpathParameterList.java:77
#: org/postgresql/core/v2/FastpathParameterList.java:84
#: org/postgresql/core/v2/SimpleParameterList.java:57
#: org/postgresql/core/v2/SimpleParameterList.java:76
#: org/postgresql/core/v2/SimpleParameterList.java:83
#: org/postgresql/core/v2/SimpleParameterList.java:90
#: org/postgresql/core/v3/CompositeParameterList.java:35
#: org/postgresql/core/v3/SimpleParameterList.java:47
#: org/postgresql/core/v3/SimpleParameterList.java:54
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2845
#: org/postgresql/jdbc2/AbstractJdbc2ResultSetMetaData.java:419
#, java-format
msgid "The column index is out of range: {0}, number of columns: {1}."
msgstr ""
"Der Spaltenindex {0} ist auerhalb des gltigen Bereichs. Anzahl Spalten: "
"{1}."
#: org/postgresql/core/v2/FastpathParameterList.java:142
#: org/postgresql/core/v2/SimpleParameterList.java:155
#: org/postgresql/core/v3/SimpleParameterList.java:183
#, java-format
msgid "No value specified for parameter {0}."
msgstr "Fr den Parameter {0} wurde kein Wert angegeben."
#: org/postgresql/core/v2/QueryExecutorImpl.java:72
#: org/postgresql/core/v2/QueryExecutorImpl.java:337
#: org/postgresql/core/v3/QueryExecutorImpl.java:443
#: org/postgresql/core/v3/QueryExecutorImpl.java:507
#, java-format
msgid "Expected command status BEGIN, got {0}."
msgstr "Statt des erwarteten Befehlsstatus BEGIN, wurde {0} empfangen."
#: org/postgresql/core/v2/QueryExecutorImpl.java:78
#: org/postgresql/core/v3/QueryExecutorImpl.java:513
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1828
#, java-format
msgid "Unexpected command status: {0}."
msgstr "Unerwarteter Befehlsstatus: {0}."
#: org/postgresql/core/v2/QueryExecutorImpl.java:118
#: org/postgresql/core/v2/QueryExecutorImpl.java:129
#: org/postgresql/core/v2/QueryExecutorImpl.java:174
#: org/postgresql/core/v2/QueryExecutorImpl.java:369
#: org/postgresql/core/v3/QueryExecutorImpl.java:281
#: org/postgresql/core/v3/QueryExecutorImpl.java:411
#: org/postgresql/core/v3/QueryExecutorImpl.java:485
#: org/postgresql/core/v3/QueryExecutorImpl.java:551
#: org/postgresql/core/v3/QueryExecutorImpl.java:631
#: org/postgresql/core/v3/QueryExecutorImpl.java:2094
msgid "An I/O error occured while sending to the backend."
msgstr "Eingabe/Ausgabe-Fehler {0} beim Senden an das Backend."
#: org/postgresql/core/v2/QueryExecutorImpl.java:170
#: org/postgresql/core/v2/QueryExecutorImpl.java:225
#: org/postgresql/core/v2/QueryExecutorImpl.java:236
#: org/postgresql/core/v3/QueryExecutorImpl.java:627
#: org/postgresql/core/v3/QueryExecutorImpl.java:685
#, java-format
msgid "Unknown Response Type {0}."
msgstr "Die Antwort weist einen unbekannten Typ auf: {0}."
#: org/postgresql/core/v2/QueryExecutorImpl.java:430
#: org/postgresql/core/v2/QueryExecutorImpl.java:475
#: org/postgresql/core/v3/QueryExecutorImpl.java:1857
msgid "Ran out of memory retrieving query results."
msgstr "Nicht gengend Speicher beim Abholen der Abfrageergebnisse."
#: org/postgresql/core/v2/QueryExecutorImpl.java:597
#: org/postgresql/core/v3/QueryExecutorImpl.java:2199
#, java-format
msgid "Unable to interpret the update count in command completion tag: {0}."
msgstr ""
"Der Updatecount aus der Kommandovervollstndigungsmarkierung(?) {0} konnte "
"nicht interpretiert werden."
#: org/postgresql/core/v2/QueryExecutorImpl.java:610
msgid "Copy not implemented for protocol version 2"
msgstr ""
#: org/postgresql/core/v3/CopyOperationImpl.java:56
msgid "CommandComplete expected COPY but got: "
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:66
msgid "Tried to obtain lock while already holding it"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:78
msgid "Tried to break lock on database connection"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:93
#, fuzzy
msgid "Interrupted while waiting to obtain lock on database connection"
msgstr "Beim Verbindungsversuch trat eine Unterbrechung auf."
#: org/postgresql/core/v3/QueryExecutorImpl.java:275
msgid "Unable to bind parameter values for statement."
msgstr "Der Anweisung konnten keine Parameterwerte zugewiesen werden."
#: org/postgresql/core/v3/QueryExecutorImpl.java:726
msgid "Database connection failed when starting copy"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:757
msgid "Tried to cancel an inactive copy operation"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:794
msgid "Database connection failed when canceling copy operation"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:799
msgid "Missing expected error response to copy cancel request"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:801
#, java-format
msgid "Got {0} error responses to single copy cancel request"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:814
msgid "Tried to end inactive copy"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:827
msgid "Database connection failed when ending copy"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:842
#: org/postgresql/core/v3/QueryExecutorImpl.java:860
msgid "Tried to write to an inactive copy operation"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:854
#: org/postgresql/core/v3/QueryExecutorImpl.java:866
msgid "Database connection failed when writing to copy"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:878
msgid "Tried to read from inactive copy"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:883
msgid "Database connection failed when reading from copy"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:951
#, java-format
msgid "Received CommandComplete ''{0}'' without an active copy operation"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:975
#, java-format
msgid "Got CopyInResponse from server during an active {0}"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:988
#, java-format
msgid "Got CopyOutResponse from server during an active {0}"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:1003
msgid "Got CopyData without an active copy operation"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:1005
#, fuzzy, java-format
msgid "Unexpected copydata from server for {0}"
msgstr "Vom Server wurde ein EOF erwartet, jedoch {0} gelesen."
#: org/postgresql/core/v3/QueryExecutorImpl.java:1056
#, java-format
msgid "Unexpected packet type during copy: {0}"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:1310
#, java-format
msgid ""
"Bind message length {0} too long. This can be caused by very large or "
"incorrect length specifications on InputStream parameters."
msgstr ""
"Die Nachrichtenlnge {0} ist zu gro. Das kann von sehr groen oder "
"inkorrekten Lngenangaben eines InputStream-Parameters herrhren."
#: org/postgresql/core/v3/QueryExecutorImpl.java:1925
#, fuzzy, java-format
msgid ""
"The server''s client_encoding parameter was changed to {0}. The JDBC driver "
"requires client_encoding to be UTF8 for correct operation."
msgstr ""
"Der Parameter ''client_encoding'' wurde auf dem Server auf {0} verndert. "
"Der JDBC-Treiber setzt fr korrektes Funktionieren die Einstellung UNICODE "
"voraus."
#: org/postgresql/core/v3/QueryExecutorImpl.java:1932
#, java-format
msgid ""
"The server''s DateStyle parameter was changed to {0}. The JDBC driver "
"requires DateStyle to begin with ISO for correct operation."
msgstr ""
"Der Parameter ''Date Style'' wurde auf dem Server auf {0} verndert. Der "
"JDBC-Treiber setzt fr korrekte Funktion voraus, dass ''Date Style'' mit "
"''ISO'' beginnt."
#: org/postgresql/core/v3/QueryExecutorImpl.java:1945
#, java-format
msgid ""
"The server''s standard_conforming_strings parameter was reported as {0}. The "
"JDBC driver expected on or off."
msgstr ""
"Der standard_conforming_strings Parameter des Servers steht auf {0}. Der "
"JDBC-Treiber erwartete on oder off."
#: org/postgresql/core/v3/QueryExecutorImpl.java:2015
msgid "The driver currently does not support COPY operations."
msgstr "Der Treiber untersttzt derzeit keine COPY-Operationen."
#: org/postgresql/ds/jdbc23/AbstractJdbc23PooledConnection.java:112
msgid "This PooledConnection has already been closed."
msgstr "Diese PooledConnection ist bereits geschlossen worden."
#: org/postgresql/ds/jdbc23/AbstractJdbc23PooledConnection.java:295
msgid ""
"Connection has been closed automatically because a new connection was opened "
"for the same PooledConnection or the PooledConnection has been closed."
msgstr ""
"Die Verbindung wurde automatisch geschlossen, da entweder eine neue "
"Verbindung fr die gleiche PooledConnection geffnet wurde, oder die "
"PooledConnection geschlossen worden ist.."
#: org/postgresql/ds/jdbc23/AbstractJdbc23PooledConnection.java:295
msgid "Connection has been closed."
msgstr "Die Verbindung wurde geschlossen."
#: org/postgresql/ds/jdbc23/AbstractJdbc23PooledConnection.java:442
msgid "Statement has been closed."
msgstr "Die Anweisung wurde geschlossen."
#: org/postgresql/ds/jdbc23/AbstractJdbc23PoolingDataSource.java:291
msgid "Failed to setup DataSource."
msgstr ""
#: org/postgresql/ds/jdbc23/AbstractJdbc23PoolingDataSource.java:414
msgid "DataSource has been closed."
msgstr "Die Datenquelle wurde geschlossen."
#: org/postgresql/fastpath/Fastpath.java:81
#: org/postgresql/fastpath/Fastpath.java:128
#, java-format
msgid "Fastpath call {0} - No result was returned and we expected an integer."
msgstr ""
"Der Fastpath-Aufruf {0} gab kein Ergebnis zurck, jedoch wurde ein Integer "
"erwartet."
#: org/postgresql/fastpath/Fastpath.java:237
#, java-format
msgid "The fastpath function {0} is unknown."
msgstr "Die Fastpath-Funktion {0} ist unbekannt."
#: org/postgresql/geometric/PGbox.java:83
#: org/postgresql/geometric/PGcircle.java:82
#: org/postgresql/geometric/PGcircle.java:91
#: org/postgresql/geometric/PGline.java:80
#: org/postgresql/geometric/PGlseg.java:77
#: org/postgresql/geometric/PGpoint.java:85
#, java-format
msgid "Conversion to type {0} failed: {1}."
msgstr "Die Umwandlung in den Typ {0} schlug fehl: {1}."
#: org/postgresql/geometric/PGpath.java:81
#, java-format
msgid "Cannot tell if path is open or closed: {0}."
msgstr ""
"Es konnte nicht ermittelt werden, ob der Pfad offen oder geschlossen ist: "
"{0}."
#: org/postgresql/gss/MakeGSS.java:47 org/postgresql/gss/MakeGSS.java:55
#: org/postgresql/gss/MakeGSS.java:168
msgid "GSS Authentication failed"
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Array.java:153
#: org/postgresql/jdbc2/AbstractJdbc2Array.java:790
#, java-format
msgid "The array index is out of range: {0}"
msgstr "Der Arrayindex ist auerhalb des gltigen Bereichs: {0}."
#: org/postgresql/jdbc2/AbstractJdbc2Array.java:168
#: org/postgresql/jdbc2/AbstractJdbc2Array.java:807
#, java-format
msgid "The array index is out of range: {0}, number of elements: {1}."
msgstr ""
"Der Arrayindex {0} ist auerhalb des gltigen Bereichs. Vorhandene Elemente: "
"{1}."
#: org/postgresql/jdbc2/AbstractJdbc2Array.java:196
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1982
#: org/postgresql/util/HStoreConverter.java:34
#: org/postgresql/util/HStoreConverter.java:61
msgid ""
"Invalid character data was found. This is most likely caused by stored data "
"containing characters that are invalid for the character set the database "
"was created in. The most common example of this is storing 8bit data in a "
"SQL_ASCII database."
msgstr ""
"Ungltige Zeichendaten. Das ist hchstwahrscheinlich von in der Datenbank "
"gespeicherten Zeichen hervorgerufen, die in einer anderen Kodierung "
"vorliegen, als die, in der die Datenbank erstellt wurde. Das hufigste "
"Beispiel dafr ist es, 8Bit-Daten in SQL_ASCII-Datenbanken abzulegen."
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:73
msgid ""
"Truncation of large objects is only implemented in 8.3 and later servers."
msgstr ""
"Das Abschneiden groer Objekte ist nur in Versionen nach 8.3 implementiert."
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:77
msgid "Cannot truncate LOB to a negative length."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:81
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:235
#, java-format
msgid "PostgreSQL LOBs can only index to: {0}"
msgstr "LOBs in PostgreSQL knnen nur auf {0} verweisen."
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:231
msgid "LOB positioning offsets start at 1."
msgstr "Positionsoffsets fr LOBs beginnen bei 1."
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:246
msgid "free() was called on this LOB previously"
msgstr "free() wurde bereits fr dieses LOB aufgerufen."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:229
#, java-format
msgid "Unsupported value for stringtype parameter: {0}"
msgstr "Nichtuntersttzter Wert fr den Stringparameter: {0}"
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:249
msgid "unknownLength parameter value must be an integer"
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:357
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:284
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:303
#: org/postgresql/jdbc2/TypeInfoCache.java:201
#: org/postgresql/jdbc2/TypeInfoCache.java:249
#: org/postgresql/jdbc2/TypeInfoCache.java:287
#: org/postgresql/jdbc2/TypeInfoCache.java:344
#: org/postgresql/jdbc2/TypeInfoCache.java:348
#: org/postgresql/jdbc2/TypeInfoCache.java:384
#: org/postgresql/jdbc2/TypeInfoCache.java:388
msgid "No results were returned by the query."
msgstr "Die Abfrage lieferte kein Ergebnis."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:371
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:336
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:368
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2695
msgid "A result was returned when none was expected."
msgstr "Die Anweisung lieferte ein Ergebnis obwohl keines erwartet wurde."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:523
#, fuzzy
msgid "Custom type maps are not supported."
msgstr "Selbstdefinierte Typabbildungen werden nicht untersttzt."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:571
#, java-format
msgid "Failed to create object for: {0}."
msgstr "Erstellung des Objektes schlug fehl fr: {0}."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:633
#, java-format
msgid "Unable to load the class {0} responsible for the datatype {1}"
msgstr ""
"Die fr den Datentyp {1} verantwortliche Klasse {0} konnte nicht geladen "
"werden."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:729
msgid ""
"Cannot change transaction read-only property in the middle of a transaction."
msgstr ""
"Die Nur-Lesen-Eigenschaft einer Transaktion kann nicht whrend der "
"Transaktion verndert werden."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:817
msgid "Cannot commit when autoCommit is enabled."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:826
#, fuzzy
msgid "This connection has been closed."
msgstr "Die Verbindung wurde geschlossen."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:846
msgid "Cannot rollback when autoCommit is enabled."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:933
msgid ""
"Cannot change transaction isolation level in the middle of a transaction."
msgstr ""
"Die Transaktions-Trennungsstufe kann nicht whrend einer Transaktion "
"verndert werden."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:938
#, java-format
msgid "Transaction isolation level {0} not supported."
msgstr "Die Transaktions-Trennungsstufe {0} ist nicht untersttzt."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:1005
msgid "Finalizing a Connection that was never closed:"
msgstr "Eine Connection wurde finalisiert, die nie geschlossen wurde:"
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:1107
msgid "Unable to translate data into the desired encoding."
msgstr "Die Daten konnten nicht in die gewnschte Kodierung gewandelt werden."
#: org/postgresql/jdbc2/AbstractJdbc2DatabaseMetaData.java:63
msgid ""
"Unable to determine a value for MaxIndexKeys due to missing system catalog "
"data."
msgstr ""
"Es konnte kein Wert fr MaxIndexKeys gefunden werden, da die "
"Systemkatalogdaten fehlen."
#: org/postgresql/jdbc2/AbstractJdbc2DatabaseMetaData.java:86
msgid "Unable to find name datatype in the system catalogs."
msgstr ""
"In den Systemkatalogen konnte der Namensdatentyp nicht gefunden werden."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:235
msgid ""
"Operation requires a scrollable ResultSet, but this ResultSet is "
"FORWARD_ONLY."
msgstr ""
"Die Operation erfordert ein scrollbares ResultSet, dieses jedoch ist "
"FORWARD_ONLY."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:416
msgid "Unexpected error while decoding character data from a large object."
msgstr ""
"Ein unerwarteter Fehler trat beim Dekodieren von Zeichen aus einem "
"LargeObject (LOB) auf."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:462
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:491
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:525
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3129
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3174
#, fuzzy, java-format
msgid "Cannot convert the column of type {0} to requested type {1}."
msgstr "Die Typwandlung fr eine Instanz von {0} nach {1} ist nicht mglich."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:744
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:768
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1892
msgid "Can''t use relative move methods while on the insert row."
msgstr ""
"Relative Bewegungen knnen in der Einfgezeile nicht durchgefhrt werden."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:788
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2949
#, java-format
msgid "Invalid fetch direction constant: {0}."
msgstr "Unzulssige Richtungskonstante bei fetch: {0}."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:802
msgid "Cannot call cancelRowUpdates() when on the insert row."
msgstr ""
"''cancelRowUpdates()'' kann in der Einfgezeile nicht aufgerufen werden."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:822
msgid "Cannot call deleteRow() when on the insert row."
msgstr "''deleteRow()'' kann in der Einfgezeile nicht aufgerufen werden."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:828
msgid ""
"Currently positioned before the start of the ResultSet. You cannot call "
"deleteRow() here."
msgstr ""
"Die augenblickliche Position ist vor dem Beginn des ResultSets. Dort kann "
"''deleteRow()'' nicht aufgerufen werden."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:833
msgid ""
"Currently positioned after the end of the ResultSet. You cannot call "
"deleteRow() here."
msgstr ""
"Die augenblickliche Position ist hinter dem Ende des ResultSets. Dort kann "
"''deleteRow()'' nicht aufgerufen werden."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:838
msgid "There are no rows in this ResultSet."
msgstr "Es gibt keine Zeilen in diesem ResultSet."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:885
msgid "Not on the insert row."
msgstr "Nicht in der Einfgezeile."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:889
msgid "You must specify at least one column value to insert a row."
msgstr ""
"Sie mssen mindestens einen Spaltenwert angeben, um eine Zeile einzufgen."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1074
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1805
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2494
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2524
#, java-format
msgid "The JVM claims not to support the encoding: {0}"
msgstr "Die JVM behauptet, die Zeichenkodierung {0} nicht zu untersttzen."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1078
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1121
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1527
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1656
msgid "Provided InputStream failed."
msgstr "Der bereitgestellte InputStream scheiterte."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1191
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3130
msgid "Provided Reader failed."
msgstr "Der bereitgestellte Reader scheiterte."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1259
msgid "Can''t refresh the insert row."
msgstr "Die Einfgezeile kann nicht aufgefrischt werden."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1327
msgid "Cannot call updateRow() when on the insert row."
msgstr "''updateRow()'' kann in der Einfgezeile nicht aufgerufen werden."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1333
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3190
msgid ""
"Cannot update the ResultSet because it is either before the start or after "
"the end of the results."
msgstr ""
"Das ResultSet kann nicht aktualisiert werden, da es entweder vor oder nach "
"dem Ende der Ergebnisse ist."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1582
msgid "ResultSets with concurrency CONCUR_READ_ONLY cannot be updated."
msgstr ""
"ResultSets, deren Zugriffsart CONCUR_READ_ONLY ist, knnen nicht "
"aktualisiert werden."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1650
#, java-format
msgid "No primary key found for table {0}."
msgstr "Fr die Tabelle {0} konnte kein Primrschlssel gefunden werden."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1876
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2958
msgid "Fetch size must be a value greater to or equal to 0."
msgstr "Die Fetch-Gre muss ein Wert grer oder gleich Null sein."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2044
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2051
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2098
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2106
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2926
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2934
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2964
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2971
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2991
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3002
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3020
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3038
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3179
#: org/postgresql/jdbc2/TimestampUtils.java:258
#, java-format
msgid "Bad value for type {0} : {1}"
msgstr "Unzulssiger Wert fr den Typ {0} : {1}."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2727
#, java-format
msgid "The column name {0} was not found in this ResultSet."
msgstr "Der Spaltenname {0} wurde in diesem ResultSet nicht gefunden."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2827
msgid ""
"ResultSet is not updateable. The query that generated this result set must "
"select only one table, and must select all primary keys from that table. See "
"the JDBC 2.1 API Specification, section 5.6 for more details."
msgstr ""
"Das ResultSet kann nicht aktualisiert werden. Die Abfrage, die es erzeugte, "
"darf nur eine Tabelle und muss darin alle Primrschlssel auswhlen. Siehe "
"JDBC 2.1 API-Spezifikation, Abschnitt 5.6 fr mehr Details."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2839
msgid "This ResultSet is closed."
msgstr "Dieses ResultSet ist geschlossen."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2860
msgid "ResultSet not positioned properly, perhaps you need to call next."
msgstr ""
"Das ResultSet ist nicht richtig positioniert. Eventuell muss ''next'' "
"aufgerufen werden."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:259
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:323
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:392
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2648
#, fuzzy
msgid ""
"Can''t use query methods that take a query string on a PreparedStatement."
msgstr ""
"Abfragemethoden, die einen Abfragestring annehmen, knnen nicht auf ein "
"PreparedStatement angewandt werden."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:287
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:306
msgid "Multiple ResultSets were returned by the query."
msgstr "Die Abfrage ergab mehrere ResultSets."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:425
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:429
msgid "A CallableStatement was executed with nothing returned."
msgstr "Ein CallableStatement wurde ausgefhrt ohne etwas zurckzugeben."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:437
msgid "A CallableStatement was executed with an invalid number of parameters"
msgstr ""
"Ein CallableStatement wurde mit einer falschen Anzahl Parameter ausgefhrt."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:468
#, java-format
msgid ""
"A CallableStatement function was executed and the out parameter {0} was of "
"type {1} however type {2} was registered."
msgstr ""
"Eine CallableStatement-Funktion wurde ausgefhrt und der Rckgabewert {0} "
"war vom Typ {1}. Jedoch wurde der Typ {2} dafr registriert."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:670
msgid "Maximum number of rows must be a value grater than or equal to 0."
msgstr "Die maximale Zeilenzahl muss ein Wert grer oder gleich Null sein."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:713
msgid "Query timeout must be a value greater than or equals to 0."
msgstr "Das Abfragetimeout muss ein Wert grer oder gleich Null sein."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:804
msgid "The maximum field size must be a value greater than or equal to 0."
msgstr "Die maximale Feldgre muss ein Wert grer oder gleich Null sein."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1219
msgid "Unknown Types value."
msgstr "Unbekannter Typ."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1492
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1617
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3101
#, java-format
msgid "Invalid stream length {0}."
msgstr "Ungltige Lnge des Datenstroms: {0}."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1523
#, java-format
msgid "The JVM claims not to support the {0} encoding."
msgstr "Die JVM behauptet, die Zeichenkodierung {0} nicht zu untersttzen."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1698
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3023
#, java-format
msgid "Unknown type {0}."
msgstr "Unbekannter Typ {0}."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1713
msgid "No hstore extension installed."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1838
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1844
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1850
#, java-format
msgid "Cannot cast an instance of {0} to type {1}"
msgstr "Die Typwandlung fr eine Instanz von {0} nach {1} ist nicht mglich."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1862
#, java-format
msgid "Unsupported Types value: {0}"
msgstr "Unbekannter Typ: {0}."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1920
#, java-format
msgid ""
"Can''t infer the SQL type to use for an instance of {0}. Use setObject() "
"with an explicit Types value to specify the type to use."
msgstr ""
"Der in SQL fr eine Instanz von {0} zu verwendende Datentyp kann nicht "
"abgeleitet werden. Benutzen Sie ''setObject()'' mit einem expliziten Typ, um "
"ihn festzulegen."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1968
msgid ""
"This statement does not declare an OUT parameter. Use '{' ?= call ... '}' "
"to declare one."
msgstr ""
"Diese Anweisung deklariert keinen OUT-Parameter. Benutzen Sie '{' ?= "
"call ... '}' um das zu tun."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2018
msgid "wasNull cannot be call before fetching a result."
msgstr ""
"wasNull kann nicht aufgerufen werden, bevor ein Ergebnis abgefragt wurde."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2514
#, java-format
msgid "Malformed function or procedure escape syntax at offset {0}."
msgstr ""
"Unzulssige Syntax fr ein Funktions- oder Prozedur-Escape an Offset {0}."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2564
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2578
#, java-format
msgid ""
"Parameter of type {0} was registered, but call to get{1} (sqltype={2}) was "
"made."
msgstr ""
"Ein Parameter des Typs {0} wurde registriert, jedoch erfolgte ein Aufruf get"
"{1} (sqltype={2})."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2597
msgid ""
"A CallableStatement was declared, but no call to registerOutParameter(1, "
") was made."
msgstr ""
"Ein CallableStatement wurde deklariert, aber kein Aufruf von "
"''registerOutParameter(1, )'' erfolgte."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2601
#, fuzzy
msgid "No function outputs were registered."
msgstr "Es wurden keine Funktionsausgaben registriert."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2604
msgid ""
"Results cannot be retrieved from a CallableStatement before it is executed."
msgstr ""
"Ergebnisse knnen nicht von einem CallableStatement abgerufen werden, bevor "
"es ausgefhrt wurde."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2637
msgid "This statement has been closed."
msgstr "Die Anweisung wurde geschlossen."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2717
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2787
msgid "Too many update results were returned."
msgstr "Zu viele Updateergebnisse wurden zurckgegeben."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2746
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2816
#, java-format
msgid ""
"Batch entry {0} {1} was aborted. Call getNextException to see the cause."
msgstr ""
"Batch-Eintrag {0} {1} wurde abgebrochen. Rufen Sie ''getNextException'' "
"auf, um die Ursache zu erfahren."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3071
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3160
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3200
msgid "Unexpected error writing large object to database."
msgstr ""
"Beim Schreiben eines LargeObjects (LOB) in die Datenbank trat ein "
"unerwarteter Fehler auf."
#: org/postgresql/jdbc2/EscapedFunctions.java:145
#: org/postgresql/jdbc2/EscapedFunctions.java:157
#: org/postgresql/jdbc2/EscapedFunctions.java:169
#: org/postgresql/jdbc2/EscapedFunctions.java:206
#: org/postgresql/jdbc2/EscapedFunctions.java:243
#: org/postgresql/jdbc2/EscapedFunctions.java:267
#: org/postgresql/jdbc2/EscapedFunctions.java:292
#: org/postgresql/jdbc2/EscapedFunctions.java:316
#: org/postgresql/jdbc2/EscapedFunctions.java:328
#: org/postgresql/jdbc2/EscapedFunctions.java:352
#: org/postgresql/jdbc2/EscapedFunctions.java:380
#: org/postgresql/jdbc2/EscapedFunctions.java:389
#: org/postgresql/jdbc2/EscapedFunctions.java:399
#: org/postgresql/jdbc2/EscapedFunctions.java:408
#: org/postgresql/jdbc2/EscapedFunctions.java:417
#: org/postgresql/jdbc2/EscapedFunctions.java:426
#: org/postgresql/jdbc2/EscapedFunctions.java:435
#: org/postgresql/jdbc2/EscapedFunctions.java:444
#: org/postgresql/jdbc2/EscapedFunctions.java:453
#: org/postgresql/jdbc2/EscapedFunctions.java:462
#: org/postgresql/jdbc2/EscapedFunctions.java:471
#: org/postgresql/jdbc2/EscapedFunctions.java:480
#, java-format
msgid "{0} function takes one and only one argument."
msgstr "Die {0}-Funktion erwartet nur genau ein Argument."
#: org/postgresql/jdbc2/EscapedFunctions.java:181
#: org/postgresql/jdbc2/EscapedFunctions.java:193
#: org/postgresql/jdbc2/EscapedFunctions.java:255
#: org/postgresql/jdbc2/EscapedFunctions.java:304
#: org/postgresql/jdbc2/EscapedFunctions.java:582
#, java-format
msgid "{0} function takes two and only two arguments."
msgstr "Die {0}-Funktion erwartet genau zwei Argumente."
#: org/postgresql/jdbc2/EscapedFunctions.java:230
#, java-format
msgid "{0} function takes four and only four argument."
msgstr "Die {0}-Funktion erwartet genau vier Argumente."
#: org/postgresql/jdbc2/EscapedFunctions.java:282
#: org/postgresql/jdbc2/EscapedFunctions.java:342
#, java-format
msgid "{0} function takes two or three arguments."
msgstr "Die {0}-Funktion erwartet zwei oder drei Argumente."
#: org/postgresql/jdbc2/EscapedFunctions.java:362
#: org/postgresql/jdbc2/EscapedFunctions.java:371
#: org/postgresql/jdbc2/EscapedFunctions.java:573
#: org/postgresql/jdbc2/EscapedFunctions.java:591
#, java-format
msgid "{0} function doesn''t take any argument."
msgstr "Die {0}-Funktion akzeptiert kein Argument."
#: org/postgresql/jdbc2/EscapedFunctions.java:489
#: org/postgresql/jdbc2/EscapedFunctions.java:531
#, java-format
msgid "{0} function takes three and only three arguments."
msgstr "Die {0}-Funktion erwartet genau drei Argumente."
#: org/postgresql/jdbc2/EscapedFunctions.java:501
#: org/postgresql/jdbc2/EscapedFunctions.java:521
#: org/postgresql/jdbc2/EscapedFunctions.java:523
#: org/postgresql/jdbc2/EscapedFunctions.java:543
#: org/postgresql/jdbc2/EscapedFunctions.java:564
#: org/postgresql/jdbc2/EscapedFunctions.java:566
#, java-format
msgid "Interval {0} not yet implemented"
msgstr "Intervall {0} ist noch nicht implementiert."
#: org/postgresql/jdbc2/TimestampUtils.java:360
msgid ""
"Infinite value found for timestamp/date. This cannot be represented as time."
msgstr ""
"Fr den Zeitstempel oder das Datum wurde der Wert ''unendlich'' gefunden. "
"Dies kann nicht als Zeit reprsentiert werden."
#: org/postgresql/jdbc2/TimestampUtils.java:648
#: org/postgresql/jdbc2/TimestampUtils.java:680
#: org/postgresql/jdbc2/TimestampUtils.java:727
#, fuzzy, java-format
msgid "Unsupported binary encoding of {0}."
msgstr "Unbekannter Typ: {0}."
#: org/postgresql/jdbc2/TypeInfoCache.java:161
#, java-format
msgid "The class {0} does not implement org.postgresql.util.PGobject."
msgstr "Die Klasse {0} implementiert nicht ''org.postgresql.util.PGobject''."
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:60
#, java-format
msgid "Unknown ResultSet holdability setting: {0}."
msgstr "Unbekannte Einstellung fr die Haltbarkeit des ResultSets: {0}."
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:98
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:130
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:165
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:187
msgid "Server versions prior to 8.0 do not support savepoints."
msgstr "Der Server untersttzt keine Rettungspunkte vor Version 8.0."
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:100
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:132
msgid "Cannot establish a savepoint in auto-commit mode."
msgstr "Ein Rettungspunkt kann im Modus ''auto-commit'' nicht erstellt werden."
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:419
msgid "Returning autogenerated keys is not supported."
msgstr "Die Rckgabe automatisch generierter Schlssel wird nicht untersttzt,"
#: org/postgresql/jdbc3/AbstractJdbc3ParameterMetaData.java:81
#, java-format
msgid "The parameter index is out of range: {0}, number of parameters: {1}."
msgstr ""
"Der Parameterindex {0} ist auerhalb des gltigen Bereichs. Es gibt {1} "
"Parameter."
#: org/postgresql/jdbc3/AbstractJdbc3Statement.java:151
#, fuzzy
msgid ""
"Returning autogenerated keys is only supported for 8.2 and later servers."
msgstr "Die Rckgabe automatisch generierter Schlssel wird nicht untersttzt,"
#: org/postgresql/jdbc3/AbstractJdbc3Statement.java:199
#: org/postgresql/jdbc3/AbstractJdbc3Statement.java:317
#, fuzzy
msgid "Returning autogenerated keys by column index is not supported."
msgstr "Die Rckgabe automatisch generierter Schlssel wird nicht untersttzt,"
#: org/postgresql/jdbc3/PSQLSavepoint.java:38
#: org/postgresql/jdbc3/PSQLSavepoint.java:50
#: org/postgresql/jdbc3/PSQLSavepoint.java:66
msgid "Cannot reference a savepoint after it has been released."
msgstr ""
"Ein Rettungspunkt kann nicht angesprochen werden, nach dem er entfernt wurde."
#: org/postgresql/jdbc3/PSQLSavepoint.java:42
msgid "Cannot retrieve the id of a named savepoint."
msgstr "Die ID eines benamten Rettungspunktes kann nicht ermittelt werden."
#: org/postgresql/jdbc3/PSQLSavepoint.java:54
msgid "Cannot retrieve the name of an unnamed savepoint."
msgstr "Der Name eines namenlosen Rettungpunktes kann nicht ermittelt werden."
#: org/postgresql/jdbc3g/AbstractJdbc3gResultSet.java:37
#, fuzzy
msgid "Invalid UUID data."
msgstr "Ungltiges Flag."
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:83
#, fuzzy, java-format
msgid "Unable to find server array type for provided name {0}."
msgstr ""
"Fr den angegebenen Namen {0} konnte kein Serverarraytyp gefunden werden."
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:120
#, fuzzy, java-format
msgid "Invalid timeout ({0}<0)."
msgstr "Ungltige Lnge des Datenstroms: {0}."
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:133
msgid "Validating connection."
msgstr ""
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:156
#, fuzzy, java-format
msgid "Failed to set ClientInfo property: {0}"
msgstr "Erstellung des Objektes schlug fehl fr: {0}."
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:165
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:187
msgid "ClientInfo property not supported."
msgstr "Die ClientInfo-Eigenschaft ist nicht untersttzt."
#: org/postgresql/jdbc4/AbstractJdbc4Statement.java:127
msgid "Object is too large to send over the protocol."
msgstr ""
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:147
msgid "Unable to decode xml data."
msgstr ""
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:150
#, java-format
msgid "Unknown XML Source class: {0}"
msgstr ""
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:195
#, fuzzy
msgid "Unable to create SAXResult for SQLXML."
msgstr "Erstellung des Objektes schlug fehl fr: {0}."
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:209
msgid "Unable to create StAXResult for SQLXML"
msgstr ""
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:213
#, fuzzy, java-format
msgid "Unknown XML Result class: {0}"
msgstr "Unbekannte Einstellung fr die Haltbarkeit des ResultSets: {0}."
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:226
#, fuzzy
msgid "This SQLXML object has already been freed."
msgstr "Diese PooledConnection ist bereits geschlossen worden."
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:233
msgid ""
"This SQLXML object has not been initialized, so you cannot retrieve data "
"from it."
msgstr ""
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:244
#, java-format
msgid "Failed to convert binary xml data to encoding: {0}."
msgstr ""
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:269
msgid "Unable to convert DOMResult SQLXML data to a string."
msgstr ""
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:282
msgid ""
"This SQLXML object has already been initialized, so you cannot manipulate it "
"further."
msgstr ""
#: org/postgresql/largeobject/LargeObjectManager.java:138
msgid "Failed to initialize LargeObject API"
msgstr "Die LargeObject-API konnte nicht initialisiert werden."
#: org/postgresql/largeobject/LargeObjectManager.java:198
#: org/postgresql/largeobject/LargeObjectManager.java:239
msgid "Large Objects may not be used in auto-commit mode."
msgstr ""
"LargeObjects (LOB) drfen im Modus ''auto-commit'' nicht verwendet werden."
#: org/postgresql/ssl/jdbc3/AbstractJdbc3MakeSSL.java:58
#: org/postgresql/ssl/jdbc4/AbstractJdbc4MakeSSL.java:110
#, java-format
msgid "The SSLSocketFactory class provided {0} could not be instantiated."
msgstr ""
"Die von {0} bereitgestellte SSLSocketFactory-Klasse konnte nicht "
"instanziiert werden."
#: org/postgresql/ssl/jdbc4/AbstractJdbc4MakeSSL.java:125
#, java-format
msgid "SSL error: {0}"
msgstr ""
#: org/postgresql/ssl/jdbc4/AbstractJdbc4MakeSSL.java:138
#, fuzzy, java-format
msgid "The HostnameVerifier class provided {0} could not be instantiated."
msgstr ""
"Die von {0} bereitgestellte SSLSocketFactory-Klasse konnte nicht "
"instanziiert werden."
#: org/postgresql/ssl/jdbc4/AbstractJdbc4MakeSSL.java:142
#, java-format
msgid "The hostname {0} could not be verified by hostnameverifier {1}."
msgstr ""
#: org/postgresql/ssl/jdbc4/AbstractJdbc4MakeSSL.java:149
#, java-format
msgid "The hostname {0} could not be verified."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:121
msgid ""
"Could not find a java cryptographic algorithm: X.509 CertificateFactory not "
"available."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:132
#, java-format
msgid "Could not open SSL certificate file {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:137
#, java-format
msgid "Loading the SSL certificate {0} into a KeyManager failed."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:194
msgid "Enter SSL password: "
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:202
msgid "Could not read password for SSL key file, console is not available."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:204
#, java-format
msgid "Could not read password for SSL key file by callbackhandler {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:223
#, java-format
msgid "Could not decrypt SSL key file {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:231
#, java-format
msgid "Could not read SSL key file {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:235
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:173
#, java-format
msgid "Could not find a java cryptographic algorithm: {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:99
#, fuzzy, java-format
msgid "The password callback class provided {0} could not be instantiated."
msgstr ""
"Die von {0} bereitgestellte SSLSocketFactory-Klasse konnte nicht "
"instanziiert werden."
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:133
#, java-format
msgid "Could not open SSL root certificate file {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:150
#, java-format
msgid "Could not read SSL root certificate file {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:153
#, java-format
msgid "Loading the SSL root certificate {0} into a TrustManager failed."
msgstr ""
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:166
msgid "Could not initialize SSL context."
msgstr ""
#: org/postgresql/util/PGInterval.java:164
msgid "Conversion of interval failed"
msgstr "Die Umwandlung eines Intervalls schlug fehl."
#: org/postgresql/util/PGmoney.java:73
msgid "Conversion of money failed."
msgstr "Die Umwandlung eines Whrungsbetrags schlug fehl."
#: org/postgresql/util/ServerErrorMessage.java:155
#, java-format
msgid "Detail: {0}"
msgstr "Detail: {0}"
#: org/postgresql/util/ServerErrorMessage.java:159
#, java-format
msgid "Hint: {0}"
msgstr "Hinweis: {0}"
#: org/postgresql/util/ServerErrorMessage.java:162
#, java-format
msgid "Position: {0}"
msgstr "Position: {0}"
#: org/postgresql/util/ServerErrorMessage.java:165
#, java-format
msgid "Where: {0}"
msgstr "Wobei: {0}"
#: org/postgresql/util/ServerErrorMessage.java:171
#, java-format
msgid "Internal Query: {0}"
msgstr "Interne Abfrage: {0}"
#: org/postgresql/util/ServerErrorMessage.java:174
#, java-format
msgid "Internal Position: {0}"
msgstr "Interne Position: {0}"
#: org/postgresql/util/ServerErrorMessage.java:180
#, java-format
msgid "Location: File: {0}, Routine: {1}, Line: {2}"
msgstr "Ort: Datei: {0}, Routine: {1}, Zeile: {2}."
#: org/postgresql/util/ServerErrorMessage.java:183
#, java-format
msgid "Server SQLState: {0}"
msgstr "Server SQLState: {0}"
#: org/postgresql/xa/PGXAConnection.java:148
msgid ""
"Transaction control methods setAutoCommit(true), commit, rollback and "
"setSavePoint not allowed while an XA transaction is active."
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:186
#: org/postgresql/xa/PGXAConnection.java:245
msgid "Invalid flags"
msgstr "Ungltige Flags"
#: org/postgresql/xa/PGXAConnection.java:189
#: org/postgresql/xa/PGXAConnection.java:248
#: org/postgresql/xa/PGXAConnection.java:425
msgid "xid must not be null"
msgstr "Die xid darf nicht null sein."
#: org/postgresql/xa/PGXAConnection.java:192
msgid "Connection is busy with another transaction"
msgstr "Die Verbindung ist derzeit mit einer anderen Transaktion beschftigt."
#: org/postgresql/xa/PGXAConnection.java:198
#: org/postgresql/xa/PGXAConnection.java:255
msgid "suspend/resume not implemented"
msgstr "Anhalten/Fortsetzen ist nicht implementiert."
#: org/postgresql/xa/PGXAConnection.java:204
#: org/postgresql/xa/PGXAConnection.java:207
#: org/postgresql/xa/PGXAConnection.java:209
msgid "Transaction interleaving not implemented"
msgstr "Transaktionsinterleaving ist nicht implementiert."
#: org/postgresql/xa/PGXAConnection.java:218
msgid "Error disabling autocommit"
msgstr "Fehler beim Abschalten von Autocommit."
#: org/postgresql/xa/PGXAConnection.java:251
msgid "tried to call end without corresponding start call"
msgstr ""
"Es wurde versucht, ohne dazugehrigen ''start''-Aufruf ''end'' aufzurufen."
#: org/postgresql/xa/PGXAConnection.java:282
msgid ""
"Not implemented: Prepare must be issued using the same connection that "
"started the transaction"
msgstr ""
"Nicht implementiert: ''Prepare'' muss ber die selbe Verbindung abgesetzt "
"werden, die die Transaktion startete."
#: org/postgresql/xa/PGXAConnection.java:286
msgid "Prepare called before end"
msgstr "''Prepare'' wurde vor ''end'' aufgerufen."
#: org/postgresql/xa/PGXAConnection.java:292
msgid "Server versions prior to 8.1 do not support two-phase commit."
msgstr "Der Server untersttzt keine zweiphasige Besttigung vor Version 8.1."
#: org/postgresql/xa/PGXAConnection.java:313
msgid "Error preparing transaction"
msgstr "Beim Vorbereiten der Transaktion trat ein Fehler auf."
#: org/postgresql/xa/PGXAConnection.java:328
msgid "Invalid flag"
msgstr "Ungltiges Flag."
#: org/postgresql/xa/PGXAConnection.java:368
msgid "Error during recover"
msgstr "Beim Wiederherstellen trat ein Fehler auf."
#: org/postgresql/xa/PGXAConnection.java:416
msgid "Error rolling back prepared transaction"
msgstr "Fehler beim Rollback einer vorbereiteten Transaktion."
#: org/postgresql/xa/PGXAConnection.java:451
msgid ""
"Not implemented: one-phase commit must be issued using the same connection "
"that was used to start it"
msgstr ""
"Nicht implementiert: Die einphasige Besttigung muss ber die selbe "
"Verbindung abgewickelt werden, die verwendet wurde, um sie zu beginnen."
#: org/postgresql/xa/PGXAConnection.java:455
msgid "commit called before end"
msgstr "''Commit'' wurde vor ''end'' aufgerufen."
#: org/postgresql/xa/PGXAConnection.java:466
msgid "Error during one-phase commit"
msgstr "Bei der einphasigen Besttigung trat ein Fehler auf."
#: org/postgresql/xa/PGXAConnection.java:487
msgid ""
"Not implemented: 2nd phase commit must be issued using an idle connection"
msgstr ""
"Nicht implementiert: Die zweite Besttigungsphase muss ber eine im Leerlauf "
"befindliche Verbindung abgewickelt werden."
#: org/postgresql/xa/PGXAConnection.java:507
#, fuzzy
msgid "Error committing prepared transaction"
msgstr "Fehler beim Rollback einer vorbereiteten Transaktion."
#: org/postgresql/xa/PGXAConnection.java:522
msgid "Heuristic commit/rollback not supported"
msgstr "Heuristisches Commit/Rollback wird nicht untersttzt."
#~ msgid "The driver does not support SSL."
#~ msgstr "Der Treiber untersttzt SSL nicht."
#~ msgid "Exception: {0}"
#~ msgstr "Exception: {0}."
#~ msgid "Stack Trace:"
#~ msgstr "Stack-Trace:"
#~ msgid "End of Stack Trace"
#~ msgstr "Ende des Stack-Traces."
#~ msgid "Exception generating stacktrace for: {0} encountered: {1}"
#~ msgstr ""
#~ "Beim Erstellen eines Stack-Traces fr {0} trat eine Exception auf: {1}"
#~ msgid "Multi-dimensional arrays are currently not supported."
#~ msgstr "Mehrdimensionale Arrays werden derzeit nicht untersttzt."
#~ msgid "rand function only takes zero or one argument(the seed)."
#~ msgstr ""
#~ "Die Funktion ''rand'' erwartet kein oder genau ein Argument (den "
#~ "''seed'')."
#~ msgid "suspend/resume and join not implemented"
#~ msgstr "Anhalten/Fortsetzen und Join sind nicht implementiert."
#~ msgid ""
#~ "setNull(i,Types.OTHER) is not supported; use setObject(i,nullobject,Types."
#~ "OTHER) instead."
#~ msgstr ""
#~ "''setNull(i, Types.OTHER)'' wird nicht untersttzt; benutzen Sie "
#~ "stattdessen ''setObject(i, nullobject, Types.OTHER)''."
#~ msgid ""
#~ "setObject(i,null) is not supported. Instead, use setNull(i,type) or "
#~ "setObject(i,null,type)"
#~ msgstr ""
#~ "''setObejct(i, null)'' ist nicht untersttzt. Benutzen Sie ''setNull(i, "
#~ "type)'' oder ''setObject(i, null, type)'' stattdessen."
#~ msgid ""
#~ "Cannot call setXXX(1, ..) on a CallableStatement. This is an output that "
#~ "must be configured with registerOutParameter instead."
#~ msgstr ""
#~ "''setXXX(1, ..)'' kann auf einem CallableStatement nicht aufgerufen "
#~ "werden. Diese Ausgabe muss stattdessen mit ''registerOutParameter'' "
#~ "konfiguriert werden."
#~ msgid ""
#~ "PostgreSQL only supports a single OUT function return value at index 1."
#~ msgstr ""
#~ "PostgreSQL untersttzt auf dem Index 1 nur einen einzigen Rckgabewert "
#~ "fr die OUT-Funktion."
#, fuzzy
#~ msgid "Conversion of circle failed: {0}."
#~ msgstr "Konnte {0} nicht in Typ circle umwandeln"
#, fuzzy
#~ msgid "Conversion of line failed: {0}."
#~ msgstr "Konnte {0} nicht in Typ line umwandeln"
#, fuzzy
#~ msgid "Conversion of point failed: {0}."
#~ msgstr "Konnte {0} nicht in Typ point umwandeln"
#, fuzzy
#~ msgid "No results where returned by the query."
#~ msgstr "Die Abfrage ergab kein Ergebnis."
#, fuzzy
#~ msgid "Bad byte: {0}"
#~ msgstr "Ungltiges Format fr Byte: {0}"
#, fuzzy
#~ msgid "Bad short: {0}"
#~ msgstr "Ungltiges Format fr Short: {0}"
#, fuzzy
#~ msgid "Bad int: {0}"
#~ msgstr "Ungltiges Format fr Long: {0}"
#, fuzzy
#~ msgid "Bad long: {0}"
#~ msgstr "Ungltiges Format fr Long: {0}"
#, fuzzy
#~ msgid "Bad BigDecimal: {0}"
#~ msgstr "Ungltiges Format fr BigDecimal: {0}"
#, fuzzy
#~ msgid "Bad float: {0}"
#~ msgstr "Ungltiges Format fr Float: {0}"
#, fuzzy
#~ msgid "Bad double: {0}"
#~ msgstr "Ungltiges Format fr Double: {0}"
#, fuzzy
#~ msgid "Bad date: {0}"
#~ msgstr "Ungltiges Format fr Byte: {0}"
postgresql-jdbc-9.2-1002.src/org/postgresql/translation/es.po 0000664 0000000 0000000 00000131566 12050675701 0024153 0 ustar 00root root 0000000 0000000 # Spanish message translation for the PostgreSQL JDBC driver
# This file is distributed under the same license as the package.
#
msgid ""
msgstr ""
"Project-Id-Version: JDBC PostgreSQL Driver\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2012-09-10 19:32-0400\n"
"PO-Revision-Date: 2004-10-22 16:51-0300\n"
"Last-Translator: Diego Gil \n"
"Language-Team: \n"
"Language: \n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Poedit-Language: Spanish\n"
#: bin/org/postgresql/Driver.java.in:235 org/postgresql/Driver.java.in:235
msgid "Error loading default settings from driverconfig.properties"
msgstr ""
#: bin/org/postgresql/Driver.java.in:282 org/postgresql/Driver.java.in:282
msgid ""
"Your security policy has prevented the connection from being attempted. You "
"probably need to grant the connect java.net.SocketPermission to the database "
"server host and port that you wish to connect to."
msgstr ""
#: bin/org/postgresql/Driver.java.in:287 bin/org/postgresql/Driver.java.in:351
#: org/postgresql/Driver.java.in:287 org/postgresql/Driver.java.in:351
msgid ""
"Something unusual has occured to cause the driver to fail. Please report "
"this exception."
msgstr ""
"Algo inusual ha ocurrido que provocó un fallo en el controlador. Por favor "
"reporte esta excepción."
#: bin/org/postgresql/Driver.java.in:359 org/postgresql/Driver.java.in:359
#, fuzzy
msgid "Connection attempt timed out."
msgstr "El intento de conexión falló."
#: bin/org/postgresql/Driver.java.in:367 org/postgresql/Driver.java.in:367
#, fuzzy
msgid "Interrupted while attempting to connect."
msgstr "Ha ocorrido un error mientras se establecía la conexión SSL."
#: bin/org/postgresql/Driver.java.in:710 org/postgresql/Driver.java.in:710
#, fuzzy, java-format
msgid "Method {0} is not yet implemented."
msgstr "Este método aún no ha sido implementado."
#: org/postgresql/copy/CopyManager.java:56
#, java-format
msgid "Requested CopyIn but got {0}"
msgstr ""
#: org/postgresql/copy/CopyManager.java:67
#, java-format
msgid "Requested CopyOut but got {0}"
msgstr ""
#: org/postgresql/copy/PGCopyInputStream.java:51
#, java-format
msgid "Copying from database failed: {0}"
msgstr ""
#: org/postgresql/copy/PGCopyInputStream.java:67
#: org/postgresql/copy/PGCopyOutputStream.java:90
msgid "This copy stream is closed."
msgstr ""
#: org/postgresql/copy/PGCopyInputStream.java:108
msgid "Read from copy failed."
msgstr ""
#: org/postgresql/copy/PGCopyOutputStream.java:68
#, java-format
msgid "Cannot write to copy a byte of value {0}"
msgstr ""
#: org/postgresql/core/ConnectionFactory.java:70
#, fuzzy, java-format
msgid "A connection could not be made using the requested protocol {0}."
msgstr "No se pudo hacer una conexión para el protocolo solicitado {0}."
#: org/postgresql/core/Oid.java:113
#, java-format
msgid "oid type {0} not known and not a number"
msgstr ""
#: org/postgresql/core/PGStream.java:490
#, java-format
msgid "Premature end of input stream, expected {0} bytes, but only read {1}."
msgstr ""
"Final prematuro del flujo de entrada, se esperaban {0} bytes, pero solo se "
"leyeron {1}."
#: org/postgresql/core/PGStream.java:530
#, java-format
msgid "Expected an EOF from server, got: {0}"
msgstr ""
#: org/postgresql/core/SetupQueryRunner.java:86
msgid "An unexpected result was returned by a query."
msgstr "Una consulta retornó un resultado inesperado."
#: org/postgresql/core/UTF8Encoding.java:28
#, java-format
msgid ""
"Illegal UTF-8 sequence: byte {0} of {1} byte sequence is not 10xxxxxx: {2}"
msgstr ""
#: org/postgresql/core/UTF8Encoding.java:61
#, java-format
msgid "Illegal UTF-8 sequence: {0} bytes used to encode a {1} byte value: {2}"
msgstr ""
#: org/postgresql/core/UTF8Encoding.java:98
#: org/postgresql/core/UTF8Encoding.java:125
#, java-format
msgid "Illegal UTF-8 sequence: initial byte is {0}: {1}"
msgstr ""
#: org/postgresql/core/UTF8Encoding.java:130
#, java-format
msgid "Illegal UTF-8 sequence: final value is out of range: {0}"
msgstr ""
#: org/postgresql/core/UTF8Encoding.java:145
#, java-format
msgid "Illegal UTF-8 sequence: final value is a surrogate value: {0}"
msgstr ""
#: org/postgresql/core/Utils.java:95 org/postgresql/core/Utils.java:112
msgid "Zero bytes may not occur in string parameters."
msgstr ""
#: org/postgresql/core/Utils.java:145
msgid "Zero bytes may not occur in identifiers."
msgstr ""
#: org/postgresql/core/types/PGBigDecimal.java:63
#: org/postgresql/core/types/PGBoolean.java:62
#: org/postgresql/core/types/PGByte.java:63
#: org/postgresql/core/types/PGDouble.java:64
#: org/postgresql/core/types/PGFloat.java:64
#: org/postgresql/core/types/PGInteger.java:61
#: org/postgresql/core/types/PGLong.java:62
#: org/postgresql/core/types/PGNumber.java:62
#: org/postgresql/core/types/PGShort.java:58
#: org/postgresql/core/types/PGString.java:73
#, java-format
msgid "Cannot convert an instance of {0} to type {1}"
msgstr ""
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:66
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:74
#, java-format
msgid "Invalid sslmode value: {0}"
msgstr ""
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:134
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:168
msgid ""
"Connection refused. Check that the hostname and port are correct and that "
"the postmaster is accepting TCP/IP connections."
msgstr ""
"Conexión rechazada. Verifique que el nombre del Host y el puerto sean "
"correctos y que postmaster este aceptando conexiones TCP/IP."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:153
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:186
msgid "The connection attempt failed."
msgstr "El intento de conexión falló."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:175
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:207
#, fuzzy
msgid "The connection url is invalid."
msgstr "El intento de conexión falló."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:198
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:210
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:256
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:268
msgid "The server does not support SSL."
msgstr "Este servidor no soporta SSL."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:223
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:281
msgid "An error occured while setting up the SSL connection."
msgstr "Ha ocorrido un error mientras se establecía la conexión SSL."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:272
#, java-format
msgid "Connection rejected: {0}."
msgstr "Conexión rechazada: {0}."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:290
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:312
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:332
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:380
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:405
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:432
msgid ""
"The server requested password-based authentication, but no password was "
"provided."
msgstr ""
"El servidor requiere autenticación basada en contraseña, pero no se ha "
"provisto ninguna contraseña."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:356
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:465
#, fuzzy, java-format
msgid ""
"The authentication type {0} is not supported. Check that you have configured "
"the pg_hba.conf file to include the client''s IP address or subnet, and that "
"it is using an authentication scheme supported by the driver."
msgstr ""
"El tipo de autenticación {0} no es soportada. Verifique que ha configurado "
"el archivo pg_hba.conf para incluir las direcciones IP de los clientes o la "
"subred, y que está usando un esquema de autenticación soportado por el "
"driver."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:362
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:400
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:471
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:514
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:560
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:570
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:579
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:587
#: org/postgresql/gss/MakeGSS.java:158
msgid "Protocol error. Session setup failed."
msgstr "Error de protocolo. Falló el inicio de la sesión."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:390
#, java-format
msgid "Backend start-up failed: {0}."
msgstr "Falló el arranque del Backend: {0}. "
#: org/postgresql/core/v2/FastpathParameterList.java:55
#: org/postgresql/core/v2/FastpathParameterList.java:77
#: org/postgresql/core/v2/FastpathParameterList.java:84
#: org/postgresql/core/v2/SimpleParameterList.java:57
#: org/postgresql/core/v2/SimpleParameterList.java:76
#: org/postgresql/core/v2/SimpleParameterList.java:83
#: org/postgresql/core/v2/SimpleParameterList.java:90
#: org/postgresql/core/v3/CompositeParameterList.java:35
#: org/postgresql/core/v3/SimpleParameterList.java:47
#: org/postgresql/core/v3/SimpleParameterList.java:54
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2845
#: org/postgresql/jdbc2/AbstractJdbc2ResultSetMetaData.java:419
#, java-format
msgid "The column index is out of range: {0}, number of columns: {1}."
msgstr ""
"El índice de la columna está fuera de rango: {0}, número de columnas: {1}."
#: org/postgresql/core/v2/FastpathParameterList.java:142
#: org/postgresql/core/v2/SimpleParameterList.java:155
#: org/postgresql/core/v3/SimpleParameterList.java:183
#, java-format
msgid "No value specified for parameter {0}."
msgstr "No se ha especificado un valor para el parámetro {0}."
#: org/postgresql/core/v2/QueryExecutorImpl.java:72
#: org/postgresql/core/v2/QueryExecutorImpl.java:337
#: org/postgresql/core/v3/QueryExecutorImpl.java:443
#: org/postgresql/core/v3/QueryExecutorImpl.java:507
#, java-format
msgid "Expected command status BEGIN, got {0}."
msgstr ""
#: org/postgresql/core/v2/QueryExecutorImpl.java:78
#: org/postgresql/core/v3/QueryExecutorImpl.java:513
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1828
#, java-format
msgid "Unexpected command status: {0}."
msgstr ""
#: org/postgresql/core/v2/QueryExecutorImpl.java:118
#: org/postgresql/core/v2/QueryExecutorImpl.java:129
#: org/postgresql/core/v2/QueryExecutorImpl.java:174
#: org/postgresql/core/v2/QueryExecutorImpl.java:369
#: org/postgresql/core/v3/QueryExecutorImpl.java:281
#: org/postgresql/core/v3/QueryExecutorImpl.java:411
#: org/postgresql/core/v3/QueryExecutorImpl.java:485
#: org/postgresql/core/v3/QueryExecutorImpl.java:551
#: org/postgresql/core/v3/QueryExecutorImpl.java:631
#: org/postgresql/core/v3/QueryExecutorImpl.java:2094
msgid "An I/O error occured while sending to the backend."
msgstr "Un error de E/S ha ocurrido mientras se enviaba al backend."
#: org/postgresql/core/v2/QueryExecutorImpl.java:170
#: org/postgresql/core/v2/QueryExecutorImpl.java:225
#: org/postgresql/core/v2/QueryExecutorImpl.java:236
#: org/postgresql/core/v3/QueryExecutorImpl.java:627
#: org/postgresql/core/v3/QueryExecutorImpl.java:685
#, java-format
msgid "Unknown Response Type {0}."
msgstr "Tipo de respuesta desconocida {0}."
#: org/postgresql/core/v2/QueryExecutorImpl.java:430
#: org/postgresql/core/v2/QueryExecutorImpl.java:475
#: org/postgresql/core/v3/QueryExecutorImpl.java:1857
msgid "Ran out of memory retrieving query results."
msgstr ""
#: org/postgresql/core/v2/QueryExecutorImpl.java:597
#: org/postgresql/core/v3/QueryExecutorImpl.java:2199
#, java-format
msgid "Unable to interpret the update count in command completion tag: {0}."
msgstr ""
#: org/postgresql/core/v2/QueryExecutorImpl.java:610
msgid "Copy not implemented for protocol version 2"
msgstr ""
#: org/postgresql/core/v3/CopyOperationImpl.java:56
msgid "CommandComplete expected COPY but got: "
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:66
msgid "Tried to obtain lock while already holding it"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:78
msgid "Tried to break lock on database connection"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:93
msgid "Interrupted while waiting to obtain lock on database connection"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:275
msgid "Unable to bind parameter values for statement."
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:726
msgid "Database connection failed when starting copy"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:757
msgid "Tried to cancel an inactive copy operation"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:794
msgid "Database connection failed when canceling copy operation"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:799
msgid "Missing expected error response to copy cancel request"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:801
#, java-format
msgid "Got {0} error responses to single copy cancel request"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:814
msgid "Tried to end inactive copy"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:827
msgid "Database connection failed when ending copy"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:842
#: org/postgresql/core/v3/QueryExecutorImpl.java:860
msgid "Tried to write to an inactive copy operation"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:854
#: org/postgresql/core/v3/QueryExecutorImpl.java:866
msgid "Database connection failed when writing to copy"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:878
msgid "Tried to read from inactive copy"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:883
msgid "Database connection failed when reading from copy"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:951
#, java-format
msgid "Received CommandComplete ''{0}'' without an active copy operation"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:975
#, java-format
msgid "Got CopyInResponse from server during an active {0}"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:988
#, java-format
msgid "Got CopyOutResponse from server during an active {0}"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:1003
msgid "Got CopyData without an active copy operation"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:1005
#, java-format
msgid "Unexpected copydata from server for {0}"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:1056
#, java-format
msgid "Unexpected packet type during copy: {0}"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:1310
#, java-format
msgid ""
"Bind message length {0} too long. This can be caused by very large or "
"incorrect length specifications on InputStream parameters."
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:1925
#, java-format
msgid ""
"The server''s client_encoding parameter was changed to {0}. The JDBC driver "
"requires client_encoding to be UTF8 for correct operation."
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:1932
#, java-format
msgid ""
"The server''s DateStyle parameter was changed to {0}. The JDBC driver "
"requires DateStyle to begin with ISO for correct operation."
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:1945
#, java-format
msgid ""
"The server''s standard_conforming_strings parameter was reported as {0}. The "
"JDBC driver expected on or off."
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:2015
msgid "The driver currently does not support COPY operations."
msgstr ""
#: org/postgresql/ds/jdbc23/AbstractJdbc23PooledConnection.java:112
msgid "This PooledConnection has already been closed."
msgstr ""
#: org/postgresql/ds/jdbc23/AbstractJdbc23PooledConnection.java:295
msgid ""
"Connection has been closed automatically because a new connection was opened "
"for the same PooledConnection or the PooledConnection has been closed."
msgstr ""
#: org/postgresql/ds/jdbc23/AbstractJdbc23PooledConnection.java:295
#, fuzzy
msgid "Connection has been closed."
msgstr "Conexión rechazada: {0}."
#: org/postgresql/ds/jdbc23/AbstractJdbc23PooledConnection.java:442
msgid "Statement has been closed."
msgstr ""
#: org/postgresql/ds/jdbc23/AbstractJdbc23PoolingDataSource.java:291
msgid "Failed to setup DataSource."
msgstr ""
#: org/postgresql/ds/jdbc23/AbstractJdbc23PoolingDataSource.java:414
msgid "DataSource has been closed."
msgstr ""
#: org/postgresql/fastpath/Fastpath.java:81
#: org/postgresql/fastpath/Fastpath.java:128
#, java-format
msgid "Fastpath call {0} - No result was returned and we expected an integer."
msgstr ""
#: org/postgresql/fastpath/Fastpath.java:237
#, java-format
msgid "The fastpath function {0} is unknown."
msgstr ""
#: org/postgresql/geometric/PGbox.java:83
#: org/postgresql/geometric/PGcircle.java:82
#: org/postgresql/geometric/PGcircle.java:91
#: org/postgresql/geometric/PGline.java:80
#: org/postgresql/geometric/PGlseg.java:77
#: org/postgresql/geometric/PGpoint.java:85
#, java-format
msgid "Conversion to type {0} failed: {1}."
msgstr ""
#: org/postgresql/geometric/PGpath.java:81
#, java-format
msgid "Cannot tell if path is open or closed: {0}."
msgstr ""
#: org/postgresql/gss/MakeGSS.java:47 org/postgresql/gss/MakeGSS.java:55
#: org/postgresql/gss/MakeGSS.java:168
msgid "GSS Authentication failed"
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Array.java:153
#: org/postgresql/jdbc2/AbstractJdbc2Array.java:790
#, java-format
msgid "The array index is out of range: {0}"
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Array.java:168
#: org/postgresql/jdbc2/AbstractJdbc2Array.java:807
#, java-format
msgid "The array index is out of range: {0}, number of elements: {1}."
msgstr ""
"El índice del arreglo esta fuera de rango: {0}, número de elementos: {1}."
#: org/postgresql/jdbc2/AbstractJdbc2Array.java:196
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1982
#: org/postgresql/util/HStoreConverter.java:34
#: org/postgresql/util/HStoreConverter.java:61
msgid ""
"Invalid character data was found. This is most likely caused by stored data "
"containing characters that are invalid for the character set the database "
"was created in. The most common example of this is storing 8bit data in a "
"SQL_ASCII database."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:73
msgid ""
"Truncation of large objects is only implemented in 8.3 and later servers."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:77
msgid "Cannot truncate LOB to a negative length."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:81
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:235
#, java-format
msgid "PostgreSQL LOBs can only index to: {0}"
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:231
msgid "LOB positioning offsets start at 1."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:246
msgid "free() was called on this LOB previously"
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:229
#, java-format
msgid "Unsupported value for stringtype parameter: {0}"
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:249
msgid "unknownLength parameter value must be an integer"
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:357
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:284
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:303
#: org/postgresql/jdbc2/TypeInfoCache.java:201
#: org/postgresql/jdbc2/TypeInfoCache.java:249
#: org/postgresql/jdbc2/TypeInfoCache.java:287
#: org/postgresql/jdbc2/TypeInfoCache.java:344
#: org/postgresql/jdbc2/TypeInfoCache.java:348
#: org/postgresql/jdbc2/TypeInfoCache.java:384
#: org/postgresql/jdbc2/TypeInfoCache.java:388
msgid "No results were returned by the query."
msgstr "La consulta no retornó ningún resultado."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:371
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:336
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:368
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2695
msgid "A result was returned when none was expected."
msgstr "Se retornó un resultado cuando no se esperaba ninguno."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:523
msgid "Custom type maps are not supported."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:571
#, java-format
msgid "Failed to create object for: {0}."
msgstr "Fallo al crear objeto: {0}."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:633
#, java-format
msgid "Unable to load the class {0} responsible for the datatype {1}"
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:729
msgid ""
"Cannot change transaction read-only property in the middle of a transaction."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:817
msgid "Cannot commit when autoCommit is enabled."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:826
#, fuzzy
msgid "This connection has been closed."
msgstr "El intento de conexión falló."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:846
msgid "Cannot rollback when autoCommit is enabled."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:933
msgid ""
"Cannot change transaction isolation level in the middle of a transaction."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:938
#, java-format
msgid "Transaction isolation level {0} not supported."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:1005
msgid "Finalizing a Connection that was never closed:"
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:1107
msgid "Unable to translate data into the desired encoding."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2DatabaseMetaData.java:63
msgid ""
"Unable to determine a value for MaxIndexKeys due to missing system catalog "
"data."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2DatabaseMetaData.java:86
msgid "Unable to find name datatype in the system catalogs."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:235
msgid ""
"Operation requires a scrollable ResultSet, but this ResultSet is "
"FORWARD_ONLY."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:416
msgid "Unexpected error while decoding character data from a large object."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:462
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:491
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:525
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3129
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3174
#, java-format
msgid "Cannot convert the column of type {0} to requested type {1}."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:744
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:768
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1892
msgid "Can''t use relative move methods while on the insert row."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:788
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2949
#, java-format
msgid "Invalid fetch direction constant: {0}."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:802
msgid "Cannot call cancelRowUpdates() when on the insert row."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:822
msgid "Cannot call deleteRow() when on the insert row."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:828
msgid ""
"Currently positioned before the start of the ResultSet. You cannot call "
"deleteRow() here."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:833
msgid ""
"Currently positioned after the end of the ResultSet. You cannot call "
"deleteRow() here."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:838
msgid "There are no rows in this ResultSet."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:885
msgid "Not on the insert row."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:889
msgid "You must specify at least one column value to insert a row."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1074
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1805
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2494
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2524
#, java-format
msgid "The JVM claims not to support the encoding: {0}"
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1078
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1121
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1527
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1656
msgid "Provided InputStream failed."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1191
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3130
msgid "Provided Reader failed."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1259
msgid "Can''t refresh the insert row."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1327
msgid "Cannot call updateRow() when on the insert row."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1333
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3190
msgid ""
"Cannot update the ResultSet because it is either before the start or after "
"the end of the results."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1582
msgid "ResultSets with concurrency CONCUR_READ_ONLY cannot be updated."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1650
#, java-format
msgid "No primary key found for table {0}."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1876
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2958
msgid "Fetch size must be a value greater to or equal to 0."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2044
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2051
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2098
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2106
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2926
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2934
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2964
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2971
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2991
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3002
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3020
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3038
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3179
#: org/postgresql/jdbc2/TimestampUtils.java:258
#, java-format
msgid "Bad value for type {0} : {1}"
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2727
#, java-format
msgid "The column name {0} was not found in this ResultSet."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2827
msgid ""
"ResultSet is not updateable. The query that generated this result set must "
"select only one table, and must select all primary keys from that table. See "
"the JDBC 2.1 API Specification, section 5.6 for more details."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2839
msgid "This ResultSet is closed."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2860
msgid "ResultSet not positioned properly, perhaps you need to call next."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:259
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:323
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:392
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2648
msgid ""
"Can''t use query methods that take a query string on a PreparedStatement."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:287
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:306
msgid "Multiple ResultSets were returned by the query."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:425
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:429
msgid "A CallableStatement was executed with nothing returned."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:437
msgid "A CallableStatement was executed with an invalid number of parameters"
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:468
#, java-format
msgid ""
"A CallableStatement function was executed and the out parameter {0} was of "
"type {1} however type {2} was registered."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:670
msgid "Maximum number of rows must be a value grater than or equal to 0."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:713
msgid "Query timeout must be a value greater than or equals to 0."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:804
msgid "The maximum field size must be a value greater than or equal to 0."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1219
msgid "Unknown Types value."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1492
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1617
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3101
#, java-format
msgid "Invalid stream length {0}."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1523
#, java-format
msgid "The JVM claims not to support the {0} encoding."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1698
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3023
#, java-format
msgid "Unknown type {0}."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1713
msgid "No hstore extension installed."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1838
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1844
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1850
#, java-format
msgid "Cannot cast an instance of {0} to type {1}"
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1862
#, java-format
msgid "Unsupported Types value: {0}"
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1920
#, java-format
msgid ""
"Can''t infer the SQL type to use for an instance of {0}. Use setObject() "
"with an explicit Types value to specify the type to use."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1968
msgid ""
"This statement does not declare an OUT parameter. Use '{' ?= call ... '}' "
"to declare one."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2018
msgid "wasNull cannot be call before fetching a result."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2514
#, java-format
msgid "Malformed function or procedure escape syntax at offset {0}."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2564
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2578
#, java-format
msgid ""
"Parameter of type {0} was registered, but call to get{1} (sqltype={2}) was "
"made."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2597
msgid ""
"A CallableStatement was declared, but no call to registerOutParameter(1, "
") was made."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2601
msgid "No function outputs were registered."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2604
msgid ""
"Results cannot be retrieved from a CallableStatement before it is executed."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2637
msgid "This statement has been closed."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2717
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2787
#, fuzzy
msgid "Too many update results were returned."
msgstr "La consulta no retornó ningún resultado."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2746
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2816
#, java-format
msgid ""
"Batch entry {0} {1} was aborted. Call getNextException to see the cause."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3071
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3160
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3200
msgid "Unexpected error writing large object to database."
msgstr ""
#: org/postgresql/jdbc2/EscapedFunctions.java:145
#: org/postgresql/jdbc2/EscapedFunctions.java:157
#: org/postgresql/jdbc2/EscapedFunctions.java:169
#: org/postgresql/jdbc2/EscapedFunctions.java:206
#: org/postgresql/jdbc2/EscapedFunctions.java:243
#: org/postgresql/jdbc2/EscapedFunctions.java:267
#: org/postgresql/jdbc2/EscapedFunctions.java:292
#: org/postgresql/jdbc2/EscapedFunctions.java:316
#: org/postgresql/jdbc2/EscapedFunctions.java:328
#: org/postgresql/jdbc2/EscapedFunctions.java:352
#: org/postgresql/jdbc2/EscapedFunctions.java:380
#: org/postgresql/jdbc2/EscapedFunctions.java:389
#: org/postgresql/jdbc2/EscapedFunctions.java:399
#: org/postgresql/jdbc2/EscapedFunctions.java:408
#: org/postgresql/jdbc2/EscapedFunctions.java:417
#: org/postgresql/jdbc2/EscapedFunctions.java:426
#: org/postgresql/jdbc2/EscapedFunctions.java:435
#: org/postgresql/jdbc2/EscapedFunctions.java:444
#: org/postgresql/jdbc2/EscapedFunctions.java:453
#: org/postgresql/jdbc2/EscapedFunctions.java:462
#: org/postgresql/jdbc2/EscapedFunctions.java:471
#: org/postgresql/jdbc2/EscapedFunctions.java:480
#, java-format
msgid "{0} function takes one and only one argument."
msgstr ""
#: org/postgresql/jdbc2/EscapedFunctions.java:181
#: org/postgresql/jdbc2/EscapedFunctions.java:193
#: org/postgresql/jdbc2/EscapedFunctions.java:255
#: org/postgresql/jdbc2/EscapedFunctions.java:304
#: org/postgresql/jdbc2/EscapedFunctions.java:582
#, java-format
msgid "{0} function takes two and only two arguments."
msgstr ""
#: org/postgresql/jdbc2/EscapedFunctions.java:230
#, java-format
msgid "{0} function takes four and only four argument."
msgstr ""
#: org/postgresql/jdbc2/EscapedFunctions.java:282
#: org/postgresql/jdbc2/EscapedFunctions.java:342
#, java-format
msgid "{0} function takes two or three arguments."
msgstr ""
#: org/postgresql/jdbc2/EscapedFunctions.java:362
#: org/postgresql/jdbc2/EscapedFunctions.java:371
#: org/postgresql/jdbc2/EscapedFunctions.java:573
#: org/postgresql/jdbc2/EscapedFunctions.java:591
#, java-format
msgid "{0} function doesn''t take any argument."
msgstr ""
#: org/postgresql/jdbc2/EscapedFunctions.java:489
#: org/postgresql/jdbc2/EscapedFunctions.java:531
#, java-format
msgid "{0} function takes three and only three arguments."
msgstr ""
#: org/postgresql/jdbc2/EscapedFunctions.java:501
#: org/postgresql/jdbc2/EscapedFunctions.java:521
#: org/postgresql/jdbc2/EscapedFunctions.java:523
#: org/postgresql/jdbc2/EscapedFunctions.java:543
#: org/postgresql/jdbc2/EscapedFunctions.java:564
#: org/postgresql/jdbc2/EscapedFunctions.java:566
#, fuzzy, java-format
msgid "Interval {0} not yet implemented"
msgstr "Este método aún no ha sido implementado."
#: org/postgresql/jdbc2/TimestampUtils.java:360
msgid ""
"Infinite value found for timestamp/date. This cannot be represented as time."
msgstr ""
#: org/postgresql/jdbc2/TimestampUtils.java:648
#: org/postgresql/jdbc2/TimestampUtils.java:680
#: org/postgresql/jdbc2/TimestampUtils.java:727
#, java-format
msgid "Unsupported binary encoding of {0}."
msgstr ""
#: org/postgresql/jdbc2/TypeInfoCache.java:161
#, java-format
msgid "The class {0} does not implement org.postgresql.util.PGobject."
msgstr "La clase {0} no implementa org.postgresql.util.PGobject."
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:60
#, java-format
msgid "Unknown ResultSet holdability setting: {0}."
msgstr ""
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:98
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:130
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:165
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:187
msgid "Server versions prior to 8.0 do not support savepoints."
msgstr ""
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:100
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:132
msgid "Cannot establish a savepoint in auto-commit mode."
msgstr ""
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:419
msgid "Returning autogenerated keys is not supported."
msgstr ""
#: org/postgresql/jdbc3/AbstractJdbc3ParameterMetaData.java:81
#, fuzzy, java-format
msgid "The parameter index is out of range: {0}, number of parameters: {1}."
msgstr ""
"El índice del arreglo esta fuera de rango: {0}, número de elementos: {1}."
#: org/postgresql/jdbc3/AbstractJdbc3Statement.java:151
msgid ""
"Returning autogenerated keys is only supported for 8.2 and later servers."
msgstr ""
#: org/postgresql/jdbc3/AbstractJdbc3Statement.java:199
#: org/postgresql/jdbc3/AbstractJdbc3Statement.java:317
msgid "Returning autogenerated keys by column index is not supported."
msgstr ""
#: org/postgresql/jdbc3/PSQLSavepoint.java:38
#: org/postgresql/jdbc3/PSQLSavepoint.java:50
#: org/postgresql/jdbc3/PSQLSavepoint.java:66
msgid "Cannot reference a savepoint after it has been released."
msgstr ""
#: org/postgresql/jdbc3/PSQLSavepoint.java:42
msgid "Cannot retrieve the id of a named savepoint."
msgstr ""
#: org/postgresql/jdbc3/PSQLSavepoint.java:54
msgid "Cannot retrieve the name of an unnamed savepoint."
msgstr ""
#: org/postgresql/jdbc3g/AbstractJdbc3gResultSet.java:37
msgid "Invalid UUID data."
msgstr ""
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:83
#, java-format
msgid "Unable to find server array type for provided name {0}."
msgstr ""
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:120
#, java-format
msgid "Invalid timeout ({0}<0)."
msgstr ""
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:133
msgid "Validating connection."
msgstr ""
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:156
#, fuzzy, java-format
msgid "Failed to set ClientInfo property: {0}"
msgstr "Fallo al crear objeto: {0}."
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:165
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:187
msgid "ClientInfo property not supported."
msgstr ""
#: org/postgresql/jdbc4/AbstractJdbc4Statement.java:127
msgid "Object is too large to send over the protocol."
msgstr ""
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:147
msgid "Unable to decode xml data."
msgstr ""
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:150
#, java-format
msgid "Unknown XML Source class: {0}"
msgstr ""
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:195
#, fuzzy
msgid "Unable to create SAXResult for SQLXML."
msgstr "Fallo al crear objeto: {0}."
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:209
msgid "Unable to create StAXResult for SQLXML"
msgstr ""
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:213
#, java-format
msgid "Unknown XML Result class: {0}"
msgstr ""
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:226
msgid "This SQLXML object has already been freed."
msgstr ""
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:233
msgid ""
"This SQLXML object has not been initialized, so you cannot retrieve data "
"from it."
msgstr ""
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:244
#, java-format
msgid "Failed to convert binary xml data to encoding: {0}."
msgstr ""
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:269
msgid "Unable to convert DOMResult SQLXML data to a string."
msgstr ""
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:282
msgid ""
"This SQLXML object has already been initialized, so you cannot manipulate it "
"further."
msgstr ""
#: org/postgresql/largeobject/LargeObjectManager.java:138
msgid "Failed to initialize LargeObject API"
msgstr ""
#: org/postgresql/largeobject/LargeObjectManager.java:198
#: org/postgresql/largeobject/LargeObjectManager.java:239
msgid "Large Objects may not be used in auto-commit mode."
msgstr ""
#: org/postgresql/ssl/jdbc3/AbstractJdbc3MakeSSL.java:58
#: org/postgresql/ssl/jdbc4/AbstractJdbc4MakeSSL.java:110
#, java-format
msgid "The SSLSocketFactory class provided {0} could not be instantiated."
msgstr ""
#: org/postgresql/ssl/jdbc4/AbstractJdbc4MakeSSL.java:125
#, java-format
msgid "SSL error: {0}"
msgstr ""
#: org/postgresql/ssl/jdbc4/AbstractJdbc4MakeSSL.java:138
#, java-format
msgid "The HostnameVerifier class provided {0} could not be instantiated."
msgstr ""
#: org/postgresql/ssl/jdbc4/AbstractJdbc4MakeSSL.java:142
#, java-format
msgid "The hostname {0} could not be verified by hostnameverifier {1}."
msgstr ""
#: org/postgresql/ssl/jdbc4/AbstractJdbc4MakeSSL.java:149
#, java-format
msgid "The hostname {0} could not be verified."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:121
msgid ""
"Could not find a java cryptographic algorithm: X.509 CertificateFactory not "
"available."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:132
#, java-format
msgid "Could not open SSL certificate file {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:137
#, java-format
msgid "Loading the SSL certificate {0} into a KeyManager failed."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:194
msgid "Enter SSL password: "
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:202
msgid "Could not read password for SSL key file, console is not available."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:204
#, java-format
msgid "Could not read password for SSL key file by callbackhandler {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:223
#, java-format
msgid "Could not decrypt SSL key file {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:231
#, java-format
msgid "Could not read SSL key file {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:235
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:173
#, java-format
msgid "Could not find a java cryptographic algorithm: {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:99
#, java-format
msgid "The password callback class provided {0} could not be instantiated."
msgstr ""
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:133
#, java-format
msgid "Could not open SSL root certificate file {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:150
#, java-format
msgid "Could not read SSL root certificate file {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:153
#, java-format
msgid "Loading the SSL root certificate {0} into a TrustManager failed."
msgstr ""
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:166
msgid "Could not initialize SSL context."
msgstr ""
#: org/postgresql/util/PGInterval.java:164
msgid "Conversion of interval failed"
msgstr ""
#: org/postgresql/util/PGmoney.java:73
msgid "Conversion of money failed."
msgstr ""
#: org/postgresql/util/ServerErrorMessage.java:155
#, java-format
msgid "Detail: {0}"
msgstr ""
#: org/postgresql/util/ServerErrorMessage.java:159
#, java-format
msgid "Hint: {0}"
msgstr ""
#: org/postgresql/util/ServerErrorMessage.java:162
#, java-format
msgid "Position: {0}"
msgstr ""
#: org/postgresql/util/ServerErrorMessage.java:165
#, java-format
msgid "Where: {0}"
msgstr ""
#: org/postgresql/util/ServerErrorMessage.java:171
#, java-format
msgid "Internal Query: {0}"
msgstr ""
#: org/postgresql/util/ServerErrorMessage.java:174
#, java-format
msgid "Internal Position: {0}"
msgstr ""
#: org/postgresql/util/ServerErrorMessage.java:180
#, java-format
msgid "Location: File: {0}, Routine: {1}, Line: {2}"
msgstr ""
#: org/postgresql/util/ServerErrorMessage.java:183
#, java-format
msgid "Server SQLState: {0}"
msgstr "SQLState del servidor: {0}."
#: org/postgresql/xa/PGXAConnection.java:148
msgid ""
"Transaction control methods setAutoCommit(true), commit, rollback and "
"setSavePoint not allowed while an XA transaction is active."
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:186
#: org/postgresql/xa/PGXAConnection.java:245
msgid "Invalid flags"
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:189
#: org/postgresql/xa/PGXAConnection.java:248
#: org/postgresql/xa/PGXAConnection.java:425
msgid "xid must not be null"
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:192
msgid "Connection is busy with another transaction"
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:198
#: org/postgresql/xa/PGXAConnection.java:255
#, fuzzy
msgid "suspend/resume not implemented"
msgstr "Este método aún no ha sido implementado."
#: org/postgresql/xa/PGXAConnection.java:204
#: org/postgresql/xa/PGXAConnection.java:207
#: org/postgresql/xa/PGXAConnection.java:209
msgid "Transaction interleaving not implemented"
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:218
msgid "Error disabling autocommit"
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:251
msgid "tried to call end without corresponding start call"
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:282
msgid ""
"Not implemented: Prepare must be issued using the same connection that "
"started the transaction"
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:286
msgid "Prepare called before end"
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:292
msgid "Server versions prior to 8.1 do not support two-phase commit."
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:313
msgid "Error preparing transaction"
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:328
msgid "Invalid flag"
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:368
msgid "Error during recover"
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:416
msgid "Error rolling back prepared transaction"
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:451
msgid ""
"Not implemented: one-phase commit must be issued using the same connection "
"that was used to start it"
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:455
msgid "commit called before end"
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:466
msgid "Error during one-phase commit"
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:487
msgid ""
"Not implemented: 2nd phase commit must be issued using an idle connection"
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:507
msgid "Error committing prepared transaction"
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:522
msgid "Heuristic commit/rollback not supported"
msgstr ""
#~ msgid "The driver does not support SSL."
#~ msgstr "Este driver no soporta SSL."
postgresql-jdbc-9.2-1002.src/org/postgresql/translation/fr.po 0000664 0000000 0000000 00000156751 12050675701 0024156 0 ustar 00root root 0000000 0000000 # translation of head-fr.po to
# french message translation for the PostgreSQL JDBC driver
# This file is distributed under the same license as the package.
# Xavier Poinsard , 2004, 2005.
# Poinsard Xavier , 2005.
#
msgid ""
msgstr ""
"Project-Id-Version: head-fr\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2012-09-10 19:32-0400\n"
"PO-Revision-Date: 2007-07-27 12:27+0200\n"
"Last-Translator: \n"
"Language-Team: \n"
"Language: \n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=ISO-8859-1\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: KBabel 1.11.4\n"
"Plural-Forms: nplurals=2; plural=(n > 1);\n"
#: bin/org/postgresql/Driver.java.in:235 org/postgresql/Driver.java.in:235
msgid "Error loading default settings from driverconfig.properties"
msgstr ""
"Erreur de chargement des valeurs par dfaut depuis driverconfig.properties"
#: bin/org/postgresql/Driver.java.in:282 org/postgresql/Driver.java.in:282
msgid ""
"Your security policy has prevented the connection from being attempted. You "
"probably need to grant the connect java.net.SocketPermission to the database "
"server host and port that you wish to connect to."
msgstr ""
#: bin/org/postgresql/Driver.java.in:287 bin/org/postgresql/Driver.java.in:351
#: org/postgresql/Driver.java.in:287 org/postgresql/Driver.java.in:351
msgid ""
"Something unusual has occured to cause the driver to fail. Please report "
"this exception."
msgstr ""
"Quelque chose d''inhabituel a provoqu l''chec du pilote. Veuillez faire un "
"rapport sur cette erreur."
#: bin/org/postgresql/Driver.java.in:359 org/postgresql/Driver.java.in:359
msgid "Connection attempt timed out."
msgstr "La tentative de connexion a chou dans le dlai imparti."
#: bin/org/postgresql/Driver.java.in:367 org/postgresql/Driver.java.in:367
msgid "Interrupted while attempting to connect."
msgstr "Interrompu pendant l''tablissement de la connexion."
#: bin/org/postgresql/Driver.java.in:710 org/postgresql/Driver.java.in:710
#, java-format
msgid "Method {0} is not yet implemented."
msgstr "La fonction {0} n''est pas encore implmente."
#: org/postgresql/copy/CopyManager.java:56
#, java-format
msgid "Requested CopyIn but got {0}"
msgstr ""
#: org/postgresql/copy/CopyManager.java:67
#, java-format
msgid "Requested CopyOut but got {0}"
msgstr ""
#: org/postgresql/copy/PGCopyInputStream.java:51
#, java-format
msgid "Copying from database failed: {0}"
msgstr ""
#: org/postgresql/copy/PGCopyInputStream.java:67
#: org/postgresql/copy/PGCopyOutputStream.java:90
#, fuzzy
msgid "This copy stream is closed."
msgstr "Ce ResultSet est ferm."
#: org/postgresql/copy/PGCopyInputStream.java:108
msgid "Read from copy failed."
msgstr ""
#: org/postgresql/copy/PGCopyOutputStream.java:68
#, java-format
msgid "Cannot write to copy a byte of value {0}"
msgstr ""
#: org/postgresql/core/ConnectionFactory.java:70
#, java-format
msgid "A connection could not be made using the requested protocol {0}."
msgstr ""
"Aucune connexion n''a pu tre tablie en utilisant le protocole demand {0}. "
#: org/postgresql/core/Oid.java:113
#, java-format
msgid "oid type {0} not known and not a number"
msgstr ""
#: org/postgresql/core/PGStream.java:490
#, java-format
msgid "Premature end of input stream, expected {0} bytes, but only read {1}."
msgstr ""
"Fin prmature du flux en entre, {0} octets attendus, mais seulement {1} "
"lus."
#: org/postgresql/core/PGStream.java:530
#, java-format
msgid "Expected an EOF from server, got: {0}"
msgstr "Attendait une fin de fichier du serveur, reu: {0}"
#: org/postgresql/core/SetupQueryRunner.java:86
msgid "An unexpected result was returned by a query."
msgstr "Un rsultat inattendu a t retourn par une requte."
#: org/postgresql/core/UTF8Encoding.java:28
#, java-format
msgid ""
"Illegal UTF-8 sequence: byte {0} of {1} byte sequence is not 10xxxxxx: {2}"
msgstr ""
"Squence UTF-8 illgale: l''octet {0} de la squence d''octet {1} n''est pas "
"10xxxxxx: {2}"
#: org/postgresql/core/UTF8Encoding.java:61
#, java-format
msgid "Illegal UTF-8 sequence: {0} bytes used to encode a {1} byte value: {2}"
msgstr ""
"Squence UTF-8 illgale: {0} octets utilis pour encoder une valeur {1} "
"octets: {2}"
#: org/postgresql/core/UTF8Encoding.java:98
#: org/postgresql/core/UTF8Encoding.java:125
#, java-format
msgid "Illegal UTF-8 sequence: initial byte is {0}: {1}"
msgstr "Squence UTF-8 illgale: le premier octet est {0}: {1}"
#: org/postgresql/core/UTF8Encoding.java:130
#, java-format
msgid "Illegal UTF-8 sequence: final value is out of range: {0}"
msgstr ""
"Squence UTF-8 illgale: la valeur finale est en dehors des limites: {0}"
#: org/postgresql/core/UTF8Encoding.java:145
#, java-format
msgid "Illegal UTF-8 sequence: final value is a surrogate value: {0}"
msgstr ""
"Squence UTF-8 illgale: la valeur finale est une valeur de remplacement: {0}"
#: org/postgresql/core/Utils.java:95 org/postgresql/core/Utils.java:112
msgid "Zero bytes may not occur in string parameters."
msgstr ""
"Zro octets ne devrait pas se produire dans les paramtres de type chane de "
"caractres."
#: org/postgresql/core/Utils.java:145
msgid "Zero bytes may not occur in identifiers."
msgstr "Des octects 0 ne devraient pas apparatre dans les identifiants."
#: org/postgresql/core/types/PGBigDecimal.java:63
#: org/postgresql/core/types/PGBoolean.java:62
#: org/postgresql/core/types/PGByte.java:63
#: org/postgresql/core/types/PGDouble.java:64
#: org/postgresql/core/types/PGFloat.java:64
#: org/postgresql/core/types/PGInteger.java:61
#: org/postgresql/core/types/PGLong.java:62
#: org/postgresql/core/types/PGNumber.java:62
#: org/postgresql/core/types/PGShort.java:58
#: org/postgresql/core/types/PGString.java:73
#, java-format
msgid "Cannot convert an instance of {0} to type {1}"
msgstr "Impossible de convertir une instance de type {0} vers le type {1}"
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:66
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:74
#, fuzzy, java-format
msgid "Invalid sslmode value: {0}"
msgstr "Longueur de flux invalide {0}."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:134
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:168
msgid ""
"Connection refused. Check that the hostname and port are correct and that "
"the postmaster is accepting TCP/IP connections."
msgstr ""
"Connexion refuse. Vrifiez que le nom de machine et le port sont corrects "
"et que postmaster accepte les connexions TCP/IP."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:153
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:186
msgid "The connection attempt failed."
msgstr "La tentative de connexion a chou."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:175
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:207
#, fuzzy
msgid "The connection url is invalid."
msgstr "La tentative de connexion a chou."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:198
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:210
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:256
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:268
msgid "The server does not support SSL."
msgstr "Le serveur ne supporte pas SSL."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:223
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:281
msgid "An error occured while setting up the SSL connection."
msgstr ""
"Une erreur s''est produite pendant l''tablissement de la connexion SSL."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:272
#, java-format
msgid "Connection rejected: {0}."
msgstr "Connexion rejete: {0}."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:290
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:312
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:332
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:380
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:405
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:432
msgid ""
"The server requested password-based authentication, but no password was "
"provided."
msgstr ""
"Le serveur a demand une authentification par mots de passe, mais aucun mot "
"de passe n''a t fourni."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:356
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:465
#, java-format
msgid ""
"The authentication type {0} is not supported. Check that you have configured "
"the pg_hba.conf file to include the client''s IP address or subnet, and that "
"it is using an authentication scheme supported by the driver."
msgstr ""
"Le type d''authentification {0} n''est pas support. Vrifiez que vous avez "
"configur le fichier pg_hba.conf pour inclure l''adresse IP du client ou le "
"sous-rseau et qu''il utilise un schma d''authentification support par le "
"pilote."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:362
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:400
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:471
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:514
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:560
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:570
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:579
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:587
#: org/postgresql/gss/MakeGSS.java:158
msgid "Protocol error. Session setup failed."
msgstr "Erreur de protocole. Ouverture de la session en chec."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:390
#, java-format
msgid "Backend start-up failed: {0}."
msgstr "Dmarrage du serveur en chec: {0}."
#: org/postgresql/core/v2/FastpathParameterList.java:55
#: org/postgresql/core/v2/FastpathParameterList.java:77
#: org/postgresql/core/v2/FastpathParameterList.java:84
#: org/postgresql/core/v2/SimpleParameterList.java:57
#: org/postgresql/core/v2/SimpleParameterList.java:76
#: org/postgresql/core/v2/SimpleParameterList.java:83
#: org/postgresql/core/v2/SimpleParameterList.java:90
#: org/postgresql/core/v3/CompositeParameterList.java:35
#: org/postgresql/core/v3/SimpleParameterList.java:47
#: org/postgresql/core/v3/SimpleParameterList.java:54
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2845
#: org/postgresql/jdbc2/AbstractJdbc2ResultSetMetaData.java:419
#, java-format
msgid "The column index is out of range: {0}, number of columns: {1}."
msgstr ""
"L''indice de la colonne est hors limite: {0}, nombre de colonnes: {1}."
#: org/postgresql/core/v2/FastpathParameterList.java:142
#: org/postgresql/core/v2/SimpleParameterList.java:155
#: org/postgresql/core/v3/SimpleParameterList.java:183
#, java-format
msgid "No value specified for parameter {0}."
msgstr "Pas de valeur spcifie pour le paramtre {0}."
#: org/postgresql/core/v2/QueryExecutorImpl.java:72
#: org/postgresql/core/v2/QueryExecutorImpl.java:337
#: org/postgresql/core/v3/QueryExecutorImpl.java:443
#: org/postgresql/core/v3/QueryExecutorImpl.java:507
#, java-format
msgid "Expected command status BEGIN, got {0}."
msgstr "Attendait le statut de commande BEGIN, obtenu {0}."
#: org/postgresql/core/v2/QueryExecutorImpl.java:78
#: org/postgresql/core/v3/QueryExecutorImpl.java:513
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1828
#, java-format
msgid "Unexpected command status: {0}."
msgstr "Statut de commande inattendu: {0}."
#: org/postgresql/core/v2/QueryExecutorImpl.java:118
#: org/postgresql/core/v2/QueryExecutorImpl.java:129
#: org/postgresql/core/v2/QueryExecutorImpl.java:174
#: org/postgresql/core/v2/QueryExecutorImpl.java:369
#: org/postgresql/core/v3/QueryExecutorImpl.java:281
#: org/postgresql/core/v3/QueryExecutorImpl.java:411
#: org/postgresql/core/v3/QueryExecutorImpl.java:485
#: org/postgresql/core/v3/QueryExecutorImpl.java:551
#: org/postgresql/core/v3/QueryExecutorImpl.java:631
#: org/postgresql/core/v3/QueryExecutorImpl.java:2094
msgid "An I/O error occured while sending to the backend."
msgstr "Une erreur d''entre/sortie a eu lieu lors d''envoi vers le serveur."
#: org/postgresql/core/v2/QueryExecutorImpl.java:170
#: org/postgresql/core/v2/QueryExecutorImpl.java:225
#: org/postgresql/core/v2/QueryExecutorImpl.java:236
#: org/postgresql/core/v3/QueryExecutorImpl.java:627
#: org/postgresql/core/v3/QueryExecutorImpl.java:685
#, java-format
msgid "Unknown Response Type {0}."
msgstr "Type de rponse inconnu {0}."
#: org/postgresql/core/v2/QueryExecutorImpl.java:430
#: org/postgresql/core/v2/QueryExecutorImpl.java:475
#: org/postgresql/core/v3/QueryExecutorImpl.java:1857
msgid "Ran out of memory retrieving query results."
msgstr "Ai manqu de mmoire en rcuprant les rsultats de la requte."
#: org/postgresql/core/v2/QueryExecutorImpl.java:597
#: org/postgresql/core/v3/QueryExecutorImpl.java:2199
#, java-format
msgid "Unable to interpret the update count in command completion tag: {0}."
msgstr ""
"Incapable d''interprter le nombre de mise jour dans la balise de "
"compltion de commande: {0}."
#: org/postgresql/core/v2/QueryExecutorImpl.java:610
msgid "Copy not implemented for protocol version 2"
msgstr ""
#: org/postgresql/core/v3/CopyOperationImpl.java:56
msgid "CommandComplete expected COPY but got: "
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:66
msgid "Tried to obtain lock while already holding it"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:78
msgid "Tried to break lock on database connection"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:93
#, fuzzy
msgid "Interrupted while waiting to obtain lock on database connection"
msgstr "Interrompu pendant l''tablissement de la connexion."
#: org/postgresql/core/v3/QueryExecutorImpl.java:275
msgid "Unable to bind parameter values for statement."
msgstr "Incapable de lier les valeurs des paramtres pour la commande."
#: org/postgresql/core/v3/QueryExecutorImpl.java:726
msgid "Database connection failed when starting copy"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:757
msgid "Tried to cancel an inactive copy operation"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:794
msgid "Database connection failed when canceling copy operation"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:799
msgid "Missing expected error response to copy cancel request"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:801
#, java-format
msgid "Got {0} error responses to single copy cancel request"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:814
msgid "Tried to end inactive copy"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:827
msgid "Database connection failed when ending copy"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:842
#: org/postgresql/core/v3/QueryExecutorImpl.java:860
msgid "Tried to write to an inactive copy operation"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:854
#: org/postgresql/core/v3/QueryExecutorImpl.java:866
msgid "Database connection failed when writing to copy"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:878
msgid "Tried to read from inactive copy"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:883
msgid "Database connection failed when reading from copy"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:951
#, java-format
msgid "Received CommandComplete ''{0}'' without an active copy operation"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:975
#, java-format
msgid "Got CopyInResponse from server during an active {0}"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:988
#, java-format
msgid "Got CopyOutResponse from server during an active {0}"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:1003
msgid "Got CopyData without an active copy operation"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:1005
#, fuzzy, java-format
msgid "Unexpected copydata from server for {0}"
msgstr "Attendait une fin de fichier du serveur, reu: {0}"
#: org/postgresql/core/v3/QueryExecutorImpl.java:1056
#, java-format
msgid "Unexpected packet type during copy: {0}"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:1310
#, java-format
msgid ""
"Bind message length {0} too long. This can be caused by very large or "
"incorrect length specifications on InputStream parameters."
msgstr ""
"La longueur du message de liaison {0} est trop grande. Cela peut tre caus "
"par des spcification de longueur trs grandes ou incorrectes pour les "
"paramtres de type InputStream."
#: org/postgresql/core/v3/QueryExecutorImpl.java:1925
#, fuzzy, java-format
msgid ""
"The server''s client_encoding parameter was changed to {0}. The JDBC driver "
"requires client_encoding to be UTF8 for correct operation."
msgstr ""
"Le paramtre client_encoding du serveur a t chang pour {0}. Le pilote "
"JDBC ncessite l''affectation de la valeur UNICODE client_encoding pour un "
"fonctionnement correct."
#: org/postgresql/core/v3/QueryExecutorImpl.java:1932
#, java-format
msgid ""
"The server''s DateStyle parameter was changed to {0}. The JDBC driver "
"requires DateStyle to begin with ISO for correct operation."
msgstr ""
"Le paramtre DateStyle du serveur a t chang pour {0}. Le pilote JDBC "
"ncessite que DateStyle commence par ISO pour un fonctionnement correct."
#: org/postgresql/core/v3/QueryExecutorImpl.java:1945
#, java-format
msgid ""
"The server''s standard_conforming_strings parameter was reported as {0}. The "
"JDBC driver expected on or off."
msgstr ""
"Le paramtre serveur standard_conforming_strings a pour valeur {0}. Le "
"driver JDBC attend on ou off."
#: org/postgresql/core/v3/QueryExecutorImpl.java:2015
msgid "The driver currently does not support COPY operations."
msgstr "Le pilote ne supporte pas actuellement les oprations COPY."
#: org/postgresql/ds/jdbc23/AbstractJdbc23PooledConnection.java:112
msgid "This PooledConnection has already been closed."
msgstr "Cette PooledConnection a dj t ferme."
#: org/postgresql/ds/jdbc23/AbstractJdbc23PooledConnection.java:295
msgid ""
"Connection has been closed automatically because a new connection was opened "
"for the same PooledConnection or the PooledConnection has been closed."
msgstr ""
"La connexion a t ferme automatiquement car une nouvelle connexion a t "
"ouverte pour la mme PooledConnection ou la PooledConnection a t ferme."
#: org/postgresql/ds/jdbc23/AbstractJdbc23PooledConnection.java:295
msgid "Connection has been closed."
msgstr "La connexion a t ferme."
#: org/postgresql/ds/jdbc23/AbstractJdbc23PooledConnection.java:442
msgid "Statement has been closed."
msgstr "Statement a t ferm."
#: org/postgresql/ds/jdbc23/AbstractJdbc23PoolingDataSource.java:291
msgid "Failed to setup DataSource."
msgstr ""
#: org/postgresql/ds/jdbc23/AbstractJdbc23PoolingDataSource.java:414
msgid "DataSource has been closed."
msgstr "DataSource a t ferme."
#: org/postgresql/fastpath/Fastpath.java:81
#: org/postgresql/fastpath/Fastpath.java:128
#, java-format
msgid "Fastpath call {0} - No result was returned and we expected an integer."
msgstr ""
"Appel Fastpath {0} - Aucun rsultat n''a t retourn et nous attendions un "
"entier."
#: org/postgresql/fastpath/Fastpath.java:237
#, java-format
msgid "The fastpath function {0} is unknown."
msgstr "La fonction fastpath {0} est inconnue."
#: org/postgresql/geometric/PGbox.java:83
#: org/postgresql/geometric/PGcircle.java:82
#: org/postgresql/geometric/PGcircle.java:91
#: org/postgresql/geometric/PGline.java:80
#: org/postgresql/geometric/PGlseg.java:77
#: org/postgresql/geometric/PGpoint.java:85
#, java-format
msgid "Conversion to type {0} failed: {1}."
msgstr "La conversion vers le type {0} a chou: {1}."
#: org/postgresql/geometric/PGpath.java:81
#, java-format
msgid "Cannot tell if path is open or closed: {0}."
msgstr "Impossible de dire si path est ferm ou ouvert: {0}."
#: org/postgresql/gss/MakeGSS.java:47 org/postgresql/gss/MakeGSS.java:55
#: org/postgresql/gss/MakeGSS.java:168
msgid "GSS Authentication failed"
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Array.java:153
#: org/postgresql/jdbc2/AbstractJdbc2Array.java:790
#, java-format
msgid "The array index is out of range: {0}"
msgstr "L''indice du tableau est hors limites: {0}"
#: org/postgresql/jdbc2/AbstractJdbc2Array.java:168
#: org/postgresql/jdbc2/AbstractJdbc2Array.java:807
#, java-format
msgid "The array index is out of range: {0}, number of elements: {1}."
msgstr "L''indice du tableau est hors limites: {0}, nombre d''lments: {1}."
#: org/postgresql/jdbc2/AbstractJdbc2Array.java:196
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1982
#: org/postgresql/util/HStoreConverter.java:34
#: org/postgresql/util/HStoreConverter.java:61
msgid ""
"Invalid character data was found. This is most likely caused by stored data "
"containing characters that are invalid for the character set the database "
"was created in. The most common example of this is storing 8bit data in a "
"SQL_ASCII database."
msgstr ""
"Des donnes de caractres invalides ont t trouves. C''est probablement "
"caus par le stockage de caractres invalides pour le jeu de caractres de "
"cration de la base. L''exemple le plus courant est le stockage de donnes "
"8bit dans une base SQL_ASCII."
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:73
msgid ""
"Truncation of large objects is only implemented in 8.3 and later servers."
msgstr ""
"Le troncage des large objects n''est implment que dans les serveurs 8.3 et "
"suprieurs."
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:77
msgid "Cannot truncate LOB to a negative length."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:81
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:235
#, java-format
msgid "PostgreSQL LOBs can only index to: {0}"
msgstr "Les LOB PostgreSQL peuvent seulement s''indicer : {0}"
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:231
msgid "LOB positioning offsets start at 1."
msgstr "Les dcalages de position des LOB commencent 1."
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:246
msgid "free() was called on this LOB previously"
msgstr "free() a t appele auparavant sur ce LOB"
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:229
#, java-format
msgid "Unsupported value for stringtype parameter: {0}"
msgstr ""
"Valeur non supporte pour les paramtre de type chane de caractres: {0}"
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:249
msgid "unknownLength parameter value must be an integer"
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:357
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:284
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:303
#: org/postgresql/jdbc2/TypeInfoCache.java:201
#: org/postgresql/jdbc2/TypeInfoCache.java:249
#: org/postgresql/jdbc2/TypeInfoCache.java:287
#: org/postgresql/jdbc2/TypeInfoCache.java:344
#: org/postgresql/jdbc2/TypeInfoCache.java:348
#: org/postgresql/jdbc2/TypeInfoCache.java:384
#: org/postgresql/jdbc2/TypeInfoCache.java:388
msgid "No results were returned by the query."
msgstr "Aucun rsultat retourn par la requte."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:371
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:336
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:368
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2695
msgid "A result was returned when none was expected."
msgstr "Un rsultat a t retourn alors qu''aucun n''tait attendu."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:523
msgid "Custom type maps are not supported."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:571
#, java-format
msgid "Failed to create object for: {0}."
msgstr "chec la cration de l''objet pour: {0}."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:633
#, java-format
msgid "Unable to load the class {0} responsible for the datatype {1}"
msgstr "Incapable de charger la classe {0} responsable du type de donnes {1}"
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:729
msgid ""
"Cannot change transaction read-only property in the middle of a transaction."
msgstr ""
"Impossible de changer la proprit read-only d''une transaction au milieu "
"d''une transaction."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:817
msgid "Cannot commit when autoCommit is enabled."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:826
#, fuzzy
msgid "This connection has been closed."
msgstr "La connexion a t ferme."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:846
msgid "Cannot rollback when autoCommit is enabled."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:933
msgid ""
"Cannot change transaction isolation level in the middle of a transaction."
msgstr ""
"Impossible de changer le niveau d''isolation des transactions au milieu "
"d''une transaction."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:938
#, java-format
msgid "Transaction isolation level {0} not supported."
msgstr "Le niveau d''isolation de transaction {0} n''est pas support."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:1005
msgid "Finalizing a Connection that was never closed:"
msgstr "Destruction d''une connection qui n''a jamais t ferme:"
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:1107
msgid "Unable to translate data into the desired encoding."
msgstr "Impossible de traduire les donnes dans l''encodage dsir."
#: org/postgresql/jdbc2/AbstractJdbc2DatabaseMetaData.java:63
msgid ""
"Unable to determine a value for MaxIndexKeys due to missing system catalog "
"data."
msgstr ""
"Incapable de dterminer la valeur de MaxIndexKeys en raison de donnes "
"manquante dans lecatalogue systme."
#: org/postgresql/jdbc2/AbstractJdbc2DatabaseMetaData.java:86
msgid "Unable to find name datatype in the system catalogs."
msgstr ""
"Incapable de trouver le type de donne name dans les catalogues systmes."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:235
msgid ""
"Operation requires a scrollable ResultSet, but this ResultSet is "
"FORWARD_ONLY."
msgstr ""
"L''opration ncessite un scrollable ResultSet, mais ce ResultSet est "
"FORWARD_ONLY."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:416
msgid "Unexpected error while decoding character data from a large object."
msgstr ""
"Erreur inattendue pendant le dcodage des donnes caractres pour un large "
"object."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:462
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:491
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:525
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3129
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3174
#, fuzzy, java-format
msgid "Cannot convert the column of type {0} to requested type {1}."
msgstr "Impossible de convertir une instance de type {0} vers le type {1}"
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:744
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:768
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1892
msgid "Can''t use relative move methods while on the insert row."
msgstr ""
"Impossible d''utiliser les fonctions de dplacement relatif pendant "
"l''insertion d''une ligne."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:788
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2949
#, java-format
msgid "Invalid fetch direction constant: {0}."
msgstr "Constante de direction pour la rcupration invalide: {0}."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:802
msgid "Cannot call cancelRowUpdates() when on the insert row."
msgstr ""
"Impossible d''appeler cancelRowUpdates() pendant l''insertion d''une ligne."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:822
msgid "Cannot call deleteRow() when on the insert row."
msgstr "Impossible d''appeler deleteRow() pendant l''insertion d''une ligne."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:828
msgid ""
"Currently positioned before the start of the ResultSet. You cannot call "
"deleteRow() here."
msgstr ""
"Actuellement positionn avant le dbut du ResultSet. Vous ne pouvez pas "
"appeler deleteRow() ici."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:833
msgid ""
"Currently positioned after the end of the ResultSet. You cannot call "
"deleteRow() here."
msgstr ""
"Actuellement positionn aprs la fin du ResultSet. Vous ne pouvez pas "
"appeler deleteRow() ici."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:838
msgid "There are no rows in this ResultSet."
msgstr "Il n''y pas pas de lignes dans ce ResultSet."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:885
msgid "Not on the insert row."
msgstr "Pas sur la ligne en insertion."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:889
msgid "You must specify at least one column value to insert a row."
msgstr ""
"Vous devez spcifier au moins une valeur de colonne pour insrer une ligne."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1074
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1805
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2494
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2524
#, java-format
msgid "The JVM claims not to support the encoding: {0}"
msgstr "La JVM prtend ne pas supporter l''encodage: {0}"
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1078
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1121
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1527
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1656
msgid "Provided InputStream failed."
msgstr "L''InputStream fourni a chou."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1191
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3130
msgid "Provided Reader failed."
msgstr "Le Reader fourni a chou."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1259
msgid "Can''t refresh the insert row."
msgstr "Impossible de rafrachir la ligne insre."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1327
msgid "Cannot call updateRow() when on the insert row."
msgstr ""
"Impossible d''appeler updateRow() tant que l''on est sur la ligne insre."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1333
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3190
msgid ""
"Cannot update the ResultSet because it is either before the start or after "
"the end of the results."
msgstr ""
"Impossible de mettre jour le ResultSet car c''est soit avant le dbut ou "
"aprs la fin des rsultats."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1582
msgid "ResultSets with concurrency CONCUR_READ_ONLY cannot be updated."
msgstr ""
"Les ResultSets avec la concurrence CONCUR_READ_ONLY ne peuvent tre mis "
"jour."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1650
#, java-format
msgid "No primary key found for table {0}."
msgstr "Pas de cl primaire trouve pour la table {0}."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1876
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2958
msgid "Fetch size must be a value greater to or equal to 0."
msgstr "Fetch size doit tre une valeur suprieur ou gal 0."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2044
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2051
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2098
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2106
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2926
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2934
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2964
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2971
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2991
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3002
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3020
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3038
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3179
#: org/postgresql/jdbc2/TimestampUtils.java:258
#, java-format
msgid "Bad value for type {0} : {1}"
msgstr "Mauvaise valeur pour le type {0}: {1}"
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2727
#, java-format
msgid "The column name {0} was not found in this ResultSet."
msgstr "Le nom de colonne {0} n''a pas t trouv dans ce ResultSet."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2827
msgid ""
"ResultSet is not updateable. The query that generated this result set must "
"select only one table, and must select all primary keys from that table. See "
"the JDBC 2.1 API Specification, section 5.6 for more details."
msgstr ""
"Le ResultSet n''est pas modifiable. La requte qui a gnr ce rsultat doit "
"slectionner seulement une table, et doit slectionner toutes les cls "
"primaires de cette table. Voir la spcification de l''API JDBC 2.1, section "
"5.6 pour plus de dtails."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2839
msgid "This ResultSet is closed."
msgstr "Ce ResultSet est ferm."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2860
msgid "ResultSet not positioned properly, perhaps you need to call next."
msgstr ""
"Le ResultSet n''est pas positionn correctement, vous devez peut-tre "
"appeler next()."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:259
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:323
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:392
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2648
msgid ""
"Can''t use query methods that take a query string on a PreparedStatement."
msgstr ""
"Impossible d''utiliser les fonctions de requte qui utilisent une chane de "
"caractres sur un PreparedStatement."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:287
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:306
msgid "Multiple ResultSets were returned by the query."
msgstr "Plusieurs ResultSets ont t retourns par la requte."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:425
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:429
msgid "A CallableStatement was executed with nothing returned."
msgstr "Un CallableStatement a t excut mais n''a rien retourn."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:437
#, fuzzy
msgid "A CallableStatement was executed with an invalid number of parameters"
msgstr ""
"Un CallableStatement a t excut avec un nombre de paramtres incorrect"
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:468
#, java-format
msgid ""
"A CallableStatement function was executed and the out parameter {0} was of "
"type {1} however type {2} was registered."
msgstr ""
"Une fonction CallableStatement a t excute et le paramtre en sortie {0} "
"tait du type {1} alors que le type {2} tait prvu."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:670
msgid "Maximum number of rows must be a value grater than or equal to 0."
msgstr ""
"Le nombre maximum de lignes doit tre une valeur suprieure ou gale 0."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:713
msgid "Query timeout must be a value greater than or equals to 0."
msgstr "Query timeout doit tre une valeur suprieure ou gale 0."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:804
msgid "The maximum field size must be a value greater than or equal to 0."
msgstr ""
"La taille maximum des champs doit tre une valeur suprieure ou gale 0."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1219
msgid "Unknown Types value."
msgstr "Valeur de Types inconnue."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1492
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1617
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3101
#, java-format
msgid "Invalid stream length {0}."
msgstr "Longueur de flux invalide {0}."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1523
#, java-format
msgid "The JVM claims not to support the {0} encoding."
msgstr "La JVM prtend ne pas supporter l''encodage {0}."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1698
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3023
#, java-format
msgid "Unknown type {0}."
msgstr "Type inconnu: {0}."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1713
msgid "No hstore extension installed."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1838
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1844
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1850
#, java-format
msgid "Cannot cast an instance of {0} to type {1}"
msgstr "Impossible de convertir une instance de {0} vers le type {1}"
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1862
#, java-format
msgid "Unsupported Types value: {0}"
msgstr "Valeur de type non supporte: {0}"
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1920
#, java-format
msgid ""
"Can''t infer the SQL type to use for an instance of {0}. Use setObject() "
"with an explicit Types value to specify the type to use."
msgstr ""
"Impossible de dduire le type SQL utiliser pour une instance de {0}. "
"Utilisez setObject() avec une valeur de type explicite pour spcifier le "
"type utiliser."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1968
msgid ""
"This statement does not declare an OUT parameter. Use '{' ?= call ... '}' "
"to declare one."
msgstr ""
"Cette requte ne dclare pas de paramtre OUT. Utilisez '{' ?= call ... '}' "
"pour en dclarer un."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2018
msgid "wasNull cannot be call before fetching a result."
msgstr "wasNull ne peut pas tre appel avant la rcupration d''un rsultat."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2514
#, java-format
msgid "Malformed function or procedure escape syntax at offset {0}."
msgstr ""
"Syntaxe de fonction ou d''chappement de procdure malforme l''indice {0}."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2564
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2578
#, java-format
msgid ""
"Parameter of type {0} was registered, but call to get{1} (sqltype={2}) was "
"made."
msgstr ""
"Un paramtre de type {0} a t enregistr, mais un appel get{1} (sqltype="
"{2}) a t fait."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2597
msgid ""
"A CallableStatement was declared, but no call to registerOutParameter(1, "
") was made."
msgstr ""
"Un CallableStatement a t dclar, mais aucun appel registerOutParameter"
"(1, ) n''a t fait."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2601
msgid "No function outputs were registered."
msgstr "Aucune fonction outputs n''a t enregistre."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2604
msgid ""
"Results cannot be retrieved from a CallableStatement before it is executed."
msgstr ""
"Les rsultats ne peuvent tre rcuprs partir d''un CallableStatement "
"avant qu''il ne soit excut."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2637
msgid "This statement has been closed."
msgstr "Ce statement a t ferm."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2717
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2787
msgid "Too many update results were returned."
msgstr "Trop de rsultats de mise jour ont t retourns."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2746
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2816
#, java-format
msgid ""
"Batch entry {0} {1} was aborted. Call getNextException to see the cause."
msgstr ""
"L''lment du batch {0} {1} a t annul. Appeler getNextException pour en "
"connatre la cause."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3071
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3160
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3200
msgid "Unexpected error writing large object to database."
msgstr "Erreur inattendue pendant l''criture de large object dans la base."
#: org/postgresql/jdbc2/EscapedFunctions.java:145
#: org/postgresql/jdbc2/EscapedFunctions.java:157
#: org/postgresql/jdbc2/EscapedFunctions.java:169
#: org/postgresql/jdbc2/EscapedFunctions.java:206
#: org/postgresql/jdbc2/EscapedFunctions.java:243
#: org/postgresql/jdbc2/EscapedFunctions.java:267
#: org/postgresql/jdbc2/EscapedFunctions.java:292
#: org/postgresql/jdbc2/EscapedFunctions.java:316
#: org/postgresql/jdbc2/EscapedFunctions.java:328
#: org/postgresql/jdbc2/EscapedFunctions.java:352
#: org/postgresql/jdbc2/EscapedFunctions.java:380
#: org/postgresql/jdbc2/EscapedFunctions.java:389
#: org/postgresql/jdbc2/EscapedFunctions.java:399
#: org/postgresql/jdbc2/EscapedFunctions.java:408
#: org/postgresql/jdbc2/EscapedFunctions.java:417
#: org/postgresql/jdbc2/EscapedFunctions.java:426
#: org/postgresql/jdbc2/EscapedFunctions.java:435
#: org/postgresql/jdbc2/EscapedFunctions.java:444
#: org/postgresql/jdbc2/EscapedFunctions.java:453
#: org/postgresql/jdbc2/EscapedFunctions.java:462
#: org/postgresql/jdbc2/EscapedFunctions.java:471
#: org/postgresql/jdbc2/EscapedFunctions.java:480
#, java-format
msgid "{0} function takes one and only one argument."
msgstr "La fonction {0} n''accepte qu''un et un seul argument."
#: org/postgresql/jdbc2/EscapedFunctions.java:181
#: org/postgresql/jdbc2/EscapedFunctions.java:193
#: org/postgresql/jdbc2/EscapedFunctions.java:255
#: org/postgresql/jdbc2/EscapedFunctions.java:304
#: org/postgresql/jdbc2/EscapedFunctions.java:582
#, java-format
msgid "{0} function takes two and only two arguments."
msgstr "La fonction {0} n''accepte que deux et seulement deux arguments."
#: org/postgresql/jdbc2/EscapedFunctions.java:230
#, java-format
msgid "{0} function takes four and only four argument."
msgstr "La fonction {0} n''accepte que quatre et seulement quatre arguments."
#: org/postgresql/jdbc2/EscapedFunctions.java:282
#: org/postgresql/jdbc2/EscapedFunctions.java:342
#, java-format
msgid "{0} function takes two or three arguments."
msgstr "La fonction {0} n''accepte que deux ou trois arguments."
#: org/postgresql/jdbc2/EscapedFunctions.java:362
#: org/postgresql/jdbc2/EscapedFunctions.java:371
#: org/postgresql/jdbc2/EscapedFunctions.java:573
#: org/postgresql/jdbc2/EscapedFunctions.java:591
#, java-format
msgid "{0} function doesn''t take any argument."
msgstr "La fonction {0} n''accepte aucun argument."
#: org/postgresql/jdbc2/EscapedFunctions.java:489
#: org/postgresql/jdbc2/EscapedFunctions.java:531
#, java-format
msgid "{0} function takes three and only three arguments."
msgstr "La fonction {0} n''accepte que trois et seulement trois arguments."
#: org/postgresql/jdbc2/EscapedFunctions.java:501
#: org/postgresql/jdbc2/EscapedFunctions.java:521
#: org/postgresql/jdbc2/EscapedFunctions.java:523
#: org/postgresql/jdbc2/EscapedFunctions.java:543
#: org/postgresql/jdbc2/EscapedFunctions.java:564
#: org/postgresql/jdbc2/EscapedFunctions.java:566
#, java-format
msgid "Interval {0} not yet implemented"
msgstr "L''interval {0} n''est pas encore implment"
#: org/postgresql/jdbc2/TimestampUtils.java:360
msgid ""
"Infinite value found for timestamp/date. This cannot be represented as time."
msgstr ""
"Valeur infinie trouve pour une date/timestamp. Cette valeur ne peut tre "
"reprsent comme une valeur temporelle."
#: org/postgresql/jdbc2/TimestampUtils.java:648
#: org/postgresql/jdbc2/TimestampUtils.java:680
#: org/postgresql/jdbc2/TimestampUtils.java:727
#, fuzzy, java-format
msgid "Unsupported binary encoding of {0}."
msgstr "Valeur de type non supporte: {0}"
#: org/postgresql/jdbc2/TypeInfoCache.java:161
#, java-format
msgid "The class {0} does not implement org.postgresql.util.PGobject."
msgstr "La classe {0} n''implmente pas org.postgresql.util.PGobject."
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:60
#, java-format
msgid "Unknown ResultSet holdability setting: {0}."
msgstr "Paramtre holdability du ResultSet inconnu: {0}."
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:98
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:130
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:165
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:187
msgid "Server versions prior to 8.0 do not support savepoints."
msgstr ""
"Les serveurs de version antrieure 8.0 ne supportent pas les savepoints."
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:100
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:132
msgid "Cannot establish a savepoint in auto-commit mode."
msgstr "Impossible d''tablir un savepoint en mode auto-commit."
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:419
msgid "Returning autogenerated keys is not supported."
msgstr "Le renvoi des cls automatiquement gnres n''est pas support."
#: org/postgresql/jdbc3/AbstractJdbc3ParameterMetaData.java:81
#, java-format
msgid "The parameter index is out of range: {0}, number of parameters: {1}."
msgstr ""
"L''indice du paramtre est hors limites: {0}, nombre de paramtres: {1}."
#: org/postgresql/jdbc3/AbstractJdbc3Statement.java:151
#, fuzzy
msgid ""
"Returning autogenerated keys is only supported for 8.2 and later servers."
msgstr "Le renvoi des cls automatiquement gnres n''est pas support."
#: org/postgresql/jdbc3/AbstractJdbc3Statement.java:199
#: org/postgresql/jdbc3/AbstractJdbc3Statement.java:317
#, fuzzy
msgid "Returning autogenerated keys by column index is not supported."
msgstr "Le renvoi des cls automatiquement gnres n''est pas support."
#: org/postgresql/jdbc3/PSQLSavepoint.java:38
#: org/postgresql/jdbc3/PSQLSavepoint.java:50
#: org/postgresql/jdbc3/PSQLSavepoint.java:66
msgid "Cannot reference a savepoint after it has been released."
msgstr "Impossible de rfrencer un savepoint aprs qu''il ait t libr."
#: org/postgresql/jdbc3/PSQLSavepoint.java:42
msgid "Cannot retrieve the id of a named savepoint."
msgstr "Impossible de retrouver l''identifiant d''un savepoint nomm."
#: org/postgresql/jdbc3/PSQLSavepoint.java:54
msgid "Cannot retrieve the name of an unnamed savepoint."
msgstr "Impossible de retrouver le nom d''un savepoint sans nom."
#: org/postgresql/jdbc3g/AbstractJdbc3gResultSet.java:37
#, fuzzy
msgid "Invalid UUID data."
msgstr "Drapeau invalide"
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:83
#, java-format
msgid "Unable to find server array type for provided name {0}."
msgstr ""
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:120
#, fuzzy, java-format
msgid "Invalid timeout ({0}<0)."
msgstr "Longueur de flux invalide {0}."
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:133
msgid "Validating connection."
msgstr ""
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:156
#, fuzzy, java-format
msgid "Failed to set ClientInfo property: {0}"
msgstr "chec la cration de l''objet pour: {0}."
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:165
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:187
#, fuzzy
msgid "ClientInfo property not supported."
msgstr "Le renvoi des cls automatiquement gnres n''est pas support."
#: org/postgresql/jdbc4/AbstractJdbc4Statement.java:127
msgid "Object is too large to send over the protocol."
msgstr ""
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:147
msgid "Unable to decode xml data."
msgstr ""
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:150
#, java-format
msgid "Unknown XML Source class: {0}"
msgstr ""
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:195
#, fuzzy
msgid "Unable to create SAXResult for SQLXML."
msgstr "chec la cration de l''objet pour: {0}."
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:209
msgid "Unable to create StAXResult for SQLXML"
msgstr ""
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:213
#, fuzzy, java-format
msgid "Unknown XML Result class: {0}"
msgstr "Paramtre holdability du ResultSet inconnu: {0}."
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:226
#, fuzzy
msgid "This SQLXML object has already been freed."
msgstr "Cette PooledConnection a dj t ferme."
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:233
msgid ""
"This SQLXML object has not been initialized, so you cannot retrieve data "
"from it."
msgstr ""
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:244
#, java-format
msgid "Failed to convert binary xml data to encoding: {0}."
msgstr ""
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:269
msgid "Unable to convert DOMResult SQLXML data to a string."
msgstr ""
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:282
msgid ""
"This SQLXML object has already been initialized, so you cannot manipulate it "
"further."
msgstr ""
#: org/postgresql/largeobject/LargeObjectManager.java:138
msgid "Failed to initialize LargeObject API"
msgstr "chec l''initialisation de l''API LargeObject"
#: org/postgresql/largeobject/LargeObjectManager.java:198
#: org/postgresql/largeobject/LargeObjectManager.java:239
msgid "Large Objects may not be used in auto-commit mode."
msgstr "Les Large Objects ne devraient pas tre utiliss en mode auto-commit."
#: org/postgresql/ssl/jdbc3/AbstractJdbc3MakeSSL.java:58
#: org/postgresql/ssl/jdbc4/AbstractJdbc4MakeSSL.java:110
#, java-format
msgid "The SSLSocketFactory class provided {0} could not be instantiated."
msgstr "La classe SSLSocketFactory fournie {0} n''a pas pu tre instancie."
#: org/postgresql/ssl/jdbc4/AbstractJdbc4MakeSSL.java:125
#, java-format
msgid "SSL error: {0}"
msgstr ""
#: org/postgresql/ssl/jdbc4/AbstractJdbc4MakeSSL.java:138
#, fuzzy, java-format
msgid "The HostnameVerifier class provided {0} could not be instantiated."
msgstr "La classe SSLSocketFactory fournie {0} n''a pas pu tre instancie."
#: org/postgresql/ssl/jdbc4/AbstractJdbc4MakeSSL.java:142
#, java-format
msgid "The hostname {0} could not be verified by hostnameverifier {1}."
msgstr ""
#: org/postgresql/ssl/jdbc4/AbstractJdbc4MakeSSL.java:149
#, java-format
msgid "The hostname {0} could not be verified."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:121
msgid ""
"Could not find a java cryptographic algorithm: X.509 CertificateFactory not "
"available."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:132
#, java-format
msgid "Could not open SSL certificate file {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:137
#, java-format
msgid "Loading the SSL certificate {0} into a KeyManager failed."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:194
msgid "Enter SSL password: "
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:202
msgid "Could not read password for SSL key file, console is not available."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:204
#, java-format
msgid "Could not read password for SSL key file by callbackhandler {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:223
#, java-format
msgid "Could not decrypt SSL key file {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:231
#, java-format
msgid "Could not read SSL key file {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:235
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:173
#, java-format
msgid "Could not find a java cryptographic algorithm: {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:99
#, fuzzy, java-format
msgid "The password callback class provided {0} could not be instantiated."
msgstr "La classe SSLSocketFactory fournie {0} n''a pas pu tre instancie."
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:133
#, java-format
msgid "Could not open SSL root certificate file {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:150
#, java-format
msgid "Could not read SSL root certificate file {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:153
#, java-format
msgid "Loading the SSL root certificate {0} into a TrustManager failed."
msgstr ""
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:166
msgid "Could not initialize SSL context."
msgstr ""
#: org/postgresql/util/PGInterval.java:164
msgid "Conversion of interval failed"
msgstr "La conversion de l''intervalle a chou"
#: org/postgresql/util/PGmoney.java:73
msgid "Conversion of money failed."
msgstr "La conversion de money a chou."
#: org/postgresql/util/ServerErrorMessage.java:155
#, java-format
msgid "Detail: {0}"
msgstr "Dtail: {0}"
#: org/postgresql/util/ServerErrorMessage.java:159
#, java-format
msgid "Hint: {0}"
msgstr "Indice: {0}"
#: org/postgresql/util/ServerErrorMessage.java:162
#, java-format
msgid "Position: {0}"
msgstr "Position: {0}"
#: org/postgresql/util/ServerErrorMessage.java:165
#, java-format
msgid "Where: {0}"
msgstr "O: {0}"
#: org/postgresql/util/ServerErrorMessage.java:171
#, java-format
msgid "Internal Query: {0}"
msgstr "Requte interne: {0}"
#: org/postgresql/util/ServerErrorMessage.java:174
#, java-format
msgid "Internal Position: {0}"
msgstr "Position interne: {0}"
#: org/postgresql/util/ServerErrorMessage.java:180
#, java-format
msgid "Location: File: {0}, Routine: {1}, Line: {2}"
msgstr "Localisation: Fichier: {0}, Routine: {1}, Ligne: {2}"
#: org/postgresql/util/ServerErrorMessage.java:183
#, java-format
msgid "Server SQLState: {0}"
msgstr "SQLState serveur: {0}"
#: org/postgresql/xa/PGXAConnection.java:148
msgid ""
"Transaction control methods setAutoCommit(true), commit, rollback and "
"setSavePoint not allowed while an XA transaction is active."
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:186
#: org/postgresql/xa/PGXAConnection.java:245
msgid "Invalid flags"
msgstr "Drapeaux invalides"
#: org/postgresql/xa/PGXAConnection.java:189
#: org/postgresql/xa/PGXAConnection.java:248
#: org/postgresql/xa/PGXAConnection.java:425
msgid "xid must not be null"
msgstr "xid ne doit pas tre nul"
#: org/postgresql/xa/PGXAConnection.java:192
msgid "Connection is busy with another transaction"
msgstr "La connection est occupe avec une autre transaction"
#: org/postgresql/xa/PGXAConnection.java:198
#: org/postgresql/xa/PGXAConnection.java:255
msgid "suspend/resume not implemented"
msgstr "suspend/resume pas implment"
#: org/postgresql/xa/PGXAConnection.java:204
#: org/postgresql/xa/PGXAConnection.java:207
#: org/postgresql/xa/PGXAConnection.java:209
msgid "Transaction interleaving not implemented"
msgstr "L''entrelacement des transactions n''est pas implment"
#: org/postgresql/xa/PGXAConnection.java:218
msgid "Error disabling autocommit"
msgstr "Erreur en dsactivant autocommit"
#: org/postgresql/xa/PGXAConnection.java:251
msgid "tried to call end without corresponding start call"
msgstr "tentative d''appel de fin sans l''appel start correspondant"
#: org/postgresql/xa/PGXAConnection.java:282
msgid ""
"Not implemented: Prepare must be issued using the same connection that "
"started the transaction"
msgstr ""
"Pas implment: Prepare doit tre envoy sur la mme connection qui a "
"dmarr la transaction"
#: org/postgresql/xa/PGXAConnection.java:286
msgid "Prepare called before end"
msgstr "Prparation appele avant la fin"
#: org/postgresql/xa/PGXAConnection.java:292
msgid "Server versions prior to 8.1 do not support two-phase commit."
msgstr ""
"Les serveurs de versions antrieures 8.1 ne supportent pas le commit "
"deux phases."
#: org/postgresql/xa/PGXAConnection.java:313
msgid "Error preparing transaction"
msgstr "Erreur en prparant la transaction"
#: org/postgresql/xa/PGXAConnection.java:328
msgid "Invalid flag"
msgstr "Drapeau invalide"
#: org/postgresql/xa/PGXAConnection.java:368
msgid "Error during recover"
msgstr "Erreur durant la restauration"
#: org/postgresql/xa/PGXAConnection.java:416
msgid "Error rolling back prepared transaction"
msgstr "Erreur en annulant une transaction prpare"
#: org/postgresql/xa/PGXAConnection.java:451
msgid ""
"Not implemented: one-phase commit must be issued using the same connection "
"that was used to start it"
msgstr ""
"Pas implment: le commit une phase doit avoir lieu en utilisant la mme "
"connection que celle o il a commenc"
#: org/postgresql/xa/PGXAConnection.java:455
msgid "commit called before end"
msgstr "Commit appel avant la fin"
#: org/postgresql/xa/PGXAConnection.java:466
msgid "Error during one-phase commit"
msgstr "Erreur pendant le commit une phase"
#: org/postgresql/xa/PGXAConnection.java:487
msgid ""
"Not implemented: 2nd phase commit must be issued using an idle connection"
msgstr ""
"Pas implment: le commit deux phase doit tre envoy sur une connection "
"inutilise"
#: org/postgresql/xa/PGXAConnection.java:507
#, fuzzy
msgid "Error committing prepared transaction"
msgstr "Erreur en annulant une transaction prpare"
#: org/postgresql/xa/PGXAConnection.java:522
msgid "Heuristic commit/rollback not supported"
msgstr "Heuristic commit/rollback non support"
#~ msgid "The driver does not support SSL."
#~ msgstr "Ce pilote ne supporte pas SSL."
#~ msgid "Multi-dimensional arrays are currently not supported."
#~ msgstr ""
#~ "Les tableaux plusieurs dimensions ne sont pas supports pour le moment."
#~ msgid "Exception: {0}"
#~ msgstr "Exception: {0}"
#~ msgid "Stack Trace:"
#~ msgstr "Pile d''appel:"
#~ msgid "End of Stack Trace"
#~ msgstr "Fin de la pile d''appel"
#~ msgid "Exception generating stacktrace for: {0} encountered: {1}"
#~ msgstr ""
#~ "Exception en gnrant la pile d''appel pour: {0} erreur rencontre: {1}"
postgresql-jdbc-9.2-1002.src/org/postgresql/translation/it.po 0000664 0000000 0000000 00000164572 12050675701 0024163 0 ustar 00root root 0000000 0000000 # Italian message translation for the PostgreSQL JDBC driver
# This file is distributed under the same license as the package.
#
# First translation by Daniele Arduini
# Updated by Giuseppe Sacco 2004, 2005.
#
#
msgid ""
msgstr ""
"Project-Id-Version: PostgreSQL JDBC Driver 8.2\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2012-09-10 19:32-0400\n"
"PO-Revision-Date: 2006-06-23 17:25+0200\n"
"Last-Translator: Giuseppe Sacco \n"
"Language-Team: Italian \n"
"Language: it\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=ISO-8859-1\n"
"Content-Transfer-Encoding: 8bit\n"
#: bin/org/postgresql/Driver.java.in:235 org/postgresql/Driver.java.in:235
msgid "Error loading default settings from driverconfig.properties"
msgstr ""
"Si verificato un errore caricando le impostazioni predefinite da "
"driverconfig.properties."
#: bin/org/postgresql/Driver.java.in:282 org/postgresql/Driver.java.in:282
msgid ""
"Your security policy has prevented the connection from being attempted. You "
"probably need to grant the connect java.net.SocketPermission to the database "
"server host and port that you wish to connect to."
msgstr ""
#: bin/org/postgresql/Driver.java.in:287 bin/org/postgresql/Driver.java.in:351
#: org/postgresql/Driver.java.in:287 org/postgresql/Driver.java.in:351
msgid ""
"Something unusual has occured to cause the driver to fail. Please report "
"this exception."
msgstr ""
"Qualcosa di insolito si verificato causando il fallimento del driver. Per "
"favore riferire all''autore del driver questa eccezione."
#: bin/org/postgresql/Driver.java.in:359 org/postgresql/Driver.java.in:359
msgid "Connection attempt timed out."
msgstr "Il tentativo di connessione scaduto."
#: bin/org/postgresql/Driver.java.in:367 org/postgresql/Driver.java.in:367
msgid "Interrupted while attempting to connect."
msgstr "Si verificata una interruzione durante il tentativo di connessione."
#: bin/org/postgresql/Driver.java.in:710 org/postgresql/Driver.java.in:710
#, java-format
msgid "Method {0} is not yet implemented."
msgstr "Il metodo {0} non stato ancora implementato."
#: org/postgresql/copy/CopyManager.java:56
#, java-format
msgid "Requested CopyIn but got {0}"
msgstr ""
#: org/postgresql/copy/CopyManager.java:67
#, java-format
msgid "Requested CopyOut but got {0}"
msgstr ""
#: org/postgresql/copy/PGCopyInputStream.java:51
#, fuzzy, java-format
msgid "Copying from database failed: {0}"
msgstr "Fallita la conversione di un ``box'': {0}."
#: org/postgresql/copy/PGCopyInputStream.java:67
#: org/postgresql/copy/PGCopyOutputStream.java:90
#, fuzzy
msgid "This copy stream is closed."
msgstr "Questo ResultSet chiuso."
#: org/postgresql/copy/PGCopyInputStream.java:108
msgid "Read from copy failed."
msgstr ""
#: org/postgresql/copy/PGCopyOutputStream.java:68
#, java-format
msgid "Cannot write to copy a byte of value {0}"
msgstr ""
#: org/postgresql/core/ConnectionFactory.java:70
#, java-format
msgid "A connection could not be made using the requested protocol {0}."
msgstr ""
"Non stato possibile attivare la connessione utilizzando il protocollo "
"richiesto {0}."
#: org/postgresql/core/Oid.java:113
#, java-format
msgid "oid type {0} not known and not a number"
msgstr ""
#: org/postgresql/core/PGStream.java:490
#, java-format
msgid "Premature end of input stream, expected {0} bytes, but only read {1}."
msgstr ""
"Il flusso di input stato interrotto, sono arrivati {1} byte al posto dei "
"{0} attesi."
#: org/postgresql/core/PGStream.java:530
#, java-format
msgid "Expected an EOF from server, got: {0}"
msgstr "Ricevuto dal server {0} mentre era atteso un EOF"
#: org/postgresql/core/SetupQueryRunner.java:86
msgid "An unexpected result was returned by a query."
msgstr "Un risultato inaspettato stato ricevuto dalla query."
#: org/postgresql/core/UTF8Encoding.java:28
#, java-format
msgid ""
"Illegal UTF-8 sequence: byte {0} of {1} byte sequence is not 10xxxxxx: {2}"
msgstr ""
"Sequenza UTF-8 illegale: il byte {0} di una sequenza di {1} byte non "
"10xxxxxx: {2}"
#: org/postgresql/core/UTF8Encoding.java:61
#, java-format
msgid "Illegal UTF-8 sequence: {0} bytes used to encode a {1} byte value: {2}"
msgstr ""
"Sequenza UTF-8 illegale: {0} byte utilizzati per codificare un valore di {1} "
"byte: {2}"
#: org/postgresql/core/UTF8Encoding.java:98
#: org/postgresql/core/UTF8Encoding.java:125
#, java-format
msgid "Illegal UTF-8 sequence: initial byte is {0}: {1}"
msgstr "Sequenza UTF-8 illegale: il byte iniziale {0}: {1}"
#: org/postgresql/core/UTF8Encoding.java:130
#, java-format
msgid "Illegal UTF-8 sequence: final value is out of range: {0}"
msgstr ""
"Sequenza UTF-8 illegale: il valore finale fuori dall''intervallo permesso: "
"{0}"
#: org/postgresql/core/UTF8Encoding.java:145
#, java-format
msgid "Illegal UTF-8 sequence: final value is a surrogate value: {0}"
msgstr "Sequenza UTF-8 illegale: il valore finale un surrogato: {0}"
#: org/postgresql/core/Utils.java:95 org/postgresql/core/Utils.java:112
msgid "Zero bytes may not occur in string parameters."
msgstr ""
"Byte con valore zero non possono essere contenuti nei parametri stringa."
#: org/postgresql/core/Utils.java:145
#, fuzzy
msgid "Zero bytes may not occur in identifiers."
msgstr ""
"Byte con valore zero non possono essere contenuti nei parametri stringa."
#: org/postgresql/core/types/PGBigDecimal.java:63
#: org/postgresql/core/types/PGBoolean.java:62
#: org/postgresql/core/types/PGByte.java:63
#: org/postgresql/core/types/PGDouble.java:64
#: org/postgresql/core/types/PGFloat.java:64
#: org/postgresql/core/types/PGInteger.java:61
#: org/postgresql/core/types/PGLong.java:62
#: org/postgresql/core/types/PGNumber.java:62
#: org/postgresql/core/types/PGShort.java:58
#: org/postgresql/core/types/PGString.java:73
#, java-format
msgid "Cannot convert an instance of {0} to type {1}"
msgstr "Non possibile convertire una istanza di {0} nel tipo {1}"
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:66
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:74
#, fuzzy, java-format
msgid "Invalid sslmode value: {0}"
msgstr "La dimensione specificata, {0}, per lo stream non valida."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:134
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:168
msgid ""
"Connection refused. Check that the hostname and port are correct and that "
"the postmaster is accepting TCP/IP connections."
msgstr ""
"Connessione rifiutata. Controllare che il nome dell''host e la porta siano "
"corretti, e che il server (postmaster) sia in esecuzione con l''opzione -i, "
"che abilita le connessioni attraverso la rete TCP/IP."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:153
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:186
msgid "The connection attempt failed."
msgstr "Il tentativo di connessione fallito."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:175
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:207
#, fuzzy
msgid "The connection url is invalid."
msgstr "Il tentativo di connessione fallito."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:198
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:210
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:256
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:268
msgid "The server does not support SSL."
msgstr "Il server non supporta SSL."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:223
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:281
msgid "An error occured while setting up the SSL connection."
msgstr "Si verificato un errore impostando la connessione SSL."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:272
#, java-format
msgid "Connection rejected: {0}."
msgstr "Connessione rifiutata: {0}."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:290
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:312
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:332
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:380
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:405
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:432
msgid ""
"The server requested password-based authentication, but no password was "
"provided."
msgstr ""
"Il server ha richiesto l''autenticazione con password, ma tale password non "
" stata fornita."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:356
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:465
#, java-format
msgid ""
"The authentication type {0} is not supported. Check that you have configured "
"the pg_hba.conf file to include the client''s IP address or subnet, and that "
"it is using an authentication scheme supported by the driver."
msgstr ""
"L''autenticazione di tipo {0} non supportata. Verificare che nel file di "
"configurazione pg_hba.conf sia presente l''indirizzo IP o la sottorete del "
"client, e che lo schema di autenticazione utilizzato sia supportato dal "
"driver."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:362
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:400
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:471
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:514
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:560
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:570
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:579
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:587
#: org/postgresql/gss/MakeGSS.java:158
msgid "Protocol error. Session setup failed."
msgstr "Errore di protocollo. Impostazione della sessione fallita."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:390
#, java-format
msgid "Backend start-up failed: {0}."
msgstr "Attivazione del backend fallita: {0}."
#: org/postgresql/core/v2/FastpathParameterList.java:55
#: org/postgresql/core/v2/FastpathParameterList.java:77
#: org/postgresql/core/v2/FastpathParameterList.java:84
#: org/postgresql/core/v2/SimpleParameterList.java:57
#: org/postgresql/core/v2/SimpleParameterList.java:76
#: org/postgresql/core/v2/SimpleParameterList.java:83
#: org/postgresql/core/v2/SimpleParameterList.java:90
#: org/postgresql/core/v3/CompositeParameterList.java:35
#: org/postgresql/core/v3/SimpleParameterList.java:47
#: org/postgresql/core/v3/SimpleParameterList.java:54
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2845
#: org/postgresql/jdbc2/AbstractJdbc2ResultSetMetaData.java:419
#, java-format
msgid "The column index is out of range: {0}, number of columns: {1}."
msgstr "Indice di colonna, {0}, maggiore del numero di colonne {1}."
#: org/postgresql/core/v2/FastpathParameterList.java:142
#: org/postgresql/core/v2/SimpleParameterList.java:155
#: org/postgresql/core/v3/SimpleParameterList.java:183
#, java-format
msgid "No value specified for parameter {0}."
msgstr "Nessun valore specificato come parametro {0}."
#: org/postgresql/core/v2/QueryExecutorImpl.java:72
#: org/postgresql/core/v2/QueryExecutorImpl.java:337
#: org/postgresql/core/v3/QueryExecutorImpl.java:443
#: org/postgresql/core/v3/QueryExecutorImpl.java:507
#, java-format
msgid "Expected command status BEGIN, got {0}."
msgstr "Lo stato del comando avrebbe dovuto essere BEGIN, mentre invece {0}."
#: org/postgresql/core/v2/QueryExecutorImpl.java:78
#: org/postgresql/core/v3/QueryExecutorImpl.java:513
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1828
#, java-format
msgid "Unexpected command status: {0}."
msgstr "Stato del comando non previsto: {0}."
#: org/postgresql/core/v2/QueryExecutorImpl.java:118
#: org/postgresql/core/v2/QueryExecutorImpl.java:129
#: org/postgresql/core/v2/QueryExecutorImpl.java:174
#: org/postgresql/core/v2/QueryExecutorImpl.java:369
#: org/postgresql/core/v3/QueryExecutorImpl.java:281
#: org/postgresql/core/v3/QueryExecutorImpl.java:411
#: org/postgresql/core/v3/QueryExecutorImpl.java:485
#: org/postgresql/core/v3/QueryExecutorImpl.java:551
#: org/postgresql/core/v3/QueryExecutorImpl.java:631
#: org/postgresql/core/v3/QueryExecutorImpl.java:2094
msgid "An I/O error occured while sending to the backend."
msgstr "Si verificato un errore di I/O nella spedizione di dati al server."
#: org/postgresql/core/v2/QueryExecutorImpl.java:170
#: org/postgresql/core/v2/QueryExecutorImpl.java:225
#: org/postgresql/core/v2/QueryExecutorImpl.java:236
#: org/postgresql/core/v3/QueryExecutorImpl.java:627
#: org/postgresql/core/v3/QueryExecutorImpl.java:685
#, java-format
msgid "Unknown Response Type {0}."
msgstr "Risposta di tipo sconosciuto {0}."
#: org/postgresql/core/v2/QueryExecutorImpl.java:430
#: org/postgresql/core/v2/QueryExecutorImpl.java:475
#: org/postgresql/core/v3/QueryExecutorImpl.java:1857
msgid "Ran out of memory retrieving query results."
msgstr "Fine memoria scaricando i risultati della query."
#: org/postgresql/core/v2/QueryExecutorImpl.java:597
#: org/postgresql/core/v3/QueryExecutorImpl.java:2199
#, java-format
msgid "Unable to interpret the update count in command completion tag: {0}."
msgstr ""
"Impossibile interpretare il numero degli aggiornamenti nel tag di "
"completamento del comando: {0}."
#: org/postgresql/core/v2/QueryExecutorImpl.java:610
msgid "Copy not implemented for protocol version 2"
msgstr ""
#: org/postgresql/core/v3/CopyOperationImpl.java:56
msgid "CommandComplete expected COPY but got: "
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:66
msgid "Tried to obtain lock while already holding it"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:78
msgid "Tried to break lock on database connection"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:93
#, fuzzy
msgid "Interrupted while waiting to obtain lock on database connection"
msgstr "Si verificata una interruzione durante il tentativo di connessione."
#: org/postgresql/core/v3/QueryExecutorImpl.java:275
msgid "Unable to bind parameter values for statement."
msgstr ""
"Impossibile fare il bind dei valori passati come parametri per lo "
"statement."
#: org/postgresql/core/v3/QueryExecutorImpl.java:726
msgid "Database connection failed when starting copy"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:757
msgid "Tried to cancel an inactive copy operation"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:794
msgid "Database connection failed when canceling copy operation"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:799
msgid "Missing expected error response to copy cancel request"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:801
#, java-format
msgid "Got {0} error responses to single copy cancel request"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:814
msgid "Tried to end inactive copy"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:827
msgid "Database connection failed when ending copy"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:842
#: org/postgresql/core/v3/QueryExecutorImpl.java:860
msgid "Tried to write to an inactive copy operation"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:854
#: org/postgresql/core/v3/QueryExecutorImpl.java:866
msgid "Database connection failed when writing to copy"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:878
msgid "Tried to read from inactive copy"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:883
msgid "Database connection failed when reading from copy"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:951
#, java-format
msgid "Received CommandComplete ''{0}'' without an active copy operation"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:975
#, java-format
msgid "Got CopyInResponse from server during an active {0}"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:988
#, java-format
msgid "Got CopyOutResponse from server during an active {0}"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:1003
msgid "Got CopyData without an active copy operation"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:1005
#, fuzzy, java-format
msgid "Unexpected copydata from server for {0}"
msgstr "Ricevuto dal server {0} mentre era atteso un EOF"
#: org/postgresql/core/v3/QueryExecutorImpl.java:1056
#, java-format
msgid "Unexpected packet type during copy: {0}"
msgstr ""
#: org/postgresql/core/v3/QueryExecutorImpl.java:1310
#, java-format
msgid ""
"Bind message length {0} too long. This can be caused by very large or "
"incorrect length specifications on InputStream parameters."
msgstr ""
"Il messaggio di bind troppo lungo ({0}). Questo pu essere causato da "
"una dimensione eccessiva o non corretta dei parametri dell''InputStream."
#: org/postgresql/core/v3/QueryExecutorImpl.java:1925
#, fuzzy, java-format
msgid ""
"The server''s client_encoding parameter was changed to {0}. The JDBC driver "
"requires client_encoding to be UTF8 for correct operation."
msgstr ""
"Il parametro client_encoding del server stato cambiato in {0}. Il driver "
"JDBC richiede che client_encoding sia UNICODE per un corretto "
"funzionamento."
#: org/postgresql/core/v3/QueryExecutorImpl.java:1932
#, java-format
msgid ""
"The server''s DateStyle parameter was changed to {0}. The JDBC driver "
"requires DateStyle to begin with ISO for correct operation."
msgstr ""
"Il parametro del server DateStyle stato cambiato in {0}. Il driver JDBC "
"richiede che DateStyle cominci con ISO per un corretto funzionamento."
#: org/postgresql/core/v3/QueryExecutorImpl.java:1945
#, fuzzy, java-format
msgid ""
"The server''s standard_conforming_strings parameter was reported as {0}. The "
"JDBC driver expected on or off."
msgstr ""
"Il parametro client_encoding del server stato cambiato in {0}. Il driver "
"JDBC richiede che client_encoding sia UNICODE per un corretto "
"funzionamento."
#: org/postgresql/core/v3/QueryExecutorImpl.java:2015
msgid "The driver currently does not support COPY operations."
msgstr "Il driver non supporta al momento l''operazione COPY."
#: org/postgresql/ds/jdbc23/AbstractJdbc23PooledConnection.java:112
msgid "This PooledConnection has already been closed."
msgstr "Questo PooledConnection stato chiuso."
#: org/postgresql/ds/jdbc23/AbstractJdbc23PooledConnection.java:295
msgid ""
"Connection has been closed automatically because a new connection was opened "
"for the same PooledConnection or the PooledConnection has been closed."
msgstr ""
"La Connection stata chiusa automaticamente perch una nuova l''ha "
"sostituita nello stesso PooledConnection, oppure il PooledConnection "
"stato chiuso."
#: org/postgresql/ds/jdbc23/AbstractJdbc23PooledConnection.java:295
msgid "Connection has been closed."
msgstr "Questo Connection stato chiuso."
#: org/postgresql/ds/jdbc23/AbstractJdbc23PooledConnection.java:442
msgid "Statement has been closed."
msgstr "Questo Statement stato chiuso."
#: org/postgresql/ds/jdbc23/AbstractJdbc23PoolingDataSource.java:291
msgid "Failed to setup DataSource."
msgstr ""
#: org/postgresql/ds/jdbc23/AbstractJdbc23PoolingDataSource.java:414
msgid "DataSource has been closed."
msgstr "Questo DataSource stato chiuso."
#: org/postgresql/fastpath/Fastpath.java:81
#: org/postgresql/fastpath/Fastpath.java:128
#, java-format
msgid "Fastpath call {0} - No result was returned and we expected an integer."
msgstr ""
"Chiamata Fastpath {0}: Nessun risultato restituito mentre ci si aspettava "
"un intero."
#: org/postgresql/fastpath/Fastpath.java:237
#, java-format
msgid "The fastpath function {0} is unknown."
msgstr "La funzione fastpath {0} sconosciuta."
#: org/postgresql/geometric/PGbox.java:83
#: org/postgresql/geometric/PGcircle.java:82
#: org/postgresql/geometric/PGcircle.java:91
#: org/postgresql/geometric/PGline.java:80
#: org/postgresql/geometric/PGlseg.java:77
#: org/postgresql/geometric/PGpoint.java:85
#, java-format
msgid "Conversion to type {0} failed: {1}."
msgstr "Conversione al tipo {0} fallita: {1}."
#: org/postgresql/geometric/PGpath.java:81
#, java-format
msgid "Cannot tell if path is open or closed: {0}."
msgstr "Impossibile stabilire se il percorso aperto o chiuso: {0}."
#: org/postgresql/gss/MakeGSS.java:47 org/postgresql/gss/MakeGSS.java:55
#: org/postgresql/gss/MakeGSS.java:168
msgid "GSS Authentication failed"
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Array.java:153
#: org/postgresql/jdbc2/AbstractJdbc2Array.java:790
#, java-format
msgid "The array index is out of range: {0}"
msgstr "Indice di colonna fuori dall''intervallo ammissibile: {0}"
#: org/postgresql/jdbc2/AbstractJdbc2Array.java:168
#: org/postgresql/jdbc2/AbstractJdbc2Array.java:807
#, java-format
msgid "The array index is out of range: {0}, number of elements: {1}."
msgstr ""
"L''indice dell''array fuori intervallo: {0}, numero di elementi: {1}."
#: org/postgresql/jdbc2/AbstractJdbc2Array.java:196
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1982
#: org/postgresql/util/HStoreConverter.java:34
#: org/postgresql/util/HStoreConverter.java:61
msgid ""
"Invalid character data was found. This is most likely caused by stored data "
"containing characters that are invalid for the character set the database "
"was created in. The most common example of this is storing 8bit data in a "
"SQL_ASCII database."
msgstr ""
"Sono stati trovati caratteri non validi tra i dati. Molto probabilmente sono "
"stati memorizzati dei caratteri che non sono validi per la codifica dei "
"caratteri impostata alla creazione del database. Il caso pi diffuso "
"quello nel quale si memorizzano caratteri a 8bit in un database con codifica "
"SQL_ASCII."
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:73
msgid ""
"Truncation of large objects is only implemented in 8.3 and later servers."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:77
msgid "Cannot truncate LOB to a negative length."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:81
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:235
#, java-format
msgid "PostgreSQL LOBs can only index to: {0}"
msgstr "Il massimo valore per l''indice dei LOB di PostgreSQL {0}. "
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:231
msgid "LOB positioning offsets start at 1."
msgstr "L''offset per la posizione dei LOB comincia da 1."
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:246
msgid "free() was called on this LOB previously"
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:229
#, java-format
msgid "Unsupported value for stringtype parameter: {0}"
msgstr "Il valore per il parametro di tipo string {0} non supportato."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:249
msgid "unknownLength parameter value must be an integer"
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:357
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:284
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:303
#: org/postgresql/jdbc2/TypeInfoCache.java:201
#: org/postgresql/jdbc2/TypeInfoCache.java:249
#: org/postgresql/jdbc2/TypeInfoCache.java:287
#: org/postgresql/jdbc2/TypeInfoCache.java:344
#: org/postgresql/jdbc2/TypeInfoCache.java:348
#: org/postgresql/jdbc2/TypeInfoCache.java:384
#: org/postgresql/jdbc2/TypeInfoCache.java:388
msgid "No results were returned by the query."
msgstr "Nessun risultato stato restituito dalla query."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:371
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:336
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:368
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2695
msgid "A result was returned when none was expected."
msgstr " stato restituito un valore nonostante non ne fosse atteso nessuno."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:523
msgid "Custom type maps are not supported."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:571
#, java-format
msgid "Failed to create object for: {0}."
msgstr "Fallita la creazione dell''oggetto per: {0}."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:633
#, java-format
msgid "Unable to load the class {0} responsible for the datatype {1}"
msgstr "Non possibile caricare la class {0} per gestire il tipo {1}."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:729
msgid ""
"Cannot change transaction read-only property in the middle of a transaction."
msgstr ""
"Non possibile modificare la propriet read-only delle transazioni nel "
"mezzo di una transazione."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:817
msgid "Cannot commit when autoCommit is enabled."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:826
#, fuzzy
msgid "This connection has been closed."
msgstr "Questo Connection stato chiuso."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:846
msgid "Cannot rollback when autoCommit is enabled."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:933
msgid ""
"Cannot change transaction isolation level in the middle of a transaction."
msgstr ""
"Non possibile cambiare il livello di isolamento delle transazioni nel "
"mezzo di una transazione."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:938
#, java-format
msgid "Transaction isolation level {0} not supported."
msgstr "Il livello di isolamento delle transazioni {0} non supportato."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:1005
msgid "Finalizing a Connection that was never closed:"
msgstr "Finalizzazione di una Connection che non stata chiusa."
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:1107
msgid "Unable to translate data into the desired encoding."
msgstr "Impossibile tradurre i dati nella codifica richiesta."
#: org/postgresql/jdbc2/AbstractJdbc2DatabaseMetaData.java:63
msgid ""
"Unable to determine a value for MaxIndexKeys due to missing system catalog "
"data."
msgstr ""
"Non possibile trovare il valore di MaxIndexKeys nel catalogo si sistema."
#: org/postgresql/jdbc2/AbstractJdbc2DatabaseMetaData.java:86
msgid "Unable to find name datatype in the system catalogs."
msgstr "Non possibile trovare il datatype name nel catalogo di sistema."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:235
msgid ""
"Operation requires a scrollable ResultSet, but this ResultSet is "
"FORWARD_ONLY."
msgstr ""
"L''operazione richiete un ResultSet scorribile mentre questo "
"FORWARD_ONLY."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:416
msgid "Unexpected error while decoding character data from a large object."
msgstr ""
"Errore non previsto durante la decodifica di caratteri a partire da un "
"large object."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:462
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:491
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:525
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3129
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3174
#, fuzzy, java-format
msgid "Cannot convert the column of type {0} to requested type {1}."
msgstr "Non possibile convertire una istanza di {0} nel tipo {1}"
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:744
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:768
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1892
msgid "Can''t use relative move methods while on the insert row."
msgstr ""
"Non possibile utilizzare gli spostamenti relativi durante l''inserimento "
"di una riga."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:788
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2949
#, java-format
msgid "Invalid fetch direction constant: {0}."
msgstr "Costante per la direzione dell''estrazione non valida: {0}."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:802
msgid "Cannot call cancelRowUpdates() when on the insert row."
msgstr ""
"Non possibile invocare cancelRowUpdates() durante l''inserimento di una "
"riga."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:822
msgid "Cannot call deleteRow() when on the insert row."
msgstr ""
"Non possibile invocare deleteRow() durante l''inserimento di una riga."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:828
msgid ""
"Currently positioned before the start of the ResultSet. You cannot call "
"deleteRow() here."
msgstr ""
"La posizione attuale precedente all''inizio del ResultSet. Non possibile "
"invocare deleteRow() qui."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:833
msgid ""
"Currently positioned after the end of the ResultSet. You cannot call "
"deleteRow() here."
msgstr ""
"La posizione attuale successiva alla fine del ResultSet. Non possibile "
"invocare deleteRow() qui."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:838
msgid "There are no rows in this ResultSet."
msgstr "Non ci sono righe in questo ResultSet."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:885
msgid "Not on the insert row."
msgstr "Non si in una nuova riga."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:889
msgid "You must specify at least one column value to insert a row."
msgstr ""
"Per inserire un record si deve specificare almeno il valore di una colonna."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1074
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1805
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2494
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2524
#, java-format
msgid "The JVM claims not to support the encoding: {0}"
msgstr "La JVM sostiene di non supportare la codifica: {0}."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1078
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1121
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1527
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1656
msgid "Provided InputStream failed."
msgstr "L''InputStream fornito fallito."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1191
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3130
msgid "Provided Reader failed."
msgstr "Il Reader fornito fallito."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1259
msgid "Can''t refresh the insert row."
msgstr "Non possibile aggiornare la riga in inserimento."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1327
msgid "Cannot call updateRow() when on the insert row."
msgstr ""
"Non possibile invocare updateRow() durante l''inserimento di una riga."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1333
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3190
msgid ""
"Cannot update the ResultSet because it is either before the start or after "
"the end of the results."
msgstr ""
"Non possibile aggiornare il ResultSet perch la posizione attuale "
"precedente all''inizio o successiva alla file dei risultati."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1582
msgid "ResultSets with concurrency CONCUR_READ_ONLY cannot be updated."
msgstr ""
"I ResultSet in modalit CONCUR_READ_ONLY non possono essere aggiornati."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1650
#, java-format
msgid "No primary key found for table {0}."
msgstr "Non stata trovata la chiave primaria della tabella {0}."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1876
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2958
msgid "Fetch size must be a value greater to or equal to 0."
msgstr "La dimensione dell''area di fetch deve essere maggiore o eguale a 0."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2044
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2051
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2098
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2106
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2926
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2934
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2964
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2971
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2991
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3002
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3020
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3038
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3179
#: org/postgresql/jdbc2/TimestampUtils.java:258
#, java-format
msgid "Bad value for type {0} : {1}"
msgstr "Il valore {1} non adeguato al tipo {0}."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2727
#, java-format
msgid "The column name {0} was not found in this ResultSet."
msgstr "Colonna denominata {0} non presente in questo ResultSet."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2827
msgid ""
"ResultSet is not updateable. The query that generated this result set must "
"select only one table, and must select all primary keys from that table. See "
"the JDBC 2.1 API Specification, section 5.6 for more details."
msgstr ""
"Il ResultSet non aggiornabile. La query che lo genera deve selezionare "
"una sola tabella e deve selezionarne tutti i campi che ne compongono la "
"chiave primaria. Si vedano le specifiche dell''API JDBC 2.1, sezione 5.6, "
"per ulteriori dettagli."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2839
msgid "This ResultSet is closed."
msgstr "Questo ResultSet chiuso."
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2860
msgid "ResultSet not positioned properly, perhaps you need to call next."
msgstr ""
"Il ResultSet non correttamente posizionato; forse necessario invocare "
"next()."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:259
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:323
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:392
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2648
msgid ""
"Can''t use query methods that take a query string on a PreparedStatement."
msgstr ""
"Non si possono utilizzare i metodi \"query\" che hanno come argomento una "
"stringa nel caso di PreparedStatement."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:287
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:306
msgid "Multiple ResultSets were returned by the query."
msgstr "La query ha restituito ResultSet multipli."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:425
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:429
msgid "A CallableStatement was executed with nothing returned."
msgstr ""
"Un CallableStatement stato eseguito senza produrre alcun risultato. "
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:437
#, fuzzy
msgid "A CallableStatement was executed with an invalid number of parameters"
msgstr ""
"Un CallableStatement stato eseguito con un numero errato di parametri."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:468
#, java-format
msgid ""
"A CallableStatement function was executed and the out parameter {0} was of "
"type {1} however type {2} was registered."
msgstr ""
" stato eseguito un CallableStatement ma il parametro in uscita {0} era "
"di tipo {1} al posto di {2}, che era stato dichiarato."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:670
msgid "Maximum number of rows must be a value grater than or equal to 0."
msgstr "Il numero massimo di righe deve essere maggiore o eguale a 0."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:713
msgid "Query timeout must be a value greater than or equals to 0."
msgstr "Il timeout relativo alle query deve essere maggiore o eguale a 0."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:804
msgid "The maximum field size must be a value greater than or equal to 0."
msgstr "La dimensione massima del campo deve essere maggiore o eguale a 0."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1219
msgid "Unknown Types value."
msgstr "Valore di tipo sconosciuto."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1492
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1617
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3101
#, java-format
msgid "Invalid stream length {0}."
msgstr "La dimensione specificata, {0}, per lo stream non valida."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1523
#, java-format
msgid "The JVM claims not to support the {0} encoding."
msgstr "La JVM sostiene di non supportare la codifica {0}."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1698
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3023
#, java-format
msgid "Unknown type {0}."
msgstr "Tipo sconosciuto {0}."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1713
msgid "No hstore extension installed."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1838
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1844
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1850
#, java-format
msgid "Cannot cast an instance of {0} to type {1}"
msgstr "Non possibile fare il cast di una istanza di {0} al tipo {1}."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1862
#, java-format
msgid "Unsupported Types value: {0}"
msgstr "Valore di tipo {0} non supportato."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1920
#, java-format
msgid ""
"Can''t infer the SQL type to use for an instance of {0}. Use setObject() "
"with an explicit Types value to specify the type to use."
msgstr ""
"Non possibile identificare il tipo SQL da usare per l''istanza di tipo "
"{0}. Usare setObject() specificando esplicitamente il tipo da usare per "
"questo valore."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1968
msgid ""
"This statement does not declare an OUT parameter. Use '{' ?= call ... '}' "
"to declare one."
msgstr ""
"Questo statement non dichiara il parametro in uscita. Usare { ?= "
"call ... } per farlo."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2018
msgid "wasNull cannot be call before fetching a result."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2514
#, java-format
msgid "Malformed function or procedure escape syntax at offset {0}."
msgstr ""
"Sequenza di escape definita erroneamente nella funzione o procedura "
"all''offset {0}."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2564
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2578
#, java-format
msgid ""
"Parameter of type {0} was registered, but call to get{1} (sqltype={2}) was "
"made."
msgstr ""
" stato definito il parametro di tipo {0}, ma poi stato invocato il "
"metodo get{1}() (sqltype={2})."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2597
msgid ""
"A CallableStatement was declared, but no call to registerOutParameter(1, "
") was made."
msgstr ""
" stato definito un CallableStatement ma non stato invocato il metodo "
"registerOutParameter(1, )."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2601
msgid "No function outputs were registered."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2604
msgid ""
"Results cannot be retrieved from a CallableStatement before it is executed."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2637
msgid "This statement has been closed."
msgstr "Questo statement stato chiuso."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2717
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2787
msgid "Too many update results were returned."
msgstr "Sono stati restituiti troppi aggiornamenti."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2746
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2816
#, java-format
msgid ""
"Batch entry {0} {1} was aborted. Call getNextException to see the cause."
msgstr ""
"L''operazione batch {0} {1} stata interrotta. Chiamare "
"getNextException per scoprirne il motivo."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3071
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3160
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3200
msgid "Unexpected error writing large object to database."
msgstr "Errore inatteso inviando un large object al database."
#: org/postgresql/jdbc2/EscapedFunctions.java:145
#: org/postgresql/jdbc2/EscapedFunctions.java:157
#: org/postgresql/jdbc2/EscapedFunctions.java:169
#: org/postgresql/jdbc2/EscapedFunctions.java:206
#: org/postgresql/jdbc2/EscapedFunctions.java:243
#: org/postgresql/jdbc2/EscapedFunctions.java:267
#: org/postgresql/jdbc2/EscapedFunctions.java:292
#: org/postgresql/jdbc2/EscapedFunctions.java:316
#: org/postgresql/jdbc2/EscapedFunctions.java:328
#: org/postgresql/jdbc2/EscapedFunctions.java:352
#: org/postgresql/jdbc2/EscapedFunctions.java:380
#: org/postgresql/jdbc2/EscapedFunctions.java:389
#: org/postgresql/jdbc2/EscapedFunctions.java:399
#: org/postgresql/jdbc2/EscapedFunctions.java:408
#: org/postgresql/jdbc2/EscapedFunctions.java:417
#: org/postgresql/jdbc2/EscapedFunctions.java:426
#: org/postgresql/jdbc2/EscapedFunctions.java:435
#: org/postgresql/jdbc2/EscapedFunctions.java:444
#: org/postgresql/jdbc2/EscapedFunctions.java:453
#: org/postgresql/jdbc2/EscapedFunctions.java:462
#: org/postgresql/jdbc2/EscapedFunctions.java:471
#: org/postgresql/jdbc2/EscapedFunctions.java:480
#, java-format
msgid "{0} function takes one and only one argument."
msgstr "Il metodo {0} accetta un ed un solo argomento."
#: org/postgresql/jdbc2/EscapedFunctions.java:181
#: org/postgresql/jdbc2/EscapedFunctions.java:193
#: org/postgresql/jdbc2/EscapedFunctions.java:255
#: org/postgresql/jdbc2/EscapedFunctions.java:304
#: org/postgresql/jdbc2/EscapedFunctions.java:582
#, java-format
msgid "{0} function takes two and only two arguments."
msgstr "Il metodo {0} accetta due e solo due argomenti."
#: org/postgresql/jdbc2/EscapedFunctions.java:230
#, java-format
msgid "{0} function takes four and only four argument."
msgstr "Il metodo {0} accetta quattro e solo quattro argomenti."
#: org/postgresql/jdbc2/EscapedFunctions.java:282
#: org/postgresql/jdbc2/EscapedFunctions.java:342
#, java-format
msgid "{0} function takes two or three arguments."
msgstr "Il metodo {0} accetta due o tre argomenti."
#: org/postgresql/jdbc2/EscapedFunctions.java:362
#: org/postgresql/jdbc2/EscapedFunctions.java:371
#: org/postgresql/jdbc2/EscapedFunctions.java:573
#: org/postgresql/jdbc2/EscapedFunctions.java:591
#, java-format
msgid "{0} function doesn''t take any argument."
msgstr "Il metodo {0} non accetta argomenti."
#: org/postgresql/jdbc2/EscapedFunctions.java:489
#: org/postgresql/jdbc2/EscapedFunctions.java:531
#, java-format
msgid "{0} function takes three and only three arguments."
msgstr "Il metodo {0} accetta tre e solo tre argomenti."
#: org/postgresql/jdbc2/EscapedFunctions.java:501
#: org/postgresql/jdbc2/EscapedFunctions.java:521
#: org/postgresql/jdbc2/EscapedFunctions.java:523
#: org/postgresql/jdbc2/EscapedFunctions.java:543
#: org/postgresql/jdbc2/EscapedFunctions.java:564
#: org/postgresql/jdbc2/EscapedFunctions.java:566
#, java-format
msgid "Interval {0} not yet implemented"
msgstr "L''intervallo {0} non stato ancora implementato."
#: org/postgresql/jdbc2/TimestampUtils.java:360
msgid ""
"Infinite value found for timestamp/date. This cannot be represented as time."
msgstr ""
"Il valore specificato per il tipo timestamp o date, infinito, non pu "
"essere rappresentato come time."
#: org/postgresql/jdbc2/TimestampUtils.java:648
#: org/postgresql/jdbc2/TimestampUtils.java:680
#: org/postgresql/jdbc2/TimestampUtils.java:727
#, fuzzy, java-format
msgid "Unsupported binary encoding of {0}."
msgstr "Valore di tipo {0} non supportato."
#: org/postgresql/jdbc2/TypeInfoCache.java:161
#, java-format
msgid "The class {0} does not implement org.postgresql.util.PGobject."
msgstr "La class {0} non implementa org.postgresql.util.PGobject."
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:60
#, java-format
msgid "Unknown ResultSet holdability setting: {0}."
msgstr "Il parametro holdability per il ResultSet sconosciuto: {0}."
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:98
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:130
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:165
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:187
msgid "Server versions prior to 8.0 do not support savepoints."
msgstr ""
"Le versioni del server precedenti alla 8.0 non permettono i punti di "
"ripristino."
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:100
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:132
msgid "Cannot establish a savepoint in auto-commit mode."
msgstr ""
"Non possibile impostare i punti di ripristino in modalit auto-commit."
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:419
msgid "Returning autogenerated keys is not supported."
msgstr "La restituzione di chiavi autogenerate non supportata."
#: org/postgresql/jdbc3/AbstractJdbc3ParameterMetaData.java:81
#, java-format
msgid "The parameter index is out of range: {0}, number of parameters: {1}."
msgstr "Il parametro indice fuori intervallo: {0}, numero di elementi: {1}."
#: org/postgresql/jdbc3/AbstractJdbc3Statement.java:151
#, fuzzy
msgid ""
"Returning autogenerated keys is only supported for 8.2 and later servers."
msgstr "La restituzione di chiavi autogenerate non supportata."
#: org/postgresql/jdbc3/AbstractJdbc3Statement.java:199
#: org/postgresql/jdbc3/AbstractJdbc3Statement.java:317
#, fuzzy
msgid "Returning autogenerated keys by column index is not supported."
msgstr "La restituzione di chiavi autogenerate non supportata."
#: org/postgresql/jdbc3/PSQLSavepoint.java:38
#: org/postgresql/jdbc3/PSQLSavepoint.java:50
#: org/postgresql/jdbc3/PSQLSavepoint.java:66
msgid "Cannot reference a savepoint after it has been released."
msgstr ""
"Non possibile utilizzare un punto di ripristino successivamente al suo "
"rilascio."
#: org/postgresql/jdbc3/PSQLSavepoint.java:42
msgid "Cannot retrieve the id of a named savepoint."
msgstr "Non possibile trovare l''id del punto di ripristino indicato."
#: org/postgresql/jdbc3/PSQLSavepoint.java:54
msgid "Cannot retrieve the name of an unnamed savepoint."
msgstr "Non possibile trovare il nome di un punto di ripristino anonimo."
#: org/postgresql/jdbc3g/AbstractJdbc3gResultSet.java:37
#, fuzzy
msgid "Invalid UUID data."
msgstr "Flag non valido"
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:83
#, java-format
msgid "Unable to find server array type for provided name {0}."
msgstr ""
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:120
#, fuzzy, java-format
msgid "Invalid timeout ({0}<0)."
msgstr "La dimensione specificata, {0}, per lo stream non valida."
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:133
msgid "Validating connection."
msgstr ""
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:156
#, fuzzy, java-format
msgid "Failed to set ClientInfo property: {0}"
msgstr "Fallita la creazione dell''oggetto per: {0}."
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:165
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:187
#, fuzzy
msgid "ClientInfo property not supported."
msgstr "La restituzione di chiavi autogenerate non supportata."
#: org/postgresql/jdbc4/AbstractJdbc4Statement.java:127
msgid "Object is too large to send over the protocol."
msgstr ""
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:147
msgid "Unable to decode xml data."
msgstr ""
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:150
#, java-format
msgid "Unknown XML Source class: {0}"
msgstr ""
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:195
#, fuzzy
msgid "Unable to create SAXResult for SQLXML."
msgstr "Fallita la creazione dell''oggetto per: {0}."
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:209
msgid "Unable to create StAXResult for SQLXML"
msgstr ""
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:213
#, fuzzy, java-format
msgid "Unknown XML Result class: {0}"
msgstr "Il parametro holdability per il ResultSet sconosciuto: {0}."
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:226
#, fuzzy
msgid "This SQLXML object has already been freed."
msgstr "Questo PooledConnection stato chiuso."
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:233
msgid ""
"This SQLXML object has not been initialized, so you cannot retrieve data "
"from it."
msgstr ""
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:244
#, java-format
msgid "Failed to convert binary xml data to encoding: {0}."
msgstr ""
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:269
msgid "Unable to convert DOMResult SQLXML data to a string."
msgstr ""
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:282
msgid ""
"This SQLXML object has already been initialized, so you cannot manipulate it "
"further."
msgstr ""
#: org/postgresql/largeobject/LargeObjectManager.java:138
msgid "Failed to initialize LargeObject API"
msgstr "Inizializzazione di LargeObject API fallita."
#: org/postgresql/largeobject/LargeObjectManager.java:198
#: org/postgresql/largeobject/LargeObjectManager.java:239
msgid "Large Objects may not be used in auto-commit mode."
msgstr "Non possibile impostare i Large Object in modalit auto-commit."
#: org/postgresql/ssl/jdbc3/AbstractJdbc3MakeSSL.java:58
#: org/postgresql/ssl/jdbc4/AbstractJdbc4MakeSSL.java:110
#, java-format
msgid "The SSLSocketFactory class provided {0} could not be instantiated."
msgstr ""
"La classe SSLSocketFactory specificata, {0}, non pu essere istanziata."
#: org/postgresql/ssl/jdbc4/AbstractJdbc4MakeSSL.java:125
#, java-format
msgid "SSL error: {0}"
msgstr ""
#: org/postgresql/ssl/jdbc4/AbstractJdbc4MakeSSL.java:138
#, fuzzy, java-format
msgid "The HostnameVerifier class provided {0} could not be instantiated."
msgstr ""
"La classe SSLSocketFactory specificata, {0}, non pu essere istanziata."
#: org/postgresql/ssl/jdbc4/AbstractJdbc4MakeSSL.java:142
#, java-format
msgid "The hostname {0} could not be verified by hostnameverifier {1}."
msgstr ""
#: org/postgresql/ssl/jdbc4/AbstractJdbc4MakeSSL.java:149
#, java-format
msgid "The hostname {0} could not be verified."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:121
msgid ""
"Could not find a java cryptographic algorithm: X.509 CertificateFactory not "
"available."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:132
#, java-format
msgid "Could not open SSL certificate file {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:137
#, java-format
msgid "Loading the SSL certificate {0} into a KeyManager failed."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:194
msgid "Enter SSL password: "
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:202
msgid "Could not read password for SSL key file, console is not available."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:204
#, java-format
msgid "Could not read password for SSL key file by callbackhandler {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:223
#, java-format
msgid "Could not decrypt SSL key file {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:231
#, java-format
msgid "Could not read SSL key file {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:235
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:173
#, java-format
msgid "Could not find a java cryptographic algorithm: {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:99
#, fuzzy, java-format
msgid "The password callback class provided {0} could not be instantiated."
msgstr ""
"La classe SSLSocketFactory specificata, {0}, non pu essere istanziata."
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:133
#, java-format
msgid "Could not open SSL root certificate file {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:150
#, java-format
msgid "Could not read SSL root certificate file {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:153
#, java-format
msgid "Loading the SSL root certificate {0} into a TrustManager failed."
msgstr ""
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:166
msgid "Could not initialize SSL context."
msgstr ""
#: org/postgresql/util/PGInterval.java:164
msgid "Conversion of interval failed"
msgstr "Fallita la conversione di un interval."
#: org/postgresql/util/PGmoney.java:73
msgid "Conversion of money failed."
msgstr "Fallita la conversione di un money."
#: org/postgresql/util/ServerErrorMessage.java:155
#, java-format
msgid "Detail: {0}"
msgstr "Dettaglio: {0}"
#: org/postgresql/util/ServerErrorMessage.java:159
#, java-format
msgid "Hint: {0}"
msgstr "Suggerimento: {0}"
#: org/postgresql/util/ServerErrorMessage.java:162
#, java-format
msgid "Position: {0}"
msgstr "Posizione: {0}"
#: org/postgresql/util/ServerErrorMessage.java:165
#, java-format
msgid "Where: {0}"
msgstr "Dove: {0}"
#: org/postgresql/util/ServerErrorMessage.java:171
#, java-format
msgid "Internal Query: {0}"
msgstr "Query interna: {0}"
#: org/postgresql/util/ServerErrorMessage.java:174
#, java-format
msgid "Internal Position: {0}"
msgstr "Posizione interna: {0}"
#: org/postgresql/util/ServerErrorMessage.java:180
#, java-format
msgid "Location: File: {0}, Routine: {1}, Line: {2}"
msgstr "Individuazione: file: \"{0}\", routine: {1}, linea: {2}"
#: org/postgresql/util/ServerErrorMessage.java:183
#, java-format
msgid "Server SQLState: {0}"
msgstr "SQLState del server: {0}"
#: org/postgresql/xa/PGXAConnection.java:148
msgid ""
"Transaction control methods setAutoCommit(true), commit, rollback and "
"setSavePoint not allowed while an XA transaction is active."
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:186
#: org/postgresql/xa/PGXAConnection.java:245
msgid "Invalid flags"
msgstr "Flag non validi"
#: org/postgresql/xa/PGXAConnection.java:189
#: org/postgresql/xa/PGXAConnection.java:248
#: org/postgresql/xa/PGXAConnection.java:425
msgid "xid must not be null"
msgstr "xid non pu essere NULL"
#: org/postgresql/xa/PGXAConnection.java:192
msgid "Connection is busy with another transaction"
msgstr "La connessione utilizzata da un''altra transazione"
#: org/postgresql/xa/PGXAConnection.java:198
#: org/postgresql/xa/PGXAConnection.java:255
msgid "suspend/resume not implemented"
msgstr "suspend/resume non implementato"
#: org/postgresql/xa/PGXAConnection.java:204
#: org/postgresql/xa/PGXAConnection.java:207
#: org/postgresql/xa/PGXAConnection.java:209
msgid "Transaction interleaving not implemented"
msgstr "L''\"interleaving\" delle transazioni {0} non supportato."
#: org/postgresql/xa/PGXAConnection.java:218
#, fuzzy
msgid "Error disabling autocommit"
msgstr "Errore durante il commit \"one-phase\""
#: org/postgresql/xa/PGXAConnection.java:251
msgid "tried to call end without corresponding start call"
msgstr " stata chiamata end senza la corrispondente chiamata a start"
#: org/postgresql/xa/PGXAConnection.java:282
msgid ""
"Not implemented: Prepare must be issued using the same connection that "
"started the transaction"
msgstr ""
"Non implementato: Prepare deve essere eseguito nella stessa connessione "
"che ha iniziato la transazione."
#: org/postgresql/xa/PGXAConnection.java:286
msgid "Prepare called before end"
msgstr "Prepare invocato prima della fine"
#: org/postgresql/xa/PGXAConnection.java:292
msgid "Server versions prior to 8.1 do not support two-phase commit."
msgstr ""
"Le versioni del server precedenti alla 8.1 non permettono i commit \"two-"
"phase\"."
#: org/postgresql/xa/PGXAConnection.java:313
msgid "Error preparing transaction"
msgstr "Errore nel preparare una transazione"
#: org/postgresql/xa/PGXAConnection.java:328
msgid "Invalid flag"
msgstr "Flag non valido"
#: org/postgresql/xa/PGXAConnection.java:368
msgid "Error during recover"
msgstr "Errore durante il ripristino"
#: org/postgresql/xa/PGXAConnection.java:416
msgid "Error rolling back prepared transaction"
msgstr "Errore durante il rollback di una transazione preparata"
#: org/postgresql/xa/PGXAConnection.java:451
msgid ""
"Not implemented: one-phase commit must be issued using the same connection "
"that was used to start it"
msgstr ""
"Non implementato: il commit \"one-phase\" deve essere invocato sulla stessa "
"connessione che ha iniziato la transazione."
#: org/postgresql/xa/PGXAConnection.java:455
msgid "commit called before end"
msgstr "Commit stato chiamato prima della fine"
#: org/postgresql/xa/PGXAConnection.java:466
msgid "Error during one-phase commit"
msgstr "Errore durante il commit \"one-phase\""
#: org/postgresql/xa/PGXAConnection.java:487
msgid ""
"Not implemented: 2nd phase commit must be issued using an idle connection"
msgstr ""
"Non implementato: la seconda fase del commit deve essere effettuata con "
"una connessione non in uso"
#: org/postgresql/xa/PGXAConnection.java:507
#, fuzzy
msgid "Error committing prepared transaction"
msgstr "Errore durante il rollback di una transazione preparata"
#: org/postgresql/xa/PGXAConnection.java:522
msgid "Heuristic commit/rollback not supported"
msgstr "Commit e rollback euristici non sono supportati"
#~ msgid "The driver does not support SSL."
#~ msgstr "Il driver non supporta SSL."
#~ msgid "Multi-dimensional arrays are currently not supported."
#~ msgstr "Gli array multidimensionali non sono attualmente gestiti."
#~ msgid "rand function only takes zero or one argument(the seed)."
#~ msgstr "Il metodo rand vuole al massimo un argomento (il seme)."
#~ msgid "Exception: {0}"
#~ msgstr "Eccezione: {0}."
#~ msgid "Stack Trace:"
#~ msgstr "Stack trace:"
#~ msgid "End of Stack Trace"
#~ msgstr "Fine dello stack trace"
#~ msgid "Exception generating stacktrace for: {0} encountered: {1}"
#~ msgstr ""
#~ "Eccezione durante la generazione dello stack trace per: {0} trovata: {1}"
#~ msgid "suspend/resume and join not implemented"
#~ msgstr "Suspend, resume e join non sono implementati"
#~ msgid ""
#~ "Cannot call setXXX(1, ..) on a CallableStatement. This is an output that "
#~ "must be configured with registerOutParameter instead."
#~ msgstr ""
#~ "Non possibile invocare setXXX(1,...) per un CallableStatement. Si "
#~ "tratta di un valore restituito che va configurato usando il metodo "
#~ "registerOutParameter()."
#~ msgid ""
#~ "PostgreSQL only supports a single OUT function return value at index 1."
#~ msgstr ""
#~ "PostgreSQL permette di avere un solo valore restituito dalle funzioni, "
#~ "utilizzando l''indice 1."
#~ msgid "Conversion of circle failed: {0}."
#~ msgstr "Fallita la conversione di un ``circle'': {0}."
#~ msgid "Conversion of line failed: {0}."
#~ msgstr "Fallita la conversione di un ``line'': {0}."
#~ msgid "Conversion of point failed: {0}."
#~ msgstr "Fallita la conversione di un ``point'': {0}."
#~ msgid "No results where returned by the query."
#~ msgstr "Nessun risultato stato restituito dalla query."
#~ msgid "Bad byte: {0}"
#~ msgstr "Byte non corretto: {0}"
#~ msgid "Bad short: {0}"
#~ msgstr "Short non corretto: {0}"
#~ msgid "The JVM claims not to support the UTF-8 encoding."
#~ msgstr "La JVM sostiene di non supportare la codifica UTF-8."
#~ msgid "Bad int: {0}"
#~ msgstr "Int non corretto: {0}"
#~ msgid "Bad long: {0}"
#~ msgstr "Long non corretto: {0}"
#~ msgid "Bad BigDecimal: {0}"
#~ msgstr "BigDecimal non corretto: {0}"
#~ msgid "Bad float: {0}"
#~ msgstr "Float non corretto: {0}"
#~ msgid "Bad double: {0}"
#~ msgstr "Double non corretto: {0}"
#~ msgid "Bad date: {0}"
#~ msgstr "Date non corretto: {0}"
#~ msgid "The given date {0} does not match the format required: {1}."
#~ msgstr "La data fornita {0} non corrisponde al formato richiesto: {1}."
#~ msgid "The time given {0} does not match the format required: {1}."
#~ msgstr "L''orario fornito {0} non corrisponde al formato richiesto: {1}."
#~ msgid "The timestamp given {0} does not match the format required: {1}."
#~ msgstr ""
#~ "La marca temporale fornita {0} non corrisponde al formato richiesto: {1}."
#~ msgid "Could not extract nanoseconds from {0}."
#~ msgstr "Non possibile estrarre i nanosecondi da {0}."
#~ msgid "ResultSet holdability of HOLD_CURSORS_OVER_COMMIT is not supported."
#~ msgstr ""
#~ "Il mantenimento del ResultSet tramite HOLD_CURSOR_OVER_COMMIT non "
#~ "supportato."
postgresql-jdbc-9.2-1002.src/org/postgresql/translation/ja.po 0000664 0000000 0000000 00000174624 12050675701 0024140 0 ustar 00root root 0000000 0000000 # translation of head-de.po to Deutsch
# German message translation for the PostgreSQL JDBC driver
# This file is distributed under the same license as the package.
#
# Andre Bialojahn , 2005, 2006, 2008.
#
msgid ""
msgstr ""
"Project-Id-Version: head-ja\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2012-09-10 19:32-0400\n"
"PO-Revision-Date: 2010-04-11 22:58+0900\n"
"Last-Translator: Hiroshi Saito \n"
"Language-Team: PostgreSQL \n"
"Language: \n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: KBabel 1.0.2\n"
"X-Poedit-Language: Japanese\n"
"X-Poedit-Country: Japan\n"
#: bin/org/postgresql/Driver.java.in:235 org/postgresql/Driver.java.in:235
msgid "Error loading default settings from driverconfig.properties"
msgstr "driverconfig.propertiesによる初期設定のロードエラー"
#: bin/org/postgresql/Driver.java.in:282 org/postgresql/Driver.java.in:282
msgid ""
"Your security policy has prevented the connection from being attempted. You "
"probably need to grant the connect java.net.SocketPermission to the database "
"server host and port that you wish to connect to."
msgstr ""
"セキュリティ・ポリシーは、接続を妨げました。おそらく、データベース・サー"
"バー・ホスト接続のためjava.net.SocketPermissionを許可する必要があります。"
#: bin/org/postgresql/Driver.java.in:287 bin/org/postgresql/Driver.java.in:351
#: org/postgresql/Driver.java.in:287 org/postgresql/Driver.java.in:351
msgid ""
"Something unusual has occured to cause the driver to fail. Please report "
"this exception."
msgstr ""
"なにかドライバを失敗させる変化が起こりました。どうぞこの例外を報告して下さ"
"い。"
#: bin/org/postgresql/Driver.java.in:359 org/postgresql/Driver.java.in:359
msgid "Connection attempt timed out."
msgstr "接続中にタイムアウトしました。"
#: bin/org/postgresql/Driver.java.in:367 org/postgresql/Driver.java.in:367
msgid "Interrupted while attempting to connect."
msgstr "接続中に割り込みがありました。"
#: bin/org/postgresql/Driver.java.in:710 org/postgresql/Driver.java.in:710
#, java-format
msgid "Method {0} is not yet implemented."
msgstr "方法 {0} はまだ装備されていません。"
#: org/postgresql/copy/CopyManager.java:56
#, java-format
msgid "Requested CopyIn but got {0}"
msgstr "CopyInを要求しましたが {0} を得ます"
#: org/postgresql/copy/CopyManager.java:67
#, java-format
msgid "Requested CopyOut but got {0}"
msgstr "CopyOutを要求しましたが {0} を得ます"
#: org/postgresql/copy/PGCopyInputStream.java:51
#, java-format
msgid "Copying from database failed: {0}"
msgstr "データベースからコピーに失敗しました: {0}"
#: org/postgresql/copy/PGCopyInputStream.java:67
#: org/postgresql/copy/PGCopyOutputStream.java:90
msgid "This copy stream is closed."
msgstr "copyストリームは閉じられました。"
#: org/postgresql/copy/PGCopyInputStream.java:108
msgid "Read from copy failed."
msgstr "copyからの読み取りに失敗しました。"
#: org/postgresql/copy/PGCopyOutputStream.java:68
#, java-format
msgid "Cannot write to copy a byte of value {0}"
msgstr "値{0}のバイトコピーで書き込みができません。"
#: org/postgresql/core/ConnectionFactory.java:70
#, java-format
msgid "A connection could not be made using the requested protocol {0}."
msgstr "要求されたプロトコル {0} を使用して接続することができません。"
#: org/postgresql/core/Oid.java:113
#, java-format
msgid "oid type {0} not known and not a number"
msgstr ""
#: org/postgresql/core/PGStream.java:490
#, java-format
msgid "Premature end of input stream, expected {0} bytes, but only read {1}."
msgstr ""
"早すぎた入力ストリームの終了です、{0} バイトが想定されました、しかし唯一 {1} "
"は読み込まれました。"
#: org/postgresql/core/PGStream.java:530
#, java-format
msgid "Expected an EOF from server, got: {0}"
msgstr "サーバから EOF が想定されました、取得: {0}"
#: org/postgresql/core/SetupQueryRunner.java:86
msgid "An unexpected result was returned by a query."
msgstr "クエリーによって想定しない結果が返されました。"
#: org/postgresql/core/UTF8Encoding.java:28
#, java-format
msgid ""
"Illegal UTF-8 sequence: byte {0} of {1} byte sequence is not 10xxxxxx: {2}"
msgstr ""
"UTF-8シーケンス違反: {1} バイトシーケンスの {0} バイト は、10xxxxxx でありま"
"せん: {2}"
#: org/postgresql/core/UTF8Encoding.java:61
#, java-format
msgid "Illegal UTF-8 sequence: {0} bytes used to encode a {1} byte value: {2}"
msgstr ""
"UTF-8シーケンス違反: {0} バイトは、 {1} バイト値のエンコードに使いました: {2}"
#: org/postgresql/core/UTF8Encoding.java:98
#: org/postgresql/core/UTF8Encoding.java:125
#, java-format
msgid "Illegal UTF-8 sequence: initial byte is {0}: {1}"
msgstr "UTF-8シーケンス違反: 初期バイトは、{0}: {1}"
#: org/postgresql/core/UTF8Encoding.java:130
#, java-format
msgid "Illegal UTF-8 sequence: final value is out of range: {0}"
msgstr "UTF-8シーケンス違反: 最終値は範囲外です: {0}"
#: org/postgresql/core/UTF8Encoding.java:145
#, java-format
msgid "Illegal UTF-8 sequence: final value is a surrogate value: {0}"
msgstr "UTF-8シーケンス違反: 最終値はサロゲート値です: {0}"
#: org/postgresql/core/Utils.java:95 org/postgresql/core/Utils.java:112
msgid "Zero bytes may not occur in string parameters."
msgstr "ゼロ・バイトは、文字列パラメーターにできないかもしれません。"
#: org/postgresql/core/Utils.java:145
msgid "Zero bytes may not occur in identifiers."
msgstr "ゼロ・バイトは、識別できないかもしれません。"
#: org/postgresql/core/types/PGBigDecimal.java:63
#: org/postgresql/core/types/PGBoolean.java:62
#: org/postgresql/core/types/PGByte.java:63
#: org/postgresql/core/types/PGDouble.java:64
#: org/postgresql/core/types/PGFloat.java:64
#: org/postgresql/core/types/PGInteger.java:61
#: org/postgresql/core/types/PGLong.java:62
#: org/postgresql/core/types/PGNumber.java:62
#: org/postgresql/core/types/PGShort.java:58
#: org/postgresql/core/types/PGString.java:73
#, java-format
msgid "Cannot convert an instance of {0} to type {1}"
msgstr "型 {1} に {0} のインスタンスを変換できません。"
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:66
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:74
#, fuzzy, java-format
msgid "Invalid sslmode value: {0}"
msgstr "無効なストリーム長 {0}."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:134
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:168
msgid ""
"Connection refused. Check that the hostname and port are correct and that "
"the postmaster is accepting TCP/IP connections."
msgstr ""
"接続は拒絶されました。ホスト名とポート番号が正しいか、または、ポストマスタが"
"TCP/IP接続を受け入れているかを調べて下さい。"
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:153
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:186
msgid "The connection attempt failed."
msgstr "接続の試みは失敗しました。"
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:175
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:207
#, fuzzy
msgid "The connection url is invalid."
msgstr "接続の試みは失敗しました。"
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:198
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:210
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:256
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:268
msgid "The server does not support SSL."
msgstr "サーバはSSLをサポートしていません。"
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:223
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:281
msgid "An error occured while setting up the SSL connection."
msgstr "SSL接続のセットアップ中に、エラーが起こりました。"
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:272
#, java-format
msgid "Connection rejected: {0}."
msgstr "接続は拒絶されました: {0}."
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:290
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:312
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:332
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:380
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:405
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:432
msgid ""
"The server requested password-based authentication, but no password was "
"provided."
msgstr ""
"サーバーは、パスワード・ベースの認証を要求しました、しかし、いかなるパスワー"
"ドも提供されませんでした。"
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:356
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:465
#, java-format
msgid ""
"The authentication type {0} is not supported. Check that you have configured "
"the pg_hba.conf file to include the client''s IP address or subnet, and that "
"it is using an authentication scheme supported by the driver."
msgstr ""
"認証型 {0} はサポートされません、pg_hba.confファイルの構成でクライアントのIP"
"アドレス、サブネットが含まれているか、そしてドライバがサポートする認証機構を"
"使っているかを調べてください。"
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:362
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:400
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:471
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:514
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:560
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:570
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:579
#: org/postgresql/core/v3/ConnectionFactoryImpl.java:587
#: org/postgresql/gss/MakeGSS.java:158
msgid "Protocol error. Session setup failed."
msgstr "プロトコルエラー, セッション設定は失敗しました。"
#: org/postgresql/core/v2/ConnectionFactoryImpl.java:390
#, java-format
msgid "Backend start-up failed: {0}."
msgstr "バックエンドの開始に失敗しました: {0}"
#: org/postgresql/core/v2/FastpathParameterList.java:55
#: org/postgresql/core/v2/FastpathParameterList.java:77
#: org/postgresql/core/v2/FastpathParameterList.java:84
#: org/postgresql/core/v2/SimpleParameterList.java:57
#: org/postgresql/core/v2/SimpleParameterList.java:76
#: org/postgresql/core/v2/SimpleParameterList.java:83
#: org/postgresql/core/v2/SimpleParameterList.java:90
#: org/postgresql/core/v3/CompositeParameterList.java:35
#: org/postgresql/core/v3/SimpleParameterList.java:47
#: org/postgresql/core/v3/SimpleParameterList.java:54
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2845
#: org/postgresql/jdbc2/AbstractJdbc2ResultSetMetaData.java:419
#, java-format
msgid "The column index is out of range: {0}, number of columns: {1}."
msgstr "列インデックスは範囲外です: {0} , 列の数: {1}"
#: org/postgresql/core/v2/FastpathParameterList.java:142
#: org/postgresql/core/v2/SimpleParameterList.java:155
#: org/postgresql/core/v3/SimpleParameterList.java:183
#, java-format
msgid "No value specified for parameter {0}."
msgstr "パラメータ {0} の明確な値がありません。"
#: org/postgresql/core/v2/QueryExecutorImpl.java:72
#: org/postgresql/core/v2/QueryExecutorImpl.java:337
#: org/postgresql/core/v3/QueryExecutorImpl.java:443
#: org/postgresql/core/v3/QueryExecutorImpl.java:507
#, java-format
msgid "Expected command status BEGIN, got {0}."
msgstr "BEGINコマンドステータスを想定しました, 取得 {0}"
#: org/postgresql/core/v2/QueryExecutorImpl.java:78
#: org/postgresql/core/v3/QueryExecutorImpl.java:513
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1828
#, java-format
msgid "Unexpected command status: {0}."
msgstr "想定外のコマンドステータス: {0}"
#: org/postgresql/core/v2/QueryExecutorImpl.java:118
#: org/postgresql/core/v2/QueryExecutorImpl.java:129
#: org/postgresql/core/v2/QueryExecutorImpl.java:174
#: org/postgresql/core/v2/QueryExecutorImpl.java:369
#: org/postgresql/core/v3/QueryExecutorImpl.java:281
#: org/postgresql/core/v3/QueryExecutorImpl.java:411
#: org/postgresql/core/v3/QueryExecutorImpl.java:485
#: org/postgresql/core/v3/QueryExecutorImpl.java:551
#: org/postgresql/core/v3/QueryExecutorImpl.java:631
#: org/postgresql/core/v3/QueryExecutorImpl.java:2094
msgid "An I/O error occured while sending to the backend."
msgstr "バックエンドに送信中に、入出力エラーはが起こりました。"
#: org/postgresql/core/v2/QueryExecutorImpl.java:170
#: org/postgresql/core/v2/QueryExecutorImpl.java:225
#: org/postgresql/core/v2/QueryExecutorImpl.java:236
#: org/postgresql/core/v3/QueryExecutorImpl.java:627
#: org/postgresql/core/v3/QueryExecutorImpl.java:685
#, java-format
msgid "Unknown Response Type {0}."
msgstr "未知の応答型 {0} です。"
#: org/postgresql/core/v2/QueryExecutorImpl.java:430
#: org/postgresql/core/v2/QueryExecutorImpl.java:475
#: org/postgresql/core/v3/QueryExecutorImpl.java:1857
msgid "Ran out of memory retrieving query results."
msgstr "メモリを使い果たし、クエリー結果を回収しました。"
#: org/postgresql/core/v2/QueryExecutorImpl.java:597
#: org/postgresql/core/v3/QueryExecutorImpl.java:2199
#, java-format
msgid "Unable to interpret the update count in command completion tag: {0}."
msgstr "コマンド完了タグで更新数を解釈することができません: {0}"
#: org/postgresql/core/v2/QueryExecutorImpl.java:610
msgid "Copy not implemented for protocol version 2"
msgstr "プロトコルバージョン2でCopyは装備されていません"
#: org/postgresql/core/v3/CopyOperationImpl.java:56
msgid "CommandComplete expected COPY but got: "
msgstr "コマンド完了はCOPYを想定します、しかし取得は:"
#: org/postgresql/core/v3/QueryExecutorImpl.java:66
msgid "Tried to obtain lock while already holding it"
msgstr "すでに占有している最中のロック取得です"
#: org/postgresql/core/v3/QueryExecutorImpl.java:78
msgid "Tried to break lock on database connection"
msgstr "データベース接続のロック中断を試みます。"
#: org/postgresql/core/v3/QueryExecutorImpl.java:93
msgid "Interrupted while waiting to obtain lock on database connection"
msgstr "データベース接続でロック待ちの最中に割り込みがありました。"
#: org/postgresql/core/v3/QueryExecutorImpl.java:275
msgid "Unable to bind parameter values for statement."
msgstr "ステートメントのバインドパラメーター値ができません。"
#: org/postgresql/core/v3/QueryExecutorImpl.java:726
msgid "Database connection failed when starting copy"
msgstr "文字列copy中にデータベース接続に失敗しました。"
#: org/postgresql/core/v3/QueryExecutorImpl.java:757
msgid "Tried to cancel an inactive copy operation"
msgstr "不活発なコピー操作の取り消しを試みました"
#: org/postgresql/core/v3/QueryExecutorImpl.java:794
msgid "Database connection failed when canceling copy operation"
msgstr "コピー操作取り消し中にデータベース接続に失敗しました"
#: org/postgresql/core/v3/QueryExecutorImpl.java:799
msgid "Missing expected error response to copy cancel request"
msgstr "コピー取り消し要求のエラー応答を想定しました"
#: org/postgresql/core/v3/QueryExecutorImpl.java:801
#, java-format
msgid "Got {0} error responses to single copy cancel request"
msgstr "単一copy取り消し要求の {0} エラー応答を得ました"
#: org/postgresql/core/v3/QueryExecutorImpl.java:814
msgid "Tried to end inactive copy"
msgstr "不活発なコピーの終了を試みました。"
#: org/postgresql/core/v3/QueryExecutorImpl.java:827
msgid "Database connection failed when ending copy"
msgstr "コピーを終えるときに、データベース接続は失敗しました"
#: org/postgresql/core/v3/QueryExecutorImpl.java:842
#: org/postgresql/core/v3/QueryExecutorImpl.java:860
msgid "Tried to write to an inactive copy operation"
msgstr "不活発なコピー操作で書き込みを試みました。"
#: org/postgresql/core/v3/QueryExecutorImpl.java:854
#: org/postgresql/core/v3/QueryExecutorImpl.java:866
msgid "Database connection failed when writing to copy"
msgstr "copy書き込み中にデータベース接続に失敗しました"
#: org/postgresql/core/v3/QueryExecutorImpl.java:878
msgid "Tried to read from inactive copy"
msgstr "活動していないcopyから読み取りを試みました。"
#: org/postgresql/core/v3/QueryExecutorImpl.java:883
msgid "Database connection failed when reading from copy"
msgstr "copyから読み取り中にデータベース接続が失敗しました"
#: org/postgresql/core/v3/QueryExecutorImpl.java:951
#, java-format
msgid "Received CommandComplete ''{0}'' without an active copy operation"
msgstr "活動中のコピー操作なしでCommandComplete ''{0}'' を受け取りました"
#: org/postgresql/core/v3/QueryExecutorImpl.java:975
#, java-format
msgid "Got CopyInResponse from server during an active {0}"
msgstr "活動中のサーバ {0} からCopyInResponseを得ました"
#: org/postgresql/core/v3/QueryExecutorImpl.java:988
#, java-format
msgid "Got CopyOutResponse from server during an active {0}"
msgstr "活動中のサーバ {0} からCopyOutResponseを得ました"
#: org/postgresql/core/v3/QueryExecutorImpl.java:1003
msgid "Got CopyData without an active copy operation"
msgstr "活動中のコピー操作なしでCopyDataを得ました"
#: org/postgresql/core/v3/QueryExecutorImpl.java:1005
#, java-format
msgid "Unexpected copydata from server for {0}"
msgstr "{0} のサーバからの思いがけない copydata です。"
#: org/postgresql/core/v3/QueryExecutorImpl.java:1056
#, java-format
msgid "Unexpected packet type during copy: {0}"
msgstr "copy最中に思いがけないパケット型です: {0}"
#: org/postgresql/core/v3/QueryExecutorImpl.java:1310
#, java-format
msgid ""
"Bind message length {0} too long. This can be caused by very large or "
"incorrect length specifications on InputStream parameters."
msgstr ""
"バインドメッセージ長 {0} は長すぎます。これはとても大きくする要因となるか、あ"
"るいは、InputStreamパラメーターの不正確な長さ記述です。"
#: org/postgresql/core/v3/QueryExecutorImpl.java:1925
#, fuzzy, java-format
msgid ""
"The server''s client_encoding parameter was changed to {0}. The JDBC driver "
"requires client_encoding to be UTF8 for correct operation."
msgstr ""
"サーバーのclient_encodingパラメーターが {0} に変わりました、JDBCドライバー"
"は、正しい操作のためclient_encodingをUNICODEにすることを要求します。"
#: org/postgresql/core/v3/QueryExecutorImpl.java:1932
#, java-format
msgid ""
"The server''s DateStyle parameter was changed to {0}. The JDBC driver "
"requires DateStyle to begin with ISO for correct operation."
msgstr ""
"サーバーのDateStyleパラメーターは、{0} に変わりました,JDBCドライバーは、正し"
"い操作のISOで、開始するためのDateStyleを必要とします。"
#: org/postgresql/core/v3/QueryExecutorImpl.java:1945
#, java-format
msgid ""
"The server''s standard_conforming_strings parameter was reported as {0}. The "
"JDBC driver expected on or off."
msgstr ""
"サーバーのstandard_conforming_stringsパラメーターは、{0}として報告されまし"
"た。JDBCドライバーは、on または off を想定します。"
#: org/postgresql/core/v3/QueryExecutorImpl.java:2015
msgid "The driver currently does not support COPY operations."
msgstr "現在、ドライバはコピー操作をサポートしません。"
#: org/postgresql/ds/jdbc23/AbstractJdbc23PooledConnection.java:112
msgid "This PooledConnection has already been closed."
msgstr "PooledConnectionは、すでに閉じられています。"
#: org/postgresql/ds/jdbc23/AbstractJdbc23PooledConnection.java:295
msgid ""
"Connection has been closed automatically because a new connection was opened "
"for the same PooledConnection or the PooledConnection has been closed."
msgstr ""
"同じPooledConnectionが開かれたので新しい接続は自動的に閉じられました、また"
"は、PooledConnectionが閉じられました。"
#: org/postgresql/ds/jdbc23/AbstractJdbc23PooledConnection.java:295
msgid "Connection has been closed."
msgstr "接続は閉じられました。"
#: org/postgresql/ds/jdbc23/AbstractJdbc23PooledConnection.java:442
msgid "Statement has been closed."
msgstr "構文は閉じられました。"
#: org/postgresql/ds/jdbc23/AbstractJdbc23PoolingDataSource.java:291
msgid "Failed to setup DataSource."
msgstr ""
#: org/postgresql/ds/jdbc23/AbstractJdbc23PoolingDataSource.java:414
msgid "DataSource has been closed."
msgstr "データソースは閉じられました。"
#: org/postgresql/fastpath/Fastpath.java:81
#: org/postgresql/fastpath/Fastpath.java:128
#, java-format
msgid "Fastpath call {0} - No result was returned and we expected an integer."
msgstr ""
"Fastpath 呼び出し {0} - いかなる結果も返されません、整数を予想しました。"
#: org/postgresql/fastpath/Fastpath.java:237
#, java-format
msgid "The fastpath function {0} is unknown."
msgstr " {0} は未知の fastpath 関数です。"
#: org/postgresql/geometric/PGbox.java:83
#: org/postgresql/geometric/PGcircle.java:82
#: org/postgresql/geometric/PGcircle.java:91
#: org/postgresql/geometric/PGline.java:80
#: org/postgresql/geometric/PGlseg.java:77
#: org/postgresql/geometric/PGpoint.java:85
#, java-format
msgid "Conversion to type {0} failed: {1}."
msgstr "型変換 {0} は失敗しました: {1}."
#: org/postgresql/geometric/PGpath.java:81
#, java-format
msgid "Cannot tell if path is open or closed: {0}."
msgstr "もし path が オープン、またはクローズされていたら話せません: {0}"
#: org/postgresql/gss/MakeGSS.java:47 org/postgresql/gss/MakeGSS.java:55
#: org/postgresql/gss/MakeGSS.java:168
msgid "GSS Authentication failed"
msgstr "GSS認証は失敗しました"
#: org/postgresql/jdbc2/AbstractJdbc2Array.java:153
#: org/postgresql/jdbc2/AbstractJdbc2Array.java:790
#, java-format
msgid "The array index is out of range: {0}"
msgstr "配列インデックスは、範囲外です: {0}"
#: org/postgresql/jdbc2/AbstractJdbc2Array.java:168
#: org/postgresql/jdbc2/AbstractJdbc2Array.java:807
#, java-format
msgid "The array index is out of range: {0}, number of elements: {1}."
msgstr "配列インデックスは、範囲外です: {0} , 要素の数: {1}"
#: org/postgresql/jdbc2/AbstractJdbc2Array.java:196
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1982
#: org/postgresql/util/HStoreConverter.java:34
#: org/postgresql/util/HStoreConverter.java:61
msgid ""
"Invalid character data was found. This is most likely caused by stored data "
"containing characters that are invalid for the character set the database "
"was created in. The most common example of this is storing 8bit data in a "
"SQL_ASCII database."
msgstr ""
"不正な文字データが見つかりました。これは、恐らく作成されたデータベースの文字"
"セットにとって無効である文字を含むデータによって引き起こされます。最も共通の"
"例として、8bitデータがSQL_ASCIIデータベースに保存されています。"
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:73
msgid ""
"Truncation of large objects is only implemented in 8.3 and later servers."
msgstr ""
"ラージオブジェクトの除去は、サーババージョンが 8.3 以上で装備されています。"
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:77
msgid "Cannot truncate LOB to a negative length."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:81
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:235
#, java-format
msgid "PostgreSQL LOBs can only index to: {0}"
msgstr "PostgreSQL LOB は、インデックス {0} のみ可能です。 "
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:231
msgid "LOB positioning offsets start at 1."
msgstr "LOB オフセット開始位置を 1 としてください。"
#: org/postgresql/jdbc2/AbstractJdbc2BlobClob.java:246
msgid "free() was called on this LOB previously"
msgstr "free() は、 このLOB以前に呼ばれました"
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:229
#, java-format
msgid "Unsupported value for stringtype parameter: {0}"
msgstr "文字列型パラメータのサポートされない値です: {0}"
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:249
msgid "unknownLength parameter value must be an integer"
msgstr "未知の長さパラメータ値は整数でなければなりません"
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:357
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:284
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:303
#: org/postgresql/jdbc2/TypeInfoCache.java:201
#: org/postgresql/jdbc2/TypeInfoCache.java:249
#: org/postgresql/jdbc2/TypeInfoCache.java:287
#: org/postgresql/jdbc2/TypeInfoCache.java:344
#: org/postgresql/jdbc2/TypeInfoCache.java:348
#: org/postgresql/jdbc2/TypeInfoCache.java:384
#: org/postgresql/jdbc2/TypeInfoCache.java:388
msgid "No results were returned by the query."
msgstr "いかなる結果も、クエリーによって返されませんでした。"
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:371
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:336
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:368
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2695
msgid "A result was returned when none was expected."
msgstr "何も予想しなかったときに、結果が返されました。"
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:523
msgid "Custom type maps are not supported."
msgstr "カスタム・型のマップはサポートされません。"
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:571
#, java-format
msgid "Failed to create object for: {0}."
msgstr "{0} へのオブジェクト生成に失敗しました。"
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:633
#, java-format
msgid "Unable to load the class {0} responsible for the datatype {1}"
msgstr "データ型 {1} 対応のクラス{0} をロードできません。"
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:729
msgid ""
"Cannot change transaction read-only property in the middle of a transaction."
msgstr ""
"トランザクション中に、読み出し専用プロパティトランザクションに変えることがで"
"きません。"
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:817
msgid "Cannot commit when autoCommit is enabled."
msgstr "オートコミット有効時にコミットできません。"
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:826
msgid "This connection has been closed."
msgstr "接続は既に閉じられました。"
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:846
msgid "Cannot rollback when autoCommit is enabled."
msgstr "オートコミット有効時にロールバックできません。"
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:933
msgid ""
"Cannot change transaction isolation level in the middle of a transaction."
msgstr "トランザクションの最中に隔離レベルを変えることができません。"
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:938
#, java-format
msgid "Transaction isolation level {0} not supported."
msgstr "トランザクション隔離レベル{0} はサポートされていません。"
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:1005
msgid "Finalizing a Connection that was never closed:"
msgstr "接続終了で閉じられませんでした:"
#: org/postgresql/jdbc2/AbstractJdbc2Connection.java:1107
msgid "Unable to translate data into the desired encoding."
msgstr "望む符号化にデータを訳すことができません。"
#: org/postgresql/jdbc2/AbstractJdbc2DatabaseMetaData.java:63
msgid ""
"Unable to determine a value for MaxIndexKeys due to missing system catalog "
"data."
msgstr ""
"間違ったシステム・カタログ・データのためにMaxIndexKeysの値を決めることができ"
"ません。"
#: org/postgresql/jdbc2/AbstractJdbc2DatabaseMetaData.java:86
msgid "Unable to find name datatype in the system catalogs."
msgstr "名前データ型をシステムカタログで見つけることができません。"
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:235
msgid ""
"Operation requires a scrollable ResultSet, but this ResultSet is "
"FORWARD_ONLY."
msgstr ""
"操作は、スクロール可能なResultSetを必要とします、しかし、このResultSetは、 "
"FORWARD_ONLYです。"
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:416
msgid "Unexpected error while decoding character data from a large object."
msgstr ""
"ラージオブジェクトから文字データの複合化中に思いがけないエラーが起きました。"
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:462
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:491
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:525
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3129
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3174
#, fuzzy, java-format
msgid "Cannot convert the column of type {0} to requested type {1}."
msgstr "型 {1} に {0} のインスタンスを変換できません。"
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:744
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:768
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1892
msgid "Can''t use relative move methods while on the insert row."
msgstr "行挿入の最中に関連の動作方法を使うことはできません。"
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:788
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2949
#, java-format
msgid "Invalid fetch direction constant: {0}."
msgstr "フェッチ方向コンスタントが不正です: {0}"
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:802
msgid "Cannot call cancelRowUpdates() when on the insert row."
msgstr "行挿入の最中にcancelRowUpdates()を呼び出せません。"
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:822
msgid "Cannot call deleteRow() when on the insert row."
msgstr "行挿入時に deleteRow() を呼び出せません。"
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:828
msgid ""
"Currently positioned before the start of the ResultSet. You cannot call "
"deleteRow() here."
msgstr ""
"ResultSetの開始の前に置かれました。ここでdeleteRowを呼ぶことはできません。"
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:833
msgid ""
"Currently positioned after the end of the ResultSet. You cannot call "
"deleteRow() here."
msgstr ""
"ResultSetの終わりの後に置かれました。ここでdeleteRowを呼ぶことはできません。"
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:838
msgid "There are no rows in this ResultSet."
msgstr "このResultSetにいかなる行もありません。"
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:885
msgid "Not on the insert row."
msgstr "挿入行がありません。"
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:889
msgid "You must specify at least one column value to insert a row."
msgstr "行挿入には、最低でも１つの列の値が必要です。"
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1074
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1805
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2494
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2524
#, java-format
msgid "The JVM claims not to support the encoding: {0}"
msgstr "JVMでサポートされないエンコーディングです: {0}"
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1078
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1121
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1527
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1656
msgid "Provided InputStream failed."
msgstr "提供の InputStream は失敗しました。"
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1191
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3130
msgid "Provided Reader failed."
msgstr "提供の Reader は失敗しました。"
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1259
msgid "Can''t refresh the insert row."
msgstr "挿入行を回復することはできません。"
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1327
msgid "Cannot call updateRow() when on the insert row."
msgstr "列を挿入したときに、updateRow() を呼び出すことができません。"
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1333
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3190
msgid ""
"Cannot update the ResultSet because it is either before the start or after "
"the end of the results."
msgstr ""
"開始前にResultSetを更新することができません、または結果の終わりの後です。"
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1582
msgid "ResultSets with concurrency CONCUR_READ_ONLY cannot be updated."
msgstr "CONCUR_READ_ONLYを伴うResultSetsは更新できませんでした。"
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1650
#, java-format
msgid "No primary key found for table {0}."
msgstr "テーブル {0} の主キーがありません。"
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:1876
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2958
msgid "Fetch size must be a value greater to or equal to 0."
msgstr "フェッチサイズは、0に等しいか、より以上の値でなくてはなりません。"
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2044
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2051
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2098
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2106
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2926
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2934
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2964
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2971
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2991
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3002
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3020
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3038
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:3179
#: org/postgresql/jdbc2/TimestampUtils.java:258
#, java-format
msgid "Bad value for type {0} : {1}"
msgstr "型 {0} : {1} で不正な値"
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2727
#, java-format
msgid "The column name {0} was not found in this ResultSet."
msgstr "ResultSet に列名 {0} は見つかりませんでした。"
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2827
msgid ""
"ResultSet is not updateable. The query that generated this result set must "
"select only one table, and must select all primary keys from that table. See "
"the JDBC 2.1 API Specification, section 5.6 for more details."
msgstr ""
"ResultSetは変更可能ではありません。この結果セットを生成したクエリーは、ただ一"
"つのテーブルを選ばなくてはいけません、そしてそのテーブルから全ての主キーを選"
"ばなくてはいけません。より多くの詳細に関して JDBC 2.1 API仕様、章 5.6 を参照"
"して下さい。"
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2839
msgid "This ResultSet is closed."
msgstr "ResultSetは閉じられました。"
#: org/postgresql/jdbc2/AbstractJdbc2ResultSet.java:2860
msgid "ResultSet not positioned properly, perhaps you need to call next."
msgstr ""
"ResultSetは適切に配置されませんでした、たぶん、次に呼ぶ必要があります。"
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:259
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:323
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:392
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2648
msgid ""
"Can''t use query methods that take a query string on a PreparedStatement."
msgstr "PreparedStatementでクエリー文字を含むクエリー方法は使えません。"
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:287
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:306
msgid "Multiple ResultSets were returned by the query."
msgstr "クエリーで、マルチのResultSetsが返されました。"
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:425
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:429
msgid "A CallableStatement was executed with nothing returned."
msgstr "CallableStatementは、戻りなしで実行されました。"
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:437
msgid "A CallableStatement was executed with an invalid number of parameters"
msgstr "CallableStatementは、パラメーターの不正な数で実行されました"
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:468
#, java-format
msgid ""
"A CallableStatement function was executed and the out parameter {0} was of "
"type {1} however type {2} was registered."
msgstr ""
"CallableStatement機能は実行されました、そして、出力パラメーター {0} は、型 "
"{1} です。しかし、型 {2} が登録されました。"
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:670
msgid "Maximum number of rows must be a value grater than or equal to 0."
msgstr "行の最大数は、0に等しいか、より以上の値でなくてはなりません。"
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:713
msgid "Query timeout must be a value greater than or equals to 0."
msgstr ""
"クエリータイムアウトは、0に等しいか、より以上の値でなくてはなりません。"
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:804
msgid "The maximum field size must be a value greater than or equal to 0."
msgstr "最大の項目サイズは、0に等しいか、または以上の値でなくてはなりません。"
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1219
msgid "Unknown Types value."
msgstr "未知の型の値です。"
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1492
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1617
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3101
#, java-format
msgid "Invalid stream length {0}."
msgstr "無効なストリーム長 {0}."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1523
#, java-format
msgid "The JVM claims not to support the {0} encoding."
msgstr "JVMは、エンコーディング {0} をサポートしません。"
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1698
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3023
#, java-format
msgid "Unknown type {0}."
msgstr "未知の型 {0}."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1713
msgid "No hstore extension installed."
msgstr ""
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1838
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1844
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1850
#, java-format
msgid "Cannot cast an instance of {0} to type {1}"
msgstr "インスタンス {0} は型 {1} へのキャストはできません"
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1862
#, java-format
msgid "Unsupported Types value: {0}"
msgstr "サポートされない型の値: {0}."
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1920
#, java-format
msgid ""
"Can''t infer the SQL type to use for an instance of {0}. Use setObject() "
"with an explicit Types value to specify the type to use."
msgstr ""
"{0} で使うべきSQL型を推測できません。明確な型値で記述した setObject() を使っ"
"てください。"
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:1968
msgid ""
"This statement does not declare an OUT parameter. Use '{' ?= call ... '}' "
"to declare one."
msgstr ""
"ステートメントは、OUTパラメーターを宣言しません。'{' ?= call ... '}' を使って"
"宣言して下さい。"
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2018
msgid "wasNull cannot be call before fetching a result."
msgstr "wasNullは、結果フェッチ前に呼び出せません。"
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2514
#, java-format
msgid "Malformed function or procedure escape syntax at offset {0}."
msgstr "奇形の関数または手順は、位置 {0} で文法を逸しました。"
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2564
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2578
#, java-format
msgid ""
"Parameter of type {0} was registered, but call to get{1} (sqltype={2}) was "
"made."
msgstr ""
"型 {0} のパラメータは登録されました,、しかし、{1} 取得呼び出し(sqltype={2})"
"が作られました。"
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2597
msgid ""
"A CallableStatement was declared, but no call to registerOutParameter(1, "
") was made."
msgstr ""
"CallableStatementは宣言されました、しかし registerOutParameterwas(1, ) のいかなる呼び出しも作られません。"
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2601
msgid "No function outputs were registered."
msgstr "関数出力は登録されませんでした。"
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2604
msgid ""
"Results cannot be retrieved from a CallableStatement before it is executed."
msgstr "実行される前に、CallableStatement から結果を得ることはできません。"
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2637
msgid "This statement has been closed."
msgstr "このステートメントは閉じられました。"
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2717
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2787
msgid "Too many update results were returned."
msgstr "多すぎる更新結果が返されました。"
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2746
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:2816
#, java-format
msgid ""
"Batch entry {0} {1} was aborted. Call getNextException to see the cause."
msgstr ""
"バッチ投入 {0} {1} は停止しました、getNextExceptionを呼んで原因を見て下さい。"
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3071
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3160
#: org/postgresql/jdbc2/AbstractJdbc2Statement.java:3200
msgid "Unexpected error writing large object to database."
msgstr ""
"ラージオブジェクトをデータベースへ書き込み中に想定外のエラーが起きました。"
#: org/postgresql/jdbc2/EscapedFunctions.java:145
#: org/postgresql/jdbc2/EscapedFunctions.java:157
#: org/postgresql/jdbc2/EscapedFunctions.java:169
#: org/postgresql/jdbc2/EscapedFunctions.java:206
#: org/postgresql/jdbc2/EscapedFunctions.java:243
#: org/postgresql/jdbc2/EscapedFunctions.java:267
#: org/postgresql/jdbc2/EscapedFunctions.java:292
#: org/postgresql/jdbc2/EscapedFunctions.java:316
#: org/postgresql/jdbc2/EscapedFunctions.java:328
#: org/postgresql/jdbc2/EscapedFunctions.java:352
#: org/postgresql/jdbc2/EscapedFunctions.java:380
#: org/postgresql/jdbc2/EscapedFunctions.java:389
#: org/postgresql/jdbc2/EscapedFunctions.java:399
#: org/postgresql/jdbc2/EscapedFunctions.java:408
#: org/postgresql/jdbc2/EscapedFunctions.java:417
#: org/postgresql/jdbc2/EscapedFunctions.java:426
#: org/postgresql/jdbc2/EscapedFunctions.java:435
#: org/postgresql/jdbc2/EscapedFunctions.java:444
#: org/postgresql/jdbc2/EscapedFunctions.java:453
#: org/postgresql/jdbc2/EscapedFunctions.java:462
#: org/postgresql/jdbc2/EscapedFunctions.java:471
#: org/postgresql/jdbc2/EscapedFunctions.java:480
#, java-format
msgid "{0} function takes one and only one argument."
msgstr "{0} 関数は、単一の引数のみを用います。"
#: org/postgresql/jdbc2/EscapedFunctions.java:181
#: org/postgresql/jdbc2/EscapedFunctions.java:193
#: org/postgresql/jdbc2/EscapedFunctions.java:255
#: org/postgresql/jdbc2/EscapedFunctions.java:304
#: org/postgresql/jdbc2/EscapedFunctions.java:582
#, java-format
msgid "{0} function takes two and only two arguments."
msgstr "{0} 関数は、二つの引数のみを用います。"
#: org/postgresql/jdbc2/EscapedFunctions.java:230
#, java-format
msgid "{0} function takes four and only four argument."
msgstr "{0} 関数は、四つの引数のみを用います。"
#: org/postgresql/jdbc2/EscapedFunctions.java:282
#: org/postgresql/jdbc2/EscapedFunctions.java:342
#, java-format
msgid "{0} function takes two or three arguments."
msgstr "{0} 関数は、二つ、または三つの引数を用います。"
#: org/postgresql/jdbc2/EscapedFunctions.java:362
#: org/postgresql/jdbc2/EscapedFunctions.java:371
#: org/postgresql/jdbc2/EscapedFunctions.java:573
#: org/postgresql/jdbc2/EscapedFunctions.java:591
#, java-format
msgid "{0} function doesn''t take any argument."
msgstr "{0} 関数は、どのような引数も用いません。"
#: org/postgresql/jdbc2/EscapedFunctions.java:489
#: org/postgresql/jdbc2/EscapedFunctions.java:531
#, java-format
msgid "{0} function takes three and only three arguments."
msgstr "{0} 関数は、三つの引数のみを用います。"
#: org/postgresql/jdbc2/EscapedFunctions.java:501
#: org/postgresql/jdbc2/EscapedFunctions.java:521
#: org/postgresql/jdbc2/EscapedFunctions.java:523
#: org/postgresql/jdbc2/EscapedFunctions.java:543
#: org/postgresql/jdbc2/EscapedFunctions.java:564
#: org/postgresql/jdbc2/EscapedFunctions.java:566
#, java-format
msgid "Interval {0} not yet implemented"
msgstr "間隔 {0} はまだ装備されていません"
#: org/postgresql/jdbc2/TimestampUtils.java:360
msgid ""
"Infinite value found for timestamp/date. This cannot be represented as time."
msgstr ""
"timestamp/date で無限値が見つかりました、これは、時間として表すことができませ"
"ん。"
#: org/postgresql/jdbc2/TimestampUtils.java:648
#: org/postgresql/jdbc2/TimestampUtils.java:680
#: org/postgresql/jdbc2/TimestampUtils.java:727
#, fuzzy, java-format
msgid "Unsupported binary encoding of {0}."
msgstr "サポートされない型の値: {0}."
#: org/postgresql/jdbc2/TypeInfoCache.java:161
#, java-format
msgid "The class {0} does not implement org.postgresql.util.PGobject."
msgstr "クラス {0} は、org.postgresql.util.PGobject を装備していません。"
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:60
#, java-format
msgid "Unknown ResultSet holdability setting: {0}."
msgstr "未知の ResultSet 保持的設定: {0}"
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:98
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:130
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:165
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:187
msgid "Server versions prior to 8.0 do not support savepoints."
msgstr "サーバーバージョン 8.0 以前は、savepointをサポートしません。"
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:100
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:132
msgid "Cannot establish a savepoint in auto-commit mode."
msgstr "オートコミットモードでsavepointを確立できません。"
#: org/postgresql/jdbc3/AbstractJdbc3Connection.java:419
msgid "Returning autogenerated keys is not supported."
msgstr "自動生成キーを返すことはサポートされていません。"
#: org/postgresql/jdbc3/AbstractJdbc3ParameterMetaData.java:81
#, java-format
msgid "The parameter index is out of range: {0}, number of parameters: {1}."
msgstr "パラメーター・インデックスは範囲外です: {0} , パラメータ数: {1}"
#: org/postgresql/jdbc3/AbstractJdbc3Statement.java:151
msgid ""
"Returning autogenerated keys is only supported for 8.2 and later servers."
msgstr "自動生成キーの戻りは 8.2 以上でサポートされます。"
#: org/postgresql/jdbc3/AbstractJdbc3Statement.java:199
#: org/postgresql/jdbc3/AbstractJdbc3Statement.java:317
msgid "Returning autogenerated keys by column index is not supported."
msgstr "列インデックスの自動生成キーの戻りはサポートされていません。"
#: org/postgresql/jdbc3/PSQLSavepoint.java:38
#: org/postgresql/jdbc3/PSQLSavepoint.java:50
#: org/postgresql/jdbc3/PSQLSavepoint.java:66
msgid "Cannot reference a savepoint after it has been released."
msgstr "savepointは、解放された後で参照することはできません。"
#: org/postgresql/jdbc3/PSQLSavepoint.java:42
msgid "Cannot retrieve the id of a named savepoint."
msgstr "名前の付いたsavepointのidを回収することができません。"
#: org/postgresql/jdbc3/PSQLSavepoint.java:54
msgid "Cannot retrieve the name of an unnamed savepoint."
msgstr "名前のないsavepointを回収することができません。"
#: org/postgresql/jdbc3g/AbstractJdbc3gResultSet.java:37
msgid "Invalid UUID data."
msgstr "UUIDデータ不正です。"
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:83
#, java-format
msgid "Unable to find server array type for provided name {0}."
msgstr "提供名 {0} で、サーバーの配列型を見つけることができません。"
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:120
#, fuzzy, java-format
msgid "Invalid timeout ({0}<0)."
msgstr "無効なストリーム長 {0}."
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:133
msgid "Validating connection."
msgstr ""
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:156
#, fuzzy, java-format
msgid "Failed to set ClientInfo property: {0}"
msgstr "{0} へのオブジェクト生成に失敗しました。"
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:165
#: org/postgresql/jdbc4/AbstractJdbc4Connection.java:187
msgid "ClientInfo property not supported."
msgstr "ClientInfo プロパティはサポートされていません。"
#: org/postgresql/jdbc4/AbstractJdbc4Statement.java:127
msgid "Object is too large to send over the protocol."
msgstr ""
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:147
msgid "Unable to decode xml data."
msgstr "xmlデータを復号化できません。"
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:150
#, java-format
msgid "Unknown XML Source class: {0}"
msgstr "未知のXMLソースクラス: {0}"
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:195
msgid "Unable to create SAXResult for SQLXML."
msgstr "SQLXMLへのSAXResult生成ができません。"
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:209
msgid "Unable to create StAXResult for SQLXML"
msgstr "SQLXMLのStAXResultを生成できません。"
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:213
#, java-format
msgid "Unknown XML Result class: {0}"
msgstr "未知のXML結果クラス: {0}"
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:226
msgid "This SQLXML object has already been freed."
msgstr "SQLXMLオブジェクトはすでに解放されました。"
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:233
msgid ""
"This SQLXML object has not been initialized, so you cannot retrieve data "
"from it."
msgstr ""
"このSQLXMLオブジェクトは、初期化されませんでした、そこからデータを回収するこ"
"とができません。"
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:244
#, java-format
msgid "Failed to convert binary xml data to encoding: {0}."
msgstr "バイナリxmlデータをエンコード {0} に変換できません。"
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:269
msgid "Unable to convert DOMResult SQLXML data to a string."
msgstr "DOMResult SQLXMLデータを文字列に変えることができません。"
#: org/postgresql/jdbc4/Jdbc4SQLXML.java:282
msgid ""
"This SQLXML object has already been initialized, so you cannot manipulate it "
"further."
msgstr ""
"このSQLXMLオブジェクトは、すでに初期化されました、それ以上操作することができ"
"ません。"
#: org/postgresql/largeobject/LargeObjectManager.java:138
msgid "Failed to initialize LargeObject API"
msgstr "ラージオブジェクトAPIの初期化に失敗しました。"
#: org/postgresql/largeobject/LargeObjectManager.java:198
#: org/postgresql/largeobject/LargeObjectManager.java:239
msgid "Large Objects may not be used in auto-commit mode."
msgstr "ラージオブジェクトでは、オートコミットモードを使うことができません。"
#: org/postgresql/ssl/jdbc3/AbstractJdbc3MakeSSL.java:58
#: org/postgresql/ssl/jdbc4/AbstractJdbc4MakeSSL.java:110
#, java-format
msgid "The SSLSocketFactory class provided {0} could not be instantiated."
msgstr "提供のSSLSocketFactoryクラス {0} は、即応しないかもしれません。"
#: org/postgresql/ssl/jdbc4/AbstractJdbc4MakeSSL.java:125
#, java-format
msgid "SSL error: {0}"
msgstr ""
#: org/postgresql/ssl/jdbc4/AbstractJdbc4MakeSSL.java:138
#, fuzzy, java-format
msgid "The HostnameVerifier class provided {0} could not be instantiated."
msgstr "提供のSSLSocketFactoryクラス {0} は、即応しないかもしれません。"
#: org/postgresql/ssl/jdbc4/AbstractJdbc4MakeSSL.java:142
#, java-format
msgid "The hostname {0} could not be verified by hostnameverifier {1}."
msgstr ""
#: org/postgresql/ssl/jdbc4/AbstractJdbc4MakeSSL.java:149
#, java-format
msgid "The hostname {0} could not be verified."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:121
msgid ""
"Could not find a java cryptographic algorithm: X.509 CertificateFactory not "
"available."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:132
#, java-format
msgid "Could not open SSL certificate file {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:137
#, java-format
msgid "Loading the SSL certificate {0} into a KeyManager failed."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:194
msgid "Enter SSL password: "
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:202
msgid "Could not read password for SSL key file, console is not available."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:204
#, java-format
msgid "Could not read password for SSL key file by callbackhandler {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:223
#, java-format
msgid "Could not decrypt SSL key file {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:231
#, java-format
msgid "Could not read SSL key file {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LazyKeyManager.java:235
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:173
#, java-format
msgid "Could not find a java cryptographic algorithm: {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:99
#, fuzzy, java-format
msgid "The password callback class provided {0} could not be instantiated."
msgstr "提供のSSLSocketFactoryクラス {0} は、即応しないかもしれません。"
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:133
#, java-format
msgid "Could not open SSL root certificate file {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:150
#, java-format
msgid "Could not read SSL root certificate file {0}."
msgstr ""
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:153
#, java-format
msgid "Loading the SSL root certificate {0} into a TrustManager failed."
msgstr ""
#: org/postgresql/ssl/jdbc4/LibPQFactory.java:166
msgid "Could not initialize SSL context."
msgstr ""
#: org/postgresql/util/PGInterval.java:164
msgid "Conversion of interval failed"
msgstr "間隔の変換に失敗しました。"
#: org/postgresql/util/PGmoney.java:73
msgid "Conversion of money failed."
msgstr "通貨の変換に失敗しました。"
#: org/postgresql/util/ServerErrorMessage.java:155
#, java-format
msgid "Detail: {0}"
msgstr "詳細l: {0}"
#: org/postgresql/util/ServerErrorMessage.java:159
#, java-format
msgid "Hint: {0}"
msgstr "ヒント: {0}"
#: org/postgresql/util/ServerErrorMessage.java:162
#, java-format
msgid "Position: {0}"
msgstr "ポジション: {0}"
#: org/postgresql/util/ServerErrorMessage.java:165
#, java-format
msgid "Where: {0}"
msgstr "場所: {0}"
#: org/postgresql/util/ServerErrorMessage.java:171
#, java-format
msgid "Internal Query: {0}"
msgstr "インターナル・クエリー: {0}"
#: org/postgresql/util/ServerErrorMessage.java:174
#, java-format
msgid "Internal Position: {0}"
msgstr "インターナル・ポジション: {0}"
#: org/postgresql/util/ServerErrorMessage.java:180
#, java-format
msgid "Location: File: {0}, Routine: {1}, Line: {2}"
msgstr "場所: ファイル: {0}, ルーチン: {1},行: {2}"
#: org/postgresql/util/ServerErrorMessage.java:183
#, java-format
msgid "Server SQLState: {0}"
msgstr "サーバー SQLState: {0}"
#: org/postgresql/xa/PGXAConnection.java:148
msgid ""
"Transaction control methods setAutoCommit(true), commit, rollback and "
"setSavePoint not allowed while an XA transaction is active."
msgstr ""
#: org/postgresql/xa/PGXAConnection.java:186
#: org/postgresql/xa/PGXAConnection.java:245
msgid "Invalid flags"
msgstr "フラグ不正"
#: org/postgresql/xa/PGXAConnection.java:189
#: org/postgresql/xa/PGXAConnection.java:248
#: org/postgresql/xa/PGXAConnection.java:425
msgid "xid must not be null"
msgstr "xidはnullではいけません"
#: org/postgresql/xa/PGXAConnection.java:192
msgid "Connection is busy with another transaction"
msgstr "接続は、別のトランザクションで忙しいです"
#: org/postgresql/xa/PGXAConnection.java:198
#: org/postgresql/xa/PGXAConnection.java:255
msgid "suspend/resume not implemented"
msgstr "停止/再開 は装備されていません"
#: org/postgresql/xa/PGXAConnection.java:204
#: org/postgresql/xa/PGXAConnection.java:207
#: org/postgresql/xa/PGXAConnection.java:209
msgid "Transaction interleaving not implemented"
msgstr "トランザクションの間に実施されませんでした。"
#: org/postgresql/xa/PGXAConnection.java:218
msgid "Error disabling autocommit"
msgstr "オート・コミット無効エラー"
#: org/postgresql/xa/PGXAConnection.java:251
msgid "tried to call end without corresponding start call"
msgstr "対応する開始呼び出しなしで、終了呼び出しを得ました。"
#: org/postgresql/xa/PGXAConnection.java:282
msgid ""
"Not implemented: Prepare must be issued using the same connection that "
"started the transaction"
msgstr ""
"装備されていません: 準備は、開始トランザクションと同じ接続で使わなくてはなり"
"ません。"
#: org/postgresql/xa/PGXAConnection.java:286
msgid "Prepare called before end"
msgstr "終了前に\"準備\"が呼ばれました"
#: org/postgresql/xa/PGXAConnection.java:292
msgid "Server versions prior to 8.1 do not support two-phase commit."
msgstr "2フェーズ COMMIT は、サーババージョン 8.1以前はサポートされません。"
#: org/postgresql/xa/PGXAConnection.java:313
msgid "Error preparing transaction"
msgstr "準備トランザクションエラー"
#: org/postgresql/xa/PGXAConnection.java:328
msgid "Invalid flag"
msgstr "無効なフラグ"
#: org/postgresql/xa/PGXAConnection.java:368
msgid "Error during recover"
msgstr "回復中にエラー"
#: org/postgresql/xa/PGXAConnection.java:416
msgid "Error rolling back prepared transaction"
msgstr "準備トランザクションのロールバッグエラー"
#: org/postgresql/xa/PGXAConnection.java:451
msgid ""
"Not implemented: one-phase commit must be issued using the same connection "
"that was used to start it"
msgstr ""
"装備されていません: 単一フェーズのCOMMITは同じ接続を使って始めなければなりま"
"せん。"
#: org/postgresql/xa/PGXAConnection.java:455
msgid "commit called before end"
msgstr "終了の前に COMMIT を呼びました"
#: org/postgresql/xa/PGXAConnection.java:466
msgid "Error during one-phase commit"
msgstr "単一フェーズのCOMMITの最中にエラー"
#: org/postgresql/xa/PGXAConnection.java:487
msgid ""
"Not implemented: 2nd phase commit must be issued using an idle connection"
msgstr ""
"装備されていません: 第二フェーズの COMMIT は、待機接続で使わなくてはなりませ"
"ん。"
#: org/postgresql/xa/PGXAConnection.java:507
msgid "Error committing prepared transaction"
msgstr "準備トランザクションのコミットエラー"
#: org/postgresql/xa/PGXAConnection.java:522
msgid "Heuristic commit/rollback not supported"
msgstr "サポートされない commit/rollback が見つかりました。"
#~ msgid "The driver does not support SSL."
#~ msgstr "ドライバはSSLをサポートしていません。"
#~ msgid "Exception: {0}"
#~ msgstr "例外: {0}."
#~ msgid "Stack Trace:"
#~ msgstr "スタック・トレース:"
#~ msgid "End of Stack Trace"
#~ msgstr "スタック・トレースの終り:"
#~ msgid "Exception generating stacktrace for: {0} encountered: {1}"
#~ msgstr "スタック・トレース例外生成: {0} 遭遇: {1}"
#~ msgid "Multi-dimensional arrays are currently not supported."
#~ msgstr "Mehrdimensionale Arrays werden derzeit nicht unterstützt."
#~ msgid "rand function only takes zero or one argument(the seed)."
#~ msgstr ""
#~ "Die Funktion ''rand'' erwartet kein oder genau ein Argument (den "
#~ "''seed'')."
#~ msgid "suspend/resume and join not implemented"
#~ msgstr "Anhalten/Fortsetzen und Join sind nicht implementiert."
#~ msgid ""
#~ "setNull(i,Types.OTHER) is not supported; use setObject(i,nullobject,Types."
#~ "OTHER) instead."
#~ msgstr ""
#~ "''setNull(i, Types.OTHER)'' wird nicht unterstützt; benutzen Sie "
#~ "stattdessen ''setObject(i, nullobject, Types.OTHER)''."
#~ msgid ""
#~ "setObject(i,null) is not supported. Instead, use setNull(i,type) or "
#~ "setObject(i,null,type)"
#~ msgstr ""
#~ "''setObejct(i, null)'' ist nicht unterstützt. Benutzen Sie ''setNull(i, "
#~ "type)'' oder ''setObject(i, null, type)'' stattdessen."
#~ msgid ""
#~ "Cannot call setXXX(1, ..) on a CallableStatement. This is an output that "
#~ "must be configured with registerOutParameter instead."
#~ msgstr ""
#~ "''setXXX(1, ..)'' kann auf einem CallableStatement nicht aufgerufen "
#~ "werden. Diese Ausgabe muss stattdessen mit ''registerOutParameter'' "
#~ "konfiguriert werden."
#~ msgid ""
#~ "PostgreSQL only supports a single OUT function return value at index 1."
#~ msgstr ""
#~ "PostgreSQL unterstützt auf dem Index 1 nur einen einzigen Rückgabewert "
#~ "für die OUT-Funktion."
#, fuzzy
#~ msgid "Conversion of circle failed: {0}."
#~ msgstr "Konnte »{0}« nicht in Typ »circle« umwandeln"
#, fuzzy
#~ msgid "Conversion of line failed: {0}."
#~ msgstr "Konnte »{0}« nicht in Typ »line« umwandeln"
#, fuzzy
#~ msgid "Conversion of point failed: {0}."
#~ msgstr "Konnte »{0}« nicht in Typ »point« umwandeln"
#, fuzzy
#~ msgid "No results where returned by the query."
#~ msgstr "Die Abfrage ergab kein Ergebnis."
#, fuzzy
#~ msgid "Bad byte: {0}"
#~ msgstr "Ungültiges Format für Byte: {0}"
#, fuzzy
#~ msgid "Bad short: {0}"
#~ msgstr "Ungültiges Format für Short: {0}"
#, fuzzy
#~ msgid "Bad int: {0}"
#~ msgstr "Ungültiges Format für Long: {0}"
#, fuzzy
#~ msgid "Bad long: {0}"
#~ msgstr "Ungültiges Format für Long: {0}"
#, fuzzy
#~ msgid "Bad BigDecimal: {0}"
#~ msgstr "Ungültiges Format für BigDecimal: {0}"
#, fuzzy
#~ msgid "Bad float: {0}"
#~ msgstr "Ungültiges Format für Float: {0}"
#, fuzzy
#~ msgid "Bad double: {0}"
#~ msgstr "Ungültiges Format für Double: {0}"
#, fuzzy
#~ msgid "Bad date: {0}"
#~ msgstr "Ungültiges Format für Byte: {0}"
postgresql-jdbc-9.2-1002.src/org/postgresql/translation/messages_bg.class 0000664 0000000 0000000 00000115234 12050675701 0026504 0 ustar 00root root 0000000 0000000 -
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ table Ljava/util/Hashtable; ()V Code LineNumberTable handleGetObject &(Ljava/lang/String;)Ljava/lang/Object;
Exceptions getKeys ()Ljava/util/Enumeration; getParent ()Ljava/util/ResourceBundle;
SourceFile messages_bg.java java/util/Hashtable uProject-Id-Version: JDBC Driver for PostgreSQL 8.x
Report-Msgid-Bugs-To:
POT-Creation-Date: 2012-09-10 19:32-0400
PO-Revision-Date: 2009-12-28 00:01+0100
Last-Translator:
Language-Team:
Language:
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
X-Poedit-Language: Bulgarian
X-Poedit-Country: BULGARIA
;Error loading default settings from driverconfig.properties Грешка при зареждане на настройките по подразбиране от файла driverconfig.properties Your security policy has prevented the connection from being attempted. You probably need to grant the connect java.net.SocketPermission to the database server host and port that you wish to connect to.OВръзката не бе осъществена, поради вашите настройки за сигурност. Може би трябва да предоставите java.net.SocketPermission права на сървъра и порта с базата данни, към който искате да се свържете. XSomething unusual has occured to cause the driver to fail. Please report this exception. Възникна неочаквана грешка с драйвъра. Моля докадвайте това изключение. Connection attempt timed out. cВремето за осъществяване на връзката изтече (таймаут). (Interrupted while attempting to connect. oОпита за осъществяване на връзка бе своевременно прекъснат. "Method {0} is not yet implemented. BМетодът {0} все още не е функционален. Requested CopyIn but got {0} 1Зададено CopyIn но получено {0} Requested CopyOut but got {0} 2Зададено CopyOut но получено {0} !Copying from database failed: {0} NКопирането от базата данни бе неуспешно: {0} This copy stream is closed. KПотока за копиране на данните е затворен. Read from copy failed. 4Четене от копието неуспешно. (Cannot write to copy a byte of value {0} \Няма пишещи права, за да копира байтова стойност {0} @A connection could not be made using the requested protocol {0}. kНе може да осъществи връзка, ползвайки искания протокол {0}. EPremature end of input stream, expected {0} bytes, but only read {1}. Преждевременен край на входящ поток на данни, очаквани {0} байта, но прочетени само {1}. %Expected an EOF from server, got: {0} WОчакван край на файла от сървъра, но получено: {0} -An unexpected result was returned by a query. @Заявката върна неочакван резултат. JIllegal UTF-8 sequence: byte {0} of {1} byte sequence is not 10xxxxxx: {2} Невалидна UTF-8 последователност: байта {0} от байтова последователност {1} не е 10xxxxxx: {2} FIllegal UTF-8 sequence: {0} bytes used to encode a {1} byte value: {2} Невалидна UTF-8 последователност: {0} байта използвани за кодирането на {1} байтова стойност: {2} 0Illegal UTF-8 sequence: initial byte is {0}: {1} hНевалидна UTF-8 последователност: първоначален байт е {0}: {1} 8Illegal UTF-8 sequence: final value is out of range: {0} Невалидна UTF-8 последователност: крайната стойност е извън стойностните граници: {0} =Illegal UTF-8 sequence: final value is a surrogate value: {0} Невалидна UTF-8 последователност: крайната стойност е заместителна стойност: {0} .Zero bytes may not occur in string parameters. OНе може да има нула байта в низ параметрите. (Zero bytes may not occur in identifiers. RНе може да има нула байта в идентификаторите. -Cannot convert an instance of {0} to type {1} ]Не може да преобразува инстанцията на {0} във вида {1} yConnection refused. Check that the hostname and port are correct and that the postmaster is accepting TCP/IP connections. Връзката отказана. Проверете дали името на хоста и порта са верни и дали postmaster приема ТСР / IP връзки. The connection attempt failed. 5Опита за връзка бе неуспешен. The server does not support SSL. +Сървърът не поддържа SSL. 5An error occured while setting up the SSL connection. ZВъзникна грешка при осъществяване на SSL връзката. Connection rejected: {0}. 'Връзката отказана: {0}. QThe server requested password-based authentication, but no password was provided. {Сървърът изисква идентифициране с парола, но парола не бе въведена. The authentication type {0} is not supported. Check that you have configured the pg_hba.conf file to include the client''s IP address or subnet, and that it is using an authentication scheme supported by the driver.kТип на удостоверяване {0} не се поддържа. Проверете дали сте конфигурирали pg_hba.conf файла, да включва IP адреса на клиента или подмрежата, и че се използва схема за удостоверяване, поддържана от драйвъра. &Protocol error. Session setup failed. ^Грешка в протокола. Неуспешна настройка на сесията. Backend start-up failed: {0}. HНеуспешен опит за стартиране на backend: {0}. >The column index is out of range: {0}, number of columns: {1}. xИндексът на колоната е извън стойностен обхват: {0}, брой колони: {1}. %No value specified for parameter {0}. LНяма стойност, определена за параметър {0}. 'Expected command status BEGIN, got {0}. <Очаквана команда BEGIN, получена {0}. Unexpected command status: {0}. 9Неочакван статус на команда: {0}. 2An I/O error occured while sending to the backend. RВходно/изходна грешка при изпращане към backend. Unknown Response Type {0}. 4Неизвестен тип на отговор {0}. +Ran out of memory retrieving query results. tНедостатъчна памет при представяна на резултатите от заявката. DUnable to interpret the update count in command completion tag: {0}. Не може да осъществи актуализация на брояча при командно допълнение: {0}. +Copy not implemented for protocol version 2 [Копирането не е възможно при версия 2 на протокола 'CommandComplete expected COPY but got: SОчаквано командно допълнение COPY но получено: -Tried to obtain lock while already holding it {Опит за получаване на заключване/резервация докато вече е получено *Tried to break lock on database connection Опит за премахване на заключването/резервацията при връзка към базата данни ?Interrupted while waiting to obtain lock on database connection Прекъсване при чакане да получи заключване/резервация при връзка към базата данни .Unable to bind parameter values for statement. SНе може да подготви параметрите на командата. -Database connection failed when starting copy zНеосъществена връзка към базата данни при започване на копирането *Tried to cancel an inactive copy operation KОпит за прекъсване на неактивно копиране 8Database connection failed when canceling copy operation |Неосъществена връзка към базата данни при прекъсване на копирането 6Missing expected error response to copy cancel request iЛипсва очакван отговор при грешка да прекъсне копирането 5Got {0} error responses to single copy cancel request Получени {0} отговори за грешка при единствено искане да се прекъсне копирането Tried to end inactive copy +Database connection failed when ending copy |Неосъществена връзка към базата данни при завършване на копирането ,Tried to write to an inactive copy operation [Опит за писане при неактивна операция за копиране /Database connection failed when writing to copy lНеосъществена връзка към базата данни при опит за копиране Tried to read from inactive copy EОпит за четене при неактивно копиране 1Database connection failed when reading from copy jНеосъществена връзка към базата данни при четене от копие AReceived CommandComplete ''{0}'' without an active copy operation yПолучено командно допълнение ''{0}'' без активна команда за копиране 3Got CopyInResponse from server during an active {0} ZПолучен CopyInResponse отговор от сървъра при активно {0} 4Got CopyOutResponse from server during an active {0} [Получен CopyOutResponse отговор от сървъра при активно {0} -Got CopyData without an active copy operation jПолучено CopyData без наличие на активна операция за копиране 'Unexpected copydata from server for {0} :Неочаквано CopyData от сървъра за {0} 'Unexpected packet type during copy: {0} AНеочакван тип пакет при копиране: {0} Bind message length {0} too long. This can be caused by very large or incorrect length specifications on InputStream parameters.Прекалено голяма дължина {0} на съобщението. Това може да е причинено от прекалено голяма или неправилно зададена дължина на InputStream параметри. The server''s DateStyle parameter was changed to {0}. The JDBC driver requires DateStyle to begin with ISO for correct operation. Параметърът DateStyle при сървъра бе променен на {0}. JDBC драйвъра изисква DateStyle започва с ISO за да функционира правилно. lThe server''s standard_conforming_strings parameter was reported as {0}. The JDBC driver expected on or off. Параметърът standard_conforming_strings при сървъра бе докладван като {0}. JDBC драйвъра очаква този параметър да бъде on или off. 6The driver currently does not support COPY operations. OЗа момента драйвъра не поддържа COPY команди. .This PooledConnection has already been closed. JТази PooledConnection връзка бе вече прекъсната. Connection has been closed automatically because a new connection was opened for the same PooledConnection or the PooledConnection has been closed. Връзката бе автоматично прекъсната, защото нова връзка за същата беше осъществена или PooledConnection връзката е вече прекъсната. Connection has been closed. +Връзката бе прекъсната. Statement has been closed. )Командата е завършена. DataSource has been closed. ;Източникът на данни е прекъснат. FFastpath call {0} - No result was returned and we expected an integer. jИзвикване на {0} - няма резултати и а бе очаквано цяло число. %The fastpath function {0} is unknown. /Функцията {0} е неизвестна. #Conversion to type {0} failed: {1}. EНеуспешно преобразуване към тип {0}: {1}. +Cannot tell if path is open or closed: {0}. iНе може да определи дали адреса е отворен или затворен: {0}. GSS Authentication failed The array index is out of range: {0}, number of elements: {1}. cИндексът на масив е извън обхвата: {0}, брой елементи: {1}. Invalid character data was found. This is most likely caused by stored data containing characters that are invalid for the character set the database was created in. The most common example of this is storing 8bit data in a SQL_ASCII database.Бяха намерени невалидни данни. Това най-вероятно се дължи на съхранявани данни, съдържащи символи, които са невалидни за набора от знаци при създаване на базата данни. Чест пример за това е съхраняване на 8bit данни в SQL_ASCII бази данни. ITruncation of large objects is only implemented in 8.3 and later servers. zСкъсяване на големи обекти LOB е осъществено само във версии след 8.3. &PostgreSQL LOBs can only index to: {0} NPostgreSQL индексира големи обекти LOB само до: {0} #LOB positioning offsets start at 1. cПозиционалният офсет при големи обекти LOB започва от 1. (free() was called on this LOB previously `Функцията free() бе вече извикана за този голям обект LOB /Unsupported value for stringtype parameter: {0} OНепозволена стойност за StringType параметър: {0} 0unknownLength parameter value must be an integer kСтойността на параметъра unknownLength трябва да бъде цяло число &No results were returned by the query. CНяма намерени резултати за заявката. -A result was returned when none was expected. WБе получен резултат, когато такъв не бе очакван. #Custom type maps are not supported. XСпецифични типови съответствия не се поддържат. !Failed to create object for: {0}. @Неуспешно създаване на обект за: {0}. =Unable to load the class {0} responsible for the datatype {1} qНевъзможно е зареждането на клас {0}, отговарящ за типа данни {1} LCannot change transaction read-only property in the middle of a transaction. Не може да променяте правата на транзакцията по време на нейното извършване. ICannot change transaction isolation level in the middle of a transaction. Не може да променяте изолационното ниво на транзакцията по време на нейното извършване. .Transaction isolation level {0} not supported. ]Изолационно ниво на транзакциите {0} не се поддържа. .Finalizing a Connection that was never closed: TПриключване на връзка, която не бе прекъсната: 3Unable to translate data into the desired encoding. eНевъзможно преобразуване на данни в желаното кодиране. PUnable to determine a value for MaxIndexKeys due to missing system catalog data. Невъзможно е да се определи стойността за MaxIndexKeys поради липса на системния каталог с данни. 4Unable to find name datatype in the system catalogs. rНе може да се намери името на типа данни в системните каталози. NOperation requires a scrollable ResultSet, but this ResultSet is FORWARD_ONLY. yОперацията изисква резултатите да са scrollable, но този ResultSet е FORWARD_ONLY. CUnexpected error while decoding character data from a large object. uНеочаквана грешка при декодиране на символите от голям обект LOB. 9Can''t use relative move methods while on the insert row. Не може да се използват относителни методи за движение, когато се намираме при редицата на въвеждане. &Invalid fetch direction constant: {0}. GНевалидна константа за fetch посоката: {0}. 6Cannot call cancelRowUpdates() when on the insert row. Не може да се изпълни cancelRowUpdates() метода, когато се намираме при редицата на въвеждане. /Cannot call deleteRow() when on the insert row. Не може да се изпълни deleteRow() метода, когато се намираме при редицата на въвеждане. ZCurrently positioned before the start of the ResultSet. You cannot call deleteRow() here. В момента се намираме в началото на ResultSet. Тук не може да се изпълни deleteRow() метода. WCurrently positioned after the end of the ResultSet. You cannot call deleteRow() here. В момента се намираме преди края на ResultSet. Тук не може да се изпълни deleteRow() метода. $There are no rows in this ResultSet. ,В този ResultSet няма редове. Not on the insert row. 8Не сме в редицата на въвеждане. ;You must specify at least one column value to insert a row. {Трябва да посочите поне една стойност за колона, за да вмъкнете ред. /The JVM claims not to support the encoding: {0} WJVM не поддържа тази кодова таблица за момента: {0} Provided InputStream failed. @Зададения InputStream поток е неуспешен. Provided Reader failed. .Грешка с ползвания четец. Can''t refresh the insert row. :Не може да обнови въведения ред. /Cannot call updateRow() when on the insert row. Не може да се изпълни updateRow() метода, когато се намираме при редицата на въвеждане. bCannot update the ResultSet because it is either before the start or after the end of the results. Не може да се обнови ResultSet, когато се намираме преди началото или след края на резултатите. ?ResultSets with concurrency CONCUR_READ_ONLY cannot be updated. fResultSets с concurrency CONCUR_READ_ONLY не могат да бъдат актуализирани. #No primary key found for table {0}. ;Няма първичен ключ за таблица {0}. 4Fetch size must be a value greater to or equal to 0. cРазмера за fetch size трябва да бъде по-голям или равен на 0. Bad value for type {0} : {1} 9Невалидна стойност за тип {0} : {1} 4The column name {0} was not found in this ResultSet. VИмето на колоната {0} не бе намерено в този ResultSet. ResultSet is not updateable. The query that generated this result set must select only one table, and must select all primary keys from that table. See the JDBC 2.1 API Specification, section 5.6 for more details.eResultSet не може да се обновява. Заявката генерираща този резултат трябва да селектира само една таблица, както и всички първични ключове в нея. За повече информация, вижте раздел 5.6 на JDBC 2.1 API Specification. This ResultSet is closed. PОперациите по този ResultSet са били прекратени. AResultSet not positioned properly, perhaps you need to call next. ResultSet не е референциран правилно. Вероятно трябва да придвижите курсора посредством next. ICan''t use query methods that take a query string on a PreparedStatement. Не може да се употребяват методи за заявка, които ползват низове на PreparedStatement. /Multiple ResultSets were returned by the query. 6Заявката върна няколко ResultSets. 7A CallableStatement was executed with nothing returned. ]CallableStatement функция бе обработена, но няма резултати. EA CallableStatement was executed with an invalid number of parameters uCallableStatement функция бе обработена, но с непозволен брой параметри. tA CallableStatement function was executed and the out parameter {0} was of type {1} however type {2} was registered. CallableStatement функция бе обработена и изходния параметър {0} бе от тип {1}, обаче тип {2} бе използван. AMaximum number of rows must be a value grater than or equal to 0. Максималният брой редове трябва да бъде стойност по-голяма или равна на 0. :Query timeout must be a value greater than or equals to 0. Времето за изпълнение на заявката трябва да бъде стойност по-голяма или равна на 0. BThe maximum field size must be a value greater than or equal to 0. Максималният размер на полето трябва да бъде стойност по-голяма или равна на 0. Unknown Types value. 2Стойност от неизвестен тип. Invalid stream length {0}. CНевалидна дължина {0} на потока данни. /The JVM claims not to support the {0} encoding. RJVM не поддържа за момента {0} кодовата таблица. Unknown type {0}. Неизвестен тип {0}. *Cannot cast an instance of {0} to type {1} WНе може да преобразува инстанция на {0} към тип {1} Unsupported Types value: {0} :Неподдържана стойност за тип: {0} Can''t infer the SQL type to use for an instance of {0}. Use setObject() with an explicit Types value to specify the type to use. Не може да се определи SQL тип, който да се използва за инстанцията на {0}. Ползвайте метода setObject() с точни стойности, за да определите типа. ZThis statement does not declare an OUT parameter. Use '{' ?= call ... '}' to declare one. Тази заявка не декларира изходен параметър. Ползвайте '{' ?= call ... '}' за да декларирате такъв. 0wasNull cannot be call before fetching a result. lwasNull не може да бьде изпълнен, преди наличието на резултата. ) was made. CallableStatement функция бе декларирана, но обработена като registerOutParameter(1, ) $No function outputs were registered. RРезултати от функцията не бяха регистрирани. KResults cannot be retrieved from a CallableStatement before it is executed. Резултати от CallableStatement функция не могат да бъдат получени, преди тя да бъде обработена. This statement has been closed. )Командата е извършена. &Too many update results were returned. iТвърде много резултати бяха получени при актуализацията. IBatch entry {0} {1} was aborted. Call getNextException to see the cause. Партида {0} {1} беше прекратена. Изпълнете функция getNextException за да видите причината. 2Unexpected error writing large object to database. vНеочаквана грешка при записване на голям обект LOB в базата данни. -{0} function takes one and only one argument. hФункцията {0} може да приеме само един единствен аргумент. .{0} function takes two and only two arguments. _Функцията {0} може да приеме два и само два аргумента. /{0} function takes four and only four argument. kФункцията {0} може да приеме четири и само четири аргумента. *{0} function takes two or three arguments. ZФункцията {0} може да приеме два или три аргумента. ({0} function doesn''t take any argument. JФункцията {0} не може да приема аргументи. 2{0} function takes three and only three arguments. _Функцията {0} може да приеме три и само три аргумента. Interval {0} not yet implemented >Интервалът {0} не е валиден все още. LInfinite value found for timestamp/date. This cannot be represented as time. Безкрайна стойност за време или дата. Не може да бъде представена като времева стойност. >The class {0} does not implement org.postgresql.util.PGobject. BКлас {0} не изпълнява org.postgresql.util.PGobject. +Unknown ResultSet holdability setting: {0}. CНеизвестна ResultSet holdability настройка: {0}. 7Server versions prior to 8.0 do not support savepoints. LСървър версии преди 8.0 не поддържат savepoints. 1Cannot establish a savepoint in auto-commit mode. MНе може да се установи savepoint в auto-commit модус. .Returning autogenerated keys is not supported. XАвтоматично генерирани ключове не се поддържат. DThe parameter index is out of range: {0}, number of parameters: {1}. jПараметърният индекс е извън обхват: {0}, брой параметри: {1}. IReturning autogenerated keys is only supported for 8.2 and later servers. Автоматично генерирани ключове се поддържат за версии на сървъра след 8.2. >Returning autogenerated keys by column index is not supported. Автоматично генерирани ключове спрямо индекс на колона не се поддържат. 8Cannot reference a savepoint after it has been released. hНе може да референцира savepoint, след като е била освободена. ,Cannot retrieve the id of a named savepoint. IНе може да определи ID на спомената savepoint. 1Cannot retrieve the name of an unnamed savepoint. UНе може да определи името на неупомената savepoint. Invalid UUID data. #Невалидни UUID данни. 7Unable to find server array type for provided name {0}. tНе може да се намери типа на сървърен масив за зададеното име {0}. "ClientInfo property not supported. DИнформацията за ClientInfo не се поддържа. Unable to decode xml data. 7Не може да декодира XML данните. Unknown XML Source class: {0} 3Неизвестен XML входящ клас: {0} &Unable to create SAXResult for SQLXML. =Не може да се създаде SAXResult за SQLXML. &Unable to create StAXResult for SQLXML >Не може да се създаде StAXResult за SQLXML. Unknown XML Result class: {0} 5Неизвестен XML изходящ клас: {0} *This SQLXML object has already been freed. :Този SQLXML обект вече е освободен. QThis SQLXML object has not been initialized, so you cannot retrieve data from it. Този SQLXML обект не е инициализиран, така че не могат да се извличат данни от него. 3Failed to convert binary xml data to encoding: {0}. }Неуспешно преобразуване на двоични XML данни за кодиране съгласно: {0}. 4Unable to convert DOMResult SQLXML data to a string. PНе може да преобразува DOMResult SQLXML данни в низ. UThis SQLXML object has already been initialized, so you cannot manipulate it further. rТози SQLXML обект вече е инициализиран и не може да бъде променен. $Failed to initialize LargeObject API ;Не може да инициализира LargeObject API 2Large Objects may not be used in auto-commit mode. eГолеми обекти LOB не могат да се използват в auto-commit модус. BThe SSLSocketFactory class provided {0} could not be instantiated. eКласът SSLSocketFactory връща {0} и не може да бъде инстанцииран. Conversion of interval failed CНеуспешно преобразуване на интервал Conversion of money failed. =Неуспешно валутно преобразуване. Detail: {0} Подробност: {0} Hint: {0} Забележка: {0}
Position: {0} Позиция: {0}
Where: {0} Където: {0} Internal Query: {0} "Вътрешна заявка: {0} Internal Position: {0} $Вътрешна позиция: {0} ,Location: File: {0}, Routine: {1}, Line: {2} MМестоположение: Файл: {0}, Функция: {1}, Ред: {2} Server SQLState: {0} )SQL статус на сървъра: {0}
Invalid flags !Невалидни флагове xid must not be null $xid не може да бъде null +Connection is busy with another transaction AВръзката е заета с друга транзакция suspend/resume not implemented Rспиране / започване не се поддържа за момента (Transaction interleaving not implemented [Транзакция в транзакция не се поддържа за момента Error disabling autocommit 8Грешка при изключване на autocommit 2tried to call end without corresponding start call `опита да извика end без съответстващо извикване на start ^Not implemented: Prepare must be issued using the same connection that started the transaction Невъзможна комбинация: Prepare трябва да бъде издадено чрез използване на същата връзка, при която е започната транзакцията Prepare called before end ,Prepare извикано преди края =Server versions prior to 8.1 do not support two-phase commit. ZСървър версии преди 8.1 не поддържат дву-фазов commit. Error preparing transaction BГрешка при подготвяне на транзакция Invalid flag Невалиден флаг Error during recover 0Грешка при възстановяване 'Error rolling back prepared transaction Грешка при възстановяване на състоянието преди подготвена транзакция dNot implemented: one-phase commit must be issued using the same connection that was used to start it Невъзможна комбинация: едно-фазов commit трябва да бъде издаден чрез използване на същата връзка, при която е започнал commit called before end $commit извикан преди end Error during one-phase commit .Грешка при едно-фазов commit INot implemented: 2nd phase commit must be issued using an idle connection Невъзможна комбинация: втората фаза на commit задължително трябва да бъде издадена при свободна връзка 'Heuristic commit/rollback not supported FЕвристичен commit или rollback не се поддържа &org/postgresql/translation/messages_bg java/util/ResourceBundle "java/util/MissingResourceException get &(Ljava/lang/Object;)Ljava/lang/Object; keys parent Ljava/util/ResourceBundle; put 8(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object; ! * + * R Y K*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*!"
W*#$
W*%&
W*'(
W*)*
W*+,
W*-.
W*/0
W*12
W*34
W*56
W*78
W*9:
W*;<
W*=>
W*?@
W*AB
W*CD
W*EF
W*GH
W*IJ
W*KL
W*MN
W*OP
W*QR
W*ST
W*UV
W*WX
W*YZ
W*[\
W*]^
W*_`
W*ab
W*cd
W*ef
W*gh
W*ij
W*kl
W*mn
W*op
W*qr
W*sl
W*tu
W*vw
W*xy
W*z{
W*|}
W*~
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*ö
W*Ŷ
W*Ƕ
W*ɶ
W*˶
W*Ͷ
W*϶
W*Ѷ
W*Ӷ
W*ն
W*
W*ٶ
W*۶
W*ݶ
W*߶
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W* !
W*"#
W*$%
W*&'
W*()
W**+
W*,-
W*./
W*01
W*23
W*45
W*67
W*89
W*:;
W*<=
W*>?
W*@A
W*BC
W*DE
W*FG
W*HI
W*JK
W*LM
W*NO
W*PQ
W*RS
W*TU
W*VW
W*XY
W*Z[
W*\]
W*^_
W*`a
W*bc
W*de
W*fg
W*hi
W*jk
W*lm
W*no
W*pq
W*rs
W*tu
W*vw
W*xy
W*z{
W*|}
W*~
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W* j #
, 5 >
G P Y b k t } ! " #
$ % &( '1 (: )C *L +U ,^ -g .p /y 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B$ C- D6 E? FH GQ HZ Ic Jl Ku L~ M N O P Q R S T U V W X Y Z [ \ ] ^ _) `2 a; bD cM dV e_ fh gq hz i j k l m n o p q r s t u v w x
y z {% |. }7 ~@ I R [ d o z * 5 @ K V a l w ' 2 = H S ^ i t $ / : E P [ f q | ! , 7 B M Q postgresql-jdbc-9.2-1002.src/org/postgresql/translation/messages_cs.class 0000664 0000000 0000000 00000031352 12050675701 0026517 0 ustar 00root root 0000000 0000000 -
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ table Ljava/util/Hashtable; ()V Code LineNumberTable handleGetObject &(Ljava/lang/String;)Ljava/lang/Object;
Exceptions getKeys ()Ljava/util/Enumeration; getParent ()Ljava/util/ResourceBundle;
SourceFile messages_cs.java java/util/Hashtable >Project-Id-Version: PostgreSQL JDBC Driver 8.0
Report-Msgid-Bugs-To:
POT-Creation-Date: 2012-09-10 19:32-0400
PO-Revision-Date: 2005-08-21 20:00+0200
Last-Translator: Petr Dittrich
Language-Team:
Language:
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
;Error loading default settings from driverconfig.properties EChyba načítání standardního nastavení z driverconfig.properties XSomething unusual has occured to cause the driver to fail. Please report this exception. NNěco neobvyklého přinutilo ovladač selhat. Prosím nahlaste tuto vyjímku. "Method {0} is not yet implemented. !Metoda {0} není implementována. @A connection could not be made using the requested protocol {0}. @Spojení nelze vytvořit s použitím žádaného protokolu {0}. -An unexpected result was returned by a query. )Obdržen neočekávaný výsledek dotazu. yConnection refused. Check that the hostname and port are correct and that the postmaster is accepting TCP/IP connections. sSpojení odmítnuto. Zkontrolujte zda je jméno hosta a port správné a zda postmaster přijímá TCP/IP spojení. The connection attempt failed. Pokus o připojení selhal. The server does not support SSL. Server nepodporuje SSL. 5An error occured while setting up the SSL connection. +Nastala chyba při nastavení SSL spojení. Connection rejected: {0}. Spojení odmítnuto: {0}. QThe server requested password-based authentication, but no password was provided. AServer vyžaduje ověření heslem, ale žádné nebylo posláno. The authentication type {0} is not supported. Check that you have configured the pg_hba.conf file to include the client''s IP address or subnet, and that it is using an authentication scheme supported by the driver. Ověření typu {0} není podporováno. Zkontrolujte zda konfigurační soubor pg_hba.conf obsahuje klientskou IP adresu či podsíť a zda je použité ověřenovací schéma podporováno ovladačem. &Protocol error. Session setup failed. +Chyba protokolu. Nastavení relace selhalo. Backend start-up failed: {0}. Selhal start backendu: {0}. >The column index is out of range: {0}, number of columns: {1}. 9Index sloupece je mimo rozsah: {0}, počet sloupců: {1}. %No value specified for parameter {0}. 'Nespecifikována hodnota parametru {0}. 'Expected command status BEGIN, got {0}. )Očekáván příkaz BEGIN, obdržen {0}. Unexpected command status: {0}. #Neočekávaný stav příkazu: {0}. 2An I/O error occured while sending to the backend. 7Vystupně/výstupní chyba při odesílání k backend. Unknown Response Type {0}. Neznámý typ odpovědi {0}. 6The driver currently does not support COPY operations. )Ovladač nyní nepodporuje příkaz COPY. .This PooledConnection has already been closed. $Tento PooledConnection byl uzavřen. Connection has been closed. Spojeni bylo uzavřeno. Statement has been closed. Statement byl uzavřen. DataSource has been closed. DataSource byl uzavřen. $The array index is out of range: {0} Index pole mimo rozsah: {0} >The array index is out of range: {0}, number of elements: {1}. 0Index pole mimo rozsah: {0}, počet prvků: {1}. Invalid character data was found. This is most likely caused by stored data containing characters that are invalid for the character set the database was created in. The most common example of this is storing 8bit data in a SQL_ASCII database.Nalezena vada ve znakových datech. Toto může být způsobeno uloženými daty obsahujícími znaky, které jsou závadné pro znakovou sadu nastavenou při zakládání databáze. Nejznámejší příklad je ukládání 8bitových dat vSQL_ASCII databázi. #LOB positioning offsets start at 1. )Začátek pozicování LOB začína na 1. &No results were returned by the query. %Neobdržen žádný výsledek dotazu. -A result was returned when none was expected. 6Obdržen výsledek, ikdyž žádný nebyl očekáván. !Failed to create object for: {0}. !Selhalo vytvoření objektu: {0}. =Unable to load the class {0} responsible for the datatype {1} 2Nemohu načíst třídu {0} odpovědnou za typ {1} 3Unable to translate data into the desired encoding. 5Nemohu přeložit data do požadovaného kódování. 4Unable to find name datatype in the system catalogs. 2Nemohu najít název typu v systémovém katalogu. CUnexpected error while decoding character data from a large object. CNeočekávaná chyba běham dekódování znaku z velkého objektu. 9Can''t use relative move methods while on the insert row. CNemůžete používat relativní přesuny při vkládání řádku. &Invalid fetch direction constant: {0}. Špatný směr čtení: {0}. 6Cannot call cancelRowUpdates() when on the insert row. =Nemůžete volat cancelRowUpdates() při vkládání řádku. /Cannot call deleteRow() when on the insert row. 6Nemůžete volat deleteRow() při vkládání řádku. WCurrently positioned after the end of the ResultSet. You cannot call deleteRow() here. LPrávě jste za pozicí konce ResultSetu. Zde nemůžete volat deleteRow().s $There are no rows in this ResultSet. Žádný řádek v ResultSet. Not on the insert row. Ne na vkládaném řádku. ;You must specify at least one column value to insert a row. =Musíte vyplnit alespoň jeden sloupec pro vložení řádku. /The JVM claims not to support the encoding: {0} +JVM tvrdí, že nepodporuje kodování: {0} Provided InputStream failed. Selhal poskytnutý InputStream. Provided Reader failed. Selhal poskytnutý Reader. Can''t refresh the insert row. "Nemohu obnovit vkládaný řádek. /Cannot call updateRow() when on the insert row. 0Nemohu volat updateRow() na vlkádaném řádku. ?ResultSets with concurrency CONCUR_READ_ONLY cannot be updated. JResultSets se souběžností CONCUR_READ_ONLY nemůže být aktualizováno #No primary key found for table {0}. ,Nenalezen primární klíč pro tabulku {0}. 4Fetch size must be a value greater to or equal to 0. )Nabraná velikost musí být nezáporná. Bad value for type {0} : {1} "Špatná hodnota pro typ {0} : {1} 4The column name {0} was not found in this ResultSet. 3Sloupec pojmenovaný {0} nebyl nalezen v ResultSet. ResultSet is not updateable. The query that generated this result set must select only one table, and must select all primary keys from that table. See the JDBC 2.1 API Specification, section 5.6 for more details. ResultSet není aktualizavatelný. Dotaz musí vybírat pouze z jedné tabulky a musí obsahovat všechny primární klíče tabulky. Koukni do JDBC 2.1 API Specifikace, sekce 5.6 pro více podrobností. This ResultSet is closed. Tento ResultSet je uzavřený. /Multiple ResultSets were returned by the query. -Vícenásobný ResultSet byl vrácen dotazem. 7A CallableStatement was executed with nothing returned. :CallableStatement byl spuštěn, leč nic nebylo vráceno. AMaximum number of rows must be a value grater than or equal to 0. :Maximální počet řádek musí být nezáporné číslo. :Query timeout must be a value greater than or equals to 0. 5Časový limit dotazu musí být nezáporné číslo. BThe maximum field size must be a value greater than or equal to 0. 9Maximální velikost pole musí být nezáporné číslo. Unknown Types value. Neznámá hodnota typu. Invalid stream length {0}. Vadná délka proudu {0}. /The JVM claims not to support the {0} encoding. +JVM tvrdí, že nepodporuje kodování {0}. Unknown type {0}. Neznámý typ {0}. *Cannot cast an instance of {0} to type {1} *Nemohu přetypovat instanci {0} na typ {1} Unsupported Types value: {0} Nepodporovaná hodnota typu: {0} The class {0} does not implement org.postgresql.util.PGobject. 5Třída {0} nepodporuje org.postgresql.util.PGobject. 7Server versions prior to 8.0 do not support savepoints. 8Verze serveru nižší než 8.0 nepodporují savepoints. 1Cannot establish a savepoint in auto-commit mode. .Nemohu vytvořit savepoint v auto-commit modu. .Returning autogenerated keys is not supported. @Vrácení automaticky generovaných klíčů není podporováno. DThe parameter index is out of range: {0}, number of parameters: {1}. 8Index parametru mimo rozsah: {0}, počet parametrů {1}. 8Cannot reference a savepoint after it has been released. 6Nemohu získat odkaz na savepoint, když byl uvolněn. ,Cannot retrieve the id of a named savepoint. .Nemohu získat id nepojmenovaného savepointu. 1Cannot retrieve the name of an unnamed savepoint. 2Nemohu získat název nepojmenovaného savepointu. $Failed to initialize LargeObject API $Selhala inicializace LargeObject API 2Large Objects may not be used in auto-commit mode. 8Velké objecky nemohou být použity v auto-commit modu. BThe SSLSocketFactory class provided {0} could not be instantiated. LTřída SSLSocketFactory poskytla {0} což nemůže být instancionizováno. Conversion of money failed. Převod peněz selhal. Detail: {0} Hint: {0} Rada: {0}
Position: {0} Pozice: {0}
Where: {0} Kde: {0} ,Location: File: {0}, Routine: {1}, Line: {2} .Poloha: Soubor: {0}, Rutina: {1}, Řádek: {2} Server SQLState: {0} &org/postgresql/translation/messages_cs java/util/ResourceBundle "java/util/MissingResourceException get &(Ljava/lang/Object;)Ljava/lang/Object; keys parent Ljava/util/ResourceBundle; put 8(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object; ! * + j m * p
m Y K*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*!"
W*#$
W*%&
W*'(
W*)*
W*+,
W*-.
W*/0
W*12
W*34
W*56
W*78
W*9:
W*;<
W*=>
W*?@
W*AB
W*CD
W*EF
W*GH
W*IJ
W*KL
W*MN
W*OP
W*QR
W*ST
W*UV
W*WX
W*YZ
W*[\
W*]^
W*_`
W*ab
W*cd
W*ef
W*gh
W*ij
W*kl
W*mn
W*op
W*qr
W*st
W*uv
W*wx
W*yz
W*{|
W*}~
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*ö
W*Ŷ
W*ƶ
W* c #
, 5 >
G P Y b k t } ! " #
$ % &( '1 (: )C *L +U ,^ -g .p /y 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B$ C- D6 E? FH GQ HZ Ic Jl Ku L~ M N O P Q R S T U V W X Y Z [ \ ] ^ _) `2 a; bD cM dV e_ fh gl h postgresql-jdbc-9.2-1002.src/org/postgresql/translation/messages_de.class 0000664 0000000 0000000 00000062377 12050675701 0026515 0 ustar 00root root 0000000 0000000 -
Tf Sg
h
i Tjk
flm
nopqrstuvwxyz{|}~
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ table Ljava/util/Hashtable; ()V Code LineNumberTable handleGetObject &(Ljava/lang/String;)Ljava/lang/Object;
Exceptions getKeys ()Ljava/util/Enumeration; getParent ()Ljava/util/ResourceBundle;
SourceFile messages_de.java WX UV ` java/util/Hashtable Project-Id-Version: head-de
Report-Msgid-Bugs-To:
POT-Creation-Date: 2012-09-10 19:32-0400
PO-Revision-Date: 2008-09-12 14:22+0200
Last-Translator: Andre Bialojahn
Language-Team: Deutsch
Language:
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
X-Generator: KBabel 1.0.2
X-Poedit-Language: German
X-Poedit-Country: GERMANY
;Error loading default settings from driverconfig.properties BFehler beim Laden der Voreinstellungen aus driverconfig.properties Your security policy has prevented the connection from being attempted. You probably need to grant the connect java.net.SocketPermission to the database server host and port that you wish to connect to. Ihre Sicherheitsrichtlinie hat den Versuch des Verbindungsaufbaus verhindert. Sie müssen wahrscheinlich der Verbindung zum Datenbankrechner java.net.SocketPermission gewähren, um den Rechner auf dem gewählten Port zu erreichen. XSomething unusual has occured to cause the driver to fail. Please report this exception. kEtwas Ungewöhnliches ist passiert, das den Treiber fehlschlagen ließ. Bitte teilen Sie diesen Fehler mit. Connection attempt timed out. 7Keine Verbindung innerhalb des Zeitintervalls möglich. (Interrupted while attempting to connect. 4Beim Verbindungsversuch trat eine Unterbrechung auf. "Method {0} is not yet implemented. -Die Methode {0} ist noch nicht implementiert. @A connection could not be made using the requested protocol {0}. REs konnte keine Verbindung unter Verwendung des Protokolls {0} hergestellt werden. EPremature end of input stream, expected {0} bytes, but only read {1}. ^Vorzeitiges Ende des Eingabedatenstroms. Es wurden {0} Bytes erwartet, jedoch nur {1} gelesen. %Expected an EOF from server, got: {0} 6Vom Server wurde ein EOF erwartet, jedoch {0} gelesen. -An unexpected result was returned by a query. 0Eine Abfrage lieferte ein unerwartetes Resultat. JIllegal UTF-8 sequence: byte {0} of {1} byte sequence is not 10xxxxxx: {2} NUngültige UTF-8-Sequenz: Byte {0} der {1} Bytesequenz ist nicht 10xxxxxx: {2} FIllegal UTF-8 sequence: {0} bytes used to encode a {1} byte value: {2} [Ungültige UTF-8-Sequenz: {0} Bytes wurden verwendet um einen {1} Bytewert zu kodieren: {2} 0Illegal UTF-8 sequence: initial byte is {0}: {1} 5Ungültige UTF-8-Sequenz: das erste Byte ist {0}: {1} 8Illegal UTF-8 sequence: final value is out of range: {0} VUngültige UTF-8-Sequenz: Der letzte Wert ist außerhalb des zulässigen Bereichs: {0} =Illegal UTF-8 sequence: final value is a surrogate value: {0} AUngültige UTF-8-Sequenz: der letzte Wert ist ein Ersatzwert: {0} .Zero bytes may not occur in string parameters. 2Stringparameter dürfen keine Nullbytes enthalten. (Zero bytes may not occur in identifiers. 1Nullbytes dürfen in Bezeichnern nicht vorkommen. -Cannot convert an instance of {0} to type {1} FDie Typwandlung für eine Instanz von {0} nach {1} ist nicht möglich. yConnection refused. Check that the hostname and port are correct and that the postmaster is accepting TCP/IP connections. Verbindung verweigert. Überprüfen Sie die Korrektheit von Hostnamen und der Portnummer und dass der Datenbankserver TCP/IP-Verbindungen annimmt. The connection attempt failed. #Der Verbindungsversuch schlug fehl. The server does not support SSL. "Der Server unterstützt SSL nicht. 5An error occured while setting up the SSL connection. 3Beim Aufbau der SSL-Verbindung trat ein Fehler auf. Connection rejected: {0}. Verbindung abgewiesen: {0}. QThe server requested password-based authentication, but no password was provided. ]Der Server verlangt passwortbasierte Authentifizierung, jedoch wurde kein Passwort angegeben. The authentication type {0} is not supported. Check that you have configured the pg_hba.conf file to include the client''s IP address or subnet, and that it is using an authentication scheme supported by the driver. Der Authentifizierungstyp {0} wird nicht unterstützt. Stellen Sie sicher, dass die Datei ''pg_hba.conf'' die IP-Adresse oder das Subnetz des Clients enthält und dass der Client ein Authentifizierungsschema nutzt, das vom Treiber unterstützt wird. &Protocol error. Session setup failed. The column index is out of range: {0}, number of columns: {1}. PDer Spaltenindex {0} ist außerhalb des gültigen Bereichs. Anzahl Spalten: {1}. %No value specified for parameter {0}. 1Für den Parameter {0} wurde kein Wert angegeben. 'Expected command status BEGIN, got {0}. >Statt des erwarteten Befehlsstatus BEGIN, wurde {0} empfangen. Unexpected command status: {0}. Unerwarteter Befehlsstatus: {0}. 2An I/O error occured while sending to the backend. 6Eingabe/Ausgabe-Fehler {0} beim Senden an das Backend. Unknown Response Type {0}. 1Die Antwort weist einen unbekannten Typ auf: {0}. +Ran out of memory retrieving query results. The array index is out of range: {0}, number of elements: {1}. SDer Arrayindex {0} ist außerhalb des gültigen Bereichs. Vorhandene Elemente: {1}. Invalid character data was found. This is most likely caused by stored data containing characters that are invalid for the character set the database was created in. The most common example of this is storing 8bit data in a SQL_ASCII database. Ungültige Zeichendaten. Das ist höchstwahrscheinlich von in der Datenbank gespeicherten Zeichen hervorgerufen, die in einer anderen Kodierung vorliegen, als die, in der die Datenbank erstellt wurde. Das häufigste Beispiel dafür ist es, 8Bit-Daten in SQL_ASCII-Datenbanken abzulegen. ITruncation of large objects is only implemented in 8.3 and later servers. LDas Abschneiden großer Objekte ist nur in Versionen nach 8.3 implementiert. &PostgreSQL LOBs can only index to: {0} 1LOBs in PostgreSQL können nur auf {0} verweisen. #LOB positioning offsets start at 1. *Positionsoffsets für LOBs beginnen bei 1. (free() was called on this LOB previously 0free() wurde bereits für dieses LOB aufgerufen. /Unsupported value for stringtype parameter: {0} 6Nichtunterstützter Wert für den Stringparameter: {0} &No results were returned by the query. #Die Abfrage lieferte kein Ergebnis. -A result was returned when none was expected. ADie Anweisung lieferte ein Ergebnis obwohl keines erwartet wurde. !Failed to create object for: {0}. .Erstellung des Objektes schlug fehl für: {0}. =Unable to load the class {0} responsible for the datatype {1} QDie für den Datentyp {1} verantwortliche Klasse {0} konnte nicht geladen werden. LCannot change transaction read-only property in the middle of a transaction. bDie Nur-Lesen-Eigenschaft einer Transaktion kann nicht während der Transaktion verändert werden. ICannot change transaction isolation level in the middle of a transaction. XDie Transaktions-Trennungsstufe kann nicht während einer Transaktion verändert werden. .Transaction isolation level {0} not supported. ;Die Transaktions-Trennungsstufe {0} ist nicht unterstützt. .Finalizing a Connection that was never closed: =Eine Connection wurde finalisiert, die nie geschlossen wurde: 3Unable to translate data into the desired encoding. FDie Daten konnten nicht in die gewünschte Kodierung gewandelt werden. PUnable to determine a value for MaxIndexKeys due to missing system catalog data. XEs konnte kein Wert für MaxIndexKeys gefunden werden, da die Systemkatalogdaten fehlen. 4Unable to find name datatype in the system catalogs. GIn den Systemkatalogen konnte der Namensdatentyp nicht gefunden werden. NOperation requires a scrollable ResultSet, but this ResultSet is FORWARD_ONLY. RDie Operation erfordert ein scrollbares ResultSet, dieses jedoch ist FORWARD_ONLY. CUnexpected error while decoding character data from a large object. YEin unerwarteter Fehler trat beim Dekodieren von Zeichen aus einem LargeObject (LOB) auf. 9Can''t use relative move methods while on the insert row. LRelative Bewegungen können in der Einfügezeile nicht durchgeführt werden. &Invalid fetch direction constant: {0}. /Unzulässige Richtungskonstante bei fetch: {0}. 6Cannot call cancelRowUpdates() when on the insert row. I''cancelRowUpdates()'' kann in der Einfügezeile nicht aufgerufen werden. /Cannot call deleteRow() when on the insert row. B''deleteRow()'' kann in der Einfügezeile nicht aufgerufen werden. ZCurrently positioned before the start of the ResultSet. You cannot call deleteRow() here. sDie augenblickliche Position ist vor dem Beginn des ResultSets. Dort kann ''deleteRow()'' nicht aufgerufen werden. WCurrently positioned after the end of the ResultSet. You cannot call deleteRow() here. tDie augenblickliche Position ist hinter dem Ende des ResultSets. Dort kann ''deleteRow()'' nicht aufgerufen werden. $There are no rows in this ResultSet. )Es gibt keine Zeilen in diesem ResultSet. Not on the insert row. Nicht in der Einfügezeile. ;You must specify at least one column value to insert a row. LSie müssen mindestens einen Spaltenwert angeben, um eine Zeile einzufügen. /The JVM claims not to support the encoding: {0} CDie JVM behauptet, die Zeichenkodierung {0} nicht zu unterstützen. Provided InputStream failed. +Der bereitgestellte InputStream scheiterte. Provided Reader failed. &Der bereitgestellte Reader scheiterte. Can''t refresh the insert row. 1Die Einfügezeile kann nicht aufgefrischt werden. /Cannot call updateRow() when on the insert row. B''updateRow()'' kann in der Einfügezeile nicht aufgerufen werden. bCannot update the ResultSet because it is either before the start or after the end of the results. gDas ResultSet kann nicht aktualisiert werden, da es entweder vor oder nach dem Ende der Ergebnisse ist. ?ResultSets with concurrency CONCUR_READ_ONLY cannot be updated. VResultSets, deren Zugriffsart CONCUR_READ_ONLY ist, können nicht aktualisiert werden. #No primary key found for table {0}. CFür die Tabelle {0} konnte kein Primärschlüssel gefunden werden. 4Fetch size must be a value greater to or equal to 0. ?Die Fetch-Größe muss ein Wert größer oder gleich Null sein. Bad value for type {0} : {1} *Unzulässiger Wert für den Typ {0} : {1}. 4The column name {0} was not found in this ResultSet. =Der Spaltenname {0} wurde in diesem ResultSet nicht gefunden. ResultSet is not updateable. The query that generated this result set must select only one table, and must select all primary keys from that table. See the JDBC 2.1 API Specification, section 5.6 for more details. Das ResultSet kann nicht aktualisiert werden. Die Abfrage, die es erzeugte, darf nur eine Tabelle und muss darin alle Primärschlüssel auswählen. Siehe JDBC 2.1 API-Spezifikation, Abschnitt 5.6 für mehr Details. This ResultSet is closed. !Dieses ResultSet ist geschlossen. AResultSet not positioned properly, perhaps you need to call next. XDas ResultSet ist nicht richtig positioniert. Eventuell muss ''next'' aufgerufen werden. /Multiple ResultSets were returned by the query. %Die Abfrage ergab mehrere ResultSets. 7A CallableStatement was executed with nothing returned. BEin CallableStatement wurde ausgeführt ohne etwas zurückzugeben. EA CallableStatement was executed with an invalid number of parameters LEin CallableStatement wurde mit einer falschen Anzahl Parameter ausgeführt. tA CallableStatement function was executed and the out parameter {0} was of type {1} however type {2} was registered. Eine CallableStatement-Funktion wurde ausgeführt und der Rückgabewert {0} war vom Typ {1}. Jedoch wurde der Typ {2} dafür registriert. AMaximum number of rows must be a value grater than or equal to 0. EDie maximale Zeilenzahl muss ein Wert größer oder gleich Null sein. :Query timeout must be a value greater than or equals to 0. @Das Abfragetimeout muss ein Wert größer oder gleich Null sein. BThe maximum field size must be a value greater than or equal to 0. FDie maximale Feldgröße muss ein Wert größer oder gleich Null sein. Unknown Types value. Unbekannter Typ. Invalid stream length {0}. 'Ungültige Länge des Datenstroms: {0}. /The JVM claims not to support the {0} encoding. Unknown type {0}. Unbekannter Typ {0}. *Cannot cast an instance of {0} to type {1} Unsupported Types value: {0} Unbekannter Typ: {0}. Can''t infer the SQL type to use for an instance of {0}. Use setObject() with an explicit Types value to specify the type to use. Der in SQL für eine Instanz von {0} zu verwendende Datentyp kann nicht abgeleitet werden. Benutzen Sie ''setObject()'' mit einem expliziten Typ, um ihn festzulegen. ZThis statement does not declare an OUT parameter. Use '{' ?= call ... '}' to declare one. `Diese Anweisung deklariert keinen OUT-Parameter. Benutzen Sie '{' ?= call ... '}' um das zu tun. 0wasNull cannot be call before fetching a result. IwasNull kann nicht aufgerufen werden, bevor ein Ergebnis abgefragt wurde. ) was made. oEin CallableStatement wurde deklariert, aber kein Aufruf von ''registerOutParameter(1, )'' erfolgte. KResults cannot be retrieved from a CallableStatement before it is executed. bErgebnisse können nicht von einem CallableStatement abgerufen werden, bevor es ausgeführt wurde. This statement has been closed. &Too many update results were returned. 0Zu viele Updateergebnisse wurden zurückgegeben. IBatch entry {0} {1} was aborted. Call getNextException to see the cause. iBatch-Eintrag {0} {1} wurde abgebrochen. Rufen Sie ''getNextException'' auf, um die Ursache zu erfahren. 2Unexpected error writing large object to database. ZBeim Schreiben eines LargeObjects (LOB) in die Datenbank trat ein unerwarteter Fehler auf. -{0} function takes one and only one argument. 1Die {0}-Funktion erwartet nur genau ein Argument. .{0} function takes two and only two arguments. /Die {0}-Funktion erwartet genau zwei Argumente. /{0} function takes four and only four argument. /Die {0}-Funktion erwartet genau vier Argumente. *{0} function takes two or three arguments. 3Die {0}-Funktion erwartet zwei oder drei Argumente. ({0} function doesn''t take any argument. *Die {0}-Funktion akzeptiert kein Argument. 2{0} function takes three and only three arguments. /Die {0}-Funktion erwartet genau drei Argumente. Interval {0} not yet implemented +Intervall {0} ist noch nicht implementiert. LInfinite value found for timestamp/date. This cannot be represented as time. zFür den Zeitstempel oder das Datum wurde der Wert ''unendlich'' gefunden. Dies kann nicht als Zeit repräsentiert werden. >The class {0} does not implement org.postgresql.util.PGobject. DDie Klasse {0} implementiert nicht ''org.postgresql.util.PGobject''. +Unknown ResultSet holdability setting: {0}. @Unbekannte Einstellung für die Haltbarkeit des ResultSets: {0}. 7Server versions prior to 8.0 do not support savepoints. =Der Server unterstützt keine Rettungspunkte vor Version 8.0. 1Cannot establish a savepoint in auto-commit mode. FEin Rettungspunkt kann im Modus ''auto-commit'' nicht erstellt werden. .Returning autogenerated keys is not supported. IDie Rückgabe automatisch generierter Schlüssel wird nicht unterstützt, DThe parameter index is out of range: {0}, number of parameters: {1}. TDer Parameterindex {0} ist außerhalb des gültigen Bereichs. Es gibt {1} Parameter. 8Cannot reference a savepoint after it has been released. MEin Rettungspunkt kann nicht angesprochen werden, nach dem er entfernt wurde. ,Cannot retrieve the id of a named savepoint. BDie ID eines benamten Rettungspunktes kann nicht ermittelt werden. 1Cannot retrieve the name of an unnamed savepoint. EDer Name eines namenlosen Rettungpunktes kann nicht ermittelt werden. "ClientInfo property not supported. 2Die ClientInfo-Eigenschaft ist nicht unterstützt. $Failed to initialize LargeObject API 6Die LargeObject-API konnte nicht initialisiert werden. 2Large Objects may not be used in auto-commit mode. KLargeObjects (LOB) dürfen im Modus ''auto-commit'' nicht verwendet werden. BThe SSLSocketFactory class provided {0} could not be instantiated. UDie von {0} bereitgestellte SSLSocketFactory-Klasse konnte nicht instanziiert werden. Conversion of interval failed ,Die Umwandlung eines Intervalls schlug fehl. Conversion of money failed. 2Die Umwandlung eines Währungsbetrags schlug fehl. Detail: {0} Hint: {0} Hinweis: {0}
Position: {0}
Where: {0}
Wobei: {0} Internal Query: {0} Interne Abfrage: {0} Internal Position: {0} Interne Position: {0} ,Location: File: {0}, Routine: {1}, Line: {2} *Ort: Datei: {0}, Routine: {1}, Zeile: {2}. Server SQLState: {0}
Invalid flags Ungültige Flags xid must not be null Die xid darf nicht null sein. +Connection is busy with another transaction FDie Verbindung ist derzeit mit einer anderen Transaktion beschäftigt. suspend/resume not implemented ,Anhalten/Fortsetzen ist nicht implementiert. (Transaction interleaving not implemented 1Transaktionsinterleaving ist nicht implementiert. Error disabling autocommit &Fehler beim Abschalten von Autocommit. 2tried to call end without corresponding start call KEs wurde versucht, ohne dazugehörigen ''start''-Aufruf ''end'' aufzurufen. ^Not implemented: Prepare must be issued using the same connection that started the transaction pNicht implementiert: ''Prepare'' muss über die selbe Verbindung abgesetzt werden, die die Transaktion startete. Prepare called before end )''Prepare'' wurde vor ''end'' aufgerufen. =Server versions prior to 8.1 do not support two-phase commit. GDer Server unterstützt keine zweiphasige Bestätigung vor Version 8.1. Error preparing transaction 5Beim Vorbereiten der Transaktion trat ein Fehler auf. Invalid flag Ungültiges Flag. Error during recover *Beim Wiederherstellen trat ein Fehler auf. 'Error rolling back prepared transaction 5Fehler beim Rollback einer vorbereiteten Transaktion. dNot implemented: one-phase commit must be issued using the same connection that was used to start it Nicht implementiert: Die einphasige Bestätigung muss über die selbe Verbindung abgewickelt werden, die verwendet wurde, um sie zu beginnen. commit called before end (''Commit'' wurde vor ''end'' aufgerufen. Error during one-phase commit 5Bei der einphasigen Bestätigung trat ein Fehler auf. INot implemented: 2nd phase commit must be issued using an idle connection yNicht implementiert: Die zweite Bestätigungsphase muss über eine im Leerlauf befindliche Verbindung abgewickelt werden. 'Heuristic commit/rollback not supported 6Heuristisches Commit/Rollback wird nicht unterstützt. &org/postgresql/translation/messages_de java/util/ResourceBundle "java/util/MissingResourceException get &(Ljava/lang/Object;)Ljava/lang/Object; keys parent Ljava/util/ResourceBundle; put 8(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object; !ST UV WX Y * Z [\ Y + Z ] ^ _` Y Z ab Y * Z cX Y K Y K*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*!"
W*#$
W*%&
W*'(
W*)*
W*+,
W*-.
W*/0
W*12
W*34
W*56
W*78
W*9:
W*;<
W*=>
W*?@
W*AB
W*CD
W*EF
W*GH
W*IJ
W*KL
W*MN
W*OP
W*QR
W*ST
W*UV
W*WX
W*YZ
W*[\
W*]^
W*_`
W*ab
W*cd
W*ef
W*gh
W*ij
W*kl
W*mn
W*op
W*qr
W*st
W*uv
W*wx
W*yz
W*{|
W*}~
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*¶
W*Ķ
W*ƶ
W*ȶ
W*ʶ
W*̶
W*ζ
W*ж
W*Ҷ
W*Զ
W*ֶ
W*
W*ٶ
W*.
W*ܶ
W*
W*
W*
W*
W*
W*
W*
W*b
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*!"
W*##
W*$%
W*&'
W*()
W**+
W*,,
W*-.
W*/0
W*12
W*34
W*56
W*78
W*9:
W*;<
W*=>
W*?@
W*AB
W*CD
W*EF
W*GH
W*IJ
W*KL
W*MN
W*OP
W*QR
W* Z #
, 5 >
G P Y b k t } ! " #
$ % &( '1 (: )C *L +U ,^ -g .p /y 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B$ C- D6 E? FH GQ HZ Ic Jl Ku L~ M N O P Q R S T U V W X Y Z [ \ ] ^ _) `2 a; bD cM dV e_ fh gq hz i j k l m n o p q r s t u v w x
y z {% |. }7 ~@ I R [ d m x ( 3 > I T _ j u % 0 ; F J d e postgresql-jdbc-9.2-1002.src/org/postgresql/translation/messages_es.class 0000664 0000000 0000000 00000007730 12050675701 0026524 0 ustar 00root root 0000000 0000000 -
6 H 5 I
J
K 6 L M
H N O
P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | table Ljava/util/Hashtable; ()V Code LineNumberTable handleGetObject &(Ljava/lang/String;)Ljava/lang/Object;
Exceptions } getKeys ()Ljava/util/Enumeration; getParent ()Ljava/util/ResourceBundle;
SourceFile messages_es.java 9 : 7 8 ~ B java/util/Hashtable RProject-Id-Version: JDBC PostgreSQL Driver
Report-Msgid-Bugs-To:
POT-Creation-Date: 2012-09-10 19:32-0400
PO-Revision-Date: 2004-10-22 16:51-0300
Last-Translator: Diego Gil
Language-Team:
Language:
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
X-Poedit-Language: Spanish
XSomething unusual has occured to cause the driver to fail. Please report this exception. dAlgo inusual ha ocurrido que provocó un fallo en el controlador. Por favor reporte esta excepción. EPremature end of input stream, expected {0} bytes, but only read {1}. WFinal prematuro del flujo de entrada, se esperaban {0} bytes, pero solo se leyeron {1}. -An unexpected result was returned by a query. .Una consulta retornó un resultado inesperado. yConnection refused. Check that the hostname and port are correct and that the postmaster is accepting TCP/IP connections. Conexión rechazada. Verifique que el nombre del Host y el puerto sean correctos y que postmaster este aceptando conexiones TCP/IP. The connection attempt failed. El intento de conexión falló. The server does not support SSL. Este servidor no soporta SSL. 5An error occured while setting up the SSL connection. >Ha ocorrido un error mientras se establecía la conexión SSL. Connection rejected: {0}. Conexión rechazada: {0}. QThe server requested password-based authentication, but no password was provided. fEl servidor requiere autenticación basada en contraseña, pero no se ha provisto ninguna contraseña. &Protocol error. Session setup failed. 3Error de protocolo. Falló el inicio de la sesión. Backend start-up failed: {0}. %Falló el arranque del Backend: {0}. >The column index is out of range: {0}, number of columns: {1}. MEl índice de la columna está fuera de rango: {0}, número de columnas: {1}. %No value specified for parameter {0}. 6No se ha especificado un valor para el parámetro {0}. 2An I/O error occured while sending to the backend. ;Un error de E/S ha ocurrido mientras se enviaba al backend. Unknown Response Type {0}. "Tipo de respuesta desconocida {0}. >The array index is out of range: {0}, number of elements: {1}. KEl índice del arreglo esta fuera de rango: {0}, número de elementos: {1}. &No results were returned by the query. *La consulta no retornó ningún resultado. -A result was returned when none was expected. 7Se retornó un resultado cuando no se esperaba ninguno. !Failed to create object for: {0}. Fallo al crear objeto: {0}. >The class {0} does not implement org.postgresql.util.PGobject. 8La clase {0} no implementa org.postgresql.util.PGobject. Server SQLState: {0} SQLState del servidor: {0}. &org/postgresql/translation/messages_es java/util/ResourceBundle "java/util/MissingResourceException get &(Ljava/lang/Object;)Ljava/lang/Object; keys parent Ljava/util/ResourceBundle; put 8(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object; ! 5 6 7 8 9 : ; * < = > ; + < ? @ A B ; < # C D ; * < & E : ; K ӻ Y K*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*!"
W*#$
W*%&
W*'(
W*)*
W*+,
W*-.
W*/0
W*12
W*34
W* < f #
, 5 >
G P Y b k t } F G postgresql-jdbc-9.2-1002.src/org/postgresql/translation/messages_fr.class 0000664 0000000 0000000 00000061643 12050675701 0026527 0 ustar 00root root 0000000 0000000 -
Xj Wk
l
m Xno
jpq
rstuvwxyz{|}~
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ table Ljava/util/Hashtable; ()V Code LineNumberTable handleGetObject &(Ljava/lang/String;)Ljava/lang/Object;
Exceptions getKeys ()Ljava/util/Enumeration; getParent ()Ljava/util/ResourceBundle;
SourceFile messages_fr.java [\ YZ d java/util/Hashtable ]Project-Id-Version: head-fr
Report-Msgid-Bugs-To:
POT-Creation-Date: 2012-09-10 19:32-0400
PO-Revision-Date: 2007-07-27 12:27+0200
Last-Translator:
Language-Team:
Language:
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
X-Generator: KBabel 1.11.4
Plural-Forms: nplurals=2; plural=(n > 1);
;Error loading default settings from driverconfig.properties KErreur de chargement des valeurs par défaut depuis driverconfig.properties XSomething unusual has occured to cause the driver to fail. Please report this exception. hQuelque chose d''inhabituel a provoqué l''échec du pilote. Veuillez faire un rapport sur cette erreur. Connection attempt timed out. The column index is out of range: {0}, number of columns: {1}. JL''indice de la colonne est hors limite : {0}, nombre de colonnes : {1}. %No value specified for parameter {0}. 1Pas de valeur spécifiée pour le paramètre {0}. 'Expected command status BEGIN, got {0}. 2Attendait le statut de commande BEGIN, obtenu {0}. Unexpected command status: {0}. $Statut de commande inattendu : {0}. 2An I/O error occured while sending to the backend. EUne erreur d''entrée/sortie a eu lieu lors d''envoi vers le serveur. Unknown Response Type {0}. Type de réponse inconnu {0}. +Ran out of memory retrieving query results. EAi manqué de mémoire en récupérant les résultats de la requête. DUnable to interpret the update count in command completion tag: {0}. eIncapable d''interpréter le nombre de mise à jour dans la balise de complétion de commande : {0}. .Unable to bind parameter values for statement. ?Incapable de lier les valeurs des paramètres pour la commande. Bind message length {0} too long. This can be caused by very large or incorrect length specifications on InputStream parameters. La longueur du message de liaison {0} est trop grande. Cela peut être causé par des spécification de longueur très grandes ou incorrectes pour les paramètres de type InputStream. The server''s DateStyle parameter was changed to {0}. The JDBC driver requires DateStyle to begin with ISO for correct operation. Le paramètre DateStyle du serveur a été changé pour {0}. Le pilote JDBC nécessite que DateStyle commence par ISO pour un fonctionnement correct. lThe server''s standard_conforming_strings parameter was reported as {0}. The JDBC driver expected on or off. eLe paramètre serveur standard_conforming_strings a pour valeur {0}. Le driver JDBC attend on ou off. 6The driver currently does not support COPY operations. The array index is out of range: {0}, number of elements: {1}. JL''indice du tableau est hors limites : {0}, nombre d''éléments : {1}. Invalid character data was found. This is most likely caused by stored data containing characters that are invalid for the character set the database was created in. The most common example of this is storing 8bit data in a SQL_ASCII database.Des données de caractères invalides ont été trouvées. C''est probablement causé par le stockage de caractères invalides pour le jeu de caractères de création de la base. L''exemple le plus courant est le stockage de données 8bit dans une base SQL_ASCII. ITruncation of large objects is only implemented in 8.3 and later servers. [Le troncage des large objects n''est implémenté que dans les serveurs 8.3 et supérieurs. &PostgreSQL LOBs can only index to: {0} 7Les LOB PostgreSQL peuvent seulement s''indicer à: {0} #LOB positioning offsets start at 1. 3Les décalages de position des LOB commencent à 1. (free() was called on this LOB previously -free() a été appelée auparavant sur ce LOB /Unsupported value for stringtype parameter: {0} OValeur non supportée pour les paramètre de type chaîne de caractères : {0} &No results were returned by the query. *Aucun résultat retourné par la requête. -A result was returned when none was expected. AUn résultat a été retourné alors qu''aucun n''était attendu. !Failed to create object for: {0}. /Échec à la création de l''objet pour : {0}. =Unable to load the class {0} responsible for the datatype {1} FIncapable de charger la classe {0} responsable du type de données {1} LCannot change transaction read-only property in the middle of a transaction. _Impossible de changer la propriété read-only d''une transaction au milieu d''une transaction. ICannot change transaction isolation level in the middle of a transaction. [Impossible de changer le niveau d''isolation des transactions au milieu d''une transaction. .Transaction isolation level {0} not supported. ?Le niveau d''isolation de transaction {0} n''est pas supporté. .Finalizing a Connection that was never closed: Impossible de traduire les données dans l''encodage désiré. PUnable to determine a value for MaxIndexKeys due to missing system catalog data. mIncapable de déterminer la valeur de MaxIndexKeys en raison de données manquante dans lecatalogue système. 4Unable to find name datatype in the system catalogs. KIncapable de trouver le type de donnée name dans les catalogues systèmes. NOperation requires a scrollable ResultSet, but this ResultSet is FORWARD_ONLY. UL''opération nécessite un scrollable ResultSet, mais ce ResultSet est FORWARD_ONLY. CUnexpected error while decoding character data from a large object. UErreur inattendue pendant le décodage des données caractères pour un large object. 9Can''t use relative move methods while on the insert row. _Impossible d''utiliser les fonctions de déplacement relatif pendant l''insertion d''une ligne. &Invalid fetch direction constant: {0}. >Constante de direction pour la récupération invalide : {0}. 6Cannot call cancelRowUpdates() when on the insert row. KImpossible d''appeler cancelRowUpdates() pendant l''insertion d''une ligne. /Cannot call deleteRow() when on the insert row. DImpossible d''appeler deleteRow() pendant l''insertion d''une ligne. ZCurrently positioned before the start of the ResultSet. You cannot call deleteRow() here. bActuellement positionné avant le début du ResultSet. Vous ne pouvez pas appeler deleteRow() ici. WCurrently positioned after the end of the ResultSet. You cannot call deleteRow() here. `Actuellement positionné après la fin du ResultSet. Vous ne pouvez pas appeler deleteRow() ici. $There are no rows in this ResultSet. ,Il n''y pas pas de lignes dans ce ResultSet. Not on the insert row. Pas sur la ligne en insertion. ;You must specify at least one column value to insert a row. MVous devez spécifier au moins une valeur de colonne pour insérer une ligne. /The JVM claims not to support the encoding: {0} 1La JVM prétend ne pas supporter l''encodage: {0} Provided InputStream failed. !L''InputStream fourni a échoué. Provided Reader failed. Le Reader fourni a échoué. Can''t refresh the insert row. -Impossible de rafraîchir la ligne insérée. /Cannot call updateRow() when on the insert row. LImpossible d''appeler updateRow() tant que l''on est sur la ligne insérée. bCannot update the ResultSet because it is either before the start or after the end of the results. jImpossible de mettre à jour le ResultSet car c''est soit avant le début ou après la fin des résultats. ?ResultSets with concurrency CONCUR_READ_ONLY cannot be updated. QLes ResultSets avec la concurrence CONCUR_READ_ONLY ne peuvent être mis à jour. #No primary key found for table {0}. 0Pas de clé primaire trouvée pour la table {0}. 4Fetch size must be a value greater to or equal to 0. :Fetch size doit être une valeur supérieur ou égal à 0. Bad value for type {0} : {1} 'Mauvaise valeur pour le type {0} : {1} 4The column name {0} was not found in this ResultSet. ?Le nom de colonne {0} n''a pas été trouvé dans ce ResultSet. ResultSet is not updateable. The query that generated this result set must select only one table, and must select all primary keys from that table. See the JDBC 2.1 API Specification, section 5.6 for more details.Le ResultSet n''est pas modifiable. La requête qui a généré ce résultat doit sélectionner seulement une table, et doit sélectionner toutes les clés primaires de cette table. Voir la spécification de l''API JDBC 2.1, section 5.6 pour plus de détails. This ResultSet is closed. Ce ResultSet est fermé. AResultSet not positioned properly, perhaps you need to call next. WLe ResultSet n''est pas positionné correctement, vous devez peut-être appeler next(). ICan''t use query methods that take a query string on a PreparedStatement. sImpossible d''utiliser les fonctions de requête qui utilisent une chaîne de caractères sur un PreparedStatement. /Multiple ResultSets were returned by the query. :Plusieurs ResultSets ont été retournés par la requête. 7A CallableStatement was executed with nothing returned. @Un CallableStatement a été exécuté mais n''a rien retourné. tA CallableStatement function was executed and the out parameter {0} was of type {1} however type {2} was registered. Une fonction CallableStatement a été exécutée et le paramètre en sortie {0} était du type {1} alors que le type {2} était prévu. AMaximum number of rows must be a value grater than or equal to 0. MLe nombre maximum de lignes doit être une valeur supérieure ou égale à 0. :Query timeout must be a value greater than or equals to 0. ?Query timeout doit être une valeur supérieure ou égale à 0. BThe maximum field size must be a value greater than or equal to 0. NLa taille maximum des champs doit être une valeur supérieure ou égale à 0. Unknown Types value. Valeur de Types inconnue. Invalid stream length {0}. Longueur de flux invalide {0}. /The JVM claims not to support the {0} encoding. 1La JVM prétend ne pas supporter l''encodage {0}. Unknown type {0}. Type inconnu : {0}. *Cannot cast an instance of {0} to type {1} ) was made. oUn CallableStatement a été déclaré, mais aucun appel à registerOutParameter(1, ) n''a été fait. $No function outputs were registered. 0Aucune fonction outputs n''a été enregistrée. KResults cannot be retrieved from a CallableStatement before it is executed. nLes résultats ne peuvent être récupérés à partir d''un CallableStatement avant qu''il ne soit exécuté. This statement has been closed. Ce statement a été fermé. &Too many update results were returned. 8Trop de résultats de mise à jour ont été retournés. IBatch entry {0} {1} was aborted. Call getNextException to see the cause. dL''élément du batch {0} {1} a été annulé. Appeler getNextException pour en connaître la cause. 2Unexpected error writing large object to database. DErreur inattendue pendant l''écriture de large object dans la base. -{0} function takes one and only one argument. 6La fonction {0} n''accepte qu''un et un seul argument. .{0} function takes two and only two arguments. @La fonction {0} n''accepte que deux et seulement deux arguments. /{0} function takes four and only four argument. DLa fonction {0} n''accepte que quatre et seulement quatre arguments. *{0} function takes two or three arguments. 7La fonction {0} n''accepte que deux ou trois arguments. ({0} function doesn''t take any argument. *La fonction {0} n''accepte aucun argument. 2{0} function takes three and only three arguments. BLa fonction {0} n''accepte que trois et seulement trois arguments. Interval {0} not yet implemented .L''interval {0} n''est pas encore implémenté LInfinite value found for timestamp/date. This cannot be represented as time. uValeur infinie trouvée pour une date/timestamp. Cette valeur ne peut être représenté comme une valeur temporelle. >The class {0} does not implement org.postgresql.util.PGobject. >La classe {0} n''implémente pas org.postgresql.util.PGobject. +Unknown ResultSet holdability setting: {0}. 3Paramètre holdability du ResultSet inconnu : {0}. 7Server versions prior to 8.0 do not support savepoints. LLes serveurs de version antérieure à 8.0 ne supportent pas les savepoints. 1Cannot establish a savepoint in auto-commit mode. 8Impossible d''établir un savepoint en mode auto-commit. .Returning autogenerated keys is not supported. ELe renvoi des clés automatiquement générées n''est pas supporté. DThe parameter index is out of range: {0}, number of parameters: {1}. NL''indice du paramètre est hors limites : {0}, nombre de paramètres : {1}. 8Cannot reference a savepoint after it has been released. IImpossible de référencer un savepoint après qu''il ait été libéré. ,Cannot retrieve the id of a named savepoint. >Impossible de retrouver l''identifiant d''un savepoint nommé. 1Cannot retrieve the name of an unnamed savepoint. 8Impossible de retrouver le nom d''un savepoint sans nom. $Failed to initialize LargeObject API 1Échec à l''initialisation de l''API LargeObject 2Large Objects may not be used in auto-commit mode. GLes Large Objects ne devraient pas être utilisés en mode auto-commit. BThe SSLSocketFactory class provided {0} could not be instantiated. ELa classe SSLSocketFactory fournie {0} n''a pas pu être instanciée. Conversion of interval failed )La conversion de l''intervalle a échoué Conversion of money failed. "La conversion de money a échoué. Detail: {0} Détail : {0} Hint: {0}
Indice : {0}
Position: {0} Position : {0}
Where: {0}
Où : {0} Internal Query: {0} Requête interne: {0} Internal Position: {0} Position interne : {0} ,Location: File: {0}, Routine: {1}, Line: {2}
W*?@
W*AB
W*CD
W*EF
W*GH
W*IJ
W*KL
W*MN
W*OP
W*QR
W*ST
W*UV
W*WX
W*YZ
W*[\
W*]^
W*_`
W*ab
W*cd
W*ef
W*gh
W*ij
W*kl
W*mn
W*op
W*qr
W*st
W*uv
W*wx
W*yz
W*{|
W*}~
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*¶
W*Ķ
W*ƶ
W*ȶ
W*ʶ
W*̶
W*ζ
W*ж
W*Ҷ
W*Զ
W*ֶ
W*ض
W*ڶ
W*ܶ
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*!"
W*#$
W*%&
W*'(
W*)*
W*+,
W*-.
W*/0
W*12
W*34
W*56
W*78
W*9:
W*;<
W*=>
W*?@
W*AB
W*CD
W*EF
W*GH
W*IJ
W*KL
W*MN
W*OP
W*QR
W*ST
W*UV
W* ^ #
, 5 >
G P Y b k t } ! " #
$ % &( '1 (: )C *L +U ,^ -g .p /y 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B$ C- D6 E? FH GQ HZ Ic Jl Ku L~ M N O P Q R S T U V W X Y Z [ \ ] ^ _) `2 a; bD cM dV e_ fh gq hz i j k l m n o p q r s t u v w x
y z {% |. }7 ~@ I R [ e p {
+ 6 A L W b m x ( 3 > B h i postgresql-jdbc-9.2-1002.src/org/postgresql/translation/messages_it.class 0000664 0000000 0000000 00000060067 12050675701 0026533 0 ustar 00root root 0000000 0000000 -
HZ G[
\
] H^_
Z`a
bcdefghijklmnopqrstuvwxyz{|}~
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ table Ljava/util/Hashtable; ()V Code LineNumberTable handleGetObject &(Ljava/lang/String;)Ljava/lang/Object;
Exceptions getKeys ()Ljava/util/Enumeration; getParent ()Ljava/util/ResourceBundle;
SourceFile messages_it.java KL IJ T java/util/Hashtable _Project-Id-Version: PostgreSQL JDBC Driver 8.2
Report-Msgid-Bugs-To:
POT-Creation-Date: 2012-09-10 19:32-0400
PO-Revision-Date: 2006-06-23 17:25+0200
Last-Translator: Giuseppe Sacco
Language-Team: Italian
Language: it
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
;Error loading default settings from driverconfig.properties `Si è verificato un errore caricando le impostazioni predefinite da «driverconfig.properties». XSomething unusual has occured to cause the driver to fail. Please report this exception. Qualcosa di insolito si è verificato causando il fallimento del driver. Per favore riferire all''autore del driver questa eccezione. Connection attempt timed out. 'Il tentativo di connessione è scaduto. (Interrupted while attempting to connect. FSi è verificata una interruzione durante il tentativo di connessione. "Method {0} is not yet implemented. 3Il metodo «{0}» non è stato ancora implementato. @A connection could not be made using the requested protocol {0}. WNon è stato possibile attivare la connessione utilizzando il protocollo richiesto {0}. EPremature end of input stream, expected {0} bytes, but only read {1}. WIl flusso di input è stato interrotto, sono arrivati {1} byte al posto dei {0} attesi. %Expected an EOF from server, got: {0} 4Ricevuto dal server «{0}» mentre era atteso un EOF -An unexpected result was returned by a query. 7Un risultato inaspettato è stato ricevuto dalla query. JIllegal UTF-8 sequence: byte {0} of {1} byte sequence is not 10xxxxxx: {2} USequenza UTF-8 illegale: il byte {0} di una sequenza di {1} byte non è 10xxxxxx: {2} FIllegal UTF-8 sequence: {0} bytes used to encode a {1} byte value: {2} VSequenza UTF-8 illegale: {0} byte utilizzati per codificare un valore di {1} byte: {2} 0Illegal UTF-8 sequence: initial byte is {0}: {1} 5Sequenza UTF-8 illegale: il byte iniziale è {0}: {1} 8Illegal UTF-8 sequence: final value is out of range: {0} QSequenza UTF-8 illegale: il valore finale è fuori dall''intervallo permesso: {0} =Illegal UTF-8 sequence: final value is a surrogate value: {0} ASequenza UTF-8 illegale: il valore è finale è un surrogato: {0} .Zero bytes may not occur in string parameters. HByte con valore zero non possono essere contenuti nei parametri stringa. -Cannot convert an instance of {0} to type {1} CNon è possibile convertire una istanza di «{0}» nel tipo «{1}» yConnection refused. Check that the hostname and port are correct and that the postmaster is accepting TCP/IP connections. Connessione rifiutata. Controllare che il nome dell''host e la porta siano corretti, e che il server (postmaster) sia in esecuzione con l''opzione -i, che abilita le connessioni attraverso la rete TCP/IP. The connection attempt failed. 'Il tentativo di connessione è fallito. The server does not support SSL. Il server non supporta SSL. 5An error occured while setting up the SSL connection. 9Si è verificato un errore impostando la connessione SSL. Connection rejected: {0}. Connessione rifiutata: {0}. QThe server requested password-based authentication, but no password was provided. ]Il server ha richiesto l''autenticazione con password, ma tale password non è stata fornita. The authentication type {0} is not supported. Check that you have configured the pg_hba.conf file to include the client''s IP address or subnet, and that it is using an authentication scheme supported by the driver. L''autenticazione di tipo {0} non è supportata. Verificare che nel file di configurazione pg_hba.conf sia presente l''indirizzo IP o la sottorete del client, e che lo schema di autenticazione utilizzato sia supportato dal driver. &Protocol error. Session setup failed. :Errore di protocollo. Impostazione della sessione fallita. Backend start-up failed: {0}. %Attivazione del backend fallita: {0}. >The column index is out of range: {0}, number of columns: {1}. >Indice di colonna, {0}, è maggiore del numero di colonne {1}. %No value specified for parameter {0}. -Nessun valore specificato come parametro {0}. 'Expected command status BEGIN, got {0}. GLo stato del comando avrebbe dovuto essere BEGIN, mentre invece è {0}. Unexpected command status: {0}. $Stato del comando non previsto: {0}. 2An I/O error occured while sending to the backend. ESi è verificato un errore di I/O nella spedizione di dati al server. Unknown Response Type {0}. !Risposta di tipo sconosciuto {0}. +Ran out of memory retrieving query results. 0Fine memoria scaricando i risultati della query. DUnable to interpret the update count in command completion tag: {0}. eImpossibile interpretare il numero degli aggiornamenti nel «tag» di completamento del comando: {0}. .Unable to bind parameter values for statement. PImpossibile fare il «bind» dei valori passati come parametri per lo statement. Bind message length {0} too long. This can be caused by very large or incorrect length specifications on InputStream parameters. Il messaggio di «bind» è troppo lungo ({0}). Questo può essere causato da una dimensione eccessiva o non corretta dei parametri dell''«InputStream». The server''s DateStyle parameter was changed to {0}. The JDBC driver requires DateStyle to begin with ISO for correct operation. Il parametro del server «DateStyle» è stato cambiato in {0}. Il driver JDBC richiede che «DateStyle» cominci con «ISO» per un corretto funzionamento. 6The driver currently does not support COPY operations. 9Il driver non supporta al momento l''operazione «COPY». .This PooledConnection has already been closed. ,Questo «PooledConnection» è stato chiuso. Connection has been closed automatically because a new connection was opened for the same PooledConnection or the PooledConnection has been closed. La «Connection» è stata chiusa automaticamente perché una nuova l''ha sostituita nello stesso «PooledConnection», oppure il «PooledConnection» è stato chiuso. Connection has been closed. &Questo «Connection» è stato chiuso. Statement has been closed. %Questo «Statement» è stato chiuso. DataSource has been closed. &Questo «DataSource» è stato chiuso. FFastpath call {0} - No result was returned and we expected an integer. XChiamata Fastpath «{0}»: Nessun risultato restituito mentre ci si aspettava un intero. %The fastpath function {0} is unknown. ,La funzione fastpath «{0}» è sconosciuta. #Conversion to type {0} failed: {1}. %Conversione al tipo {0} fallita: {1}. +Cannot tell if path is open or closed: {0}. =Impossibile stabilire se il percorso è aperto o chiuso: {0}. $The array index is out of range: {0} 9Indice di colonna fuori dall''intervallo ammissibile: {0} >The array index is out of range: {0}, number of elements: {1}. HL''indice dell''array è fuori intervallo: {0}, numero di elementi: {1}. Invalid character data was found. This is most likely caused by stored data containing characters that are invalid for the character set the database was created in. The most common example of this is storing 8bit data in a SQL_ASCII database.5Sono stati trovati caratteri non validi tra i dati. Molto probabilmente sono stati memorizzati dei caratteri che non sono validi per la codifica dei caratteri impostata alla creazione del database. Il caso più diffuso è quello nel quale si memorizzano caratteri a 8bit in un database con codifica SQL_ASCII. &PostgreSQL LOBs can only index to: {0} >Il massimo valore per l''indice dei LOB di PostgreSQL è {0}. #LOB positioning offsets start at 1. 1L''offset per la posizione dei LOB comincia da 1. /Unsupported value for stringtype parameter: {0} DIl valore per il parametro di tipo string «{0}» non è supportato. &No results were returned by the query. 1Nessun risultato è stato restituito dalla query. -A result was returned when none was expected. EÈ stato restituito un valore nonostante non ne fosse atteso nessuno. !Failed to create object for: {0}. ,Fallita la creazione dell''oggetto per: {0}. =Unable to load the class {0} responsible for the datatype {1} GNon è possibile caricare la class «{0}» per gestire il tipo «{1}». LCannot change transaction read-only property in the middle of a transaction. gNon è possibile modificare la proprietà «read-only» delle transazioni nel mezzo di una transazione. ICannot change transaction isolation level in the middle of a transaction. bNon è possibile cambiare il livello di isolamento delle transazioni nel mezzo di una transazione. .Transaction isolation level {0} not supported. EIl livello di isolamento delle transazioni «{0}» non è supportato. .Finalizing a Connection that was never closed: =Finalizzazione di una «Connection» che non è stata chiusa. 3Unable to translate data into the desired encoding. 5Impossibile tradurre i dati nella codifica richiesta. PUnable to determine a value for MaxIndexKeys due to missing system catalog data. ONon è possibile trovare il valore di «MaxIndexKeys» nel catalogo si sistema. 4Unable to find name datatype in the system catalogs. FNon è possibile trovare il datatype «name» nel catalogo di sistema. NOperation requires a scrollable ResultSet, but this ResultSet is FORWARD_ONLY. UL''operazione richiete un «ResultSet» scorribile mentre questo è «FORWARD_ONLY». CUnexpected error while decoding character data from a large object. XErrore non previsto durante la decodifica di caratteri a partire da un «large object». 9Can''t use relative move methods while on the insert row. XNon è possibile utilizzare gli spostamenti relativi durante l''inserimento di una riga. &Invalid fetch direction constant: {0}. ;Costante per la direzione dell''estrazione non valida: {0}. 6Cannot call cancelRowUpdates() when on the insert row. TNon è possibile invocare «cancelRowUpdates()» durante l''inserimento di una riga. /Cannot call deleteRow() when on the insert row. MNon è possibile invocare «deleteRow()» durante l''inserimento di una riga. ZCurrently positioned before the start of the ResultSet. You cannot call deleteRow() here. lLa posizione attuale è precedente all''inizio del ResultSet. Non è possibile invocare «deleteRow()» qui. WCurrently positioned after the end of the ResultSet. You cannot call deleteRow() here. jLa posizione attuale è successiva alla fine del ResultSet. Non è possibile invocare «deleteRow()» qui. $There are no rows in this ResultSet. *Non ci sono righe in questo «ResultSet». Not on the insert row. Non si è in una nuova riga. ;You must specify at least one column value to insert a row. KPer inserire un record si deve specificare almeno il valore di una colonna. /The JVM claims not to support the encoding: {0} 3La JVM sostiene di non supportare la codifica: {0}. Provided InputStream failed. &L''«InputStream» fornito è fallito. Provided Reader failed. !Il «Reader» fornito è fallito. Can''t refresh the insert row. 3Non è possibile aggiornare la riga in inserimento. /Cannot call updateRow() when on the insert row. MNon è possibile invocare «updateRow()» durante l''inserimento di una riga. bCannot update the ResultSet because it is either before the start or after the end of the results. Non è possibile aggiornare il «ResultSet» perché la posizione attuale è precedente all''inizio o successiva alla file dei risultati. ?ResultSets with concurrency CONCUR_READ_ONLY cannot be updated. LI «ResultSet» in modalità CONCUR_READ_ONLY non possono essere aggiornati. #No primary key found for table {0}. >Non è stata trovata la chiave primaria della tabella «{0}». 4Fetch size must be a value greater to or equal to 0. HLa dimensione dell''area di «fetch» deve essere maggiore o eguale a 0. Bad value for type {0} : {1} 2Il valore «{1}» non è adeguato al tipo «{0}». 4The column name {0} was not found in this ResultSet. CColonna denominata «{0}» non è presente in questo «ResultSet». ResultSet is not updateable. The query that generated this result set must select only one table, and must select all primary keys from that table. See the JDBC 2.1 API Specification, section 5.6 for more details. Il «ResultSet» non è aggiornabile. La query che lo genera deve selezionare una sola tabella e deve selezionarne tutti i campi che ne compongono la chiave primaria. Si vedano le specifiche dell''API JDBC 2.1, sezione 5.6, per ulteriori dettagli. This ResultSet is closed. Questo «ResultSet» è chiuso. AResultSet not positioned properly, perhaps you need to call next. [Il «ResultSet» non è correttamente posizionato; forse è necessario invocare «next()». ICan''t use query methods that take a query string on a PreparedStatement. rNon si possono utilizzare i metodi "query" che hanno come argomento una stringa nel caso di «PreparedStatement». /Multiple ResultSets were returned by the query. .La query ha restituito «ResultSet» multipli. 7A CallableStatement was executed with nothing returned. KUn «CallableStatement» è stato eseguito senza produrre alcun risultato. tA CallableStatement function was executed and the out parameter {0} was of type {1} however type {2} was registered. È stato eseguito un «CallableStatement» ma il parametro in uscita «{0}» era di tipo «{1}» al posto di «{2}», che era stato dichiarato. AMaximum number of rows must be a value grater than or equal to 0. =Il numero massimo di righe deve essere maggiore o eguale a 0. :Query timeout must be a value greater than or equals to 0. AIl timeout relativo alle query deve essere maggiore o eguale a 0. BThe maximum field size must be a value greater than or equal to 0. BLa dimensione massima del campo deve essere maggiore o eguale a 0. Unknown Types value. Valore di tipo sconosciuto. Invalid stream length {0}. @La dimensione specificata, {0}, per lo «stream» non è valida. /The JVM claims not to support the {0} encoding. 2La JVM sostiene di non supportare la codifica {0}. Unknown type {0}. Tipo sconosciuto {0}. *Cannot cast an instance of {0} to type {1} HNon è possibile fare il cast di una istanza di «{0}» al tipo «{1}». Unsupported Types value: {0} &Valore di tipo «{0}» non supportato. Can''t infer the SQL type to use for an instance of {0}. Use setObject() with an explicit Types value to specify the type to use. Non è possibile identificare il tipo SQL da usare per l''istanza di tipo «{0}». Usare «setObject()» specificando esplicitamente il tipo da usare per questo valore. ZThis statement does not declare an OUT parameter. Use '{' ?= call ... '}' to declare one. ZQuesto statement non dichiara il parametro in uscita. Usare «{ ?= call ... }» per farlo. ) was made. rÈ stato definito un «CallableStatement» ma non è stato invocato il metodo «registerOutParameter(1, )». This statement has been closed. !Questo statement è stato chiuso. &Too many update results were returned. +Sono stati restituiti troppi aggiornamenti. IBatch entry {0} {1} was aborted. Call getNextException to see the cause. kL''operazione «batch» {0} {1} è stata interrotta. Chiamare «getNextException» per scoprirne il motivo. 2Unexpected error writing large object to database. 9Errore inatteso inviando un «large object» al database. -{0} function takes one and only one argument. 2Il metodo «{0}» accetta un ed un solo argomento. .{0} function takes two and only two arguments. 3Il metodo «{0}» accetta due e solo due argomenti. /{0} function takes four and only four argument. ;Il metodo «{0}» accetta quattro e solo quattro argomenti. *{0} function takes two or three arguments. .Il metodo «{0}» accetta due o tre argomenti. ({0} function doesn''t take any argument. (Il metodo «{0}» non accetta argomenti. 2{0} function takes three and only three arguments. 3Il metodo «{0}» accetta tre e solo tre argomenti. Interval {0} not yet implemented 7L''intervallo «{0}» non è stato ancora implementato. LInfinite value found for timestamp/date. This cannot be represented as time. rIl valore specificato per il tipo «timestamp» o «date», infinito, non può essere rappresentato come «time». >The class {0} does not implement org.postgresql.util.PGobject. ALa class «{0}» non implementa «org.postgresql.util.PGobject». +Unknown ResultSet holdability setting: {0}. FIl parametro «holdability» per il «ResultSet» è sconosciuto: {0}. 7Server versions prior to 8.0 do not support savepoints. PLe versioni del server precedenti alla 8.0 non permettono i punti di ripristino. 1Cannot establish a savepoint in auto-commit mode. NNon è possibile impostare i punti di ripristino in modalità «auto-commit». .Returning autogenerated keys is not supported. 9La restituzione di chiavi autogenerate non è supportata. DThe parameter index is out of range: {0}, number of parameters: {1}. FIl parametro indice è fuori intervallo: {0}, numero di elementi: {1}. 8Cannot reference a savepoint after it has been released. SNon è possibile utilizzare un punto di ripristino successivamente al suo rilascio. ,Cannot retrieve the id of a named savepoint. @Non è possibile trovare l''id del punto di ripristino indicato. 1Cannot retrieve the name of an unnamed savepoint. CNon è possibile trovare il nome di un punto di ripristino anonimo. $Failed to initialize LargeObject API ,Inizializzazione di LargeObject API fallita. 2Large Objects may not be used in auto-commit mode. KNon è possibile impostare i «Large Object» in modalità «auto-commit». BThe SSLSocketFactory class provided {0} could not be instantiated. PLa classe «SSLSocketFactory» specificata, «{0}», non può essere istanziata. Conversion of interval failed *Fallita la conversione di un «interval». Conversion of money failed. 'Fallita la conversione di un «money». Detail: {0} Dettaglio: {0} Hint: {0} Suggerimento: {0}
Position: {0} Posizione: {0}
Where: {0} Dove: {0} Internal Query: {0} Query interna: {0} Internal Position: {0} Posizione interna: {0} ,Location: File: {0}, Routine: {1}, Line: {2} 5Individuazione: file: "{0}", routine: {1}, linea: {2} Server SQLState: {0} SQLState del server: {0}
Invalid flags Flag non validi xid must not be null xid non può essere NULL +Connection is busy with another transaction 5La connessione è utilizzata da un''altra transazione suspend/resume not implemented '«suspend»/«resume» non implementato (Transaction interleaving not implemented >L''"interleaving" delle transazioni «{0}» non è supportato. 2tried to call end without corresponding start call FÈ stata chiamata «end» senza la corrispondente chiamata a «start» ^Not implemented: Prepare must be issued using the same connection that started the transaction kNon implementato: «Prepare» deve essere eseguito nella stessa connessione che ha iniziato la transazione. Prepare called before end %«Prepare» invocato prima della fine =Server versions prior to 8.1 do not support two-phase commit. OLe versioni del server precedenti alla 8.1 non permettono i commit "two-phase". Error preparing transaction $Errore nel preparare una transazione Invalid flag Flag non valido Error during recover Errore durante il ripristino 'Error rolling back prepared transaction ;Errore durante il «rollback» di una transazione preparata dNot implemented: one-phase commit must be issued using the same connection that was used to start it uNon implementato: il commit "one-phase" deve essere invocato sulla stessa connessione che ha iniziato la transazione. commit called before end -«Commit» è stato chiamato prima della fine Error during one-phase commit $Errore durante il commit "one-phase" INot implemented: 2nd phase commit must be issued using an idle connection fNon implementato: la seconda fase del «commit» deve essere effettuata con una connessione non in uso 'Heuristic commit/rollback not supported 7«Commit» e «rollback» euristici non sono supportati &org/postgresql/translation/messages_it java/util/ResourceBundle "java/util/MissingResourceException get &(Ljava/lang/Object;)Ljava/lang/Object; keys parent Ljava/util/ResourceBundle; put 8(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object; !GH IJ KL M * N OP M + N Q R ST M N UV M * N WL M Y K*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*!"
W*#$
W*%&
W*'(
W*)*
W*+,
W*-.
W*/0
W*12
W*34
W*56
W*78
W*9:
W*;<
W*=>
W*?@
W*AB
W*CD
W*EF
W*GH
W*IJ
W*KL
W*MN
W*OP
W*QR
W*ST
W*UV
W*WX
W*YZ
W*[\
W*]^
W*_`
W*ab
W*cd
W*ef
W*gh
W*ij
W*kl
W*mn
W*op
W*qr
W*st
W*uv
W*wx
W*yz
W*{|
W*}~
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*¶
W*Ķ
W*ƶ
W*ȶ
W*ʶ
W*̶
W*ζ
W*ж
W*Ҷ
W*Զ
W*ֶ
W*ض
W*ڶ
W*ܶ
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*!"
W*#$
W*%&
W*'(
W*)*
W*+,
W*-.
W*/0
W*12
W*34
W*56
W*78
W*9:
W*;<
W*=>
W*?@
W*AB
W*CD
W*EF
W* N #
, 5 >
G P Y b k t } ! " #
$ % &( '1 (: )C *L +U ,^ -g .p /y 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B$ C- D6 E? FH GQ HZ Ic Jl Ku L~ M N O P Q R S T U V W X Y Z [ \ ] ^ _) `2 a; bD cM dV e_ fh gq hz i j k l m n o p q r s t u v w x
y z {% |. }7 ~@ I R [ e p {
+ 6 A L W b m x X Y postgresql-jdbc-9.2-1002.src/org/postgresql/translation/messages_ja.class 0000664 0000000 0000000 00000103017 12050675701 0026502 0 ustar 00root root 0000000 0000000 -
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ table Ljava/util/Hashtable; ()V Code LineNumberTable handleGetObject &(Ljava/lang/String;)Ljava/lang/Object;
Exceptions getKeys ()Ljava/util/Enumeration; getParent ()Ljava/util/ResourceBundle;
SourceFile messages_ja.java java/util/Hashtable Project-Id-Version: head-ja
Report-Msgid-Bugs-To:
POT-Creation-Date: 2012-09-10 19:32-0400
PO-Revision-Date: 2010-04-11 22:58+0900
Last-Translator: Hiroshi Saito
Language-Team: PostgreSQL
Language:
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
X-Generator: KBabel 1.0.2
X-Poedit-Language: Japanese
X-Poedit-Country: Japan
;Error loading default settings from driverconfig.properties Adriverconfig.propertiesによる初期設定のロードエラー Your security policy has prevented the connection from being attempted. You probably need to grant the connect java.net.SocketPermission to the database server host and port that you wish to connect to. セキュリティ・ポリシーは、接続を妨げました。おそらく、データベース・サーバー・ホスト接続のためjava.net.SocketPermissionを許可する必要があります。 XSomething unusual has occured to cause the driver to fail. Please report this exception. uなにかドライバを失敗させる変化が起こりました。どうぞこの例外を報告して下さい。 Connection attempt timed out. -接続中にタイムアウトしました。 (Interrupted while attempting to connect. -接続中に割り込みがありました。 "Method {0} is not yet implemented. 2方法 {0} はまだ装備されていません。 Requested CopyIn but got {0} /CopyInを要求しましたが {0} を得ます Requested CopyOut but got {0} 0CopyOutを要求しましたが {0} を得ます !Copying from database failed: {0} ;データベースからコピーに失敗しました: {0} This copy stream is closed. .copyストリームは閉じられました。 Read from copy failed. 1copyからの読み取りに失敗しました。 (Cannot write to copy a byte of value {0} ?値{0}のバイトコピーで書き込みができません。 @A connection could not be made using the requested protocol {0}. Y要求されたプロトコル {0} を使用して接続することができません。 EPremature end of input stream, expected {0} bytes, but only read {1}. 早すぎた入力ストリームの終了です、{0} バイトが想定されました、しかし唯一 {1} は読み込まれました。 %Expected an EOF from server, got: {0} :サーバから EOF が想定されました、取得: {0} -An unexpected result was returned by a query. Eクエリーによって想定しない結果が返されました。 JIllegal UTF-8 sequence: byte {0} of {1} byte sequence is not 10xxxxxx: {2} pUTF-8シーケンス違反: {1} バイトシーケンスの {0} バイト は、10xxxxxx でありません: {2} FIllegal UTF-8 sequence: {0} bytes used to encode a {1} byte value: {2} iUTF-8シーケンス違反: {0} バイトは、 {1} バイト値のエンコードに使いました: {2} 0Illegal UTF-8 sequence: initial byte is {0}: {1} 9UTF-8シーケンス違反: 初期バイトは、{0}: {1} 8Illegal UTF-8 sequence: final value is out of range: {0} The column index is out of range: {0}, number of columns: {1}. =列インデックスは範囲外です: {0} , 列の数: {1} %No value specified for parameter {0}. 8パラメータ {0} の明確な値がありません。 'Expected command status BEGIN, got {0}. ABEGINコマンドステータスを想定しました, 取得 {0} Unexpected command status: {0}. ,想定外のコマンドステータス: {0} 2An I/O error occured while sending to the backend. Qバックエンドに送信中に、入出力エラーはが起こりました。 Unknown Response Type {0}. 未知の応答型 {0} です。 +Ran out of memory retrieving query results. Hメモリを使い果たし、クエリー結果を回収しました。 DUnable to interpret the update count in command completion tag: {0}. Pコマンド完了タグで更新数を解釈することができません: {0} +Copy not implemented for protocol version 2 Dプロトコルバージョン2でCopyは装備されていません 'CommandComplete expected COPY but got: Aコマンド完了はCOPYを想定します、しかし取得は: -Tried to obtain lock while already holding it 9すでに占有している最中のロック取得です *Tried to break lock on database connection <データベース接続のロック中断を試みます。 ?Interrupted while waiting to obtain lock on database connection Wデータベース接続でロック待ちの最中に割り込みがありました。 .Unable to bind parameter values for statement. Nステートメントのバインドパラメーター値ができません。 -Database connection failed when starting copy C文字列copy中にデータベース接続に失敗しました。 *Tried to cancel an inactive copy operation <不活発なコピー操作の取り消しを試みました 8Database connection failed when canceling copy operation Nコピー操作取り消し中にデータベース接続に失敗しました 6Missing expected error response to copy cancel request Bコピー取り消し要求のエラー応答を想定しました 5Got {0} error responses to single copy cancel request B単一copy取り消し要求の {0} エラー応答を得ました Tried to end inactive copy 3不活発なコピーの終了を試みました。 +Database connection failed when ending copy Nコピーを終えるときに、データベース接続は失敗しました ,Tried to write to an inactive copy operation ?不活発なコピー操作で書き込みを試みました。 /Database connection failed when writing to copy Ccopy書き込み中にデータベース接続に失敗しました Tried to read from inactive copy @活動していないcopyから読み取りを試みました。 1Database connection failed when reading from copy Icopyから読み取り中にデータベース接続が失敗しました AReceived CommandComplete ''{0}'' without an active copy operation T活動中のコピー操作なしでCommandComplete ''{0}'' を受け取りました 3Got CopyInResponse from server during an active {0} =活動中のサーバ {0} からCopyInResponseを得ました 4Got CopyOutResponse from server during an active {0} >活動中のサーバ {0} からCopyOutResponseを得ました -Got CopyData without an active copy operation ;活動中のコピー操作なしでCopyDataを得ました 'Unexpected copydata from server for {0} >{0} のサーバからの思いがけない copydata です。 'Unexpected packet type during copy: {0} 9copy最中に思いがけないパケット型です: {0} Bind message length {0} too long. This can be caused by very large or incorrect length specifications on InputStream parameters. バインドメッセージ長 {0} は長すぎます。これはとても大きくする要因となるか、あるいは、InputStreamパラメーターの不正確な長さ記述です。 The server''s DateStyle parameter was changed to {0}. The JDBC driver requires DateStyle to begin with ISO for correct operation. サーバーのDateStyleパラメーターは、{0} に変わりました,JDBCドライバーは、正しい操作のISOで、開始するためのDateStyleを必要とします。 lThe server''s standard_conforming_strings parameter was reported as {0}. The JDBC driver expected on or off. サーバーのstandard_conforming_stringsパラメーターは、{0}として報告されました。JDBCドライバーは、on または off を想定します。 6The driver currently does not support COPY operations. E現在、ドライバはコピー操作をサポートしません。 .This PooledConnection has already been closed. :PooledConnectionは、すでに閉じられています。 Connection has been closed automatically because a new connection was opened for the same PooledConnection or the PooledConnection has been closed. 同じPooledConnectionが開かれたので新しい接続は自動的に閉じられました、または、PooledConnectionが閉じられました。 Connection has been closed. !接続は閉じられました。 Statement has been closed. !構文は閉じられました。 DataSource has been closed. -データソースは閉じられました。 FFastpath call {0} - No result was returned and we expected an integer. dFastpath 呼び出し {0} - いかなる結果も返されません、整数を予想しました。 %The fastpath function {0} is unknown. * {0} は未知の fastpath 関数です。 #Conversion to type {0} failed: {1}. )型変換 {0} は失敗しました: {1}. +Cannot tell if path is open or closed: {0}. Zもし path が オープン、またはクローズされていたら話せません: {0} GSS Authentication failed GSS認証は失敗しました $The array index is out of range: {0} 2配列インデックスは、範囲外です: {0} >The array index is out of range: {0}, number of elements: {1}. F配列インデックスは、範囲外です: {0} , 要素の数: {1} Invalid character data was found. This is most likely caused by stored data containing characters that are invalid for the character set the database was created in. The most common example of this is storing 8bit data in a SQL_ASCII database.<不正な文字データが見つかりました。これは、恐らく作成されたデータベースの文字セットにとって無効である文字を含むデータによって引き起こされます。最も共通の例として、8bitデータがSQL_ASCIIデータベースに保存されています。 ITruncation of large objects is only implemented in 8.3 and later servers. nラージオブジェクトの除去は、サーババージョンが 8.3 以上で装備されています。 &PostgreSQL LOBs can only index to: {0} BPostgreSQL LOB は、インデックス {0} のみ可能です。 #LOB positioning offsets start at 1. =LOB オフセット開始位置を 1 としてください。 (free() was called on this LOB previously 2free() は、 このLOB以前に呼ばれました /Unsupported value for stringtype parameter: {0} D文字列型パラメータのサポートされない値です: {0} 0unknownLength parameter value must be an integer H未知の長さパラメータ値は整数でなければなりません &No results were returned by the query. Nいかなる結果も、クエリーによって返されませんでした。 -A result was returned when none was expected. E何も予想しなかったときに、結果が返されました。 #Custom type maps are not supported. ?カスタム・型のマップはサポートされません。 !Failed to create object for: {0}. :{0} へのオブジェクト生成に失敗しました。 =Unable to load the class {0} responsible for the datatype {1} Eデータ型 {1} 対応のクラス{0} をロードできません。 LCannot change transaction read-only property in the middle of a transaction. トランザクション中に、読み出し専用プロパティトランザクションに変えることができません。 )Cannot commit when autoCommit is enabled. ?オートコミット有効時にコミットできません。 This connection has been closed. '接続は既に閉じられました。 +Cannot rollback when autoCommit is enabled. Eオートコミット有効時にロールバックできません。 ICannot change transaction isolation level in the middle of a transaction. Zトランザクションの最中に隔離レベルを変えることができません。 .Transaction isolation level {0} not supported. Rトランザクション隔離レベル{0} はサポートされていません。 .Finalizing a Connection that was never closed: .接続終了で閉じられませんでした: 3Unable to translate data into the desired encoding. ?望む符号化にデータを訳すことができません。 PUnable to determine a value for MaxIndexKeys due to missing system catalog data. x間違ったシステム・カタログ・データのためにMaxIndexKeysの値を決めることができません。 4Unable to find name datatype in the system catalogs. W名前データ型をシステムカタログで見つけることができません。 NOperation requires a scrollable ResultSet, but this ResultSet is FORWARD_ONLY. |操作は、スクロール可能なResultSetを必要とします、しかし、このResultSetは、 FORWARD_ONLYです。 CUnexpected error while decoding character data from a large object. rラージオブジェクトから文字データの複合化中に思いがけないエラーが起きました。 9Can''t use relative move methods while on the insert row. N行挿入の最中に関連の動作方法を使うことはできません。 &Invalid fetch direction constant: {0}. 8フェッチ方向コンスタントが不正です: {0} 6Cannot call cancelRowUpdates() when on the insert row. B行挿入の最中にcancelRowUpdates()を呼び出せません。 /Cannot call deleteRow() when on the insert row. 7行挿入時に deleteRow() を呼び出せません。 ZCurrently positioned before the start of the ResultSet. You cannot call deleteRow() here. fResultSetの開始の前に置かれました。ここでdeleteRowを呼ぶことはできません。 WCurrently positioned after the end of the ResultSet. You cannot call deleteRow() here. iResultSetの終わりの後に置かれました。ここでdeleteRowを呼ぶことはできません。 $There are no rows in this ResultSet. 6このResultSetにいかなる行もありません。 Not on the insert row. 挿入行がありません。 ;You must specify at least one column value to insert a row. B行挿入には、最低でも１つの列の値が必要です。 /The JVM claims not to support the encoding: {0} AJVMでサポートされないエンコーディングです: {0} Provided InputStream failed. .提供の InputStream は失敗しました。 Provided Reader failed. )提供の Reader は失敗しました。 Can''t refresh the insert row. 3挿入行を回復することはできません。 /Cannot call updateRow() when on the insert row. T列を挿入したときに、updateRow() を呼び出すことができません。 bCannot update the ResultSet because it is either before the start or after the end of the results. i開始前にResultSetを更新することができません、または結果の終わりの後です。 ?ResultSets with concurrency CONCUR_READ_ONLY cannot be updated. GCONCUR_READ_ONLYを伴うResultSetsは更新できませんでした。 #No primary key found for table {0}. 2テーブル {0} の主キーがありません。 4Fetch size must be a value greater to or equal to 0. aフェッチサイズは、0に等しいか、より以上の値でなくてはなりません。 Bad value for type {0} : {1} 型 {0} : {1} で不正な値 4The column name {0} was not found in this ResultSet. CallableStatementは、戻りなしで実行されました。 EA CallableStatement was executed with an invalid number of parameters PCallableStatementは、パラメーターの不正な数で実行されました tA CallableStatement function was executed and the out parameter {0} was of type {1} however type {2} was registered. CallableStatement機能は実行されました、そして、出力パラメーター {0} は、型 {1} です。しかし、型 {2} が登録されました。 AMaximum number of rows must be a value grater than or equal to 0. [行の最大数は、0に等しいか、より以上の値でなくてはなりません。 :Query timeout must be a value greater than or equals to 0. jクエリータイムアウトは、0に等しいか、より以上の値でなくてはなりません。 BThe maximum field size must be a value greater than or equal to 0. g最大の項目サイズは、0に等しいか、または以上の値でなくてはなりません。 Unknown Types value. 未知の型の値です。 Invalid stream length {0}. 無効なストリーム長 {0}. /The JVM claims not to support the {0} encoding. DJVMは、エンコーディング {0} をサポートしません。 Unknown type {0}. 未知の型 {0}. *Cannot cast an instance of {0} to type {1} Fインスタンス {0} は型 {1} へのキャストはできません Unsupported Types value: {0} 'サポートされない型の値: {0}. Can''t infer the SQL type to use for an instance of {0}. Use setObject() with an explicit Types value to specify the type to use. z{0} で使うべきSQL型を推測できません。明確な型値で記述した setObject() を使ってください。 ZThis statement does not declare an OUT parameter. Use '{' ?= call ... '}' to declare one. ステートメントは、OUTパラメーターを宣言しません。'{' ?= call ... '}' を使って宣言して下さい。 0wasNull cannot be call before fetching a result. =wasNullは、結果フェッチ前に呼び出せません。 ) was made. CallableStatementは宣言されました、しかし registerOutParameterwas(1, ) のいかなる呼び出しも作られません。 $No function outputs were registered. 0関数出力は登録されませんでした。 KResults cannot be retrieved from a CallableStatement before it is executed. Z実行される前に、CallableStatement から結果を得ることはできません。 This statement has been closed. 6このステートメントは閉じられました。 &Too many update results were returned. 0多すぎる更新結果が返されました。 IBatch entry {0} {1} was aborted. Call getNextException to see the cause. gバッチ投入 {0} {1} は停止しました、getNextExceptionを呼んで原因を見て下さい。 2Unexpected error writing large object to database. oラージオブジェクトをデータベースへ書き込み中に想定外のエラーが起きました。 -{0} function takes one and only one argument. 7{0} 関数は、単一の引数のみを用います。 .{0} function takes two and only two arguments. 7{0} 関数は、二つの引数のみを用います。 /{0} function takes four and only four argument. 7{0} 関数は、四つの引数のみを用います。 *{0} function takes two or three arguments. C{0} 関数は、二つ、または三つの引数を用います。 ({0} function doesn''t take any argument. :{0} 関数は、どのような引数も用いません。 2{0} function takes three and only three arguments. 7{0} 関数は、三つの引数のみを用います。 Interval {0} not yet implemented /間隔 {0} はまだ装備されていません LInfinite value found for timestamp/date. This cannot be represented as time. rtimestamp/date で無限値が見つかりました、これは、時間として表すことができません。 >The class {0} does not implement org.postgresql.util.PGobject. Oクラス {0} は、org.postgresql.util.PGobject を装備していません。 +Unknown ResultSet holdability setting: {0}. (未知の ResultSet 保持的設定: {0} 7Server versions prior to 8.0 do not support savepoints. Sサーバーバージョン 8.0 以前は、savepointをサポートしません。 1Cannot establish a savepoint in auto-commit mode. Eオートコミットモードでsavepointを確立できません。 .Returning autogenerated keys is not supported. H自動生成キーを返すことはサポートされていません。 DThe parameter index is out of range: {0}, number of parameters: {1}. Xパラメーター・インデックスは範囲外です: {0} , パラメータ数: {1} IReturning autogenerated keys is only supported for 8.2 and later servers. G自動生成キーの戻りは 8.2 以上でサポートされます。 >Returning autogenerated keys by column index is not supported. Z列インデックスの自動生成キーの戻りはサポートされていません。 8Cannot reference a savepoint after it has been released. Ksavepointは、解放された後で参照することはできません。 ,Cannot retrieve the id of a named savepoint. J名前の付いたsavepointのidを回収することができません。 1Cannot retrieve the name of an unnamed savepoint. B名前のないsavepointを回収することができません。 Invalid UUID data. UUIDデータ不正です。 7Unable to find server array type for provided name {0}. V提供名 {0} で、サーバーの配列型を見つけることができません。 "ClientInfo property not supported. AClientInfo プロパティはサポートされていません。 Unable to decode xml data. *xmlデータを復号化できません。 Unknown XML Source class: {0} #未知のXMLソースクラス: {0} &Unable to create SAXResult for SQLXML. 0SQLXMLへのSAXResult生成ができません。 &Unable to create StAXResult for SQLXML .SQLXMLのStAXResultを生成できません。 Unknown XML Result class: {0} 未知のXML結果クラス: {0} *This SQLXML object has already been freed.
W*?@
W*AB
W*CD
W*EF
W*GH
W*IJ
W*KL
W*MN
W*OP
W*QR
W*ST
W*UV
W*WX
W*YZ
W*[\
W*]^
W*_`
W*ab
W*cd
W*ef
W*gh
W*ij
W*kl
W*mn
W*op
W*qr
W*st
W*uv
W*wx
W*yz
W*{|
W*}~
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*¶
W*Ķ
W*ƶ
W*ȶ
W*ʶ
W*̶
W*ζ
W*ж
W*Ҷ
W*Զ
W*ֶ
W*ض
W*ڶ
W*ܶ
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*!"
W*#$
W*%&
W*'(
W*)*
W*+,
W*-.
W*/0
W*12
W*34
W*56
W*78
W*9:
W*;<
W*=>
W*?@
W*AB
W*CD
W*EF
W*GH
W*IJ
W*KL
W*MN
W*OP
W*QR
W*ST
W*UV
W*WX
W*YZ
W*[\
W*]^
W*_`
W*ab
W*cd
W*ef
W*gh
W*ij
W*kl
W*mn
W*op
W*qr
W*st
W*uv
W*wx
W*yz
W*{|
W*}~
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W* z #
, 5 >
G P Y b k t } ! " #
$ % &( '1 (: )C *L +U ,^ -g .p /y 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B$ C- D6 E? FH GQ HZ Ic Jl Ku L~ M N O P Q R S T U V W X Y Z [ \ ] ^ _) `2 a; bD cM dV e_ fh gq hz i j k l m n o p q r s t u v w x
y z {% |. }7 ~@ I R [ e p {
+ 6 A L W b m x ( 3 > I T _ j u % 0 ; F Q \ g r } " - 8 C N Y d o z ~ postgresql-jdbc-9.2-1002.src/org/postgresql/translation/messages_nl.class 0000664 0000000 0000000 00000004512 12050675701 0026521 0 ustar 00root root 0000000 0000000 - M
, -
.
/ 0 1
, 2 3
4 5 6 7 8 9 : ; < = > ? @ A B C D table Ljava/util/Hashtable; ()V Code LineNumberTable handleGetObject &(Ljava/lang/String;)Ljava/lang/Object;
Exceptions E getKeys ()Ljava/util/Enumeration; getParent ()Ljava/util/ResourceBundle;
SourceFile messages_nl.java F G H & I J java/util/Hashtable VProject-Id-Version: PostgreSQL JDBC Driver 8.0
Report-Msgid-Bugs-To:
POT-Creation-Date: 2012-09-10 19:32-0400
PO-Revision-Date: 2004-10-11 23:55-0700
Last-Translator: Arnout Kuiper
Language-Team: Dutch
Language: nl
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
K L XSomething unusual has occured to cause the driver to fail. Please report this exception. WIets ongewoons is opgetreden, wat deze driver doet falen. Rapporteer deze fout AUB: {0} -An unexpected result was returned by a query. 9Een onverwacht resultaat werd teruggegeven door een query yConnection refused. Check that the hostname and port are correct and that the postmaster is accepting TCP/IP connections. Verbinding geweigerd. Controleer dat de hostnaam en poort correct zijn, en dat de postmaster is opgestart met de -i vlag, welke TCP/IP networking aanzet. FFastpath call {0} - No result was returned and we expected an integer. `Fastpath aanroep {0} - Geen resultaat werd teruggegeven, terwijl we een integer verwacht hadden. %The fastpath function {0} is unknown. $De fastpath functie {0} is onbekend. &No results were returned by the query. 2Geen resultaten werden teruggegeven door de query. Unknown Types value. Onbekende Types waarde. &org/postgresql/translation/messages_nl java/util/ResourceBundle "java/util/MissingResourceException get &(Ljava/lang/Object;)Ljava/lang/Object; keys parent Ljava/util/ResourceBundle; put 8(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object; ! * ! " + # $ % & ' ( * ) U Y K*
W*
W*
W*
W*
W*
W*
W*
W* . #
, 5 >
G P T * + postgresql-jdbc-9.2-1002.src/org/postgresql/translation/messages_pl.class 0000664 0000000 0000000 00000026370 12050675701 0026531 0 ustar 00root root 0000000 0000000 -S
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJ table Ljava/util/Hashtable; ()V Code LineNumberTable handleGetObject &(Ljava/lang/String;)Ljava/lang/Object;
ExceptionsK getKeys ()Ljava/util/Enumeration; getParent ()Ljava/util/ResourceBundle;
SourceFile messages_pl.java LM N OP java/util/Hashtable Project-Id-Version: head-pl
Report-Msgid-Bugs-To:
POT-Creation-Date: 2012-09-10 19:32-0400
PO-Revision-Date: 2005-05-22 03:01+0200
Last-Translator: Jarosław Jan Pyszny
Language-Team:
Language:
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
X-Generator: KBabel 1.10
Plural-Forms: nplurals=3; plural=(n==1 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);
QR ;Error loading default settings from driverconfig.properties JBłąd podczas wczytywania ustawień domyślnych z driverconfig.properties XSomething unusual has occured to cause the driver to fail. Please report this exception. MCoś niezwykłego spowodowało pad sterownika. Proszę, zgłoś ten wyjątek. "Method {0} is not yet implemented. (Metoda {0}nie jest jeszcze obsługiwana. @A connection could not be made using the requested protocol {0}. KNie można było nawiązać połączenia stosując żądany protokołu {0}. EPremature end of input stream, expected {0} bytes, but only read {1}. YPrzedwczesny koniec strumienia wejściowego, oczekiwano {0} bajtów, odczytano tylko {1}. -An unexpected result was returned by a query. )Zapytanie zwróciło nieoczekiwany wynik. .Zero bytes may not occur in string parameters. KZerowe bajty nie mogą pojawiać się w parametrach typu łańcuch znakowy. yConnection refused. Check that the hostname and port are correct and that the postmaster is accepting TCP/IP connections. Połączenie odrzucone. Sprawdź, czy prawidłowo ustawiłeś nazwę hosta oraz port i upewnij się, czy postmaster przyjmuje połączenia TCP/IP. The connection attempt failed. 3Próba nawiązania połączenia nie powiodła się. The server does not support SSL. Serwer nie obsługuje SSL. 5An error occured while setting up the SSL connection. 8Wystąpił błąd podczas ustanawiania połączenia SSL. Connection rejected: {0}. Połączenie odrzucone: {0}. QThe server requested password-based authentication, but no password was provided. bSerwer zażądał uwierzytelnienia opartego na haśle, ale żadne hasło nie zostało dostarczone. The authentication type {0} is not supported. Check that you have configured the pg_hba.conf file to include the client''s IP address or subnet, and that it is using an authentication scheme supported by the driver. Uwierzytelnienie typu {0} nie jest obsługiwane. Upewnij się, że skonfigurowałeś plik pg_hba.conf tak, że zawiera on adres IP lub podsieć klienta oraz że użyta metoda uwierzytelnienia jest wspierana przez ten sterownik. &Protocol error. Session setup failed. 3Błąd protokołu. Nie udało się utworzyć sesji. Backend start-up failed: {0}. &Start serwera się nie powiódł: {0}. >The column index is out of range: {0}, number of columns: {1}. ;Indeks kolumny jest poza zakresem: {0}, liczba kolumn: {1}. %No value specified for parameter {0}. 'Nie podano wartości dla parametru {0}. 'Expected command status BEGIN, got {0}. 6Spodziewano się statusu komendy BEGIN, otrzymano {0}. Unexpected command status: {0}. "Nieoczekiwany status komendy: {0}. 2An I/O error occured while sending to the backend. 6Wystąpił błąd We/Wy podczas wysyłania do serwera. Unknown Response Type {0}. Nieznany typ odpowiedzi {0}. 6The driver currently does not support COPY operations. 1Sterownik nie obsługuje aktualnie operacji COPY. .This PooledConnection has already been closed. -To PooledConnection zostało już zamknięte. Connection has been closed automatically because a new connection was opened for the same PooledConnection or the PooledConnection has been closed. Połączenie zostało zamknięte automatycznie, ponieważ nowe połączenie zostało otwarte dla tego samego PooledConnection lub PooledConnection zostało zamknięte. Connection has been closed. !Połączenie zostało zamknięte. DataSource has been closed. DataSource zostało zamknięte. FFastpath call {0} - No result was returned and we expected an integer. YWywołanie fastpath {0} - Nie otrzymano żadnego wyniku, a oczekiwano liczby całkowitej. %The fastpath function {0} is unknown. #Funkcja fastpath {0} jest nieznana. #Conversion to type {0} failed: {1}. .Konwersja do typu {0} nie powiodła się: {1}. +Cannot tell if path is open or closed: {0}. GNie można stwierdzić, czy ścieżka jest otwarta czy zamknięta: {0}. $The array index is out of range: {0} &Indeks tablicy jest poza zakresem: {0} >The array index is out of range: {0}, number of elements: {1}. ?Indeks tablicy jest poza zakresem: {0}, liczba elementów: {1}. Invalid character data was found. This is most likely caused by stored data containing characters that are invalid for the character set the database was created in. The most common example of this is storing 8bit data in a SQL_ASCII database.Znaleziono nieprawidłowy znak. Najprawdopodobniej jest to spowodowane przechowywaniem w bazie znaków, które nie pasują do zestawu znaków wybranego podczas tworzenia bazy danych. Najczęstszy przykład to przechowywanie 8-bitowych znaków w bazie o kodowaniu SQL_ASCII. &No results were returned by the query. +Zapytanie nie zwróciło żadnych wyników. -A result was returned when none was expected. 8Zwrócono wynik zapytania, choć nie był on oczekiwany. !Failed to create object for: {0}. /Nie powiodło się utworzenie obiektu dla: {0}. =Unable to load the class {0} responsible for the datatype {1} JNie jest możliwe załadowanie klasy {0} odpowiedzialnej za typ danych {1} .Transaction isolation level {0} not supported. 5Poziom izolacji transakcji {0} nie jest obsługiwany. 6Cannot call cancelRowUpdates() when on the insert row. @Nie można wywołać cancelRowUpdates() na wstawianym rekordzie. /Cannot call deleteRow() when on the insert row. 9Nie można wywołać deleteRow() na wstawianym rekordzie. ZCurrently positioned before the start of the ResultSet. You cannot call deleteRow() here. OAktualna pozycja przed początkiem ResultSet. Nie można wywołać deleteRow(). WCurrently positioned after the end of the ResultSet. You cannot call deleteRow() here. HAktualna pozycja za końcem ResultSet. Nie można wywołać deleteRow(). $There are no rows in this ResultSet. (Nie ma żadnych wierszy w tym ResultSet. Not on the insert row. Nie na wstawianym rekordzie. /Cannot call updateRow() when on the insert row. 9Nie można wywołać updateRow() na wstawianym rekordzie. 4Fetch size must be a value greater to or equal to 0. 9Rozmiar pobierania musi być wartością dodatnią lub 0. Bad value for type {0} : {1} Zła wartość dla typu {0}: {1} ResultSet is not updateable. The query that generated this result set must select only one table, and must select all primary keys from that table. See the JDBC 2.1 API Specification, section 5.6 for more details. ResultSet nie jest modyfikowalny (not updateable). Zapytanie, które zwróciło ten wynik musi dotyczyć tylko jednej tabeli oraz musi pobierać wszystkie klucze główne tej tabeli. Zobacz Specyfikację JDBC 2.1 API, rozdział 5.6, by uzyskać więcej szczegółów. This ResultSet is closed. Ten ResultSet jest zamknięty. AResultSet not positioned properly, perhaps you need to call next. 6Zła pozycja w ResultSet, może musisz wywołać next. AMaximum number of rows must be a value grater than or equal to 0. BMaksymalna liczba rekordów musi być wartością dodatnią lub 0. :Query timeout must be a value greater than or equals to 0. 8Timeout zapytania musi być wartością dodatnią lub 0. BThe maximum field size must be a value greater than or equal to 0. >Maksymalny rozmiar pola musi być wartością dodatnią lub 0. Unknown Types value. Nieznana wartość Types. Unknown type {0}. Nieznany typ {0}. Unsupported Types value: {0} Nieznana wartość Types: {0} _A CallableStatement was declared, but no call to registerOutParameter(1, ) was made. kFunkcja CallableStatement została zadeklarowana, ale nie wywołano registerOutParameter (1, ). &Too many update results were returned. IBatch entry {0} {1} was aborted. Call getNextException to see the cause. \Zadanie wsadowe {0} {1} zostało przerwane. Wywołaj getNextException by poznać przyczynę. >The class {0} does not implement org.postgresql.util.PGobject. 8Klasa {0} nie implementuje org.postgresql.util.PGobject. DThe parameter index is out of range: {0}, number of parameters: {1}. BIndeks parametru jest poza zakresem: {0}, liczba parametrów: {1}. $Failed to initialize LargeObject API ,Nie udało się zainicjować LargeObject API Conversion of interval failed *Konwersja typu interval nie powiodła się Conversion of money failed. (Konwersja typu money nie powiodła się. Detail: {0} Szczegóły: {0} Hint: {0} Wskazówka: {0}
Position: {0} Pozycja: {0}
Where: {0}
Gdzie: {0} Internal Query: {0} Wewnętrzne Zapytanie: {0} Internal Position: {0} Wewnętrzna Pozycja: {0} ,Location: File: {0}, Routine: {1}, Line: {2} 2Lokalizacja: Plik: {0}, Procedura: {1}, Linia: {2} Server SQLState: {0} Serwer SQLState: {0} &org/postgresql/translation/messages_pl java/util/ResourceBundle "java/util/MissingResourceException get &(Ljava/lang/Object;)Ljava/lang/Object; keys parent Ljava/util/ResourceBundle; put 8(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object; ! * + T W * Z Y K*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*!"
W*#$
W*%&
W*'(
W*)*
W*+,
W*-.
W*/0
W*12
W*34
W*56
W*78
W*9:
W*;<
W*=>
W*?@
W*AB
W*CD
W*EF
W*GH
W*IJ
W*KL
W*MN
W*OP
W*QR
W*ST
W*UV
W*WX
W*YZ
W*[\
W*]^
W*_`
W*ab
W*cd
W*ef
W*gh
W*ij
W*kl
W*mn
W*op
W*qr
W*st
W*uv
W*wx
W*yz
W*{|
W*}~
W*P
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W* 6 M #
, 5 >
G P Y b k t } ! " #
$ % &( '1 (: )C *L +U ,^ -g .p /y 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B$ C- D6 E? FH GQ HZ Ic Jl Ku L~ M N O P Q R postgresql-jdbc-9.2-1002.src/org/postgresql/translation/messages_pt_BR.class 0000664 0000000 0000000 00000065235 12050675701 0027127 0 ustar 00root root 0000000 0000000 -
} |
}
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
table Ljava/util/Hashtable; ()V Code LineNumberTable handleGetObject &(Ljava/lang/String;)Ljava/lang/Object;
Exceptions getKeys ()Ljava/util/Enumeration; getParent ()Ljava/util/ResourceBundle;
SourceFile messages_pt_BR.java ~
java/util/Hashtable |Project-Id-Version: PostgreSQL 8.4
Report-Msgid-Bugs-To:
POT-Creation-Date: 2012-10-17 14:17-0400
PO-Revision-Date: 2004-10-31 20:48-0300
Last-Translator: Euler Taveira de Oliveira
Language-Team: Brazilian Portuguese
Language: pt_BR
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
;Error loading default settings from driverconfig.properties CErro ao carregar configurações padrão do driverconfig.properties Your security policy has prevented the connection from being attempted. You probably need to grant the connect java.net.SocketPermission to the database server host and port that you wish to connect to. Sua política de segurança impediu que a conexão pudesse ser estabelecida. Você provavelmente precisa conceder permissão em java.net.SocketPermission para a máquina e a porta do servidor de banco de dados que você deseja se conectar. XSomething unusual has occured to cause the driver to fail. Please report this exception. `Alguma coisa não usual ocorreu para causar a falha do driver. Por favor reporte esta exceção. Connection attempt timed out. Tentativa de conexão falhou. (Interrupted while attempting to connect. #Interrompido ao tentar se conectar. "Method {0} is not yet implemented. (Método {0} ainda não foi implementado. @A connection could not be made using the requested protocol {0}. >A conexão não pode ser feita usando protocolo informado {0}. EPremature end of input stream, expected {0} bytes, but only read {1}. PFim de entrada prematuro, eram esperados {0} bytes, mas somente {1} foram lidos. %Expected an EOF from server, got: {0} *Esperado um EOF do servidor, recebido: {0} -An unexpected result was returned by a query. 4Um resultado inesperado foi retornado pela consulta. JIllegal UTF-8 sequence: byte {0} of {1} byte sequence is not 10xxxxxx: {2} RSequência UTF-8 ilegal: byte {0} da sequência de bytes {1} não é 10xxxxxx: {2} FIllegal UTF-8 sequence: {0} bytes used to encode a {1} byte value: {2} WSequência UTF-8 ilegal: {0} bytes utilizados para codificar um valor de {1} bytes: {2} 0Illegal UTF-8 sequence: initial byte is {0}: {1} 1Sequência UTF-8 ilegal: byte inicial é {0}: {1} 8Illegal UTF-8 sequence: final value is out of range: {0} ASequência UTF-8 ilegal: valor final está fora do intervalo: {0} =Illegal UTF-8 sequence: final value is a surrogate value: {0} ASequência UTF-8 ilegal: valor final é um valor suplementar: {0} .Zero bytes may not occur in string parameters. EZero bytes não podem ocorrer em parâmetros de cadeia de caracteres. (Zero bytes may not occur in identifiers. 1Zero bytes não podem ocorrer em identificadores. -Cannot convert an instance of {0} to type {1} 7Não pode converter uma instância de {0} para tipo {1} yConnection refused. Check that the hostname and port are correct and that the postmaster is accepting TCP/IP connections. ~Conexão negada. Verifique se o nome da máquina e a porta estão corretos e se o postmaster está aceitando conexões TCP/IP. The connection attempt failed. A tentativa de conexão falhou. The server does not support SSL. O servidor não suporta SSL. 5An error occured while setting up the SSL connection. 0Um erro ocorreu ao estabelecer uma conexão SSL. Connection rejected: {0}. Conexão negada: {0}. QThe server requested password-based authentication, but no password was provided. RO servidor pediu autenticação baseada em senha, mas nenhuma senha foi fornecida. The authentication type {0} is not supported. Check that you have configured the pg_hba.conf file to include the client''s IP address or subnet, and that it is using an authentication scheme supported by the driver. O tipo de autenticação {0} não é suportado. Verifique se você configurou o arquivo pg_hba.conf incluindo a subrede ou endereço IP do cliente, e se está utilizando o esquema de autenticação suportado pelo driver. &Protocol error. Session setup failed. 4Erro de Protocolo. Configuração da sessão falhou. Backend start-up failed: {0}. 1Inicialização do processo servidor falhou: {0}. >The column index is out of range: {0}, number of columns: {1}. JO índice da coluna está fora do intervalo: {0}, número de colunas: {1}. %No value specified for parameter {0}. .Nenhum valor especificado para parâmetro {0}. 'Expected command status BEGIN, got {0}. .Status do comando BEGIN esperado, recebeu {0}. Unexpected command status: {0}. "Status do comando inesperado: {0}. 2An I/O error occured while sending to the backend. :Um erro de E/S ocorreu ao enviar para o processo servidor. Unknown Response Type {0}. "Tipo de Resposta Desconhecido {0}. +Ran out of memory retrieving query results. :Memória insuficiente ao recuperar resultados da consulta. DUnable to interpret the update count in command completion tag: {0}. bNão foi possível interpretar o contador de atualização na marcação de comando completo: {0}. .Unable to bind parameter values for statement. :Não foi possível ligar valores de parâmetro ao comando. Bind message length {0} too long. This can be caused by very large or incorrect length specifications on InputStream parameters. Tamanho de mensagem de ligação {0} é muito longo. Isso pode ser causado por especificações de tamanho incorretas ou muito grandes nos parâmetros do InputStream. The server''s DateStyle parameter was changed to {0}. The JDBC driver requires DateStyle to begin with ISO for correct operation. O parâmetro do servidor DateStyle foi alterado para {0}. O driver JDBC requer que o DateStyle começe com ISO para operação normal. lThe server''s standard_conforming_strings parameter was reported as {0}. The JDBC driver expected on or off. tO parâmetro do servidor standard_conforming_strings foi definido como {0}. O driver JDBC espera que seja on ou off. 6The driver currently does not support COPY operations. 2O driver atualmente não suporta operações COPY. .This PooledConnection has already been closed. &Este PooledConnection já foi fechado. Connection has been closed automatically because a new connection was opened for the same PooledConnection or the PooledConnection has been closed. Conexão foi fechada automaticamente porque uma nova conexão foi aberta pelo mesmo PooledConnection ou o PooledConnection foi fechado. Connection has been closed. Conexão foi fechada. Statement has been closed. Comando foi fechado. DataSource has been closed. DataSource foi fechado. FFastpath call {0} - No result was returned and we expected an integer. XChamada ao Fastpath {0} - Nenhum resultado foi retornado e nós esperávamos um inteiro. %The fastpath function {0} is unknown. +A função do fastpath {0} é desconhecida. #Conversion to type {0} failed: {1}. %Conversão para tipo {0} falhou: {1}. +Cannot tell if path is open or closed: {0}. 8Não pode dizer se caminho está aberto ou fechado: {0}. GSS Authentication failed Autenticação GSS falhou $The array index is out of range: {0} 0O índice da matriz está fora do intervalo: {0} >The array index is out of range: {0}, number of elements: {1}. LO índice da matriz está fora do intervalo: {0}, número de elementos: {1}. Invalid character data was found. This is most likely caused by stored data containing characters that are invalid for the character set the database was created in. The most common example of this is storing 8bit data in a SQL_ASCII database.Caracter inválido foi encontrado. Isso é mais comumente causado por dado armazenado que contém caracteres que são inválidos para a codificação que foi criado o banco de dados. O exemplo mais comum disso é armazenar dados de 8 bits em um banco de dados SQL_ASCII. ITruncation of large objects is only implemented in 8.3 and later servers. MTruncar objetos grandes só é implementado por servidores 8.3 ou superiores. &PostgreSQL LOBs can only index to: {0} .LOBs do PostgreSQL só podem indexar até: {0} #LOB positioning offsets start at 1. 0Deslocamentos da posição de LOB começam em 1. (free() was called on this LOB previously free() já foi chamado neste LOB /Unsupported value for stringtype parameter: {0} 5Valor do parâmetro stringtype não é suportado: {0} &No results were returned by the query. -Nenhum resultado foi retornado pela consulta. -A result was returned when none was expected. 6Um resultado foi retornado quando nenhum era esperado. #Custom type maps are not supported. 8Mapeamento de tipos personalizados não são suportados. !Failed to create object for: {0}. !Falhou ao criar objeto para: {0}. =Unable to load the class {0} responsible for the datatype {1} KNão foi possível carregar a classe {0} responsável pelo tipo de dado {1} LCannot change transaction read-only property in the middle of a transaction. VNão pode mudar propriedade somente-leitura da transação no meio de uma transação. ICannot change transaction isolation level in the middle of a transaction. ONão pode mudar nível de isolamento da transação no meio de uma transação. .Transaction isolation level {0} not supported. :Nível de isolamento da transação {0} não é suportado. .Finalizing a Connection that was never closed: +Fechando uma Conexão que não foi fechada: 3Unable to translate data into the desired encoding. =Não foi possível traduzir dado para codificação desejada. PUnable to determine a value for MaxIndexKeys due to missing system catalog data. mNão foi possível determinar um valor para MaxIndexKeys por causa de falta de dados no catálogo do sistema. 4Unable to find name datatype in the system catalogs. INão foi possível encontrar tipo de dado name nos catálogos do sistema. NOperation requires a scrollable ResultSet, but this ResultSet is FORWARD_ONLY. bOperação requer um ResultSet rolável, mas este ResultSet é FORWARD_ONLY (somente para frente). CUnexpected error while decoding character data from a large object. ) was made. bUma função foi declarada mas nenhuma chamada a registerOutParameter (1, ) foi feita. $No function outputs were registered. )Nenhum saída de função foi registrada. KResults cannot be retrieved from a CallableStatement before it is executed. OResultados não podem ser recuperados de uma função antes dela ser executada. This statement has been closed. Este comando foi fechado. &Too many update results were returned. 4Muitos resultados de atualização foram retornados. IBatch entry {0} {1} was aborted. Call getNextException to see the cause. NEntrada em lote {0} {1} foi abortada. Chame getNextException para ver a causa. 2Unexpected error writing large object to database. The class {0} does not implement org.postgresql.util.PGobject. :A classe {0} não implementa org.postgresql.util.PGobject. +Unknown ResultSet holdability setting: {0}. ;Definição de durabilidade do ResultSet desconhecida: {0}. 7Server versions prior to 8.0 do not support savepoints. ?Versões do servidor anteriores a 8.0 não suportam savepoints. 1Cannot establish a savepoint in auto-commit mode. UNão pode estabelecer um savepoint no modo de efetivação automática (auto-commit). .Returning autogenerated keys is not supported. Returning autogenerated keys by column index is not supported. RRetorno de chaves geradas automaticamente por índice de coluna não é suportado. 8Cannot reference a savepoint after it has been released.
W*?@
W*AB
W*CD
W*EF
W*GH
W*IJ
W*KL
W*MN
W*OP
W*QR
W*ST
W*UV
W*WX
W*YZ
W*[\
W*]^
W*_`
W*ab
W*cd
W*ef
W*gh
W*ij
W*kl
W*mn
W*op
W*qr
W*st
W*uv
W*wx
W*yz
W*{|
W*}~
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*¶
W*Ķ
W*ƶ
W*ȶ
W*ʶ
W*̶
W*ζ
W*ж
W*Ҷ
W*Զ
W*ֶ
W*ض
W*ڶ
W*ܶ
W*
W*
W*.
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W* !
W*"#
W*$%
W*&'
W*()
W**+
W*,-
W*./
W*01
W*23
W*45
W*67
W*89
W*:;
W*<=
W*>?
W*@A
W*BC
W*DE
W*FG
W*HI
W*JK
W*LM
W*NO
W*PQ
W*RS
W*TU
W*VW
W*XY
W*Z[
W*\]
W*^_
W*`a
W*bc
W*de
W*fg
W*hi
W*jk
W*lm
W*no
W*pq
W*rs
W*tu
W*vw
W*xy
W*z{
W* #
, 5 >
G P Y b k t } ! " #
$ % &( '1 (: )C *L +U ,^ -g .p /y 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B$ C- D6 E? FH GQ HZ Ic Jl Ku L~ M N O P Q R S T U V W X Y Z [ \ ] ^ _) `2 a; bD cM dV e_ fh gq hz i j k l m n o p q r s t u v w x
y z {% |. }7 ~@ I R [ d o z * 5 @ K V a l w ' 2 = H S ^ i t postgresql-jdbc-9.2-1002.src/org/postgresql/translation/messages_ru.class 0000664 0000000 0000000 00000020610 12050675701 0026533 0 ustar 00root root 0000000 0000000 -
n m
n
table Ljava/util/Hashtable; ()V Code LineNumberTable handleGetObject &(Ljava/lang/String;)Ljava/lang/Object;
Exceptions getKeys ()Ljava/util/Enumeration; getParent ()Ljava/util/ResourceBundle;
SourceFile messages_ru.java q r o p z java/util/Hashtable Project-Id-Version: JDBC Driver for PostgreSQL 8.x.x
Report-Msgid-Bugs-To:
POT-Creation-Date: 2012-09-10 19:32-0400
PO-Revision-Date: 2004-11-15 12:19-0500
Last-Translator: Serguei A. Mokhov
Language-Team: pgsql-rus
Language:
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
X-Poedit-Language: Russian
X-Poedit-Country: RUSSIAN FEDERATION
XSomething unusual has occured to cause the driver to fail. Please report this exception. Случилось что-то необычное, что заставило драйвер произвести ошибку. Пожалуйста сообщите это исключение. EPremature end of input stream, expected {0} bytes, but only read {1}. Раннее завершение входного потока, ожидалось байт: {0}, но считано только {1}. -An unexpected result was returned by a query. DЗапрос вернул неожиданный результат. .Zero bytes may not occur in string parameters. VНоль байт не может быть в строковых параметрах. yConnection refused. Check that the hostname and port are correct and that the postmaster is accepting TCP/IP connections. Подсоединение отклонено. Проверьте что хост и порт указаны правильно и что postmaster принимает TCP/IP-подсоединения. The connection attempt failed. >Ошибка при попытке подсоединения. The server does not support SSL. /Сервер не поддерживает SSL. 5An error occured while setting up the SSL connection. FОшибка при установке SSL-подсоединения. Connection rejected: {0}. 5Подсоединение отвергнуто: {0}. QThe server requested password-based authentication, but no password was provided. zСервер запросил парольную аутентификацию, но пароль не был указан. &Protocol error. Session setup failed. \Ошибка протокола. Установление сессии не удалось. Backend start-up failed: {0}. 3Запуск бэкенда не удался: {0}. >The column index is out of range: {0}, number of columns: {1}. [Индекс колонки вне диапазона: {0}, число колонок: {1}. %No value specified for parameter {0}. CНе указано значение для параметра {0}. 'Expected command status BEGIN, got {0}. SОжидался статус команды BEGIN, но получен для {0}. Unexpected command status: {0}. 8Неожиданный статус команды: {0}. 2An I/O error occured while sending to the backend. NОшибка ввода/ввывода при отправке бэкенду. Unknown Response Type {0}. /Неизвестный тип ответа {0}. .Unable to bind parameter values for statement. rНе в состоянии ассоциировать значения параметров для команды. 6The driver currently does not support COPY operations. `Драйвер в данный момент не поддерживате операции COPY. .This PooledConnection has already been closed. 7Это PooledConnection уже было закрыто. Connection has been closed. (Это Connection было закрыт. Statement has been closed. Statement закрыт. DataSource has been closed. DataSource закрыт. $The array index is out of range: {0} :Индекс массива вне диапазона: {0} >The array index is out of range: {0}, number of elements: {1}. _Индекс массива вне диапазона: {0}, число элементов: {1}. Invalid character data was found. This is most likely caused by stored data containing characters that are invalid for the character set the database was created in. The most common example of this is storing 8bit data in a SQL_ASCII database.Найдены неверные символьные данные. Причиной этого скорее всего являются хранимые данные содержащие символы не соответствующие набору символов базы. Типичным примером этого является хранение 8-битных данных в базе SQL_ASCII. &No results were returned by the query. 6Запрос не вернул результатов. -A result was returned when none was expected. PРезультат возвращён когда его не ожидалось. !Failed to create object for: {0}. >Ошибка при создании объект для: {0}. .Transaction isolation level {0} not supported. [Уровень изоляции транзакций {0} не поддерживается. 4The column name {0} was not found in this ResultSet. HИмя колонки {0} не найдено в этом ResultSet''е. This ResultSet is closed. ResultSet закрыт. Unknown Types value. .Неизвестное значение Types. Invalid stream length {0}. -Неверная длина потока {0}. Unknown type {0}. "Неизвестный тип {0}. This statement has been closed. (Этот Sstatement был закрыт. &Too many update results were returned. [Возвращено слишком много результатов обновления. >The class {0} does not implement org.postgresql.util.PGobject. DКласс {0} не реализует org.postgresql.util.PGobject. $Failed to initialize LargeObject API >Ошибка при инициализации LargeObject API 2Large Objects may not be used in auto-commit mode. Большие объекты не могут использоваться в режиме авто-подтверждения (auto-commit). BThe SSLSocketFactory class provided {0} could not be instantiated. kПредоставленный класс SSLSocketFactory {0} нельзя инстанциировать. Conversion of money failed. @Ошибка при преобразовании типа money. Detail: {0} Подробности: {0} Hint: {0} Подсказка: {0}
Position: {0} Позиция: {0}
Where: {0} Где: {0} ,Location: File: {0}, Routine: {1}, Line: {2} XМестонахождение: Файл {0}, Процедура: {1}, Строка: {2} Server SQLState: {0} SQLState сервера: {0} &org/postgresql/translation/messages_ru java/util/ResourceBundle "java/util/MissingResourceException get &(Ljava/lang/Object;)Ljava/lang/Object; keys parent Ljava/util/ResourceBundle; put 8(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object; ! m n o p q r s * t u v s + t < w x y z s t ? { | s * t B } r s ϻ Y K*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*!"
W*#$
W*%&
W*'(
W*)*
W*+,
W*-.
W*/0
W*12
W*34
W*56
W*78
W*9:
W*;<
W*=>
W*?@
W*AB
W*CD
W*EF
W*GH
W*IJ
W*KL
W*MN
W*OP
W*QR
W*ST
W*UV
W*WX
W*YZ
W*[\
W*]^
W*_`
W*ab
W*cd
W*ef
W*gh
W*ij
W*kl
W* t 5 #
, 5 >
G P Y b k t } ! " #
$ % &( '1 (: )C *L +U ,^ -g .p /y 0 1 2 3 4 5 6 7 8 9 : ~ postgresql-jdbc-9.2-1002.src/org/postgresql/translation/messages_sr.class 0000664 0000000 0000000 00000063631 12050675701 0026543 0 ustar 00root root 0000000 0000000 -
| {
|
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ table Ljava/util/Hashtable; ()V Code LineNumberTable handleGetObject &(Ljava/lang/String;)Ljava/lang/Object;
Exceptions getKeys ()Ljava/util/Enumeration; getParent ()Ljava/util/ResourceBundle;
SourceFile messages_sr.java }~
java/util/Hashtable Project-Id-Version: PostgreSQL 8.1
Report-Msgid-Bugs-To:
POT-Creation-Date: 2012-09-10 19:32-0400
PO-Revision-Date: 2009-05-26 11:13+0100
Last-Translator: Bojan Škaljac
Language-Team: Srpski
Language:
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
X-Poedit-Language: Serbian
X-Poedit-Country: YUGOSLAVIA
;Error loading default settings from driverconfig.properties FGreška u čitanju standardnih podešavanja iz driverconfig.properties Your security policy has prevented the connection from being attempted. You probably need to grant the connect java.net.SocketPermission to the database server host and port that you wish to connect to. Sigurnosna podešavanja su sprečila konekciju. Verovatno je potrebno da dozvolite konekciju klasi java.net.SocketPermission na bazu na serveru. XSomething unusual has occured to cause the driver to fail. Please report this exception. QNešto neobično se dogodilo i drajver je zakazao. Molim prijavite ovaj izuzetak. Connection attempt timed out. *Isteklo je vreme za pokušaj konektovanja. (Interrupted while attempting to connect. Prekinut pokušaj konektovanja. "Method {0} is not yet implemented. !Metod {0} nije još impelemtiran. @A connection could not be made using the requested protocol {0}. 8Konekciju nije moguće kreirati uz pomoć protokola {0}. EPremature end of input stream, expected {0} bytes, but only read {1}. YPrevremen završetak ulaznog toka podataka,očekivano {0} bajtova, a pročitano samo {1}. %Expected an EOF from server, got: {0} )Očekivan EOF od servera, a dobijeno: {0} -An unexpected result was returned by a query. 1Nepredviđen rezultat je vraćen od strane upita. JIllegal UTF-8 sequence: byte {0} of {1} byte sequence is not 10xxxxxx: {2} LIlegalna UTF-8 sekvenca: bajt {0} od {1} bajtova sekvence nije 10xxxxxx: {2} FIllegal UTF-8 sequence: {0} bytes used to encode a {1} byte value: {2} GIlegalna UTF-8 sekvenca: {0} bytes used to encode a {1} byte value: {2} 0Illegal UTF-8 sequence: initial byte is {0}: {1} 4Ilegalna UTF-8 sekvenca: inicijalni bajt je {0}: {1} 8Illegal UTF-8 sequence: final value is out of range: {0} The column index is out of range: {0}, number of columns: {1}. /Indeks kolone van osega: {0}, broj kolona: {1}. %No value specified for parameter {0}. &Nije zadata vrednost za parametar {0}. 'Expected command status BEGIN, got {0}. 5Očekivan status komande je BEGIN, a dobijeno je {0}. Unexpected command status: {0}. !Neočekivan komandni status: {0}. 2An I/O error occured while sending to the backend. PUlazno/izlazna greška se dogodila prilikom slanja podataka pozadinskom procesu. Unknown Response Type {0}. Nepoznat tip odziva {0}. +Ran out of memory retrieving query results. 9Nestalo je memorije prilikom preuzimanja rezultata upita. DUnable to interpret the update count in command completion tag: {0}. TNeuspešno prekidanje prebrojavanja ažurivanja u tagu zakompletiranje komandi: {0}. .Unable to bind parameter values for statement. ENije moguće naći vrednost vezivnog parametra za izjavu (statement). Bind message length {0} too long. This can be caused by very large or incorrect length specifications on InputStream parameters. Dužina vezivne poruke {0} prevelika. Ovo je možda rezultat veoma velike ili pogrešne dužine specifikacije za InputStream parametre. The server''s DateStyle parameter was changed to {0}. The JDBC driver requires DateStyle to begin with ISO for correct operation. {Serverov DataStyle parametar promenjen u {0}. JDBC zahteva da DateStyle počinje sa ISO za uspešno završavanje operacije. lThe server''s standard_conforming_strings parameter was reported as {0}. The JDBC driver expected on or off. [Serverov standard_conforming_strings parametar javlja {0}. JDBC drajver ocekuje on ili off. 6The driver currently does not support COPY operations. -Drajver trenutno ne podržava COPY operacije. .This PooledConnection has already been closed. "PooledConnection je već zatvoren. Connection has been closed automatically because a new connection was opened for the same PooledConnection or the PooledConnection has been closed. Konekcija je zatvorena automatski zato što je nova konekcija otvorena za isti PooledConnection ili je PooledConnection zatvoren. Connection has been closed. Konekcija je već zatvorena. Statement has been closed. Statemen je već zatvoren. DataSource has been closed. DataSource je zatvoren. FFastpath call {0} - No result was returned and we expected an integer. JFastpath poziv {0} - Nikakav rezultat nije vraćen a očekivan je integer. %The fastpath function {0} is unknown. #Fastpath funkcija {0} je nepoznata. #Conversion to type {0} failed: {1}. "Konverzija u tip {0} propala: {1}. +Cannot tell if path is open or closed: {0}. BNije moguće utvrditi dali je putanja otvorena ili zatvorena: {0}. $The array index is out of range: {0} Indeks niza je van opsega: {0} >The array index is out of range: {0}, number of elements: {1}. 4Indeks niza je van opsega: {0}, broj elemenata: {1}. Invalid character data was found. This is most likely caused by stored data containing characters that are invalid for the character set the database was created in. The most common example of this is storing 8bit data in a SQL_ASCII database. Pronađeni su nevažeći karakter podaci. Uzrok je najverovatnije to što pohranjeni podaci sadrže karaktere koji su nevažeći u setu karaktera sa kojima je baza kreirana. Npr. Čuvanje 8bit podataka u SQL_ASCII bazi podataka. ITruncation of large objects is only implemented in 8.3 and later servers. OSkraćivanje velikih objekata je implementirano samo u 8.3 i novijim serverima. &PostgreSQL LOBs can only index to: {0} .PostgreSQL LOB mogu jedino da označavaju: {0} #LOB positioning offsets start at 1. "LOB pozicija ofset počinje kod 1. (free() was called on this LOB previously (free() je pozvan na ovom LOB-u prethodno /Unsupported value for stringtype parameter: {0} 5Vrednost za parametar tipa string nije podržana: {0} &No results were returned by the query. .Nikakav rezultat nije vraćen od strane upita. -A result was returned when none was expected. 5Rezultat vraćen ali nikakav rezultat nije očekivan. #Custom type maps are not supported. 8Mape sa korisnički definisanim tipovima nisu podržane. !Failed to create object for: {0}. *Propao pokušaj kreiranja objekta za: {0}. =Unable to load the class {0} responsible for the datatype {1} =Nije moguće učitati kalsu {0} odgovornu za tip podataka {1} LCannot change transaction read-only property in the middle of a transaction. TNije moguće izmeniti read-only osobinu transakcije u sred izvršavanja transakcije. ICannot change transaction isolation level in the middle of a transaction. QNije moguće izmeniti nivo izolacije transakcije u sred izvršavanja transakcije. .Transaction isolation level {0} not supported. -Nivo izolacije transakcije {0} nije podržan. .Finalizing a Connection that was never closed: 2Dovršavanje konekcije koja nikada nije zatvorena: 3Unable to translate data into the desired encoding. 9Nije moguće prevesti podatke u odabrani encoding format. PUnable to determine a value for MaxIndexKeys due to missing system catalog data. ^Nije moguće odrediti vrednost za MaxIndexKezs zbog nedostatka podataka u sistemskom katalogu. 4Unable to find name datatype in the system catalogs. =Nije moguće pronaći ime tipa podatka u sistemskom katalogu. NOperation requires a scrollable ResultSet, but this ResultSet is FORWARD_ONLY. KOperacija zahteva skrolabilan ResultSet,ali ovaj ResultSet je FORWARD_ONLY. CUnexpected error while decoding character data from a large object. GNeočekivana greška prilikom dekodiranja karaktera iz velikog objekta. 9Can''t use relative move methods while on the insert row. LNe može se koristiti metod relativnog pomeranja prilikom ubacivanja redova. &Invalid fetch direction constant: {0}. 1Pogrešna konstanta za direkciju donošenja: {0}. 6Cannot call cancelRowUpdates() when on the insert row. CNije moguće pozvati cancelRowUpdates() prilikom ubacivanja redova. /Cannot call deleteRow() when on the insert row. CallableStatement je izvršen sa nevažećim brojem parametara tA CallableStatement function was executed and the out parameter {0} was of type {1} however type {2} was registered. }CallableStatement funkcija je izvršena dok je izlazni parametar {0} tipa {1} a tip {2} je registrovan kao izlazni parametar. AMaximum number of rows must be a value grater than or equal to 0. ?Maksimalni broj redova mora biti vrednosti veće ili jednake 0. :Query timeout must be a value greater than or equals to 0. 0Tajm-aut mora biti vrednost veća ili jednaka 0. BThe maximum field size must be a value greater than or equal to 0. KMaksimalna vrednost veličine polja mora biti vrednost veća ili jednaka 0. Unknown Types value. Nepoznata vrednost za Types. Invalid stream length {0}. Nevažeća dužina toka {0}. /The JVM claims not to support the {0} encoding. 'JVM tvrdi da ne podržava {0} encoding. Unknown type {0}. Nepoznat tip {0}. *Cannot cast an instance of {0} to type {1} -Nije moguće kastovati instancu {0} u tip {1} Unsupported Types value: {0} #Za tip nije podržana vrednost: {0} Can''t infer the SQL type to use for an instance of {0}. Use setObject() with an explicit Types value to specify the type to use. Nije moguće zaključiti SQL tip koji bi se koristio sa instancom {0}. Koristite setObject() sa zadatim eksplicitnim tipom vrednosti. ZThis statement does not declare an OUT parameter. Use '{' ?= call ... '}' to declare one. VIzraz ne deklariše izlazni parametar. Koristite '{' ?= poziv ... '}' za deklarisanje. 0wasNull cannot be call before fetching a result. 5wasNull nemože biti pozvan pre zahvatanja rezultata. ) was made. YCallableStatement jedeklarisan ali nije bilo poziva registerOutParameter (1, ). $No function outputs were registered. *Nije registrovan nikakv izlaz iz funkcije. KResults cannot be retrieved from a CallableStatement before it is executed. NRazultat nemože da se primi iz CallableStatement pre nego što se on izvrši. This statement has been closed. Statement je zatvoren. &Too many update results were returned. .Previše rezultata za ažuriranje je vraćeno. IBatch entry {0} {1} was aborted. Call getNextException to see the cause. SSmeša prijava {0} {1} je odbačena. Pozovite getNextException da proverite rezlog. 2Unexpected error writing large object to database. DNeočekivana greška prilikom upisa velikog objekta u bazu podataka. -{0} function takes one and only one argument. 0Funkcija {0} prima jedan i samo jedan parametar. .{0} function takes two and only two arguments. ,Funkcija {0} prima dva i samo dva parametra. /{0} function takes four and only four argument. 4Funkcija {0} prima četiri i samo četiri parametra. *{0} function takes two or three arguments. )Funkcija {0} prima dva ili tri parametra. ({0} function doesn''t take any argument. Funkcija {0} nema parametara. 2{0} function takes three and only three arguments. ,Funkcija {0} prima tri i samo tri parametra. Interval {0} not yet implemented %Interval {0} još nije implementiran. LInfinite value found for timestamp/date. This cannot be represented as time. ZBeskonačna vrednost je pronađena za tipestamp/date. To se nemože predstaviti kao vreme. >The class {0} does not implement org.postgresql.util.PGobject. 7Klasa {0} ne implementira org.postgresql.util.PGobject. +Unknown ResultSet holdability setting: {0}. KNepoznata ResultSet podešavanja za mogućnost držanja (holdability): {0}. 7Server versions prior to 8.0 do not support savepoints. Returning autogenerated keys by column index is not supported. >Vraćanje autogenerisanih ključeva po kloloni nije podržano. 8Cannot reference a savepoint after it has been released. FNije moguće referenciranje tačke snimanja nakon njenog oslobađanja. ,Cannot retrieve the id of a named savepoint. .Nije moguće primiti id imena tačke snimanja. 1Cannot retrieve the name of an unnamed savepoint. 8Nije moguće izvaditi ime tačke snimanja koja nema ime. Invalid UUID data. Nevažeća UUID podatak. 7Unable to find server array type for provided name {0}. 6Neuspešno nalaženje liste servera za zadato ime {0}. "ClientInfo property not supported. "ClientInfo property nije podržan. Unable to decode xml data. $Neuspešno dekodiranje XML podataka. Unknown XML Source class: {0} Nepoznata XML ulazna klasa: {0} &Unable to create SAXResult for SQLXML. *Nije moguće kreirati SAXResult za SQLXML. &Unable to create StAXResult for SQLXML *Nije moguće kreirati StAXResult za SQLXML Unknown XML Result class: {0} "nepoznata XML klasa rezultata: {0} *This SQLXML object has already been freed. Ovaj SQLXML je već obrisan. QThis SQLXML object has not been initialized, so you cannot retrieve data from it. TSQLXML objekat nije inicijalizovan tako da nije moguće preuzimati podatke iz njega. 3Failed to convert binary xml data to encoding: {0}. CNeuspešno konvertovanje binarnih XML podataka u kodnu stranu: {0}. 4Unable to convert DOMResult SQLXML data to a string.
W*?@
W*AB
W*CD
W*EF
W*GH
W*IJ
W*KL
W*MN
W*OP
W*QR
W*ST
W*UV
W*WX
W*YZ
W*[\
W*]^
W*_`
W*ab
W*cd
W*ef
W*gh
W*ij
W*kl
W*mn
W*op
W*qr
W*st
W*uv
W*wx
W*yz
W*{|
W*}~
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*¶
W*Ķ
W*ƶ
W*ȶ
W*ʶ
W*̶
W*ζ
W*ж
W*Ҷ
W*Զ
W*ֶ
W*ض
W*ڶ
W*ܶ
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*!"
W*#$
W*%&
W*'(
W*)*
W*+,
W*-.
W*/0
W*12
W*34
W*56
W*78
W*9:
W*;<
W*=>
W*?@
W*AB
W*CD
W*EF
W*GH
W*IJ
W*KL
W*MN
W*OP
W*QR
W*ST
W*UV
W*WX
W*YZ
W*[\
W*]^
W*_`
W*ab
W*cd
W*ef
W*gh
W*ij
W*kl
W*mn
W*op
W*qr
W*st
W*uv
W*wx
W*yz
W* #
, 5 >
G P Y b k t } ! " #
$ % &( '1 (: )C *L +U ,^ -g .p /y 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B$ C- D6 E? FH GQ HZ Ic Jl Ku L~ M N O P Q R S T U V W X Y Z [ \ ] ^ _) `2 a; bD cM dV e_ fh gq hz i j k l m n o p q r s t u v w x
y z {% |. }7 ~@ I R [ e p {
+ 6 A L W b m x ( 3 > I T _ j u postgresql-jdbc-9.2-1002.src/org/postgresql/translation/messages_tr.class 0000664 0000000 0000000 00000063533 12050675701 0026545 0 ustar 00root root 0000000 0000000 -
u t
u
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ table Ljava/util/Hashtable; ()V Code LineNumberTable handleGetObject &(Ljava/lang/String;)Ljava/lang/Object;
Exceptions getKeys ()Ljava/util/Enumeration; getParent ()Ljava/util/ResourceBundle;
SourceFile messages_tr.java xy vw java/util/Hashtable Project-Id-Version: jdbc-tr
Report-Msgid-Bugs-To:
POT-Creation-Date: 2012-09-10 19:32-0400
PO-Revision-Date: 2009-05-31 21:47+0200
Last-Translator: Devrim GÜNDÜZ
Language-Team: Turkish
Language: tr
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
X-Generator: KBabel 1.3.1
X-Poedit-Language: Turkish
X-Poedit-Country: TURKEY
;Error loading default settings from driverconfig.properties Kdriverconfig.properties dosyasından varsayılan ayarları yükleme hatası Your security policy has prevented the connection from being attempted. You probably need to grant the connect java.net.SocketPermission to the database server host and port that you wish to connect to. Güvenlik politikanız bağlantının kurulmasını engelledi. java.net.SocketPermission'a veritabanına ve de bağlanacağı porta bağlantı izni vermelisiniz. XSomething unusual has occured to cause the driver to fail. Please report this exception. lSıradışı bir durum sürücünün hata vermesine sebep oldu. Lütfen bu durumu geliştiricilere bildirin. Connection attempt timed out. .Bağlantı denemesi zaman aşımına uğradı. (Interrupted while attempting to connect. Bağlanırken kesildi. "Method {0} is not yet implemented. {0} yöntemi henüz kodlanmadı. @A connection could not be made using the requested protocol {0}. 2İstenilen protokol ile bağlantı kurulamadı {0} EPremature end of input stream, expected {0} bytes, but only read {1}. XGiriş akımında beklenmeyen dosya sonu, {0} bayt beklenirken sadece {1} bayt alındı. %Expected an EOF from server, got: {0} )Sunucudan EOF beklendi; ama {0} alındı. -An unexpected result was returned by a query. )Sorgu beklenmeyen bir sonuç döndürdü. JIllegal UTF-8 sequence: byte {0} of {1} byte sequence is not 10xxxxxx: {2} MGeçersiz UTF-8 çoklu bayt karakteri: {0}/{1} baytı 10xxxxxx değildir: {2} FIllegal UTF-8 sequence: {0} bytes used to encode a {1} byte value: {2} dGeçersiz UTF-8 çoklu bayt karakteri: {0} bayt, {1} bayt değeri kodlamak için kullanılmış: {2} 0Illegal UTF-8 sequence: initial byte is {0}: {1} 8Geçersiz UTF-8 çoklu bayt karakteri: ilk bayt {0}: {1} 8Illegal UTF-8 sequence: final value is out of range: {0} HGeçersiz UTF-8 çoklu bayt karakteri: son değer sıra dışıdır: {0} =Illegal UTF-8 sequence: final value is a surrogate value: {0} JGeçersiz UTF-8 çoklu bayt karakteri: son değer yapay bir değerdir: {0} .Zero bytes may not occur in string parameters. ,String parametrelerinde sıfır bayt olamaz. (Zero bytes may not occur in identifiers. #Belirteçlerde sıfır bayt olamaz. -Cannot convert an instance of {0} to type {1} .{0} instance, {1} tipine dönüştürülemiyor yConnection refused. Check that the hostname and port are correct and that the postmaster is accepting TCP/IP connections. Bağlantı reddedildi. Sunucu adı ve portun doğru olup olmadığını ve postmaster''in TCP/IP bağlantılarını kabul edip etmediğini kontrol ediniz. The connection attempt failed. &Bağlantı denemesi başarısız oldu. The server does not support SSL. Sunucu SSL desteklemiyor. 5An error occured while setting up the SSL connection. 1SSL bağlantısı ayarlanırken bir hata oluştu. Connection rejected: {0}. Bağlantı reddedildi {0} QThe server requested password-based authentication, but no password was provided. KSunucu şifre tabanlı yetkilendirme istedi; ancak bir şifre sağlanmadı. The authentication type {0} is not supported. Check that you have configured the pg_hba.conf file to include the client''s IP address or subnet, and that it is using an authentication scheme supported by the driver.{0} yetkinlendirme tipi desteklenmemektedir. pg_hba.conf dosyanızı istemcinin IP adresini ya da subnetini içerecek şekilde ayarlayıp ayarlamadığınızı ve sürücü tarafından desteklenen yetkilendirme yöntemlerinden birisini kullanıp kullanmadığını kontrol ediniz. &Protocol error. Session setup failed. 5Protokol hatası. Oturum kurulumu başarısız oldu. Backend start-up failed: {0}. *Backend başlaması başarısız oldu: {0} >The column index is out of range: {0}, number of columns: {1}. ASütun gçstergesi kapsam dışıdır: {0}, sütun sayısı: {1}. %No value specified for parameter {0}. 3{0} parametresi için hiç bir değer belirtilmedi. 'Expected command status BEGIN, got {0}. .BEGIN komut durumunu beklenirken {0} alındı. Unexpected command status: {0}. Beklenmeyen komut durumu: {0}. 2An I/O error occured while sending to the backend. 0Backend''e gönderirken bir I/O hatası oluştu. Unknown Response Type {0}. Bilinmeyen yanıt tipi {0} +Ran out of memory retrieving query results. .Sorgu sonuçları alınırken bellek yetersiz. DUnable to interpret the update count in command completion tag: {0}. @Komut tamamlama etiketinde update sayısı yorumlanamıyor: {0}. .Unable to bind parameter values for statement. .Komut için parametre değerlei bağlanamadı. Bind message length {0} too long. This can be caused by very large or incorrect length specifications on InputStream parameters. lBind mesaj uzunluğu ({0}) fazla uzun. Bu durum InputStream yalnış uzunluk belirtimlerden kaynaklanabilir. The server''s DateStyle parameter was changed to {0}. The JDBC driver requires DateStyle to begin with ISO for correct operation. Sunucunun DateStyle parametresi {0} olarak değiştirildi. JDBC sürücüsü doğru işlemesi için DateStyle tanımının ISO işle başlamasını gerekir. lThe server''s standard_conforming_strings parameter was reported as {0}. The JDBC driver expected on or off. İstemcinin client_standard_conforming_strings parametresi {0} olarak raporlandı. JDBC sürücüsü on ya da off olarak bekliyordu. 6The driver currently does not support COPY operations. 9Bu sunucu şu aşamada COPY işlemleri desteklememktedir. .This PooledConnection has already been closed. 5Geçerli PooledConnection zaten önceden kapatıldı. Connection has been closed automatically because a new connection was opened for the same PooledConnection or the PooledConnection has been closed. PooledConnection kapatıldığı için veya aynı PooledConnection için yeni bir bağlantı açıldığı için geçerli bağlantı otomatik kapatıldı. Connection has been closed. Bağlantı kapatıldı. Statement has been closed. Komut kapatıldı. DataSource has been closed. DataSource kapatıldı. FFastpath call {0} - No result was returned and we expected an integer. CFastpath call {0} - Integer beklenirken hiçbir sonuç getirilmedi. %The fastpath function {0} is unknown. ({0} fastpath fonksiyonu bilinmemektedir. #Conversion to type {0} failed: {1}. ,{0} veri tipine dönüştürme hatası: {1}. +Cannot tell if path is open or closed: {0}. The array index is out of range: {0}, number of elements: {1}. ?Dizin göstergisi kapsam dışıdır: {0}, öğe sayısı: {1}. Invalid character data was found. This is most likely caused by stored data containing characters that are invalid for the character set the database was created in. The most common example of this is storing 8bit data in a SQL_ASCII database. Geçersiz karakterler bulunmuştur. Bunun sebebi, verilerde veritabanın desteklediği dil kodlamadaki karakterlerin dışında bir karaktere rastlamasıdır. Bunun en yaygın örneği 8 bitlik veriyi SQL_ASCII veritabanında saklamasıdır. ITruncation of large objects is only implemented in 8.3 and later servers. KLarge objectlerin temizlenmesi 8.3 ve sonraki sürümlerde kodlanmıştır. &PostgreSQL LOBs can only index to: {0} 9PostgreSQL LOB göstergeleri sadece {0} referans edebilir #LOB positioning offsets start at 1. 'LOB bağlangıç adresi 1Den başlıyor (free() was called on this LOB previously *Bu LOB'da free() daha önce çağırıldı /Unsupported value for stringtype parameter: {0} 6strinftype parametresi için destekleneyen değer: {0} &No results were returned by the query. "Sorgudan hiç bir sonuç dönmedi. -A result was returned when none was expected. /Hiçbir sonuç kebklenimezken sonuç getirildi. #Custom type maps are not supported. *Özel tip eşleştirmeleri desteklenmiyor. !Failed to create object for: {0}. #{0} için nesne oluşturma hatası. =Unable to load the class {0} responsible for the datatype {1} 4{1} veri tipinden sorumlu {0} sınıfı yüklenemedi LCannot change transaction read-only property in the middle of a transaction. STransaction ortasında geçerli transactionun read-only özellği değiştirilemez. ICannot change transaction isolation level in the middle of a transaction. eTransaction ortasında geçerli transactionun transaction isolation level özellği değiştirilemez. .Transaction isolation level {0} not supported. /Transaction isolation level {0} desteklenmiyor. .Finalizing a Connection that was never closed: .Kapatılmamış bağlantı sonlandırılıyor. 3Unable to translate data into the desired encoding. /Veri, istenilen dil kodlamasına çevrilemiyor. PUnable to determine a value for MaxIndexKeys due to missing system catalog data. OSistem kataloğu olmadığından MaxIndexKeys değerini tespit edilememektedir. 4Unable to find name datatype in the system catalogs. 3Sistem kataloglarında name veri tipi bulunamıyor. NOperation requires a scrollable ResultSet, but this ResultSet is FORWARD_ONLY. Sİşlem, kaydırılabilen ResultSet gerektirir, ancak bu ResultSet FORWARD_ONLYdir. CUnexpected error while decoding character data from a large object. ELarge-object nesnesinden karakter veriyi çözerken beklenmeyen hata. 9Can''t use relative move methods while on the insert row. ;Insert kaydı üzerinde relative move method kullanılamaz. &Invalid fetch direction constant: {0}. *Getirme yönü değişmezi geçersiz: {0}. 6Cannot call cancelRowUpdates() when on the insert row. IInsert edilmiş kaydın üzerindeyken cancelRowUpdates() çağırılamaz. /Cannot call deleteRow() when on the insert row. 5Insert kaydı üzerinde deleteRow() çağırılamaz. ZCurrently positioned before the start of the ResultSet. You cannot call deleteRow() here. ]Şu an ResultSet başlangcıından önce konumlandı. deleteRow() burada çağırabilirsiniz. WCurrently positioned after the end of the ResultSet. You cannot call deleteRow() here. VŞu an ResultSet sonucundan sonra konumlandı. deleteRow() burada çağırabilirsiniz. $There are no rows in this ResultSet. (Bu ResultSet içinde kayıt bulunamadı. Not on the insert row. Insert kaydı değil. ;You must specify at least one column value to insert a row. DBir satır eklemek için en az bir sütun değerini belirtmelisiniz. /The JVM claims not to support the encoding: {0} .JVM, {0} dil kodlamasını desteklememektedir. Provided InputStream failed. &Sağlanmış InputStream başarısız. Provided Reader failed. Can''t refresh the insert row. Inser satırı yenilenemiyor. /Cannot call updateRow() when on the insert row. 5Insert kaydı üzerinde updateRow() çağırılamaz. bCannot update the ResultSet because it is either before the start or after the end of the results. tResultSet, sonuçların ilk kaydından önce veya son kaydından sonra olduğu için güncelleme yapılamamaktadır. ?ResultSets with concurrency CONCUR_READ_ONLY cannot be updated. CEş zamanlama CONCUR_READ_ONLY olan ResultSet''ler değiştirilemez #No primary key found for table {0}. {0} tablosunda primary key yok. 4Fetch size must be a value greater to or equal to 0. >Fetch boyutu sıfır veya daha büyük bir değer olmalıdır. Bad value for type {0} : {1} *{0} veri tipi için geçersiz değer : {1} 4The column name {0} was not found in this ResultSet. 1Bu ResultSet içinde {0} sütun adı bulunamadı. ResultSet is not updateable. The query that generated this result set must select only one table, and must select all primary keys from that table. See the JDBC 2.1 API Specification, section 5.6 for more details. ResultSet değiştirilemez. Bu sonucu üreten sorgu tek bir tablodan sorgulamalı ve tablonun tüm primary key alanları belirtmelidir. Daha fazla bilgi için bk. JDBC 2.1 API Specification, section 5.6. This ResultSet is closed. ResultSet kapalıdır. AResultSet not positioned properly, perhaps you need to call next. JResultSet doğru konumlanmamıştır, next işlemi çağırmanız gerekir. ICan''t use query methods that take a query string on a PreparedStatement. JPreparedStatement ile sorgu satırı alan sorgu yöntemleri kullanılamaz. /Multiple ResultSets were returned by the query. 3Sorgu tarafından birden fazla ResultSet getirildi. 7A CallableStatement was executed with nothing returned. ) was made. _CallableStatement bildirildi ancak registerOutParameter(1, < bir tip>) tanıtımı yapılmadı. $No function outputs were registered. +Hiçbir fonksiyon çıktısı kaydedilmedi. KResults cannot be retrieved from a CallableStatement before it is executed. ACallableStatement çalıştırılmadan sonuçlar ondan alınamaz. This statement has been closed. Bu komut kapatıldı. &Too many update results were returned. -Çok fazla güncelleme sonucu döndürüldü. IBatch entry {0} {1} was aborted. Call getNextException to see the cause. gTpilı iş girişi {0} {1} durduruldu. Nedenini görmek için getNextException fonksiyonu çağırın. 2Unexpected error writing large object to database. 9Large object veritabanına yazılırken beklenmeyan hata. -{0} function takes one and only one argument. 4{0} fonksiyonunu yalnız tek bir parametre alabilir. .{0} function takes two and only two arguments. /{0} fonksiyonunu sadece iki parametre alabilir. /{0} function takes four and only four argument. 2{0} fonksiyonunu yalnız dört parametre alabilir. *{0} function takes two or three arguments. 7{0} fonksiyonu yalnız iki veya üç argüman alabilir. ({0} function doesn''t take any argument. {0} fonksiyonu parametre almaz. 2{0} function takes three and only three arguments. 0{0} fonksiyonunu sadece üç parametre alabilir. Interval {0} not yet implemented "{0} aralığı henüz kodlanmadı. LInfinite value found for timestamp/date. This cannot be represented as time. STimestamp veri tipinde sonsuz değer bulunmuştur. Buna uygun bir gösterim yoktur. >The class {0} does not implement org.postgresql.util.PGobject. >{0} sınıfı org.postgresql.util.PGobject implemente etmiyor. +Unknown ResultSet holdability setting: {0}. *ResultSet tutabilme ayarı geçersiz: {0}. 7Server versions prior to 8.0 do not support savepoints. DSunucunun 8.0''dan önceki sürümler savepoint desteklememektedir. 1Cannot establish a savepoint in auto-commit mode. 1Auto-commit biçimde savepoint oluşturulamıyor. .Returning autogenerated keys is not supported. ?Otomatik üretilen değerlerin getirilmesi desteklenememktedir. DThe parameter index is out of range: {0}, number of parameters: {1}. IReturning autogenerated keys is only supported for 8.2 and later servers. xOtomatik üretilen anahtarların döndürülmesi sadece 8.2 ve üzerindeki sürümlerdeki sunucularda desteklenmektedir. >Returning autogenerated keys by column index is not supported. gKolonların indexlenmesi ile otomatik olarak oluşturulan anahtarların döndürülmesi desteklenmiyor. 8Cannot reference a savepoint after it has been released. 3Bırakıldıktan sonra savepoint referans edilemez. ,Cannot retrieve the id of a named savepoint. 9Adlandırılmış savepointin id değerine erişilemiyor. 1Cannot retrieve the name of an unnamed savepoint. 8Adı verilmemiş savepointin id değerine erişilemiyor. Invalid UUID data. Geçersiz UUID verisi. 7Unable to find server array type for provided name {0}. 8Belirtilen {0} adı için sunucu array tipi bulunamadı. "ClientInfo property not supported. +Clientinfo property'si desteklenememktedir. Unable to decode xml data. !XML verisinin kodu çözülemedi. Unknown XML Source class: {0} $Bilinmeyen XML Kaynak Sınıfı: {0} &Unable to create SAXResult for SQLXML. &SQLXML için SAXResult yaratılamadı. &Unable to create StAXResult for SQLXML &SQLXML için StAXResult yaratılamadı Unknown XML Result class: {0} %Bilinmeyen XML Sonuç sınıfı: {0}. *This SQLXML object has already been freed. (Bu SQLXML nesnesi zaten boşaltılmış. QThis SQLXML object has not been initialized, so you cannot retrieve data from it. HBu SQLXML nesnesi ilklendirilmemiş; o yüzden ondan veri alamazsınız. 3Failed to convert binary xml data to encoding: {0}. Fxml verisinin şu dil kodlamasına çevirilmesi başarısız oldu: {0} 4Unable to convert DOMResult SQLXML data to a string. 6DOMResult SQLXML verisini diziye dönüştürülemedi. UThis SQLXML object has already been initialized, so you cannot manipulate it further. \Bu SQLXML nesnesi daha önceden ilklendirilmiştir; o yüzden daha fazla müdahale edilemez. $Failed to initialize LargeObject API #LArgeObject API ilklendirme hatası 2Large Objects may not be used in auto-commit mode. 0Auto-commit biçimde large object kullanılamaz. BThe SSLSocketFactory class provided {0} could not be instantiated. 'SSLSocketFactory {0} ile örneklenmedi. Conversion of interval failed 'Interval dönüştürmesi başarısız. Conversion of money failed. $Money dönüştürmesi başarısız. Detail: {0} Ayrıntı: {0} Hint: {0} İpucu: {0}
Position: {0}
Where: {0} Internal Query: {0} Internal Position: {0} ,Location: File: {0}, Routine: {1}, Line: {2} )Yer: Dosya: {0}, Yordam: {1}, Satır: {2} Server SQLState: {0} Sunucu SQLState: {0}
Invalid flags Geçersiz seçenekler xid must not be null xid null olamaz +Connection is busy with another transaction ?Bağlantı, başka bir transaction tarafından meşgul ediliyor suspend/resume not implemented suspend/resume desteklenmiyor (Transaction interleaving not implemented (Transaction interleaving desteklenmiyor. Error disabling autocommit 4autocommit'i devre dışı bırakma sırasında hata 2tried to call end without corresponding start call 4start çağırımı olmadan end çağırılmıştır ^Not implemented: Prepare must be issued using the same connection that started the transaction XDesteklenmiyor: Prepare, transaction başlatran bağlantı tarafından çağırmalıdır Prepare called before end %Sondan önce prepare çağırılmış =Server versions prior to 8.1 do not support two-phase commit. KSunucunun 8.1''den önceki sürümler two-phase commit desteklememektedir. Error preparing transaction Transaction hazırlama hatası Invalid flag Geçersiz seçenek Error during recover Kurtarma sırasında hata 'Error rolling back prepared transaction +Hazırlanmış transaction rollback hatası dNot implemented: one-phase commit must be issued using the same connection that was used to start it ^Desteklenmiyor: one-phase commit, işlevinde başlatan ve bitiren bağlantı aynı olmalıdır commit called before end #commit, sondan önce çağırıldı Error during one-phase commit !One-phase commit sırasında hata INot implemented: 2nd phase commit must be issued using an idle connection MDesteklenmiyor: 2nd phase commit, atıl bir bağlantıdan başlatılmalıdır 'Heuristic commit/rollback not supported (Heuristic commit/rollback desteklenmiyor &org/postgresql/translation/messages_tr java/util/ResourceBundle "java/util/MissingResourceException get &(Ljava/lang/Object;)Ljava/lang/Object; keys parent Ljava/util/ResourceBundle; put 8(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object; !tu vw xy z * { |} z + { ~ z { z * { y z
Y K*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*!"
W*#$
W*%&
W*'(
W*)*
W*+,
W*-.
W*/0
W*12
W*34
W*56
W*78
W*9:
W*;<
W*=>
W*?@
W*AB
W*CD
W*EF
W*GH
W*IJ
W*KL
W*MN
W*OP
W*QR
W*ST
W*UV
W*WX
W*YZ
W*[\
W*]^
W*_`
W*ab
W*cd
W*ef
W*gh
W*ij
W*kl
W*mn
W*op
W*qr
W*st
W*uv
W*wx
W*yz
W*{|
W*}~
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*ö
W*Ŷ
W*Ƕ
W*ɶ
W*˶
W*Ͷ
W*϶
W*Ѷ
W*Ӷ
W*ն
W*
W*ٶ
W*
W*ܶ
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*
W*p
W*
W*
W*
W*
W*
W*
W* !
W*"#
W*$%
W*&'
W*()
W**+
W*,-
W*./
W*01
W*23
W*45
W*67
W*89
W*:;
W*<=
W*>?
W*@A
W*BC
W*DE
W*FF
W*GG
W*HH
W*II
W*JK
W*LM
W*NO
W*PQ
W*RS
W*TU
W*VW
W*XY
W*Z[
W*\]
W*^_
W*`a
W*bc
W*de
W*fg
W*hi
W*jk
W*lm
W*no
W*pq
W*rs
W* { #
, 5 >
G P Y b k t } ! " #
$ % &( '1 (: )C *L +U ,^ -g .p /y 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B$ C- D6 E? FH GQ HZ Ic Jl Ku L~ M N O P Q R S T U V W X Y Z [ \ ] ^ _) `2 a; bD cM dV e_ fh gq hz i j k l m n o p q r s t u v w x
y z {% |. }7 ~@ I R [ d n y ( 3 > I T _ j u % 0 ; F Q \ g r } postgresql-jdbc-9.2-1002.src/org/postgresql/translation/messages_zh_CN.class 0000664 0000000 0000000 00000041767 12050675701 0027126 0 ustar 00root root 0000000 0000000 -
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
table Ljava/util/Hashtable; ()V Code LineNumberTable handleGetObject &(Ljava/lang/String;)Ljava/lang/Object;
Exceptions getKeys ()Ljava/util/Enumeration; getParent ()Ljava/util/ResourceBundle;