cipherstash-pg 1.0.0.beta.1-arm64-darwin-22 → 1.0.0.beta.3-arm64-darwin-22

data/translation/po4a.cfg

@@ -0,0 +1,9 @@
+[po_directory] po
+
+[options] --master-charset UTF-8 \
+   --localized-charset UTF-8 \
+   --master-language en \
+   --option markdown \
+   --keep 0
+
+[type:text] ../README.md ja:../README.ja.md

metadata

@@ -1,60 +1,74 @@
 --- !ruby/object:Gem::Specification
 name: cipherstash-pg
 version: !ruby/object:Gem::Version
-  version: 1.0.0.beta.1
+  version: 1.0.0.beta.3
 platform: arm64-darwin-22
 authors:
-- CipherStash
+- CipherStash Engineers
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-04-06 00:00:00.000000000 Z
+date: 2023-05-01 00:00:00.000000000 Z
 dependencies: []
-description: CipherStash PG is a drop in replacement of PG that provides transparent
-  data encryption, with a PG-compatible API
+description: CipherStashPG is the Ruby interface to CipherStash-enhanced PostgresQL,
+  based on PG. Known to work on Postgres 14+ (might work on older version)
 email:
 - engineers@cipherstash.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- "./.appveyor.yml"
+- "./.gems"
+- "./.gemtest"
+- "./.github/workflows/binary-gems.yml"
+- "./.github/workflows/source-gem.yml"
+- "./.gitignore"
+- "./.hgsigs"
+- "./.hgtags"
+- "./.irbrc"
+- "./.pryrc"
+- "./.tm_properties"
+- "./.travis.yml"
 - "./BSDL"
 - "./Contributors.rdoc"
 - "./Gemfile"
-- "./History.rdoc"
+- "./Gemfile.lock"
+- "./History.md"
 - "./LICENSE"
 - "./Manifest.txt"
 - "./POSTGRES"
 - "./README-OS_X.rdoc"
 - "./README-Windows.rdoc"
-- "./README.ja.rdoc"
-- "./README.rdoc"
+- "./README.ja.md"
+- "./README.md"
 - "./Rakefile"
+- "./Rakefile.cross"
 - "./certs/ged.pem"
 - "./certs/larskanis-2022.pem"
+- "./certs/larskanis-2023.pem"
 - "./cipherstash-pg.gemspec"
 - "./lib/2.7/pg_ext.bundle"
 - "./lib/3.0/pg_ext.bundle"
 - "./lib/3.1/pg_ext.bundle"
 - "./lib/3.2/pg_ext.bundle"
 - "./lib/cipherstash-pg.rb"
+- "./lib/cipherstash-pg/basic_type_map_based_on_result.rb"
+- "./lib/cipherstash-pg/basic_type_map_for_queries.rb"
+- "./lib/cipherstash-pg/basic_type_map_for_results.rb"
+- "./lib/cipherstash-pg/basic_type_registry.rb"
+- "./lib/cipherstash-pg/binary_decoder.rb"
+- "./lib/cipherstash-pg/coder.rb"
+- "./lib/cipherstash-pg/connection.rb"
+- "./lib/cipherstash-pg/constants.rb"
+- "./lib/cipherstash-pg/exceptions.rb"
+- "./lib/cipherstash-pg/result.rb"
+- "./lib/cipherstash-pg/text_decoder.rb"
+- "./lib/cipherstash-pg/text_encoder.rb"
+- "./lib/cipherstash-pg/tuple.rb"
+- "./lib/cipherstash-pg/type_map_by_column.rb"
+- "./lib/cipherstash-pg/version.rb"
 - "./lib/libpq.5.dylib"
-- "./lib/pg.rb"
-- "./lib/pg/basic_type_map_based_on_result.rb"
-- "./lib/pg/basic_type_map_for_queries.rb"
-- "./lib/pg/basic_type_map_for_results.rb"
-- "./lib/pg/basic_type_registry.rb"
-- "./lib/pg/binary_decoder.rb"
-- "./lib/pg/coder.rb"
-- "./lib/pg/connection.rb"
-- "./lib/pg/constants.rb"
-- "./lib/pg/exceptions.rb"
-- "./lib/pg/result.rb"
-- "./lib/pg/text_decoder.rb"
-- "./lib/pg/text_encoder.rb"
-- "./lib/pg/tuple.rb"
-- "./lib/pg/type_map_by_column.rb"
-- "./lib/pg/version.rb"
 - "./misc/openssl-pg-segfault.rb"
 - "./misc/postgres/History.txt"
 - "./misc/postgres/Manifest.txt"
