praxis-mapper 3.3 → 3.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6846f3a009fa64333abe3cb2ec246739bd51eac6
-  data.tar.gz: 9816dfbed93468cab708a9d7e62184d0ec8dd50b
+  metadata.gz: e7b9f2ce4f066cc2efacc2305788cb72c6e7b263
+  data.tar.gz: c1c76b006d57dac6e868e43109f37db79931b9b4
 SHA512:
-  metadata.gz: 4f60333005ce4fbe58804f91b3641d7e7dee4f82cabb0ae57b1dd910f6f3364a04ab1c2145764ec94c17d75621800be1f140050507dbb8040b4bca3758ece56d
-  data.tar.gz: de0d8e4d594f3059ff204d5b808454ae9c53df667cf2f2b4bb22be58235a7019a687daf910f36cbd5ed7c0bec54bd1f152e350540cd6c7a3816d6cefd843eb1c
+  metadata.gz: 5f4e0bc3f8e16c1b73a6268c5f73b4c57a692aefaa600f5113280b44f37c7543535be23717b90ca5e79c99e9fa7ade59e4205a829c1035ffd9f0b023409df882
+  data.tar.gz: ca517a3d90bbf750aacc028bd6a1b6f0ee22bb82c632a1777933ca68e2714a73f7e64311d337f975a7d4b02c1fe35fbca02a6eccc1bf182d8d716203027c6a79

data/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## next
 
+## 3.4.0
+
+* Add preliminary Sequel-centric `Query::Sequel` class that exposes a a Sequel dataset with an interface compatible with other `Query` types.
+* Removed `member_name` and `collection_name` methods from `Resource`, as well as the `type` alias.
+* Fixed `IdentityMap#load` to return the records from the identity map corresponding to rows returned from the database. This fixes a bug where loading rows already existing in the identity map would return new record objects rather than the objects in the map.
+
 ## 3.3.0
 
 * Tightened up handling of missing records in `IdentityMap#all` and `Resource.wrap`. They now will never return `nil` values.
@@ -9,7 +15,7 @@
 
 ## 3.2.0
 
-* Add `Resource.decorate` for extending/overriding methods on Resource associations. See `PersonResource` in [spec_resources.rb](spec/support/spec_resources.rb) for usage. 
+* Add `Resource.decorate` for extending/overriding methods on Resource associations. See `PersonResource` in [spec_resources.rb](spec/support/spec_resources.rb) for usage.
 
 ## 3.1.2
 
@@ -18,7 +24,7 @@
 
 ## 3.1
 
-* Begin migration to Sequel for `Query::Sql`. 
+* Begin migration to Sequel for `Query::Sql`.
   * `#_execute` uses it for a database-agnostic adapter for running raw SQL.
   * `#_multi_get` uses it generate a datbase-agnostic where clause
 * Added accessor generation for `one_to_many` associations in resources.
@@ -29,7 +35,7 @@
 * Added `Model#identities` to get a hash of identities and values for a record.
 * Auto-generated attribute accessors on `Blueprint` do not load (coerce) the value using the attribute. Ensure values passed in already have the appropriate types. Blueprint attributes will still be wrapped properly, however.
 * Performance and memory use optimizations.
-* `IdentityMap#load` now supports eagerly-loading associated records in a query, and supports the full set of options on the inner query, including 
+* `IdentityMap#load` now supports eagerly-loading associated records in a query, and supports the full set of options on the inner query, including
 * Tracked `:one_to_many` associations now support where clauses. Using `where` clauses when tracking other association types is not supported and will raise an exception.
 
 

data/lib/praxis-mapper.rb

@@ -55,6 +55,7 @@ require 'praxis-mapper/resource'
 
 require 'praxis-mapper/query/base'
 require 'praxis-mapper/query/sql'
+require 'praxis-mapper/query/sequel'
 
 
 require 'praxis-mapper/config_hash'

data/lib/praxis-mapper/identity_map.rb

@@ -107,6 +107,7 @@ module Praxis::Mapper
       @secondary_indexes =  Hash.new
     end
 
+
     def load(model, &block)
       raise "Can't load unfinalized model #{model}" unless model.finalized?
 
@@ -119,7 +120,7 @@ module Praxis::Mapper
       end
 
       records = query.execute
-      add_records(records)
+      im_records = add_records(records)
 
       # TODO: refactor this to better-hide queries?
       query.freeze
