pg 1.4.6-x64-mingw-ucrt → 1.5.1-x64-mingw-ucrt

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}" 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}" 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}" 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}" 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}" 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}" 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}" 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

data/lib/pg/connection.rb

@@ -2,8 +2,7 @@
 # frozen_string_literal: true
 
 require 'pg' unless defined?( PG )
-require 'uri'
-require 'io/wait'
+require 'io/wait' unless ::IO.public_instance_methods(false).include?(:wait_readable)
 require 'socket'
 
 # The PostgreSQL connection class. The interface for this class is based on
@@ -31,8 +30,8 @@ require 'socket'
 class PG::Connection
 
 	# The order the options are passed to the ::connect method.
-	CONNECT_ARGUMENT_ORDER = %w[host port options tty dbname user password]
-
+	CONNECT_ARGUMENT_ORDER = %w[host port options tty dbname user password].freeze
+	private_constant :CONNECT_ARGUMENT_ORDER
 
 	### Quote a single +value+ for use in a connection-parameter string.
 	def self.quote_connstr( value )
@@ -46,6 +45,10 @@ class PG::Connection
 		hash.map { |k,v| "#{k}=#{quote_connstr(v)}" }.join( ' ' )
 	end
 
+	# Shareable program name for Ractor
+	PROGRAM_NAME = $PROGRAM_NAME.dup.freeze
+	private_constant :PROGRAM_NAME
+
 	# Parse the connection +args+ into a connection-parameter string.
 	# See PG::Connection.new for valid arguments.
 	#
@@ -63,8 +66,8 @@ class PG::Connection
 		iopts = {}
 
 		if args.length == 1
-			case args.first
-			when URI, /=/, /:\/\//
+			case args.first.to_s
+			when /=/, /:\/\//
 				# Option or URL string style
 				conn_string = args.first.to_s
 				iopts = PG::Connection.conninfo_parse(conn_string).each_with_object({}){|h, o| o[h[:keyword].to_sym] = h[:val] if h[:val] }
@@ -87,7 +90,7 @@ class PG::Connection
 		iopts.merge!( hash_arg )
 
 		if !iopts[:fallback_application_name]
-			iopts[:fallback_application_name] = $0.sub( /^(.{30}).{4,}(.{30})$/ ){ $1+"..."+$2 }
+			iopts[:fallback_application_name] = PROGRAM_NAME.sub( /^(.{30}).{4,}(.{30})$/ ){ $1+"..."+$2 }
 		end
 
 		return connect_hash_to_string(iopts)
@@ -114,6 +117,9 @@ class PG::Connection
 		return str
 	end
 
+	BinarySignature = "PGCOPY\n\377\r\n\0".b
+	private_constant :BinarySignature
+
 	#  call-seq:
 	#     conn.copy_data( sql [, coder] ) {|sql_result| ... } -> PG::Result
 	#
@@ -189,10 +195,16 @@ class PG::Connection
 		case res.result_status
 		when PGRES_COPY_IN
 			begin
+				if res.binary_tuples == 1
+					# Binary file header (11 byte signature, 32 bit flags and 32 bit extension length)
+					put_copy_data(BinarySignature + ("\x00" * 8))
+				end
+
 				if coder
 					old_coder = self.encoder_for_put_copy_data
 					self.encoder_for_put_copy_data = coder
 				end
+
 				yield res
 			rescue Exception => err
 				errmsg = "%s while copy data: %s" % [ err.class.name, err.message ]
@@ -205,6 +217,12 @@ class PG::Connection
 				raise err
 			else
 				begin
+					self.encoder_for_put_copy_data = old_coder if coder
+
+					if res.binary_tuples == 1
+						put_copy_data("\xFF\xFF") # Binary file trailer 16 bit "-1"
+					end
+
 					put_copy_end
 				rescue PG::Error => err
 					raise PG::LostCopyState.new("#{err} (probably by executing another SQL query while running a COPY command)", connection: self)
