pg_funcall 0.1.0

data/lib/pg_funcall/ipaddr_monkeys.rb

@@ -0,0 +1,23 @@
+require 'ipaddr'
+require 'ipaddr_extensions'
+
+class IPAddr
+  def prefixlen
+    mask = @mask_addr
+    len = 0
+    len += mask & 1 and mask >>= 1 until mask == 0
+    len
+  end
+
+  def to_cidr_string
+    "#{to_s}/#{prefixlen}"
+  end
+
+  def as_json(options = {})
+    if (ipv6? && prefixlen == 64) || (ipv4? && prefixlen == 32)
+      to_s
+    else
+      to_cidr_string
+    end
+  end
+end

data/lib/pg_funcall/type_info.rb

@@ -0,0 +1,149 @@
+class PgFuncall::TypeInfo
+  attr_accessor :ar_type
+  attr_accessor :array_type
+  attr_accessor :element_type
+
+  def initialize(row, ar_type = nil)
+    @row = {}
+    # copy and convert int-looking things to int along the way
+    row.each do |key, val|
+      @row[key] =
+          (val && val.respond_to?(:match) && val.match(/^-?\d+$/)) ? val.to_i : val
+    end
+    @row.freeze
+    @ar_type = ar_type
+  end
+
+  # TODO: replace this to not use ar_type
+  def cast_from_database(value)
+    @ar_type.respond_to?(:type_cast_from_database) ?
+        @ar_type.type_cast_from_database(value) :
+        @ar_type.type_cast(value)
+  end
+
+    #
+  # Represent a Ruby object in a string form to be passed as a parameter
+  # within a descriptor hash, rather than substituted into a string-form
+  # query.
+  #
+  def _format_param_for_descriptor(param, type=nil)
+    return param.value if param.is_a?(PgFuncall::Literal)
+
+    case param
+      when PgFuncall::TypedArray
+        _format_param_for_descriptor(param.value, param.type + "[]")
+      when PgFuncall::Typed
+        _format_param_for_descriptor(param.value, param.type)
+      when PgFuncall::PGTyped
+        param.respond_to?(:__pg_value) ?
+            param.__pg_value :
+            _format_param_for_descriptor(param, type)
+      when TrueClass
+        'true'
+      when FalseClass
+        'false'
+      when String
+        if type == 'bytea' || param.encoding == Encoding::BINARY
+          '\x' + param.unpack('C*').map {|x| sprintf("%02X", x)}.join("")
+        else
+          param
+        end
+      when Array
+        "{" + param.map {|p| _format_param_for_descriptor(p)}.join(",") + "}"
+      when IPAddr
+        param.to_cidr_string
+      when Range
+        last_char = param.exclude_end? ? ')' : ']'
+        case type
+          when 'tsrange', 'tstzrange'
+            "[#{param.first.utc},#{param.last.utc}#{last_char}"
+          else
+            "[#{param.first},#{param.last}#{last_char}"
+        end
+      when Set
+        _format_param_for_descriptor(param.to_a)
+      when Hash
+        param.map do |k,v|
+          "#{k} => #{v}"
+        end.join(',')
+      else
+        ActiveRecord::Base.connection.quote(param)
+    end
+  end
+
+    # TODO: replace this to not use ar_type
+  def cast_to_database(value)
+    @ar_type.respond_to?(:type_cast_for_database) ?
+        @ar_type.type_cast_for_database(value).to_s :
+        _format_param_for_descriptor(value, name)
+  end
+
+  def name
+    @row['typname']
+  end
+
+  def namespace
+    @row['nspname']
+  end
+
+  #
+  # Don't fully qualify base types -- this is pretty, but is it wise?
+  #
+  def fqname
+    namespace == 'pg_catalog' ?
+        name :
+        namespace + '.' + name
+  end
+
+  def oid
+    @row['oid']
+  end
+
+  def category
+    @row['typcategory']
+  end
+
+  def temporal?
+    datetime? || timespan?
+  end
+
+  CATEGORY_MAP =
+      {'A' => 'array',
+       'B' => 'boolean',
+       'C' => 'composite',
+       'D' => 'datetime',
+       'E' => 'enum',
+       'G' => 'geometric',
+       'I' => 'network_address',
+       'N' => 'numeric',
+       'P' => 'pseudotype',
+       'S' => 'string',
+       'T' => 'timespan',
+       'U' => 'user_defined',
+       'V' => 'bit_string',
+       'X' => 'unknown'
+      }
+
+  CATEGORY_MAP.each do |typ, name|
+    define_method("#{name}?") do
+      category == typ
+    end
+  end
+
+  def category_name
+    CATEGORY_MAP[category]
+  end
+
+  def element_type_oid
+    raise "Can only call on array" unless array?
+    @row['typelem']
+  end
+
+  def array_type_oid
+    @row['typarray']
+  end
+
+  def [](element)
+    @row[element.to_s]
+  end
+end

