rom-sql 0.3.2 → 0.4.0.beta1

data/lib/rom/sql/commands/delete.rb

@@ -0,0 +1,18 @@
+require 'rom/sql/commands'
+require 'rom/sql/commands/transaction'
+
+module ROM
+  module SQL
+    module Commands
+      class Delete < ROM::Commands::Delete
+        include Transaction
+
+        def execute
+          deleted = target.to_a
+          target.delete
+          deleted
+        end
+      end
+    end
+  end
+end

data/lib/rom/sql/commands/transaction.rb

@@ -0,0 +1,17 @@
+require 'rom/commands/result'
+
+module ROM
+  module SQL
+    module Commands
+      module Transaction
+        ROM::SQL::Rollback = Class.new(Sequel::Rollback)
+
+        def transaction(options = {}, &block)
+          ROM::Commands::Result::Success.new(
+            relation.dataset.db.transaction(options, &block)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rom/sql/commands/update.rb

@@ -0,0 +1,54 @@
+require 'rom/sql/commands'
+require 'rom/sql/commands/transaction'
+
+module ROM
+  module SQL
+    module Commands
+      class Update < ROM::Commands::Update
+        include Transaction
+
+        option :original, type: Hash, reader: true
+
+        alias_method :to, :call
+
+        def execute(tuple)
+          attributes = input[tuple]
+          validator.call(attributes)
+
+          changed = diff(attributes.to_h)
+
+          if changed.any?
+            update(changed)
+          else
+            []
+          end
+        end
+
+        def change(original)
+          self.class.new(relation, options.merge(original: original))
+        end
+
+        def update(tuple)
+          pks = relation.map { |t| t[primary_key] }
+          dataset = relation.dataset
+          dataset.update(tuple)
+          dataset.unfiltered.where(primary_key => pks).to_a
+        end
+
+        def primary_key
+          relation.primary_key
+        end
+
+        private
+
+        def diff(tuple)
+          if original
+            Hash[tuple.to_a - (tuple.to_a & original.to_a)]
+          else
+            tuple
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rom/sql/commands_ext/postgres.rb

@@ -0,0 +1,24 @@
+require 'rom/sql/commands/create'
+require 'rom/sql/commands/update'
+
+module ROM
+  module SQL
+    module Commands
+      module Postgres
+        module Create
+          def insert(tuples)
+            tuples.map do |tuple|
+              relation.dataset.returning(*relation.columns).insert(tuple)
+            end.flatten
+          end
+        end
+
+        module Update
+          def update(tuple)
+            relation.dataset.returning(*relation.columns).update(tuple)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rom/sql/header.rb

@@ -2,13 +2,12 @@ module ROM
   module SQL
     # @private
     class Header
-      include Charlatan.new(:columns)
       include Equalizer.new(:columns, :table)
 
-      attr_reader :table
+      attr_reader :columns, :table
 
       def initialize(columns, table)
-        super
+        @columns = columns
         @table = table
       end
 
@@ -25,19 +24,19 @@ module ROM
       end
 
       def names
-        map { |col| :"#{col.to_s.split('___').last}" }
+        columns.map { |col| :"#{col.to_s.split('___').last}" }
       end
 
       def project(*names)
-        find_all { |col| names.include?(col) }
+        self.class.new(columns.find_all { |col| names.include?(col) }, table)
       end
 
       def qualified
-        map { |col| :"#{table}__#{col}" }
+        self.class.new(columns.map { |col| :"#{table}__#{col}" }, table)
       end
 
       def rename(options)
-        map do |col|
+        self.class.new(columns.map { |col|
           new_name = options[col]
 
           if new_name
@@ -45,11 +44,11 @@ module ROM
           else
             col
           end
-        end
+        }, table)
       end
 
       def prefix(col_prefix)
-        rename(Hash[map { |col| [col, :"#{col_prefix}_#{col}"] }])
+        rename(Hash[columns.map { |col| [col, :"#{col_prefix}_#{col}"] }])
       end
     end
   end

data/lib/rom/sql/migration.rb

@@ -0,0 +1,26 @@
+module ROM
+  module SQL
+    class Migration
+      ::Sequel.extension :migration
+
+      DEFAULT_PATH = 'db/migrate'
+
+      class << self
+        attr_writer :path
+        attr_accessor :connection
+
+        def path
+          @path || DEFAULT_PATH
+        end
+
+        def run(options = {})
+          ::Sequel::Migrator.run(connection, path, options)
+        end
+
+        def create(&block)
+          ::Sequel.migration(&block)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+module ROM
+  module SQL
+    module Plugin
+      module Pagination
+        class Pager
+          include Options
+          include Equalizer.new(:current_page, :per_page)
+
+          option :current_page, reader: true, default: 1
+          option :per_page, reader: true
+
+          attr_reader :dataset
+          attr_reader :current_page
+
+          def initialize(dataset, options = {})
+            @dataset = dataset
+            super
+          end
+
+          def next_page
+            num = current_page + 1
+            num if total_pages >= num
+          end
+
+          def prev_page
+            num = current_page - 1
+            num if num > 0
+          end
+
+          def total
+            dataset.unlimited.count
+          end
+
+          def total_pages
+            (total / per_page) + 1
+          end
+
+          def at(num, per_page = options[:per_page])
+            self.class.new(
+              dataset.offset((num-1)*per_page).limit(per_page),
+              options.merge(current_page: num, per_page: per_page)
+            )
+          end
+
+          alias_method :limit_value, :per_page
+        end
+
+        def self.included(klass)
+          super
+
+          klass.class_eval do
+            defines :per_page
+
+            option :pager, reader: true, default: proc { |relation|
+              Pager.new(relation.dataset, per_page: relation.class.per_page)
+            }
+
+            exposed_relations.merge([:pager, :page, :per_page])
+          end
+        end
+
+        # Paginate a relation
+        #
+        # @example
+        #   rom.relation(:users).class.per_page(10)
+        #   rom.relation(:users).page(1)
+        #   rom.relation(:users).pager # => info about pagination
+        #
+        # @return [Relation]
+        #
+        # @api public
+        def page(num)
+          num = num.to_i
+          next_pager = pager.at(num)
+          __new__(next_pager.dataset, pager: next_pager)
+        end
+
+        # Set limit for pagination
+        #
+        # @example
+        #   rom.relation(:users).page(2).per_page(10)
+        #
+        # @api public
+        def per_page(num)
+          num = num.to_i
+          next_pager = pager.at(pager.current_page, num)
+          __new__(next_pager.dataset, pager: next_pager)
+        end
+
+      end
+    end
+  end
+end

data/lib/rom/sql/rake_task.rb

@@ -0,0 +1,2 @@
+require 'rake'
+load 'rom/sql/tasks/migration_tasks.rake'

data/lib/rom/sql/relation.rb

@@ -0,0 +1,320 @@
+require 'rom/sql/header'
+
+require 'rom/sql/relation/class_methods'
+require 'rom/sql/relation/inspection'
+require 'rom/sql/relation/associations'
+
+module ROM
+  module SQL
+    # Sequel-specific relation extensions
+    #
+    class Relation < ROM::Relation
+      extend ClassMethods
+
+      include Inspection
+      include Associations
+
+      attr_reader :header, :table
+
+      # @api private
+      def initialize(dataset, registry = {})
+        super
+        @table = dataset.opts[:from].first
+      end
+
+      # Return a header for this relation
+      #
+      # @return [Header]
+      #
+      # @api private
+      def header
+        @header ||= Header.new(dataset.opts[:select] || dataset.columns, table)
+      end
+
+      # Return raw column names
+      #
+      # @return [Array<Symbol>]
+      #
+      # @api private
+      def columns
+        dataset.columns
+      end
+
+      # @api public
+      def project(*names)
+        select(*header.project(*names))
+      end
+
+      # @api public
+      def rename(options)
+        select(*header.rename(options))
+      end
+
+      # @api public
+      def prefix(name = Inflector.singularize(table))
+        rename(header.prefix(name).to_h)
+      end
+
+      # @api public
+      def qualified
+        select(*qualified_columns)
+      end
+
+      # @api public
+      def qualified_columns
+        header.qualified.to_a
+      end
+
+      # Get first tuple from the relation
+      #
+      # @example
+      #   users.first
+      #
+      # @return [Relation]
+      #
+      # @api public
+      def first
+        dataset.first
+      end
+
+      # Get last tuple from the relation
+      #
+      # @example
+      #   users.first
+      #
+      # @return [Relation]
+      #
+      # @api public
+      def last
+        dataset.last
+      end
+
+      # Return relation count
+      #
+      # @example
+      #   users.count # => 12
+      #
+      # @return [Relation]
+      #
+      # @api public
+      def count
+        dataset.count
+      end
+
+      # Select specific columns for select clause
+      #
+      # @example
+      #   users.select(:id, :name)
+      #
+      # @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)
+      #
+      # @return [Relation]
+      #
+      # @api public
+      def select_append(*args, &block)
+        __new__(dataset.__send__(__method__, *args, &block))
+      end
+
+      # Restrict a relation to match criteria
+      #
+      # @example
+      #   users.where(name: 'Jane')
+      #
+      # @return [Relation]
+      #
+      # @api public
+      def where(*args, &block)
+        __new__(dataset.__send__(__method__, *args, &block))
+      end
+
+      # Set order for the relation
+      #
+      # @example
+      #   users.order(:name)
+      #
+      # @return [Relation]
+      #
+      # @api public
+      def order(*args, &block)
+        __new__(dataset.__send__(__method__, *args, &block))
+      end
+
+      # Reverse the order of the relation
+      #
+      # @example
+      #   users.order(:name).reverse
+      #
+      # @return [Relation]
+      #
+      # @api public
+      def reverse(*args, &block)
+        __new__(dataset.__send__(__method__, *args, &block))
+      end
+
+      # Limit a relation to a specific number of tuples
+      #
+      # @example
+      #   users.limit(1)
+      #
+      # @return [Relation]
+      #
+      # @api public
+      def limit(*args, &block)
+        __new__(dataset.__send__(__method__, *args, &block))
+      end
+
+      # Set offset for the relation
+      #
+      # @example
+      #   users.limit(10).offset(2)
+      #
+      # @return [Relation]
+      #
+      # @api public
+      def offset(*args, &block)
+        __new__(dataset.__send__(__method__, *args, &block))
+      end
+
+      # Map tuples from the relation
+      #
+      # @example
+      #   users.map { |user| ... }
+      #
+      # @api public
+      def map(&block)
+        to_enum.map(&block)
+      end
+
+      # Join other relation using inner join
+      #
+      # @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
+      #
+      # @param [Symbol] relation name
+      # @param [Hash] join keys
+      #
+      # @return [Relation]
+      #
+      # @api public
+      def left_join(*args, &block)
+        __new__(dataset.__send__(__method__, *args, &block))
+      end
+
+      # Group by specific columns
+      #
+      # @example
+      #   tasks.group(:user_id)
+      #
+      # @return [Relation]
+      #
+      # @api public
+      def group(*args, &block)
+        __new__(dataset.__send__(__method__, *args, &block))
+      end
+
+      # Group by specific columns and count by group
+      #
+      # @example
+      #   tasks.group_and_count(:user_id)
+      #   # => [{ user_id: 1, count: 2 }, { user_id: 2, count: 3 }]
+      #
+      # @return [Relation]
+      #
+      # @api public
+      def group_and_count(*args, &block)
+        __new__(dataset.__send__(__method__, *args, &block))
+      end
+
+      # Select and group by specific columns
+      #
+      # @example
+      #   tasks.select_group(:user_id)
+      #   # => [{ user_id: 1 }, { user_id: 2 }]
+      #
+      # @return [Relation]
+      #
+      # @api public
+      def select_group(*args, &block)
+        __new__(dataset.__send__(__method__, *args, &block))
+      end
+
+      # Insert tuple into relation
+      #
+      # @example
+      #   users.insert(name: 'Jane')
+      #
+      # @param [Hash] tuple
+      #
+      # @return [Relation]
+      #
+      # @api public
+      def insert(*args, &block)
+        dataset.insert(*args, &block)
+      end
+
+      # Update tuples in the relation
+      #
+      # @example
+      #   users.update(name: 'Jane')
+      #   users.where(name: 'Jane').update(name: 'Jane Doe')
+      #
+      # @return [Relation]
+      #
+      # @api public
+      def update(*args, &block)
+        dataset.update(*args, &block)
+      end
+
+      # Delete tuples from the relation
+      #
+      # @example
+      #   users.delete # deletes all
+      #   users.where(name: 'Jane').delete # delete tuples
+      #                                      from restricted relation
+      #
+      # @return [Relation]
+      #
+      # @api public
+      def delete(*args, &block)
+        dataset.delete(*args, &block)
+      end
+
+      # Return if a restricted relation has 0 tuples
+      #
+      # @example
+      #   users.unique?(email: 'jane@doe.org') # true
+      #
+      #   users.insert(email: 'jane@doe.org')
+      #
+      #   users.unique?(email: 'jane@doe.org') # false
+      #
+      # @param [Hash] criteria hash for the where clause
+      #
+      # @return [Relation]
+      #
+      # @api public
+      def unique?(criteria)
+        where(criteria).count.zero?
+      end
+    end
+  end
+end