pg 1.4.6 → 1.5.3

data/ext/pg_type_map_by_column.c

@@ -232,7 +232,7 @@ static const rb_data_type_t pg_tmbc_type = {
 	},
 	&pg_typemap_type,
 	0,
-	RUBY_TYPED_FREE_IMMEDIATELY,
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
 };
 
 static VALUE
@@ -266,13 +266,14 @@ pg_tmbc_init(VALUE self, VALUE conv_ary)
 	t_tmbc *this;
 	int conv_ary_len;
 
+	rb_check_frozen(self);
 	Check_Type(conv_ary, T_ARRAY);
 	conv_ary_len = RARRAY_LENINT(conv_ary);
 	this = xmalloc(sizeof(t_tmbc) + sizeof(struct pg_tmbc_converter) * conv_ary_len);
 	/* Set nfields to 0 at first, so that GC mark function doesn't access uninitialized memory. */
 	this->nfields = 0;
 	this->typemap.funcs = pg_tmbc_funcs;
-	this->typemap.default_typemap = pg_typemap_all_strings;
+	RB_OBJ_WRITE(self, &this->typemap.default_typemap, pg_typemap_all_strings);
 	RTYPEDDATA_DATA(self) = this;
 
 	for(i=0; i<conv_ary_len; i++)
@@ -283,8 +284,11 @@ pg_tmbc_init(VALUE self, VALUE conv_ary)
 			/* no type cast */
 			this->convs[i].cconv = NULL;
 		} else {
+			t_pg_coder *p_coder;
 			/* Check argument type and store the coder pointer */
-			TypedData_Get_Struct(obj, t_pg_coder, &pg_coder_type, this->convs[i].cconv);
+			TypedData_Get_Struct(obj, t_pg_coder, &pg_coder_type, p_coder);
+			RB_OBJ_WRITTEN(self, Qnil, p_coder->coder_obj);
+			this->convs[i].cconv = p_coder;
 		}
 	}
 

data/ext/pg_type_map_by_oid.c

@@ -194,7 +194,7 @@ static const rb_data_type_t pg_tmbo_type = {
 	},
 	&pg_typemap_type,
 	0,
-	RUBY_TYPED_FREE_IMMEDIATELY,
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
 };
 
 static VALUE
@@ -212,11 +212,11 @@ pg_tmbo_s_allocate( VALUE klass )
 	this->typemap.funcs.typecast_result_value = pg_tmbo_result_value;
 	this->typemap.funcs.typecast_query_param = pg_typemap_typecast_query_param;
 	this->typemap.funcs.typecast_copy_get = pg_typemap_typecast_copy_get;
-	this->typemap.default_typemap = pg_typemap_all_strings;
+	RB_OBJ_WRITE(self, &this->typemap.default_typemap, pg_typemap_all_strings);
 	this->max_rows_for_online_lookup = 10;
 
 	for( i=0; i<2; i++){
-		this->format[i].oid_to_coder = rb_hash_new();
+		RB_OBJ_WRITE(self, &this->format[i].oid_to_coder, rb_hash_new());
 	}
 
 	return self;
@@ -242,6 +242,7 @@ pg_tmbo_add_coder( VALUE self, VALUE coder )
 	t_pg_coder *p_coder;
 	struct pg_tmbo_oid_cache_entry *p_ce;
 
+	rb_check_frozen(self);
 	TypedData_Get_Struct(coder, t_pg_coder, &pg_coder_type, p_coder);
 
 	if( p_coder->format < 0 || p_coder->format > 1 )
@@ -276,6 +277,7 @@ pg_tmbo_rm_coder( VALUE self, VALUE format, VALUE oid )
 	int i_format = NUM2INT(format);
 	struct pg_tmbo_oid_cache_entry *p_ce;
 
+	rb_check_frozen(self);
 	if( i_format < 0 || i_format > 1 )
 		rb_raise(rb_eArgError, "invalid format code %d", i_format);
 
