cipherstash-pg 1.0.0.beta.1-x86_64-linux → 1.0.0.beta.4-x86_64-linux

data/Rakefile

@@ -1,115 +1,76 @@
-# -*- rake -*-
-
-require 'rbconfig'
-require 'pathname'
-require 'tmpdir'
-require 'rake/extensiontask'
-require 'rake/clean'
-require 'rspec/core/rake_task'
-require 'bundler'
-require 'bundler/gem_helper'
-
-# Build directory constants
-BASEDIR = Pathname( __FILE__ ).dirname
-SPECDIR = BASEDIR + 'spec'
-LIBDIR  = BASEDIR + 'lib'
-EXTDIR  = BASEDIR + 'ext'
-PKGDIR  = BASEDIR + 'pkg'
-TMPDIR  = BASEDIR + 'tmp'
-TESTDIR = BASEDIR + "tmp_test_*"
-
-DLEXT   = RbConfig::CONFIG['DLEXT']
-EXT     = LIBDIR + "pg_ext.#{DLEXT}"
-
-GEMSPEC = 'cipherstash-pg.gemspec'
-
-CLEAN.include( TESTDIR.to_s )
-CLEAN.include( PKGDIR.to_s, TMPDIR.to_s )
-CLEAN.include "lib/*/libpq.dll"
-CLEAN.include "lib/pg_ext.*"
-CLEAN.include "lib/pg/postgresql_lib_path.rb"
-
-# load 'Rakefile.cross'
-
+require("rbconfig")
+require("pathname")
+require("tmpdir")
+require("rake/extensiontask")
+require("rake/clean")
+require("rspec/core/rake_task")
+require("bundler")
+require("bundler/gem_helper")
+BASEDIR = Pathname("(string)").dirname
+SPECDIR = (BASEDIR + "spec")
+LIBDIR = (BASEDIR + "lib")
+EXTDIR = (BASEDIR + "ext")
+PKGDIR = (BASEDIR + "pkg")
+TMPDIR = (BASEDIR + "tmp")
+TESTDIR = (BASEDIR + "tmp_test_*")
+DLEXT = RbConfig::CONFIG["DLEXT"]
+EXT = (LIBDIR + "pg_ext.#{DLEXT}")
+GEMSPEC = "cipherstash-pg.gemspec"
+CLEAN.include(TESTDIR.to_s)
+CLEAN.include(PKGDIR.to_s, TMPDIR.to_s)
+CLEAN.include("lib/*/libpq.dll")
+CLEAN.include("lib/pg_ext.*")
+CLEAN.include("lib/pg/postgresql_lib_path.rb")
+load("Rakefile.cross")
 Bundler::GemHelper.install_tasks
 $gem_spec = Bundler.load_gemspec(GEMSPEC)
-
-desc "Turn on warnings and debugging in the build."
-task :maint do
-	ENV['MAINTAINER_MODE'] = 'yes'
-end
-
-# Rake-compiler task
+desc("Turn on warnings and debugging in the build.")
+task(:maint) { ENV["MAINTAINER_MODE"] = "yes" }
 Rake::ExtensionTask.new do |ext|
-	ext.name           = 'pg_ext'
-	ext.gem_spec       = $gem_spec
-	ext.ext_dir        = 'ext'
-	ext.lib_dir        = 'lib'
-	ext.source_pattern = "*.{c,h}"
-	ext.cross_compile  = false
-	# ext.cross_platform = CrossLibraries.map(&:for_platform)
-
-	# ext.cross_config_options += CrossLibraries.map do |lib|
-	# 	{
-	# 		lib.for_platform => [
-	# 			"--enable-windows-cross",
-	# 			"--with-pg-include=#{lib.static_postgresql_incdir}",
-	# 			"--with-pg-lib=#{lib.static_postgresql_libdir}",
-	# 			# libpq-fe.h resides in src/interfaces/libpq/ before make install
-	# 			"--with-opt-include=#{lib.static_postgresql_libdir}",
-	# 		]
-	# 	}
-	# end
-
-	# Add libpq.dll to windows binary gemspec
-	# ext.cross_compiling do |spec|
-	# 	spec.files << "lib/#{spec.platform}/libpq.dll"
-	# end
+  ext.name = "pg_ext"
+  ext.gem_spec = $gem_spec
+  ext.ext_dir = "ext"
+  ext.lib_dir = "lib"
+  ext.source_pattern = "*.{c,h}"
+  ext.cross_compile = true
+  ext.cross_platform = CrossLibraries.map(&:for_platform)
+  ext.cross_config_options += CrossLibraries.map do |lib|
+    { lib.for_platform => (["--enable-windows-cross", "--with-pg-include=#{lib.static_postgresql_incdir}", "--with-pg-lib=#{lib.static_postgresql_libdir}", "--with-opt-include=#{lib.static_postgresql_libdir}"]) }
+  end
+  ext.cross_compiling do |spec|
+    (spec.files << "lib/#{spec.platform}/libpq.dll")
+  end
 end
