rom-sql 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 017ad7f1a32c576596913c9f86d7d5781efad7e6
-  data.tar.gz: ee55e2a05c6733c1b10dbedad0a638c7d0da066d
+  metadata.gz: 5da70a1471f9c0b3a27f10cacf6af54f060090be
+  data.tar.gz: 1f391fdbd269bbf0df9d0af23a5fc112948ce1f2
 SHA512:
-  metadata.gz: 1675cade8ac1b92697582e6cfd0ccd17bc3af848a2677a0fbab6e39d188d660e16b937d7d2643ffbd9d94fca60bcdb9af758255abde5af9bc7c0c3298f78790f
-  data.tar.gz: c9bc786e8e52a805453bca55cfb3f6ca236761455d5f68d598bc476463282d8c74d4d383343693d3a1e4abefec5e444bef6cd06a4319f312c61630af33443805
+  metadata.gz: f91c5854d45dc52b26ddb0eaca6dc465ff02db69bd145d6ce010c6eaa93571ac46842d68a6897e0b88fffb7639efe26c94435a035c0d4a0790be37defd846fa2
+  data.tar.gz: 879cf6a660eb79ab84b1adbfb33ede96613d786356457182d81bc3f00f2a7165fbe939d25b7bd0755242710469cffae650976252c9c19eeda37067a89a0407ec

data/.rspec

@@ -1,2 +1,3 @@
 --color
 --order random
+--require ./spec/spec_helper

data/.travis.yml

@@ -1,28 +1,33 @@
 language: ruby
 sudo: false
 cache: bundler
+services:
+  - postgresql
+  - mysql
 bundler_args: --without yard guard benchmarks tools
 before_script:
   - psql -c 'create database rom_sql;' -U postgres
+  - mysql -e 'create database rom_sql;'
 script: "bundle exec rake ci"
 rvm:
-  - 2.0
-  - 2.1
-  - 2.2
-  - 2.3.0
+  - 2.1.9
+  - 2.2.5
+  - 2.3.1
   - rbx-2
-  - jruby-9000
-  - jruby-head
+  - jruby-9.0.5.0
   - ruby-head
 env:
   global:
     - CODECLIMATE_REPO_TOKEN=03d7f66589572702b12426d2bc71c4de6281a96139e33b335b894264b1f8f0b0
     - JRUBY_OPTS='--dev -J-Xmx1024M'
+    - PG_LTE_95='false'
 matrix:
   allow_failures:
-    - rvm: jruby-9000
     - rvm: ruby-head
     - rvm: jruby-head
+  include:
+    - rvm: jruby-head
+      before_install: gem install bundler --no-ri --no-rdoc
 notifications:
   webhooks:
     urls:

data/CHANGELOG.md

