rom-sql 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 83c439ad1fcf4ee22b0a4f8d92f924b41b2a0d19
-  data.tar.gz: ebd68c2d754a959b7f669cbcc1269d23108a663c
+  metadata.gz: dd4d5efa9ebc24506ae85cf772c6d57f6d59530b
+  data.tar.gz: 1fe47e3b07ee7979e92d47257b1ecdf4a258246b
 SHA512:
-  metadata.gz: 4a8081d7fb278e307d71b3be25fe4d386e2a33aa6794b4706a1d7096daf2a29364a867e52e945a41c388f211ecbc0c280af23fe1a9ab9b9c0e730a0a7e5991cc
-  data.tar.gz: 8de227092aa395b288d281cbfc69c5370424d76c856ef24f96ef308a4f1f110633556c9021207f74f96b01ee279f0916fc66dcbc20d8d9f4a5d7a99992c5391e
+  metadata.gz: 7338e9310e9ea94d333489edde055d213e2b466640c1366702cd08f78d636ee0577b5ec2f16e9e4c47b67847ff50f5fe23476d0440ba4e3fec9ad7c1e265c663
+  data.tar.gz: 6c26fb847b68e9f5add7b8255fbf8d4b99ecd387dbcc5897343658c21cf75358b0dc3db369351c70fd592b2f90ce10b428512df0ffeabd747a80685a5b2da97f

data/.travis.yml

@@ -17,14 +17,11 @@ rvm:
   - 2.3
   - 2.2
   - rbx-3
-  - jruby-9.1.6.0
+  - jruby-9.1.7.0
 env:
   global:
     - CODECLIMATE_REPO_TOKEN=03d7f66589572702b12426d2bc71c4de6281a96139e33b335b894264b1f8f0b0
     - JRUBY_OPTS='--dev -J-Xmx1024M'
-matrix:
-  allow_failures:
-    - rvm: jruby-9.1.6.0
 notifications:
   webhooks:
     urls:

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+## v1.0.1 2017-02-09
+
+### Added
+
+* Support for inferring the PostgreSQL `hstore` data type (flash-gordon)
+* Support for the rest of geometric PostgreSQL data types (box, lseg, polygon, etc.) (Morozzzko)
+* Added inferring for timestamp types with specified precision (flash-gordon)
+* Added `ROM::SQL::Attribute#in` to support range checks in conditions (flash-gordon)
+
+### Fixed
+
+* Missing primary key now leads to a more meaningful error (flash-gordon)
+
 ## v1.0.0 2017-01-29
 
 This release is based on rom core 3.0.0 with its improved Schema API, which is extended with SQL-specific features.

data/Gemfile

@@ -7,6 +7,7 @@ gem 'rom-mapper', git: 'https://github.com/rom-rb/rom-mapper.git', branch: 'mast
 
 group :test do
   gem 'byebug', platforms: :mri
+  gem 'pry', platforms: %i(jruby rbx)
   gem 'dry-struct'
   gem 'activesupport', '~> 5.0'
   gem 'rspec', '~> 3.1'

data/Rakefile

@@ -1,3 +1,4 @@
+require "bundler/gem_tasks"
 require "rspec/core/rake_task"
 
 RSpec::Core::RakeTask.new(:spec)

data/lib/rom/plugins/relation/sql/auto_wrap.rb

@@ -32,10 +32,21 @@ module ROM
             #
             # @api private
             def for_wrap(keys, name)
-              other = __registry__[name]
-              other_dataset = other.name.dataset
+              rel, other =
+                if associations.key?(name)
+                  assoc = associations[name]
+                  other = __registry__[assoc.target.to_sym]
 
-              schema.merge(other.schema.wrap).qualified.(inner_join(other_dataset, keys))
+                  [assoc.join(__registry__, :inner_join, self), other]
+                else
+                  # TODO: deprecate this before 2.0
+                  other = __registry__[name]
+                  other_dataset = other.name.dataset
+
+                  [qualified.inner_join(other_dataset, keys), other]
+                end
+
+              rel.schema.merge(other.schema.wrap).qualified.(rel)
             end
           end
         end

data/lib/rom/sql/attribute.rb

@@ -149,7 +149,37 @@ module ROM
       #
       # @api public
       def is(other)
