The document describes a custom DataMapper adapter for MongoDB. It discusses how the adapter initializes by connecting to MongoDB and setting naming conventions. It also covers how the adapter implements the main DataMapper methods like create, read, and parsing query conditions to translate them to MongoDB queries. The adapter allows DataMapper models and queries to work with a MongoDB backend instead of a relational database.

1. Custom DataMapper
Adapters
By Josh Moore

2. About Me
• Josh Moore
• Optimis International
• github.com/joshsmoore
• twitter.com/codingforrent
• www.codingforrent.com

4. About this
presentation
• Not an introduction to DataMapper
• Mostly Code
• Why?

5. Examples
class Comment class Post
include include
DataMapper::Resource DataMapper::Resource
property :id, Serial property :id, Serial
property :body, String property :title, String
belongs_to :post has n, :comments
end end

7. Terms
term meaning
Storage Engine Whatever is persisting the data
Resource A model
field A property on a model
Repository DataMapper term for the storage engine

9. Preamble
require 'dm-core'
Just do it
module DataMapper
Just do it
module Adapters
class TestAdapter < AbstractAdapter
...
end
Just do it
const_added(:TestAdapter)
end
end

12. Symbol
Hash
def initialize(name, options)
end

13. def initialize(name, options)
Just do it
super
end

14. def initialize(name, options)
super
end

15. Connect
to your
def initialize(name, options) adapter
super
@conn = Mongo::Connection.new(
options[:host], options[:port])
@adapter = @conn[options[:database]]
end

16. def initialize(name, options)
super
@conn = Mongo::Connection.new(
Sub class of: DataMapper::Property
options[:host], options[:port])
@adapter = @conn[options[:database]]
@field_naming_convention = Proc.new do |field|
field.model.storage_name + '_' + field.name.to_s
end
Return a String
end

17. def initialize(name, options)
super
@conn = Mongo::Connection.new(
options[:host], options[:port])
@adapter = @conn[options[:database]]
@field_naming_convention = Proc.new do |field|
field.model.storage_name String (class.to_s)
+ '_' + field.name.to_s
end
@resource_naming_convention = Proc.new do |resource|
resource.downcase
end Return a String
end

18. def initialize(name, options)
super
@conn = Mongo::Connection.new(
options[:host], options[:port])
@adapter = @conn[options[:database]]
@field_naming_convention = Proc.new do |field|
field.model.storage_name + '_' + field.name.to_s
end
@resource_naming_convention = Proc.new do |resource|
resource.downcase
end
end

21. Array of Resources
def create(resources)
end
Return number of resources created

22. def create(resources)
resources.collect do |resource|
initialize_serial(resource,
@adapter[resource.class.storage_name].find.count)
fields = attributes_as_fields(
resource.attributes(:property))
@adapter[resource.class.storage_name].insert(fields)
end.size
end

23. def create(resources)
resources.collect do |resource|
initialize_serial(resource,
@adapter[resource.class.storage_name].find.count)
fields = attributes_as_fields(
resource.attributes(:property))
@adapter[resource.class.storage_name].insert(fields)
end.size
end

24. • Accepts: Hash
• Key: Sub class of: DataMapper::Property
• Value: non marshaled data
• example:
{<DataMapper::Property::String(title)> =>
"hasdf"}
def create(resources)
resources.collect do |resource|
initialize_serial(resource,
@adapter[resource.class.storage_name].find.count)
fields = attributes_as_fields(
resource.attributes(:property))
@adapter[resource.class.storage_name].insert(fields)
end.size
• Return: Hash
• Key: @field_naming_convention result
end • Value: Marshaled data
• Only values that are set
•Example:
{"post_title" => "hasdf"}

25. def create(resources)
resources.collect do |resource|
initialize_serial(resource,
@adapter[resource.class.storage_name].find.count)
fields = attributes_as_fields(
resource.attributes(:property))
@adapter[resource.class.storage_name].insert(fields)
end.size
end