@@ -127,7 +128,7 @@ module Praxis::Mapper
 
       subload(model, query,records)
 
-      records
+      im_records
     end
 
     def stage_for!(spec, records)
@@ -164,11 +165,7 @@ module Praxis::Mapper
         new_query_class = @connection_manager.repository(associated_model.repository_name)[:query]
         new_query = new_query_class.new(self,associated_model, &block)
 
-        new_records = new_query.multi_get(key, values).collect do |row|
-          m = spec[:model].new(row)
-          m._query = new_query
-          m
-        end
+        new_records = new_query.multi_get(key, values)
 
         self.queries[associated_model].add(new_query)
 
@@ -239,7 +236,7 @@ module Praxis::Mapper
         non_identities.each do |key|
           values = @staged[model].delete(key)
 
-          rows = query.multi_get(key, values, select: model.identities)
+          rows = query.multi_get(key, values, select: model.identities, raw: true)
           rows.each do |row|
             model.identities.each do |identity|
               if identity.kind_of? Array
@@ -259,18 +256,12 @@ module Praxis::Mapper
         next if values.empty?
 
         query.where = nil # clear out any where clause from non-identity
-        records = query.multi_get(identity_name, values).collect do |row|
-          m = model.new(row)
-          m._query = query
-          m
-        end
-
-        add_records(records)
+        records = query.multi_get(identity_name, values)
 
         # TODO: refactor this to better-hide queries?
         self.queries[model].add(query)
 
-        results.merge(records)
+        results.merge(add_records(records))
 
         # add nil records for records that were not found by the multi_get
         missing_keys = self.get_staged(model,identity_name)
@@ -389,22 +380,6 @@ module Praxis::Mapper
       @connection_manager.checkout(name)
     end
 
-
-    def <<(record)
-      model = record.class
-
-      @rows[model] << record
-      record.identity_map = self
-
-      model.identities.each do |identity|
-        key = record.send(identity)
-
-        get_staged(model, identity).delete(key)
-        @row_keys[model][identity][key] = record
-      end
-    end
-
-
     def extract_keys(field, records)
       row_keys = []
       if field.kind_of?(Array) # composite identities
@@ -463,9 +438,7 @@ module Praxis::Mapper
 
 
     def add_records(records)
-      return if records.empty?
-
-      records_added = Array.new
+      return [] if records.empty? 
 
       to_stage = Hash.new do |hash,staged_model|
         hash[staged_model] = Hash.new do |identities, identity_name|
@@ -495,28 +468,30 @@ module Praxis::Mapper
 
       end
 
-      records.each do |record|
-        if add_record(record)
-          records_added << record
-        end
+      im_records = records.collect do |record|
+        add_record(record)
       end
 
       to_stage.each do |model_to_stage, data|
         stage(model_to_stage, data)
       end
 
-      records_added
+      im_records
     end
 
 
+    # return the record provided (if added to the identity map)
+    # or return the corresponding record if it was already present
     def add_record(record)
       model = record.class
       record.identities.each do |identity, key|
         # FIXME: Should we be overwriting (possibly) a "nil" value from before?
         #        (due to that row not being found by a previous query)
         #        (That'd be odd since that means we tried to load that same identity)
-
-        return false if @row_keys[model][identity].has_key? key
+        if (existing = @row_keys[model][identity][key])
+          # FIXME: should merge record into existing to add any additional fields
+          return existing
+        end
 
         get_staged(model, identity).delete(key)
         @row_keys[model][identity][key] = record
@@ -527,6 +502,8 @@ module Praxis::Mapper
       record
     end
 
+    alias_method :<<, :add_record
+
     def query_statistics
       QueryStatistics.new(queries)
     end

data/lib/praxis-mapper/model.rb

@@ -422,6 +422,10 @@ module Praxis::Mapper
       end
     end
 
+    def _data
+      @data
+    end
+
   end
 
 end

data/lib/praxis-mapper/query/base.rb

@@ -148,30 +148,34 @@ module Praxis::Mapper
       #
       # @param identity [Symbol|Array] a simple or composite key for this model
       # @param values [Array] list of identifier values (ideally a sorted set)
+      # @param select [Array] list of field names to select
+      # @param raw [Boolean] return raw hashes instead of models (default false)
       # @return [Array] list of matching records, wrapped as models