@@ -318,6 +320,7 @@ static VALUE
 pg_tmbo_max_rows_for_online_lookup_set( VALUE self, VALUE value )
 {
 	t_tmbo *this = RTYPEDDATA_DATA( self );
+	rb_check_frozen(self);
 	this->max_rows_for_online_lookup = NUM2INT(value);
 	return value;
 }
@@ -338,7 +341,7 @@ pg_tmbo_max_rows_for_online_lookup_get( VALUE self )
  *    typemap.build_column_map( result )
  *
  * This builds a PG::TypeMapByColumn that fits to the given PG::Result object
- * based on it's type OIDs.
+ * based on it's type OIDs and binary/text format.
  *
  */
 static VALUE

data/ext/pg_type_map_in_ruby.c

@@ -44,7 +44,7 @@ static const rb_data_type_t pg_tmir_type = {
 	},
 	&pg_typemap_type,
 	0,
-	RUBY_TYPED_FREE_IMMEDIATELY,
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
 };
 
 /*
@@ -210,6 +210,9 @@ pg_tmir_typecast_query_param( VALUE self, VALUE param_value, VALUE field )
  * This method is called, when a type map is used for decoding copy data,
  * before the value is casted.
  *
+ * Should return the expected number of columns or 0 if the number of columns is unknown.
+ * This number is only used for memory pre-allocation.
+ *
  */
 static VALUE pg_tmir_fit_to_copy_get_dummy( VALUE self ){}
 #endif
@@ -291,7 +294,7 @@ pg_tmir_s_allocate( VALUE klass )
 	this->typemap.funcs.typecast_result_value = pg_tmir_result_value;
 	this->typemap.funcs.typecast_query_param = pg_tmir_query_param;
 	this->typemap.funcs.typecast_copy_get = pg_tmir_copy_get;
-	this->typemap.default_typemap = pg_typemap_all_strings;
+	RB_OBJ_WRITE(self, &this->typemap.default_typemap, pg_typemap_all_strings);
 	this->self = self;
 
 	return self;

data/lib/pg/basic_type_map_based_on_result.rb

@@ -32,7 +32,27 @@ require 'pg' unless defined?( PG )
 #     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.
+# database types using text format.
+#
+# Very similar with binary format:
+#
+#   conn.exec( "CREATE TEMP TABLE copytable (t TEXT, i INT, blob bytea, created_at timestamp)" )
+#   # Retrieve table OIDs per empty result set in binary format.
+#   res = conn.exec_params( "SELECT * FROM copytable LIMIT 0", [], 1 )
+#   # 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::BinaryEncoder::CopyRow.new type_map: tm
+#
+#   conn.copy_data( "COPY copytable FROM STDIN WITH (FORMAT binary)", row_encoder ) do |res|
+#     conn.put_copy_data ['a', 123, "\xff\x00".b, Time.now]
+#   end
+#
+# This inserts a single row into copytable with type casts from ruby to
+# database types using binary copy and value format.
+# Binary COPY is faster than text format but less portable and less readable and pg offers fewer en-/decoders of database types.
+#
 class PG::BasicTypeMapBasedOnResult < PG::TypeMapByOid
 	include PG::BasicTypeRegistry::Checker
 

data/lib/pg/basic_type_map_for_queries.rb

@@ -47,16 +47,20 @@ class PG::BasicTypeMapForQueries < PG::TypeMapByClass
 	# 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.
+	#   The +Proc+ object is called with the name and format of the missing type.
+	#   Its return value is not used.
 	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}"
-		}
+		@if_undefined = if_undefined || method(:raise_undefined_type).to_proc
 		init_encoders
 	end
 
+	private def raise_undefined_type(oid_name, format)
+		raise UndefinedEncoder, "no encoder defined for type #{oid_name.inspect} format #{format}"
+	end
+
 	# Change the mechanism that is used to encode ruby array values
 	#
 	# Possible values:
@@ -162,7 +166,7 @@ class PG::BasicTypeMapForQueries < PG::TypeMapByClass
 				@textarray_encoder
 	end
 