26. def create(resources)
resources.collect do |resource|
initialize_serial(resource,
@adapter[resource.class.storage_name].find.count)
fields = attributes_as_fields(
resource.attributes(:property))
@adapter[resource.class.storage_name].insert(fields)
end.size
end Unless an Exception is raised the
resource will be considered saved

29. DataMapper::Query
def read(query)
end
Return a Array of Hashes
key: field name
value: unmarshed value
{field_name => value}

30. def read(query)
conditions = parse_query_conditions(query)
@adapter[query.model.storage_name].find(
conditions)
end

31. Query Structure
DataMapper::Query
#conditions
Operation
#operands
Set
Operation Condition Array
#subject
Field Association

32. Query Structure
DataMapper::Query
#conditions
Operation
#operands
Set
Operation Condition Array
#subject
Field Association
:conditions => ["updated_at > ?", Time.now]

33. Query Structure
DataMapper::Query
#conditions
Operation
#operands
Set
Operation Condition Array
#subject
Field Association
:conditions => ["updated_at > ?", Time.now]
:conditions => {:updated_at => {"$gte" => Time.now}}

34. Query Structure
DataMapper::Query
#conditions
Operation
#operands
Set
Operation Condition
Hash
Array
#subject
Field Association
:conditions => ["updated_at > ?", Time.now]
:conditions => {:updated_at => {"$gte" => Time.now}}

36. DataMapper::Query
def parse_query_conditions(query)
mongo_conditions = {}
Return a hash
mongo_conditions

37. query.conditions.operands.each do |condition|
def parse_query_conditions(query)
mongo_conditions = {}
case condition.class.to_s
when 'DataMapper::Query::Conditions::GreaterThanComparison'
mongo_conditions[condition.subject.field] =
{ "$gt" => condition.value}
when 'DataMapper::Query::Conditions::LessThanComparison'
mongo_conditions[condition.subject.field] =
{ "$lt" => condition.value}
else
mongo_conditions[condition.subject.field] =
condition.value
end mongo_conditions
end end

38. query.conditions.operands.each do |condition|
def parse_query_conditions(query)
mongo_conditions = {}
case condition.class.to_s
when 'DataMapper::Query::Conditions::GreaterThanComparison'
mongo_conditions[condition.subject.field] =
{ "$gt" => condition.value}
when 'DataMapper::Query::Conditions::LessThanComparison'
mongo_conditions[condition.subject.field] =
{ "$lt" => condition.value}
else
mongo_conditions[condition.subject.field] =
condition.value
end mongo_conditions
end end

39. query.conditions.operands.each do |condition|
def parse_query_conditions(query)
mongo_conditions = {}
case condition.class.to_s
when 'DataMapper::Query::Conditions::GreaterThanComparison'
mongo_conditions[condition.subject.field] =
{ "$gt" => condition.value}
when 'DataMapper::Query::Conditions::LessThanComparison'
mongo_conditions[condition.subject.field] =
{ "$lt" => condition.value}
else
mongo_conditions[condition.subject.field] =
condition.value
end mongo_conditions
end end

40. def parse_query_conditions(query)
mongo_conditions = {}
query.conditions.operands.each do |condition|
case condition.class.to_s
when 'DataMapper::Query::Conditions::GreaterThanComparison'
mongo_conditions[condition.subject.field] =
{ "$gt" => condition.value}
when 'DataMapper::Query::Conditions::LessThanComparison'
mongo_conditions[condition.subject.field] =
{ "$lt" => condition.value}
else
mongo_conditions[condition.subject.field] =
condition.value
end
end
mongo_conditions
end

41. Post.all(:comments => {:body => 'hi 2'})

42. conditions.operands.each do |condition|
...
case condition.class.to_s
when '...InclusionComparison'
if condition.subject.instance_of?
DataMapper::Associations::OneToMany::Relationship
pk = condition.subject.parent_key.first.field
ck = condition.subject.child_key.first.name
mongo_conditions[pk] = {"$in" =>
condition.value.collect {|r| r.send(ck)}}
else
...

