sdb_dal 0.0.1

data/lib/sdb_dal/domain_object.rb

@@ -0,0 +1,642 @@
+require "active_support"
+require 'uuid'
+require File.dirname(__FILE__) +'/domain_attribute_description.rb'
+require File.dirname(__FILE__) +"/reference.rb"
+require File.dirname(__FILE__) +"/index_description.rb"
+require File.dirname(__FILE__) +"/lazy_loading_text.rb"
+module SdbDal
+class DomainObject
+  
+  @@repository  =nil
+  @@items_to_commit=nil
+  @@transaction_depth=0
+  attr_accessor :sdb_key 
+  def initialize(options={})
+    @attribute_values=HashWithIndifferentAccess.new
+    self.class.attribute_descriptions.each do |attribute_name,description|
+      if description.is_primary_key && options.has_key?(:primary_key)
+        @attribute_values[attribute_name]=options[:primary_key]
+      else  
+        value=options[attribute_name]
+        value=value || options[attribute_name.intern]
+        if !description.is_collection && value.respond_to?(:flatten) && value.length==1
+          value=value[0]
+        end
+        @attribute_values[attribute_name]=value
+      end
+    end
+    @accessor_cache={}
+    @repository=options[:repository]
+  end
+  def self.primary_key_attribute_name
+    return @primary_key_attribute_name
+  end
+  def id
+    return @attribute_values[:id] if self.class.attribute_descriptions[:id] 
+    return base.id
+  end
+  def self.index_names
+    []
+  end
+  def self.index(name,columns,options={}) 
+    class_eval <<-GETTERDONE
+    @@index_names||=[]
+    @@index_descriptions||={}
+    @@index_names<<:#{name}
+    def self.index_names
+        @@index_names
+    end
+
+    attribute_description=SdbDal::DomainAttributeDescription.new(name,:string,{})
+    @@index_descriptions[name]=SdbDal::IndexDescription.new(name,columns)
+   
+    GETTERDONE
+     
+    getter_params=[]
+    finder_code=""
+     
+    params=[]
+    columns.each do |column|
+      if column.respond_to?(:transform)
+        finder_code<<"h[:#{column.name}]=#{column.name.to_s.downcase}\n"
+        getter_params<<"@attribute_values[:#{column.source_column}]"
+       
+        params<<"#{column.name.to_s.downcase}"
+      else
+        finder_code<<"h[:#{column}]=#{column.to_s.downcase}\n"
+        getter_params<<"@attribute_values[:#{column}]"
+        params<<"#{column.to_s.downcase}"
+       
+      end
+       
+    end
+    find_scope=":all"
+    if options[:unique]
+      find_scope=":first"
+    end
+    class_eval <<-GETTERDONE
+        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(",")})}
+           find(#{find_scope},options)
+        end
+    GETTERDONE
+  end
+  def self.data_attribute(name,type,options={})
+    class_eval <<-GETTERDONE
+    @@attribute_descriptions||=HashWithIndifferentAccess.new 
+    
+    @@non_clob_attribute_names||=[]
+    @@clob_attribute_names||=[]
+    @@on_destroy_blocks||=[]
+    def self.on_destroy_blocks
+      @@on_destroy_blocks
+    end
+     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
+    def self.clob_attribute_names
+      @@clob_attribute_names
+    end
+    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 
+            else
+                return true
+            end
+    end
+    GETTERDONE
+    
+  
+    attribute_description=DomainAttributeDescription.new(name,type,options)
+    self.attribute_descriptions[name] = attribute_description
+    if attribute_description.is_primary_key
+      class_eval <<-GETTERDONE
+       def self.primary_key_attribute_name
+            '#{name}'
+       end
+      def self.exists?(primary_key)
+            return self.find(primary_key)!=nil
+       end
+        
+      GETTERDONE
+    end
+    if !attribute_description.is_primary_key
+      if attribute_description.value_type==:clob
+        clob_attribute_names<<attribute_description.name
+      else
+        non_clob_attribute_names<<attribute_description.name
+      end
+    end
+    scope=":all"
+    if(options[:unique] && options[:unique]==true)
+      scope=":first"
+    end
+    if type==:reference_set
+        
+    
+      class_eval <<-GETTERDONE
+        def #{attribute_description.name}
+              result=@attribute_values[:#{attribute_description.name}] || []
+              result=result.sort_by{|item|item.index}
+          
+	end
+        def add_to_#{attribute_description.name}(item,index=-1)
+		@attribute_values[:#{attribute_description.name}] ||=[]
+                @attribute_values[:#{attribute_description.name}] <<SdbDal::Reference.new(:target=> item ,:index=>index)
+	end
+        def remove_from_#{attribute_description.name}(item)
+		@attribute_values[:#{attribute_description.name}] ||=[]
+                @attribute_values.each do |reference|
+                      if reference.targets?(item)
+                        @attribute_values.remove(reference)
+                        return
+                      end
+                end
+	end
+        
+      GETTERDONE
+    
+    elsif type==:clob
+      class_eval <<-GETTERDONE
+         
+        def #{attribute_description.name}
+            if @attribute_values[:#{attribute_description.name}]!= nil && 
+                            @attribute_values[:#{attribute_description.name}].respond_to?(:value)
+		return @attribute_values[:#{attribute_description.name}].value 
+            else
+                return @attribute_values[:#{attribute_description.name}] 
+            end
+	end
+        
+      GETTERDONE
+    else
+     
+      class_eval <<-GETTERDONE
+        def #{attribute_description.name}
+		return @attribute_values[:#{attribute_description.name}] 
+	end
+       
+      GETTERDONE
+    end
+    class_eval <<-GETTERDONE
+    
+	 def #{attribute_description.name}=(xvalue)
+                @attribute_values[:#{attribute_description.name}] =xvalue
+	end
+	def #{attribute_description.name}?
+		return @attribute_values[:#{attribute_description.name}] 
+	end
+	
+	def self.find_by_#{attribute_description.name}(#{attribute_description.name.to_s.downcase},options={})
+          options[:params]={:#{attribute_description.name}=>#{attribute_description.name.to_s.downcase}}
+               find(#{scope},options)
+	end
+    GETTERDONE
+  end
+  
+  def self.belongs_to(domain_class,foreign_key_attribute=nil,accesser_attribute_name=nil,options={})
+    
+    foreign_key_attribute ||= "#{domain_class.to_s.downcase}_id".to_sym
+    accesser_attribute_name ||=domain_class.to_s.downcase
+  
+    class_eval <<-GETTERDONE
+	def #{accesser_attribute_name}
+		#{domain_class}.find(self.#{foreign_key_attribute})
+	end
+        
+    GETTERDONE
+  end
+  def self.many_to_many(domain_class,
+      through_class,
+      reflecting_key_attribute=nil,
+      foriegn_key_attribute=nil,
+      accesser_attribute_name=nil,
+      options={})
+    reflecting_key_attribute ||= (self.name+"_"+primary_key_attribute_name.to_s).downcase.to_sym
+    accesser_attribute_name ||=domain_class.to_s.downcase+'s'
+    order=""
+    if options[:order_by]
+      if options[:order]
+        order="result=DomainObject.sort_result(result,:#{options[:order_by]},:#{options[:order]})"
+      else
+        order="result=DomainObject.sort_result(result,:#{options[:order_by]},:ascending)"
+      end
+    end
+   
+       
+    foriegn_key_attribute=options[:foriegn_key_attribute] || "#{domain_class.to_s.downcase}_id".to_sym
+    primary_key=options[:primary_key] || "id".to_sym
+    class_eval <<-XXDONE
+	def #{accesser_attribute_name}
+            #unless @accessor_cache.has_key? :#{accesser_attribute_name}
+		through_results= #{through_class}.find(:all,:params=>{:#{reflecting_key_attribute}=>self.primary_key})
+                result=[]
+                through_results.each do |through_result|
+                  item= #{domain_class}.find(through_result.#{foriegn_key_attribute}) 
+                  result<< item if item
+                end
+                #{order}
+                
+              #  @accessor_cache[:#{accesser_attribute_name}]=result
+                return result
+            #end
+            #return @accessor_cache[:#{accesser_attribute_name}]
+            
+	end
+        def connect_#{domain_class.to_s.downcase}(#{domain_class.to_s.downcase})
+            connector=#{through_class}.new
+            connector.#{foriegn_key_attribute}=#{domain_class.to_s.downcase}.primary_key
+            connector.#{reflecting_key_attribute}=self.primary_key
+            connector.save
+        end
+    XXDONE
+       
+   
+  end
+  def DomainObject.transaction
+    @@items_to_commit||=[]
+    @@transaction_depth+=1
+    begin
+      yield
+    rescue # catch all
+      raise $! # rethrow 
+    ensure
+      @@transaction_depth-=1
+      
+    end
+    
+    
+    if @@transaction_depth==0
+     
+      @@items_to_commit.uniq.each do |item |
+        item.save!
+      end
+      @@items_to_commit=[]
+    end
+    
+  end
+  def DomainObject.sort_result(results,sort_by,order=:ascending)
+    non_null_results=[]
+    null_results=[]
+    results.each { |i|  
+      sorter_value=i.get_attribute(sort_by)
+      if sorter_value
+        non_null_results<<i
+      else
+        null_results<<i
+      end
+    }
+    sorted_results=non_null_results.sort{ |a,b|
+        a_val= a.get_sortable_attribute(sort_by)
+        b_val= b.get_sortable_attribute(sort_by)
+        
+            a_val <=> b_val
+        }
+        
+    if order!=:ascending
+      sorted_results.reverse!
+    end
+    sorted_results.concat( null_results)
+    sorted_results
+  end
+  def get_sortable_attribute(attr_name)
+       a_val= self.get_attribute(attr_name)
+       return 0 unless a_val
+        if a_val.class== Time
+            return a_val.to_f
+        else
+            return a_val
+        end
+  end
+  def self.has_many(domain_class,
+      reflecting_key_attribute=nil,
+      accesser_attribute_name=nil,
+      options={})
+    
+    reflecting_key_attribute ||= (self.name+"_"+primary_key_attribute_name.to_s).downcase.to_sym
+    accesser_attribute_name ||=domain_class.to_s.downcase+'s'
+    order=""
+    if options[:order_by]
+      order=",:order_by=>:#{options[:order_by]}"
+    end
+    if options[:order]
+      order<<",:order=>:#{options[:order]}"
+    end
+  
+    if options[:dependent]
+        
+      class_eval <<-XXDONE
+          
+            on_destroy_blocks<<"#{accesser_attribute_name}.each{|item|item.destroy}"
+      XXDONE
+    end
+    #  if options[:tracking]
+    #    #add add_xxx method
+    #    #add to list of tracker attributes
+    #    
+    #      class_eval <<-XXDONE
+    #        
+    #    @@attribute_descriptions[ :#{accesser_attribute_name}_tracker]=TrackerDescription.new(:#{accesser_attribute_name}_tracker,:#{domain_class},:#{reflecting_key_attribute})
+    #	def #{accesser_attribute_name}
+    #		find_tracked_list(:#{accesser_attribute_name}_tracker,#{domain_class},:#{reflecting_key_attribute})
+    #	end
+    #        def add_to_#{accesser_attribute_name}(item)
+    #		item.save!
+    #                add_to_tracked_list(:#{accesser_attribute_name}_tracker,#{domain_class.to_s},:#{reflecting_key_attribute},item.primary_key)
+    #                item.set_attribute(:#{reflecting_key_attribute},self.primary_key)
+    #                
+    #                
+    #	end
+    #    XXDONE
+    #  else
+    class_eval <<-XXDONE
+	def #{accesser_attribute_name}
+            if !@accessor_cache.has_key? :#{accesser_attribute_name}
+		@accessor_cache[:#{accesser_attribute_name}]=#{domain_class}.find(:all,:params=>{:#{reflecting_key_attribute}=>self.primary_key}#{order})
+            end
+            return @accessor_cache[:#{accesser_attribute_name}]
+	end
+    XXDONE
+    # end
+  end
+  def self.AttributeDescription(name)
+    return attribute_descriptions[name]
+  end
+  def self.ColumnDescription(name)
+    return column_descriptions[name]
+  end
+  def primary_key
+    
+    @attribute_values[ self.class.primary_key_attribute_name]
+  end
+  def primary_key=(value)
+    @attribute_values[ self.class.primary_key_attribute_name]=value
+  end
+  def method_missing(method_symbol, *arguments) #:nodoc:
+    method_name = method_symbol.to_s
+
+    case method_name.last
+    when "="
+      if @attribute_values.has_key?(method_name.first(-1))
+        @attribute_values[method_name.first(-1)] = arguments.first 
+      else
+        super
+      end
+    when "?"
+      @attribute_values[method_name.first(-1)]
+    else
+      @attribute_values.has_key?(method_name) ? @attribute_values[method_name] : super
+    end
+  end
+  def index_values
+    result={}
+    self.class.index_names.each do |name|
+              
+      result[name]=  self.send("#{name}")
+   
+    end
+    result
+  end
+  def set_attribute(name,value)
+    @attribute_values[name]=value
+  end
+  def get_attribute(name)
+    @attribute_values[name]
+  end
+def to_xml
+    result= "<#{self.class.table_name}>"
+    attributes.each do |key,value|
+        if value.respond_to?(:flatten)
+            result<<"<#{key}>"
+            value.each do |sub_value|
+                result<<"<value>#{h sub_value.to_s}</value>"
+            end
+            result<<"</#{key}>"
+        else
+          result<<"<#{key}>#{h value.to_s}</#{key}>"
+        end
+   end
+    result<< "</#{self.class.table_name}>"
+    result
+end
+def destroy(options={})
+    self.class.on_destroy_blocks.each do |block| 
+      instance_eval <<-XXDONE
+                  #{block}
+             
+      XXDONE
+         
+    end
+    if self.primary_key
+      self.repository(options).destroy(self.table_name,self.primary_key)
+    end
+  end
+  def attributes
+    result={}
+    #todo refactor to avoid this copy
+    self.class.attribute_descriptions.values.each do |description|
+      if !description.is_clob || is_dirty(description.name)
+        result[description.name]=@attribute_values[description.name]
+      end
+    end
+    return result
+  end
+
+  def find_tracked_list(tracking_attribute,other_class,reflecting_attribute)
+    #if the attribute has no  value do a query
+    list=@attribute_values[tracking_attribute]
+    if !list
+      list=other_class.query_ids(:params=>{reflecting_attribute=>self.primary_key})
+      @attribute_values[tracking_attribute]=list
+      self.save!
+    end
+      
+    return other_class.find_list(list)
+    
+  end
+  
+  def add_to_tracked_list(tracking_attribute,other_class,reflecting_attribute,value)
+    list=@attribute_values[tracking_attribute]
+    if !list
+      list=other_class.query_ids(:params=>{reflecting_attribute=>self.primary_key})
+      
+    end
+    list<<value
+    @attribute_values[tracking_attribute]=list.uniq
+    
+  end
+  def save!(options={})
+    save(options)
+  end
+  def save(options={})
+     if !self.primary_key
+      self.primary_key= UUID.generate.to_s
+    end
+        
+    if @@transaction_depth>0
+      #we are in a transaction.  wait to commit
+      @@items_to_commit<<self
+     
+    else
+      temp_accessor_cache=@accessor_cache
+      @accessor_cache=nil
+   
+      #     $service.put_attributes(class_object.table_name,item.send(name_column),attributes,true)
+      attributes={}
+      #todo refactor to avoid this copy
+      self.class.attribute_descriptions.values.each do |description|
+        if !description.is_clob || is_dirty(description.name)
+          value=@attribute_values[description.name]
+          attributes[description]=value
+        end
+   
+                
+           
+      end
+      self.index_values.each do |name,value|
+      
+        attributes[self.class.index_descriptions[name]]=value
+      end
+  
+      self.repository(options).save(self.table_name,self.primary_key,attributes)
+      @accessor_cache=temp_accessor_cache
+    end
+    
+  end
+  def table_name
+    return self.class.table_name
+  end
+  def DomainObject.table_name
+    return self.name
+  end
+  #    def find
+  #       
+  #       attributes=repository.find(self.class.name,self.primary_key,@@non_clob_attribute_names,@@clob_attribute_names)
+  #       attributes.each do |key,value|
+  #           @attribute_values[key]=value
+  #       end
+  #    end
+  def repository(options=nil)
+    
+    if options and options.has_key?(:repository)          
+      return options[:repository]
+    end
+    if @repository
+      return @repository
+    end
+    if @@repository
+      return @@repository
+    end
+    return $repository
+  end
+  class << self
+    def repository(options=nil)
+    
+      if options and options.has_key?(:repository)          
+        return options[:repository]
+      end
+      if @repository
+        return @repository
+      end
+      return $repository
+    end
+    def find(*arguments)
+      scope   = arguments.slice!(0)
+      options = arguments.slice!(0) || {}
+        
+      case scope
+      when :all   then return find_every(options)
+      when :first then return find_one(options)
+      else             return find_single(scope, options)
+      end
+    end
+    def find_one(options)
+      options[:limit]=1
+      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={})
+      result=[]
+      primary_keys.each do |key|
+        item=find_single(key,options)
+        result<<item if item
+      end
+      return result
+    end
+    def query_ids(options={})
+      self.repository.query_ids(self.table_name,attribute_descriptions,options)
+    end
+    def istantiate(sdb_attributes,repository)
+      this_result=new(sdb_attributes||{})
+      get_clob_proc=nil
+      clob_attribute_names.each do |clob_attribute_name|
+        get_clob_proc= proc {
+          repository.get_clob(self.table_name,this_result.primary_key,clob_attribute_name)
+        }
+                  
+        this_result.set_attribute(clob_attribute_name, LazyLoadingText.new(get_clob_proc))
+      end
+      this_result
+    end
+       
+    def find_single(id, options)
+      return nil if id==nil
+      attributes=self.repository(options).find_one(self.table_name,id,attribute_descriptions)
+      if attributes && attributes.length>0 
+        attributes[@primary_key_attribute_name]=id
+        attributes[:repository]=self.repository(options)
+        return istantiate(attributes,self.repository(options))
+      end
+      return nil
+    end
+    def find_recent_with_exponential_expansion(time_column,how_many,options={})
+      found=[]
+      tries=0
+      timespan=options[:timespan_hint] || 60*60*4
+      
+      params = options[:params] || {}
+      
+      while found.length<how_many && tries<4
+        time=Time.now.gmtime-timespan
+        params[time_column]  =AttributeRange.new(:greater_than=>time)
+        found= find(:all,:limit=>how_many,:order=>:descending,:order_by => time_column,
+          :params=>params)
+        
+        tries=tries+1
+        timespan=timespan*3
+      end
+      return found
+          
+    end  
+    
+  end
+end
+end

data/lib/sdb_dal/domain_object_cache_item.rb

@@ -0,0 +1,14 @@
+module SdbDal
+
+
+class DomainObjectCacheItem
+    attr_accessor :table_name
+    attr_accessor :primary_key
+    attr_accessor :non_clob_attributes
+  def initialize(table_name,primary_key,non_clob_attributes)
+    self.table_name=table_name
+    self.primary_key=primary_key
+    self.non_clob_attributes=non_clob_attributes
+  end
+end
+end

data/lib/sdb_dal/equals_condition.rb

@@ -0,0 +1,18 @@
+module SdbDal
+ 
+
+class EqualsCondition
+    attr_accessor :attribute_description
+  attr_accessor :value
+  def initialize(attribute_description,value)
+    self.attribute_description=attribute_description
+    self.value=value
+  end
+   def matches?(domain_object)
+       return domain_object[attribute_description.name]==value
+   end
+   def to_sdb_query
+     return "'#{self.attribute_description.name}'='#{self.attribute_description.format_for_sdb(self.value)}'"
+   end
+end
+end