Cheating on ActiveRecord with DataMapper

• We're integrating with Google Sheet!
  

• …yeah, I'm gonna need you to have that done by Friday…
  

1. Create
2. Read
3. Update
4. Delete
5. Profit!

module DataMapper
  module Adapters
    class GoogleSheetAdapter < 
          DataMapper::Adapters::AbstractAdapter
      # ...
    end
  end  
end

def create(resources)
  # ...
end

def create(resources)
  table_groups = group_resources_by_table(resources)
  table_groups.each do |table, resources|
    # ...
  end
end

Initializing serial fields…

resources.each do |resource|
  initialize_serial(resource, 
                    worksheet_record_count(table) + 1)
  # ...
end

…makes this to work:

class User
  property :id, Serial
end

resources.each do |resource|
  # ...
  post_resource_to_worksheet(resource, table)
end

def create(resources)
  # ...
  resources.size
end

Now we can do this:

class LogEntry
  include DataMapper::Resource
  property :exercise, String
  property :reps, Integer
end
LogEntry.create(:exercise => "push-ups", :reps => 30)

def read(query)
  # ...
end

def read(query)
  worksheet_name = query.model.storage_name(name)
  list = worksheet_as_list(worksheet_name)
  # ...
end

DataMapper expects an Enumerable of {Property => value} hashes to be returned.

def read(query)
  # ...
  resource_hashes = list_to_hashes(list, query.fields)
  # ...
end

We can already do this:

LogEntry.all # => all entries
LogEntry.first # => first entry in the table  

def read(query)
  # ...
  query.filter_records(resource_hashes)
end

Now we can do this:

LogEntry.all(:reps.gt => 30, 
             :limit   => 10, 
             :order   => [:reps.desc])

Optimize as-needed.

# ...
when GreaterThanComparison          then ">"
when LessThanComparison             then "<"
when GreaterThanOrEqualToComparison then ">="
# ...

def update(attributes, collection)
  # ...
end

def update(attributes, collection)
  each_resource_with_edit_url(collection) do 
    |resource, edit_url|

    put_updated_resource(edit_url, resource)
  end
  # ...
end

def update(attributes, collection)
  # ...
  collection.size
end

Now we can do this:

log_entry.update(:comment => "increase weight")

def delete(collection)
  # ...
end

def delete(collection)
  each_resource_with_edit_url(collection) do 
    |resource, edit_url|

    connection.delete(edit_url, 'If-Match' => "*")
  end
  # ...
end

def delete(collection)
  # ...
  collection.size
end

Now we can do this:

log_entry.destroy
LogEntry.destroy # clear the table

def field_naming_convention
  ->(property){
    property.name.to_s.gsub(/[^[:alnum:]]+/, '').downcase
  }
end

def create_model_storage(model)
  # ...
end

def upgrade_model_storage(model)
  # ...
end

def destroy_model_storage(model)
  # ...
end

DataMapper.auto_migrate!
# or:
DataMapper.auto_upgrade!

Very handy for testing/development.

• SQL is the new NoSQL
  

• Need all the Sheet data back in the DB
  

• ASAP!
  

DataMapper.setup(:other, 'sqlite::memory:')
DataMapper.repository(:other).auto_migrate!
LogEntry.copy(:default, :other)

DataMapper's killer app is that it lowers the bar for experimenting with different forms of data storage.

• dm-mongo-adapter
  

• dm-redis-adapter
  

• dm-rdf-adapter
  

• dm-imap-adapter
  

• dm-adapter-simpledb
  

• dm-tokyo-adapter
  

• etc…
  

• Easy things easy, hard things possible
  

• AST representation of queries
  

• Incrementally add features, optimizations
  

• Great documentation, readable code
  

• Lots of conveniences
  

• Plugins give you free functionality
  

• Validation
  

• DB constraints
  

• Pagination
  

• State machine
  

• Tagging
  

• Aggregation
  

• Versioning
  

• Trees/lists/nested sets
  

• etc…
  

Based on the Data Mapper pattern

A layer of Mappers that moves data between objects and a database while keeping them independent of each other and the mapper itself.

• In development since early 2008 (?)
  

• Hit 1.0 in June
  

• API is now stable
  

entries = LogEntry.all
pushups = entries.all(:name => "push-ups")
squats  = entries.all(:name => "squats")
combined = pushups & squats
combined.to_a # NOW the datastore is queried

ActiveRecord:

big_bird = Monster.create!(:name => "Big Bird")
snuffy   = Monster.create!(:name => "Snuffleupagus")
snuffy.friends << big_bird
snuffy.friends.first.name # => "Big Bird"
snuffy.friends.first.equal?(big_bird) # => false

DataMapper:

big_bird = Monster.create(:name => "Big Bird")
snuffy   = Monster.create(:name => "Snuffleupagus")
snuffy.friends << big_bird
snuffy.friends.first.name # => "Big Bird"
snuffy.friends.first.equal?(big_bird) # => true

class ZipCode
  property :code, String, :key => true
  property :state, String
end
# ...
ZipCode.get("17361")

class LogEntry
  storage_names[:legacy] = 'tblEntry'
  # ...
end

#datamapper on Freenode

• Use alongside ActiveRecord
  

• Or replace ActiveRecord entirely
  

  rails new project_name \
    -m http://datamapper.org/templates/rails.rb
  

• Rate!
  http://spkr8.com/t/7286

• Contact
  
  • Home: http://avdi.org
  • Email: avdi@avdi.org
  • Twitter: @avdi