@@ -86,17 +100,23 @@ files:
 - "./sample/test_binary_values.rb"
 - "./sample/wal_shipper.rb"
 - "./sample/warehouse_partitions.rb"
-- "./vendor/database-extensions/install.sql"
-- "./vendor/database-extensions/uninstall.sql"
+- "./translation/.po4a-version"
+- "./translation/po/all.pot"
+- "./translation/po/ja.po"
+- "./translation/po4a.cfg"
 homepage: https://github.com/cipherstash/cipherstash-pg
 licenses:
 - BSD-2-Clause
 metadata:
   homepage_uri: https://github.com/cipherstash/cipherstash-pg
   source_code_uri: https://github.com/cipherstash/cipherstash-pg
-  documentation_uri: http://deveiate.org/code/pg
+  derived_from_pg_gem_version: 1.4.6
 post_install_message:
-rdoc_options: []
+rdoc_options:
+- "--main"
+- README.md
+- "--title"
+- 'CipherStashPG: The Ruby PostgreSQL Driver for CipherStash-enhanced PostgreSQL'
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
@@ -113,6 +133,6 @@ requirements: []
 rubygems_version: 3.4.6
 signing_key:
 specification_version: 4
-summary: CipherStash PG is a drop in replacement of PG that provides transparent data
-  encryption
+summary: CipherStashPG is the Ruby interface to CipherStash-enhanced PostgresQL, based
+  on PG
 test_files: []

data/README.ja.rdoc

@@ -1,13 +0,0 @@
-= pg
-
-home :: https://github.com/ged/ruby-pg
-docs :: http://deveiate.org/code/pg
-
-
-== Description
-
-This file needs a translation of the English README. Pull requests, patches, or
-volunteers gladly accepted.
-
-Until such time, please accept my sincere apologies for not knowing Japanese.
-

data/README.rdoc

