hold 1.0.0

data/lib/hold/sequel/polymorphic_repository.rb

@@ -0,0 +1,121 @@
+module Hold::Sequel
+  class PolymorphicRepository
+    include Hold::IdentitySetRepository
+
+    attr_reader :db, :table, :type_column, :id_column, :type_to_model_class_mapping,
+                :repos_for_model_classes, :model_class_to_type_mapping
+
+    def initialize(db, options={})
+      @db = db
+      @table = options[:table] || :base
+      @type_column = options[:type_column] || :type
+      @id_column = options[:id_column] || :id
+      @type_to_model_class_mapping = options[:mapping]
+      @model_class_to_type_mapping = @type_to_model_class_mapping.invert
+
+      @repos_for_model_classes = options[:repos] || {}
+      @dataset = @db[@table].select(Sequel.as(@type_column,:_type), Sequel.as(@id_column,:_id))
+    end
+
+    def can_get_class?(model_class)
+      @model_class_to_type_mapping.has_key?(model_class)
+    end
+
+    def can_set_class?(model_class)
+      @model_class_to_type_mapping.has_key?(model_class)
+    end
+
+    def get_repo_dependencies_from(repo_set)
+      @type_to_model_class_mapping.each do |type,model_class|
+        @repos_for_model_classes[model_class] ||= repo_set.repo_for_model_class(model_class)
+      end
+    end
+
+    def type_to_repo_mapping
+      @type_to_repo_mapping ||= begin
+        result = {}
+        @type_to_model_class_mapping.each {|t,m| result[t] = @repos_for_model_classes[m]}
+        result
+      end
+    end
+
+    def construct_entity(property_hash, row=nil)
+      type = property_hash[:_type] or raise "missing _type in result row"
+      @type_to_model_class_mapping[type].new(property_hash)
+    end
+
+    def transaction(*p, &b)
+      @db.transaction(*p, &b)
+    end
+
+    # - Takes multiple result rows with type and id column
+    # - Groups the IDs by type and does a separate get_many_by_ids query on the relevant repo
+    # - Combines the results from the separate queries putting them into the order of the IDs from
+    #   the original rows (or in the order of the ids given, where they are given)
+    def load_from_rows(rows, options={}, ids=nil)
+      ids ||= rows.map {|row| row[:_id]}
+      ids_by_type = Hash.new {|h,k| h[k]=[]}
+      rows.each {|row| ids_by_type[row[:_type]] << row[:_id]}
+      results_by_id = {}
+      ids_by_type.each do |type, type_ids|
+        repo = type_to_repo_mapping[type] or raise "PolymorphicRepository: no repo found for type value #{type}"
+        repo.get_many_by_ids(type_ids, options).each_with_index do |result, index|
+          results_by_id[type_ids[index]] = result
+        end
+      end
+      results_by_id.values_at(*ids)
+    end
+
+    def load_from_row(row, options={})
+      repo = type_to_repo_mapping[row[:_type]] or raise "PolymorphicRepository: no repo found for type value #{row[:_type]}"
+      repo.get_by_id(row[:_id], options)
+    end
+
+    def get_with_dataset(options={}, &b)
+      dataset = @dataset
+      dataset = yield @dataset if block_given?
+      row = dataset.limit(1).first and load_from_row(row, options)
+    end
+
+    def get_by_id(id, options={})
+      get_with_dataset(options) {|ds| ds.filter(@id_column => id)}
+    end
+
+    def get_many_by_ids(ids, options={})
+      rows = @dataset.filter(@id_column => ids).all
+      load_from_rows(rows, options, ids)
+    end
+
+    def contains_id?(id)
+      @dataset.filter(@id_column => id).select(1).limit(1).single_value ? true : false
+    end
+
+
+
+
+    def store(object)
+      repo = @repos_for_model_classes[object.class] or raise Error
+      repo.store(id, object)
+    end
+
+    def store_new(object)
+      repo = @repos_for_model_classes[object.class] or raise Error
+      repo.store_new(id, object)
+    end
+
+    def update(entity, update_entity)
+      repo = @repos_for_model_classes[entity.class] or raise Error
+      repo.update(entity, update_entity)
+    end
+
+    def update_by_id(id, update_entity)
+      repo = @repos_for_model_classes[update_entity.class] or raise Error
+      repo.update_by_id(id, update_entity)
+    end
+
+    def delete(object)
+      repo = @repos_for_model_classes[object.class] or raise Error
+      repo.delete(object)
+    end
+  end
+end

