Class: DataMapper::Adapters::DataStoreAdapter

Inherits:
AbstractAdapter
  • Object
show all
Defined in:
lib/dm-datastore-adapter/transaction.rb,
lib/dm-datastore-adapter/datastore-adapter.rb

Defined Under Namespace

Modules: DS Classes: InvalidConditionError, Transaction

Instance Method Summary collapse

Instance Method Details

#aggregate(query) ⇒ Object 



131
132
133
134
135
136
137
138
139
140
141
 
# File 'lib/dm-datastore-adapter/datastore-adapter.rb', line 131

def aggregate(query)
  op = query.fields.find{|p| p.kind_of?(DataMapper::Query::Operator)}
  if op.nil?
    raise NotImplementedError, "No operator supplied."
  end
  if respond_to?(op.operator)
    self.send op.operator, query
  else
    raise NotImplementedError, "#{op.operator} is not supported yet."
  end
end

#count(query) ⇒ Object 



143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
 
# File 'lib/dm-datastore-adapter/datastore-adapter.rb', line 143

def count(query)
  result, limit = 0, query.limit
  loop do
    negas, posis = {}, {}
    q = build_query(query) do |op, property, value|
      negas[property] = value if op == :not
      posis[property] = value if op == :eql
    end
    result += DS::Service.prepare(q).countEntities
    unless negas.empty?
      result -= count(negate_query(query, negas)).first
    end
    break if posis.empty?
    break if limit && result >= limit
    query = assert_query(query, posis)
  end
  [limit ? [result, limit].min : result]
end

#create(resources) ⇒ Object 



23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
# File 'lib/dm-datastore-adapter/datastore-adapter.rb', line 23

def create(resources)
  created = 0
  resources.each do |resource|
    entity = DS::Entity.new(resource.class.name)
    resource.attributes.each do |key, value|
      ds_set(entity, resource.model.properties[key], value)
    end
    begin
      ds_key = ds_service_put(entity)
    rescue Exception
    else
      ds_id = ds_key.get_id
      resource.model.key.each do |property|
        resource.attribute_set property.field, ds_id
        ds_set(entity, property, ds_id)
      end
      ds_service_put(entity)
      created += 1
    end
  end
  created
end

#current_transaction ⇒ Object 



47
48
49
 
# File 'lib/dm-datastore-adapter/transaction.rb', line 47

def current_transaction
  transactions(Thread::current).last
end

#delete(query) ⇒ Object 



67
68
69
70
71
72
73
74
75
76
77
78
79
80
 
# File 'lib/dm-datastore-adapter/datastore-adapter.rb', line 67

def delete(query)
  resources = read_many(query)
  ds_keys = resources.map do |resource|
    begin
      ds_key_from_resource(resource)
    rescue Exception
      nil
    end
  end.compact
  ds_service_delete(ds_keys.to_java(DS::Key))
  ds_keys.size
rescue Exception
  0
end

#pop_transaction ⇒ Object 



43
44
45
 
# File 'lib/dm-datastore-adapter/transaction.rb', line 43

def pop_transaction
  transactions(Thread::current).pop
end

#push_transaction(transaction) ⇒ Object 



39
40
41
 
# File 'lib/dm-datastore-adapter/transaction.rb', line 39

def push_transaction(transaction)
  transactions(Thread::current) << transaction
end

#read_many(query) ⇒ Object 



82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
 
# File 'lib/dm-datastore-adapter/datastore-adapter.rb', line 82

def read_many(query)
  Collection.new(query) do |collection|
    loop do
      negas, posis = {}, {}
      q = build_query(query) do |op, property, value|
        negas[property] = value if op == :not
        posis[property] = value if op == :eql
      end
      fo = build_fetch_option(query)
      iter = if fo
        DS::Service.prepare(q).as_iterable(fo)
      else
        DS::Service.prepare(q).as_iterable
      end
      iter.each do |entity|
        next if negative?(entity, negas)
        collection.load(query.fields.map do |property|
          property.key? ?
            entity.key.get_id : ds_get(entity, property.field)
        end)
      end
      break if posis.empty?
      query = assert_query(query, posis)
    end
  end
end

#read_one(query) ⇒ Object 



109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
 
# File 'lib/dm-datastore-adapter/datastore-adapter.rb', line 109

def read_one(query)
  negas = {}
  q = build_query(query) do |op, property, value|
    negas[property] = value if op == :not
    if op == :eql
      raise InvalidConditionError,
        "OR condition is not afflowed for read_one"
    end
  end
  fo = build_fetch_option(query)
  entity = if fo
    DS::Service.prepare(q).as_iterable(fo).map{|i| break i}
  else 
    DS::Service.prepare(q).asSingleEntity
  end
  return nil if entity.blank?
  return nil if negative?(entity, negas)
  query.model.load(query.fields.map do |property|
    property.key? ? entity.key.get_id : ds_get(entity, property.field)
  end, query)
end

#transaction_primitive ⇒ Object 



35
36
37
 
# File 'lib/dm-datastore-adapter/transaction.rb', line 35

def transaction_primitive
  DataStoreAdapter::Transaction.new
end

#update(attributes, query) ⇒ Object 



46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
# File 'lib/dm-datastore-adapter/datastore-adapter.rb', line 46

def update(attributes, query)
  updated = 0
  resources = read_many(query)
  resources.each do |resource|
    entity = ds_service_get(ds_key_from_resource(resource))
    attributes.each do |property, value|
      ds_set(entity, property, value)
    end
    begin
      ds_key = ds_service_put(entity)
    rescue Exception
    else
      resource.model.key.each do |property|
        resource.attribute_set property.field, ds_key.get_id
      end
      updated += 1
    end
  end
  updated
end

#within_transaction? ⇒ Boolean

Returns:

  • (Boolean) 


51
52
53
 
# File 'lib/dm-datastore-adapter/transaction.rb', line 51

def within_transaction?
  !current_transaction.nil?
end