rom-sql 1.0.0.beta2 → 1.0.0.beta3

data/lib/rom/sql/relation.rb

@@ -3,6 +3,7 @@ require 'rom/sql/schema'
 
 require 'rom/sql/relation/reading'
 require 'rom/sql/relation/writing'
+require 'rom/sql/relation/sequel_api'
 
 require 'rom/plugins/relation/key_inference'
 require 'rom/plugins/relation/sql/auto_combine'
@@ -88,6 +89,23 @@ module ROM
 
       option :primary_key, reader: true, default: -> rel { rel.schema.primary_key_name }
 
+      # Return relation that will load associated tuples of this relation
+      #
+      # This method is useful for defining custom relation views for relation
+      # composition when you want to enhance default association query
+      #
+      # @example
+      #   assoc(:tasks).where(tasks[:title] => "Task One")
+      #
+      # @param [Symbol] name The association name
+      #
+      # @return [Relation]
+      #
+      # @api public
+      def assoc(name)
+        associations[name].(__registry__)
+      end
+
       # Return raw column names
       #
       # @return [Array<Symbol>]

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

@@ -558,10 +558,10 @@ module ROM
         private
 
         # @api private
-        def __join__(type, other, opts = EMPTY_HASH, &block)
+        def __join__(type, other, join_cond = EMPTY_HASH, opts = EMPTY_HASH, &block)
           case other
           when Symbol, Association::Name
-            new(dataset.__send__(type, other.to_sym, opts, &block))
+            new(dataset.__send__(type, other.to_sym, join_cond, opts, &block))
           when Relation
             __send__(type, other.name.dataset, join_keys(other))
           else

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

@@ -0,0 +1,119 @@
+module ROM
+  module SQL
+    # Query API for SQL::Relation
+    #
+    # @api public
+    module SequelAPI
+      # Select specific columns for select clause
+      #
+      # @example
+      #   users.select(:id, :name).first
+      #   # {:id => 1, :name => "Jane" }
+      #
+      # @return [Relation]
+      #
+      # @api public
+      def select(*args, &block)
+        new(dataset.__send__(__method__, *args, &block))
+      end
+
+      # Append specific columns to select clause
+      #
+      # @example
+      #   users.select(:id, :name).select_append(:email)
+      #   # {:id => 1, :name => "Jane", :email => "jane@doe.org"}
+      #
+      # @param [Array<Symbol>] *args A list with column names
+      #
+      # @return [Relation]
+      #
+      # @api public
+      def select_append(*args, &block)
+        new(dataset.__send__(__method__, *args, &block))
+      end
+
+      # Restrict a relation to match criteria
+      #
+      # If block is passed it'll be executed in the context of a condition
+      # builder object.
+      #
+      # @example
+      #   users.where(name: 'Jane')
+      #
+      #   users.where { age >= 18 }
+      #
+      # @param [Hash] *args An optional hash with conditions for WHERE clause
+      #
+      # @return [Relation]
+      #
+      # @see http://sequel.jeremyevans.net/rdoc/files/doc/dataset_filtering_rdoc.html
+      #
+      # @api public
+      def where(*args, &block)
+        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
+
+      # Set order for the relation
+      #
+      # @example
+      #   users.order(:name)
+      #
+      # @param [Array<Symbol>] *args A list with column names
+      #
+      # @return [Relation]
+      #
+      # @api public
+      def order(*args, &block)
+        new(dataset.__send__(__method__, *args, &block))
+      end
+
+      # Join with another relation using INNER JOIN
+      #
+      # @example
+      #   users.inner_join(:tasks, id: :user_id)
+      #
+      # @param [Symbol] relation name
+      # @param [Hash] join keys
+      #
+      # @return [Relation]
+      #
+      # @api public
+      def inner_join(*args, &block)
+        new(dataset.__send__(__method__, *args, &block))
+      end
+
+      # Join other relation using LEFT OUTER JOIN
+      #
+      # @example
+      #   users.left_join(:tasks, id: :user_id)
+      #
+      # @param [Symbol] relation name
+      # @param [Hash] join keys
+      #
+      # @return [Relation]
+      #
+      # @api public
+      def left_join(*args, &block)
+        new(dataset.__send__(__method__, *args, &block))
+      end
+    end
+  end
+end

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

