dm-adapter-simpledb 1.0.0 → 1.1.0

data/.gitignore

@@ -6,3 +6,4 @@ log/**
 pkg/**
 /THROW_AWAY_SDB_DOMAIN
 /TODO
+/TAGS

data/History.txt

@@ -0,0 +1,21 @@
+== 1.1.0 2009-11-24
+
+* 2 major enhancements:
+  * Supports legacy (pre-1.0.0) objects
+    
+    Prior to version 1.0.0 there were some differences in how this adapter
+    stored nils and strings containing newlines. The adapter will now detect old
+    objects and load them correctly.
+
+  * Adds object versioning
+
+    New records created by the adapter now have version metadata attached to
+    them, making it easier to change how objects are stored in the future.
+
+* 1 bug fix
+  * Fixed an "odd number of arguments for hash" error when saving objects.
+
+* Cleanup/refactoring
+  * Work has begun to start splitting out functionality into separate files and
+    classes
+  * Added unit tests to complement the existing integration tests

data/README

@@ -38,21 +38,30 @@ http://github.com/devver/dm-adapter-simpledb/
 
 == TODO
 
- * Backwards-compatibility option for nils stored as "nil" string
  * More complete handling of NOT conditions in queries
  * Robust quoting in SELECT calls
  * Handle exclusive ranges natively
    Implement as inclusive range + filter step
  * Tests for associations
- * Split up into multiple files
  * Option for smart lexicographical storage for numbers
    - Zero-pad integers
    - Store floats using exponential notation
  * Option to store Date/Time/DateTime as ISO8601
  * Full aggregate support (min/max/etc)
+ * Offset support
+   Note, from the SimpleDB documentation:
+   
+   "The next token returned by count(*) and select are interchangeable as long
+   as the where and order by clauses match. For example, if you want to return
+   the 200 items after the first 10,000 (similar to an offset), you can perform
+   a count with a limit clause of 10,000 and use the next token to return the
+   next 200 items with select."
+
  * Option to use libxml if available
  * Parallelized queries for increased throughput
  * Support of normalized 1:1 table:domain schemes that works with associations
+ * Sharding
+ * Support BatchPutAttributes
 
 == Usage
   
@@ -60,8 +69,14 @@ http://github.com/devver/dm-adapter-simpledb/
   
     require 'rubygems'
     require 'dm-core'
+    require 'dm-adapter-simpledb'
     
-    DataMapper.setup(:default, 'simpledb://ACCESS_KEY:SECRET_KEY@sdb.amazon.com/DOMAIN')
+    DataMapper.setup(:default, 
+      :adapter       => 'simpledb',
+      :access_key    => "ACCESS_KEY",
+      :secret_key    => "SECRET_KEY",
+      :domain        => "DOMAIN",
+    )
     
     [Same as the following, but skip the database.yml]
     
@@ -71,19 +86,17 @@ http://github.com/devver/dm-adapter-simpledb/
   
     Setup database.yml with the SimpleDB DataMapper adapter:
 
-      adapter:  simpledb
-      database: 'default'
+      adapter:    simpledb
       access_key: (a 20-character, alphanumeric sequence)
       secret_key: (a 40-character sequence)
-      domain: 'my_amazon_sdb_domain'
-      base_url: 'http://sdb.amazon.com'
+      domain:     'my_amazon_sdb_domain'
 
     Create a model
   
       class Tree
         include DataMapper::Resource
       
-        storage_name "trees"  # manually setting the domain
+        storage_name[:default] = "trees"
       
         property :id,   Serial
         property :name, String, :nullable => false

data/Rakefile

@@ -1,36 +1,46 @@
 require 'spec'
 require 'spec/rake/spectask'
 require 'pathname'
-load 'tasks/devver.rake'
 
 ROOT = Pathname(__FILE__).dirname.expand_path
-require ROOT + 'lib/simpledb_adapter'
 
-task :default => [ :spec ]
+task :default => [ 'spec:unit' ]
 
-desc 'Run specifications'
-Spec::Rake::SpecTask.new(:spec) do |t|
-  if File.exists?('spec/spec.opts')
-    t.spec_opts << '--options' << 'spec/spec.opts'
+namespace :spec do
+  desc 'Run unit-level specifications'
+  Spec::Rake::SpecTask.new(:unit) do |t|
+    if File.exists?('spec/spec.opts')
+      t.spec_opts << '--options' << 'spec/spec.opts'
+    end
+    t.spec_files = Pathname.glob((ROOT + 'spec/unit/**/*_spec.rb').to_s)
+    
+    begin
+      t.rcov = ENV.has_key?('NO_RCOV') ? ENV['NO_RCOV'] != 'true' : true
+      t.rcov_opts << '--exclude' << 'spec'
+      t.rcov_opts << '--text-summary'
+      t.rcov_opts << '--sort' << 'coverage' << '--sort-reverse'
+    rescue Exception
+      # rcov not installed
+    end
   end