-	DEFAULT_TYPE_MAP = {
+	DEFAULT_TYPE_MAP = PG.make_shareable({
 		TrueClass => [1, 'bool', 'bool'],
 		FalseClass => [1, 'bool', 'bool'],
 		# We use text format and no type OID for numbers, because setting the OID can lead
@@ -177,9 +181,10 @@ class PG::BasicTypeMapForQueries < PG::TypeMapByClass
 		Hash => [0, 'json'],
 		Array => :get_array_type,
 		BinaryData => [1, 'bytea'],
-	}
+	})
+	private_constant :DEFAULT_TYPE_MAP
 
-	DEFAULT_ARRAY_TYPE_MAP = {
+	DEFAULT_ARRAY_TYPE_MAP = PG.make_shareable({
 		TrueClass => [0, '_bool'],
 		FalseClass => [0, '_bool'],
 		Integer => [0, '_int8'],
@@ -188,6 +193,6 @@ class PG::BasicTypeMapForQueries < PG::TypeMapByClass
 		BigDecimal => [0, '_numeric'],
 		Time => [0, '_timestamptz'],
 		IPAddr => [0, '_inet'],
-	}
-
+	})
+	private_constant :DEFAULT_ARRAY_TYPE_MAP
 end

data/lib/pg/basic_type_map_for_results.rb

@@ -46,22 +46,45 @@ require 'pg' unless defined?( PG )
 # This prints the rows with type casted columns:
 #   ["a", 123, [5, 4, 3]]
 #
+# Very similar with binary format:
+#
+#   conn.exec( "CREATE TABLE copytable AS VALUES('a', 123, '2023-03-19 18:39:44'::TIMESTAMP)" )
+#
+#   # Retrieve table OIDs per empty result set in binary format.
+#   res = conn.exec_params( "SELECT * FROM copytable LIMIT 0", [], 1 )
+#   # Build a type map for common database to ruby type decoders.
+#   btm = PG::BasicTypeMapForResults.new(conn)
+#   # Build a PG::TypeMapByColumn with decoders suitable for copytable.
+#   tm = btm.build_column_map( res )
+#   row_decoder = PG::BinaryDecoder::CopyRow.new type_map: tm
+#
+#   conn.copy_data( "COPY copytable TO STDOUT WITH (FORMAT binary)", row_decoder ) do |res|
+#     while row=conn.get_copy_data
+#       p row
+#     end
+#   end
+# This prints the rows with type casted columns:
+#   ["a", 123, 2023-03-19 18:39:44 UTC]
+#
 # See also PG::BasicTypeMapBasedOnResult for the encoder direction and PG::BasicTypeRegistry for the definition of additional types.
 class PG::BasicTypeMapForResults < PG::TypeMapByOid
 	include PG::BasicTypeRegistry::Checker
 
 	class WarningTypeMap < PG::TypeMapInRuby
 		def initialize(typenames)
-			@already_warned = Hash.new{|h, k| h[k] = {} }
+			@already_warned = {}
 			@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]
+			unless @already_warned.dig(format, oid)
 				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
+				unless frozen?
+					@already_warned[format] ||= {}
+					@already_warned[format][oid] = true
+				end
 			end
 			super
 		end

data/lib/pg/basic_type_registry.rb

@@ -39,7 +39,8 @@ class PG::BasicTypeRegistry
 			oid
 			bool
 			date timestamp timestamptz
-		].inject({}){|h,e| h[e] = true; h }
+		].inject({}){|h,e| h[e] = true; h }.freeze
+		private_constant :DONT_QUOTE_TYPES
 
 		def initialize(result, coders_by_name, format, arraycoder)
 			coder_map = {}
@@ -52,7 +53,7 @@ class PG::BasicTypeRegistry
 				coder.oid = row['oid'].to_i
 				coder.name = row['typname']
 				coder.format = format