-      def multi_get(identity, values, select: nil)
+      def multi_get(identity, values, select: nil, raw: false)
         if self.frozen?
           raise TypeError.new "can not reuse a frozen query"
         end
 
         statistics[:multi_get] += 1
 
-        records = []
+        rows = []
 
         original_select = @select
         self.select *select.flatten.uniq if select
 
         values.each_slice(MULTI_GET_BATCH_SIZE) do |batch|
-          # create model objects for each row
-          records += _multi_get(identity, batch)
+          rows += _multi_get(identity, batch)
         end
 
-        statistics[:records_loaded] += records.size
-        records
+        statistics[:records_loaded] += rows.size
+
+        return rows if raw
+        to_records(rows)
       ensure
         @select = original_select unless self.frozen?
       end
 
+
       # Executes assembled read query and returns all matching records.
       #
       # @return [Array] list of matching records, wrapped as models
@@ -184,14 +188,17 @@ module Praxis::Mapper
         rows = _execute
 
         statistics[:records_loaded] += rows.size
-        rows.collect do |row|
+        to_records(rows)
+      end
+
+      def to_records(rows)
+         rows.collect do |row|
           m = model.new(row)
           m._query = self
           m
         end
       end
 
-
       # Subclasses Must Implement
       def _multi_get(identity, values)
         raise "subclass responsibility"

data/lib/praxis-mapper/query/sequel.rb

@@ -0,0 +1,100 @@
+require "set"
+
+module Praxis::Mapper
+  module Query
+
+    # Sequel-centric query class
+    class Sequel < Base
+
+
+      def initialize(identity_map, model, &block)
+        super
+      end
+
+      def dataset
+        ds = connection[model.table_name.to_sym]
+
+        # TODO: support column aliases
+        if @select
+          ds = ds.select(*@select.keys)
+        end
+
+        if @where
+          ds = ds.where(@where)
+        end
+
+        if @limit
+          ds = ds.limit(@limit)
+        end
+
+        ds
+      end
+
+      # Executes a 'SELECT' statement.
+      #
+      # @param identity [Symbol|Array] a simple or composite key for this model
+      # @param values [Array] list of identifier values (ideally a sorted set)
+      # @return [Array] SQL result set
+      #
+      # @example numeric key
+      #     _multi_get(:id, [1, 2])
+      # @example string key
+      #     _multi_get(:uid, ['foo', 'bar'])
+      # @example composite key (possibly a combination of numeric and string keys)
+      #     _multi_get([:cloud_id, :account_id], [['foo1', 'bar1'], ['foo2', 'bar2']])
+      def _multi_get(identity, values)
+        ds = self.dataset.where(identity => values)
+        _execute(ds)
+      end
+
+      # Executes this SQL statement.
+      # Does not perform any validation of the statement before execution.
+      #
+      # @return [Array] result-set
+      def _execute(ds=nil)
+        Praxis::Mapper.logger.debug "SQL:\n#{self.describe}\n"
+        self.statistics[:datastore_interactions] += 1
+        start_time = Time.now
+
+        rows = if @raw_query
+          unless ds.nil?
+            warn 'WARNING: Query::Sequel#_execute ignoring passed dataset due to previously-specified raw SQL'
+          end
+          connection.run(@raw_query).to_a
+        else
+          (ds || self.dataset).to_a
+        end
+
+        self.statistics[:datastore_interaction_time] += (Time.now - start_time)
+        return rows
+      end
+
+      # @see #sql
+      def describe
+        self.sql
+      end
+
+      # Constructs a raw SQL statement.
+      # No validation is performed here (security risk?).
+      #
+      # @param sql_text a custom SQL query
+      #
+      def raw(sql_text)
+        @raw_query = sql_text
+      end
+
+      # @return [String] raw or assembled SQL statement
+      def sql
+        if @raw_query
+          @raw_query
+        else
+          dataset.sql
+        end
+      end
+
+
+    end
+
+  end
+
+end

data/lib/praxis-mapper/query/sql.rb

@@ -75,6 +75,9 @@ module Praxis::Mapper
         self.statistics[:datastore_interactions] += 1
         start_time = Time.now
 
+        if @where && @raw_query
+          warn 'WARNING: Query::Sql#_execute ignoring requested `where` clause due to specified raw SQL'
+        end
         rows = connection.fetch(self.sql).to_a
 
         self.statistics[:datastore_interaction_time] += (Time.now - start_time)