-  t.spec_files = Pathname.glob((ROOT + 'spec/**/*_spec.rb').to_s)
- 
-  begin
-    t.rcov = ENV.has_key?('NO_RCOV') ? ENV['NO_RCOV'] != 'true' : true
-    t.rcov_opts << '--exclude' << 'spec'
-    t.rcov_opts << '--text-summary'
-    t.rcov_opts << '--sort' << 'coverage' << '--sort-reverse'
-  rescue Exception
-    # rcov not installed
-  end
-end
 
-desc 'Run specifications without Rcov'
-Spec::Rake::SpecTask.new(:spec_no_rcov) do |t|
-  if File.exists?('spec/spec.opts')
-    t.spec_opts << '--options' << 'spec/spec.opts'
+  desc 'Run integration-level specifications'
+  Spec::Rake::SpecTask.new(:integration) do |t|
+    if File.exists?('spec/spec.opts')
+      t.spec_opts << '--options' << 'spec/spec.opts'
+    end
+    t.spec_files = Pathname.glob((ROOT + 'spec/integration/**/*_spec.rb').to_s)
+    
+    begin
+      t.rcov = ENV.has_key?('NO_RCOV') ? ENV['NO_RCOV'] != 'true' : true
+      t.rcov_opts << '--exclude' << 'spec'
+      t.rcov_opts << '--text-summary'
+      t.rcov_opts << '--sort' << 'coverage' << '--sort-reverse'
+    rescue Exception
+      # rcov not installed
+    end
   end
-  t.spec_files = Pathname.glob((ROOT + 'spec/**/*_spec.rb').to_s)
+
 end
 
 begin
@@ -68,6 +78,8 @@ END
     ]
     gem.add_dependency('dm-core',               '~> 0.10.0')
     gem.add_dependency('dm-aggregates',         '~> 0.10.0')
+    gem.add_dependency('dm-migrations',         '~> 0.10.0')
+    gem.add_dependency('dm-types',              '~> 0.10.0')
     gem.add_dependency('uuidtools',             '~> 2.0')
     gem.add_dependency('right_aws',             '~> 1.10')
   end

data/VERSION

@@ -1 +1 @@
-1.0.0
+1.1.0

