dm-adapter-simpledb 1.3.0 → 1.4.0

data/spec/integration/spec_helper.rb

@@ -4,6 +4,7 @@ $LOAD_PATH.unshift(File.join(ROOT,'lib'))
 require 'simpledb_adapter'
 require 'logger'
 require 'fileutils'
+require 'right_aws'
 require 'spec'
 require 'spec/autorun'
 

data/spec/unit/dm_adapter_simpledb/where_expression_spec.rb

@@ -0,0 +1,368 @@
+require File.expand_path('../unit_spec_helper', File.dirname(__FILE__))
+require 'dm-adapter-simpledb/where_expression'
+
+module DmAdapterSimpledb
+  include DataMapper::Query::Conditions
+
+  describe WhereExpression do
+    include DataMapper
+
+    class Post
+      include DataMapper::Resource
+      
+      property :id,    Serial
+      property :title, String
+      property :body,  Text
+    end
+
+    context "given a basic equality query" do
+      before :each do
+        @conditions = Operation.new(
+          :and,
+          Comparison.new(:eql, Post.properties[:title], "FOO"))
+        @it = WhereExpression.new(@conditions)
+      end
+
+      specify { @it.to_s.should == 'title = "FOO"' }
+
+      it "should have no unsupported conditions" do
+        @it.unsupported_conditions.should be == Operation.new(:and)
+      end
+    end
+
+    context "given a basic inequality query" do
+      before :each do
+        @conditions = Operation.new(
+          :and,
+          Operation.new(:not,
+            Comparison.new(:eql, Post.properties[:title], "FOO")))
+        @it = WhereExpression.new(@conditions)
+      end
+
+      specify { @it.to_s.should == 'title != "FOO"' }
+    end
+
+    context "given a greater-than query" do
+      before :each do
+        @conditions = Operation.new(
+          :and,
+          Comparison.new(:gt, Post.properties[:title], "FOO"))
+        @it = WhereExpression.new(@conditions)
+      end
+
+      specify { @it.to_s.should == 'title > "FOO"' }
+    end
+
+    context "given a lesser-than query" do
+      before :each do
+        @conditions = Operation.new(
+          :and,
+          Comparison.new(:lt, Post.properties[:title], "FOO"))
+        @it = WhereExpression.new(@conditions)
+      end
+
+      specify { @it.to_s.should == 'title < "FOO"' }
+    end
+
+    context "given a equal-or-greater-than query" do
+      before :each do
+        @conditions = Operation.new(
+          :and,
+          Comparison.new(:gte, Post.properties[:title], "FOO"))
+        @it = WhereExpression.new(@conditions)
+      end
+
+      specify { @it.to_s.should == 'title >= "FOO"' }
+    end
+
+    context "given an equal-to-or-lesser-than query" do
+      before :each do
+        @conditions = Operation.new(
+          :and,
+          Comparison.new(:lte, Post.properties[:title], "FOO"))
+        @it = WhereExpression.new(@conditions)
+      end
+
+      specify { @it.to_s.should == 'title <= "FOO"' }
+    end
+
+    context "given a LIKE query" do
+      before :each do
+        @conditions = Operation.new(
+          :and,
+          Comparison.new(:like, Post.properties[:title], "%FOO%"))
+        @it = WhereExpression.new(@conditions)
+      end
+
+      specify { @it.to_s.should == 'title LIKE "%FOO%"' }
+    end
+
+    context "given an IN query" do
+      before :each do
+        @conditions = Operation.new(
+          :and,
+          Comparison.new(:in, Post.properties[:title], ["FOO", "BAZ"]))
+        @it = WhereExpression.new(@conditions)
+      end
+
+      specify { @it.to_s.should == 'title IN ("FOO", "BAZ")' }
+    end
+
+    context "given an IN query with an empty list" do
+      before :each do
+        @conditions = Operation.new(
+          :and,
+          Comparison.new(:in, Post.properties[:title], []))
+        @it = WhereExpression.new(@conditions)
+      end
+
+      specify { @it.to_s.should == 'title IS NULL' }
+    end
+
+    context "given a negated IN query with an empty list" do
+      before :each do
+        @conditions = Operation.new(
+          :and,
+          Comparison.new(:eql, Post.properties[:title], "FOO"),
+          Operation.new(:not,
+            Comparison.new(:in, Post.properties[:title], [])))
+        @it = WhereExpression.new(@conditions)
+      end
+
+      specify { @it.to_s.should == 'title = "FOO"' }
+    end
+
+    context "given an empty IN query OR another IN query" do
+      before :each do
+        @conditions = Operation.new(
+          :or,
+          Comparison.new(:in, Post.properties[:body], []),
+          Comparison.new(:in, Post.properties[:title], ["foo"]))
+        @it = WhereExpression.new(@conditions)
+      end
+
+      specify { @it.to_s.should == 'body IS NULL OR title IN ("foo")' }
+    end
+
+    context "given an IN query with a range" do
+      before :each do
+        @conditions = Operation.new(
+          :and,
+          Comparison.new(:in, Post.properties[:title], ("A".."Z")))
+        @it = WhereExpression.new(@conditions)
+      end
+
+      specify { @it.to_s.should == 'title BETWEEN "A" AND "Z"' }
+    end
+
+    context "given an IN query with an exclusive range" do
+      before :each do
+        pending "Implementationm of exclusive ranges"
+        @conditions = Operation.new(
+          :and,
+          Comparison.new(:in, Post.properties[:title], ("A"..."Z")),
+          Comparison.new(:eql, Post.properties[:body], 42))
+        @it = WhereExpression.new(@conditions)
+      end
+
+      specify { @it.to_s.should == 'body = "42" AND title BETWEEN "A" AND "Z"' }
+
+      it "should include the range in unsupported conditions" do
+        @it.unsupported_conditions.should be ==
+          Operation.new(:and,
+            Comparison.new(:in, Post.properties[:title], ("A"..."Z")))
+      end
+    end
+
+    context "given a negated IN query with an exclusive range" do
+      before :each do
+        pending "Implementationm of exclusive ranges"
+        @conditions = Operation.new(
+          :and,
+          Operation.new(:not,
+            Comparison.new(:in, Post.properties[:title], (1...5))))
+        @it = WhereExpression.new(@conditions)
+      end
+
+      specify { @it.to_s.should == 'NOT title BETWEEN "1" AND "5"' }
+
+      it "should include the range in unsupported conditions" do
+        @it.unsupported_conditions.should be ==
+          Operation.new(:and,
+            Operation.new(:not,
+              Comparison.new(:in, Post.properties[:title], (1...5))))
+        @it.unsupported_conditions.operands.first.operands.first.value.should be == (1...5)
+      end
+    end
+
+    context "given a comparison to nil" do
+      before :each do
+        @conditions = Operation.new(
+          :and,
+          Comparison.new(:eql, Post.properties[:title], nil))
+        @it = WhereExpression.new(@conditions)
+      end
+
+      specify { @it.to_s.should == 'title IS NULL' }
+    end
+
+    context "given a negated comparison to nil" do
+      before :each do
+        @conditions = Operation.new(
+          :and,
+          Operation.new(:not,
+            Comparison.new(:eql, Post.properties[:title], nil)))
+        @it = WhereExpression.new(@conditions)
+      end
+
+      specify { @it.to_s.should == 'title IS NOT NULL' }
+    end
+
+    context "given a regexp comparison" do
+      before :each do
+        @conditions = Operation.new(
+          :and,
+          Comparison.new(:regexp, Post.properties[:title], /foo/),
+          Comparison.new(:eql, Post.properties[:body], "bar"))
+        @it = WhereExpression.new(@conditions)
+      end
+
+      specify { @it.to_s.should == 'body = "bar"' }
+
+      it "should include the regexp comparison in unsupported conds" do
+        @it.unsupported_conditions.should be == 
+          Operation.new(:and,
+            Comparison.new(:regexp, Post.properties[:title], /foo/))
+      end
+    end
+
+    context "given a literal expression with replacements" do
+      before :each do
+        @conditions = Operation.new(
+          :and,
+          ["body in (?, ?)", "FUZ", "BUZ"])
+        @it = WhereExpression.new(@conditions)
+      end
+
+      specify { @it.to_s.should == 'body in ("FUZ", "BUZ")' }
+    end
+
+    context "given a literal expression with subarray of replacements" do
+      before :each do
+        @conditions = Operation.new(
+          :and,
+          ["body in (?, ?)", ["FUZ", "BUZ"]])
+        @it = WhereExpression.new(@conditions)
+      end
+
+      specify { @it.to_s.should == 'body in ("FUZ", "BUZ")' }
+    end
+
+    context "given a literal expression" do
+      before :each do
+        @conditions = Operation.new(
+          :and,
+          ["body like '%frotz%'"])
+        @it = WhereExpression.new(@conditions)
+      end
+
+      specify { @it.to_s.should == "body like '%frotz%'" }
+    end
+
+    context "given a literal expression with a hash of replacements" do
+      before :each do
+        @conditions = Operation.new(
+          :and,
+          ["title = :title and body = :body", 
+            {
+              :title => "foo", :body => "bar"
+            }
+          ])
+        @it = WhereExpression.new(@conditions)
+      end
+
+      specify { @it.to_s.should == 'title = "foo" and body = "bar"' }
+    end
+
+    context "given a two ANDed comparisons" do
+      before :each do
+        @conditions = Operation.new(
+          :and,
+          Comparison.new(:eql, Post.properties[:title], "FOO"),
+          Comparison.new(:eql, Post.properties[:body],  "BAR"))
+        @it = WhereExpression.new(@conditions)
+      end
+
+      specify { @it.to_s.should == 'body = "BAR" AND title = "FOO"' }
+    end
+
+    context "given an OR nested in an AND comparisons" do
+      before :each do
+        @conditions = Operation.new(
+          :and,
+          Comparison.new(:eql, Post.properties[:title], "FOO"),
+          Operation.new(:or,
+            Comparison.new(:eql, Post.properties[:body],  "BAR"),
+            Comparison.new(:eql, Post.properties[:body],  "BAZ")))
+        @it = WhereExpression.new(@conditions)
+      end
+
+      specify { 
+        @it.to_s.should == '( body = "BAR" OR body = "BAZ" ) AND title = "FOO"'
+      }
+    end
+
+    context "given a two ORed comparisons" do
+      before :each do
+        @conditions = Operation.new(
+          :or,
+          Comparison.new(:eql, Post.properties[:title], "FOO"),
+          Comparison.new(:eql, Post.properties[:body],  "BAR"))
+        @it = WhereExpression.new(@conditions)
+      end
+
+      specify { @it.to_s.should == 'body = "BAR" OR title = "FOO"' }
+    end
+
+    context "given an intersection" do
+      before :each do
+        @conditions = Operation.new(
+          :or,
+          Comparison.new(:eql, Post.properties[:title], "FOO"),
+          Comparison.new(:eql, Post.properties[:body],  "BAR"))
+        @it = WhereExpression.new(@conditions)
+      end
+
+      specify { @it.to_s.should == 'body = "BAR" OR title = "FOO"' }
+    end
+
+    context "given a negated AND comparison" do
+      before :each do
+        @conditions = Operation.new(
+          :and,
+          Operation.new(:not,
+            Operation.new(:and,
+              Comparison.new(:eql, Post.properties[:title], "FOO"),
+              Comparison.new(:eql, Post.properties[:body],  "BAR"))))
+        @it = WhereExpression.new(@conditions)
+      end
+
+      specify { @it.to_s.should == 'NOT ( body = "BAR" AND title = "FOO" )' }
+    end
+
+    context "given individually negated equality comparisons" do
+      before :each do
+        @conditions = Operation.new(
+          :and,
+          Operation.new(:not,
+              Comparison.new(:eql, Post.properties[:title], "FOO")),
+          Operation.new(:not,
+              Comparison.new(:eql, Post.properties[:body],  "BAR")))
+        @it = WhereExpression.new(@conditions)
+      end
+
+      specify { @it.to_s.should == 'body != "BAR" AND title != "FOO"' }
+    end
+
+  end
+end