@@ -226,6 +244,13 @@ class PG::Connection
 				discard_results
 				raise
 			else
+				if res.binary_tuples == 1
+					# there are two end markers in binary mode: file trailer and the final nil
+					if get_copy_data
+						discard_results
+						raise PG::NotAllCopyDataRetrieved.new("Not all binary COPY data retrieved", connection: self)
+					end
+				end
 				res = get_last_result
 				if !res
 					discard_results
@@ -320,6 +345,23 @@ class PG::Connection
 		end
 	end
 
+	# Read all pending socket input to internal memory and raise an exception in case of errors.
+	#
+	# This verifies that the connection socket is in a usable state and not aborted in any way.
+	# No communication is done with the server.
+	# Only pending data is read from the socket - the method doesn't wait for any outstanding server answers.
+	#
+	# Raises a kind of PG::Error if there was an error reading the data or if the socket is in a failure state.
+	#
+	# The method doesn't verify that the server is still responding.
+	# To verify that the communication to the server works, it is recommended to use something like <tt>conn.exec('')</tt> instead.
+	def check_socket
+		while socket_io.wait_readable(0)
+			consume_input
+		end
+		nil
+	end
+
 	# call-seq:
 	#    conn.get_result() -> PG::Result
 	#    conn.get_result() {|pg_result| block }
@@ -774,7 +816,10 @@ class PG::Connection
 		#    PG::Connection.ping(connection_string)     -> Integer
 		#    PG::Connection.ping(host, port, options, tty, dbname, login, password) ->  Integer
 		#
-		# Check server status.
+		# PQpingParams reports the status of the server.
+		#
+		# It accepts connection parameters identical to those of PQ::Connection.new .
+		# It is not necessary to supply correct user name, password, or database name values to obtain the server status; however, if incorrect values are provided, the server will log a failed connection attempt.
 		#
 		# See PG::Connection.new for a description of the parameters.
 		#
@@ -787,6 +832,8 @@ class PG::Connection
 		#   could not establish connection
 		# [+PQPING_NO_ATTEMPT+]
 		#   connection not attempted (bad params)
+		#
+		# See also check_socket for a way to check the connection without doing any server communication.
 		def ping(*args)
 			if Fiber.respond_to?(:scheduler) && Fiber.scheduler
 				# Run PQping in a second thread to avoid blocking of the scheduler.
@@ -798,23 +845,25 @@ class PG::Connection
 		end
 		alias async_ping ping
 
-		REDIRECT_CLASS_METHODS = {
+		REDIRECT_CLASS_METHODS = PG.make_shareable({
 			:new => [:async_connect, :sync_connect],
 			:connect => [:async_connect, :sync_connect],
 			:open => [:async_connect, :sync_connect],
 			:setdb => [:async_connect, :sync_connect],
 			:setdblogin => [:async_connect, :sync_connect],
 			:ping => [:async_ping, :sync_ping],
-		}
+		})
+		private_constant :REDIRECT_CLASS_METHODS
 
 		# These methods are affected by PQsetnonblocking
-		REDIRECT_SEND_METHODS = {
+		REDIRECT_SEND_METHODS = PG.make_shareable({
 			:isnonblocking => [:async_isnonblocking, :sync_isnonblocking],
 			:nonblocking? => [:async_isnonblocking, :sync_isnonblocking],
 			:put_copy_data => [:async_put_copy_data, :sync_put_copy_data],
 			:put_copy_end => [:async_put_copy_end, :sync_put_copy_end],
 			:flush => [:async_flush, :sync_flush],
-		}
+		})
+		private_constant :REDIRECT_SEND_METHODS
 		REDIRECT_METHODS = {
 			:exec => [:async_exec, :sync_exec],
 			:query => [:async_exec, :sync_exec],
@@ -832,12 +881,14 @@ class PG::Connection
 			:client_encoding= => [:async_set_client_encoding, :sync_set_client_encoding],
 			:cancel => [:async_cancel, :sync_cancel],
 		}