@@ -26,6 +26,7 @@ module ROM
         db_registry Hash.new(self)
 
         CONSTRAINT_DB_TYPE = 'add_constraint'.freeze
+        DECIMAL_REGEX = /(?:decimal|numeric)\((\d+)(?:,\s*(\d+))?\)/.freeze
 
         def self.inherited(klass)
           super
@@ -72,9 +73,16 @@ module ROM
             mapped_type = map_type(type, db_type, rest)
 
             if mapped_type
+              read_type = mapped_type.meta[:read]
               mapped_type = mapped_type.optional if allow_null
               mapped_type = mapped_type.meta(foreign_key: true, target: foreign_key) if foreign_key
-              mapped_type
+              if read_type && allow_null
+                mapped_type.meta(read: read_type.optional)
+              elsif read_type
+                mapped_type.meta(read: read_type)
+              else
+                mapped_type
+              end
             end
           end
         end
@@ -87,7 +95,7 @@ module ROM
           type = self.class.ruby_type_mapping[ruby_type]
 
           if db_type.is_a?(String) && db_type.include?('numeric') || db_type.include?('decimal')
-            self.class.ruby_type_mapping[:decimal]
+            map_decimal_type(db_type)
           else
             type
           end
@@ -110,6 +118,22 @@ module ROM
             columns[0]
           end
         end
+
+        # @api private
+        def map_decimal_type(type)
+          precision = DECIMAL_REGEX.match(type)
+
+          if precision
+            prcsn, scale = precision[1..2].map(&:to_i)
+
+            self.class.ruby_type_mapping[:decimal].meta(
+              precision: prcsn,
+              scale: scale
+            )
+          else
+            self.class.ruby_type_mapping[:decimal]
+          end
+        end
       end
     end
   end

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

@@ -24,11 +24,11 @@ module ROM
 end
 
 namespace :db do
-  desc "Perform migration reset (full erase and migration up)"
   task :rom_configuration do
     Rake::Task["db:setup"].invoke
   end
 
+  desc "Perform migration reset (full erase and migration up)"
   task reset: :rom_configuration do
     ROM::SQL::RakeSupport.run_migrations(target: 0)
     ROM::SQL::RakeSupport.run_migrations

data/lib/rom/sql/type.rb

@@ -3,6 +3,8 @@ require 'rom/schema/type'
 module ROM
   module SQL
     class Type < ROM::Schema::Type
+      QualifyError = Class.new(StandardError)
+
       # Return a new type marked as a FK
       #
       # @return [SQL::Type]
@@ -13,9 +15,10 @@ module ROM
       end
 
       # @api public
-      def as(name)
+      def aliased(name)
         super.meta(sql_expr: sql_expr.as(name))
       end
+      alias_method :as, :aliased
 
       # Return a new type marked as qualified
       #
@@ -23,7 +26,15 @@ module ROM
       #
       # @api public
       def qualified
-        meta(qualified: true)
+        return self if qualified?
+
+        case sql_expr
+        when Sequel::SQL::AliasedExpression, Sequel::SQL::Identifier
+          type = meta(qualified: true)
+          type.meta(qualified: true, sql_expr: Sequel[type.to_sym])
+        else
+          raise QualifyError, "can't qualify #{name.inspect} (#{sql_expr.inspect})"
+        end
       end
 
       # Return a new type marked as joined

data/lib/rom/sql/types.rb

@@ -5,11 +5,13 @@ module ROM
     module Types
       include ROM::Types
 
+      def self.Constructor(*args, &block)
+        ROM::Types.Constructor(*args, &block)
+      end
+
       Serial = Int.constrained(gt: 0).meta(primary_key: true)
 