-        Sequel::SQL::BooleanExpression.new(:'=', self, other)
+        __cmp__(:'=', other)
+      end
+
+      # Return a boolean expression with an inclusion test
+      #
+      # If the single argument passed to the method is a Range object
+      # then the resulting expression will restrict the attribute value
+      # with range's bounds. Upper bound condition will be inclusive/non-inclusive
+      # depending on the range type.
+      #
+      # If more than one argument is passed to the method or the first
+      # argument is not Range then the result will be a simple IN check.
+      #
+      # @example
+      #   users.where { id.in(1..100) | created_at(((Time.now - 86400)..Time.now)) }
+      #   users.where { id.in(1, 2, 3) }
+      #   users.where(users[:id].in(1, 2, 3))
+      #
+      # @param [Array<Object>] *args A range or a list of values for an inclusion check
+      #
+      # @api public
+      def in(*args)
+        if args.first.is_a?(Range)
+          range = args.first
+          lower_cond = __cmp__(:>=, range.begin)
+          upper_cond = __cmp__(range.exclude_end? ? :< : :<=, range.end)
+
+          Sequel::SQL::BooleanExpression.new(:AND, lower_cond, upper_cond)
+        else
+          __cmp__(:IN, args)
+        end
       end
 
       # Create a function DSL from the attribute
@@ -213,6 +243,14 @@ module ROM
           super
         end
       end
+
+      # A simple wrapper for the boolean expression constructor where
+      # the left part is the attribute value
+      #
+      # @api private
+      def __cmp__(op, r)
+        Sequel::SQL::BooleanExpression.new(op, self, r)
+      end
     end
   end
 end

data/lib/rom/sql/errors.rb

@@ -11,6 +11,7 @@ module ROM
     ForeignKeyConstraintError = Class.new(ConstraintError)
     CheckConstraintError      = Class.new(ConstraintError)
     UnknownDBTypeError        = Class.new(StandardError)
+    MissingPrimaryKeyError    = Class.new(StandardError)
 
     ERROR_MAP = {
       Sequel::DatabaseError => DatabaseError,

data/lib/rom/sql/extensions/postgres/inferrer.rb

@@ -24,7 +24,14 @@ module ROM
           'cidr' => Types::PG::IPAddress,
           'macaddr' => Types::String,
           'point' => Types::PG::PointT,
-          'xml' => Types::String
+          'xml' => Types::String,
+          'hstore' => Types::PG::HStore,
+          'line' => Types::PG::LineT,
+          'circle' => Types::PG::CircleT,
+          'box' => Types::PG::BoxT,
+          'lseg' => Types::PG::LineSegmentT,
+          'polygon' => Types::PG::PolygonT,
+          'path' => Types::PG::PathT
         ).freeze
 
         db_array_type_matcher Sequel::Postgres::PGArray::EMPTY_BRACKET
@@ -52,7 +59,8 @@ module ROM
         end
 
         def map_db_type(db_type)
-          self.class.db_type_mapping[db_type]
+          self.class.db_type_mapping[db_type] ||
+            (db_type.start_with?('timestamp') ? Types::Time : nil)
         end
 
         def numeric?(ruby_type, db_type)

data/lib/rom/sql/extensions/postgres/types.rb

@@ -2,7 +2,7 @@ require 'dry-types'
 require 'sequel'
 require 'ipaddr'
 
-Sequel.extension(*%i(pg_array pg_array_ops pg_json pg_json_ops))
+Sequel.extension(*%i(pg_array pg_array_ops pg_json pg_json_ops pg_hstore))
 
 module ROM
   module SQL
@@ -14,8 +14,7 @@ module ROM
 
         # Array
 
-        Array = Dry::Types::Definition
-                .new(Sequel::Postgres::PGArray)
+        Array = Types.Definition(Sequel::Postgres::PGArray)
 
         def self.Array(db_type)
           Array.constructor(-> (v) { Sequel.pg_array(v, db_type) }).meta(type: db_type)
@@ -41,6 +40,11 @@ module ROM
 
         JSONB = JSONBArray | JSONBHash | JSONBOp
 
+        # HStore
+
+        HStoreR = Types.Constructor(Hash, &:to_hash)
+        HStore = Types.Constructor(Sequel::Postgres::HStore, &Sequel.method(:hstore)).meta(read: HStoreR)
+
         Bytea = Types.Constructor(Sequel::SQL::Blob, &Sequel::SQL::Blob.method(:new))
 
         IPAddressR = Types.Constructor(IPAddr) { |ip| IPAddr.new(ip.to_s) }
