dm-datastore-adapter 0.1.0 → 0.2.1

data/Rakefile

@@ -5,7 +5,7 @@ require 'merb-core'
 require 'merb-core/tasks/merb'
 
 GEM_NAME = "dm-datastore-adapter"
-GEM_VERSION = "0.1.0"
+GEM_VERSION = "0.2.1"
 AUTHOR = "Genki Takiuchi"
 EMAIL = "genki@s21g.com"
 HOMEPAGE = "http://jmerbist.appspot.com/"

data/lib/dm-datastore-adapter/datastore-adapter.rb

@@ -5,6 +5,8 @@ require 'appengine-api-1.0-sdk-1.2.0.jar'
 module DataMapper
   module Adapters
     class DataStoreAdapter < AbstractAdapter
+      class InvalidConditionError < StandardError; end
+
       module DS
         unless const_defined?("Service")
           import com.google.appengine.api.datastore.DatastoreServiceFactory
@@ -24,18 +26,18 @@ module DataMapper
         resources.each do |resource|
           entity = DS::Entity.new(resource.class.name)
           resource.attributes.each do |key, value|
-            ds_set(entity, key, value)
+            ds_set(entity, resource.model.properties[key], value)
           end
           begin
-            ds_key = DS::Service.put(entity)
+            ds_key = ds_service_put(entity)
           rescue Exception
           else
             ds_id = ds_key.get_id
             resource.model.key.each do |property|
               resource.attribute_set property.field, ds_id
-              ds_set(entity, property.field, ds_id)
+              ds_set(entity, property, ds_id)
             end
-            DS::Service.put(entity)
+            ds_service_put(entity)
             created += 1
           end
         end
@@ -46,12 +48,12 @@ module DataMapper
         updated = 0
         resources = read_many(query)
         resources.each do |resource|
-          entity = DS::Service.get(ds_key_from_resource(resource))
-          resource.attributes.each do |key, value|
-            ds_set(entity, key, value)
+          entity = ds_service_get(ds_key_from_resource(resource))
+          attributes.each do |property, value|
+            ds_set(entity, property, value)
           end
           begin
-            ds_key = DS::Service.put(entity)
+            ds_key = ds_service_put(entity)
           rescue Exception
           else
             resource.model.key.each do |property|
@@ -64,39 +66,56 @@ module DataMapper
       end
 
       def delete(query)
-        deleted = 0
         resources = read_many(query)
-        resources.each do |resource|
+        ds_keys = resources.map do |resource|
           begin
-            ds_key = ds_key_from_resource(resource)
-            DS::Service.delete([ds_key].to_java(DS::Key))
+            ds_key_from_resource(resource)
           rescue Exception
-          else
-            deleted += 1
+            nil
           end
-        end
-        deleted
+        end.compact
+        ds_service_delete(ds_keys.to_java(DS::Key))
+        ds_keys.size
+      rescue Exception
+        0
       end
 
       def read_many(query)
-        q = build_query(query)
-        fo = build_fetch_option(query)
-        iter = if fo
-          DS::Service.prepare(q).as_iterable(fo)
-        else
-          DS::Service.prepare(q).as_iterable
-        end
         Collection.new(query) do |collection|
-          iter.each do |entity|
-            collection.load(query.fields.map do |property|
-              property.key? ? entity.key.get_id : ds_get(entity, property.field)
-            end)
+          loop do
+            negas, posis = {}, {}
+            q = build_query(query) do |op, property, value|
+              negas[property] = value if op == :not
+              posis[property] = value if op == :eql
+            end
+            fo = build_fetch_option(query)
+            iter = if fo
+              DS::Service.prepare(q).as_iterable(fo)
+            else
+              DS::Service.prepare(q).as_iterable
+            end
+            iter.each do |entity|
+              next if negative?(entity, negas)
+              collection.load(query.fields.map do |property|
+                property.key? ?
+                  entity.key.get_id : ds_get(entity, property.field)
+              end)
+            end
+            break if posis.empty?
+            query = assert_query(query, posis)
           end
         end
       end
 
       def read_one(query)
-        q = build_query(query)
+        negas = {}
+        q = build_query(query) do |op, property, value|
+          negas[property] = value if op == :not
+          if op == :eql
+            raise InvalidConditionError,
+              "OR condition is not afflowed for read_one"
+          end
+        end
         fo = build_fetch_option(query)
         entity = if fo
           DS::Service.prepare(q).as_iterable(fo).map{|i| break i}
@@ -104,6 +123,7 @@ module DataMapper
           DS::Service.prepare(q).asSingleEntity
         end
         return nil if entity.blank?
+        return nil if negative?(entity, negas)
         query.model.load(query.fields.map do |property|
           property.key? ? entity.key.get_id : ds_get(entity, property.field)
         end, query)
@@ -122,9 +142,22 @@ module DataMapper
       end
 
       def count(query)
-        q = build_query(query)
-        count = DS::Service.prepare(q).countEntities
-        [query.limit ? [count, query.limit].min : count]
+        result, limit = 0, query.limit
+        loop do
+          negas, posis = {}, {}
+          q = build_query(query) do |op, property, value|
+            negas[property] = value if op == :not
+            posis[property] = value if op == :eql
+          end
+          result += DS::Service.prepare(q).countEntities
+          unless negas.empty?
+            result -= count(negate_query(query, negas)).first
+          end
+          break if posis.empty?
+          break if limit && result >= limit
+          query = assert_query(query, posis)
+        end
+        [limit ? [result, limit].min : result]
       end
 
     protected