data/dm-adapter-simpledb.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{dm-adapter-simpledb}
-  s.version = "1.0.0"
+  s.version = "1.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Jeremy Boles", "Edward Ocampo-Gooding", "Dan Mayer", "Thomas Olausson", "Avdi Grimm"]
-  s.date = %q{2009-11-16}
+  s.date = %q{2009-11-24}
   s.description = %q{A DataMapper adapter for Amazon's SimpleDB service. 
 
 Features:
@@ -35,26 +35,37 @@ series and breaks backwards compatibility with DataMapper 0.9.*.
   s.files = [
     ".autotest",
      ".gitignore",
+     "History.txt",
      "README",
      "Rakefile",
      "VERSION",
      "aws_config.sample",
      "dm-adapter-simpledb.gemspec",
+     "lib/dm-adapter-simpledb.rb",
+     "lib/dm-adapter-simpledb/adapters/simpledb_adapter.rb",
+     "lib/dm-adapter-simpledb/chunked_string.rb",
+     "lib/dm-adapter-simpledb/migrations/simpledb_adapter.rb",
+     "lib/dm-adapter-simpledb/rake.rb",
+     "lib/dm-adapter-simpledb/record.rb",
+     "lib/dm-adapter-simpledb/sdb_array.rb",
+     "lib/dm-adapter-simpledb/table.rb",
+     "lib/dm-adapter-simpledb/utils.rb",
      "lib/simpledb_adapter.rb",
-     "lib/simpledb_adapter/sdb_array.rb",
      "scripts/simple_benchmark.rb",
-     "spec/associations_spec.rb",
-     "spec/compliance_spec.rb",
-     "spec/date_spec.rb",
-     "spec/limit_and_order_spec.rb",
-     "spec/migrations_spec.rb",
-     "spec/multiple_records_spec.rb",
-     "spec/nils_spec.rb",
-     "spec/sdb_array_spec.rb",
-     "spec/simpledb_adapter_spec.rb",
+     "spec/integration/associations_spec.rb",
+     "spec/integration/compliance_spec.rb",
+     "spec/integration/date_spec.rb",
+     "spec/integration/limit_and_order_spec.rb",
+     "spec/integration/migrations_spec.rb",
+     "spec/integration/multiple_records_spec.rb",
+     "spec/integration/nils_spec.rb",
+     "spec/integration/sdb_array_spec.rb",
+     "spec/integration/simpledb_adapter_spec.rb",
+     "spec/integration/spec_helper.rb",
      "spec/spec.opts",
-     "spec/spec_helper.rb",
-     "tasks/devver.rake"
+     "spec/unit/record_spec.rb",
+     "spec/unit/simpledb_adapter_spec.rb",
+     "spec/unit/unit_spec_helper.rb"
   ]
   s.homepage = %q{http://github.com/devver/dm-adapter-simpledb}
   s.rdoc_options = ["--charset=UTF-8"]
@@ -62,16 +73,19 @@ series and breaks backwards compatibility with DataMapper 0.9.*.
   s.rubygems_version = %q{1.3.5}
   s.summary = %q{DataMapper adapter for Amazon SimpleDB}
   s.test_files = [
-    "spec/nils_spec.rb",
-     "spec/limit_and_order_spec.rb",
-     "spec/compliance_spec.rb",
-     "spec/simpledb_adapter_spec.rb",
-     "spec/date_spec.rb",
-     "spec/sdb_array_spec.rb",
-     "spec/migrations_spec.rb",
-     "spec/spec_helper.rb",
-     "spec/multiple_records_spec.rb",
-     "spec/associations_spec.rb"
+    "spec/integration/nils_spec.rb",
+     "spec/integration/limit_and_order_spec.rb",
+     "spec/integration/compliance_spec.rb",
+     "spec/integration/simpledb_adapter_spec.rb",
+     "spec/integration/date_spec.rb",
+     "spec/integration/sdb_array_spec.rb",
+     "spec/integration/migrations_spec.rb",
+     "spec/integration/spec_helper.rb",
+     "spec/integration/multiple_records_spec.rb",
+     "spec/integration/associations_spec.rb",
+     "spec/unit/simpledb_adapter_spec.rb",
+     "spec/unit/unit_spec_helper.rb",
+     "spec/unit/record_spec.rb"
   ]
 
   if s.respond_to? :specification_version then
@@ -81,17 +95,23 @@ series and breaks backwards compatibility with DataMapper 0.9.*.
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<dm-core>, ["~> 0.10.0"])
       s.add_runtime_dependency(%q<dm-aggregates>, ["~> 0.10.0"])
+      s.add_runtime_dependency(%q<dm-migrations>, ["~> 0.10.0"])
+      s.add_runtime_dependency(%q<dm-types>, ["~> 0.10.0"])
       s.add_runtime_dependency(%q<uuidtools>, ["~> 2.0"])
       s.add_runtime_dependency(%q<right_aws>, ["~> 1.10"])
     else
       s.add_dependency(%q<dm-core>, ["~> 0.10.0"])
       s.add_dependency(%q<dm-aggregates>, ["~> 0.10.0"])
+      s.add_dependency(%q<dm-migrations>, ["~> 0.10.0"])
+      s.add_dependency(%q<dm-types>, ["~> 0.10.0"])
       s.add_dependency(%q<uuidtools>, ["~> 2.0"])
       s.add_dependency(%q<right_aws>, ["~> 1.10"])
     end
   else
     s.add_dependency(%q<dm-core>, ["~> 0.10.0"])
     s.add_dependency(%q<dm-aggregates>, ["~> 0.10.0"])
+    s.add_dependency(%q<dm-migrations>, ["~> 0.10.0"])
+    s.add_dependency(%q<dm-types>, ["~> 0.10.0"])
     s.add_dependency(%q<uuidtools>, ["~> 2.0"])
     s.add_dependency(%q<right_aws>, ["~> 1.10"])
   end

data/lib/dm-adapter-simpledb.rb

@@ -0,0 +1,17 @@
+gem 'dm-migrations', '~> 0.10.0'
+gem 'dm-types',      '~> 0.10.0'
+gem 'dm-aggregates', '~> 0.10.0'
+gem 'dm-core',       '~> 0.10.0'
+
+require 'dm-core'
+require 'dm-aggregates'
+require 'digest/sha1'
+require 'right_aws'
+require 'uuidtools'
+
+require 'dm-adapter-simpledb/sdb_array'
+require 'dm-adapter-simpledb/utils'
+require 'dm-adapter-simpledb/record'
+require 'dm-adapter-simpledb/table'
+require 'dm-adapter-simpledb/migrations/simpledb_adapter'
+require 'dm-adapter-simpledb/adapters/simpledb_adapter'

data/lib/dm-adapter-simpledb/adapters/simpledb_adapter.rb

@@ -0,0 +1,339 @@
+module DataMapper
+  module Adapters
+    class SimpleDBAdapter < AbstractAdapter
+      include DmAdapterSimpledb::Utils
+
+      attr_reader :sdb_options
+
+      # For testing purposes ONLY. Seriously, don't enable this for production
+      # code.
+      attr_accessor :consistency_policy
+
+      def initialize(name, normalised_options)
+        super
+        @sdb_options = {}
+        @sdb_options[:access_key] = options.fetch(:access_key) { 
+          options[:user] 
+        }
+        @sdb_options[:secret_key] = options.fetch(:secret_key) { 
+          options[:password] 
+        }
+        @sdb_options[:logger] = options.fetch(:logger) { DataMapper.logger }
+        @sdb_options[:server] = options.fetch(:host) { 'sdb.amazonaws.com' }
+        @sdb_options[:port]   = options[:port] || 443 # port may be set but nil
+        @sdb_options[:domain] = options.fetch(:domain) { 
+          options[:path].to_s.gsub(%r{(^/+)|(/+$)},"") # remove slashes
+        }
+        # We do not expect to be saving any nils in future, because now we
+        # represent null values by removing the attributes. The representation
+        # here is chosen on the basis of it being unlikely to match any strings
+        # found in real-world records, as well as being eye-catching in case any
+        # nils DO manage to sneak in. It would be preferable if we could disable
+        # RightAWS's nil-token replacement altogether, but that does not appear
+        # to be an option.
+        @sdb_options[:nil_representation] = "<[<[<NIL>]>]>"
+        @consistency_policy = 
+          normalised_options.fetch(:wait_for_consistency) { false }
+        @sdb = options.fetch(:sdb_interface) { nil }
+      end
+
+      def create(resources)
+        created = 0
+        time = Benchmark.realtime do
+          resources.each do |resource|
+            uuid = UUIDTools::UUID.timestamp_create
+            initialize_serial(resource, uuid.to_i)
+
+            record     = DmAdapterSimpledb::Record.from_resource(resource)
+            attributes = record.writable_attributes
+            item_name  = record.item_name
+            sdb.put_attributes(domain, item_name, attributes)
+            created += 1
+          end
+        end
+        DataMapper.logger.debug(format_log_entry("(#{created}) INSERT #{resources.inspect}", time))
+        modified!
+        created
+      end
+      
+      def delete(collection)
+        deleted = 0
+        time = Benchmark.realtime do
+          collection.each do |resource|
+            record = DmAdapterSimpledb::Record.from_resource(resource)
+            item_name = record.item_name
+            sdb.delete_attributes(domain, item_name)
+            deleted += 1
+          end
+          raise NotImplementedError.new('Only :eql on delete at the moment') if not_eql_query?(collection.query)
+        end; DataMapper.logger.debug(format_log_entry("(#{deleted}) DELETE #{collection.query.conditions.inspect}", time))
+        modified!
+        deleted
+      end
+
+      def read(query)
+        maybe_wait_for_consistency
+        table = DmAdapterSimpledb::Table.new(query.model)
+        conditions, order, unsupported_conditions = 
+          set_conditions_and_sort_order(query, table.simpledb_type)
+        results = get_results(query, conditions, order)
+        records = results.map{|result| 
+          DmAdapterSimpledb::Record.from_simpledb_hash(result)
+        }
+
+        proto_resources = records.map{|record|
+          record.to_resource_hash(query.fields)
+        }
+        query.conditions.operands.reject!{ |op|
+          !unsupported_conditions.include?(op)
+        }
+        records = query.filter_records(proto_resources)
+
+        records
+      end
+      
+      def update(attributes, collection)
+        updated = 0
+        time = Benchmark.realtime do
+          collection.each do |resource|
+            updated_resource = resource.dup
+            updated_resource.attributes = attributes
+            record = DmAdapterSimpledb::Record.from_resource(updated_resource)
+            attrs_to_update = record.writable_attributes
+            attrs_to_delete = record.deletable_attributes
+            item_name       = record.item_name
+            unless attrs_to_update.empty?
+              sdb.put_attributes(domain, item_name, attrs_to_update, :replace)
+            end
+            unless attrs_to_delete.empty?
+              sdb.delete_attributes(domain, item_name, attrs_to_delete)
+            end
+            updated += 1
+          end
+          raise NotImplementedError.new('Only :eql on delete at the moment') if not_eql_query?(collection.query)
+        end
+        DataMapper.logger.debug(format_log_entry("UPDATE #{collection.query.conditions.inspect} (#{updated} times)", time))
+        modified!
+        updated
+      end
+      
+      def query(query_call, query_limit = 999999999)
+        select(query_call, query_limit).collect{|x| x.values[0]}
+      end
+      
+      def aggregate(query)
+        raise ArgumentError.new("Only count is supported") unless (query.fields.first.operator == :count)
+        table    = DmAdapterSimpledb::Table.new(query.model)
+        sdb_type = table.simpledb_type
+        conditions, order, unsupported_conditions = set_conditions_and_sort_order(query, sdb_type)
+
+        query_call = "SELECT count(*) FROM #{domain} "
+        query_call << "WHERE #{conditions.compact.join(' AND ')}" if conditions.length > 0
+        results = nil
+        time = Benchmark.realtime do
+          results = sdb.select(query_call)
+        end; DataMapper.logger.debug(format_log_entry(query_call, time))
+        [results[:items][0].values.first["Count"].first.to_i]
+      end
+
+      # For testing purposes only.
+      def wait_for_consistency
+        return unless @current_consistency_token
+        token = :none
+        begin
+          results = sdb.get_attributes(domain, '__dm_consistency_token', '__dm_consistency_token')
+          tokens  = results[:attributes]['__dm_consistency_token']
+        end until tokens.include?(@current_consistency_token)
+      end
+
+    private
+      # Returns the domain for the model
+      def domain
+        @sdb_options[:domain]
+      end
+
+      #sets the conditions and order for the SDB query
+      def set_conditions_and_sort_order(query, sdb_type)
+        unsupported_conditions = []
+        conditions = ["simpledb_type = '#{sdb_type}'"]
+        # look for query.order.first and insure in conditions
+        # raise if order if greater than 1
+
+        if query.order && query.order.length > 0
+          query_object = query.order[0]
+          #anything sorted on must be a condition for SDB
+          conditions << "#{query_object.target.name} IS NOT NULL" 
+          order = "ORDER BY #{query_object.target.name} #{query_object.operator}"
+        else
+          order = ""
+        end
+        query.conditions.each do |op|
+          case op.slug
+          when :regexp
+            unsupported_conditions << op
+          when :eql
+            conditions << if op.value.nil?
+              "#{op.subject.name} IS NULL"
+            else
+              "#{op.subject.name} = '#{op.value}'"
+            end
+          when :not then
+            comp = op.operands.first
+            if comp.slug == :like
+              conditions << "#{comp.subject.name} not like '#{comp.value}'"
+              next
+            end
+            case comp.value
+            when Range, Set, Array, Regexp
+              unsupported_conditions << op
+            when nil
+              conditions << "#{comp.subject.name} IS NOT NULL"
+            else
+              conditions << "#{comp.subject.name} != '#{comp.value}'"
+            end
+          when :gt then conditions << "#{op.subject.name} > '#{op.value}'"
+          when :gte then conditions << "#{op.subject.name} >= '#{op.value}'"
+          when :lt then conditions << "#{op.subject.name} < '#{op.value}'"
+          when :lte then conditions << "#{op.subject.name} <= '#{op.value}'"
+          when :like then conditions << "#{op.subject.name} like '#{op.value}'"
+          when :in
+            case op.value
+            when Array, Set
+              values = op.value.collect{|v| "'#{v}'"}.join(',')
+              values = "'__NULL__'" if values.empty?                       
+              conditions << "#{op.subject.name} IN (#{values})"
+            when Range
+              if op.value.exclude_end?
+                unsupported_conditions << op
+              else
+                conditions << "#{op.subject.name} between '#{op.value.first}' and '#{op.value.last}'"
+              end
+            else
+              raise ArgumentError, "Unsupported inclusion op: #{op.value.inspect}"
+            end
+          else raise "Invalid query op: #{op.inspect}"
+          end
+        end
+        [conditions,order,unsupported_conditions]
+      end
+      
+      def select(query_call, query_limit)
+        items = []
+        time = Benchmark.realtime do
+          sdb_continuation_key = nil
+          while (results = sdb.select(query_call, sdb_continuation_key)) do
+            sdb_continuation_key = results[:next_token]
+            items += results[:items]
+            break if items.length > query_limit
+            break if sdb_continuation_key.nil?
+          end
+        end; DataMapper.logger.debug(format_log_entry(query_call, time))
+        items[0...query_limit]
+      end
+      
+      #gets all results or proper number of results depending on the :limit
+      def get_results(query, conditions, order)
+        fields_to_request = query.fields.map{|f| f.field}
+        fields_to_request << DmAdapterSimpledb::Record::METADATA_KEY
+        output_list = fields_to_request.join(', ')
+        query_call = "SELECT #{output_list} FROM #{domain} "
+        query_call << "WHERE #{conditions.compact.join(' AND ')}" if conditions.length > 0
+        query_call << " #{order}"
+        if query.limit!=nil
+          query_limit = query.limit
+          query_call << " LIMIT #{query.limit}" 
+        else
+          #on large items force the max limit
+          query_limit = 999999999 #TODO hack for query.limit being nil
+          #query_call << " limit 2500" #this doesn't work with continuation keys as it halts at the limit passed not just a limit per query.
+        end
+        records = select(query_call, query_limit)
+      end
+      
+      # Creates an item name for a query
+      def item_name_for_query(query)
+        sdb_type = simpledb_type(query.model)
+        
+        item_name = "#{sdb_type}+"
+        keys = keys_for_model(query.model)
+        conditions = query.conditions.sort {|a,b| a[1].name.to_s <=> b[1].name.to_s }
+        item_name += conditions.map do |property|
+          property[2].to_s
+        end.join('-')
+        Digest::SHA1.hexdigest(item_name)
+      end
+      
+      def not_eql_query?(query)
+        # Curosity check to make sure we are only dealing with a delete
+        conditions = query.conditions.map {|c| c.slug }.uniq
+        selectors = [ :gt, :gte, :lt, :lte, :not, :like, :in ]
+        return (selectors - conditions).size != selectors.size
+      end
+      
+      # Returns an SimpleDB instance to work with
+      def sdb
+        access_key = @sdb_options[:access_key]
+        secret_key = @sdb_options[:secret_key]
+        @sdb ||= RightAws::SdbInterface.new(access_key,secret_key,@sdb_options)
+        @sdb
+      end
+      
+      def format_log_entry(query, ms = 0)
+        'SDB (%.1fs)  %s' % [ms, query.squeeze(' ')]
+      end
+
+      def update_consistency_token
+        @current_consistency_token = UUIDTools::UUID.timestamp_create.to_s
+        sdb.put_attributes(
+          domain, 
+          '__dm_consistency_token', 
+          {'__dm_consistency_token' => [@current_consistency_token]})
+      end
+
+      def maybe_wait_for_consistency
+        if consistency_policy == :automatic && @current_consistency_token
+          wait_for_consistency
+        end
+      end
+
+      # SimpleDB supports "eventual consistency", which mean your data will be
+      # there... eventually. Obviously this can make tests a little flaky. One
+      # option is to just wait a fixed amount of time after every write, but
+      # this can quickly add up to a lot of waiting. The strategy implemented
+      # here is based on the theory that while consistency is only eventual,
+      # chances are writes will at least be linear. That is, once the results of
+      # write #2 show up we can probably assume that the results of write #1 are
+      # in as well.
+      #
+      # When a consistency policy is enabled, the adapter writes a new unique
+      # "consistency token" to the database after every write (i.e. every
+      # create, update, or delete). If the policy is :manual, it only writes the
+      # consistency token. If the policy is :automatic, writes will not return
+      # until the token has been successfully read back.
+      #
+      # When waiting for the consistency token to show up, we use progressively
+      # longer timeouts until finally giving up and raising an exception.
+      def modified!
+        case @consistency_policy
+        when :manual, :automatic then
+          update_consistency_token
+        when false then
+          # do nothing
+        else
+          raise "Invalid :wait_for_consistency option: #{@consistency_policy.inspect}"
+        end
+      end
+
+    end # class SimpleDBAdapter
+
+    
+    # Required naming scheme.
+    SimpledbAdapter = SimpleDBAdapter
+
+    const_added(:SimpledbAdapter)
+
+  end # module Adapters
+
+
+end # module DataMapper
+