@@ -1,233 +0,0 @@
-= pg
-
-home :: https://github.com/ged/ruby-pg
-docs :: http://deveiate.org/code/pg
-clog :: link:/History.rdoc
-
-{<img src="https://badges.gitter.im/Join%20Chat.svg" alt="Join the chat at https://gitter.im/ged/ruby-pg">}[https://gitter.im/ged/ruby-pg?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge]
-
-
-== Description
-
-Pg is the Ruby interface to the {PostgreSQL RDBMS}[http://www.postgresql.org/].
-
-It works with {PostgreSQL 9.3 and later}[http://www.postgresql.org/support/versioning/].
-
-A small example usage:
-
-  #!/usr/bin/env ruby
-
-  require 'pg'
-
-  # Output a table of current connections to the DB
-  conn = PG.connect( dbname: 'sales' )
-  conn.exec( "SELECT * FROM pg_stat_activity" ) do |result|
-    puts "     PID | User             | Query"
-    result.each do |row|
-      puts " %7d | %-16s | %s " %
-        row.values_at('pid', 'usename', 'query')
-    end
-  end
-
-== Build Status
-
-{<img src="https://github.com/ged/ruby-pg/actions/workflows/source-gem.yml/badge.svg?branch=master" alt="Build Status Github Actions" />}[https://github.com/ged/ruby-pg/actions/workflows/source-gem.yml]
-{<img src="https://ci.appveyor.com/api/projects/status/gjx5axouf3b1wicp?svg=true" alt="Build Status Appveyor" />}[https://ci.appveyor.com/project/ged/ruby-pg-9j8l3]
-{<img src="https://app.travis-ci.com/larskanis/ruby-pg.svg?branch=master" alt="Build Status" />}[https://app.travis-ci.com/larskanis/ruby-pg]
-
-== Requirements
-
-* Ruby 2.4 or newer
-* PostgreSQL 9.3.x or later (with headers, -dev packages, etc).
-
-It usually works with earlier versions of Ruby/PostgreSQL as well, but those are
-not regularly tested.
-
-
-== Versioning
-
-We tag and release gems according to the {Semantic Versioning}[http://semver.org/] principle.
-
-As a result of this policy, you can (and should) specify a dependency on this gem using the {Pessimistic Version Constraint}[http://guides.rubygems.org/patterns/#pessimistic-version-constraint] with two digits of precision.
-
-For example:
-
-  spec.add_dependency 'pg', '~> 1.0'
-
-
-== How To Install
-
-Install via RubyGems:
-
-    gem install pg
-
-You may need to specify the path to the 'pg_config' program installed with
-Postgres:
-
-    gem install pg -- --with-pg-config=<path to pg_config>
-
-If you're installing via Bundler, you can provide compile hints like so:
-
-    bundle config build.pg --with-pg-config=<path to pg_config>
-
-See README-OS_X.rdoc for more information about installing under MacOS X, and
-README-Windows.rdoc for Windows build/installation instructions.
-
-There's also {a Google+ group}[http://goo.gl/TFy1U] and a
-{mailing list}[http://groups.google.com/group/ruby-pg] if you get stuck, or just
-want to chat about something.
-
-If you want to install as a signed gem, the public certs of the gem signers
-can be found in {the `certs` directory}[https://github.com/ged/ruby-pg/tree/master/certs]
-of the repository.
-
-
-== Type Casts
-
-Pg can optionally type cast result values and query parameters in Ruby or
-native C code. This can speed up data transfers to and from the database,
-because String allocations are reduced and conversions in (slower) Ruby code
-can be omitted.
-
-Very basic type casting can be enabled by:
-
-    conn.type_map_for_results = PG::BasicTypeMapForResults.new conn
-    # ... this works for result value mapping:
-    conn.exec("select 1, now(), '{2,3}'::int[]").values
-        # => [[1, 2014-09-21 20:51:56 +0200, [2, 3]]]
-
-    conn.type_map_for_queries = PG::BasicTypeMapForQueries.new conn
-    # ... and this for param value mapping:
-    conn.exec_params("SELECT $1::text, $2::text, $3::text", [1, 1.23, [2,3]]).values
-        # => [["1", "1.2300000000000000E+00", "{2,3}"]]
-
-But Pg's type casting is highly customizable. That's why it's divided into
-2 layers:
-
-=== Encoders / Decoders (ext/pg_*coder.c, lib/pg/*coder.rb)
-
-This is the lower layer, containing encoding classes that convert Ruby
-objects for transmission to the DBMS and decoding classes to convert
-received data back to Ruby objects. The classes are namespaced according
-to their format and direction in PG::TextEncoder, PG::TextDecoder,
-PG::BinaryEncoder and PG::BinaryDecoder.
-
-It is possible to assign a type OID, format code (text or binary) and
-optionally a name to an encoder or decoder object. It's also possible
-to build composite types by assigning an element encoder/decoder.
-PG::Coder objects can be used to set up a PG::TypeMap or alternatively
-to convert single values to/from their string representation.
-
-The following PostgreSQL column types are supported by ruby-pg (TE = Text Encoder, TD = Text Decoder, BE = Binary Encoder, BD = Binary Decoder):
-* Integer: {TE}[rdoc-ref:PG::TextEncoder::Integer], {TD}[rdoc-ref:PG::TextDecoder::Integer], {BD}[rdoc-ref:PG::BinaryDecoder::Integer] 💡 No links? Switch to {here}[https://deveiate.org/code/pg/README_rdoc.html#label-Type+Casts] 💡
-  * BE: {Int2}[rdoc-ref:PG::BinaryEncoder::Int2], {Int4}[rdoc-ref:PG::BinaryEncoder::Int4], {Int8}[rdoc-ref:PG::BinaryEncoder::Int8]
-* Float: {TE}[rdoc-ref:PG::TextEncoder::Float], {TD}[rdoc-ref:PG::TextDecoder::Float], {BD}[rdoc-ref:PG::BinaryDecoder::Float]
-* Numeric: {TE}[rdoc-ref:PG::TextEncoder::Numeric], {TD}[rdoc-ref:PG::TextDecoder::Numeric]
-* Boolean: {TE}[rdoc-ref:PG::TextEncoder::Boolean], {TD}[rdoc-ref:PG::TextDecoder::Boolean], {BE}[rdoc-ref:PG::BinaryEncoder::Boolean], {BD}[rdoc-ref:PG::BinaryDecoder::Boolean]
-* String: {TE}[rdoc-ref:PG::TextEncoder::String], {TD}[rdoc-ref:PG::TextDecoder::String], {BE}[rdoc-ref:PG::BinaryEncoder::String], {BD}[rdoc-ref:PG::BinaryDecoder::String]
-* Bytea: {TE}[rdoc-ref:PG::TextEncoder::Bytea], {TD}[rdoc-ref:PG::TextDecoder::Bytea], {BE}[rdoc-ref:PG::BinaryEncoder::Bytea], {BD}[rdoc-ref:PG::BinaryDecoder::Bytea]
-* Base64: {TE}[rdoc-ref:PG::TextEncoder::ToBase64], {TD}[rdoc-ref:PG::TextDecoder::FromBase64], {BE}[rdoc-ref:PG::BinaryEncoder::FromBase64], {BD}[rdoc-ref:PG::BinaryDecoder::ToBase64]
-* Timestamp:
-  * TE: {local}[rdoc-ref:PG::TextEncoder::TimestampWithoutTimeZone], {UTC}[rdoc-ref:PG::TextEncoder::TimestampUtc], {with-TZ}[rdoc-ref:PG::TextEncoder::TimestampWithTimeZone]
-  * TD: {local}[rdoc-ref:PG::TextDecoder::TimestampLocal], {UTC}[rdoc-ref:PG::TextDecoder::TimestampUtc], {UTC-to-local}[rdoc-ref:PG::TextDecoder::TimestampUtcToLocal]
-  * BD: {local}[rdoc-ref:PG::BinaryDecoder::TimestampLocal], {UTC}[rdoc-ref:PG::BinaryDecoder::TimestampUtc], {UTC-to-local}[rdoc-ref:PG::BinaryDecoder::TimestampUtcToLocal]
-* Date: {TE}[rdoc-ref:PG::TextEncoder::Date], {TD}[rdoc-ref:PG::TextDecoder::Date]
-* JSON and JSONB: {TE}[rdoc-ref:PG::TextEncoder::JSON], {TD}[rdoc-ref:PG::TextDecoder::JSON]
-* Inet: {TE}[rdoc-ref:PG::TextEncoder::Inet], {TD}[rdoc-ref:PG::TextDecoder::Inet]
-* Array: {TE}[rdoc-ref:PG::TextEncoder::Array], {TD}[rdoc-ref:PG::TextDecoder::Array]
-* Composite Type (also called "Row" or "Record"): {TE}[rdoc-ref:PG::TextEncoder::Record], {TD}[rdoc-ref:PG::TextDecoder::Record]
-
-The following text formats can also be encoded although they are not used as column type:
-* COPY input and output data: {TE}[rdoc-ref:PG::TextEncoder::CopyRow], {TD}[rdoc-ref:PG::TextDecoder::CopyRow]
-* Literal for insertion into SQL string: {TE}[rdoc-ref:PG::TextEncoder::QuotedLiteral]
-* SQL-Identifier: {TE}[rdoc-ref:PG::TextEncoder::Identifier], {TD}[rdoc-ref:PG::TextDecoder::Identifier]
-
-=== PG::TypeMap and derivations (ext/pg_type_map*.c, lib/pg/type_map*.rb)
-
-A TypeMap defines which value will be converted by which encoder/decoder.
-There are different type map strategies, implemented by several derivations
-of this class. They can be chosen and configured according to the particular
-needs for type casting. The default type map is PG::TypeMapAllStrings.
-
-A type map can be assigned per connection or per query respectively per
-result set. Type maps can also be used for COPY in and out data streaming.
-See PG::Connection#copy_data .
-
-The following base type maps are available:
-* PG::TypeMapAllStrings - encodes and decodes all values to and from strings (default)
-* PG::TypeMapByClass - selects encoder based on the class of the value to be sent
-* PG::TypeMapByColumn - selects encoder and decoder by column order
-* PG::TypeMapByOid - selects decoder by PostgreSQL type OID
-* PG::TypeMapInRuby - define a custom type map in ruby
-
-The following type maps are prefilled with type mappings from the PG::BasicTypeRegistry :
-* PG::BasicTypeMapForResults - a PG::TypeMapByOid prefilled with decoders for common PostgreSQL column types
-* PG::BasicTypeMapBasedOnResult - a PG::TypeMapByOid prefilled with encoders for common PostgreSQL column types
-* PG::BasicTypeMapForQueries - a PG::TypeMapByClass prefilled with encoders for common Ruby value classes
-
-
-== Contributing
-
-To report bugs, suggest features, or check out the source with Git,
-{check out the project page}[https://github.com/ged/ruby-pg].
-
-After checking out the source, install all dependencies:
-
-    $ bundle install
-
-Cleanup extension files, packaging files, test databases:
-
-    $ rake clean
-
-Compile extension:
-
-    $ rake compile
-
-Run tests/specs with PostgreSQL tools like `initdb` in the path:
-
-    $ PATH=$PATH:/usr/lib/postgresql/14/bin rake test
-
-Or run a specific test with the line number:
-
-    $ PATH=$PATH:/usr/lib/postgresql/14/bin rspec -Ilib -fd spec/pg/connection_spec.rb:455
-
-Generate the API documentation:
-
-    $ rake docs
-
-Make sure, that all bugs and new features are verified by tests.
-
-The current maintainers are Michael Granger <ged@FaerieMUD.org> and
-Lars Kanis <lars@greiz-reinsdorf.de>.
-
-
-== Copying
-
-Copyright (c) 1997-2022 by the authors.
-
-* Jeff Davis <ruby-pg@j-davis.com>
-* Guy Decoux (ts) <decoux@moulon.inra.fr>
-* Michael Granger <ged@FaerieMUD.org>
-* Lars Kanis <lars@greiz-reinsdorf.de>
-* Dave Lee
-* Eiji Matsumoto <usagi@ruby.club.or.jp>
-* Yukihiro Matsumoto <matz@ruby-lang.org>
-* Noboru Saitou <noborus@netlab.jp>
-
-You may redistribute this software under the same terms as Ruby itself; see
-https://www.ruby-lang.org/en/about/license.txt or the BSDL file in the source
-for details.
-
-Portions of the code are from the PostgreSQL project, and are distributed
-under the terms of the PostgreSQL license, included in the file POSTGRES.
-
-Portions copyright LAIKA, Inc.
-
-
-== Acknowledgments
-
-See Contributors.rdoc for the many additional fine people that have contributed
-to this library over the years.
-
-We are thankful to the people at the ruby-list and ruby-dev mailing lists.
-And to the people who developed PostgreSQL.

data/lib/pg/basic_type_map_based_on_result.rb

@@ -1,47 +0,0 @@
-# -*- ruby -*-
-# frozen_string_literal: true
-
-require 'pg' unless defined?( PG )
-
-# Simple set of rules for type casting common PostgreSQL types from Ruby
-# to PostgreSQL.
-#
-# OIDs of supported type casts are not hard-coded in the sources, but are retrieved from the
-# PostgreSQL's +pg_type+ table in PG::BasicTypeMapBasedOnResult.new .
-#
-# This class works equal to PG::BasicTypeMapForResults, but does not define decoders for
-# the given result OIDs, but encoders. So it can be used to type cast field values based on
-# the type OID retrieved by a separate SQL query.
-#
-# PG::TypeMapByOid#build_column_map(result) can be used to generate a result independent
-# PG::TypeMapByColumn type map, which can subsequently be used to cast query bind parameters
-# or #put_copy_data fields.
-#
-# Example:
-#   conn.exec( "CREATE TEMP TABLE copytable (t TEXT, i INT, ai INT[])" )
-#
-#   # Retrieve table OIDs per empty result set.
-#   res = conn.exec( "SELECT * FROM copytable LIMIT 0" )
-#   # Build a type map for common ruby to database type encoders.
-#   btm = PG::BasicTypeMapBasedOnResult.new(conn)
-#   # Build a PG::TypeMapByColumn with encoders suitable for copytable.
-#   tm = btm.build_column_map( res )
-#   row_encoder = PG::TextEncoder::CopyRow.new type_map: tm
-#
-#   conn.copy_data( "COPY copytable FROM STDIN", row_encoder ) do |res|
-#     conn.put_copy_data ['a', 123, [5,4,3]]
-#   end
-# This inserts a single row into copytable with type casts from ruby to
-# database types.
-class PG::BasicTypeMapBasedOnResult < PG::TypeMapByOid
-	include PG::BasicTypeRegistry::Checker
-
-	def initialize(connection_or_coder_maps, registry: nil)
-		@coder_maps = build_coder_maps(connection_or_coder_maps, registry: registry)
-
-		# Populate TypeMapByOid hash with encoders
-		@coder_maps.each_format(:encoder).flat_map{|f| f.coders }.each do |coder|
-			add_coder(coder)
-		end
-	end
-end

data/lib/pg/basic_type_map_for_queries.rb

@@ -1,193 +0,0 @@
-# -*- ruby -*-
-# frozen_string_literal: true
-
-require 'pg' unless defined?( PG )
-
-# Simple set of rules for type casting common Ruby types to PostgreSQL.
-#
-# OIDs of supported type casts are not hard-coded in the sources, but are retrieved from the
-# PostgreSQL's pg_type table in PG::BasicTypeMapForQueries.new .
-#
-# Query params are type casted based on the class of the given value.
-#
-# Higher level libraries will most likely not make use of this class, but use their
-# own derivation of PG::TypeMapByClass or another set of rules to choose suitable
-# encoders and decoders for the values to be sent.
-#
-# Example:
-#   conn = PG::Connection.new
-#   # Assign a default ruleset for type casts of input and output values.
-#   conn.type_map_for_queries = PG::BasicTypeMapForQueries.new(conn)
-#   # Execute a query. The Integer param value is typecasted internally by PG::BinaryEncoder::Int8.
-#   # The format of the parameter is set to 0 (text) and the OID of this parameter is set to 20 (int8).
-#   res = conn.exec_params( "SELECT $1", [5] )
-class PG::BasicTypeMapForQueries < PG::TypeMapByClass
-	# Helper class for submission of binary strings into bytea columns.
-	#
-	# Since PG::BasicTypeMapForQueries chooses the encoder to be used by the class of the submitted value,
-	# it's necessary to send binary strings as BinaryData.
-	# That way they're distinct from text strings.
-	# Please note however that PG::BasicTypeMapForResults delivers bytea columns as plain String
-	# with binary encoding.
-	#
-	#   conn.type_map_for_queries = PG::BasicTypeMapForQueries.new(conn)
-	#   conn.exec("CREATE TEMP TABLE test (data bytea)")
-	#   bd = PG::BasicTypeMapForQueries::BinaryData.new("ab\xff\0cd")
-	#   conn.exec_params("INSERT INTO test (data) VALUES ($1)", [bd])
-	class BinaryData < String
-	end
-
-	class UndefinedEncoder < RuntimeError
-	end
-
-	include PG::BasicTypeRegistry::Checker
-
-	# Create a new type map for query submission
-	#
-	# Options:
-	# * +registry+: Custom type registry, nil for default global registry
-	# * +if_undefined+: Optional +Proc+ object which is called, if no type for an parameter class is not defined in the registry.
-	def initialize(connection_or_coder_maps, registry: nil, if_undefined: nil)
-		@coder_maps = build_coder_maps(connection_or_coder_maps, registry: registry)
-		@array_encoders_by_klass = array_encoders_by_klass
-		@encode_array_as = :array
-		@if_undefined = if_undefined || proc { |oid_name, format|
-			raise UndefinedEncoder, "no encoder defined for type #{oid_name.inspect} format #{format}"
-		}
-		init_encoders
-	end
-
-	# Change the mechanism that is used to encode ruby array values
-	#
-	# Possible values:
-	# * +:array+ : Encode the ruby array as a PostgreSQL array.
-	#   The array element type is inferred from the class of the first array element. This is the default.
-	# * +:json+ : Encode the ruby array as a JSON document.
-	# * +:record+ : Encode the ruby array as a composite type row.
-	# * <code>"_type"</code> : Encode the ruby array as a particular PostgreSQL type.
-	#   All PostgreSQL array types are supported.
-	#   If there's an encoder registered for the elements +type+, it will be used.
-	#   Otherwise a string conversion (by +value.to_s+) is done.
-	def encode_array_as=(pg_type)
-		case pg_type
-			when :array
-			when :json
-			when :record
-			when /\A_/
-			else
-				raise ArgumentError, "invalid pg_type #{pg_type.inspect}"
-		end
-
-		@encode_array_as = pg_type
-
-		init_encoders
-	end
-
-	attr_reader :encode_array_as
-
-	private
-
-	def init_encoders
-		coders.each { |kl, c| self[kl] = nil } # Clear type map
-		populate_encoder_list
-		@textarray_encoder = coder_by_name(0, :encoder, '_text')
-	end
-
-	def coder_by_name(format, direction, name)
-		check_format_and_direction(format, direction)
-		@coder_maps.map_for(format, direction).coder_by_name(name)
-	end
-
-	def undefined(name, format)
-		@if_undefined.call(name, format)
-	end
-
-	def populate_encoder_list
-		DEFAULT_TYPE_MAP.each do |klass, selector|
-			if Array === selector
-				format, name, oid_name = selector
-				coder = coder_by_name(format, :encoder, name).dup
-				if coder
-					if oid_name
-						oid_coder = coder_by_name(format, :encoder, oid_name)
-						if oid_coder
-							coder.oid = oid_coder.oid
-						else
-							undefined(oid_name, format)
-						end
-					else
-						coder.oid = 0
-					end
-					self[klass] = coder
-				else
-					undefined(name, format)
-				end
-			else
-
-				case @encode_array_as
-					when :array
-						self[klass] = selector
-					when :json
-						self[klass] = PG::TextEncoder::JSON.new
-					when :record
-						self[klass] = PG::TextEncoder::Record.new type_map: self
-					when /\A_/
-						coder = coder_by_name(0, :encoder, @encode_array_as)
-						if coder
-							self[klass] = coder
-						else
-							undefined(@encode_array_as, format)
-						end
-					else
-						raise ArgumentError, "invalid pg_type #{@encode_array_as.inspect}"
-				end
-			end
-		end
-	end
-
-	def array_encoders_by_klass
-		DEFAULT_ARRAY_TYPE_MAP.inject({}) do |h, (klass, (format, name))|
-			h[klass] = coder_by_name(format, :encoder, name)
-			h
-		end
-	end
-
-	def get_array_type(value)
-		elem = value
-		while elem.kind_of?(Array)
-			elem = elem.first
-		end
-		@array_encoders_by_klass[elem.class] ||
-				elem.class.ancestors.lazy.map{|ancestor| @array_encoders_by_klass[ancestor] }.find{|a| a } ||
-				@textarray_encoder
-	end
-
-	DEFAULT_TYPE_MAP = {
-		TrueClass => [1, 'bool', 'bool'],
-		FalseClass => [1, 'bool', 'bool'],
-		# We use text format and no type OID for numbers, because setting the OID can lead
-		# to unnecessary type conversions on server side.
-		Integer => [0, 'int8'],
-		Float => [0, 'float8'],
-		BigDecimal => [0, 'numeric'],
-		Time => [0, 'timestamptz'],
-		# We use text format and no type OID for IPAddr, because setting the OID can lead
-		# to unnecessary inet/cidr conversions on the server side.
-		IPAddr => [0, 'inet'],
-		Hash => [0, 'json'],
-		Array => :get_array_type,
-		BinaryData => [1, 'bytea'],
-	}
-
-	DEFAULT_ARRAY_TYPE_MAP = {
-		TrueClass => [0, '_bool'],
-		FalseClass => [0, '_bool'],
-		Integer => [0, '_int8'],
-		String => [0, '_text'],
-		Float => [0, '_float8'],
-		BigDecimal => [0, '_numeric'],
-		Time => [0, '_timestamptz'],
-		IPAddr => [0, '_inet'],
-	}
-
-end