data/lib/hold/sequel/property_mapper.rb

@@ -0,0 +1,138 @@
+module Hold::Sequel
+  # Abstract superclass.
+  # Responsibility of a PropertyMapper is to map data for a particular property of a model class, between the
+  # instances of that model class, and the database
+  class PropertyMapper
+    def self.setter_dependencies_for(options={}); {}; end
+
+    attr_reader :repository, :property_name, :property
+
+    # If you pass a block, it will be instance_evalled, allowing you to create one-off custom property mappers
+    # by overriding bits of this implementation in the block.
+    def initialize(repo, property_name, options=nil, &block)
+      @repository = repo
+      @property_name = property_name
+      instance_eval(&block) if block
+    end
+
+    # columns: column names to include in a SELECT in order to select this property. these should be
+    # qualified with the relevant table name but not aliased
+    #
+    # aliases: the above columns, aliased for use in the SELECT clause. be alias should something unique
+    # which the mapper can later use to retreive from a result row.
+    #
+    # Any tables which need to be present in the FROM clause in order to select the columns.
+    # relevant joins will be constructed by the parent repo.
+    #
+    # a 'preferred_table' hint may be passed by the repo to indicate that it'd prefer you load the
+    # column off a particular table; at present this is only used by the IdentityMapper
+    def columns_aliases_and_tables_for_select(preferred_table=nil)
+      return [], [], []
+    end
+
+    # Obtains the value of this property from a sequel result row and/or identity value.
+    #
+    # where the mapper has columns_aliases_and_tables_for_select, it will get passed a result row object here
+    # which contains the sql values for these columns (amongst others potentially)
+    #
+    # Where the identity value is available it will also be passed.
+    #
+    # One or other of id, row must always be passed.
+    def load_value(row=nil, id=nil, properties=nil)
+    end
+
+    # called inside the INSERT transaction for insertion of the given entity.
+    #
+    # this is called first thing before insert rows are built (via build_insert_row) for each table of the
+    # repo.
+    def pre_insert(entity)
+    end
+
+    # called inside the UPDATE transaction for insertion of the given entity.
+    #
+    # this is called first thing before update rows are built (via build_update_row) for each table of the
+    # repo.
+    #
+    # anything returned from pre_update will be passed to post_update's data_from_pre_update arg if the
+    # update succeeds.
+    def pre_update(entity, update_entity)
+    end
+
+    # called inside the DELETE transaction for a given entity.
+    #
+    # this is called first thing before rows are deleted for each table of the repo.
+    def pre_delete(entity)
+    end
+
+    # called inside the DELETE transaction for a given entity.
+    #
+    # this is called last thing after rows are deleted for each table of the repo.
+    def post_delete(entity)
+    end
+
+    # gets this property off the entity, and sets associated keys on a sequel row hash for insertion
+    # into the given table. May be passed an ID if an last_insert_id id value for the entity was previously
+    # obtained from an ID sequence on insertion into another table as part of the same combined entity
+    # store_new.
+    #
+    # this is called inside the transaction which wraps the insert, so this is effectively your pre-insert
+    # hook and you can safely do other things inside it in the knowledge they'll be rolled back in the
+    # event of a subsequent problem.
+    def build_insert_row(entity, table, row, id=nil)
+    end
+
+    # gets this property off the update_entity, and sets associated keys on a sequel row hash for update
+    # of the given table for the given entity.
+    #
+    # as with build_update_row, this is done inside the update transaction, it's effectively your
+    # pre-update hook.
+    def build_update_row(update_entity, table, row)
+    end
+
+    # used to make a sequel filter condition setting relevant columns equal to values equivalent
+    # to the given property value. May raise if mapper doesn't support this
+    def make_filter(value, columns_mapped_to)
+      raise Hold::UnsupportedOperation
+    end
+
+    # As for make_filter but takes multiple possible values and does a column IN (1,2,3,4) type thing.
+    def make_multi_filter(values, columns_mapped_to)
+      raise Hold::UnsupportedOperation
+    end
+
+    # like load_value, but works in a batched fashion, allowing a batched loading strategy to
+    # be used for associated objects.
+    # takes a block and yields the loaded values one at a time to it together with their index
+    def load_values(rows=nil, ids=nil, properties=nil)
+      if rows
+        rows.each_with_index {|row, i| yield load_value(row, ids && ids[i], properties), i}
+      else
+        ids.each_with_index {|id, i| yield load_value(nil, id, properties), i}
+      end
+    end
+
+    # called after rows built via build_insert_row have successfully been used in a INSERT
+    # for the entity passed. Should update the entity property, where appropriate, with any default
+    # values which were supplied by the repository (via default_for) on insert, and should do
+    # any additional work in order to save any values which are not mapped to columns on one of the repo's
+    # own :tables
+    #
+    # Is also passed the last_insert_id resulting from any insert, to help fill out any autoincrement
+    # primary key column.
+    #
+    # is executed inside the same transaction as the INSERT
+    def post_insert(entity, rows, last_insert_id=nil)
+    end
+
+    # called after rows built via build_update_row have successfully been used in a UPDATE
+    # for the id and update_entity passed. Should update the entity property, where appropriate, with any default
+    # values which were supplied by the repository (via default_for) on update, and should do
+    # any additional work in order to save any values which are not mapped to columns on one of the repo's
+    # own :tables
+    #
+    # is executed inside the same transaction as the UPDATE
+    def post_update(entity, update_entity, rows, data_from_pre_update)
+    end
+
+  end
+end

