simple_record 1.5.8 → 2.0.0

data/README.markdown

@@ -118,6 +118,10 @@ To find all:
 
     Company.find_all_by_name_and_division("Appoxy", "West")
 
+Consistent read:
+
+    Company.find(:all, :conditions => ["created > ?", 10.days.ago], :order=>"name", :limit=>50, :consistent_read=>true)
+
 There are so many different combinations of the above for querying that I can't put them all here,
 but this should get you started.
 
@@ -244,7 +248,7 @@ You can use any cache that supports the ActiveSupport::Cache::Store interface.
 
     SimpleRecord::Base.cache_store = my_cache_store
 
-If you want a simple in memory cache store, try: http://gemcutter.org/gems/local_cache . It supports max cache size and
+If you want a simple in memory cache store, try: <http://gemcutter.org/gems/local_cache>. It supports max cache size and
 timeouts. You can also use memcached or http://www.quetzall.com/cloudcache.
 
 ## Encryption
@@ -271,6 +275,19 @@ ob2.password == "mypassword"
 
 This will actually be compared by hashing "mypassword" first.
 
+## Sharding
+
+Sharding allows you to partition your data for a single class across multiple domains allowing increased write throughput,
+faster queries and more space (multiply your 10GB per domain limit).  And it's very easy to implement with SimpleRecord.
+
+    shard :shards=>:my_shards_function, :map=>:my_mapping_function
+
+The :shards function should return a list of shard names, for example: ['CA', 'FL', 'HI', ...] or [1,2,3,4,...]
+
+The :map function should return which shard name the object should be stored to.
+
+You can see some [example classes here](https://github.com/appoxy/simple_record/blob/master/test/my_sharded_model.rb).
+
 ## Kudos
 
 Special thanks to Garrett Cox for creating Activerecord2sdb which SimpleRecord is based on:

data/lib/simple_record.rb

@@ -172,7 +172,8 @@ module SimpleRecord
 
         include SimpleRecord::Translations
 #        include SimpleRecord::Attributes
-        extend SimpleRecord::Attributes
+        extend SimpleRecord::Attributes::ClassMethods
+        include SimpleRecord::Attributes
         extend SimpleRecord::Sharding::ClassMethods
         include SimpleRecord::Sharding
         include SimpleRecord::Callbacks
@@ -295,12 +296,6 @@ module SimpleRecord
             domain_name_for_class
         end
 
-        def get_attribute_sdb(name)
-            name = name.to_sym
-            ret  = strip_array(@attributes[sdb_att_name(name)])
-            return ret
-        end
-
         def has_id_on_end(name_s)
             name_s = name_s.to_s
             name_s.length > 3 && name_s[-3..-1] == "_id"
@@ -324,7 +319,7 @@ module SimpleRecord
         end
 
         def strip_array(arg)
-            if arg.class==Array
+            if arg.is_a? Array
                 if arg.length==1
                     ret = arg[0]
                 else
@@ -686,122 +681,6 @@ module SimpleRecord
         end
 
 
-        # Since SimpleDB supports multiple attributes per value, the values are an array.
-        # This method will return the value unwrapped if it's the only, otherwise it will return the array.
-        def get_attribute(name)
-#            puts "GET #{arg}"
-            # Check if this arg is already converted
-            name_s   = name.to_s
-            name     = name.to_sym
-            att_meta = get_att_meta(name)
-#            puts "att_meta for #{name}: " + att_meta.inspect
-            if att_meta && att_meta.type == :clob
-                ret = @lobs[name]
-#                puts 'get_attribute clob ' + ret.inspect
-                if ret
-                    if ret.is_a? RemoteNil
-                        return nil
-                    else
-                        return ret
-                    end
-                end
-                # get it from s3
-                unless new_record?
-                    begin
-                        ret                        = s3_bucket.get(s3_lob_id(name))
-#                        puts 'got from s3 ' + ret.inspect
-                        SimpleRecord.stats.s3_gets += 1
-                    rescue Aws::AwsError => ex
-                        if ex.include? /NoSuchKey/
-                            ret = nil
-                        else
-                            raise ex
-                        end
-                    end
-
-                    if ret.nil?
-                        ret = RemoteNil.new
-                    end
-                end
-                @lobs[name] = ret
-                return nil if ret.is_a? RemoteNil
-                return ret
-            else
-                @attributes_rb = {} unless @attributes_rb # was getting errors after upgrade.
-                ret = @attributes_rb[name_s] # instance_variable_get(instance_var)
-                return ret unless ret.nil?
-                return nil if ret.is_a? RemoteNil
-                ret                    = get_attribute_sdb(name)
-                ret                    = sdb_to_ruby(name, ret)
-                @attributes_rb[name_s] = ret
-                return ret
-            end
-
-        end
-
-        def set(name, value, dirtify=true)
-#            puts "SET #{name}=#{value.inspect}" if SimpleRecord.logging?
-#            puts "self=" + self.inspect
-            attname      = name.to_s # default attname
-            name         = name.to_sym
-            att_meta     = get_att_meta(name)
-            store_rb_val = false
-            if att_meta.nil?
-                # check if it ends with id and see if att_meta is there
-                ends_with = name.to_s[-3, 3]
-                if ends_with == "_id"
-#                    puts 'ends with id'
-                    n2       = name.to_s[0, name.length-3]
-#                    puts 'n2=' + n2
-                    att_meta = defined_attributes_local[n2.to_sym]
-#                    puts 'defined_attributes_local=' + defined_attributes_local.inspect
-                    attname  = name.to_s
-                    attvalue = value
-                    name     = n2.to_sym
-                end
-                return if att_meta.nil?
-            else
-                if att_meta.type == :belongs_to
-                    ends_with = name.to_s[-3, 3]
-                    if ends_with == "_id"
-                        att_name = name.to_s
-                        attvalue = value
-                    else
-                        attname      = name.to_s + '_id'
-                        attvalue     = value.nil? ? nil : value.id
-                        store_rb_val = true
-                    end
-                elsif att_meta.type == :clob
-                    make_dirty(name, value) if dirtify
-                    @lobs[name] = value
-                    return
-                else
-                    attname  = name.to_s
-                    attvalue = att_meta.init_value(value)
-#                  attvalue = value
-                    #puts 'converted ' + value.inspect + ' to ' + attvalue.inspect
-                end
-            end
-            attvalue = strip_array(attvalue)
-            make_dirty(name, attvalue) if dirtify
-#            puts "ARG=#{attname.to_s} setting to #{attvalue}"
-            sdb_val              = ruby_to_sdb(name, attvalue)
-#            puts "sdb_val=" + sdb_val.to_s
-            @attributes[attname] = sdb_val
-#            attvalue = wrap_if_required(name, attvalue, sdb_val)
-#            puts 'attvalue2=' + attvalue.to_s
-
-            if store_rb_val
-                @attributes_rb[name.to_s] = value
-            else
-                @attributes_rb.delete(name.to_s)
-            end
-
-        end
-
-        def set_attribute_sdb(name, val)
-            @attributes[sdb_att_name(name)] = val
-        end
 
         def delete_niled(to_delete)
 #            puts 'to_delete=' + to_delete.inspect
@@ -872,6 +751,8 @@ module SimpleRecord
         # Extra options:
         #   :per_token => the number of results to return per next_token, max is 2500.
         #   :consistent_read => true/false  --  as per http://developer.amazonwebservices.com/connect/entry.jspa?externalID=3572
+        #   :retries => maximum number of times to retry this query on an error response.
+        #   :shard => shard name or array of shard names to use on this query.
         def self.find(*params)
             #puts 'params=' + params.inspect
 
@@ -1054,12 +935,6 @@ module SimpleRecord
             id.hash
         end
 
-        private
-        def set_attributes(atts)
-            atts.each_pair do |k, v|
-                set(k, v)
-            end
-        end
 
     end
 

data/lib/simple_record/attributes.rb

@@ -18,207 +18,213 @@ module SimpleRecord
 
         end
 
-        def defined_attributes
-            @attributes ||= {}
-            @attributes
-        end
 
-        def has_attributes(*args)
-            has_attributes2(args)
-        end
+        module ClassMethods
+
 
-        def has_attributes2(args, options_for_all={})
+            def defined_attributes
+                @attributes ||= {}
+                @attributes
+            end
+
+            def has_attributes(*args)
+                has_attributes2(args)
+            end
+
+            def has_attributes2(args, options_for_all={})
 #            puts 'args=' + args.inspect
 #            puts 'options_for_all = ' + options_for_all.inspect
-            args.each do |arg|
-                arg_options = {}
-                if arg.is_a?(Hash)
-                    # then attribute may have extra options
-                    arg_options = arg
-                    arg = arg_options[:name].to_sym
-                end
-                type = options_for_all[:type] || :string
-                attr = Attribute.new(type, arg_options)
-                defined_attributes[arg] = attr if defined_attributes[arg].nil?
-
-                # define reader method
-                arg_s = arg.to_s # to get rid of all the to_s calls
-                send(:define_method, arg) do
-                    ret = get_attribute(arg)
-                    return ret
+                args.each do |arg|
+                    arg_options = {}
+                    if arg.is_a?(Hash)
+                        # then attribute may have extra options
+                        arg_options = arg
+                        arg         = arg_options[:name].to_sym
+                    end
+                    type = options_for_all[:type] || :string
+                    attr = Attribute.new(type, arg_options)
+                    defined_attributes[arg] = attr if defined_attributes[arg].nil?
+
+                    # define reader method
+                    arg_s = arg.to_s # to get rid of all the to_s calls
+                    send(:define_method, arg) do
+                        ret = get_attribute(arg)
+                        return ret
+                    end
+
+                    # define writer method
+                    send(:define_method, arg_s+"=") do |value|
+                        set(arg, value)
+                    end
+
+                    define_dirty_methods(arg_s)
                 end
+            end
 
-                # define writer method
-                send(:define_method, arg_s+"=") do |value|
-                    set(arg, value)
+            def define_dirty_methods(arg_s)
+                # Now for dirty methods: http://api.rubyonrails.org/classes/ActiveRecord/Dirty.html
+                # define changed? method
+                send(:define_method, arg_s + "_changed?") do
+                    @dirty.has_key?(sdb_att_name(arg_s))
                 end
 
-                define_dirty_methods(arg_s)
-            end
-        end
+                # define change method
+                send(:define_method, arg_s + "_change") do
+                    old_val = @dirty[sdb_att_name(arg_s)]
+                    [old_val, get_attribute(arg_s)]
+                end
 
-        def define_dirty_methods(arg_s)
-            # Now for dirty methods: http://api.rubyonrails.org/classes/ActiveRecord/Dirty.html
-            # define changed? method
-            send(:define_method, arg_s + "_changed?") do
-                @dirty.has_key?(sdb_att_name(arg_s))
+                # define was method
+                send(:define_method, arg_s + "_was") do
+                    old_val = @dirty[sdb_att_name(arg_s)]
+                    old_val
+                end
             end
 
-            # define change method
-            send(:define_method, arg_s + "_change") do
-                old_val = @dirty[sdb_att_name(arg_s)]
-                [old_val, get_attribute(arg_s)]
+            def has_strings(*args)
+                has_attributes(*args)
             end
 
-            # define was method
-            send(:define_method, arg_s + "_was") do
-                old_val = @dirty[sdb_att_name(arg_s)]
-                old_val
+            def has_ints(*args)
+                has_attributes(*args)
+                are_ints(*args)
             end
-        end
-
-        def has_strings(*args)
-            has_attributes(*args)
-        end
-
-        def has_ints(*args)
-            has_attributes(*args)
-            are_ints(*args)
-        end
 
-        def has_floats(*args)
-            has_attributes(*args)
-            are_floats(*args)
-        end
-
-        def has_dates(*args)
-            has_attributes(*args)
-            are_dates(*args)
-        end
-
-        def has_booleans(*args)
-            has_attributes(*args)
-            are_booleans(*args)
-        end
-
-        def are_ints(*args)
-            #    puts 'calling are_ints: ' + args.inspect
-            args.each do |arg|
-                defined_attributes[arg].type = :int
+            def has_floats(*args)
+                has_attributes(*args)
+                are_floats(*args)
             end
-        end
 
-        def are_floats(*args)
-            #    puts 'calling are_ints: ' + args.inspect
-            args.each do |arg|
-                defined_attributes[arg].type = :float
+            def has_dates(*args)
+                has_attributes(*args)
+                are_dates(*args)
             end
-        end
 
-        def are_dates(*args)
-            args.each do |arg|
-                defined_attributes[arg].type = :date
+            def has_booleans(*args)
+                has_attributes(*args)
+                are_booleans(*args)
             end
-        end
 
-        def are_booleans(*args)
-            args.each do |arg|
-                defined_attributes[arg].type = :boolean
+            def are_ints(*args)
+                #    puts 'calling are_ints: ' + args.inspect
+                args.each do |arg|
+                    defined_attributes[arg].type = :int
+                end
             end
-        end
 
-        def has_clobs(*args)
-            has_attributes2(args, :type=>:clob)
-
-        end
+            def are_floats(*args)
+                #    puts 'calling are_ints: ' + args.inspect
+                args.each do |arg|
+                    defined_attributes[arg].type = :float
+                end
+            end
 
-        @@virtuals=[]
+            def are_dates(*args)
+                args.each do |arg|
+                    defined_attributes[arg].type = :date
+                end
+            end
 
-        def has_virtuals(*args)
-            @@virtuals = args
-            args.each do |arg|
-                #we just create the accessor functions here, the actual instance variable is created during initialize
-                attr_accessor(arg)
+            def are_booleans(*args)
+                args.each do |arg|
+                    defined_attributes[arg].type = :boolean
+                end
             end
-        end
 
-        # One belongs_to association per call. Call multiple times if there are more than one.
-        #
-        # This method will also create an {association)_id method that will return the ID of the foreign object
-        # without actually materializing it.
-        #
-        # options:
-        #     :class_name=>"User" - to change the default class to use
-        def belongs_to(association_id, options = {})
-            arg = association_id
-            arg_s = arg.to_s
-            arg_id = arg.to_s + '_id'
-            attribute = Attribute.new(:belongs_to, options)
-            defined_attributes[arg] = attribute
+            def has_clobs(*args)
+                has_attributes2(args, :type=>:clob)
 
-            # todo: should also handle foreign_key http://74.125.95.132/search?q=cache:KqLkxuXiBBQJ:wiki.rubyonrails.org/rails/show/belongs_to+rails+belongs_to&hl=en&ct=clnk&cd=1&gl=us
-            #    puts "arg_id=#{arg}_id"
-            #        puts "is defined? " + eval("(defined? #{arg}_id)").to_s
-            #        puts 'atts=' + @attributes.inspect
+            end
 
-            # Define reader method
-            send(:define_method, arg) do
-                return get_attribute(arg)
+            def has_virtuals(*args)
+                @@virtuals = args
+                args.each do |arg|
+                    #we just create the accessor functions here, the actual instance variable is created during initialize
+                    attr_accessor(arg)
+                end
             end
 
+            # One belongs_to association per call. Call multiple times if there are more than one.
+            #
+            # This method will also create an {association)_id method that will return the ID of the foreign object
+            # without actually materializing it.
+            #
+            # options:
+            #     :class_name=>"User" - to change the default class to use
+            def belongs_to(association_id, options = {})
+                arg                     = association_id
+                arg_s                   = arg.to_s
+                arg_id                  = arg.to_s + '_id'
+                attribute               = Attribute.new(:belongs_to, options)
+                defined_attributes[arg] = attribute
+
+                # todo: should also handle foreign_key http://74.125.95.132/search?q=cache:KqLkxuXiBBQJ:wiki.rubyonrails.org/rails/show/belongs_to+rails+belongs_to&hl=en&ct=clnk&cd=1&gl=us
+                #    puts "arg_id=#{arg}_id"
+                #        puts "is defined? " + eval("(defined? #{arg}_id)").to_s
+                #        puts 'atts=' + @attributes.inspect
+
+                # Define reader method
+                send(:define_method, arg) do
+                    return get_attribute(arg)
+                end
 
-            # Define writer method
-            send(:define_method, arg.to_s + "=") do |value|
-                set(arg, value)
-            end
 
+                # Define writer method
+                send(:define_method, arg.to_s + "=") do |value|
+                    set(arg, value)
+                end
 
-            # Define ID reader method for reading the associated objects id without getting the entire object
-            send(:define_method, arg_id) do
-                get_attribute_sdb(arg_s)
-            end
 
-            # Define writer method for setting the _id directly without the associated object
-            send(:define_method, arg_id + "=") do |value|
+                # Define ID reader method for reading the associated objects id without getting the entire object
+                send(:define_method, arg_id) do
+                    get_attribute_sdb(arg_s)
+                end
+
+                # Define writer method for setting the _id directly without the associated object
+                send(:define_method, arg_id + "=") do |value|
 #                rb_att_name = arg_s # n2 = name.to_s[0, name.length-3]
-                set(arg_id, value)
+                    set(arg_id, value)
 #                if value.nil?
 #                    self[arg_id] = nil unless self[arg_id].nil? # if it went from something to nil, then we have to remember and remove attribute on save
 #                else
 #                    self[arg_id] = value
 #                end
+                end
+
+                send(:define_method, "create_"+arg.to_s) do |*params|
+                    newsubrecord=eval(arg.to_s.classify).new(*params)
+                    newsubrecord.save
+                    arg_id      = arg.to_s + '_id'
+                    self[arg_id]=newsubrecord.id
+                end
+
+                define_dirty_methods(arg_s)
             end
 
-            send(:define_method, "create_"+arg.to_s) do |*params|
-                newsubrecord=eval(arg.to_s.classify).new(*params)
-                newsubrecord.save
-                arg_id = arg.to_s + '_id'
-                self[arg_id]=newsubrecord.id
+            def has_many(*args)
+                args.each do |arg|
+                    #okay, this creates an instance method with the pluralized name of the symbol passed to belongs_to
+                    send(:define_method, arg) do
+                        #when called, the method creates a new, very temporary instance of the Activerecordtosdb_subrecord class
+                        #It is passed the three initializers it needs:
+                        #note the first parameter is just a string by time new gets it, like "user"
+                        #the second and third parameters are still a variable when new gets it, like user_id
+                        return eval(%{Activerecordtosdb_subrecord_array.new('#{arg}', self.class.name ,id)})
+                    end
+                end
+                #Disclaimer: this whole funciton just seems crazy to me, and a bit inefficient. But it was the clearest way I could think to do it code wise.
+                #It's bad programming form (imo) to have a class method require something that isn't passed to it through it's variables.
+                #I couldn't pass the id when calling find, since the original find doesn't work that way, so I was left with this.
             end
 
-            define_dirty_methods(arg_s)
-        end
+            def has_one(*args)
 
-        def has_many(*args)
-            args.each do |arg|
-                #okay, this creates an instance method with the pluralized name of the symbol passed to belongs_to
-                send(:define_method, arg) do
-                    #when called, the method creates a new, very temporary instance of the Activerecordtosdb_subrecord class
-                    #It is passed the three initializers it needs:
-                    #note the first parameter is just a string by time new gets it, like "user"
-                    #the second and third parameters are still a variable when new gets it, like user_id
-                    return eval(%{Activerecordtosdb_subrecord_array.new('#{arg}', self.class.name ,id)})
-                end
             end
-            #Disclaimer: this whole funciton just seems crazy to me, and a bit inefficient. But it was the clearest way I could think to do it code wise.
-            #It's bad programming form (imo) to have a class method require something that isn't passed to it through it's variables.
-            #I couldn't pass the id when calling find, since the original find doesn't work that way, so I was left with this.
-        end
 
-        def has_one(*args)
 
         end
 
+        @@virtuals=[]
 
         def self.handle_virtuals(attrs)
             @@virtuals.each do |virtual|
@@ -229,12 +235,149 @@ module SimpleRecord
             end
         end
 
+
+        def set(name, value, dirtify=true)
+#            puts "SET #{name}=#{value.inspect}" if SimpleRecord.logging?
+#            puts "self=" + self.inspect
+            attname      = name.to_s # default attname
+            name         = name.to_sym
+            att_meta     = get_att_meta(name)
+            store_rb_val = false
+            if att_meta.nil?
+                # check if it ends with id and see if att_meta is there
+                ends_with = name.to_s[-3, 3]
+                if ends_with == "_id"
+#                    puts 'ends with id'
+                    n2       = name.to_s[0, name.length-3]
+#                    puts 'n2=' + n2
+                    att_meta = defined_attributes_local[n2.to_sym]
+#                    puts 'defined_attributes_local=' + defined_attributes_local.inspect
+                    attname  = name.to_s
+                    attvalue = value
+                    name     = n2.to_sym
+                end
+                return if att_meta.nil?
+            else
+                if att_meta.type == :belongs_to
+                    ends_with = name.to_s[-3, 3]
+                    if ends_with == "_id"
+                        att_name = name.to_s
+                        attvalue = value
+                    else
+                        attname      = name.to_s + '_id'
+                        attvalue     = value.nil? ? nil : value.id
+                        store_rb_val = true
+                    end
+                elsif att_meta.type == :clob
+                    make_dirty(name, value) if dirtify
+                    @lobs[name] = value
+                    return
+                else
+                    attname  = name.to_s
+                    attvalue = att_meta.init_value(value)
+#                  attvalue = value
+                    #puts 'converted ' + value.inspect + ' to ' + attvalue.inspect
+                end
+            end
+            attvalue = strip_array(attvalue)
+            make_dirty(name, attvalue) if dirtify
+#            puts "ARG=#{attname.to_s} setting to #{attvalue}"
+            sdb_val              = ruby_to_sdb(name, attvalue)
+#            puts "sdb_val=" + sdb_val.to_s
+            @attributes[attname] = sdb_val
+#            attvalue = wrap_if_required(name, attvalue, sdb_val)
+#            puts 'attvalue2=' + attvalue.to_s
+
+            if store_rb_val
+                @attributes_rb[name.to_s] = value
+            else
+                @attributes_rb.delete(name.to_s)
+            end
+
+        end
+
+
+        def set_attribute_sdb(name, val)
+            @attributes[sdb_att_name(name)] = val
+        end
+
+
+        def get_attribute_sdb(name)
+            name = name.to_sym
+            ret  = strip_array(@attributes[sdb_att_name(name)])
+            return ret
+        end
+
+        # Since SimpleDB supports multiple attributes per value, the values are an array.
+        # This method will return the value unwrapped if it's the only, otherwise it will return the array.
+        def get_attribute(name)
+#            puts "get_attribute #{name}"
+            # Check if this arg is already converted
+            name_s   = name.to_s
+            name     = name.to_sym
+            att_meta = get_att_meta(name)
+#            puts "att_meta for #{name}: " + att_meta.inspect
+            if att_meta && att_meta.type == :clob
+                ret = @lobs[name]
+#                puts 'get_attribute clob ' + ret.inspect
+                if ret
+                    if ret.is_a? RemoteNil
+                        return nil
+                    else
+                        return ret
+                    end
+                end
+                # get it from s3
+                unless new_record?
+                    begin
+                        ret                        = s3_bucket.get(s3_lob_id(name))
+#                        puts 'got from s3 ' + ret.inspect
+                        SimpleRecord.stats.s3_gets += 1
+                    rescue Aws::AwsError => ex
+                        if ex.include? /NoSuchKey/
+                            ret = nil
+                        else
+                            raise ex
+                        end
+                    end
+
+                    if ret.nil?
+                        ret = RemoteNil.new
+                    end
+                end
+                @lobs[name] = ret
+                return nil if ret.is_a? RemoteNil
+                return ret
+            else
+                @attributes_rb = {} unless @attributes_rb # was getting errors after upgrade.
+                ret = @attributes_rb[name_s] # instance_variable_get(instance_var)
+                return ret unless ret.nil?
+                return nil if ret.is_a? RemoteNil
+                ret                    = get_attribute_sdb(name)
+#                p ret
+                ret                    = sdb_to_ruby(name, ret)
+#                p ret
+                @attributes_rb[name_s] = ret
+                return ret
+            end
+
+        end
+
+
+        private
+        def set_attributes(atts)
+            atts.each_pair do |k, v|
+                set(k, v)
+            end
+        end
+
+
         # Holds information about an attribute
         class Attribute
             attr_accessor :type, :options
 
             def initialize(type, options=nil)
-                @type = type
+                @type    = type
                 @options = options
             end
 
@@ -243,7 +386,11 @@ module SimpleRecord
                 ret = value
                 case self.type
                     when :int
-                        ret = value.to_i
+                        if value.is_a? Array
+                            ret = value.collect { |x| x.to_i }
+                        else
+                            ret = value.to_i
+                        end
                 end
                 ret
             end

data/lib/simple_record/sharding.rb

@@ -25,8 +25,13 @@ module SimpleRecord
 
                 options = params.size > 1 ? params[1] : {}
 
-                domains = sharded_domains
-                puts "sharded_domains=" + domains.inspect
+                if options[:shard] # User specified shard.
+                    shard   = options[:shard]
+                    domains = shard.is_a?(Array) ? (shard.collect { |x| prefix_shard_name(x) }) : [ prefix_shard_name(shard)]
+                else
+                    domains = sharded_domains
+                end
+#                puts "sharded_domains=" + domains.inspect
 
                 single = false
                 case params.first
@@ -69,17 +74,21 @@ module SimpleRecord
                 send(sharding_options[:shards])
             end
 
+            def prefix_shard_name(s)
+                "#{domain}_#{s}"
+            end
+
+
             def sharded_domains
                 sharded_domains = []
                 shard_names     = shards
                 shard_names.each do |s|
-                    sharded_domains << "#{domain}_#{s}"
+                    sharded_domains << prefix_shard_name(s)
                 end
                 sharded_domains
             end
         end
 
-
         def sharded_domain
 #            puts 'getting sharded_domain'
             options        = self.class.sharding_options
@@ -90,7 +99,7 @@ module SimpleRecord
 #                shards = self.send(shards)
 #            end
             sharded_domain = "#{domain}_#{self.send(options[:map])}"
-            puts "sharded_domain=" + sharded_domain.inspect
+#            puts "sharded_domain=" + sharded_domain.inspect
             sharded_domain
         end
 

data/lib/simple_record/translations.rb

@@ -2,30 +2,37 @@
 module SimpleRecord
     module Translations
 
-        @@offset = 9223372036854775808
-        @@padding = 20
-        @@date_format = "%Y-%m-%dT%H:%M:%S"; # Time to second precision
+        @@offset      = 9223372036854775808
+        @@padding     = 20
+        @@date_format = "%Y-%m-%dT%H:%M:%S";
 
-        def ruby_to_sdb(name, value)
+        def ruby_to_string_val(att_meta, value)
+            if att_meta.type == :int
+                ret = Translations.pad_and_offset(value, att_meta)
+            elsif att_meta.type == :date
+                ret = Translations.pad_and_offset(value, att_meta)
+            else
+                ret = value.to_s
+            end
+            ret
+        end
 
-            return nil if value.nil?
+        # Time to second precision
 
+        def ruby_to_sdb(name, value)
+            return nil if value.nil?
             name = name.to_s
-
 #            puts "Converting #{name} to sdb value=#{value}"
 #            puts "atts_local=" + defined_attributes_local.inspect
 
             att_meta = get_att_meta(name)
 
-            if att_meta.type == :int
-                ret = Translations.pad_and_offset(value, att_meta)
-            elsif att_meta.type == :date
-                ret = Translations.pad_and_offset(value, att_meta)
+            if value.is_a? Array
+                ret = value.collect { |x| ruby_to_string_val(att_meta, x) }
             else
-                ret = value.to_s
+                ret = ruby_to_string_val(att_meta, value)
             end
 
-
             unless value.blank?
                 if att_meta.options
                     if att_meta.options[:encrypted]
@@ -41,7 +48,7 @@ module SimpleRecord
                 end
             end
 
-            return ret.to_s
+            return ret
 
         end
 
@@ -68,15 +75,15 @@ module SimpleRecord
                 class_name = class_name.camelize
                 #      puts "attr=" + @attributes[arg_id].inspect
                 #      puts 'val=' + @attributes[arg_id][0].inspect unless @attributes[arg_id].nil?
-                ret = nil
-                arg_id = name.to_s + '_id'
+                ret        = nil
+                arg_id     = name.to_s + '_id'
                 arg_id_val = send("#{arg_id}")
                 if arg_id_val
                     if !cache_store.nil?
 #                        arg_id_val = @attributes[arg_id][0]
                         cache_key = self.class.cache_key(class_name, arg_id_val)
 #          puts 'cache_key=' + cache_key
-                        ret = cache_store.read(cache_key)
+                        ret       = cache_store.read(cache_key)
 #          puts 'belongs_to incache=' + ret.inspect
                     end
                     if ret.nil?
@@ -95,7 +102,18 @@ module SimpleRecord
                     end
                 end
                 value = ret
-            elsif att_meta.type == :int
+            else
+                if value.is_a? Array
+                    value = value.collect { |x| string_val_to_ruby(att_meta, x) }
+                else
+                    value = string_val_to_ruby(att_meta, value)
+                end
+            end
+            value
+        end
+
+        def string_val_to_ruby(att_meta, value)
+            if att_meta.type == :int
                 value = Translations.un_offset_int(value)
             elsif att_meta.type == :date
                 value = to_date(value)
@@ -110,7 +128,7 @@ module SimpleRecord
             # todo: add Float, etc
             #    puts 'padding=' + x.class.name + " -- " + x.inspect
             if x.kind_of? Integer
-                x += @@offset
+                x     += @@offset
                 x_str = x.to_s
                 # pad
                 x_str = '0' + x_str while x_str.size < 20
@@ -139,7 +157,7 @@ module SimpleRecord
         end
 
         # This conversion to a string is based on: http://tools.ietf.org/html/draft-wood-ldapext-float-00
-        # Java code sample is here: http://code.google.com/p/typica/source/browse/trunk/java/com/xerox/amazonws/simpledb/DataUtils.java        
+        # Java code sample is here: http://code.google.com/p/typica/source/browse/trunk/java/com/xerox/amazonws/simpledb/DataUtils.java
         def self.from_float(x)
             return x
 #            if x == 0.0
@@ -192,7 +210,7 @@ module SimpleRecord
         def unpad(i, attributes)
             if !attributes[i].nil?
 #          puts 'before=' + self[i].inspect
-                attributes[i].collect!{ |x|
+                attributes[i].collect! { |x|
                     un_offset_int(x)
 
                 }
@@ -212,7 +230,7 @@ module SimpleRecord
             key = key || get_encryption_key()
             raise SimpleRecordError, "Encryption key must be defined on the attribute." if key.nil?
             encrypted_value = SimpleRecord::Encryptor.encrypt(:value => value, :key => key)
-            encoded_value = Base64.encode64(encrypted_value)
+            encoded_value   = Base64.encode64(encrypted_value)
             encoded_value
         end
 
@@ -221,7 +239,7 @@ module SimpleRecord
 #            puts "decrypt orig value #{value} "
             unencoded_value = Base64.decode64(value)
             raise SimpleRecordError, "Encryption key must be defined on the attribute." if key.nil?
-            key = key || get_encryption_key()
+            key             = key || get_encryption_key()
 #            puts "decrypting #{unencoded_value} "
             decrypted_value = SimpleRecord::Encryptor.decrypt(:value => unencoded_value, :key => key)
 #             "decrypted #{unencoded_value} to #{decrypted_value}"
@@ -249,7 +267,7 @@ module SimpleRecord
         end
 
         def self.pass_hash(value)
-            hashed = Password::create_hash(value)
+            hashed        = Password::create_hash(value)
             encoded_value = Base64.encode64(hashed)
             encoded_value
         end

data/test/test_base.rb

@@ -32,7 +32,7 @@ class TestBase < Test::Unit::TestCase
 
     def reset_connection
         puts 'reset_connection'
-        @config = YAML::load(File.open(File.expand_path("~/.test-configs/simple_record.yml")))
+        @config = YAML::load(File.open(File.expand_path("~/.test_configs/simple_record.yml")))
         #puts 'inspecting config = ' + @config.inspect
 
         SimpleRecord.enable_logging

data/test/test_shards.rb

@@ -13,6 +13,7 @@ class TestShards < TestBase
     def setup
         super
         delete_all MyShardedModel
+        delete_all MyShardedByFieldModel
     end
 
     def teardown
@@ -96,6 +97,7 @@ class TestShards < TestBase
             saved << mm
         end
 
+        sleep 1
         # todo: assert that we're actually sharding
 
         puts "finding them all"
@@ -109,6 +111,22 @@ class TestShards < TestBase
             assert(found.find { |m1| m1.id == so.id })
         end
 
+        rs    = MyShardedByFieldModel.find(:all)
+        rs.each do |m|
+            p m
+            found << m
+        end
+        saved.each do |so|
+            assert(found.find { |m1| m1.id == so.id })
+        end
+
+        # Try to find on a specific known shard
+        selects = SimpleRecord.stats.selects
+        cali_models = MyShardedByFieldModel.find(:all, :shard => "CA")
+        puts 'cali_models=' + cali_models.inspect
+        assert_equal(5, cali_models.size)
+        assert_equal(selects + 1, SimpleRecord.stats.selects)
+
         puts "deleting all of them"
         found.each do |fo|
             fo.delete

data/test/{simple_record_test.rb → test_simple_record.rb}

@@ -11,7 +11,7 @@ require_relative 'model_with_enc'
 # Tests for SimpleRecord
 #
 
-class SimpleRecordTest < TestBase
+class TestSimpleRecord < TestBase
 
 
     def test_save_get
@@ -682,6 +682,29 @@ class SimpleRecordTest < TestBase
         assert mms.box_usage && mms.box_usage > 0
         assert mms.request_id
 
+    end
+
+    def test_multi_value_attributes
+
+        val = ['a', 'b', 'c']
+        val2 = [1, 2, 3]
+
+        mm = MyModel.new
+        mm.name = val
+        mm.age = val2
+        assert_equal val, mm.name
+        assert_equal val2, mm.age
+        mm.save
+
+        sleep 1
+        mm = MyModel.find(mm.id)
+        # Values are not returned in order
+        assert_equal val, mm.name.sort
+        assert_equal val2, mm.age.sort
+
+
+
+
     end
 
 end

metadata

@@ -3,10 +3,10 @@ name: simple_record
 version: !ruby/object:Gem::Version 
   prerelease: false
   segments: 
-  - 1
-  - 5
-  - 8
-  version: 1.5.8
+  - 2
+  - 0
+  - 0
+  version: 2.0.0
 platform: ruby
 authors: 
 - Travis Reeder
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-03 00:00:00 -08:00
+date: 2010-12-07 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -64,7 +64,6 @@ files:
 - test/my_model.rb
 - test/my_sharded_model.rb
 - test/paging_array_test.rb
-- test/simple_record_test.rb
 - test/temp.rb
 - test/temp_test.rb
 - test/test_base.rb
@@ -79,6 +78,7 @@ files:
 - test/test_rails3.rb
 - test/test_results_array.rb
 - test/test_shards.rb
+- test/test_simple_record.rb
 - test/test_usage.rb
 has_rdoc: true
 homepage: http://github.com/appoxy/simple_record/
@@ -120,7 +120,6 @@ test_files:
 - test/my_model.rb
 - test/my_sharded_model.rb
 - test/paging_array_test.rb
-- test/simple_record_test.rb
 - test/temp.rb
 - test/temp_test.rb
 - test/test_base.rb
@@ -135,4 +134,5 @@ test_files:
 - test/test_rails3.rb
 - test/test_results_array.rb
 - test/test_shards.rb
+- test/test_simple_record.rb
 - test/test_usage.rb