@@ -49,14 +53,112 @@ module ROM
 
         Money = Types::Decimal
 
+        # Geometric types
+
         Point = ::Struct.new(:x, :y)
 
+        PointD = Types.Definition(Point)
+
         PointTR = Types.Constructor(Point) do |p|
           x, y = p.to_s[1...-1].split(',', 2)
           Point.new(Float(x), Float(y))
         end
 
         PointT = Types.Constructor(Point) { |p| "(#{ p.x },#{ p.y })" }.meta(read: PointTR)
+
+        Line = ::Struct.new(:a, :b, :c)
+
+        LineTR = Types.Constructor(Line) do |ln|
+          a, b, c = ln.to_s[1..-2].split(',', 3)
+          Line.new(Float(a), Float(b), Float(c))
+        end
+
+        LineT = Types.Constructor(Line) { |ln| "{#{ ln.a },#{ ln.b },#{ln.c}}"}.meta(read: LineTR)
+
+        Circle = ::Struct.new(:center, :radius)
+
+        CircleTR = Types.Constructor(Circle) do |c|
+          x, y, r = c.to_s.tr('()<>', '').split(',', 3)
+          center = Point.new(Float(x), Float(y))
+          Circle.new(center, Float(r))
+        end
+
+        CircleT = Types.Constructor(Circle) { |c| "<(#{ c.center.x },#{ c.center.y }),#{ c.radius }>" }.meta(read: CircleTR)
+
+        Box = ::Struct.new(:upper_right, :lower_left)
+
+        BoxTR = Types.Constructor(Box) do |b|
+          x_right, y_right, x_left, y_left = b.to_s.tr('()', '').split(',', 4)
+          upper_right = Point.new(Float(x_right), Float(y_right))
+          lower_left = Point.new(Float(x_left), Float(y_left))
+          Box.new(upper_right, lower_left)
+        end
+
+        BoxT = Types.Constructor(Box) { |b| "((#{ b.upper_right.x },#{ b.upper_right.y }),(#{ b.lower_left.x },#{ b.lower_left.y }))" }.meta(read: BoxTR)
+
+        LineSegment = ::Struct.new(:begin, :end)
+
+        LineSegmentTR = Types.Constructor(LineSegment) do |lseg|
+          x_begin, y_begin, x_end, y_end = lseg.to_s.tr('()[]', '').split(',', 4)
+          point_begin = Point.new(Float(x_begin), Float(y_begin))
+          point_end = Point.new(Float(x_end), Float(y_end))
+          LineSegment.new(point_begin, point_end)
+        end
+
+        LineSegmentT = Types.Constructor(LineSegment) do |lseg|
+          "[(#{ lseg.begin.x },#{ lseg.begin.y }),(#{ lseg.end.x },#{ lseg.end.y })]"
+        end.meta(read: LineSegmentTR)
+
+        Polygon = Types::Strict::Array.member(PointD)
+
+        PolygonTR = Polygon.constructor do |p|
+          coordinates = p.to_s.tr('()', '').split(',').each_slice(2)
+          points = coordinates.map { |x, y| Point.new(Float(x), Float(y)) }
+          Polygon[points]
+        end
+
+        PolygonT = PointD.constructor do |path|
+          points_joined = path.map { |p| "(#{ p.x },#{ p.y })" }.join(',')
+          "(#{ points_joined })"
+        end.meta(read: PolygonTR)
+
+        Path = ::Struct.new(:points, :type) do
+          def open?
+            type == :open
+          end
+
+          def closed?
+            type == :closed
+          end
+
+          def to_a
+            points
+          end
+        end
+
+        PathD = Types.Definition(Path)
+
+        PathTR = PathD.constructor do |path|
+          open = path.to_s.start_with?('[') && path.to_s.end_with?(']')
+          coordinates = path.to_s.tr('()[]', '').split(',').each_slice(2)
+          points = coordinates.map { |x, y| Point.new(Float(x), Float(y)) }
+
+          if open
+            Path.new(points, :open)
+          else
+            Path.new(points, :closed)
+          end
+        end
+
+        PathT = PathD.constructor do |path|
+          points_joined = path.to_a.map { |p| "(#{ p.x },#{ p.y })" }.join(',')
+
+          if path.open?
+            "[#{ points_joined }]"
+          else
+            "(#{ points_joined })"
+          end
+        end.meta(read: PathTR)
       end
     end
   end

data/lib/rom/sql/gateway.rb