data/spec/unit/simpledb_adapter_spec.rb

@@ -21,8 +21,9 @@ describe DataMapper::Adapters::SimpleDBAdapter do
         anything,
         hash_including(
           'simpledb_type' => ["products"], 
-          'stock'         => ["3"], 
-          'name'          => ["War and Peace"]))
+          'stock'         => ["3"],
+          'name'          => ["War and Peace"]),
+        :replace)
       @record.save
     end
   end

data/spec/unit/unit_spec_helper.rb

@@ -1,6 +1,7 @@
 require 'spec'
 ROOT = File.expand_path('../..', File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(ROOT,'lib'))
+require 'right_aws'
 require 'simpledb_adapter'
 
 Spec::Runner.configure do |config|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: dm-adapter-simpledb
 version: !ruby/object:Gem::Version 
-  version: 1.3.0
+  version: 1.4.0
 platform: ruby
 authors: 
 - Jeremy Boles
@@ -13,7 +13,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-19 00:00:00 -05:00
+date: 2010-01-24 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -74,13 +74,12 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        version: "0.2"
+        version: "0.4"
     version: 
 description: |
   A DataMapper adapter for Amazon's SimpleDB service. 
   
   Features:
-   * Uses the RightAWS gem for efficient SimpleDB operations.
    * Full set of CRUD operations
    * Supports all DataMapper query predicates.
    * Can translate many queries into efficient native SELECT operations.
