rom-sql 0.8.0 → 0.9.0

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

@@ -0,0 +1,65 @@
+require 'dry-types'
+require 'sequel'
+
+Sequel.extension(*%i(pg_array pg_array_ops pg_json pg_json_ops))
+
+module ROM
+  module SQL
+    module Types
+      module PG
+        # UUID
+
+        UUID = Types::String
+
+        # Array
+
+        Array = Dry::Types::Definition
+                .new(Sequel::Postgres::PGArray)
+
+        def self.Array(db_type)
+          Array.constructor(-> (v) { Sequel.pg_array(v, db_type) }).meta(type: db_type)
+        end
+
+        # JSON
+
+        JSONArray = Dry::Types::Definition
+                    .new(Sequel::Postgres::JSONArray)
+                    .constructor(Sequel.method(:pg_json))
+
+        JSONHash = Dry::Types::Definition
+                   .new(Sequel::Postgres::JSONHash)
+                   .constructor(Sequel.method(:pg_json))
+
+        JSONOp = Dry::Types::Definition
+                 .new(Sequel::Postgres::JSONOp)
+                 .constructor(Sequel.method(:pg_json))
+
+        JSON = JSONArray | JSONHash | JSONOp
+
+        # JSONB
+
+        JSONBArray = Dry::Types::Definition
+                     .new(Sequel::Postgres::JSONBArray)
+                     .constructor(Sequel.method(:pg_jsonb))
+
+        JSONBHash = Dry::Types::Definition
+                    .new(Sequel::Postgres::JSONBHash)
+                    .constructor(Sequel.method(:pg_jsonb))
+
+        JSONBOp = Dry::Types::Definition
+                  .new(Sequel::Postgres::JSONBOp)
+                  .constructor(Sequel.method(:pg_jsonb))
+
+        JSONB = JSONBArray | JSONBHash | JSONBOp
+
+        Bytea = Dry::Types::Definition
+                .new(Sequel::SQL::Blob)
+                .constructor(Sequel::SQL::Blob.method(:new))
+
+        # MONEY
+
+        Money = Types::Decimal
+      end
+    end
+  end
+end

data/lib/rom/sql/gateway.rb

@@ -23,6 +23,10 @@ module ROM
         attr_accessor :instance
       end
 
+      CONNECTION_EXTENSIONS = {
+        postgres: %i(pg_array pg_json)
+      }.freeze
+
       # Return optionally configured logger
       #
       # @return [Object] logger
@@ -56,7 +60,7 @@ module ROM
         conn_options = options.reject { |k, _| repo_options.include?(k) }
 
         @connection = connect(uri, conn_options)
-        add_extensions(Array(options[:extensions])) if options[:extensions]
+        load_extensions(Array(options[:extensions]))
 
         super(uri, options.reject { |k, _| conn_options.keys.include?(k) })
 
@@ -177,11 +181,18 @@ module ROM
         end
       end
 
-      # Add extensions to the database connection
+      # Load database-specific extensions
       #
       # @api private
-      def add_extensions(exts)
-        connection.extension(*exts)
+      def load_extensions(exts)
+        db_type = connection.database_type.to_sym
+
+        if ROM::SQL.available_extension?(db_type)
+          ROM::SQL.load_extensions(db_type)
+        end
+
+        extensions = (CONNECTION_EXTENSIONS.fetch(db_type) { [] } + exts).uniq
+        connection.extension(*extensions)
       end
     end
   end

data/lib/rom/sql/relation.rb

@@ -42,14 +42,18 @@ module ROM
 
         klass.class_eval do
           schema_dsl SQL::Schema::DSL
-          schema_inferrer ROM::SQL::Schema::Inferrer
+          schema_inferrer -> (dataset, gateway) do
+            inferrer_for_db = ROM::SQL::Schema::Inferrer.get(gateway.connection.database_type.to_sym)
+            inferrer_for_db.new.call(dataset, gateway)
+          end
 
           dataset do
             table = opts[:from].first
 
             if db.table_exists?(table)
               pk_header = klass.primary_key_header(db, table)
-              select(*columns).order(*pk_header.qualified)
+              col_names = klass.schema ? klass.schema.attributes.keys : columns
+              select(*col_names).order(*pk_header.qualified)
             else
               self
             end

data/lib/rom/sql/relation/reading.rb

@@ -305,6 +305,24 @@ module ROM
           __new__(dataset.__send__(__method__, *args, &block))
         end
 
