cipherstash-pg 1.0.0.beta.4-arm64-darwin

data/certs/larskanis-2022.pem

@@ -0,0 +1,26 @@
+-----BEGIN CERTIFICATE-----
+MIIETTCCArWgAwIBAgIBATANBgkqhkiG9w0BAQsFADAoMSYwJAYDVQQDDB1sYXJz
+L0RDPWdyZWl6LXJlaW5zZG9yZi9EQz1kZTAeFw0yMjAyMTQxMzMwNTZaFw0yMzAy
+MTQxMzMwNTZaMCgxJjAkBgNVBAMMHWxhcnMvREM9Z3JlaXotcmVpbnNkb3JmL0RD
+PWRlMIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIBigKCAYEAwum6Y1KznfpzXOT/
+mZgJTBbxZuuZF49Fq3K0WA67YBzNlDv95qzSp7V/7Ek3NCcnT7G+2kSuhNo1FhdN
+eSDO/moYebZNAcu3iqLsuzuULXPLuoU0GsMnVMqV9DZPh7cQHE5EBZ7hlzDBK7k/
+8nBMvR0mHo77kIkapHc26UzVq/G0nKLfDsIHXVylto3PjzOumjG6GhmFN4r3cP6e
+SDfl1FSeRYVpt4kmQULz/zdSaOH3AjAq7PM2Z91iGwQvoUXMANH2v89OWjQO/NHe
+JMNDFsmHK/6Ji4Kk48Z3TyscHQnipAID5GhS1oD21/WePdj7GhmbF5gBzkV5uepd
+eJQPgWGwrQW/Z2oPjRuJrRofzWfrMWqbOahj9uth6WSxhNexUtbjk6P8emmXOJi5
+chQPnWX+N3Gj+jjYxqTFdwT7Mj3pv1VHa+aNUbqSPpvJeDyxRIuo9hvzDaBHb/Cg
+9qRVcm8a96n4t7y2lrX1oookY6bkBaxWOMtWlqIprq8JZXM9AgMBAAGjgYEwfzAJ
+BgNVHRMEAjAAMAsGA1UdDwQEAwIEsDAdBgNVHQ4EFgQUOIdbSMr3VFrTCO9/cTM0
+0exHzBcwIgYDVR0RBBswGYEXbGFyc0BncmVpei1yZWluc2RvcmYuZGUwIgYDVR0S
+BBswGYEXbGFyc0BncmVpei1yZWluc2RvcmYuZGUwDQYJKoZIhvcNAQELBQADggGB
+AFWP7F/y3Oq3NgrqUOnjKOeDaBa7AqNhHS+PZg+C90lnJzMgOs4KKgZYxqSQVSab
+SCEmzIO/StkXY4NpJ4fYLrHemf/fJy1wPyu+fNdp5SEEUwEo+2toRFlzTe4u4LdS
+QC636nPPTMt8H3xz2wf/lUIUeo2Qc95Qt2BQM465ibbG9kmA3c7Sopx6yOabYOAl
+KPRbOSEPiWYcF9Suuz8Gdf8jxEtPlnZiwRvnYJ+IHMq3XQCJWPpMzdDMbtlgHbXE
+vq1zOTLMSYAS0UB3uionR4yo1hLz60odwkCm7qf0o2Ci/5OjtB0a89VuyqRU2vUJ
+QH95WBjDJ6lCCW7J0mrMPnJQSUFTmufsU6jOChvPaCeAzW1YwrsP/YKnvwueG7ip
+VOdW6RitjtFxhS7evRL0201+KUvLz12zZWWjOcujlQs64QprxOtiv/MiisKb1Ng+
+oL1mUdzB8KrZL4/WbG5YNX6UTtJbIOu9qEFbBAy4/jtIkJX+dlNoFwd4GXQW1YNO
+nA==
+-----END CERTIFICATE-----

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

data/lib/cipherstash-pg/basic_type_registry.rb