data/lib/hold/sequel/property_mapper/array.rb

@@ -0,0 +1,62 @@
+module Hold::Sequel
+  # A property which is an array of primitive values. Persisted 'all in one go' in a separate table.
+  class PropertyMapper::Array < PropertyMapper
+    attr_reader :table, :foreign_key, :value_column
+
+    def initialize(repo, property_name, options)
+      super(repo, property_name)
+
+      @table        = options[:table]        || :"#{repo.main_table}_#{property_name}"
+      @foreign_key  = options[:foreign_key]  || :"#{repo.main_table.to_s.singularize}_id"
+      @value_column = options[:value_column] || :value
+      @order_column = options[:order_column]
+
+      @dataset    = @repository.db[@table]
+      @select_v   = @repository.db[@table].select(Sequel.as(@value_column,:value))
+      @select_v   = @select_v.order(@order_column) if @order_column
+      @select_all = @repository.db[@table].select(
+        Sequel.as(@value_column,:value),
+        Sequel.as(@foreign_key,:id))
+      @select_all = @select_all.order(@order_column) if @order_column
+    end
+
+    def load_value(row=nil, id=nil, properties=nil)
+      @select_v.filter(@foreign_key => id).map {|row| row[:value]}
+    end
+
+    def load_values(rows=nil, ids=nil, properties=nil, &block)
+      results = Hash.new {|h,k| h[k]=[]}
+      @select_all.filter(@foreign_key => ids).each do |row|
+        results[row[:id]] << row[:value]
+      end
+      result.values_at(*ids).each_with_index(&block)
+    end
+
+    def pre_delete(entity)
+      @dataset.filter(@foreign_key => entity.id).delete
+    end
+
+    def post_insert(entity, rows, last_insert_id=nil)
+      array = entity[@property_name] or return
+      insert_rows = []
+      array.each_with_index do |v,i|
+        row = {@foreign_key => entity.id || last_insert_id, @value_column => v}
+        row[@order_column] = i if @order_column
+        insert_rows << row
+      end
+      @dataset.multi_insert(insert_rows)
+    end
+
+    def post_update(entity, update_entity, rows, data_from_pre_update)
+      array = update_entity[@property_name] or return
+      @dataset.filter(@foreign_key => entity.id).delete
+      insert_rows = []
+      array.each_with_index do |v,i|
+        row = {@foreign_key => entity.id, @value_column => v}
+        row[@order_column] = i if @order_column
+        insert_rows << row
+      end
+      @dataset.multi_insert(insert_rows)
+    end
+  end
+end

data/lib/hold/sequel/property_mapper/column.rb