-
 RSpec::Core::RakeTask.new(:spec).rspec_opts = "--profile -cfdoc"
-task :test => :spec
-
-# Use the fivefish formatter for docs generated from development checkout
-require 'rdoc/task'
-
-RDoc::Task.new( 'docs' ) do |rdoc|
-	rdoc.options = $gem_spec.rdoc_options
-	rdoc.rdoc_files = $gem_spec.extra_rdoc_files
-	rdoc.generator = :fivefish
-	rdoc.rdoc_dir = 'doc'
+task(:test => :spec)
+require("rdoc/task")
+RDoc::Task.new("docs") do |rdoc|
+  rdoc.options = $gem_spec.rdoc_options
+  rdoc.rdoc_files = $gem_spec.extra_rdoc_files
+  rdoc.generator = :fivefish
+  rdoc.rdoc_dir = "doc"
 end
-
-desc "Build the source gem #{$gem_spec.full_name}.gem into the pkg directory"
-task :gem => :build
-
-task :clobber do
-	puts "Stop any Postmaster instances that remain after testing."
-	require_relative 'spec/helpers'
-	PG::TestingHelpers.stop_existing_postmasters()
+desc("Build the source gem #{$gem_spec.full_name}.gem into the pkg directory")
+task(:gem => :build)
+task(:clobber) do
+  puts("Stop any Postmaster instances that remain after testing.")
+  require_relative("spec/helpers")
+  CipherStashPG::TestingHelpers.stop_existing_postmasters
 end
-
-desc "Update list of server error codes"
-task :update_error_codes do
-	URL_ERRORCODES_TXT = "http://git.postgresql.org/gitweb/?p=postgresql.git;a=blob_plain;f=src/backend/utils/errcodes.txt;hb=refs/tags/REL_15_0"
-
-	ERRORCODES_TXT = "ext/errorcodes.txt"
-	sh "wget #{URL_ERRORCODES_TXT.inspect} -O #{ERRORCODES_TXT.inspect} || curl #{URL_ERRORCODES_TXT.inspect} -o #{ERRORCODES_TXT.inspect}"
-
-	ruby 'ext/errorcodes.rb', 'ext/errorcodes.txt', 'ext/errorcodes.def'
+desc("Update list of server error codes")
+task(:update_error_codes) do
+  URL_ERRORCODES_TXT = "http://git.postgresql.org/gitweb/?p=postgresql.git;a=blob_plain;f=src/backend/utils/errcodes.txt;hb=refs/tags/REL_15_0"
+  ERRORCODES_TXT = "ext/errorcodes.txt"
+  sh("wget #{URL_ERRORCODES_TXT.inspect} -O #{ERRORCODES_TXT.inspect} || curl #{URL_ERRORCODES_TXT.inspect} -o #{ERRORCODES_TXT.inspect}")
+  ruby("ext/errorcodes.rb", "ext/errorcodes.txt", "ext/errorcodes.def")
 end
-
-file 'ext/pg_errors.c' => ['ext/errorcodes.def'] do
-	# trigger compilation of changed errorcodes.def
-	touch 'ext/pg_errors.c'
+file("ext/pg_errors.c" => (["ext/errorcodes.def"])) do
+  touch("ext/pg_errors.c")
 end