data/lib/pg_funcall/type_map.rb

@@ -0,0 +1,198 @@
+require 'active_record'
+require 'pg_funcall/type_info'
+
+class PgFuncall
+  class FunctionSig
+    FTYPE_CACHE = {}
+
+    attr_reader :name, :ret_type, :arg_sigs
+
+    def initialize(name, ret_type, arg_sigs)
+      @name     = name.freeze
+      @ret_type = ret_type
+      @arg_sigs = arg_sigs.sort.freeze
+    end
+
+    def ==(other)
+      other.name     == @name
+      other.ret_type == @ret_type
+      other.arg_sigs == @arg_sigs
+    end
+  end
+
+  class PgType
+    def initialize(pginfo, ar_type)
+      @pginfo = pginfo
+      @ar_type = ar_type
+    end
+
+    def to_s
+      array ? "#{name}[]" : name
+    end
+  end
+
+  #
+  # See http://www.postgresql.org/docs/9.4/static/catalog-pg-type.html#CATALOG-TYPCATEGORY-TABLE
+  #
+  class TypeMap
+    def self.fetch(connection, options = {})
+      case ActiveRecord.version.segments[0..1]
+        when [4,0] then AR40TypeMap.new(connection, options)
+        when [4,1] then AR41TypeMap.new(connection, options)
+        when [4,2] then AR42TypeMap.new(connection, options)
+        else
+          raise ArgumentError, "Unsupported ActiveRecord version #{ActiveRecord.version}"
+      end
+    end
+
+
+    def initialize(connection, options = {})
+      @ftype_cache = {}
+      @ar_connection = connection
+      @options = options
+      @typeinfo         = []
+      @typeinfo_by_name = {}
+      @typeinfo_by_oid  = {}
+
+      load_types
+    end
+
+    def load_types
+      res = pg_connection.query <<-SQL
+         SELECT pgt.oid, ns.nspname, *
+         FROM pg_type as pgt
+         JOIN pg_namespace as ns on pgt.typnamespace = ns.oid;
+      SQL
+
+      PgFuncall._assign_pg_type_map_to_res(res, pg_connection)
+
+      fields = res.fields
+      @typeinfo = res.values.map do |values|
+        row = Hash[fields.zip(values)]
+        TypeInfo.new(row, lookup_ar_by_oid(row['oid'].to_i))
+      end
+
+      @typeinfo_by_name.clear
+      @typeinfo_by_oid.clear
+
+      @typeinfo.each do |ti|
+        @typeinfo_by_name[ti.name] = ti
+        @typeinfo_by_oid[ti.oid]   = ti
+      end
+    end
+
+    def ar_connection
+      @ar_connection
+    end
+
+    def pg_connection
+      @ar_connection.raw_connection
+    end
+
+    def type_cast_from_database(value, type)
+      type.cast_from_database(value)
+    end
+
+    def _canonicalize_type_name(name)
+      if name.end_with?('[]')
+        name = '_' + name.gsub(/(\[\])+$/, '')
+      end
+      name
+    end
+
+    def resolve(oid_or_name)
+      if oid_or_name.is_a?(Integer) || (oid_or_name.is_a?(String) && oid_or_name.match(/^[0-9]+$/))
+        @typeinfo_by_oid[oid_or_name.to_i]
+      elsif oid_or_name.is_a?(String) || oid_or_name.is_a?(Symbol)
+        @typeinfo_by_name[_canonicalize_type_name(oid_or_name.to_s)]
+      else
+        raise ArgumentError, "You must supply a numeric OID or a string Type name"
+      end
+    end
+
+    #
+    # Given a type name, with optional appended [] or prefixed _ for array types,
+    # return the OID for it.
+    #
+    # If array = true, find array type for given base type.
+    #
+    def oid_for_type(type, array = false)
+      type = _canonicalize_type_name(type)
+      type = '_' + type if array && !type.start_with?('_')
+      @typeinfo_by_name[type]
+    end
+
+    FMETAQUERY = <<-"SQL"
+            SELECT prorettype, proargtypes
+            FROM pg_proc as pgp
+            JOIN pg_namespace as ns on pgp.pronamespace = ns.oid
+            WHERE proname = '%s' AND ns.nspname = '%s';
+          SQL
+
+    #
+    # Query PostgreSQL metadata about function to find its
+    # return type and argument types
+    #
+    def function_types(fn, search_path = @options[:search_path])
+      return @ftype_cache[fn] if @ftype_cache[fn]
+
+      parts = fn.split('.')
+      info =  if parts.length == 1
+                raise ArgumentError, "Must supply search_path for non-namespaced function" unless
+                  search_path && search_path.is_a?(Enumerable) && !search_path.empty?
+                search_path.map do |ns|
+                  res = pg_connection.query(FMETAQUERY % [parts[0], ns])
+                  PgFuncall._assign_pg_type_map_to_res(res, pg_connection)
+                  res.ntuples == 1 ? res : nil
+                end.compact.first
+              else
+                PgFuncall._assign_pg_type_map_to_res(pg_connection.query(FMETAQUERY % [parts[1], parts[0]]),
+                                                     pg_connection)
+              end
+
+      return nil unless info && info.ntuples >= 1
+
+      @ftype_cache[fn] =
+          FunctionSig.new(fn,
+                          info.getvalue(0,0).to_i,
+                          (0..info.ntuples-1).map { |row|
+                            info.getvalue(row, 1).split(/ +/).map(&:to_i)
+                          })
+    end
+  end
+
+  class AR40TypeMap < TypeMap
+    def lookup_ar_by_oid(oid)
+      ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::OID::TYPE_MAP[oid]
+    end
+
+    def lookup_ar_by_name(name)
+      ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::OID::NAMES[name]
+    end
+  end
+
+  class AR41TypeMap < TypeMap
+    def lookup_ar_by_name(name)
+      ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::OID::NAMES[name]
+    end
+
+    def lookup_ar_by_oid(oid)
+      @ar_connection.instance_variable_get("@type_map")[oid]
+    end
+  end
+
+  class AR42TypeMap < TypeMap
+    def lookup_ar_by_name(name)
+      @ar_connection.instance_variable_get("@type_map").lookup(name)
+    end
+
+    def lookup_ar_by_oid(oid)
+      @ar_connection.instance_variable_get("@type_map").lookup(oid)
+    end
+
+    def type_cast_from_database(value, type)
+      type.ar_type.type_cast_from_database(value)
+    end
+  end
+end
+

