rom-sql 1.2.2 → 1.3.0

data/lib/rom/sql/gateway.rb

@@ -17,12 +17,6 @@ module ROM
       include Dry::Core::Constants
       include Migration
 
-      class << self
-        # FIXME: get rid of this and figure out a nicer way of handling migration DSL
-        # we want to have global access ONLY when running migration tasks
-        attr_accessor :instance
-      end
-
       adapter :sql
 
       CONNECTION_EXTENSIONS = {
@@ -48,7 +42,7 @@ module ROM
       #   @example
       #     ROM.container(:sql, 'postgres://localhost/db_name')
       #
-      #   @param [Sequel::Database] connection a connection instance
+      #   @param [String,Symbol] uri connection URI
       #
       # @overload initialize(uri, options)
       #   Connects to a database via URI and options
@@ -96,8 +90,6 @@ module ROM
         @options = options
 
         super
-
-        self.class.instance = self
       end
 
       # Disconnect from the gateway's database

data/lib/rom/sql/migration.rb

@@ -2,41 +2,92 @@ require 'rom/sql/migration/migrator'
 
 module ROM
   module SQL
-    # Trap for the migration runner. To create a migration
-    # on a specific gateway, use ROM::SQL::Gateway#migration
-    #
-    # @example
-    #   rom = ROM.container(
-    #     default: [:sql, 'sqlite::memory'],
-    #     other: [:sql, 'postgres://localhost/test']
-    #   )
-    #
-    #   # default gateway migrations
-    #   ROM::SQL.migration do
-    #     change do
-    #       create_table(:users) do
-    #         primary_key :id
-    #         String :name
-    #       end
-    #     end
-    #   end
-    #
-    #   # other gateway migrations
-    #   rom.gateways[:other].migration do
-    #     change do
-    #       create_table(:users) do
-    #         primary_key :id
-    #         String :name
-    #       end
-    #     end
-    #   end
-    #
-    # @api public
-    def self.migration(&block)
-      ROM::SQL::Gateway.instance.migration(&block)
+    class << self
+      # Trap for the migration runner. By default migrations are
+      # bound to the gateway you're using to run them.
+      # You also can explicitly pass a configuration object and a gateway name
+      # but this normally won't be not required.
+      #
+      # @example
+      #   # Ordinary migration
+      #   ROM::SQL.migration do
+      #     change do
+      #       create_table(:users) do
+      #         primary_key :id
+      #         String :name
+      #       end
+      #     end
+      #   end
+      #
+      # @example
+      #   # Providing a config
+      #   rom = ROM::Configuration.new(
+      #     default: [:sql, 'sqlite::memory'],
+      #     other: [:sql, 'postgres://localhost/test']
+      #   )
+      #
+      #   # default gateway migrations
+      #   ROM::SQL.migration(rom) do
+      #     change do
+      #       create_table(:users) do
+      #         primary_key :id
+      #         String :name
+      #       end
+      #     end
+      #   end
+      #
+      #   # other gateway migrations
+      #   ROM::SQL.migration(rom, :other) do
+      #     change do
+      #       create_table(:users) do
+      #         primary_key :id
+      #         String :name
+      #       end
+      #     end
+      #   end
+      #
+      # @param [ROM::Container] container The container instance used for accessing gateways
+      # @param [Symbol] gateway The gateway name, :default by default
+      #
+      # @api public
+      def migration(*args, &block)
+        if args.any?
+          container, gateway, * = args
+          with_gateway(container.gateways[gateway || :default]) { migration(&block) }
+        else
+          current_gateway.migration(&block)
+        end
+      end
+
+      # @api private
+      attr_accessor :current_gateway
+
+      # This method is used on loading migrations.
+      # Temporally sets the global "current_gateway", you shouln't access it.
+      #
+      # @api private
+      def with_gateway(gateway)
+        current = @current_gateway
+        @current_gateway = gateway
+
+        yield
+      ensure
+        @current_gateway = current
+      end
     end
 
+    @current_gateway = nil
+
     module Migration
+      # FIXME: remove in 2.0
+      #
+      # @api private
+      def self.included(base)
+        super
+
+        base.singleton_class.send(:attr_accessor, :instance)
+      end
+
       Sequel.extension :migration
 
       # @!attribute [r] migrator
@@ -46,6 +97,8 @@ module ROM
       # @api private
       def initialize(uri, options = EMPTY_HASH)
         @migrator = options.fetch(:migrator) { Migrator.new(connection) }
+
+        self.class.instance ||= self
       end
 
       # Check if there are any pending migrations
@@ -54,7 +107,9 @@ module ROM
       #
       # @api public
       def pending_migrations?
-        migrator.pending?
+        ROM::SQL.with_gateway(self) {
+          migrator.pending?
+        }
       end
 
       # Migration DSL
@@ -76,7 +131,9 @@ module ROM
       #
       # @api public
       def run_migrations(options = {})
-        migrator.run(options)
+        ROM::SQL.with_gateway(self) {
+          migrator.run(options)
+        }
       end
     end
   end

data/lib/rom/sql/plugin/associates.rb

@@ -142,25 +142,21 @@ module ROM
               when Association::ManyToMany
                 result_type = tuples.is_a?(Array) ? :many : :one
 
-                join_tuples = assoc.associate(__registry__, tuples, parent)
-                join_relation = assoc.join_relation(__registry__)
-                join_relation.multi_insert(join_tuples)
+                assoc.persist(__registry__, tuples, parent)
 
-                pk, fk = __registry__[assoc.target]
-                  .associations[assoc.source]
-                  .combine_keys(__registry__).to_a.flatten
+                pk, fk = assoc.parent_combine_keys(__registry__)
 
                 case parent
                 when Array
                   parent.map do |p|
-                    tuples.map { |tuple| tuple.merge(fk => p[pk]) }
+                    tuples.map { |tuple| Hash(tuple).merge(fk => p[pk]) }
                   end.flatten(1)
                 else
                   tuples.map { |tuple| Hash(tuple).update(fk => parent[pk]) }
                 end
               when Association
                 with_input_tuples(tuples).map { |tuple|
-                  assoc.associate(relation.__registry__, tuple, parent)
+                  assoc.associate(__registry__, tuple, parent)
                 }
               end
 

data/lib/rom/sql/relation.rb

@@ -78,7 +78,7 @@ module ROM
           #   @api public
           class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def by_pk(#{schema.primary_key.map(&:name).join(', ')})
-              where(#{schema.primary_key.map { |attr| "schema[:#{attr.name}] => #{attr.name}" }.join(', ')})
+              where(#{schema.primary_key.map { |attr| "self.class.schema[:#{attr.name}] => #{attr.name}" }.join(', ')})
             end
           RUBY
         else
@@ -90,14 +90,16 @@ module ROM
           #   @return [SQL::Relation]
           #
           #   @api public
-          define_method(:by_pk) do |pk|
-            if primary_key.nil?
-              raise MissingPrimaryKeyError.new("Missing primary key for "\
-                                               ":#{ schema.name }")
-            else
-              where(schema[primary_key] => pk)
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def by_pk(pk)
+              if primary_key.nil?
+                raise MissingPrimaryKeyError.new(
+                  "Missing primary key for :\#{schema.name}"
+                )
+              end
+              where(self.class.schema[self.class.schema.primary_key_name].qualified => pk)
             end
-          end
+          RUBY
         end
       end
 

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

@@ -757,6 +757,25 @@ module ROM
           new(dataset.__send__(__method__, relation.dataset, options, &block))
         end
 
+        # Checks whether a relation has at least one tuple
+        #
+        #  @example
+        #    users.where(name: 'John').exist? # => true
+        #
+        #    users.exist?(name: 'Klaus') # => false
+        #
+        #    users.exist? { name.is('klaus') } # => false
+        #
+        #   @param [Array<Object>] args Optional restrictions to filter the relation
+        #   @yield An optional block filters the relation using `where DSL`
+        #
+        # @return [TrueClass, FalseClass]
+        #
+        # @api public
+        def exist?(*args, &block)
+          !where(*args, &block).limit(1).count.zero?
+        end
+
         # Return if a restricted relation has 0 tuples
         #
         # @example
@@ -766,13 +785,13 @@ module ROM
         #
         #   users.unique?(email: 'jane@doe.org') # false
         #
-        # @param [Hash] criteria The condition hash for  WHERE clause
+        # @param [Hash] criteria The condition hash for WHERE clause
         #
         # @return [TrueClass, FalseClass]
         #
         # @api public
         def unique?(criteria)
-          where(criteria).count.zero?
+          !exist?(criteria)
         end
 
         # Return a new relation from a raw SQL string

data/lib/rom/sql/schema.rb

@@ -105,7 +105,7 @@ module ROM
       end
 
       # @api private
-      def finalize!(*)
+      def finalize!(*args)
         super do
           initialize_primary_key_names
         end

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

@@ -104,11 +104,13 @@ module ROM
           self.class.numeric_pk_type.meta(primary_key: true)
         end
 
-        def map_type(ruby_type, db_type, **_kw)
+        def map_type(ruby_type, db_type, **kw)
           type = self.class.ruby_type_mapping[ruby_type]
 
           if db_type.is_a?(String) && db_type.include?('numeric') || db_type.include?('decimal')
             map_decimal_type(db_type)
+          elsif db_type.is_a?(String) && db_type.include?('char') && kw[:max_length]
+            type.meta(limit: kw[:max_length])
           else
             type
           end

data/lib/rom/sql/tasks/migration_tasks.rake

@@ -4,6 +4,8 @@ require "fileutils"
 module ROM
   module SQL
     module RakeSupport
+      MissingEnv = Class.new(StandardError)
+
       class << self
         def run_migrations(options = {})
           gateway.run_migrations(options)
@@ -13,12 +15,26 @@ module ROM
           gateway.migrator.create_file(*args)
         end
 
+        # Global environment used for running migrations. You normally
+        # set in the `db:setup` task with `ROM::SQL::RakeSupport.env = ROM.container(...)`
+        # or something similar.
+        #
+        # @api public
+        attr_accessor :env
+
         private
 
         def gateway
-          ROM::SQL::Gateway.instance
+          if env.nil?
+            Gateway.instance ||
+              raise(MissingEnv, "Set up a configutation with ROM::SQL::RakeSupport.env= in the db:setup task")
+          else
+            env.gateways[:default]
+          end
         end
       end
+
+      @env = nil
     end
   end
 end

data/lib/rom/sql/version.rb

@@ -1,5 +1,5 @@
 module ROM
   module SQL
-    VERSION = '1.2.2'.freeze
+    VERSION = '1.3.0'.freeze
   end
 end

data/rom-sql.gemspec

@@ -19,9 +19,9 @@ Gem::Specification.new do |spec|
 
   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-types', '~> 0.10', '>= 0.10.2'
   spec.add_runtime_dependency 'dry-core', '~> 0.2', '>= 0.2.3'
-  spec.add_runtime_dependency 'rom', '~> 3.2'
+  spec.add_runtime_dependency 'rom', '~> 3.2', '>= 3.2.1'
 
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake', '~> 10.0'

data/spec/extensions/postgres/attribute_spec.rb

@@ -0,0 +1,128 @@
+RSpec.describe 'ROM::SQL::Attribute', :postgres do
+  include_context 'database setup'
+
+  jsonb_hash = -> v { Sequel::Postgres::JSONBHash.new(v) }
+  jsonb_array = -> v { Sequel::Postgres::JSONBArray.new(v) }
+
+  before do
+    conn.drop_table?(:pg_people)
+    conn.drop_table?(:people)
+
+    conf.relation(:people) do
+      schema(:pg_people, infer: true)
+    end
+  end
+
+  let(:people) { relations[:people] }
+  let(:create_person) { commands[:people].create }
+
+  describe 'using arrays' do
+    before do
+      conn.create_table :pg_people do
+        primary_key :id
+        String :name
+        column :fields, :jsonb
+      end
+
+      conf.commands(:people) do
+        define(:create)
+        define(:update)
+      end
+
+      create_person.(name: 'John Doe', fields: [{ name: 'age', value: '30' },
+                                                { name: 'height', value: 180 }])
+      create_person.(name: 'Jade Doe', fields: [{ name: 'age', value: '25' }])
+    end
+
+    it 'allows to query jsonb by inclusion' do
+      expect(people.select(:name).where { fields.contain([value: '30']) }.one).
+        to eql(name: 'John Doe')
+    end
+
+    it 'cat project result of contains' do
+      expect(people.select { fields.contain([value: '30']).as(:contains) }.to_a).
+        to eql([{ contains: true }, { contains: false }])
+    end
+
+    it 'fetches data from jsonb array by index' do
+      expect(people.select { [fields.get(1).as(:field)] }.where(name: 'John Doe').one).
+        to eql(field: jsonb_hash['name' => 'height', 'value' => 180])
+    end
+
+    it 'fetches data from jsonb array' do
+      expect(people.select { fields.get(1).get_text('value').as(:height) }.where(name: 'John Doe').one).
+        to eql(height: '180')
+    end
+
+    it 'fetches data with path' do
+      expect(people.select(people[:fields].get_text('1', 'value').as(:height)).to_a).
+        to eql([{ height: '180' }, { height: nil }])
+    end
+
+    it 'deletes key from result' do
+      expect(people.select { fields.delete(0).as(:result) }.limit(1).one).
+        to eq(result: jsonb_array[['name' => 'height', 'value' => 180]])
+    end
+
+    it 'deletes by path' do
+      expect(people.select { fields.delete('0', 'name').delete('1', 'name').as(:result) }.limit(1).one).
+        to eq(result: jsonb_array[[{ 'value' => '30' }, { 'value' => 180 }]])
+    end
+
+    it 'concatenates JSON values' do
+      expect(people.select { (fields + [name: 'height', value: 165]).as(:result) }.by_pk(2).one).
+        to eq(result: jsonb_array[[{ 'name' => 'age', 'value' => '25' },
+                                   { 'name' => 'height', 'value' => 165 }]])
+    end
+  end
+
+  describe 'using map' do
+    before do
+      conn.create_table :pg_people do
+        primary_key :id
+        String :name
+        column :data, :jsonb
+      end
+
+      conf.commands(:people) do
+        define(:create)
+        define(:update)
+      end
+
+      create_person.(name: 'John Doe', data: { age: 30, height: 180 })
+      create_person.(name: 'Jade Doe', data: { age: 25 })
+    end
+
+    it 'queries data by inclusion' do
+      expect(people.select(:name).where { data.contain(age: 30) }.one).
+        to eql(name: 'John Doe')
+    end
+
+    it 'queries data by left inclusion' do
+      expect(people.select(:name).where { data.contained_by(age: 25, foo: 'bar') }.one).
+        to eql(name: 'Jade Doe')
+    end
+
+    it 'checks for key presence' do
+      expect(people.select { data.has_key('height').as(:there) }.to_a).
+        to eql([{ there: true }, { there: false }])
+
+      expect(people.select(:name).where { data.has_any_key('height', 'width') }.one).
+        to eql(name: 'John Doe')
+
+      expect(people.select(:name).where { data.has_all_keys('height', 'age') }.one).
+        to eql(name: 'John Doe')
+    end
+
+    it 'concatenates JSON values' do
+      expect(people.select { data.merge(height: 165).as(:result) }.by_pk(2).one).
+        to eql(result: jsonb_hash['age' => 25, 'height' => 165])
+    end
+
+    it 'deletes key from result' do
+      expect(people.select { data.delete('height').as(:result) }.to_a).
+        to eql([{ result: jsonb_hash['age' => 30] },
+                { result: jsonb_hash['age' => 25] }])
+    end
+  end
+end