@@ -0,0 +1,206 @@
+require("cipherstash-pg") unless defined? CipherStashPG
+class CipherStashPG::BasicTypeRegistry
+  class CoderMap
+    DONT_QUOTE_TYPES = ["int2", "int4", "int8", "float4", "float8", "oid", "bool", "date", "timestamp", "timestamptz"].inject({}) do |h, e|
+      h[e] = true
+      h
+    end
+    
+    def initialize(result, coders_by_name, format, arraycoder)
+      coder_map = {}
+      arrays, nodes = result.partition { |row| (row["typinput"] == "array_in") }
+      nodes.find_all { |row| coders_by_name.key?(row["typname"]) }.each do |row|
+        coder = coders_by_name[row["typname"]].dup
+        coder.oid = row["oid"].to_i
+        coder.name = row["typname"]
+        coder.format = format
+        coder_map[coder.oid] = coder
+      end
+      if arraycoder then
+        arrays.each do |row|
+          elements_coder = coder_map[row["typelem"].to_i]
+          next unless elements_coder
+          coder = arraycoder.new
+          coder.oid = row["oid"].to_i
+          coder.name = row["typname"]
+          coder.format = format
+          coder.elements_type = elements_coder
+          coder.needs_quotation = (not DONT_QUOTE_TYPES[elements_coder.name])
+          coder_map[coder.oid] = coder
+        end
+      end
+      @coders = coder_map.values
+      @coders_by_name = @coders.inject({}) do |h, t|
+        h[t.name] = t
+        h
+      end
+      @coders_by_oid = @coders.inject({}) do |h, t|
+        h[t.oid] = t
+        h
+      end
+    end
+    
+    attr_reader(:coders)
+    
+    attr_reader(:coders_by_oid)
+    
+    attr_reader(:coders_by_name)
+    
+    def coder_by_name(name)
+      @coders_by_name[name]
+    end
+    
+    def coder_by_oid(oid)
+      @coders_by_oid[oid]
+    end
+  end
+  
+  class CoderMapsBundle
+    attr_reader(:typenames_by_oid)
+    
+    def initialize(connection, registry: nil)
+      registry ||= DEFAULT_TYPE_REGISTRY
+      result = connection.exec("\t\t\t\tSELECT t.oid, t.typname, t.typelem, t.typdelim, ti.proname AS typinput\n\t\t\t\tFROM pg_type as t\n\t\t\t\tJOIN pg_proc as ti ON ti.oid = t.typinput\n").to_a
+      @maps = [[0, :encoder, CipherStashPG::TextEncoder::Array], [0, :decoder, CipherStashPG::TextDecoder::Array], [1, :encoder, nil], [1, :decoder, nil]].inject([]) do |h, (format, direction, arraycoder)|
+        coders = (registry.coders_for(format, direction) or {})
+        h[format] ||= {}
+        h[format][direction] = CoderMap.new(result, coders, format, arraycoder)
+        h
+      end
+      @typenames_by_oid = result.inject({}) do |h, t|
+        h[t["oid"].to_i] = t["typname"]
+        h
+      end
+    end
+    
+    def each_format(direction)
+      @maps.map { |f| f[direction] }
+    end
+    
+    def map_for(format, direction)
+      @maps[format][direction]
+    end
+  end
+  
+  module Checker
+    ValidFormats = { 0 => true, 1 => true }
+    
+    ValidDirections = { :encoder => true, :decoder => true }
+    
+    protected(def check_format_and_direction(format, direction)
+      unless ValidFormats[format] then
+        raise(ArgumentError, ("Invalid format value %p" % format))
+      end
+      unless ValidDirections[direction] then
+        raise(ArgumentError, ("Invalid direction %p" % direction))
+      end
+    end)
+    
+    protected(def build_coder_maps(conn_or_maps, registry: nil)
+      if conn_or_maps.is_a?(CipherStashPG::BasicTypeRegistry::CoderMapsBundle) then
+        if registry then
+          raise(ArgumentError, "registry argument must be given to CoderMapsBundle")
+        end
+        conn_or_maps
+      else
+        CipherStashPG::BasicTypeRegistry::CoderMapsBundle.new(conn_or_maps, :registry => registry)
+      end
+    end)
+  end
+  
+  include(Checker)
+  
+  def initialize
+    @coders_by_name = []
+  end
+  
+  def coders_for(format, direction)
+    check_format_and_direction(format, direction)
+    @coders_by_name[format][direction]
+  end
+  
+  def register_coder(coder)
+    h = @coders_by_name[coder.format] ||= { :encoder => ({}), :decoder => ({}) }
+    name = (coder.name or raise(ArgumentError, "name of #{coder.inspect} must be defined"))
+    h[:encoder][name] = coder if coder.respond_to?(:encode)
+    h[:decoder][name] = coder if coder.respond_to?(:decode)
+    self
+  end
+  
+  def register_type(format, name, encoder_class, decoder_class)
+    if encoder_class then
+      register_coder(encoder_class.new(:name => name, :format => format))
+    end
+    if decoder_class then
+      register_coder(decoder_class.new(:name => name, :format => format))
+    end
+    self
+  end
+  
+  def alias_type(format, new, old)
+    [:encoder, :decoder].each do |ende|
+      enc = @coders_by_name[format][ende][old]
+      if enc then
+        @coders_by_name[format][ende][new] = enc
+      else
+        @coders_by_name[format][ende].delete(new)
+      end
+    end
+    self
+  end
+  
+  def register_default_types
+    register_type(0, "int2", CipherStashPG::TextEncoder::Integer, CipherStashPG::TextDecoder::Integer)
+    alias_type(0, "int4", "int2")
+    alias_type(0, "int8", "int2")
+    alias_type(0, "oid", "int2")
+    register_type(0, "numeric", CipherStashPG::TextEncoder::Numeric, CipherStashPG::TextDecoder::Numeric)
+    register_type(0, "text", CipherStashPG::TextEncoder::String, CipherStashPG::TextDecoder::String)
+    alias_type(0, "varchar", "text")
+    alias_type(0, "char", "text")
+    alias_type(0, "bpchar", "text")
+    alias_type(0, "xml", "text")
+    alias_type(0, "name", "text")
+    register_type(0, "bytea", nil, CipherStashPG::TextDecoder::Bytea)
+    register_type(0, "bool", CipherStashPG::TextEncoder::Boolean, CipherStashPG::TextDecoder::Boolean)
+    register_type(0, "float4", CipherStashPG::TextEncoder::Float, CipherStashPG::TextDecoder::Float)
+    alias_type(0, "float8", "float4")
+    register_type(0, "timestamp", CipherStashPG::TextEncoder::TimestampWithoutTimeZone, CipherStashPG::TextDecoder::TimestampWithoutTimeZone)
+    register_type(0, "timestamptz", CipherStashPG::TextEncoder::TimestampWithTimeZone, CipherStashPG::TextDecoder::TimestampWithTimeZone)
+    register_type(0, "date", CipherStashPG::TextEncoder::Date, CipherStashPG::TextDecoder::Date)
+    register_type(0, "json", CipherStashPG::TextEncoder::JSON, CipherStashPG::TextDecoder::JSON)
+    alias_type(0, "jsonb", "json")
+    register_type(0, "inet", CipherStashPG::TextEncoder::Inet, CipherStashPG::TextDecoder::Inet)
+    alias_type(0, "cidr", "inet")
+    register_type(1, "int2", CipherStashPG::BinaryEncoder::Int2, CipherStashPG::BinaryDecoder::Integer)
+    register_type(1, "int4", CipherStashPG::BinaryEncoder::Int4, CipherStashPG::BinaryDecoder::Integer)
+    register_type(1, "int8", CipherStashPG::BinaryEncoder::Int8, CipherStashPG::BinaryDecoder::Integer)
+    alias_type(1, "oid", "int2")
+    register_type(1, "text", CipherStashPG::BinaryEncoder::String, CipherStashPG::BinaryDecoder::String)
+    alias_type(1, "varchar", "text")
+    alias_type(1, "char", "text")
+    alias_type(1, "bpchar", "text")
+    alias_type(1, "xml", "text")
+    alias_type(1, "name", "text")
+    register_type(1, "bytea", CipherStashPG::BinaryEncoder::Bytea, CipherStashPG::BinaryDecoder::Bytea)
+    register_type(1, "bool", CipherStashPG::BinaryEncoder::Boolean, CipherStashPG::BinaryDecoder::Boolean)
+    register_type(1, "float4", nil, CipherStashPG::BinaryDecoder::Float)
+    register_type(1, "float8", nil, CipherStashPG::BinaryDecoder::Float)
+    register_type(1, "timestamp", nil, CipherStashPG::BinaryDecoder::TimestampUtc)
+    register_type(1, "timestamptz", nil, CipherStashPG::BinaryDecoder::TimestampUtcToLocal)
+    self
+  end
+  
+  alias :define_default_types :register_default_types
+  
+  DEFAULT_TYPE_REGISTRY = CipherStashPG::BasicTypeRegistry.new.register_default_types
+  
+  class << self
+    [:register_coder, :register_type, :alias_type].each do |meth|
+      define_method(meth) do |*args|
+        warn("PG::BasicTypeRegistry.#{meth} is deprecated. Please use your own instance by PG::BasicTypeRegistry.new instead!")
+        DEFAULT_TYPE_REGISTRY.send(meth, *args)
+      end
+    end
+  end
+end