data/lib/pg_funcall/version.rb

@@ -0,0 +1,3 @@
+class PgFuncall
+  VERSION = "0.1.0"
+end

data/pg_funcall.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pg_funcall/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "pg_funcall"
+  spec.version       = PgFuncall::VERSION
+  spec.authors       = ["Robert Sanders"]
+  spec.email         = ["robert@curioussquid.com"]
+  spec.summary       = %q{Utility class for calling functions defined in a PostgreSQL database.}
+  # spec.description   = %q{.}
+  spec.homepage      = "http://github.com/rsanders/pg_funcall"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "pg", ">= 0.17.0"
+  spec.add_dependency "activerecord", ">= 4.0.0"
+
+  # support for various PG types
+  spec.add_dependency "uuid"
+  spec.add_dependency "ipaddr_extensions"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 2.14.0"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "wwtd"
+
+end

data/script/shell

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'yaml'
+require 'active_record'
+configs = YAML.load(File.read("config/database.yml.example"))
+ActiveRecord::Base.establish_connection(configs['development'])
+
+require 'pg_funcall'
+
+def conn
+  ActiveRecord::Base.connection
+end
+
+def pgconn
+  conn.raw_connection
+end
+
+def oidclass
+  ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::OID
+end
+
+begin
+  require 'pry'
+  Pry.start
+rescue LoadError
+  require 'irb'
+  IRB.start
+end
+

data/spec/lib/pg_funcall_spec.rb