@@ -156,9 +189,18 @@ module DataMapper
           when :gte;  DS::Query::FilterOperator::GREATER_THAN_OR_EQUAL
           when :lt;   DS::Query::FilterOperator::LESS_THAN
           when :lte;  DS::Query::FilterOperator::LESS_THAN_OR_EQUAL
+          when :not;  yield(:not, property, value); next
           else next
           end
-          q = q.add_filter(property.name.to_s, ds_op, [value].flatten.first)
+          if value.is_a?(Array)
+            if op != :eql
+              raise InvalidConditionError,
+                "OR condition is allowed only for :eql operator"
+            end
+            value[1..-1].each{|v| yield(:eql, property, v)}
+            value = value.first
+          end
+          q = q.add_filter(property.field, ds_op, value)
         end
         query.order.each do |o|
           key = o.property.name.to_s
@@ -196,12 +238,77 @@ module DataMapper
         end
       end
 
-      def ds_set(entity, name, value)
+      def ds_set(entity, property, value)
+        name = property.field.to_s
+        case value
+        when DateTime
+          value = value.to_time
+        end
         if value.is_a?(String) && value.length >= 500
-          entity.set_property(name.to_s, DS::Text.new(value))
+          entity.set_property(name, DS::Text.new(value))
+        else
+          entity.set_property(name, value)
+        end
+      end
+
+      def ds_service_get(ds_key)
+        if tx = ds_transaction
+          DS::Service.get(tx, ds_key)
         else
-          entity.set_property(name.to_s, value)
+          DS::Service.get(ds_key)
+        end
+      end
+
+      def ds_service_put(entity)
+        if tx = ds_transaction
+          DS::Service.put(tx, entity)
+        else
+          DS::Service.put(entity)
+        end
+      end
+
+      def ds_service_delete(ds_key)
+        if tx = ds_transaction
+          DS::Service.delete(tx, ds_key)
+        else
+          DS::Service.delete(ds_key)
+        end
+      end
+
+      def ds_transaction
+        if tx = current_transaction
+          primitive = tx.primitive_for(self)
+          primitive.transaction
+        else
+          nil
+        end
+      end
+
+      def negative?(entity, negas)
+        negas.any? do |property, value|
+          property.typecast(ds_get(entity, property.field)) == value
+        end
+      end
+
+      def negate_query(query, negas)
+        query = query.dup
+        query.conditions.delete_if do |tuple| 
+          tuple.size != 2 && tuple[0] == :not
+        end
+        negas.each do |property, value|
+          query.conditions.push([:eql, property, value])
+        end
+        query
+      end
+
+      def assert_query(query, posis)
+        query = query.dup
+        property = posis.keys.first
+        query.conditions.delete_if do |tuple|
+          tuple.size != 2 && tuple[0] == :eql && tuple[1] == property
         end
+        query.conditions.push([:eql, property, posis[property]])
+        query
       end
     end
 

data/lib/dm-datastore-adapter/transaction.rb

@@ -0,0 +1,67 @@
+module DataMapper
+  module Adapters
+    class DataStoreAdapter < AbstractAdapter
+      class Transaction
+        class AlreadyBeginError < StandardError; end
+
+        attr_reader :transaction
+
+        def begin
+          raise AlreadyBeginError if @transaction
+          @transaction = DS::Service.beginTransaction
+        end
+
+        def commit
+          @transaction.commit
+        end
+
+        def rollback
+          @transaction.rollback
+        end
+
+        def rollback_prepared
+          @transaction.rollback
+        end
+
+        def prepare
+          # TODO
+        end
+
+        def close
+          @transaction = nil
+        end
+      end
+
+      def transaction_primitive
+        DataStoreAdapter::Transaction.new
+      end
+
+      def push_transaction(transaction)
+        transactions(Thread::current) << transaction
+      end
+
+      def pop_transaction
+        transactions(Thread::current).pop
+      end
+
+      def current_transaction
+        transactions(Thread::current).last
+      end
+
+      def within_transaction?
+        !current_transaction.nil?
+      end
+
+    private
+      def transactions(thread)
+        unless @transactions[thread]
+          @transactions.delete_if do |key, value|
+            !key.respond_to?(:alive?) || !key.alive?
+          end
+          @transactions[thread] = []
+        end
+        @transactions[thread]
+      end
+    end
+  end
+end

data/lib/dm-datastore-adapter.rb

@@ -8,6 +8,7 @@ if defined?(Merb::Plugins)
   Merb::BootLoader.before_app_loads do
     # require code that must be loaded before the application
     require File.join(%w(dm-datastore-adapter datastore-adapter))
+    require File.join(%w(dm-datastore-adapter transaction))
   end
   
   Merb::BootLoader.after_app_loads do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: dm-datastore-adapter
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors: 
 - Genki Takiuchi
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-15 00:00:00 +09:00
+date: 2009-04-17 00:00:00 +09:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -51,6 +51,7 @@ files:
 - lib/dm-datastore-adapter
 - lib/dm-datastore-adapter/datastore-adapter.rb
 - lib/dm-datastore-adapter/merbtasks.rb
+- lib/dm-datastore-adapter/transaction.rb
 - lib/dm-datastore-adapter.rb
 - spec/dm-datastore-adapter_spec.rb
 - spec/spec_helper.rb