@@ -24,7 +24,7 @@ module ROM
       end
 
       CONNECTION_EXTENSIONS = {
-        postgres: %i(pg_array pg_json pg_enum)
+        postgres: %i(pg_array pg_json pg_enum pg_hstore)
       }.freeze
 
       # @!attribute [r] logger

data/lib/rom/sql/relation.rb

@@ -91,7 +91,12 @@ module ROM
           #
           #   @api public
           define_method(:by_pk) do |pk|
-            where(schema[primary_key] => pk)
+            if primary_key.nil?
+              raise MissingPrimaryKeyError.new("Missing primary key for "\
+                                               ":#{ schema.name }")
+            else
+              where(schema[primary_key] => pk)
+            end
           end
         end
       end

data/lib/rom/sql/types.rb

@@ -9,6 +9,10 @@ module ROM
         ROM::Types.Constructor(*args, &block)
       end
 
+      def self.Definition(*args, &block)
+        ROM::Types.Definition(*args, &block)
+      end
+
       Serial = Int.meta(primary_key: true)
 
       Blob = Constructor(Sequel::SQL::Blob, &Sequel::SQL::Blob.method(:new))

data/lib/rom/sql/version.rb

@@ -1,5 +1,5 @@
 module ROM
   module SQL
-    VERSION = '1.0.0'.freeze
+    VERSION = '1.0.1'.freeze
   end
 end

data/rom-sql.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.add_runtime_dependency 'sequel', '~> 4.42'
+  spec.add_runtime_dependency 'sequel', '~> 4.43'
   spec.add_runtime_dependency 'dry-equalizer', '~> 0.2'
   spec.add_runtime_dependency 'dry-types', '~> 0.9', '>= 0.9.4'
   spec.add_runtime_dependency 'dry-core', '~> 0.2', '>= 0.2.3'

data/spec/extensions/postgres/types_spec.rb

@@ -141,4 +141,112 @@ RSpec.describe 'ROM::SQL::Types' do
       expect(described_class.meta[:read]['(7.5,30.5)']).to eql(point)
     end
   end