data/lib/cipherstash-pg/binary_decoder.rb

@@ -0,0 +1,21 @@
+module CipherStashPG
+  module BinaryDecoder
+    class TimestampUtc < Timestamp
+      def initialize(params = {})
+        super(params.merge(:flags => (CipherStashPG::Coder::TIMESTAMP_DB_UTC | CipherStashPG::Coder::TIMESTAMP_APP_UTC)))
+      end
+    end
+    
+    class TimestampUtcToLocal < Timestamp
+      def initialize(params = {})
+        super(params.merge(:flags => (CipherStashPG::Coder::TIMESTAMP_DB_UTC | CipherStashPG::Coder::TIMESTAMP_APP_LOCAL)))
+      end
+    end
+    
+    class TimestampLocal < Timestamp
+      def initialize(params = {})
+        super(params.merge(:flags => (CipherStashPG::Coder::TIMESTAMP_DB_LOCAL | CipherStashPG::Coder::TIMESTAMP_APP_LOCAL)))
+      end
+    end
+  end
+end

data/lib/cipherstash-pg/coder.rb

@@ -0,0 +1,82 @@
+module CipherStashPG
+  class Coder
+    module BinaryFormatting
+      Params = { :format => 1 }
+      
+      def initialize(params = {})
+        super(Params.merge(params))
+      end
+    end
+    
+    def initialize(params = {})
+      params.each { |key, val| send("#{key}=", val) }
+    end
+    
+    def dup
+      self.class.new(to_h)
+    end
+    
+    def to_h
+      { :oid => oid, :format => format, :flags => flags, :name => name }
+    end
+    
+    def ==(v)
+      (self.class == v.class) and (to_h == v.to_h)
+    end
+    
+    def marshal_dump
+      Marshal.dump(to_h)
+    end
+    
+    def marshal_load(str)
+      initialize(Marshal.load(str))
+    end
+    
+    def inspect
+      str = self.to_s
+      oid_str = " oid=#{oid}" unless (oid == 0)
+      format_str = " format=#{format}" unless (format == 0)
+      name_str = " #{name.inspect}" if name
+      str[-1, 0] = "#{name_str} #{oid_str}#{format_str}"
+      str
+    end
+    
+    def inspect_short
+      str = case format
+      when 0 then
+        "T"
+      when 1 then
+        "B"
+      else
+        format.to_s
+      end
+      str = (str + "E") if respond_to?(:encode)
+      str = (str + "D") if respond_to?(:decode)
+      "#{(name or self.class.name)}:#{str}"
+    end
+  end
+  
+  class CompositeCoder < Coder
+    def to_h
+      super.merge!(:elements_type => elements_type, :needs_quotation => needs_quotation?, :delimiter => delimiter)
+    end
+    
+    def inspect
+      str = super
+      str[-1, 0] = " elements_type=#{elements_type.inspect} #{needs_quotation? ? ("needs") : ("no")} quotation"
+      str
+    end
+  end
+  
+  class CopyCoder < Coder
+    def to_h
+      super.merge!(:type_map => type_map, :delimiter => delimiter, :null_string => null_string)
+    end
+  end
+  
+  class RecordCoder < Coder
+    def to_h
+      super.merge!(:type_map => type_map)
+    end
+  end
+end