def get_one(self):
"""
executes solr query if needed then returns first object according to
selected ReturnType (defaults to Model)
:return: pyoko.Model or riak.Object or solr document
"""
if not self._riak_cache:
self._exec_query()
if not self._solr_cache['docs']:
raise ObjectDoesNotExist("%s %s" % (self.index_name, self.compiled_query))
if self.count() > 1:
raise MultipleObjectsReturned(
"%s objects returned for %s" % (self.count(),
self._model_class.__name__))
self._riak_cache = [self.bucket.get(self._solr_cache['docs'][0]['_yz_rk'])]
sys.PYOKO_LOGS[self._model_class.__name__].append(
self._solr_cache['docs'][0]['_yz_rk'])
if not self._riak_cache[0].exists:
raise ObjectDoesNotExist("%s %s" % (self.index_name,
self._riak_cache[0].key))
return self._riak_cache[0].data, self._riak_cache[0].key
def _update_new_linked_model(self, internal, linked_mdl_ins, link):
"""
Iterates through linked_models of given model instance to match it's
"reverse" with given link's "field" values.
"""
# If there is a link between two sides (A and B), if a link from A to B,
# link should be saved at B but it is not necessary to control again data in A.
# If internal field is True, data control is not done and passes.
if not internal:
for lnk in linked_mdl_ins.get_links():
mdl = lnk['mdl']
if not isinstance(self,
mdl) or lnk['reverse'] != link['field']:
continue
local_field_name = lnk['field']
# remote_name = lnk['reverse']
remote_field_name = un_camel(mdl.__name__)
if not link['o2o']:
if '.' in local_field_name:
local_field_name, remote_field_name = local_field_name.split(
'.')
remote_set = getattr(linked_mdl_ins, local_field_name)
if remote_set._TYPE == 'ListNode' and self not in remote_set:
remote_set(**{remote_field_name: self._root_node})
if linked_mdl_ins._exists is False:
raise ObjectDoesNotExist(
'Linked %s on field %s with key %s doesn\'t exist'
% (
linked_mdl_ins.__class__.__name__,
remote_field_name,
linked_mdl_ins.key,
))
linked_mdl_ins.save(internal=True)
else:
linked_mdl_ins.setattr(remote_field_name, self._root_node)
if linked_mdl_ins._exists is False:
raise ObjectDoesNotExist(
'Linked object %s on field %s with key %s doesn\'t exist'
% (
linked_mdl_ins.__class__.__name__,
remote_field_name,
linked_mdl_ins.key,
))
linked_mdl_ins.save(internal=True)
def __iter__(self):
self._exec_query()
for doc in self._solr_cache['docs']:
# if settings.DEBUG:
# t1 = time.time()
obj = self.bucket.get(doc['_yz_rk'])
if not obj.exists:
raise ObjectDoesNotExist("We got %s from Solr for %s bucket but cannot find it in the Riak" % (
doc['_yz_rk'], self._model_class))
yield obj.data, obj.key
if settings.DEBUG:
sys.PYOKO_STAT_COUNTER['read'] += 1
sys.PYOKO_LOGS[self._model_class.__name__].append(doc['_yz_rk'])
def _get(self):
"""
executes solr query if needed then returns first object according to
selected ReturnType (defaults to Model)
:return: pyoko.Model or riak.Object or solr document
"""
if not self._riak_cache:
self._exec_query()
if not self._riak_cache and self._cfg['rtype'] != ReturnType.Solr:
if not self._solr_cache['docs']:
raise ObjectDoesNotExist(
"%s %s" % (self.index_name, self.compiled_query))
if settings.DEBUG:
t1 = time.time()
self._riak_cache = [
self.bucket.get(self._solr_cache['docs'][0]['_yz_rk'])
]
if settings.DEBUG:
sys._debug_db_queries.append({
'TIMESTAMP':
t1,
'KEY':
self._solr_cache['docs'][0]['_yz_rk'],
'BUCKET':
self.index_name,
'TIME':
round(time.time() - t1, 5)
})
if self._cfg['rtype'] == ReturnType.Model:
if not self._riak_cache[0].exists:
raise ObjectDoesNotExist(
"%s %s" % (self.index_name, self._riak_cache[0].key))
return self._make_model(self._riak_cache[0].data,
self._riak_cache[0])
elif self._cfg['rtype'] == ReturnType.Object:
return self._riak_cache[0]
else:
return self._solr_cache['docs'][0]
def _get_from_riak(self, key):
"""
Args:
key (str): riak key
Returns:
(tuple): riak obj json data and riak key
"""
obj = self.bucket.get(key)
if obj.exists:
return obj.data, obj.key
raise ObjectDoesNotExist("%s %s" % (key, self.compiled_query))
def _make_model(self, data, key=None):
"""
Creates a model instance with the given data.
Args:
data: Model data returned from DB.
key: Object key
Returns:
pyoko.Model object.
"""
if data['deleted'] and not self.adapter.want_deleted:
raise ObjectDoesNotExist('Deleted object returned')
model = self._model_class(self._current_context,
_pass_perm_checks=self._pass_perm_checks)
model.setattr('key', key if key else data.get('key'))
return model.set_data(data, from_db=True)
def get_or_create(self, defaults=None, **kwargs):
"""
Looks up an object with the given kwargs, creating a new one if necessary.
Args:
defaults (dict): Used when we create a new object. Must map to fields
of the model.
\*\*kwargs: Used both for filtering and new object creation.
Returns:
A tuple of (object, created), where created is a boolean variable
specifies whether the object was newly created or not.
Example:
In the following example, *code* and *name* fields are used to query the DB.
.. code-block:: python
obj, is_new = Permission.objects.get_or_create({'description': desc},
code=code, name=name)
{description: desc} dict is just for new creations. If we can't find any
records by filtering on *code* and *name*, then we create a new object by
using all of the inputs.
"""
existing = list(self.filter(**kwargs))
count = len(existing)
try:
if count > 1:
raise MultipleObjectsReturned(
"%s objects returned for %s" %
(count, self._model_class.__name__))
if existing[0].deleted:
raise ObjectDoesNotExist(
'Sync Issue, deleted object returned!')
return existing[0], False
except (ObjectDoesNotExist, IndexError):
pass
data = defaults or {}
data.update(kwargs)
return self._model_class(**data).save(), True
def get(self, key=None):
"""
If key is not None, tries to get obj from cache first. If not
found, tries to get from riak and sets to cache.
If key is None, then execute solr query and checks result. Returns
obj data and key tuple or raises exception ObjectDoesNotExist or
MultipleObjectsReturned.
Args:
key(str): obj key
Return:
(tuple): obj data dict, obj key
"""
if key:
key = ub_to_str(key)
if settings.ENABLE_CACHING:
return self.get_from_cache(key) or self.set_to_cache(
self._get_from_riak(key))
else:
return self._get_from_riak(key)
else:
self._exec_query()
if not self._solr_cache['docs']:
raise ObjectDoesNotExist(
"%s %s" % (self.index_name, self.compiled_query))
if self.count() > 1:
raise MultipleObjectsReturned(
"%s objects returned for %s" %
(self.count(), self._model_class.__name__))
return self._get_from_riak(self._solr_cache['docs'][0]['_yz_rk'])