-      Blob = Dry::Types::Definition
-        .new(Sequel::SQL::Blob)
-        .constructor(Sequel::SQL::Blob.method(:new))
+      Blob = Constructor(Sequel::SQL::Blob, &Sequel::SQL::Blob.method(:new))
     end
   end
 end

data/lib/rom/sql/version.rb

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

data/spec/extensions/postgres/types_spec.rb

@@ -112,4 +112,33 @@ RSpec.describe 'ROM::SQL::Types' do
       expect(output).to be_instance_of(BigDecimal)
     end
   end
+
+  describe ROM::SQL::Types::PG::IPAddress do
+    it 'converts IPAddr to a string' do
+      expect(described_class[IPAddr.new('127.0.0.1')]).to eql('127.0.0.1')
+    end
+
+    it 'coerces to builtin IPAddr type on read' do
+      expect(described_class.meta[:read]['127.0.0.1']).to eql(IPAddr.new('127.0.0.1'))
+    end
+
+    it 'supports networks' do
+      class_a = described_class.meta[:read]['10.0.0.0/8']
+
+      expect(class_a).to eql(IPAddr.new('10.0.0.0/8'))
+      expect(class_a).to include(IPAddr.new('10.8.8.8'))
+    end
+  end
+
+  describe ROM::SQL::Types::PG::PointT do
+    let(:point) { ROM::SQL::Types::PG::Point.new(7.5, 30.5) }
+
+    it 'serializes a point down to a string' do
+      expect(described_class[point]).to eql('(7.5,30.5)')
+    end
+
+    it 'reads serialized format' do
+      expect(described_class.meta[:read]['(7.5,30.5)']).to eql(point)
+    end
+  end
 end

data/spec/integration/association/many_to_many_spec.rb

@@ -133,6 +133,14 @@ RSpec.describe ROM::SQL::Association::ManyToMany do
 
         expect(relation.to_a).to eql([id: 1, name: 'important', task_id: 1])
       end
+
+      it 'maintains original relation' do
+        relation = tags.
+                     select_append(tags[:name].as(:tag)).
+                     for_combine(assoc).call(tasks.call)
+
+        expect(relation.to_a).to eql([id: 1, tag: 'important', name: 'important', task_id: 1])
+      end
     end
   end
 end

data/spec/integration/association/many_to_one_spec.rb

@@ -66,6 +66,17 @@ RSpec.describe ROM::SQL::Association::ManyToOne, helpers: true do
           { id: 1, task_id: 2, name: 'Jane' }
         ])
       end
+
+      it 'maintains original relation' do
+        users.accounts.insert(user_id: 2, number: 'a1', balance: 0)
+
+        relation = users.
+                     join(:accounts, user_id: :id).
+                     select_append(users.accounts[:number].as(:account_num)).
+                     for_combine(assoc).call(tasks.call)
+
+        expect(relation.to_a).to eql([{ id: 2, task_id: 1, name: 'Joe', account_num: 'a1' }])
+      end
     end
 
     context 'arbitrary name conventions' do

data/spec/integration/association/one_to_many_spec.rb

@@ -53,6 +53,15 @@ RSpec.describe ROM::SQL::Association::OneToMany do
           { id: 2, user_id: 1, title: "Jane's task" }
         ])
       end
+
+      it 'maintains original relation' do
+        relation = tasks.
+                     join(:task_tags, tag_id: :id).
+                     select_append(tasks.task_tags[:tag_id].qualified).
+                     for_combine(assoc).call(users.call)
+
+        expect(relation.to_a).to eql([{ id: 1, user_id: 2, title: "Joe's task", tag_id: 1 }])
+      end
     end
   end
 end

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