data/lib/praxis-mapper/resource.rb

@@ -259,23 +259,5 @@ module Praxis::Mapper
       end
     end
 
-    def self.member_name
-      @_member_name ||= self.name.split("::").last.underscore
-    end
-
-    def self.collection_name
-      @_collection_name ||= self.member_name.pluralize
-    end
-
-    def member_name
-      self.class.member_name
-    end
-
-    alias :type :member_name
-
-    def collection_name
-      self.class.collection_name
-    end
-
   end
 end

data/lib/praxis-mapper/support/factory_girl.rb

@@ -4,10 +4,6 @@
 module Praxis::Mapper
   class Model
 
-    def _data
-      @data
-    end
-
     def save!
       @new_record = true
       unless Praxis::Mapper::IdentityMap.current.add_records([self]).include? self

data/lib/praxis-mapper/version.rb

@@ -1,5 +1,5 @@
 module Praxis
   module Mapper
-    VERSION = "3.3"
+    VERSION = "3.4.0"
   end
 end

data/spec/praxis-mapper/identity_map_spec.rb

@@ -14,6 +14,7 @@ describe Praxis::Mapper::IdentityMap do
                 {:id => 3, :name => "george xvi", :parent_id => 2, :description => "three"}
 
   ]}
+  let(:records) { rows.collect { |row| m = model.new(row); m._query = record_query; m } }
 
   let(:person_rows) {[
                        {id: 1, email: "one@example.com", address_id: 1, prior_address_ids:JSON.dump([2,3])},
@@ -23,7 +24,7 @@ describe Praxis::Mapper::IdentityMap do
                        {id: 5, email: "five@example.com", address_id: 3, prior_address_ids: nil}
 
   ]}