+
+  describe ROM::SQL::Types::PG::HStore do
+    let(:mapping) { Hash['hot' => 'cold'] }
+    let(:read_type) { described_class.meta[:read] }
+
+    it 'covertss data to Sequel::Postgres::HStore' do
+      expect(described_class[mapping]).to be_a Sequel::Postgres::HStore
+      expect(described_class[mapping]).to eql(Sequel.hstore(hot: :cold))
+    end
+
+    it 'reads Sequel::Postgres::HStore as a Hash object' do
+      expect(read_type[Sequel.hstore(mapping)]).to eql(mapping)
+      expect(read_type[Sequel.hstore(mapping)]).to be_a(Hash)
+    end
+  end
+
+  describe ROM::SQL::Types::PG::LineT do
+    let(:line) { ROM::SQL::Types::PG::Line.new(2.3, 4.9, 3.1415) }
+
+    it 'serializes a line using the {A,B,C} format' do
+      expect(described_class[line]).to eql('{2.3,4.9,3.1415}')
+    end
+
+    it 'reads the {A,B,C} format' do
+      expect(described_class.meta[:read]['{2.3,4.9,3.1415}']).to eql(line)
+    end
+  end
+
+  describe ROM::SQL::Types::PG::CircleT do
+    let(:center) { ROM::SQL::Types::PG::Point.new(7.5, 30.5) }
+    let(:circle) { ROM::SQL::Types::PG::Circle.new(center, 1.2) }
+
+    it 'serializes a circle using the <(x,y),r> format' do
+      expect(described_class[circle]).to eql('<(7.5,30.5),1.2>')
+    end
+
+    it 'reads the <(x,y),r> format' do
+      expect(described_class.meta[:read]['<(7.5,30.5),1.2>']).to eql(circle)
+    end
+  end
+
+  describe ROM::SQL::Types::PG::BoxT do
+    let(:lower_left) { ROM::SQL::Types::PG::Point.new(7.5, 20.5) }
+    let(:upper_right) { ROM::SQL::Types::PG::Point.new(8.5, 30.5) }
+
+    let(:box) { ROM::SQL::Types::PG::Box.new(upper_right, lower_left) }
+
+    it 'serializes a box' do
+      expect(described_class[box]).to eql('((8.5,30.5),(7.5,20.5))')
+    end
+
+    it 'reads serialized format' do
+      expect(described_class.meta[:read]['((8.5,30.5),(7.5,20.5))']).to eql(box)
+    end
+  end
+
+  describe ROM::SQL::Types::PG::LineSegmentT do
+    let(:first) { ROM::SQL::Types::PG::Point.new(8.5, 30.5) }
+    let(:second) { ROM::SQL::Types::PG::Point.new(7.5, 20.5) }
+
+    let(:lseg) { ROM::SQL::Types::PG::LineSegment.new(first, second) }
+
+    it 'serializes a lseg using [ ( x1 , y1 ) , ( x2 , y2 ) ] format' do
+      expect(described_class[lseg]).to eql('[(8.5,30.5),(7.5,20.5)]')
+    end
+
+    it 'reads serialized format' do
+      expect(described_class.meta[:read]['[(8.5,30.5),(7.5,20.5)]']).to eql(lseg)
+    end
+  end
+
+  describe ROM::SQL::Types::PG::PolygonT do
+    let(:first) { ROM::SQL::Types::PG::Point.new(8.5, 30.5) }
+    let(:second) { ROM::SQL::Types::PG::Point.new(7.5, 20.5) }
+    let(:third) { ROM::SQL::Types::PG::Point.new(6.5, 10.5) }
+
+    let(:polygon) { ROM::SQL::Types::PG::Polygon[[first, second, third]] }
+
+    it 'serializes a polygon using ( ( x1 , y1 ) ... ( xn , yn ) ) format' do
+      expect(described_class[polygon]).to eql('((8.5,30.5),(7.5,20.5),(6.5,10.5))')
+    end
+
+    it 'reads serialized format' do
+      expect(described_class.meta[:read]['((8.5,30.5),(7.5,20.5),(6.5,10.5))']).to eql(polygon)
+    end
+  end
+
+  describe ROM::SQL::Types::PG::PathT do
+    let(:first) { ROM::SQL::Types::PG::Point.new(8.5, 30.5) }
+    let(:second) { ROM::SQL::Types::PG::Point.new(7.5, 20.5) }
+    let(:third) { ROM::SQL::Types::PG::Point.new(6.5, 10.5) }
+
+    let(:closed_path) { ROM::SQL::Types::PG::Path.new([first, second, third], :closed) }
+    let(:open_path) { ROM::SQL::Types::PG::Path.new([first, second, third], :open) }
+
+    it 'serializes a closed path using ( ( x1 , y1 ) ... ( xn , yn ) ) format' do
+      expect(described_class[closed_path]).to eql('((8.5,30.5),(7.5,20.5),(6.5,10.5))')
+    end
+
+    it 'serializes an open path' do
+      expect(described_class[open_path]).to eql('[(8.5,30.5),(7.5,20.5),(6.5,10.5)]')
+    end
+
+    it 'reads serialized format' do
+      expect(described_class.meta[:read]['((8.5,30.5),(7.5,20.5),(6.5,10.5))']).to eql(closed_path)
+      expect(described_class.meta[:read]['[(8.5,30.5),(7.5,20.5),(6.5,10.5)]']).to eql(open_path)
+    end
+  end
 end

data/spec/integration/commands/create_spec.rb

@@ -201,7 +201,6 @@ RSpec.describe 'Commands / Create', :postgres do
     end
 
     it 're-raises fk constraint violation error' do |ex|