43. conditions.operands.each do |condition|
...
case condition.class.to_s
when '...InclusionComparison'
if condition.subject.instance_of?
DataMapper::Associations::OneToMany::Relationship
pk = condition.subject.parent_key.first.field
ck = condition.subject.child_key.first.name
mongo_conditions[pk] = {"$in" =>
condition.value.collect {|r| r.send(ck)}}
else
...

44. conditions.operands.each do |condition|
...
case condition.class.to_s
Array of properties
when '...InclusionComparison'
* property - subclass of DataMapper::Property
if condition.subject.instance_of?
DataMapper::Associations::OneToMany::Relationship
pk = condition.subject.parent_key.first.field
ck = condition.subject.child_key.first.name
mongo_conditions[pk] = {"$in" =>
condition.value.collect {|r| r.send(ck)}}
elseArray of properties
* property - subclass of DataMapper::Property
...

45. conditions.operands.each do |condition|
...
case condition.class.to_s
when '...InclusionComparison'
if condition.subject.instance_of?
DataMapper::Associations::OneToMany::Relationship
Array of resources
pk = condition.subject.parent_key.first.field
* [#<Comment..>, #<Comment..>,...]
ck = condition.subject.child_key.first.name
mongo_conditions[pk] = {"$in" =>
condition.value.collect {|r| r.send(ck)}}
else
...

46. conditions.operands.each do |condition|
...
case condition.class.to_s
when '...InclusionComparison'
if condition.subject.instance_of?
DataMapper::Associations::OneToMany::Relationship
pk = condition.subject.parent_key.first.field
ck = condition.subject.child_key.first.name
mongo_conditions[pk] = {"$in" =>
condition.value.collect {|r| r.send(ck)}}
else
...

47. conditions.operands.each do |condition|
...
case condition.class.to_s
when '...InclusionComparison'
if condition.subject.instance_of?
DataMapper::Associations::OneToMany::Relationship
pk = condition.subject.parent_key.first.field
ck = condition.subject.child_key.first.name
mongo_conditions[pk] = {"$in" =>
condition.value.collect {|r| r.send(ck)}}
else
...

48. Operation
• DataMapper::Query::Conditions::AndOperation
• DataMapper::Query::Conditions::OrOperation
• DataMapper::Query::Conditions::NotOperation

49. Condition
• DataMapper::Query::Conditions::EqualToComparison
• DataMapper::Query::Conditions::InclusionComparison
• DataMapper::Query::Conditions::RegexpComparison
• DataMapper::Query::Conditions::LikeComparison
• DataMapper::Query::Conditions::GreaterThanComparison
• DataMapper::Query::Conditions::LessThanComparison
• DataMapper::Query::Conditions::GreaterThanOrEqualToComparison
• DataMapper::Query::Conditions::LessThanOrEqualToComparison

50. What is not covered
• Nested Operands

51. If your backed does not
have a query language
A Array of Hashes
key: field name
value: unmarshed value
[{field_name => value}]
def read(query)
query.filter_records(records)
end

53. def delete(resources)
conditions = parse_query_conditions(resources.query)
record_count = read(resources.query).count
@adapter[resources.storage_name].remove(conditions)
record_count
end

54. DataMapper::Collection
def delete(resources)
conditions = parse_query_conditions(resources.query)
record_count = read(resources.query).count
@adapter[resources.storage_name].remove(conditions)
record_count
end Number of resources deleted (int)

55. def delete(resources)
conditions = parse_query_conditions(resources.query)
record_count = read(resources.query).count
@adapter[resources.storage_name].remove(conditions)
record_count
end
Unless an Exception is raised the
resource will be considered saved

57. def update(changes, resources)
conditions = parse_query_conditions(resources.query)
@adapter[resources.storage_name].update(conditions,
{"$set" => attributes_as_fields(changes)},
{:multi => true})
read(resources.query).count
end

58. Unmarshaled hash of changes
{<DataMapper::Property::String(title)>
=> "hasdf"}
DataMapper::Collection
def update(changes, resources)
conditions = parse_query_conditions(resources.query)
@adapter[resources.storage_name].update(conditions,
{"$set" => attributes_as_fields(changes)},
{:multi => true})
read(resources.query).count
end
Number of resources updated (int)

59. def update(changes, resources)
conditions = parse_query_conditions(resources.query)
@adapter[resources.storage_name].update(conditions,
{"$set" => attributes_as_fields(changes)},
{:multi => true})
read(resources.query).count
end
Unless an Exception is raised the
resource will be considered saved

60. Be Kind log
• DataMapper.logger

61. You can stop now

62. 80/20 rule

63. But, if you want to
keep going...

64. Post.create.key

65. Post.create.key
["4e15cab882034dc7f7000002"]

66. Post.create.key

67. Just do it
module DataMapper
Just do it
module Is
module Mongo
def is_mongo(options={})
property :_id, String,
:key => true, :default => ''
end
end
end
Just do it
Model.append_extensions(Is::Mongo)
end

68. class Post
include DataMapper::Resource
property :title, String
has n, :comments
is :mongo
end

69. class Post
include DataMapper::Resource
property :title, String
has n, :comments
is :mongo
end
Post.create.key
[""]

70. def create(resources)
resources.collect do |resource|
fields =
attributes_as_fields(resource.attributes(:property))
fields.delete '_id'
b_id = @adapter[resource.class.storage_name].insert
fields
resource._id = b_id.to_s
if resource.instance_variables.include? '@_key'
resource.send :remove_instance_variable, :@_key
end
end.size
end Post.create.key

71. def create(resources)
resources.collect do |resource|
fields =
attributes_as_fields(resource.attributes(:property))
fields.delete '_id'
b_id = @adapter[resource.class.storage_name].insert
fields
resource._id = b_id.to_s
if resource.instance_variables.include? '@_key'
resource.send :remove_instance_variable, :@_key
end
end.size
end Post.create.key

72. def create(resources)
resources.collect do |resource|
fields =
attributes_as_fields(resource.attributes(:property))
fields.delete '_id'
b_id = @adapter[resource.class.storage_name].insert
fields
resource._id = b_id.to_s
if resource.instance_variables.include? '@_key'
resource.send :remove_instance_variable, :@_key
end
end.size
end Post.create.key

73. def create(resources)
resources.collect do |resource|
fields =
attributes_as_fields(resource.attributes(:property))
fields.delete '_id'
b_id = @adapter[resource.class.storage_name].insert
fields
resource._id = b_id.to_s
if resource.instance_variables.include? '@_key'
resource.send :remove_instance_variable, :@_key
end
end.size
end Post.create.key

74. def create(resources)
resources.collect do |resource|
fields =
attributes_as_fields(resource.attributes(:property))
fields.delete '_id'
b_id = @adapter[resource.class.storage_name].insert
fields
resource._id = b_id.to_s
if resource.instance_variables.include? '@_key'
resource.send :remove_instance_variable, :@_key
end
end.size
end Post.create.key

75. def create(resources)
resources.collect do |resource|
fields =
attributes_as_fields(resource.attributes(:property))
fields.delete '_id'
b_id = @adapter[resource.class.storage_name].insert
fields
resource._id = b_id.to_s
if resource.instance_variables.include? '@_key'
resource.send :remove_instance_variable, :@_key
end
end.size
end Post.create.key
["4e15cab882034dc7f7000002"]

76. def create(resources)
resources.collect do |resource|
fields =
attributes_as_fields(resource.attributes(:property))
fields.delete '_id'
b_id = @adapter[resource.class.storage_name].insert
fields
resource._id = b_id.to_s
if resource.instance_variables.include? '@_key'
resource.send :remove_instance_variable, :@_key
end
end.size
end Post.create.key

77. Whats left
• Aggregation
• Native types
• DataMapper.logger