-
+  let(:person_records) { person_rows.collect { |row| m = PersonModel.new(row); m._query = record_query; m } }
   let(:address_rows) {[
                         {id: 1, owner_id: 1, state: 'OR'},
                         {id: 2, owner_id: 3, state: 'CA'},
@@ -108,6 +109,24 @@ describe Praxis::Mapper::IdentityMap do
 
     end
 
+
+    context 'loading a record that has previously been loaded' do
+      before do
+        identity_map.load PersonModel do
+          where id: 1
+        end
+      end
+
+      it 'returns the original object' do
+        existing_person = identity_map.get PersonModel, id: 1
+        people = identity_map.load PersonModel
+        people.find { |p| p.id == 1 }.should be(existing_person)
+
+        existing_people_ids = identity_map.all(PersonModel).collect(&:object_id)
+        people.collect(&:object_id).should =~ existing_people_ids
+      end
+    end
+
     context 'where :staged' do
       after do
         identity_map.load AddressModel do
@@ -267,39 +286,43 @@ describe Praxis::Mapper::IdentityMap do
 
 
   context "#finalize_model!" do
+    let(:record_query) { nil }
 
     context 'with values staged for a single identity' do
       let(:stage) { {:id => [1,2] } }
 
       before do
-        identity_map.stage(model, stage)
+        identity_map.stage(PersonModel, stage)
       end
 
       it "does a multi-get for the unloaded ids and returns the query results" do
         Praxis::Mapper::Support::MemoryQuery.any_instance.
           should_receive(:multi_get).
           with(:id, Set.new(stage[:id])).
-          and_return(rows[0..1])
+          and_return(person_records[0..1])
         Praxis::Mapper::Support::MemoryQuery.any_instance.should_receive(:freeze)
 
-        identity_map.finalize_model!(model).collect(&:id).should =~ rows[0..1].collect { |r| r[:id] }
+        identity_map.finalize_model!(PersonModel).collect(&:id).should =~ person_rows[0..1].collect { |r| r[:id] }
       end
 
       context 'tracking associations' do
-        let(:track) { :parent }
+        let(:query) do
+           Praxis::Mapper::Support::MemoryQuery.new(identity_map,PersonModel) do
+            track :address
+          end
+        end
+        let(:record_query) { query }
 
-        it 'sets the track attribute on the generated query' do
-          Praxis::Mapper::Support::MemoryQuery.any_instance.should_receive(:multi_get).with(:id, Set.new(stage[:id])).and_return(rows[0..1])
-          Praxis::Mapper::Support::MemoryQuery.any_instance.should_receive(:track).with(track).at_least(:once).and_call_original
-          Praxis::Mapper::Support::MemoryQuery.any_instance.should_receive(:track).at_least(:once).and_call_original
-          Praxis::Mapper::Support::MemoryQuery.any_instance.should_receive(:freeze)
+        it 'stages asssociated identities' do
+          query.should_receive(:multi_get).with(:id, Set.new(stage[:id])).and_return(person_records[0..1])
+          query.should_receive(:freeze)
 
-          track_field = track
-          query = Praxis::Mapper::Support::MemoryQuery.new(identity_map,model) do
-            track track_field
-          end
+          identity_map.all(PersonModel).should be_empty
+
+          identity_map.finalize_model!(PersonModel, query)
 
-          identity_map.finalize_model!(model, query)
+          identity_map.all(PersonModel).should =~ person_records[0..1]
+          identity_map.get_staged(AddressModel, :id).should eq(Set[*person_records[0..1].collect(&:address_id)])
         end
       end
 
@@ -317,8 +340,8 @@ describe Praxis::Mapper::IdentityMap do
         query = Praxis::Mapper::Support::MemoryQuery.new(identity_map, model)
         Praxis::Mapper::Support::MemoryQuery.stub(:new).and_return(query)
 
-        query.should_receive(:multi_get).with(:id, Set.new(stage[:id])).and_return(rows[0..1])
-        query.should_receive(:multi_get).with(:name, Set.new(['george xvi'])).and_return([rows[2]])
+        query.should_receive(:multi_get).with(:id, Set.new(stage[:id])).and_return(records[0..1])
+        query.should_receive(:multi_get).with(:name, Set.new(['george xvi'])).and_return([records[2]])
         query.should_receive(:freeze).once
 
         expected = rows.collect { |r| r[:id] }
@@ -335,7 +358,7 @@ describe Praxis::Mapper::IdentityMap do
       before do
         identity_map.stage(model, stage)
 
-        Praxis::Mapper::Support::MemoryQuery.any_instance.should_receive(:multi_get).with(:id, Set.new(stage[:id])).and_return(rows[0..1])
+        Praxis::Mapper::Support::MemoryQuery.any_instance.should_receive(:multi_get).with(:id, Set.new(stage[:id])).and_return(records[0..1])
         Praxis::Mapper::Support::MemoryQuery.any_instance.should_receive(:freeze)
       end
 
@@ -362,9 +385,9 @@ describe Praxis::Mapper::IdentityMap do
         Praxis::Mapper::Support::MemoryQuery.stub(:new).and_return(query)
 
         query.should_receive(:multi_get).
-          with(:owner_id, Set.new(stage[:owner_id]), select: [:id]).ordered.and_return(owner_id_response)
+          with(:owner_id, Set.new(stage[:owner_id]), select: [:id], raw: true).ordered.and_return(owner_id_response)
         query.should_receive(:multi_get).
-          with(:id, Set.new(stage[:id])).ordered.and_return(person_rows)
+          with(:id, Set.new(stage[:id])).ordered.and_return(person_records)
 
         query.should_receive(:freeze)
       end
@@ -558,6 +581,25 @@ describe Praxis::Mapper::IdentityMap do
 
   context "#add_records" do
 
+    context 'with records already existing in the identity_map' do
+
+      before do
+        identity_map.load PersonModel
+      end
+
+      it 'returns the existing records instead of the ones passed in' do
+        person_row = person_rows.first
+        person_record = PersonModel.new(person_row)
+
+        existing_person = identity_map.get(PersonModel, id: person_record.id )
+
+        add_result = identity_map.add_records([person_record])
+
+        add_result.first.should be(existing_person)
+        add_result.first.should_not be(person_record)
+      end
+    end
+
 
     context "with a tracked many_to_one association " do
       before do
@@ -784,14 +826,6 @@ describe Praxis::Mapper::IdentityMap do
     end
 
     context '#row_by_key' do
-      let(:stage) { {:id => [1,2,3,4]} }
-      before do
-        Praxis::Mapper::Support::MemoryQuery.any_instance.should_receive(:multi_get).with(:id, Set.new(stage[:id])).and_return(rows)
-        Praxis::Mapper::Support::MemoryQuery.any_instance.should_receive(:freeze)
-        identity_map.stage(model,stage)
-        identity_map.finalize_model!(model)
-      end
-
       it 'raises UnloadedRecordException for unknown records' do
         expect { identity_map.row_by_key(model,:id, 5) }.to raise_error(Praxis::Mapper::IdentityMap::UnloadedRecordException)
       end

data/spec/praxis-mapper/query/base_spec.rb

@@ -28,17 +28,14 @@ describe Praxis::Mapper::Query::Base do
 
       it 'delegates to the subclass' do
         query.should_receive(:_multi_get).and_return(rows)
-        response = query.multi_get(:id, ids)
 
-        response.should have(3).items
+        records = query.multi_get(:id, ids)
 
-        response.should eq(rows)
-        #record = response.first
-        #record.should be_kind_of(model)
+        records.should have(3).items
 
-        #rows.first.each do |attribute, value|
-        #  record.send(attribute).should == value
-        #end
+        records.zip(rows).each do |record, row|
+          record._data.should be(row)
+        end
 
       end
 
@@ -53,7 +50,7 @@ describe Praxis::Mapper::Query::Base do
 
         let(:result_size) { (batch_size * 2.5).to_i }
 
-        let(:values) { (0..result_size).to_a }
+        let(:values) { (0...result_size).to_a }
         let(:rows) { values.collect { |v| {:id => v} } }
 
         before do
@@ -66,7 +63,11 @@ describe Praxis::Mapper::Query::Base do
         end
 
         it 'batches queries and aggregates their results' do # FIXME: totally lame name for this
-          query.multi_get(:id, values).should =~ rows
+          records = query.multi_get(:id, values)
+          records.size.should eq(result_size)
+          records.zip(rows) do |record,row|
+            record._data.should be(row)
+          end
         end
       end
     end

data/spec/praxis-mapper/query/sequel_spec.rb

@@ -0,0 +1,70 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Praxis::Mapper::Query::Sequel do
+  let(:scope) { {} }
+  let(:identity_map) { Praxis::Mapper::IdentityMap.setup!(scope) }
+  let(:connection) { identity_map.connection(:sql) }
+
+  context "without a query body" do
+    subject { Praxis::Mapper::Query::Sequel.new(identity_map, ItemModel) }
+
+    its(:sql) { should eq("SELECT * FROM items") }
+  end
+
+  subject(:query) do
+    Praxis::Mapper::Query::Sequel.new(identity_map, ItemModel) do
+      select :id
+      select :name
+      where name: 'something'
+      limit 10
+    end
+  end
+
+
+  its(:select) { should eq({:id=>nil, :name=>nil}) }
+  its(:where) { should eq({name: 'something'}) }
+  its(:limit) { should eq(10) }
+
+  its(:sql) { should eq("SELECT id, name FROM items WHERE (name = 'something') LIMIT 10")}
+
+  context 'multi_get' do
+    it 'runs the correct sql' do
+      connection.sqls.should be_empty
+      query.multi_get(:id, [1,2])
+      connection.sqls.should eq(["SELECT id, name FROM items WHERE ((name = 'something') AND (id IN (1, 2))) LIMIT 10"])
+    end
+  end
+
+  context 'execute' do
+    it 'runs the correct sql' do
+      connection.sqls.should be_empty
+      query.execute
+      connection.sqls.should eq(["SELECT id, name FROM items WHERE (name = 'something') LIMIT 10"])
+    end
+  end
+
+
+  context 'with raw sql queries' do
+    subject(:query) do
+      Praxis::Mapper::Query::Sequel.new(identity_map, ItemModel) do
+        raw 'select something from somewhere limit a-few'
+      end
+    end
+
+    its(:sql) { should eq('select something from somewhere limit a-few') }
+    it 'uses the raw query when executed' do
+      connection.sqls.should be_empty
+      query.execute
+      connection.sqls.should eq(["select something from somewhere limit a-few"])
+    end
+
+    it 'warns in _execute if a dataset is passed' do
+      connection.sqls.should be_empty
+      query.should_receive(:warn).with("WARNING: Query::Sequel#_execute ignoring passed dataset due to previously-specified raw SQL")
+      query._execute(query.dataset)
+      connection.sqls.should eq(["select something from somewhere limit a-few"])
+    end
+
+  end
+
+end

data/spec/praxis-mapper/query/sql_spec.rb

@@ -48,6 +48,7 @@ describe Praxis::Mapper::Query::Sql do
     it 'uses the exact raw query for the final SQL statement' do
       subject.sql.should eq("SELECT id, parent_id\nFROM table\nWHERE id=123\nGROUP BY id")
     end
+
   end
 
 
@@ -156,7 +157,7 @@ describe Praxis::Mapper::Query::Sql do
                    {:id => 3, :name => "snafu", :parent_id => 3}
     ] }
 