@@ -119,8 +118,12 @@ files:
 - lib/dm-adapter-simpledb/sdb_array.rb
 - lib/dm-adapter-simpledb/table.rb
 - lib/dm-adapter-simpledb/utils.rb
+- lib/dm-adapter-simpledb/where_expression.rb
 - lib/simpledb_adapter.rb
+- scripts/console
+- scripts/limits_benchmark
 - scripts/simple_benchmark.rb
+- scripts/union_benchmark
 - spec/integration/associations_spec.rb
 - spec/integration/compliance_spec.rb
 - spec/integration/date_spec.rb
@@ -132,6 +135,7 @@ files:
 - spec/integration/simpledb_adapter_spec.rb
 - spec/integration/spec_helper.rb
 - spec/spec.opts
+- spec/unit/dm_adapter_simpledb/where_expression_spec.rb
 - spec/unit/record_spec.rb
 - spec/unit/simpledb_adapter_spec.rb
 - spec/unit/unit_spec_helper.rb
@@ -174,6 +178,7 @@ test_files:
 - spec/integration/spec_helper.rb
 - spec/integration/multiple_records_spec.rb
 - spec/integration/associations_spec.rb
+- spec/unit/dm_adapter_simpledb/where_expression_spec.rb
 - spec/unit/simpledb_adapter_spec.rb
 - spec/unit/unit_spec_helper.rb
 - spec/unit/record_spec.rb