@@ -0,0 +1,42 @@
+module Hold::Sequel
+  # Simplest case: maps the property directly to a column on the corresponding table.
+  class PropertyMapper::Column < PropertyMapper
+    attr_reader :column_name, :table, :column_alias, :column_qualified, :columns_aliases_and_tables_for_select
+
+    def initialize(repo, property_name, options)
+      super(repo, property_name)
+
+      @table = options[:table] || @repository.main_table
+
+      @column_name = (options[:column_name] || property_name).to_sym
+      @column_alias = :"#{@table}_#{@column_name}"
+      @column_qualified = Sequel::SQL::QualifiedIdentifier.new(@table, @column_name)
+      @columns_aliases_and_tables_for_select = [
+        [@column_qualified],
+        [Sequel::SQL::AliasedExpression.new(@column_qualified, @column_alias)],
+        [@table]
+      ]
+    end
+
+    def load_value(row, id=nil, version=nil)
+      row[@column_alias]
+    end
+
+    def build_insert_row(entity, table, row, id=nil)
+      row[@column_name] = entity[@property_name] if @table == table && entity.has_key?(@property_name)
+    end
+
+    alias :build_update_row :build_insert_row
+
+    # for now ignoring the columns_mapped_to, since Identity mapper is the only one
+    # for which this matters at present
+
+    def make_filter(value, columns_mapped_to=nil)
+      {@column_qualified => value}
+    end
+
+    def make_multi_filter(values, columns_mapped_to=nil)
+      {@column_qualified => values}
+    end
+  end
+end

data/lib/hold/sequel/property_mapper/created_at.rb

@@ -0,0 +1,14 @@
+module Hold::Sequel
+  class PropertyMapper::CreatedAt < PropertyMapper::Column
+    def build_insert_row(entity, table, row, id=nil)
+      row[@column_name] = Time.now if table == @table
+    end
+
+    def build_update_row(entity, table, row)
+    end
+
+    def post_insert(entity, rows, last_insert_id=nil)
+      entity[@property_name] = rows[@table][@column_name]
+    end
+  end
+end

data/lib/hold/sequel/property_mapper/custom_query.rb

@@ -0,0 +1,34 @@
+module Hold::Sequel
+  # A read-only mapper for array properties, which allows you to fetch the items via an arbitrary custom query
+  # against a target repository. You supply a block which takes the dataset and mapper arguments supplied by
+  # the repository's query_for_version method, but also an additional ID argument for the ID of the object
+  # for which the property is being fetched.
+  #
+  # example:
+  #  map_custom_query('foos') do |id, dataset, mapping|
+  #    dataset.join(:bar, ...).
+  #      ...
+  #      .filter(:boz_id => id)
+  #  end
+  class PropertyMapper::CustomQuery < PropertyMapper
+    def self.setter_dependencies_for(options={})
+      features = [*options[:model_class]].map {|klass| [:get_class, klass]}
+      {:target_repo => [IdentitySetRepository, *features]}
+    end
+
+    attr_reader :model_class
+    attr_accessor :target_repo
+
+    def initialize(repo, property_name, options={}, &block)
+      super(repo, property_name, &nil) # re &nil: our &block is otherwise implicitly passed on to super it seems, bit odd
+      @model_class = options[:model_class] or raise ArgumentError
+      @query_block = options[:query] || block
+    end
+
+    def load_value(row=nil, id=nil, version=nil)
+      target_repo.query(version) do |dataset, mapping|
+        @query_block.call(id, dataset, mapping)
+      end.to_a
+    end
+  end
+end

data/lib/hold/sequel/property_mapper/custom_query_single_value.rb

@@ -0,0 +1,36 @@
+module Hold::Sequel
+  # A read-only mapper for properties which are a single instance of a model class loaded from another repo.
+  #
+  # It allows you to fetch the item via an arbitrary custom query against the target repository.
+  #
+  # You supply a block which takes the dataset and mapper arguments supplied by the repository's query_for_version
+  # method, but also an additional ID argument for the ID of the object for which the property is being fetched.
+  #
+  # example:
+  #  map_custom_query_single_value('foo') do |id, dataset, mapping|
+  #    dataset.join(:bar, ...).
+  #      ...
+  #      .filter(:boz_id => id)
+  #  end
+  class PropertyMapper::CustomQuerySingleValue < PropertyMapper
+    def self.setter_dependencies_for(options={})
+      features = [*options[:model_class]].map {|klass| [:get_class, klass]}
+      {:target_repo => [IdentitySetRepository, *features]}
+    end
+
+    attr_reader :model_class
+    attr_accessor :target_repo
+
+    def initialize(repo, property_name, options={}, &block)
+      super(repo, property_name, &nil) # re &nil: our &block is otherwise implicitly passed on to super it seems, bit odd
+      @model_class = options[:model_class] or raise ArgumentError
+      @query_block = block
+    end
+
+    def load_value(row=nil, id=nil, version=nil)
+      target_repo.query(version) do |dataset, mapping|
+        @query_block.call(id, dataset, mapping)
+      end.single_result
+    end
+  end
+end