+		private_constant :REDIRECT_METHODS
 
 		if PG::Connection.instance_methods.include? :async_encrypt_password
 			REDIRECT_METHODS.merge!({
 				:encrypt_password => [:async_encrypt_password, :sync_encrypt_password],
 			})
 		end
+		PG.make_shareable(REDIRECT_METHODS)
 
 		def async_send_api=(enable)
 			REDIRECT_SEND_METHODS.each do |ali, (async, sync)|

data/lib/pg/text_decoder/date.rb

@@ -0,0 +1,18 @@
+# -*- ruby -*-
+# frozen_string_literal: true
+
+require 'date'
+
+module PG
+	module TextDecoder
+		class Date < SimpleDecoder
+			def decode(string, tuple=nil, field=nil)
+				if string =~ /\A(\d{4})-(\d\d)-(\d\d)\z/
+					::Date.new $1.to_i, $2.to_i, $3.to_i
+				else
+					string
+				end
+			end
+		end
+	end
+end # module PG

data/lib/pg/text_decoder/inet.rb

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

data/lib/pg/text_decoder/json.rb

@@ -0,0 +1,14 @@
+# -*- ruby -*-
+# frozen_string_literal: true
+
+require 'json'
+
+module PG
+	module TextDecoder
+		class JSON < SimpleDecoder
+			def decode(string, tuple=nil, field=nil)
+				::JSON.parse(string, quirks_mode: true)
+			end
+		end
+	end
+end # module PG

data/lib/pg/text_decoder/numeric.rb

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

data/lib/pg/text_decoder/timestamp.rb

@@ -0,0 +1,30 @@
+# -*- ruby -*-
+# frozen_string_literal: true
+
+module PG
+	module TextDecoder
+		# 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}" 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}" 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}" unless hash.empty?
+				super(**hash, **kwargs, flags: PG::Coder::TIMESTAMP_DB_LOCAL | PG::Coder::TIMESTAMP_APP_LOCAL)
+			end
+		end
+
+		# For backward compatibility:
+		TimestampWithoutTimeZone = TimestampLocal
+		TimestampWithTimeZone = Timestamp
+	end
+end # module PG

data/lib/pg/text_encoder/date.rb

@@ -0,0 +1,12 @@
+# -*- ruby -*-
+# frozen_string_literal: true
+
+module PG
+	module TextEncoder
+		class Date < SimpleEncoder
+			def encode(value)
+				value.respond_to?(:strftime) ? value.strftime("%Y-%m-%d") : value
+			end
+		end
+	end
+end # module PG

data/lib/pg/text_encoder/inet.rb

@@ -0,0 +1,28 @@
+# -*- ruby -*-
+# frozen_string_literal: true
+
+require 'ipaddr'
+
+module PG
+	module TextEncoder
+		class Inet < SimpleEncoder
+			def encode(value)
+				case value
+				when IPAddr
+					default_prefix = (value.family == Socket::AF_INET ? 32 : 128)
+					s = value.to_s
+					if value.respond_to?(:prefix)
+						prefix = value.prefix
+					else
+						range = value.to_range
+						prefix  = default_prefix - Math.log(((range.end.to_i - range.begin.to_i) + 1), 2).to_i
+					end
+					s << "/" << prefix.to_s if prefix != default_prefix
+					s
+				else
+					value
+				end
+			end
+		end
+	end
+end # module PG

data/lib/pg/text_encoder/json.rb

@@ -0,0 +1,14 @@
+# -*- ruby -*-
+# frozen_string_literal: true
+
+require 'json'
+
+module PG
+	module TextEncoder
+		class JSON < SimpleEncoder
+			def encode(value)
+				::JSON.generate(value, quirks_mode: true)
+			end
+		end
+	end
+end # module PG

data/lib/pg/text_encoder/numeric.rb

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