-    subject { Praxis::Mapper::Query::Sql.new(identity_map, SimpleModel) }
+    subject(:query) { Praxis::Mapper::Query::Sql.new(identity_map, SimpleModel) }
     before do
       connection.should_receive(:fetch).and_return(rows)
       identity_map.should_receive(:connection).with(:default).and_return(connection)
@@ -166,18 +167,25 @@ describe Praxis::Mapper::Query::Sql do
     end
 
     it 'wraps database results in SimpleModel instances' do
-      records = subject.execute
+      records = query.execute
       records.each { |record| record.should be_kind_of(SimpleModel) }
     end
 
     it "tracks datastore interactions" do
-      subject.execute
-      subject.statistics[:datastore_interactions].should == 1
+      query.execute
+      query.statistics[:datastore_interactions].should == 1
     end
 
     it 'times datastore interactions' do
-      subject.execute
-      subject.statistics[:datastore_interaction_time].should == 10
+      query.execute
+      query.statistics[:datastore_interaction_time].should == 10
+    end
+
+    it 'warns when if a where clause and raw sql are used together' do
+      query.should_receive(:warn).with("WARNING: Query::Sql#_execute ignoring requested `where` clause due to specified raw SQL")
+      query.where 'id=1'
+      query.raw 'select * from stuff'
+      query.execute
     end
 
   end