-      pending 'Waits for https://github.com/jeremyevans/sequel/pull/1283' if jruby? && sqlite?(ex)
       expect {
         tasks.try {
           tasks.create.call(user_id: 918_273_645)

data/spec/integration/plugins/auto_wrap_spec.rb

@@ -4,9 +4,13 @@ RSpec.describe 'Plugins / :auto_wrap' do
 
     describe '#for_wrap' do
       shared_context 'joined tuple' do
+        let(:name) do
+          users.name.relation
+        end
+
         it 'returns joined tuples' do
           task_with_user = tasks
-            .for_wrap({ id: :user_id }, users.name.relation)
+            .for_wrap({ id: :user_id }, name)
             .where(tasks__id: 2)
             .one
 
@@ -51,6 +55,24 @@ RSpec.describe 'Plugins / :auto_wrap' do
 
         include_context 'joined tuple'
       end
+
+      context 'using association' do
+        subject(:tasks) { relations[:tasks] }
+
+        let(:users) { relations[:users] }
+
+        before do
+          conf.relation(:tasks) {
+            schema(infer: true) { associations { belongs_to :users, as: :assignee } }
+          }
+
+          conf.relation(:users) { schema(infer: true) }
+        end
+
+        include_context 'joined tuple' do
+          let(:name) { :assignee }
+        end
+      end
     end
   end
 end

data/spec/integration/schema/inferrer/mysql_spec.rb

@@ -7,6 +7,11 @@ RSpec.describe 'ROM::SQL::Schema::MysqlInferrer', :mysql do
     conn.create_table :test_inferrence do
       tinyint :tiny
       mediumint :medium
+      datetime :created_at
+      column :date_and_time, 'datetime(0)'
+      column :time_with_ms, 'datetime(3)'
+      timestamp :unix_time_usec
+      column :unix_time_sec, 'timestamp(0) null'
     end
   end
 
@@ -31,6 +36,11 @@ RSpec.describe 'ROM::SQL::Schema::MysqlInferrer', :mysql do
     expect(schema.to_h).to eql(
       tiny: ROM::SQL::Types::Int.optional.meta(name: :tiny, source: source),
       medium: ROM::SQL::Types::Int.optional.meta(name: :medium, source: source),
+      created_at: ROM::SQL::Types::Time.optional.meta(name: :created_at, source: source),
+      date_and_time: ROM::SQL::Types::Time.optional.meta(name: :date_and_time, source: source),
+      time_with_ms: ROM::SQL::Types::Time.optional.meta(name: :time_with_ms, source: source),
+      unix_time_usec: ROM::SQL::Types::Time.meta(name: :unix_time_usec, source: source),
+      unix_time_sec: ROM::SQL::Types::Time.optional.meta(name: :unix_time_sec, source: source)
     )
   end
 end

data/spec/integration/schema/inferrer/postgres_spec.rb

@@ -1,4 +1,3 @@
-
 RSpec.describe 'ROM::SQL::Schema::PostgresInferrer', :postgres do
   include_context 'database setup'
 
@@ -7,6 +6,7 @@ RSpec.describe 'ROM::SQL::Schema::PostgresInferrer', :postgres do
   before do
     conn.extension :pg_enum
 
+    conn.execute('create extension if not exists hstore')
     conn.drop_table?(:test_inferrence)
     conn.drop_enum(:rainbow, if_exists: true)
 
@@ -25,6 +25,16 @@ RSpec.describe 'ROM::SQL::Schema::PostgresInferrer', :postgres do
       rainbow :color
       point :center
       xml :page
+      hstore :mapping
+      line :line
+      circle :circle
+      box :box
+      lseg :lseg
+      polygon :polygon
+      path :path
+      timestamp :created_at
+      column :datetime, "timestamp(0) without time zone"
+      column :datetime_tz, "timestamp(0) with time zone"
     end
   end
 
@@ -71,7 +81,45 @@ RSpec.describe 'ROM::SQL::Schema::PostgresInferrer', :postgres do
           source: source,
           read: ROM::SQL::Types::PG::PointTR.optional
         ),
-        page: ROM::SQL::Types::String.optional.meta(name: :page, source: source)
+        page: ROM::SQL::Types::String.optional.meta(name: :page, source: source),
+        mapping: ROM::SQL::Types::PG::HStore.optional.meta(
+          name: :mapping,
+          source: source,
+          read: ROM::SQL::Types::PG::HStoreR.optional
+        ),
+        line: ROM::SQL::Types::PG::LineT.optional.meta(
+          name: :line,
+          source: source,
+          read: ROM::SQL::Types::PG::LineTR.optional
+        ),
+        circle: ROM::SQL::Types::PG::CircleT.optional.meta(
+          name: :circle,
+          source: source,
+          read: ROM::SQL::Types::PG::CircleTR.optional
+        ),
+        box: ROM::SQL::Types::PG::BoxT.optional.meta(
+          name: :box,
+          source: source,
+          read: ROM::SQL::Types::PG::BoxTR.optional
+        ),
+        lseg: ROM::SQL::Types::PG::LineSegmentT.optional.meta(
+          name: :lseg,
+          source: source,
+          read: ROM::SQL::Types::PG::LineSegmentTR.optional
+        ),
+        polygon: ROM::SQL::Types::PG::PolygonT.optional.meta(
+          name: :polygon,
+          source: source,
+          read: ROM::SQL::Types::PG::PolygonTR.optional
+        ),
+        path: ROM::SQL::Types::PG::PathT.optional.meta(
+          name: :path,
+          source: source,
+          read: ROM::SQL::Types::PG::PathTR.optional
+        ),
+        created_at: ROM::SQL::Types::Time.optional.meta(name: :created_at, source: source),
+        datetime: ROM::SQL::Types::Time.optional.meta(name: :datetime, source: source),
+        datetime_tz: ROM::SQL::Types::Time.optional.meta(name: :datetime_tz, source: source)
       )
     end
   end
