sdb_dal 0.0.3 → 0.0.4

data/lib/sdb_dal/domain_object.rb

@@ -43,6 +43,7 @@ class DomainObject
     @@index_names||=[]
     @@index_descriptions||={}
     @@index_names<<:#{name}
+
     def self.index_names
         @@index_names
     end
@@ -75,23 +76,29 @@ class DomainObject
       find_scope=":first"
     end
     class_eval <<-GETTERDONE
-        def #{name}
-              
-	return	self.class.calculate_#{name}(#{getter_params.join(",")})
-              
-	end
+        def #{name}              
+            return	self.class.calculate_#{name}(#{getter_params.join(",")})
+        end
+
        def self.calculate_#{name}(#{params.join(",")})
             index_description=index_descriptions[:#{name}]
             h={}
             #{finder_code}
             index_description.format_index_entry(@@attribute_descriptions,h)
       end
+
       def self.find_by_#{name}(#{params.join(",")},options={})
           options[:params]={:#{name}=>self.calculate_#{name}(#{params.join(",")})}
+          options[:index]=:#{name}
+          options[:index_value]=self.calculate_#{name}(#{params.join(",")})
            find(#{find_scope},options)
-        end
+      end
     GETTERDONE
   end
+  @@index_descriptions ={}
+  def self.index_descriptions
+      @@index_descriptions || {}
+    end
   def self.data_attribute(name,type,options={})
     class_eval <<-GETTERDONE
     @@attribute_descriptions||=HashWithIndifferentAccess.new 
@@ -105,9 +112,7 @@ class DomainObject
      def self.attribute_descriptions
       @@attribute_descriptions
     end
-    def self.index_descriptions
-      @@index_descriptions
-    end
+    
     def self.non_clob_attribute_names
       @@non_clob_attribute_names
     end
@@ -117,7 +122,7 @@ class DomainObject
     def is_dirty(attribute_name)
              if @attribute_values[attribute_name]!= nil && 
                 @attribute_values[attribute_name].respond_to?(:value)
-		return @attribute_values[attribute_name].is_dirty 
+                return @attribute_values[attribute_name].is_dirty
             else
                 return true
             end
@@ -516,7 +521,7 @@ def destroy(options={})
         attributes[self.class.index_descriptions[name]]=value
       end
   
-      self.repository(options).save(self.table_name,self.primary_key,attributes)
+      self.repository(options).save(self.table_name,self.primary_key,attributes,self.class.index_descriptions)
       @accessor_cache=temp_accessor_cache
     end
     
@@ -571,17 +576,17 @@ def destroy(options={})
       find_every(options).first
     end
     def find_every(options)
-            
+
       results=[]
       untyped_results=self.repository.query(self.table_name,attribute_descriptions,options)
       untyped_results.each do |item_attributes|
-                
+
         results<<istantiate(item_attributes,self.repository(options))
       end
       return results
-            
+
     end
-    def find_list(primary_keys,options={})
+     def find_list(primary_keys,options={})
       result=[]
       primary_keys.each do |key|
         item=find_single(key,options)

data/lib/sdb_dal/memory_repository.rb

@@ -1,168 +1,223 @@
 module SdbDal
 
-require File.dirname(__FILE__) +"/memory_storage.rb"
+  require File.dirname(__FILE__) +"/memory_storage.rb"
 
-class MemoryRepository
-  attr_accessor :use_cache #this here just so interface matches sdb repo
-      attr_accessor :storage
+  class MemoryRepository
+    attr_accessor :use_cache #this here just so interface matches sdb repo
+    attr_accessor :storage
    
-  def initialize(
-      sdb_domain= nil,
-      clob_bucket= nil,
-      aws_key_id= nil,
-      aws_secret_key= nil,
-      memcache_servers = nil ,
-      dummy=nil
-    )
-    @records={}
-    @storage=MemoryStorage.new
-  end
-  def clear_session_cache
+    def initialize(
+        sdb_domain= nil,
+        clob_bucket= nil,
+        aws_key_id= nil,
+        aws_secret_key= nil,
+        memcache_servers = nil ,
+        dummy=nil
+      )
+      clear
+    end
+    def pause
+    end
+
+    def clear_session_cache
     
-  end
-  def clear
-     @records={}
-    @storage=MemoryStorage.new
-  end
-  def save(table_name, primary_key, attributes)
-    key=make_cache_key(table_name,primary_key);
-    record=@records[key]
-    if !record 
-      record={}
-      @records[key]=record
-        
     end
+
+    def clear
+      @records={}
+      @indexes={}
+      @reverse_indexes={}
+      @storage=MemoryStorage.new
+    end
+  
+    def save(table_name, primary_key, attributes,index_descriptions)
+      key=make_cache_key(table_name,primary_key);
+      record=@records[key]
+      if !record
+        record={}
+        @records[key]=record
+        
+      end
     
-    attributes.each do |description,value|
-      if description.is_clob
-        @storage.put("",make_clob_key(table_name,primary_key,description.name),value)
-      else
-        record[description.name]=value
+      attributes.each do |description,value|
+        if description.is_clob
+          @storage.put("",make_clob_key(table_name,primary_key,description.name),value)
+        else
+          record[description.name]=value
+        end
+      end
+      record["metadata%table_name"]=table_name
+      record["metadata%primary_key"]=primary_key
+      if index_descriptions
+        remove_from_indices(table_name,primary_key)
+        index_descriptions.each do |index_name,index|
+          index_value=record[index_name.to_sym]
+          save_into_index(table_name, record, index.name, index_value)
+        end
       end
     end
-    record["metadata%table_name"]=table_name
-    record["metadata%primary_key"]=primary_key
-  end
-  def query_ids(table_name,attribute_descriptions,options)
-    primary_key=nil
-    attribute_descriptions.each do |name,desc|
-      if desc.is_primary_key
-        primary_key= name.to_sym 
-        break
+    def save_into_index(table_name,record,index_name,index_value)
+      @indexes[table_name]||={}
+      @indexes[table_name][index_name]||={}
+      index=(@indexes[table_name][index_name][index_value]||=[])
+      index.each_index do |i|
+        if index[i]["metadata%primary_key"]==record["metadata%primary_key"]
+          index[i]=record
+          return
+        end
       end
-      
+      index<<record
+      @reverse_indexes[table_name]||={}
+      @reverse_indexes[table_name][record["metadata%primary_key"]]||=[]
+      @reverse_indexes[table_name][record["metadata%primary_key"]]<<index
     end
-    objects=query(table_name,attribute_descriptions,options)
-    result=[]
-    objects.each do | o|
-      result<<o[primary_key]
+    def retrieve_from_index(table_name,index_name,index_value)
+      return [] unless @indexes[table_name]
+      return [] unless @indexes[table_name][index_name]
+      return @indexes[table_name][index_name][index_value] ||[]
     end
-    result
-  end
-  
-  def query(table_name,attribute_descriptions,options)
+    def query_ids(table_name,attribute_descriptions,options)
+      primary_key=nil
+      attribute_descriptions.each do |name,desc|
+        if desc.is_primary_key
+          primary_key= name.to_sym
+          break
+        end
       
-    if options[:query]
-      raise 'query not supported yet'
+      end
+      objects=query(table_name,attribute_descriptions,options)
+      result=[]
+      objects.each do | o|
+        result<<o[primary_key]
+      end
+      result
     end
-    
-    result=[]
-    @records.each do |record_key,record|
-      ok=true
-      if record["metadata%table_name"]!=table_name
-        ok=false
+  
+    def query(table_name,attribute_descriptions,options)
+      
+      if options[:query]
+        raise 'query not supported yet'
+      end
+      result=[]
+
+      if options.has_key?(:index)
+        result= retrieve_from_index(table_name,options[:index],options[:index_value])
       else
-        if options.has_key?(:params)
+        @records.each do |record_key,record|
+          ok=true
+          if record["metadata%table_name"]!=table_name
+            ok=false
+          else
+            if options.has_key?(:params)
              
-          options[:params].each do |param_key,param_value|
+              options[:params].each do |param_key,param_value|
 
-            if param_value==:NOT_NULL 
-              if record[param_key]==nil
-                ok=false
-                break
+                if param_value==:NOT_NULL
+                  if record[param_key]==nil
+                    ok=false
+                    break
+                  end
+                elsif param_value==:NULL
+                  if record[param_key]!=nil
+                    ok=false
+                    break
+                  end
+                elsif param_value.respond_to?(:matches?)
+
+                  if !param_value.matches?(record[param_key])
+                    ok=false
+                    break
+                  end
+                elsif !record[param_key] && !param_value
+                  # #ok
+                  break
+                elsif record[param_key]!=param_value
+                  ok=false
+                  break
+                end
               end
-            elsif param_value==:NULL 
-               if record[param_key]!=nil
-                ok=false
-                break
-              end         
-            elsif param_value.respond_to?(:matches?)
+            end
+            if options.has_key?(:conditions)
+             
+              options[:conditions].each do |condition|
 
-              if !param_value.matches?(record[param_key])
-                ok=false
-                break
+                if !condition.matches?(record)
+                  ok=false
+                  break
+                end
               end
-            elsif !record[param_key] && !param_value
-              #ok 
-              break
-            elsif record[param_key]!=param_value
-              ok=false
-              break
             end
           end
+          if ok
+            result<<record
+          end
+          
         end
-        if options.has_key?(:conditions)
-             
-          options[:conditions].each do |condition|
-
-            if !condition.matches?(record)
-              ok=false
-              break
+      end
+      if options and options[:order_by]
+        result.sort! do |a,b|
+          a_value=a[options[:order_by]]
+          b_value=b[options[:order_by]]
+          if options[:order] && options[:order]!=:ascending
+            if b_value
+              b_value <=> a_value
+            else
+              -1
+            end
+          else
+            if a_value
+              a_value <=> b_value
+            else
+              -1
             end
           end
         end
       end
-      if ok
-        result<<record
+      if options[:limit] and result.length>options[:limit]
+        result=result[0..options[:limit]-1]
       end
-          
+      return result
+    end
+    def find_one(table_name, primary_key,attribute_descriptions)#, non_clob_attribute_names, clob_attribute_names)
+      return @records[make_cache_key(table_name,primary_key)]
+    end
+    def get_clob(table_name,primary_key,clob_name)
+      return @storage.get("",make_clob_key(table_name,primary_key,clob_name))
+        
     end
+    def destroy(table_name, primary_key)
+      key=make_cache_key(table_name,primary_key);
     
-    if options and options[:order_by]
-      result.sort! do |a,b|
-        a_value=a[options[:order_by]]
-        b_value=b[options[:order_by]]
-        if options[:order] && options[:order]!=:ascending
-          if b_value
-            b_value <=> a_value
-          else
-            -1
-          end
-        else
-          if a_value
-            a_value <=> b_value
-          else
-            -1
+      if @records.has_key?(key)
+        @records.delete(key)
+      end
+      remove_from_indices(table_name,primary_key)
+    end
+    def remove_from_indices(table_name,primary_key)
+      if @reverse_indexes[table_name]
+        indicies=@reverse_indexes[table_name][primary_key]
+        if indicies
+          indicies.each do |index|
+            index.each do |record|
+              if record["metadata%primary_key"]==primary_key
+                index.delete(record)
+                break
+              end
+            end
           end
+          @reverse_indexes[table_name].delete(primary_key)
         end
       end
+
     end
-    if options[:limit] and result.length>options[:limit]
-      result=result[0..options[:limit]-1]
+    private
+    def make_cache_key(table_name,primary_key)
+      return "cached_objects/#{table_name}/#{CGI.escape(primary_key.to_s)}"
     end
-    return result
-  end
-  def find_one(table_name, primary_key,attribute_descriptions)#, non_clob_attribute_names, clob_attribute_names)
-    return @records[make_cache_key(table_name,primary_key)]
-  end
-  def get_clob(table_name,primary_key,clob_name)
-    return @storage.get("",make_clob_key(table_name,primary_key,clob_name))
-        
-  end
-  def destroy(table_name, primary_key)
-    key=make_cache_key(table_name,primary_key);
-    
-    if @records.has_key?(key)
-      @records.delete(key)
+    def make_clob_key(table_name,primary_key,clob_name)
+      return "clobs/#{table_name}/#{CGI.escape(primary_key)}/#{clob_name}"
     end
+
   end
-  
-  private
-  def make_cache_key(table_name,primary_key)
-    return "cached_objects/#{table_name}/#{CGI.escape(primary_key.to_s)}"
-  end
-  def make_clob_key(table_name,primary_key,clob_name)
-    return "clobs/#{table_name}/#{CGI.escape(primary_key)}/#{clob_name}"
-  end
-end
+
 end

data/lib/sdb_dal/repository.rb

@@ -360,7 +360,9 @@ class Repository
     end
   end
   #parse date in yyyy-mm-dd format
-   
-end
 
+def pause
+  sleep(2)
+end
+end
 end  

data/lib/sdb_dal/repository_factory.rb

@@ -3,8 +3,7 @@ require "sdb_dal/memory_repository.rb"
     
 module SdbDal
   class RepositoryFactory
-    #if this is rails insert code into application
-
+    
     
     def self.instance(options={})
       if options and options.has_key?(:repository)
@@ -29,7 +28,7 @@ module SdbDal
         memcache_servers= sdb_dal_config['memcache_servers']
         memcache_servers = memcache_servers.split(",") if memcache_servers
  
-        return repo_class.new(domain_prefix,clob_bucket,aws_key_id,aws_secret_key,memcache_servers)
+        @repository= repo_class.new(domain_prefix,clob_bucket,aws_key_id,aws_secret_key,memcache_servers)
       end
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sdb_dal
 version: !ruby/object:Gem::Version 
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors: 
 - David Knight
@@ -9,7 +9,7 @@ autorequire: sdb_dal
 bindir: bin
 cert_chain: []
 
-date: 2008-10-31 00:00:00 -07:00
+date: 2008-12-22 00:00:00 -08:00
 default_executable: 
 dependencies: []