+        # Restrict a relation to match grouping criteria
+        #
+        # @example
+        #   users.with_task_count.having( task_count: 2 )
+        #
+        #   users.with_task_count.having { task_count > 3 }
+        #
+        # @param [Hash] *args An optional hash with conditions for HAVING clause
+        #
+        # @return [Relation]
+        #
+        # @see http://sequel.jeremyevans.net/rdoc/files/doc/dataset_filtering_rdoc.html
+        #
+        # @api public
+        def having(*args, &block)
+          __new__(dataset.__send__(__method__, *args, &block))
+        end
+
         # Inverts the current WHERE and HAVING clauses. If there is neither a
         # WHERE or HAVING clause, adds a WHERE clause that is always false.
         #

data/lib/rom/sql/schema/dsl.rb

@@ -16,10 +16,13 @@ module ROM
         end
 
         def opts
-          opts = {}
-          opts[:associations] = associations_dsl.call if associations_dsl
-          opts[:inferrer] = inferrer.new(self) if inferrer
-          opts
+          opts = { inferrer: inferrer }
+
+          if associations_dsl
+            { **opts, associations: associations_dsl.call }
+          else
+            opts
+          end
         end
       end
     end

data/lib/rom/sql/schema/inferrer.rb

@@ -1,27 +1,39 @@
 module ROM
   module SQL
     class Schema < ROM::Schema
+      # @api private
       class Inferrer
         extend ClassMacros
 
-        defines :type_mapping, :pk_type
+        defines :ruby_type_mapping, :numeric_pk_type, :db_type, :db_registry
 