@@ -90,10 +138,20 @@ RSpec.describe 'ROM::SQL::Schema::PostgresInferrer', :postgres do
   context 'with a column with bi-directional mapping' do
     before do
       conn.drop_table?(:test_bidirectional)
+      conn.execute('create extension if not exists hstore')
+
       conn.create_table(:test_bidirectional) do
         primary_key :id
         inet :ip
         point :center
+        hstore :mapping
+        line :line
+        circle :circle
+        box :box
+        lseg :lseg
+        polygon :polygon
+        path :closed_path
+        path :open_path
       end
 
       conf.relation(:test_bidirectional) { schema(infer: true) }
@@ -106,14 +164,38 @@ RSpec.describe 'ROM::SQL::Schema::PostgresInferrer', :postgres do
     end
 
     let(:point) { ROM::SQL::Types::PG::Point.new(7.5, 30.5) }
+    let(:point_2) { ROM::SQL::Types::PG::Point.new(8.5, 35.5) }
+    let(:line) { ROM::SQL::Types::PG::Line.new(2.3, 4.9, 3.1415) }
     let(:dns) { IPAddr.new('8.8.8.8') }
+    let(:mapping) { Hash['hot' => 'cold'] }
+    let(:circle) { ROM::SQL::Types::PG::Circle.new(point, 1.0) }
+    let(:lseg) { ROM::SQL::Types::PG::LineSegment.new(point, point_2) }
+    let(:box_corrected) { ROM::SQL::Types::PG::Box.new(point_2, point) }
+    let(:box) do
+      upper_left = ROM::SQL::Types::PG::Point.new(point.x, point_2.y)
+      lower_right = ROM::SQL::Types::PG::Point.new(point_2.x, point.y)
+
+      ROM::SQL::Types::PG::Box.new(upper_left, lower_right)
+    end
+    let(:polygon) { ROM::SQL::Types::PG::Polygon[[point, point_2]] }
+    let(:closed_path) { ROM::SQL::Types::PG::Path.new([point, point_2], :closed) }
+    let(:open_path) { ROM::SQL::Types::PG::Path.new([point, point_2], :open) }
 
     let(:relation) { container.relations[:test_bidirectional] }
     let(:create) { commands[:test_bidirectional].create }
 
-    it 'writes and reads data' do
-      inserted = create.call(id: 1, center: point, ip: dns)
-      expect(inserted).to eql(id: 1, center: point, ip: dns)
+    it 'writes and reads data & corrects data' do
+      # Box coordinates are reordered if necessary
+      inserted = create.call(
+        id: 1, center: point, ip: dns, mapping: mapping,
+        line: line, circle: circle, lseg: lseg, box: box,
+        polygon: polygon, closed_path: closed_path, open_path: open_path
+      )
+      expect(inserted).to eql(
+        id: 1, center: point, ip: dns, mapping: mapping,
+        line: line, circle: circle, lseg: lseg, box: box_corrected,
+        polygon: polygon, closed_path: closed_path, open_path: open_path
+      )
       expect(relation.to_a).to eql([inserted])
     end
   end

data/spec/spec_helper.rb

@@ -16,7 +16,8 @@ require 'tempfile'
 
 begin
   require 'byebug'
-rescue LoadError # rubocop:disable Lint/HandleExceptions
+rescue LoadError
+  require 'pry'
 end
 
 LOGGER = Logger.new(File.open('./log/test.log', 'a'))
@@ -40,11 +41,14 @@ PG_LTE_95 = ENV.fetch('PG_LTE_95', 'true') == 'true'
 
 SPEC_ROOT = root = Pathname(__FILE__).dirname
 
-# Redirect inferrer warnings to a log file
-$stderr.reopen(SPEC_ROOT.join('../log/warnings.log'), 'w')
-
 TMP_PATH = root.join('../tmp')
 
+class ROM::SQL::Schema::Inferrer
+  def self.on_error(*)
+    # quiet in specs
+  end
+end
+
 Dir[root.join('shared/**/*')].each { |f| require f }
 Dir[root.join('support/**/*')].each { |f| require f }
 