@@ -1,3 +1,31 @@
+## v0.8.0 2016-07-27
+
+### Added
+
+* Support for relation schemas with SQL-specific data types (solnic + flash-gordon)
+* One-To-Many support in schemas (solnic + flash-gordon)
+* One-To-One support in schemas (solnic + flash-gordon)
+* One-To-One-Through support in schemas (solnic + flash-gordon)
+* Many-To-One support in schemas (solnic + flash-gordon)
+* Many-To-Many support in schemas (solnic + flash-gordon)
+* Support for `has_many`, `has_one` and `belongs_to` convenient methods in schema DSL (solnic)
+* Support for custom PG types: `Types::PG::Array`, `Types::PG::Hash`, `Types::PG::JSON`, and `Types::PG::Bytea` (solnic + flash-gordon)
+* Optional automatic schema inference for attributes and foreign keys based on DB metadata provided by Sequel (flash-gordon)
+* Support for arbitrary dataset and FK names in schemas (flash-gordon)
+* Support for native upserts in PostgreSQL >= 9.5 via `Commands::Postgres::Upsert` (gotar + flash-gordon)
+
+### Changed
+
+* `Create` and `Update` commands have `:schema` plugin enabled by default which sets input handler based on schema definition automatically (solnic)
+* `associates` command plugin uses schema associations now (solnic)
+* Dropped MRI 2.0.x support
+
+### Fixed
+
+* `Create` command properly materialize result when `:one` is set (AMHOL)
+
+[Compare v0.7.0...v0.8.0](https://github.com/rom-rb/rom-sql/compare/v0.7.0...v0.8.0)
+
 ## v0.7.0 2016-01-06
 
 ### Added

data/Gemfile

@@ -6,16 +6,13 @@ group :test do
   gem 'byebug', platforms: :mri
   gem 'anima', '~> 0.2.0'
   gem 'virtus'
-  gem 'activesupport'
+  gem 'activesupport', '~> 4.2'
   gem 'rspec', '~> 3.1'
   gem 'codeclimate-test-reporter', require: false
   gem 'pg', platforms: [:mri, :rbx]
-  gem 'pg_jruby', platforms: :jruby
-end
-
-group :tools do
-  gem 'guard'
-  gem 'guard-rspec'
-  gem 'guard-rubocop'
-  gem 'rubocop', '~> 0.28'
+  gem 'mysql2', platforms: [:mri, :rbx]
+  gem 'jdbc-postgres', platforms: :jruby
+  gem 'jdbc-mysql', platforms: :jruby
+  gem 'sqlite3', platforms: [:mri, :rbx]
+  gem 'jdbc-sqlite3', platforms: :jruby
 end

data/README.md

@@ -4,11 +4,11 @@
 [codeclimate]: https://codeclimate.com/github/rom-rb/rom-sql
 [inchpages]: http://inch-ci.org/github/rom-rb/rom-sql
 
-# ROM::SQL
+# rom-sql
 
 [![Gem Version](https://badge.fury.io/rb/rom-sql.svg)][gem]
 [![Build Status](https://travis-ci.org/rom-rb/rom-sql.svg?branch=master)][travis]
-[![Dependency Status](https://gemnasium.com/rom-rb/rom-sql.png)][gemnasium]
+[![Dependency Status](https://gemnasium.com/rom-rb/rom-sql.svg)][gemnasium]
 [![Code Climate](https://codeclimate.com/github/rom-rb/rom-sql/badges/gpa.svg)][codeclimate]
 [![Test Coverage](https://codeclimate.com/github/rom-rb/rom-sql/badges/coverage.svg)][codeclimate]
 [![Inline docs](http://inch-ci.org/github/rom-rb/rom-sql.svg?branch=master)][inchpages]
@@ -17,7 +17,8 @@ RDBMS support for [Ruby Object Mapper](https://github.com/rom-rb/rom).
 
 Resources:
 
-- [Guides](http://rom-rb.org/guides/adapters/sql/)
+- [User Documentation](http://rom-rb.org/learn/sql/)
+- [API Documentation](http://rubydoc.info/gems/rom-sql)
 
 ## Installation
 
@@ -35,7 +36,7 @@ Or install it yourself as:
 
     $ gem install rom-sql
 
-Check out [SQL guide](http://rom-rb.org/guides/adapters/sql/) for usage examples.
+Check out [SQL guide](http://rom-rb.org/learn/adapters/sql/) for usage examples.
 
 ## ROADMAP
 

data/circle.yml

@@ -0,0 +1,10 @@
+machine:
+  ruby:
+    version: 2.3.1
+dependencies:
+  bundler:
+    without: [yard guard benchmarks tools]
+database:
+  override:
+    - psql -c 'create database rom_sql;' -U postgres
+    - mysql -e 'create database rom_sql;'

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

@@ -16,6 +16,7 @@ module ROM
             def inherited(klass)
               super
               klass.auto_curry :for_combine
+              klass.auto_curry :preload
             end
           end
 
@@ -27,9 +28,21 @@ module ROM
             # @return [SQL::Relation]
             #
             # @api private
-            def for_combine(keys, relation)
-              pk, fk = keys.to_a.flatten
-              where(fk => relation.map { |tuple| tuple[pk] })
+            def for_combine(spec)
+              source_key, target_key, target =
+                case spec
+                when ROM::SQL::Association
+                  [*spec.join_keys(__registry__).flatten, spec.call(__registry__)]
+                else
+                  [*spec.flatten, self]
+                end
+
+              target.preload(source_key, target_key)
+            end
+
+            # @api private
+            def preload(source_key, target_key, source)
+              where(target_key => source.pluck(source_key.to_sym))
             end
           end
         end

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

@@ -29,10 +29,11 @@ module ROM
             # @api private
             def for_wrap(keys, name)
               other = __registry__[name]
+              other_dataset = other.name.dataset
 
-              inner_join(name, keys)
+              inner_join(other_dataset, keys)
                 .select(*qualified.header.columns)
-                .select_append(*other.prefix(other.name).qualified.header)
+                .select_append(*other.prefix(other_dataset).qualified.header)
             end
           end
         end

data/lib/rom/sql/association.rb

@@ -0,0 +1,75 @@
+require 'rom/support/constants'
+require 'rom/sql/qualified_attribute'
+require 'rom/sql/association/name'
+
+module ROM
+  module SQL
+    # Abstract association class
+    #
+    # @api public
+    class Association
+      include Dry::Equalizer(:source, :target, :result)
+      include Options
+      extend ClassMacros
+
+      defines :result
+
+      # @!attribute [r] source
+      #   @return [ROM::Relation::Name] the source relation name
+      attr_reader :source
+
+      # @!attribute [r] target
+      #   @return [ROM::Relation::Name] the target relation name
+      attr_reader :target
+
+      # @!attribute [r] relation
+      #   @return [Symbol] an optional relation identifier for the target
+      option :relation, accepts: [Symbol], reader: true
+
+      # @!attribute [r] result
+      #   @return [Symbol] either :one or :many
+      option :result, accepts: [Symbol], reader: true, default: -> assoc { assoc.class.result }
+
+      # @!attribute [r] as
+      #   @return [Symbol] an optional association alias name
+      option :as, accepts: [Symbol], reader: true, default: -> assoc { assoc.target.to_sym }
+
+      alias_method :name, :as
+
+      # @api private
+      def initialize(source, target, options = EMPTY_HASH)
+        @source = Name[source]
+        @target = Name[options[:relation] || target, target, options[:as] || target]
+        super
+      end
+
+      # Returns a qualified attribute name for a given dataset
+      #
+      # This is compatible with Sequel's SQL generator and can be used in query
+      # DSL methods
+      #
+      # @param name [ROM::Relation::Name]
+      # @param attribute [Symbol]
+      #
+      # @return [QualifiedAttribute]
+      #
+      # @api public
+      def qualify(name, attribute)
+        QualifiedAttribute[name.dataset, attribute]
+      end
+
+      protected
+
+      # @api private
+      def join_key_map(relations)
+        join_keys(relations).to_a.flatten.map(&:to_sym)
+      end
+    end
+  end
+end
+
+require 'rom/sql/association/one_to_one'
+require 'rom/sql/association/one_to_many'
+require 'rom/sql/association/many_to_many'
+require 'rom/sql/association/many_to_one'
+require 'rom/sql/association/one_to_one_through'

data/lib/rom/sql/association/many_to_many.rb

@@ -0,0 +1,86 @@
+module ROM
+  module SQL
+    class Association
+      class ManyToMany < Association
+        attr_reader :through
+
+        result :many
+
+        option :through, default: nil, type: Symbol
+
+        # @api private
+        def initialize(*)
+          super
+          @through = Relation::Name[
+            options[:through] || options[:through_relation], options[:through]
+          ]
+        end
+
+        # @api public
+        def call(relations)
+          join_rel = join_relation(relations)
+          assocs = join_rel.associations
+
+          left = assocs[target].call(relations)
+          right = relations[target.relation]
+
+          left_fk = join_rel.foreign_key(source.relation)
+
+          columns = right.header.exclude(left_fk).qualified.to_a
+          columns << left_fk unless right.header.names.include?(left_fk)
+
+          relation = left
+            .inner_join(source, join_keys(relations))
+            .select(*columns)
+            .order(*right.header.project(*right.primary_key).qualified)
+
+          relation.with(attributes: relation.header.names)
+        end
+
+        # @api public
+        def join_keys(relations)
+          with_keys(relations) { |source_key, target_key|
+            { qualify(source, source_key) => qualify(through, target_key) }
+          }
+        end
+
+        # @api public
+        def combine_keys(relations)
+          Hash[*with_keys(relations)]
+        end
+
+        # @api private
+        def associate(relations, children, parent)
+          ((spk, sfk), (tfk, tpk)) = join_key_map(relations)
+
+          children.map { |tuple|
+            { sfk => tuple.fetch(spk), tfk => parent.fetch(tpk) }
+          }
+        end
+
+        # @api private
+        def join_relation(relations)
+          relations[through.relation]
+        end
+
+        protected
+
+        # @api private
+        def with_keys(relations, &block)
+          source_key = relations[source.relation].primary_key
+          target_key = relations[through.relation].foreign_key(source.relation)
+          return [source_key, target_key] unless block
+          yield(source_key, target_key)
+        end
+
+        # @api private
+        def join_key_map(relations)
+          left = super
+          right = join_relation(relations).associations[target].join_key_map(relations)
+
+          [left, right]
+        end
+      end
+    end
+  end
+end

data/lib/rom/sql/association/many_to_one.rb

@@ -0,0 +1,60 @@
+module ROM
+  module SQL
+    class Association
+      class ManyToOne < Association
+        result :one
+
+        # @api public
+        def call(relations)
+          left = relations[target.relation]
+          right = relations[source.relation]
+
+          right_pk = right.schema.primary_key.map { |a| a.meta[:name] }
+          right_fk = right.foreign_key(target.relation)
+
+          pk_to_fk = Hash[right_pk.product(Array(left.foreign_key(source.relation)))]
+
+          columns = left.header.qualified.to_a + right.header
+            .project(*right_pk)
+            .rename(pk_to_fk)
+            .qualified.to_a
+
+          relation = left
+            .inner_join(source, right_fk => left.primary_key)
+            .select(*columns)
+            .order(*right.header.project(*right.primary_key).qualified)
+
+          relation.with(attributes: relation.header.names)
+        end
+
+        # @api public
+        def combine_keys(relations)
+          Hash[*with_keys(relations)]
+        end
+
+        # @api public
+        def join_keys(relations)
+          with_keys(relations) { |source_key, target_key|
+            { qualify(source, source_key) => qualify(target, target_key) }
+          }
+        end
+
+        # @api private
+        def associate(relations, child, parent)
+          fk, pk = join_key_map(relations)
+          child.merge(fk => parent.fetch(pk))
+        end
+
+        protected
+
+        # @api private
+        def with_keys(relations, &block)
+          source_key = relations[source.relation].foreign_key(target.relation)
+          target_key = relations[target.relation].primary_key
+          return [source_key, target_key] unless block
+          yield(source_key, target_key)
+        end
+      end
+    end
+  end
+end

data/lib/rom/sql/association/name.rb

@@ -0,0 +1,70 @@
+require 'dry/equalizer'
+require 'rom/relation/name'
+require 'rom/support/cache'
+
+module ROM
+  module SQL
+    class Association
+      class Name
+        include Dry::Equalizer.new(:relation_name, :key)
+
+        extend Cache
+
+        attr_reader :relation_name
+
+        attr_reader :key
+
+        alias_method :to_sym, :key
+
+        def self.[](*args)
+          fetch_or_store(args) do
+            rel, ds, aliaz = args
+
+            if rel.is_a?(ROM::Relation::Name)
+              new(rel, rel.dataset)
+            elsif rel.is_a?(self)
+              rel
+            elsif aliaz
+              new(ROM::Relation::Name[rel, ds], aliaz)
+            elsif ds.nil?
+              new(ROM::Relation::Name[rel], rel)
+            else
+              new(ROM::Relation::Name[rel, ds], ds)
+            end
+          end
+        end
+
+        def initialize(relation_name, aliaz)
+          @relation_name = relation_name
+          @aliased = relation_name.dataset != aliaz
+          @key = aliased? ? aliaz : relation_name.dataset
+        end
+
+        def aliased?
+          @aliased
+        end
+
+        def inspect
+          if aliased?
+            "#{self.class}(#{relation_name.to_s} as #{key})"
+          else
+            "#{self.class}(#{relation_name.to_s})"
+          end
+        end
+        alias_method :to_s, :inspect
+
+        def dataset
+          relation_name.dataset
+        end
+
+        def relation
+          relation_name.relation
+        end
+
+        def sql_literal_append(ds, sql)
+          ds.literal_append(sql, dataset)
+        end
+      end
+    end
+  end
+end