-
-desc "Translate readme"
-task :translate do
-  cd "translation" do
-    # po4a's lexer might change, so record its version for reference
-    sh "LANG=C po4a --version > .po4a-version"
-
-    sh "po4a po4a.cfg"
+desc("Translate readme")
+task(:translate) do
+  cd("translation") do
+    sh("LANG=C po4a --version > .po4a-version")
+    sh("po4a po4a.cfg")
   end
 end

data/Rakefile.cross

@@ -0,0 +1,298 @@
+# -*- rake -*-
+
+require 'uri'
+require 'tempfile'
+require 'rbconfig'
+require 'rake/clean'
+require 'rake/extensiontask'
+require 'rake/extensioncompiler'
+require 'ostruct'
+require_relative 'rakelib/task_extension'
+
+MISCDIR = BASEDIR + 'misc'
+
+NUM_CPUS = if File.exist?('/proc/cpuinfo')
+	File.read('/proc/cpuinfo').scan('processor').length
+elsif RUBY_PLATFORM.include?( 'darwin' )
+	`system_profiler SPHardwareDataType | grep 'Cores' | awk '{print $5}'`.chomp
+else
+	1
+end
+
+class CrossLibrary < OpenStruct
+	include Rake::DSL
+	prepend TaskExtension
+
+	def initialize(for_platform, openssl_config, toolchain)
+		super()
+
+		self.for_platform               = for_platform
+		self.openssl_config             = openssl_config
+		self.host_platform              = toolchain
+
+		# Cross-compilation constants
+		self.openssl_version            = ENV['OPENSSL_VERSION'] || '3.0.8'
+		self.postgresql_version         = ENV['POSTGRESQL_VERSION'] || '15.2'
+
+		# Check if symlinks work in the current working directory.
+		# This fails, if rake-compiler-dock is running on a Windows box.
+		begin
+			FileUtils.rm_f '.test_symlink'
+			FileUtils.ln_s '/', '.test_symlink'
+		rescue NotImplementedError, SystemCallError
+			# Symlinks don't work -> use home directory instead
+			self.compile_home               = Pathname( "~/.ruby-pg-build" ).expand_path
+		else
+			self.compile_home               = Pathname( "./build" ).expand_path
+		end
+		self.static_sourcesdir          = compile_home + 'sources'
+		self.static_builddir            = compile_home + 'builds' + for_platform
+		CLOBBER.include( static_sourcesdir )
+		CLEAN.include( static_builddir )
+
+		# Static OpenSSL build vars
+		self.static_openssl_builddir    = static_builddir + "openssl-#{openssl_version}"
+
+		self.openssl_source_uri         =
+			URI( "http://www.openssl.org/source/openssl-#{openssl_version}.tar.gz" )
+		self.openssl_tarball            = static_sourcesdir + File.basename( openssl_source_uri.path )
+		self.openssl_makefile           = static_openssl_builddir + 'Makefile'
+
+		self.libssl                     = static_openssl_builddir + 'libssl.a'
+		self.libcrypto                  = static_openssl_builddir + 'libcrypto.a'
+
+		self.openssl_patches            = Rake::FileList[ (MISCDIR + "openssl-#{openssl_version}.*.patch").to_s ]
+
+		# Static PostgreSQL build vars
+		self.static_postgresql_builddir = static_builddir + "postgresql-#{postgresql_version}"
+		self.postgresql_source_uri      = begin
+			uristring = "http://ftp.postgresql.org/pub/source/v%s/postgresql-%s.tar.bz2" %
+				[ postgresql_version, postgresql_version ]
+			URI( uristring )
+		end
+		self.postgresql_tarball         = static_sourcesdir + File.basename( postgresql_source_uri.path )
+
+		self.static_postgresql_srcdir   = static_postgresql_builddir + 'src'
+		self.static_postgresql_libdir   = static_postgresql_srcdir + 'interfaces/libpq'
+		self.static_postgresql_incdir   = static_postgresql_srcdir + 'include'
+
+		self.postgresql_global_makefile = static_postgresql_srcdir + 'Makefile.global'
+		self.postgresql_shlib_makefile  = static_postgresql_srcdir + 'Makefile.shlib'
+		self.postgresql_shlib_mf_orig   = static_postgresql_srcdir + 'Makefile.shlib.orig'
+		self.postgresql_lib             = static_postgresql_libdir + 'libpq.dll'
+		self.postgresql_patches         = Rake::FileList[ (MISCDIR + "postgresql-#{postgresql_version}.*.patch").to_s ]
+
+		# clean intermediate files and folders
+		CLEAN.include( static_builddir.to_s )
+
+		#####################################################################
+		### C R O S S - C O M P I L A T I O N - T A S K S
+		#####################################################################
+
+
+		directory static_sourcesdir.to_s
+
+		#
+		# Static OpenSSL build tasks
+		#
+		directory static_openssl_builddir.to_s
+
+		# openssl source file should be stored there
+		file openssl_tarball => static_sourcesdir do |t|
+			download( openssl_source_uri, t.name )
+		end
+
+		# Extract the openssl builds
+		file static_openssl_builddir => openssl_tarball do |t|
+			puts "extracting %s to %s" % [ openssl_tarball, static_openssl_builddir.parent ]
+			static_openssl_builddir.mkpath
+			run 'tar', '-xzf', openssl_tarball.to_s, '-C', static_openssl_builddir.parent.to_s
+			openssl_makefile.unlink if openssl_makefile.exist?
+
+			openssl_patches.each do |patchfile|
+				puts "  applying patch #{patchfile}..."
+				run 'patch', '-Np1', '-d', static_openssl_builddir.to_s,
+				'-i', File.expand_path( patchfile, BASEDIR )
+			end
+		end
+
+		self.cmd_prelude = [
+			"env",
+			"CROSS_COMPILE=#{host_platform}-",
+			"CFLAGS=-DDSO_WIN32",
+		]
+
+
+		# generate the makefile in a clean build location
+		file openssl_makefile => static_openssl_builddir do |t|
+			chdir( static_openssl_builddir ) do
+				cmd = cmd_prelude.dup
+				cmd << "./Configure" << "-static" << openssl_config
+
+				run( *cmd )
+			end
+		end
+
+		desc "compile static openssl libraries"
+		task "openssl_libs:#{for_platform}" => [ libssl, libcrypto ]
+
+		task "compile_static_openssl:#{for_platform}" => openssl_makefile do |t|
+			chdir( static_openssl_builddir ) do
+				cmd = cmd_prelude.dup
+				cmd << 'make' << "-j#{NUM_CPUS}" << 'build_libs'
+
+				run( *cmd )
+			end
+		end
+
+		desc "compile static #{libssl}"
+		file libssl => "compile_static_openssl:#{for_platform}"
+
+		desc "compile static #{libcrypto}"
+		file libcrypto => "compile_static_openssl:#{for_platform}"
+
+
+
+		#
+		# Static PostgreSQL build tasks
+		#
+		directory static_postgresql_builddir.to_s
+
+
+		# postgresql source file should be stored there
+		file postgresql_tarball => static_sourcesdir do |t|
+			download( postgresql_source_uri, t.name )
+		end
+
+		# Extract the postgresql sources
+		file static_postgresql_builddir => postgresql_tarball do |t|
+			puts "extracting %s to %s" % [ postgresql_tarball, static_postgresql_builddir.parent ]
+			static_postgresql_builddir.mkpath
+			run 'tar', '-xjf', postgresql_tarball.to_s, '-C', static_postgresql_builddir.parent.to_s
+
+			postgresql_patches.each do |patchfile|
+				puts "  applying patch #{patchfile}..."
+				run 'patch', '-Np1', '-d', static_postgresql_builddir.to_s,
+				'-i', File.expand_path( patchfile, BASEDIR )
+			end
+		end
+
+		# generate the makefile in a clean build location
+		file postgresql_global_makefile => [ static_postgresql_builddir, "openssl_libs:#{for_platform}" ] do |t|
+			options = [
+				"--target=#{host_platform}",
+				"--host=#{host_platform}",
+				'--with-openssl',
+				'--without-zlib',
+			]
+
+			chdir( static_postgresql_builddir ) do
+				configure_path = static_postgresql_builddir + 'configure'
+				cmd = [ configure_path.to_s, *options ]
+				cmd << "CFLAGS=-L#{static_openssl_builddir}"
+				cmd << "LDFLAGS=-L#{static_openssl_builddir}"
+				cmd << "LDFLAGS_SL=-L#{static_openssl_builddir}"
+				cmd << "LIBS=-lwsock32 -lgdi32 -lws2_32 -lcrypt32"
+				cmd << "CPPFLAGS=-I#{static_openssl_builddir}/include"
+
+				run( *cmd )
+			end
+		end
+
+
+		# make libpq.dll
+		task postgresql_lib => [ postgresql_global_makefile ] do |t|
+			# Work around missing dependency to libcommon in PostgreSQL-9.4.0
+			chdir( static_postgresql_srcdir + "common" ) do
+				sh 'make', "-j#{NUM_CPUS}"
+			end
+			chdir( static_postgresql_srcdir + "port" ) do
+				sh 'make', "-j#{NUM_CPUS}"
+			end
+
+			chdir( postgresql_lib.dirname ) do
+				sh 'make',
+					"-j#{NUM_CPUS}",
+					postgresql_lib.basename.to_s,
+					'SHLIB_LINK=-lssl -lcrypto -lcrypt32 -lgdi32 -lsecur32 -lwsock32 -lws2_32'
+			end
+		end
+
+
+		#desc 'compile libpg.a'
+		task "native:#{for_platform}" => postgresql_lib
+
+		# copy libpq.dll to lib dir
+		dest_libpq = "lib/#{for_platform}/#{postgresql_lib.basename}"
+		directory File.dirname(dest_libpq)
+		file dest_libpq => [postgresql_lib, File.dirname(dest_libpq)] do
+			cp postgresql_lib, dest_libpq
+		end
+
+		stage_libpq = "tmp/#{for_platform}/stage/#{dest_libpq}"
+		directory File.dirname(stage_libpq)
+		file stage_libpq => [postgresql_lib, File.dirname(stage_libpq)] do |t|
+			cp postgresql_lib, stage_libpq
+		end
+	end
+
+	def download(url, save_to)
+		part = save_to+".part"
+		sh "wget #{url.to_s.inspect} -O #{part.inspect} || curl #{url.to_s.inspect} -o #{part.inspect}"
+		FileUtils.mv part, save_to
+	end
+
+	def run(*args)
+		sh(*args)
+	end
+end
+
+CrossLibraries = [
+	['x64-mingw-ucrt', 'mingw64', 'x86_64-w64-mingw32'],
+	['x86-mingw32', 'mingw', 'i686-w64-mingw32'],
+	['x64-mingw32', 'mingw64', 'x86_64-w64-mingw32'],
+].map do |platform, openssl_config, toolchain|
+	CrossLibrary.new platform, openssl_config, toolchain
+end
+
+desc 'cross compile pg for win32'
+task :cross => [ :mingw32 ]
+
+task :mingw32 do
+	# Use Rake::ExtensionCompiler helpers to find the proper host
+	unless Rake::ExtensionCompiler.mingw_host then
+		warn "You need to install mingw32 cross compile functionality to be able to continue."
+		warn "Please refer to your distribution/package manager documentation about installation."
+		fail
+	end
+end
+
+task 'gem:windows:prepare' do
+	require 'io/console'
+	require 'rake_compiler_dock'
+
+	# Copy gem signing key and certs to be accessible from the docker container
+	mkdir_p 'build/gem'
+	sh "cp ~/.gem/gem-*.pem build/gem/ || true"
+	sh "bundle package"
+	begin
+		OpenSSL::PKey.read(File.read(File.expand_path("~/.gem/gem-private_key.pem")), ENV["GEM_PRIVATE_KEY_PASSPHRASE"] || "")
+	rescue OpenSSL::PKey::PKeyError
+		ENV["GEM_PRIVATE_KEY_PASSPHRASE"] = STDIN.getpass("Enter passphrase of gem signature key: ")
+		retry
+	end
+end
+
+CrossLibraries.each do |xlib|
+	platform = xlib.for_platform
+	desc "Build fat binary gem for platform #{platform}"
+	task "gem:windows:#{platform}" => ['gem:windows:prepare', xlib.openssl_tarball, xlib.postgresql_tarball] do
+		RakeCompilerDock.sh <<-EOT, platform: platform
+			(cp build/gem/gem-*.pem ~/.gem/ || true) &&
+			bundle install --local &&
+			rake native:#{platform} pkg/#{$gem_spec.full_name}-#{platform}.gem MAKE="make -j`nproc`" RUBY_CC_VERSION=3.2.0:3.1.0:3.0.0:2.7.0:2.6.0:2.5.0
+		EOT
+	end
+	desc "Build the windows binary gems"
+	multitask 'gem:windows' => "gem:windows:#{platform}"
+end