data/spec/praxis-mapper/resource_spec.rb

@@ -17,8 +17,6 @@ describe Praxis::Mapper::Resource do
   context 'configuration' do
     subject { SimpleResource }
     its(:model) { should == model }
-    its(:member_name) { should == 'simple_resource' }
-    its(:collection_name) { should == 'simple_resources' }
   end
 
   context 'retrieving resources' do

data/spec/support/spec_models.rb

@@ -129,7 +129,7 @@ class PersonModel < Praxis::Mapper::Model
     model AddressModel
     key :address_id # people.address_id
   end
-               
+
   one_to_many :properties do
     model AddressModel
     primary_key :id #people.id
@@ -206,10 +206,31 @@ class AddressModel  < Praxis::Mapper::Model
 
 end
 
+
+
 class ItemModel < Praxis::Mapper::Model
   table_name 'items'
   repository_name :sql
-  
+
+  identity :id
+
+  one_to_many :parts do
+    model PartModel
+    key :item_id # parts.item_id
+  end
+
+end
+
+
+class PartModel < Praxis::Mapper::Model
+  table_name 'parts'
+  repository_name :sql
+
   identity :id
 
-end
+  many_to_one :item do
+    model ItemModel
+    key :item_id # parts.item_id
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: praxis-mapper
 version: !ruby/object:Gem::Version
-  version: '3.3'
+  version: 3.4.0
 platform: ruby
 authors:
 - Josep M. Blanquer
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-11 00:00:00.000000000 Z
+date: 2015-04-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: randexp
@@ -232,6 +232,7 @@ files:
 - lib/praxis-mapper/logging.rb
 - lib/praxis-mapper/model.rb
 - lib/praxis-mapper/query/base.rb
+- lib/praxis-mapper/query/sequel.rb
 - lib/praxis-mapper/query/sql.rb
 - lib/praxis-mapper/query_statistics.rb
 - lib/praxis-mapper/resource.rb
@@ -249,6 +250,7 @@ files:
 - spec/praxis-mapper/memory_repository_spec.rb
 - spec/praxis-mapper/model_spec.rb
 - spec/praxis-mapper/query/base_spec.rb
+- spec/praxis-mapper/query/sequel_spec.rb
 - spec/praxis-mapper/query/sql_spec.rb
 - spec/praxis-mapper/resource_spec.rb
 - spec/praxis_mapper_spec.rb
@@ -287,6 +289,7 @@ test_files:
 - spec/praxis-mapper/memory_repository_spec.rb
 - spec/praxis-mapper/model_spec.rb
 - spec/praxis-mapper/query/base_spec.rb
+- spec/praxis-mapper/query/sequel_spec.rb
 - spec/praxis-mapper/query/sql_spec.rb
 - spec/praxis-mapper/resource_spec.rb
 - spec/praxis_mapper_spec.rb