@@ -0,0 +1,36 @@
+RSpec.describe 'ROM::SQL::Schema::MysqlInferrer', :mysql do
+  include_context 'database setup'
+
+  before do
+    conn.drop_table?(:test_inferrence)
+
+    conn.create_table :test_inferrence do
+      tinyint :tiny
+      mediumint :medium
+    end
+  end
+
+  after do
+    conn.drop_table?(:test_inferrence)
+  end
+
+  let(:dataset) { :test_inferrence }
+
+  let(:schema) { container.relations[dataset].schema }
+
+  before do
+    dataset = self.dataset
+    conf.relation(dataset) do
+      schema(dataset, infer: true)
+    end
+  end
+
+  it 'can infer attributes for dataset' do
+    source = container.relations[:test_inferrence].name
+
+    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),
+    )
+  end
+end

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

@@ -0,0 +1,118 @@
+
+RSpec.describe 'ROM::SQL::Schema::PostgresInferrer', :postgres do
+  include_context 'database setup'
+
+  colors = %w(red orange yellow green blue purple)
+
+  before do
+    conn.extension :pg_enum
+
+    conn.drop_table?(:test_inferrence)
+    conn.drop_enum(:rainbow, if_exists: true)
+
+    conn.create_enum(:rainbow, colors)
+
+    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[]"
+      column :ip, "inet"
+      column :subnet, "cidr"
+      column :hw_address, "macaddr"
+      rainbow :color
+      point :center
+    end
+  end
+
+  after do
+    conn.drop_table?(:test_inferrence)
+  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
+      source = container.relations[:test_inferrence].name
+
+      expect(schema.to_h).to eql(
+        id: ROM::SQL::Types::PG::UUID.meta(name: :id, source: source, primary_key: true),
+        json_data: ROM::SQL::Types::PG::JSON.optional.meta(name: :json_data, source: source),
+        jsonb_data: ROM::SQL::Types::PG::JSONB.optional.meta(name: :jsonb_data, source: source),
+        money: ROM::SQL::Types::Decimal.meta(name: :money, source: source),
+        tags: ROM::SQL::Types::PG::Array('text').optional.meta(name: :tags, source: source),
+        tag_ids: ROM::SQL::Types::PG::Array('biging').optional.meta(name: :tag_ids, source: source),
+        color: ROM::SQL::Types::String.enum(*colors).optional.meta(name: :color, source: source),
+        ip: ROM::SQL::Types::PG::IPAddress.optional.meta(
+          name: :ip,
+          source: source,
+          read: ROM::SQL::Types::PG::IPAddressR.optional
+        ),
+        subnet: ROM::SQL::Types::PG::IPAddress.optional.meta(
+          name: :subnet,
+          source: source,
+          read: ROM::SQL::Types::PG::IPAddressR.optional
+        ),
+        hw_address: ROM::SQL::Types::String.optional.meta(name: :hw_address, source: source),
+        center: ROM::SQL::Types::PG::PointT.optional.meta(
+          name: :center,
+          source: source,
+          read: ROM::SQL::Types::PG::PointTR.optional
+        )
+      )
+    end
+  end
+
+  context 'with a table without columns' do
+    before do
+      conn.create_table(:dummy) unless conn.table_exists?(:dummy)
+      conf.relation(:dummy) { schema(infer: true) }
+    end
+
+    it 'does not fail with a weird error when a relation does not have attributes' do
+      expect(container.relations[:dummy].schema).to be_empty
+    end
+  end
+
+  context 'with a column with bi-directional mapping' do
+    before do
+      conn.drop_table?(:test_bidirectional)
+      conn.create_table(:test_bidirectional) do
+        primary_key :id
+        inet :ip
+        point :center
+      end
+
+      conf.relation(:test_bidirectional) { schema(infer: true) }
+
+      conf.commands(:test_bidirectional) do
+        define(:create) do
+          result :one
+        end
+      end
+    end
+
+    let(:point) { ROM::SQL::Types::PG::Point.new(7.5, 30.5) }
+    let(:dns) { IPAddr.new('8.8.8.8') }
+
+    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)
+      expect(relation.to_a).to eql([inserted])
+    end
+  end
+end