data/certs/larskanis-2023.pem

@@ -0,0 +1,24 @@
+-----BEGIN CERTIFICATE-----
+MIIEBDCCAmygAwIBAgIBAjANBgkqhkiG9w0BAQsFADAoMSYwJAYDVQQDDB1sYXJz
+L0RDPWdyZWl6LXJlaW5zZG9yZi9EQz1kZTAeFw0yMzAyMTUxNzQxMTVaFw0yNDAy
+MTUxNzQxMTVaMCgxJjAkBgNVBAMMHWxhcnMvREM9Z3JlaXotcmVpbnNkb3JmL0RD
+PWRlMIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIBigKCAYEAwum6Y1KznfpzXOT/
+mZgJTBbxZuuZF49Fq3K0WA67YBzNlDv95qzSp7V/7Ek3NCcnT7G+2kSuhNo1FhdN
+eSDO/moYebZNAcu3iqLsuzuULXPLuoU0GsMnVMqV9DZPh7cQHE5EBZ7hlzDBK7k/
+8nBMvR0mHo77kIkapHc26UzVq/G0nKLfDsIHXVylto3PjzOumjG6GhmFN4r3cP6e
+SDfl1FSeRYVpt4kmQULz/zdSaOH3AjAq7PM2Z91iGwQvoUXMANH2v89OWjQO/NHe
+JMNDFsmHK/6Ji4Kk48Z3TyscHQnipAID5GhS1oD21/WePdj7GhmbF5gBzkV5uepd
+eJQPgWGwrQW/Z2oPjRuJrRofzWfrMWqbOahj9uth6WSxhNexUtbjk6P8emmXOJi5
+chQPnWX+N3Gj+jjYxqTFdwT7Mj3pv1VHa+aNUbqSPpvJeDyxRIuo9hvzDaBHb/Cg
+9qRVcm8a96n4t7y2lrX1oookY6bkBaxWOMtWlqIprq8JZXM9AgMBAAGjOTA3MAkG
+A1UdEwQCMAAwCwYDVR0PBAQDAgSwMB0GA1UdDgQWBBQ4h1tIyvdUWtMI739xMzTR
+7EfMFzANBgkqhkiG9w0BAQsFAAOCAYEAQAcuTARfiiVUVx5KURICfdTM2Kd7LhOn
+qt3Vs4ANGvT226LEp3RnQ+kWGQYMRb3cw3LY2TNQRPlnZxE994mgjBscN4fbjXqO
+T0JbVpeszRZa5k1goggbnWT7CO7yU7WcHh13DaSubY7HUpAJn2xz9w2stxQfN/EE
+VMlnDJ1P7mUHAvpK8X9j9h7Xlc1niViT18MYwux8mboVTryrLr+clATUkkM3yBF0
+RV+c34ReW5eXO9Tr6aKTxh/pFC9ggDT6jOxuJgSvG8HWJzVf4NDvMavIas4KYjiI
+BU6CpWaG5NxicqL3BERi52U43HV08br+LNVpb7Rekgve/PJuSFnAR015bhSRXe5U
+vBioD1qW2ZW9tXg8Ww2IfDaO5a1So5Xby51rhNlyo6ATj2NkuLWZUKPKHhAz0TKm
+Dzx/gFSOrRoCt2mXNgrmcAfr386AfaMvCh7cXqdxZwmVo7ILZCYXck0pajvubsDd
+NUIIFkVXvd1odFyK9LF1RFAtxn/iAmpx
+-----END CERTIFICATE-----