data/spec/unit/gateway_spec.rb

@@ -50,7 +50,7 @@ RSpec.describe ROM::SQL::Gateway, :postgres do
       extensions = [:pg_array, :pg_array_ops]
       connection = Sequel.connect uri
 
-      expect(connection).to receive(:extension).with(:pg_array, :pg_json, :pg_enum, :pg_array_ops)
+      expect(connection).to receive(:extension).with(:pg_array, :pg_json, :pg_enum, :pg_hstore, :pg_array_ops)
       expect(connection).to receive(:extension).with(:freeze_datasets) unless RUBY_ENGINE == 'rbx'
 
       ROM::SQL::Gateway.new(connection, extensions: extensions)

data/spec/unit/plugin/timestamp_spec.rb

@@ -65,13 +65,17 @@ RSpec.describe 'Plugin / Timestamp' do
       expect(updated[:updated_at]).not_to eq initial[:updated_at]
     end
 
-    it "allows overriding timestamps" do
+    it "allows overriding timestamps" do |ex|
       tomorrow = (Time.now + (60 * 60 * 24))
 
       container.command(:notes).create.call(text: "testing")
       updated = container.command(:notes).update.call(text: "updated test", updated_at: tomorrow).first
 
-      expect(updated[:updated_at].iso8601).to eq tomorrow.iso8601
+      if jruby? && sqlite?(ex)
+        expect(updated[:updated_at]).to eql(tomorrow.strftime('%Y-%m-%d %H:%M:%S.%6N'))
+      else
+        expect(updated[:updated_at].iso8601).to eql(tomorrow.iso8601)
+      end
     end
   end
 end

data/spec/unit/relation/by_pk_spec.rb

@@ -25,5 +25,30 @@ RSpec.describe ROM::Relation, '#by_pk' do
         expect(relation.by_pk(1, 1).to_a).to eql([{ tag_id: 1, task_id: 1 }])
       end
     end
+
+    context 'without PK' do
+      subject(:relation) { relations[:people] }
+
+      before do
+        conn.drop_table?(:people)
+
+        conn.create_table(:people) do
+          column :name, String
+        end
+
+        conf.relation(:people) do
+          schema do
+            attribute :name, ROM::SQL::Types::String
+          end
+        end
+      end
+
+      it 'raises a meaningful exception' do
+        expect { relation.by_pk(1) }.to \
+          raise_error(
+            ROM::SQL::MissingPrimaryKeyError,
+            'Missing primary key for :people')
+      end
+    end
   end
 end

data/spec/unit/relation/where_spec.rb

@@ -24,5 +24,33 @@ RSpec.describe ROM::Relation, '#where' do
     it 'restricts relation using canonical attributes' do
       expect(relation.rename(id: :user_id).where { id > 3 }.to_a).to be_empty
     end
+
+    it 'restricts with or condition' do
+      expect(relation.where { id.is(1) | id.is(2) }.to_a).
+        to eql([{ id: 1, title: "Joe's task" }, { id: 2, title: "Jane's task" }])
+    end
+
+    it 'restricts with a range condition' do
+      expect(relation.where { id.in(-1...2) }.to_a).
+        to eql([{ id: 1, title: "Joe's task" }])
+
+      expect(relation.where { id.in(0...3) }.to_a).
+        to eql([{ id: 1, title: "Joe's task" }, { id: 2, title: "Jane's task" }])
+    end
+
+    it 'restricts with an inclusive range' do
+      expect(relation.where { id.in(0..2) }.to_a).
+        to eql([{ id: 1, title: "Joe's task" }, { id: 2, title: "Jane's task" }])
+    end
+
+    it 'restricts with an ordinary enum' do
+      expect(relation.where { id.in(2, 3) }.to_a).
+        to eql([{ id: 2, title: "Jane's task" }])
+    end
+
+    it 'restricts with enum using self syntax' do
+      expect(relation.where(relation[:id].in(2, 3)).to_a).
+        to eql([{ id: 2, title: "Jane's task" }])
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rom-sql
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Piotr Solnica
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-29 00:00:00.000000000 Z
+date: 2017-02-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.42'
+        version: '4.43'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.42'
+        version: '4.43'
 - !ruby/object:Gem::Dependency
   name: dry-equalizer
   requirement: !ruby/object:Gem::Requirement
@@ -320,7 +320,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: SQL databases support for ROM