-        type_mapping(
-          integer: Types::Strict::Int,
-          string: Types::Strict::String,
-          date: Types::Strict::Date,
-          datetime: Types::Strict::Time,
-          boolean: Types::Strict::Bool,
-          decimal: Types::Strict::Decimal,
-          blob: Types::Strict::String
+        ruby_type_mapping(
+          integer: Types::Int,
+          string: Types::String,
+          date: Types::Date,
+          datetime: Types::Time,
+          boolean: Types::Bool,
+          decimal: Types::Decimal,
+          float: Types::Float,
+          blob: Types::Blob
         ).freeze
 
-        pk_type Types::Serial
+        numeric_pk_type Types::Serial
 
-        attr_reader :dsl
+        db_registry Hash.new(self)
 
-        def initialize(dsl)
-          @dsl = dsl
+        def self.inherited(klass)
+          super
+
+          Inferrer.db_registry[klass.db_type] = klass unless klass.name.nil?
+        end
+
+        def self.[](type)
+          Class.new(self) { db_type(type) }
+        end
+
+        def self.get(type)
+          db_registry[type]
         end
 
         # @api private
@@ -29,33 +41,35 @@ module ROM
           columns = gateway.connection.schema(dataset)
           fks = fks_for(gateway, dataset)
 
-          columns.each do |(name, definition)|
-            dsl.attribute name, build_type(definition.merge(foreign_key: fks[name]))
+          columns.each_with_object({}) do |(name, definition), attrs|
+            type = build_type(definition.merge(foreign_key: fks[name]))
+            attrs[name] = type.meta(name: name)
           end
-
-          pks = columns
-            .map { |(name, definition)| name if definition.fetch(:primary_key) }
-            .compact
-
-          dsl.primary_key(*pks) if pks.any?
-
-          dsl.attributes
         end
 
         private
 
-        # @api private
-        def build_type(primary_key: , type: , allow_null: , foreign_key: , **rest)
+        def build_type(primary_key:, db_type:, type:, allow_null:, foreign_key:, **rest)
           if primary_key
-            self.class.pk_type
+            map_pk_type(type, db_type)
           else
-            type = self.class.type_mapping.fetch(type)
-            type = type.optional if allow_null
-            type = type.meta(foreign_key: true, relation: foreign_key) if foreign_key
-            type
+            mapped_type = map_type(type, db_type)
+            mapped_type = mapped_type.optional if allow_null
+            mapped_type = mapped_type.meta(foreign_key: true, relation: foreign_key) if foreign_key
+            mapped_type
           end
         end
 
+        def map_pk_type(_ruby_type, _db_type)
+          self.class.numeric_pk_type.meta(primary_key: true)
+        end
+
+        def map_type(ruby_type, db_type)
+          self.class.ruby_type_mapping.fetch(ruby_type) {
+            raise UnknownDBTypeError, "Cannot find corresponding type for #{ruby_type || db_type}"
+          }
+        end
+
         # @api private
         def fks_for(gateway, dataset)
           gateway.connection.foreign_key_list(dataset).each_with_object({}) do |definition, fks|
@@ -65,7 +79,6 @@ module ROM
           end
         end
 
-        # @api private
         def build_fk(columns: , table: , **rest)
           if columns.size == 1
             [columns[0], table]

data/lib/rom/sql/types.rb

@@ -5,7 +5,11 @@ module ROM
     module Types
       include ROM::Types
 
-      Serial = Strict::Int.constrained(gt: 0).meta(primary_key: true)
+      Serial = Int.constrained(gt: 0).meta(primary_key: true)
+
+      Blob = Dry::Types::Definition
+        .new(Sequel::SQL::Blob)
+        .constructor(Sequel::SQL::Blob.method(:new))
     end
   end
 end

data/lib/rom/sql/version.rb

@@ -1,5 +1,5 @@
 module ROM
   module SQL
-    VERSION = '0.8.0'.freeze
+    VERSION = '0.9.0'.freeze
   end
 end

data/rom-sql.gemspec

@@ -4,26 +4,27 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'rom/sql/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "rom-sql"
+  spec.name          = 'rom-sql'
   spec.version       = ROM::SQL::VERSION.dup
-  spec.authors       = ["Piotr Solnica"]
-  spec.email         = ["piotr.solnica@gmail.com"]
+  spec.authors       = ['Piotr Solnica']
+  spec.email         = ['piotr.solnica@gmail.com']
   spec.summary       = 'SQL databases support for ROM'
   spec.description   = spec.summary
-  spec.homepage      = "http://rom-rb.org"
-  spec.license       = "MIT"
+  spec.homepage      = 'http://rom-rb.org'
+  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.require_paths = ['lib']
 
-  spec.add_runtime_dependency "sequel", "~> 4.25"
-  spec.add_runtime_dependency "dry-equalizer", "~> 0.2"
-  spec.add_runtime_dependency "dry-types", "~> 0.8"
-  spec.add_runtime_dependency "rom", "~> 2.0"
-  spec.add_runtime_dependency "rom-support", "~> 2.0"
+  spec.add_runtime_dependency 'sequel', '~> 4.25'
+  spec.add_runtime_dependency 'dry-equalizer', '~> 0.2'
+  spec.add_runtime_dependency 'dry-types', '~> 0.9'
+  spec.add_runtime_dependency 'dry-core', '~> 0.2'
+  spec.add_runtime_dependency 'rom', '~> 2.0'
+  spec.add_runtime_dependency 'rom-support', '~> 2.0'
 
-  spec.add_development_dependency "bundler"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake', '~> 10.0'
 end

data/spec/extensions/postgres/inferrer_spec.rb

@@ -0,0 +1,40 @@
+RSpec.describe 'ROM::SQL::Schema::PostgresInferrer', :postgres do
+  include_context 'database setup'
+
+  before do
+    conn.drop_table?(:test_inferrence)
+
+    conn.create_table :test_inferrence do
+      primary_key :id, :uuid
+      Json :json_data
+      Jsonb :jsonb_data
+      Decimal :money, null: false
+      column :tags, "text[]"
+      column :tag_ids, "bigint[]"
+    end
+  end
+
+  let(:dataset) { :test_inferrence }
+
+  let(:schema) { container.relations[dataset].schema }
+
+  context 'inferring db-specific attributes' do
+    before do
+      dataset = self.dataset
+      conf.relation(dataset) do
+        schema(dataset, infer: true)
+      end
+    end
+
+    it 'can infer attributes for dataset' do
+      expect(schema.attributes).to eql(
+        id: ROM::SQL::Types::PG::UUID.meta(name: :id, primary_key: true),
+        json_data: ROM::SQL::Types::PG::JSON.optional.meta(name: :json_data),
+        jsonb_data: ROM::SQL::Types::PG::JSONB.optional.meta(name: :jsonb_data),
+        money: ROM::SQL::Types::Decimal.meta(name: :money),
+        tags: ROM::SQL::Types::PG::Array('text').optional.meta(name: :tags),
+        tag_ids: ROM::SQL::Types::PG::Array('biging').optional.meta(name: :tag_ids)
+      )
+    end
+  end
+end

data/spec/extensions/postgres/integration_spec.rb

@@ -0,0 +1,38 @@
+RSpec.describe 'PostgreSQL extension', :postgres do
+  include_context 'database setup'
+
+  before do
+    conn.drop_table?(:pg_people)
+    conn.drop_table?(:people)
+
+    conn.create_table :pg_people do
+      primary_key :id
+      String :name
+      column :tags, "text[]"
+    end
+
+    conf.relation(:people) do
+      schema(:pg_people, infer: true)
+    end
+
+    conf.commands(:people) do
+      define(:create)
+    end
+  end
+
+  let(:people_relation) { relations[:people] }
+
+  describe 'using arrays' do
+    let(:people) { commands[:people] }
+
+    it 'inserts array values' do
+      people.create.call(name: 'John Doe', tags: ['foo'])
+      expect(people_relation.to_a).to eq([id: 1, name: 'John Doe', tags: ['foo']])
+    end
+
+    it 'inserts empty arrays' do
+      people.create.call(name: 'John Doe', tags: [])
+      expect(people_relation.to_a).to eq([id: 1, name: 'John Doe', tags: []])
+    end
+  end
+end

data/spec/extensions/postgres/types_spec.rb

@@ -0,0 +1,115 @@
+RSpec.describe 'ROM::SQL::Types' do
+  describe 'ROM::SQL::Types::PG::JSON' do
+    it 'coerces to pg json hash' do
+      input = { foo: 'bar' }
+
+      expect(ROM::SQL::Types::PG::JSON[input]).to eql(Sequel.pg_json(input))
+    end
+
+    it 'coerces to pg json array' do
+      input = [1, 2, 3]
+      output = ROM::SQL::Types::PG::JSON[input]
+
+      expect(output).to be_instance_of(Sequel::Postgres::JSONArray)
+      expect(output.to_a).to eql(input)
+    end
+  end
+
+  describe 'ROM::SQL::Types::PG::Bytea' do
+    it 'coerces strings to Sequel::SQL::Blob' do
+      input = 'sutin'
+      output = ROM::SQL::Types::PG::Bytea[input]
+
+      expect(output).to be_instance_of(Sequel::SQL::Blob)
+      expect(output).to eql('sutin')
+    end
+  end
+
+  describe ROM::SQL::Types::PG::UUID do
+    it 'coerces strings to UUID' do
+      input  = SecureRandom.uuid
+      output = described_class[input]
+
+      expect(output).to be_instance_of(String)
+    end
+  end
+
+  describe ROM::SQL::Types::PG::Array do
+    it 'coerces to pg array' do
+      input  = [1, 2, 3]
+      output = ROM::SQL::Types::PG::Array('integer')[input]
+
+      expect(output).to be_instance_of(Sequel::Postgres::PGArray)
+      expect(output.to_a).to eql(input)
+    end
+
+    it 'accepts any other type of objects' do
+      input  = [nil, 1, 'sutin', :sutin, 1.0, {}].sample
+      output = ROM::SQL::Types::PG::Array('integer')[input]
+
+      expect(output).to be_instance_of(Sequel::Postgres::ArrayOp)
+      expect(output.value).to eql(input)
+    end
+  end
+
+  describe ROM::SQL::Types::PG::JSON do
+    it 'coerces to pg json hash' do
+      input  = { foo: 'bar' }
+      output = described_class[input]
+
+      expect(output).to be_instance_of(Sequel::Postgres::JSONHash)
+      expect(output).to eql(Sequel.pg_json(input))
+    end
+
+    it 'coerces to pg json array' do
+      input  = [1, 2, 3]
+      output = described_class[input]
+
+      expect(output).to be_instance_of(Sequel::Postgres::JSONArray)
+      expect(output.to_a).to eql(input)
+    end
+
+    it 'accepts any other type of objects' do
+      input  = [nil, 1, 'sutin', :sutin, 1.0].sample
+      output = described_class[input]
+
+      expect(output).to be_instance_of(Sequel::Postgres::JSONOp)
+      expect(output.value).to eql(input)
+    end
+  end
+
+  describe ROM::SQL::Types::PG::JSONB do
+    it 'coerces to pg jsonb hash' do
+      input  = { foo: 'bar' }
+      output = described_class[input]
+
+      expect(output).to be_instance_of(Sequel::Postgres::JSONBHash)
+      expect(output).to eql(Sequel.pg_jsonb(input))
+    end
+
+    it 'coerces to pg jsonb array' do
+      input  = [1, 2, 3]
+      output = described_class[input]
+
+      expect(output).to be_instance_of(Sequel::Postgres::JSONBArray)
+      expect(output.to_a).to eql(input)
+    end
+
+    it 'accepts any other type of objects' do
+      input  = [nil, 1, 'sutin', :sutin, 1.0].sample
+      output = described_class[input]
+
+      expect(output).to be_instance_of(Sequel::Postgres::JSONBOp)
+      expect(output.value).to eql(input)
+    end
+  end
+
+  describe ROM::SQL::Types::PG::Money do
+    it 'coerces to pg Money' do
+      input  = BigDecimal.new(1.0, 2)
+      output = described_class[input]
+
+      expect(output).to be_instance_of(BigDecimal)
+    end
+  end
+end