@@ -0,0 +1,371 @@
+require 'spec_helper'
+
+#
+# Test the utility class for calling database functions
+#
+
+describe PgFuncall do
+  before(:all) do
+    ActiveRecord::Base.connection.execute <<-SQL
+      CREATE EXTENSION IF NOT EXISTS hstore;
+
+      CREATE OR REPLACE FUNCTION public.dbfspec_polyfunc(arg1 anyelement)
+      RETURNS anyelement
+      LANGUAGE plpgsql
+      AS $function$
+      BEGIN
+        RETURN arg1;
+      END;
+      $function$;
+
+      CREATE OR REPLACE FUNCTION public.dbfspec_textfunc(arg1 text, arg2 text)
+      RETURNS text
+      LANGUAGE plpgsql
+      AS $function$
+      BEGIN
+        RETURN arg1 || ',' || arg2;
+      END;
+      $function$;
+
+      CREATE OR REPLACE FUNCTION public.dbfspec_intfunc(arg1 integer, arg2 integer)
+      RETURNS integer
+      LANGUAGE plpgsql
+      AS $function$
+      BEGIN
+        RETURN arg1 + arg2;
+      END;
+      $function$;
+
+      CREATE OR REPLACE FUNCTION public.dbfspec_arrayfunc(arg integer[])
+      RETURNS integer[]
+      LANGUAGE plpgsql
+      AS $function$
+      DECLARE
+        result integer[];
+        val integer;
+      BEGIN
+        result := '{}';
+        FOREACH val IN ARRAY arg LOOP
+          result := array_append(result, val * 2);
+        END LOOP;
+        RETURN result;
+      END;
+      $function$;
+
+      CREATE OR REPLACE FUNCTION public.dbfspec_hstorefunc(arg hstore, cay text)
+      RETURNS text
+      LANGUAGE plpgsql
+      AS $function$
+      BEGIN
+        RETURN arg -> cay;
+      END;
+      $function$;
+
+      CREATE OR REPLACE FUNCTION public.dbfspec_hstorefunc(arg1 hstore, arg2 hstore)
+      RETURNS hstore
+      LANGUAGE plpgsql
+      AS $function$
+      BEGIN
+        RETURN arg1 || arg2;
+      END;
+      $function$;
+  SQL
+
+  end
+
+  after(:all) do
+    ActiveRecord::Base.connection.execute <<-SQL
+      DROP FUNCTION IF EXISTS public.dbfspec_polyfunc(anyelement);
+      DROP FUNCTION IF EXISTS public.dbfspec_textfunc(text, text);
+      DROP FUNCTION IF EXISTS public.dbfspec_intfunc(integer, integer);
+      DROP FUNCTION IF EXISTS public.dbfspec_arrayfunc(integer[]);
+      DROP FUNCTION IF EXISTS public.dbfspec_hstorefunc(hstore, text);
+
+    SQL
+  end
+
+  let :search_path do
+    ActiveRecord::Base.connection.schema_search_path.split(/, ?/)
+  end
+
+  context 'introspection' do
+    subject { PgFuncall.default_instance }
+
+    context '#search_path' do
+      it 'should return the expected search path' do
+        subject.search_path.should == search_path
+      end
+    end
+  end
+
+  context 'quoting for inlining into string' do
+    subject { PgFuncall.default_instance }
+    it 'does not quote integer' do
+      subject._quote_param(50).should == "50"
+    end
+
+    it 'single-quotes a string' do
+      subject._quote_param("foo").should == "'foo'"
+    end
+
+    it 'handles single quotes embedded in string' do
+      subject._quote_param("ain't misbehavin'").should ==
+          "'ain''t misbehavin'''"
+    end
+
+    it 'quotes string array properly' do
+      subject._quote_param(%w[a b cdef]).should ==
+          "ARRAY['a','b','cdef']"
+    end
+
+    it 'quotes integer array properly' do
+      subject._quote_param([99, 100]).should ==
+          "ARRAY[99,100]"
+    end
+
+    # XXX: this can be iffy unless there's a clear typecast or
+    #  unambiguous function parameter type; arrays must be typed
+    #  so it's best to specify the type of empty arrays
+    it 'quotes empty array' do
+      subject._quote_param([]).should ==
+          "ARRAY[]"
+    end
+
+    it 'quotes Ruby hash as hstore' do
+      subject._quote_param({a: 1, b: :foo}).should ==
+          "$$a => 1,b => foo$$::hstore"
+    end
+  end
+
+  context 'quoting for inclusing in Pg param descriptor' do
+    subject { PgFuncall.default_instance }
+
+    it 'does not quote integer' do
+      subject._format_param_for_descriptor(50).should == "50"
+    end
+
+    it 'single-quotes a string' do
+      subject._format_param_for_descriptor("foo").should == "foo"
+    end
+
+    it 'handles single quotes embedded in string' do
+      subject._format_param_for_descriptor("ain't misbehavin'").should ==
+          "ain't misbehavin'"
+    end
+
+    it 'quotes string array properly' do
+      subject._format_param_for_descriptor(%w[a b cdef]).should ==
+          "{a,b,cdef}"
+    end
+
+    it 'quotes integer array properly' do
+      subject._format_param_for_descriptor([99, 100]).should ==
+          "{99,100}"
+    end
+
+    # XXX: this can be iffy unless there's a clear typecast or
+    #  unambiguous function parameter type; arrays must be typed
+    #  so it's best to specify the type of empty arrays
+    it 'quotes empty array' do
+      subject._format_param_for_descriptor([]).should ==
+          "{}"
+    end
+
+    it 'quotes Ruby hash as hstore' do
+      subject._format_param_for_descriptor({a: 1, b: :foo}).should ==
+          "a => 1,b => foo"
+    end
+  end
+
+  context 'simple call with string return' do
+    it 'should return a string as a string' do
+      PgFuncall.call_uncast('public.dbfspec_textfunc', "hello", "goodbye").should == 'hello,goodbye'
+    end
+
+    it 'should return a polymorphic-cast string as a string' do
+      PgFuncall.call_uncast('public.dbfspec_polyfunc',
+                      PgFuncall.literal("'hello'::text")).should == 'hello'
+    end
+
+    it 'should return a number as a string' do
+      PgFuncall.call_uncast('public.dbfspec_intfunc', 55, 100).should == "155"
+    end
+
+    it 'should return an array as a string' do
+      PgFuncall.call_uncast('public.dbfspec_arrayfunc',
+                      PgFuncall.literal('ARRAY[55, 100]::integer[]')).should == '{110,200}'
+    end
+  end
+
+  context 'call with typecast return' do
+    it 'should return a polymorphic-cast string as a string' do
+      PgFuncall.call('public.dbfspec_polyfunc',
+                      PgFuncall.literal("'hello'::text")).should == 'hello'
+    end
+
+    it 'should return a string as a string' do
+      PgFuncall.call('public.dbfspec_textfunc', "hello", "goodbye").should == 'hello,goodbye'
+    end
+
+    it 'should return a number as a string' do
+      PgFuncall.call('public.dbfspec_intfunc', 55, 100).should == 155
+    end
+
+    it 'should return a literal array as an array' do
+      PgFuncall.call('public.dbfspec_arrayfunc',
+                      PgFuncall.literal('ARRAY[55, 100]::integer[]')).
+          should == [110, 200]
+    end
+
+    it 'should take a Ruby array as a PG array' do
+      PgFuncall.call('public.dbfspec_arrayfunc',
+                      [30, 92]).should == [60, 184]
+    end
+
+    it 'should take a Ruby hash as a PG hstore' do
+      PgFuncall.call('public.dbfspec_hstorefunc',
+                      {'a' => 'foo', 'b' => 'baz'}, 'b').should == 'baz'
+    end
+
+    it 'should return a PG hstore as a Ruby hash ' do
+      PgFuncall.call('public.dbfspec_hstorefunc',
+                      {'a' => 'foo', 'b' => 'baz'},
+                      {'c' => 'cat'}).should == {'a' => 'foo', 'b' => 'baz', 'c' => 'cat'}
+    end
+  end
+
+  context 'type roundtripping via SELECT' do
+    def roundtrip(value)
+      PgFuncall.casting_query("SELECT $1;", [value]).first
+    end
+
+    context 'numeric types' do
+      it 'should return an integer for an integer' do
+        roundtrip(3215).should eql(3215)
+      end
+
+      it 'should return a float for a float' do
+        roundtrip(77.45).should eql(77.45)
+      end
+
+      it 'should handle bigdecimal' do
+        roundtrip(BigDecimal.new("500.23")).should == BigDecimal.new("500.23")
+      end
+    end
+
+    context 'textual types' do
+      it 'should handle character' do
+        roundtrip(?Z).should == "Z"
+      end
+
+      it 'should handle UTF-8 string' do
+        roundtrip("peter piper picked").should == "peter piper picked"
+      end
+
+      it 'should handle binary string' do
+        binstring = [*(1..100)].pack('L*')
+        # puts "encoding is #{binstring.encoding}"
+        roundtrip(binstring).should == binstring
+      end
+    end
+
+    context 'hashes' do
+      it 'should handle empty hashes' do
+        roundtrip({}).should == {}
+      end
+      it 'should handle text->text hashes' do
+        roundtrip({'a' => 'foo', 'b' => 'baz'}).should == {'a' => 'foo', 'b' => 'baz'}
+      end
+      it 'should handle hashes with other type values' do
+        roundtrip({a: 'foo', b: 750}).should == {'a' => 'foo', 'b' => '750'}
+      end
+    end
+
+    context 'arrays' do
+      it 'should throw exception on untagged empty array' do
+        expect { roundtrip([]) }.to raise_error
+      end
+      it 'should handle wrapped, typed empty arrays' do
+        roundtrip(PgFuncall::TypedArray.new([], 'int4')).should == []
+      end
+      it 'should handle tagged arrays' do
+        roundtrip(PgFuncall::TypedArray.new([1,2,2**45], 'int8')).should == [1, 2, 2**45]
+      end
+      it 'should handle int arrays' do
+        roundtrip([1,2,77]).should == [1, 2, 77]
+      end
+      it 'should handle string arrays' do
+        roundtrip(%w[a b longerstring c]).should == ['a', 'b', 'longerstring', 'c']
+      end
+      it 'should handle arrays of int arrays' do
+        pending('it returns [nil, nil] for reasons unknown on AR 4.0.x - PLS FIX GOOBY') if
+            ActiveRecord.version.segments[0..1] == [4,0]
+        roundtrip(PgFuncall::TypedArray.new([[1,2,77], [99, 0, 4]], 'int4[]')).
+                      should == [[1,2,77], [99, 0, 4]]
+      end
+
+      it 'should handle arrays of txt arrays' do
+        roundtrip([['a', 'b'], ['x', 'y']]).should == [['a', 'b'], ['x', 'y']]
+      end
+    end
+
+    context 'temporal types' do
+      let(:now) { Time.now }
+      it 'should handle Date' do
+        roundtrip(now).should == now
+      end
+      it 'should handle DateTime' do
+        roundtrip(now.to_datetime).should == now.to_datetime
+      end
+      it 'should handle Time' do
+        roundtrip(PgFuncall::PGTime.new('11:45')).should == Time.parse('2000-01-01 11:45:00 UTC')
+      end
+      it 'should handle interval' do
+        roundtrip(PgFuncall::PGTimeInterval.new('1 hour')).should == '01:00:00'
+      end
+      it 'should handle with time zone'
+    end
+
+    context 'network types' do
+      it 'should handle IPv4 host without netmask' do
+        roundtrip(IPAddr.new("1.2.3.4")).should == IPAddr.new("1.2.3.4")
+      end
+      it 'should handle IPv4 host expressed as /32' do
+        roundtrip(IPAddr.new("1.2.3.4/32")).should == IPAddr.new("1.2.3.4/32")
+      end
+      it 'should handle IPv4 network' do
+        roundtrip(IPAddr.new("1.2.3.4/20")).should == IPAddr.new("1.2.3.4/20")
+      end
+      it 'should handle IPv6 host' do
+        roundtrip(IPAddr.new("2607:f8b0:4002:c01::65")).should == IPAddr.new("2607:f8b0:4002:c01::65")
+      end
+      it 'should handle IPv6 network' do
+        roundtrip(IPAddr.new("2001:db8:abcd:8000::/50")).should == IPAddr.new("2001:db8:abcd:8000::/50")
+      end
+    end
+
+    context 'misc types' do
+      it 'should handle UUIDs' do
+        uuid = UUID.new.generate
+        roundtrip(PgFuncall::PGUUID.new(uuid)).should == uuid
+      end
+      it 'should handle OIDs'
+      it 'should handle explicitly tagged types'
+      it 'should handle untyped literals'
+      it 'should handle literals including a cast'
+    end
+
+    context 'range types' do
+      it 'should handle int4 ranges'
+      it 'should handle int8 ranges'
+      it 'should handle end-exclusive ranges'
+      it 'should handle bignum ranges'
+      it 'should handle decimal ranges'
+      it 'should handle date ranges'
+      it 'should handle time ranges'
+      it 'should handle timestamp ranges'
+    end
+
+  end
+
+end