data/lib/cipherstash-pg/basic_type_map_based_on_result.rb

@@ -0,0 +1,11 @@
+require("cipherstash-pg") unless defined? CipherStashPG
+class CipherStashPG::BasicTypeMapBasedOnResult < CipherStashPG::TypeMapByOid
+  include(CipherStashPG::BasicTypeRegistry::Checker)
+  
+  def initialize(connection_or_coder_maps, registry: nil)
+    @coder_maps = build_coder_maps(connection_or_coder_maps, :registry => registry)
+    @coder_maps.each_format(:encoder).flat_map { |f| f.coders }.each do |coder|
+      add_coder(coder)
+    end
+  end
+end

data/lib/cipherstash-pg/basic_type_map_for_queries.rb

@@ -0,0 +1,113 @@
+require("cipherstash-pg") unless defined? CipherStashPG
+class CipherStashPG::BasicTypeMapForQueries < CipherStashPG::TypeMapByClass
+  class BinaryData < String
+  end
+  
+  class UndefinedEncoder < RuntimeError
+  end
+  
+  include(CipherStashPG::BasicTypeRegistry::Checker)
+  
+  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 or proc do |oid_name, format|
+      raise(UndefinedEncoder, "no encoder defined for type #{oid_name.inspect} format #{format}")
+    end)
+    init_encoders
+  end
+  
+  def encode_array_as=(pg_type)
+    case pg_type
+    when :array then
+      # do nothing
+    when :json then
+      # do nothing
+    when :record then
+      # do nothing
+    when /\A_/ then
+      # do nothing
+    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 }
+    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) then
+        format, name, oid_name = selector
+        coder = coder_by_name(format, :encoder, name).dup
+        if coder then
+          if oid_name then
+            oid_coder = coder_by_name(format, :encoder, oid_name)
+            oid_coder ? (coder.oid = oid_coder.oid) : (undefined(oid_name, format))
+          else
+            coder.oid = 0
+          end
+          self[klass] = coder
+        else
+          undefined(name, format)
+        end
+      else
+        case @encode_array_as
+        when :array then
+          self[klass] = selector
+        when :json then
+          self[klass] = CipherStashPG::TextEncoder::JSON.new
+        when :record then
+          self[klass] = CipherStashPG::TextEncoder::Record.new(:type_map => (self))
+        when /\A_/ then
+          coder = coder_by_name(0, :encoder, @encode_array_as)
+          coder ? (self[klass] = coder) : (undefined(@encode_array_as, format))
+        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) do
+      elem = elem.first
+    end
+    (@array_encoders_by_klass[elem.class] or (elem.class.ancestors.lazy.map do |ancestor|
+      @array_encoders_by_klass[ancestor]
+    end.find do |a|
+      a
+    end or @textarray_encoder))
+  end
+  
+  DEFAULT_TYPE_MAP = { TrueClass => ([1, "bool", "bool"]), FalseClass => ([1, "bool", "bool"]), Integer => ([0, "int8"]), Float => ([0, "float8"]), BigDecimal => ([0, "numeric"]), Time => ([0, "timestamptz"]), 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

data/lib/cipherstash-pg/basic_type_map_for_results.rb

@@ -0,0 +1,30 @@
+require("cipherstash-pg") unless defined? CipherStashPG
+class CipherStashPG::BasicTypeMapForResults < CipherStashPG::TypeMapByOid
+  include(CipherStashPG::BasicTypeRegistry::Checker)
+  
+  class WarningTypeMap < CipherStashPG::TypeMapInRuby
+    def initialize(typenames)
+      @already_warned = Hash.new { |h, k| h[k] = {} }
+      @typenames_by_oid = typenames
+    end
+    
+    def typecast_result_value(result, _tuple, field)
+      format = result.fformat(field)
+      oid = result.ftype(field)
+      unless @already_warned[format][oid] then
+        warn("Warning: no type cast defined for type #{@typenames_by_oid[oid].inspect} format #{format} with oid #{oid}. Please cast this type explicitly to TEXT to be safe for future changes.")
+        @already_warned[format][oid] = true
+      end
+      super
+    end
+  end
+  
+  def initialize(connection_or_coder_maps, registry: nil)
+    @coder_maps = build_coder_maps(connection_or_coder_maps, :registry => registry)
+    @coder_maps.each_format(:decoder).flat_map { |f| f.coders }.each do |coder|
+      add_coder(coder)
+    end
+    typenames = @coder_maps.typenames_by_oid
+    self.default_type_map = WarningTypeMap.new(typenames)
+  end
+end