-				coder_map[coder.oid] = coder
+				coder_map[coder.oid] = coder.freeze
 			end
 
 			if arraycoder
@@ -67,13 +68,14 @@ class PG::BasicTypeRegistry
 					coder.format = format
 					coder.elements_type = elements_coder
 					coder.needs_quotation = !DONT_QUOTE_TYPES[elements_coder.name]
-					coder_map[coder.oid] = coder
+					coder_map[coder.oid] = coder.freeze
 				end
 			end
 
-			@coders = coder_map.values
-			@coders_by_name = @coders.inject({}){|h, t| h[t.name] = t; h }
-			@coders_by_oid = @coders.inject({}){|h, t| h[t.oid] = t; h }
+			@coders = coder_map.values.freeze
+			@coders_by_name = @coders.inject({}){|h, t| h[t.name] = t; h }.freeze
+			@coders_by_oid = @coders.inject({}){|h, t| h[t.oid] = t; h }.freeze
+			freeze
 		end
 
 		attr_reader :coders
@@ -117,6 +119,11 @@ class PG::BasicTypeRegistry
 				JOIN pg_proc as ti ON ti.oid = t.typinput
 			SQL
 
+			init_maps(registry, result.freeze)
+			freeze
+		end
+
+		private def init_maps(registry, result)
 			@maps = [
 				[0, :encoder, PG::TextEncoder::Array],
 				[0, :decoder, PG::TextDecoder::Array],
@@ -127,9 +134,9 @@ class PG::BasicTypeRegistry
 				h[format] ||= {}
 				h[format][direction] = CoderMap.new(result, coders, format, arraycoder)
 				h
-			end
+			end.each{|h| h.freeze }.freeze
 
-			@typenames_by_oid = result.inject({}){|h, t| h[t['oid'].to_i] = t['typname']; h }
+			@typenames_by_oid = result.inject({}){|h, t| h[t['oid'].to_i] = t['typname']; h }.freeze
 		end
 
 		def each_format(direction)
@@ -142,8 +149,9 @@ class PG::BasicTypeRegistry
 	end
 
 	module Checker
-		ValidFormats = { 0 => true, 1 => true }
-		ValidDirections = { :encoder => true, :decoder => true }
+		ValidFormats = { 0 => true, 1 => true }.freeze
+		ValidDirections = { :encoder => true, :decoder => true }.freeze
+		private_constant :ValidFormats, :ValidDirections
 
 		protected def check_format_and_direction(format, direction)
 			raise(ArgumentError, "Invalid format value %p" % format) unless ValidFormats[format]
@@ -155,7 +163,7 @@ class PG::BasicTypeRegistry
 				raise ArgumentError, "registry argument must be given to CoderMapsBundle" if registry
 				conn_or_maps
 			else
-				PG::BasicTypeRegistry::CoderMapsBundle.new(conn_or_maps, registry: registry)
+				PG::BasicTypeRegistry::CoderMapsBundle.new(conn_or_maps, registry: registry).freeze
 			end
 		end
 	end
@@ -192,8 +200,8 @@ class PG::BasicTypeRegistry
 	# +name+ must correspond to the +typname+ column in the +pg_type+ table.
 	# +format+ can be 0 for text format and 1 for binary.
 	def register_type(format, name, encoder_class, decoder_class)
-		register_coder(encoder_class.new(name: name, format: format)) if encoder_class
-		register_coder(decoder_class.new(name: name, format: format)) if decoder_class
+		register_coder(encoder_class.new(name: name, format: format).freeze) if encoder_class
+		register_coder(decoder_class.new(name: name, format: format).freeze) if decoder_class
 		self
 	end
 
@@ -232,9 +240,7 @@ class PG::BasicTypeRegistry
 		# alias_type 'uuid',     'text'
 		#
 		# register_type 'money', OID::Money.new
-		# There is no PG::TextEncoder::Bytea, because it's simple and more efficient to send bytea-data
-		# in binary format, either with PG::BinaryEncoder::Bytea or in Hash param format.
-		register_type 0, 'bytea', nil, PG::TextDecoder::Bytea
+		register_type 0, 'bytea', PG::TextEncoder::Bytea, PG::TextDecoder::Bytea
 		register_type 0, 'bool', PG::TextEncoder::Boolean, PG::TextDecoder::Boolean
 		# register_type 'bit', OID::Bit.new
 		# register_type 'varbit', OID::Bit.new
@@ -242,6 +248,7 @@ class PG::BasicTypeRegistry
 		register_type 0, 'float4', PG::TextEncoder::Float, PG::TextDecoder::Float
 		alias_type 0, 'float8', 'float4'
 
+		# For compatibility reason the timestamp in text format is encoded as local time (TimestampWithoutTimeZone) instead of UTC
 		register_type 0, 'timestamp', PG::TextEncoder::TimestampWithoutTimeZone, PG::TextDecoder::TimestampWithoutTimeZone
 		register_type 0, 'timestamptz', PG::TextEncoder::TimestampWithTimeZone, PG::TextDecoder::TimestampWithTimeZone
 		register_type 0, 'date', PG::TextEncoder::Date, PG::TextDecoder::Date
@@ -276,26 +283,17 @@ class PG::BasicTypeRegistry
 
 		register_type 1, 'bytea', PG::BinaryEncoder::Bytea, PG::BinaryDecoder::Bytea
 		register_type 1, 'bool', PG::BinaryEncoder::Boolean, PG::BinaryDecoder::Boolean
-		register_type 1, 'float4', nil, PG::BinaryDecoder::Float
-		register_type 1, 'float8', nil, PG::BinaryDecoder::Float
-		register_type 1, 'timestamp', nil, PG::BinaryDecoder::TimestampUtc
-		register_type 1, 'timestamptz', nil, PG::BinaryDecoder::TimestampUtcToLocal
+		register_type 1, 'float4', PG::BinaryEncoder::Float4, PG::BinaryDecoder::Float
+		register_type 1, 'float8', PG::BinaryEncoder::Float8, PG::BinaryDecoder::Float
+		register_type 1, 'timestamp', PG::BinaryEncoder::TimestampUtc, PG::BinaryDecoder::TimestampUtc
+		register_type 1, 'timestamptz', PG::BinaryEncoder::TimestampUtc, PG::BinaryDecoder::TimestampUtcToLocal
+		register_type 1, 'date', PG::BinaryEncoder::Date, PG::BinaryDecoder::Date
 
 		self
 	end
 
 	alias define_default_types register_default_types
 
-	# @private
-	DEFAULT_TYPE_REGISTRY = PG::BasicTypeRegistry.new.register_default_types
-
-	# Delegate class method calls to DEFAULT_TYPE_REGISTRY
-	class << self
-		%i[ 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
+	DEFAULT_TYPE_REGISTRY = PG.make_shareable(PG::BasicTypeRegistry.new.register_default_types)
+	private_constant :DEFAULT_TYPE_REGISTRY
 end

data/lib/pg/binary_decoder/date.rb

@@ -0,0 +1,9 @@
+# -*- ruby -*-
+# frozen_string_literal: true
+
+module PG
+	module BinaryDecoder
+		# Init C part of the decoder
+		init_date
+	end
+end # module PG

data/lib/pg/binary_decoder/timestamp.rb

@@ -0,0 +1,26 @@
+# -*- ruby -*-
+# frozen_string_literal: true
+
+module PG
+	module BinaryDecoder
+		# Convenience classes for timezone options
+		class TimestampUtc < Timestamp
+			def initialize(hash={}, **kwargs)
+				warn("PG::Coder.new(hash) is deprecated. Please use keyword arguments instead! Called from #{caller.first}", category: :deprecated) unless hash.empty?
+				super(**hash, **kwargs, flags: PG::Coder::TIMESTAMP_DB_UTC | PG::Coder::TIMESTAMP_APP_UTC)
+			end
+		end
+		class TimestampUtcToLocal < Timestamp
+			def initialize(hash={}, **kwargs)
+				warn("PG::Coder.new(hash) is deprecated. Please use keyword arguments instead! Called from #{caller.first}", category: :deprecated) unless hash.empty?
+				super(**hash, **kwargs, flags: PG::Coder::TIMESTAMP_DB_UTC | PG::Coder::TIMESTAMP_APP_LOCAL)
+			end
+		end
+		class TimestampLocal < Timestamp
+			def initialize(hash={}, **kwargs)
+				warn("PG::Coder.new(hash) is deprecated. Please use keyword arguments instead! Called from #{caller.first}", category: :deprecated) unless hash.empty?
+				super(**hash, **kwargs, flags: PG::Coder::TIMESTAMP_DB_LOCAL | PG::Coder::TIMESTAMP_APP_LOCAL)
+			end
+		end
+	end
+end # module PG

data/lib/pg/binary_encoder/timestamp.rb

@@ -0,0 +1,20 @@
+# -*- ruby -*-
+# frozen_string_literal: true
+
+module PG
+	module BinaryEncoder
+		# Convenience classes for timezone options
+		class TimestampUtc < Timestamp
+			def initialize(hash={}, **kwargs)
+				warn("PG::Coder.new(hash) is deprecated. Please use keyword arguments instead! Called from #{caller.first}", category: :deprecated) unless hash.empty?
+				super(**hash, **kwargs, flags: PG::Coder::TIMESTAMP_DB_UTC)
+			end
+		end
+		class TimestampLocal < Timestamp
+			def initialize(hash={}, **kwargs)
+				warn("PG::Coder.new(hash) is deprecated. Please use keyword arguments instead! Called from #{caller.first}", category: :deprecated) unless hash.empty?
+				super(**hash, **kwargs, flags: PG::Coder::TIMESTAMP_DB_LOCAL)
+			end
+		end
+	end
+end # module PG

data/lib/pg/coder.rb

@@ -6,22 +6,24 @@ module PG
 	class Coder
 
 		module BinaryFormatting
-			Params = { format: 1 }
-			def initialize( params={} )
-				super(Params.merge(params))
+			def initialize(hash={}, **kwargs)
+				warn("PG::Coder.new(hash) is deprecated. Please use keyword arguments instead! Called from #{caller.first}", category: :deprecated) unless hash.empty?
+				super(format: 1, **hash, **kwargs)
 			end
 		end
 
 
 		# Create a new coder object based on the attribute Hash.
-		def initialize(params={})
-			params.each do |key, val|
+		def initialize(hash=nil, **kwargs)
+			warn("PG::Coder.new(hash) is deprecated. Please use keyword arguments instead! Called from #{caller.first}", category: :deprecated) if hash
+
+			(hash || kwargs).each do |key, val|
 				send("#{key}=", val)
 			end
 		end
 
 		def dup
-			self.class.new(to_h)
+			self.class.new(**to_h)
 		end
 
 		# Returns coder attributes as Hash.
@@ -43,7 +45,7 @@ module PG
 		end
 
 		def marshal_load(str)
-			initialize Marshal.load(str)
+			initialize(**Marshal.load(str))
 		end
 
 		def inspect
@@ -70,11 +72,11 @@ module PG
 
 	class CompositeCoder < Coder
 		def to_h
-			super.merge!({
+			{ **super,
 				elements_type: elements_type,
 				needs_quotation: needs_quotation?,
 				delimiter: delimiter,
-			})
+			}
 		end
 
 		def inspect
@@ -86,19 +88,19 @@ module PG
 
 	class CopyCoder < Coder
 		def to_h
-			super.merge!({
+			{ **super,
 				type_map: type_map,
 				delimiter: delimiter,
 				null_string: null_string,
-			})
+			}
 		end
 	end
 
 	class RecordCoder < Coder
 		def to_h
-			super.merge!({
+			{ **super,
 				type_map: type_map,
-			})
+			}
 		end
 	end
 end # module PG