/usr/lib/ruby/vendor_ruby/sequel/adapters/jdbc/postgresql.rb is in ruby-sequel 4.1.1-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 | Sequel.require 'adapters/shared/postgres'
module Sequel
Postgres::CONVERTED_EXCEPTIONS << NativeException
module JDBC
# Adapter, Database, and Dataset support for accessing a PostgreSQL
# database via JDBC.
module Postgres
# Methods to add to Database instances that access PostgreSQL via
# JDBC.
module DatabaseMethods
extend Sequel::Database::ResetIdentifierMangling
include Sequel::Postgres::DatabaseMethods
# Add the primary_keys and primary_key_sequences instance variables,
# so we can get the correct return values for inserted rows.
def self.extended(db)
super
db.send(:initialize_postgres_adapter)
end
# See Sequel::Postgres::Adapter#copy_into
def copy_into(table, opts=OPTS)
data = opts[:data]
data = Array(data) if data.is_a?(String)
if block_given? && data
raise Error, "Cannot provide both a :data option and a block to copy_into"
elsif !block_given? && !data
raise Error, "Must provide either a :data option or a block to copy_into"
end
synchronize(opts) do |conn|
begin
copy_manager = org.postgresql.copy.CopyManager.new(conn)
copier = copy_manager.copy_in(copy_into_sql(table, opts))
if block_given?
while buf = yield
copier.writeToCopy(buf.to_java_bytes, 0, buf.length)
end
else
data.each { |d| copier.writeToCopy(d.to_java_bytes, 0, d.length) }
end
rescue Exception => e
copier.cancelCopy
raise
ensure
unless e
begin
copier.endCopy
rescue NativeException => e2
raise_error(e2)
end
end
end
end
end
# See Sequel::Postgres::Adapter#copy_table
def copy_table(table, opts=OPTS)
synchronize(opts[:server]) do |conn|
copy_manager = org.postgresql.copy.CopyManager.new(conn)
copier = copy_manager.copy_out(copy_table_sql(table, opts))
begin
if block_given?
while buf = copier.readFromCopy
yield(String.from_java_bytes(buf))
end
nil
else
b = ''
while buf = copier.readFromCopy
b << String.from_java_bytes(buf)
end
b
end
ensure
raise DatabaseDisconnectError, "disconnecting as a partial COPY may leave the connection in an unusable state" if buf
end
end
end
private
# Use setNull for nil arguments as the default behavior of setString
# with nil doesn't appear to work correctly on PostgreSQL.
def set_ps_arg_nil(cps, i)
cps.setNull(i, JavaSQL::Types::NULL)
end
# Execute the connection configuration SQL queries on the connection.
def setup_connection(conn)
conn = super(conn)
statement(conn) do |stmt|
connection_configuration_sqls.each{|sql| log_yield(sql){stmt.execute(sql)}}
end
conn
end
end
# Dataset subclass used for datasets that connect to PostgreSQL via JDBC.
class Dataset < JDBC::Dataset
include Sequel::Postgres::DatasetMethods
APOS = Dataset::APOS
class ::Sequel::JDBC::Dataset::TYPE_TRANSLATOR
# Convert Java::OrgPostgresqlUtil::PGobject to ruby strings
def pg_object(v)
v.to_string
end
end
# Handle conversions of PostgreSQL array instances
class PGArrayConverter
# Set the method that will return the correct conversion
# proc for elements of this array.
def initialize(meth)
@conversion_proc_method = meth
@conversion_proc = nil
end
# Convert Java::OrgPostgresqlJdbc4::Jdbc4Array to ruby arrays
def call(v)
_pg_array(v.array)
end
private
# Handle multi-dimensional Java arrays by recursively mapping them
# to ruby arrays of ruby values.
def _pg_array(v)
v.to_ary.map do |i|
if i.respond_to?(:to_ary)
_pg_array(i)
elsif i
if @conversion_proc.nil?
@conversion_proc = @conversion_proc_method.call(i)
end
if @conversion_proc
@conversion_proc.call(i)
else
i
end
else
i
end
end
end
end
PG_OBJECT_METHOD = TYPE_TRANSLATOR_INSTANCE.method(:pg_object)
# Add the shared PostgreSQL prepared statement methods
def prepare(type, name=nil, *values)
ps = to_prepared_statement(type, values)
ps.extend(JDBC::Dataset::PreparedStatementMethods)
ps.extend(::Sequel::Postgres::DatasetMethods::PreparedStatementMethods)
if name
ps.prepared_statement_name = name
db.set_prepared_statement(name, ps)
end
ps
end
private
# Handle PostgreSQL array and object types. Object types are just
# turned into strings, similarly to how the native adapter treats
# the types.
def convert_type_proc(v)
case v
when Java::OrgPostgresqlJdbc4::Jdbc4Array
PGArrayConverter.new(method(:convert_type_proc))
when Java::OrgPostgresqlUtil::PGobject
PG_OBJECT_METHOD
else
super
end
end
# Literalize strings similar to the native postgres adapter
def literal_string_append(sql, v)
sql << APOS << db.synchronize(@opts[:server]){|c| c.escape_string(v)} << APOS
end
end
end
end
end
|