def test_group(self):
query = {'x': 9}
fcoll = FilteredCollection(self.coll, query=query)
result = fcoll.group({'x': 1}, {'count': 0},
'function(curr, result) { result.count += 1; }')
self.assertIsInstance(result, list)
self.assertEqual(result[0].get('count'), 2)
def query(self, *args, **kwargs):
"""
return a new MDataFrame with a filter criteria
Any subsequent operation on the new dataframe will have the filter
applied. To reset the filter call .reset() without arguments.
Note: Unlike pandas DataFrames, a filtered MDataFrame operates
on the same collection as the original DataFrame
:param args: a Q object or logical combination of Q objects
(optional)
:param kwargs: all AND filter criteria
:return: a new MDataFrame with the filter applied
"""
effective_filter = dict(self.filter_criteria)
filter_criteria = self._get_filter_criteria(*args, **kwargs)
if '$and' in effective_filter:
effective_filter['$and'].extend(filter_criteria.get('$and'))
else:
effective_filter.update(filter_criteria)
coll = FilteredCollection(self.collection, query=effective_filter)
return self.__class__(coll,
query=effective_filter,
**self._getcopy_kwargs(without='query'))
def test_find_one_and_delete(self):
query = {'x': 9}
fcoll = FilteredCollection(self.coll, query=query)
result = fcoll.find_one_and_delete()
self.assertIsInstance(result, dict)
self.assertEqual(result.get('x'), 9)
result = list(fcoll.find())
self.assertEqual(len(result), 1)
def test_find_one_and_replace(self):
query = {'x': 9}
fcoll = FilteredCollection(self.coll, query=query)
result = fcoll.find_one_and_replace({'x': 9, 'xy': 9000})
self.assertIsInstance(result, dict)
self.assertEqual(result.get('x'), 9)
result_n = fcoll.find_one()
self.assertEqual(result_n.get('xy'), 9000)
self.assertNotIn('y', result_n)
def test_map_reduce(self):
query = {'x': 9}
fcoll = FilteredCollection(self.coll, query=query)
# calculate sum as a test value (values are random)
ysum = sum(v.get('y') for v in fcoll.find())
# use map reduce for the same sum calculation
mapf = 'function() { emit(this.x, this.y); }'
reducef = 'function(x, values) { return Array.sum(values); }'
result = list(fcoll.map_reduce(mapf, reducef, 'mr_out').find())
self.assertIsInstance(result, list)
self.assertEqual(result[0].get('value'), ysum)
def test_find_one_and_update(self):
query = {'x': 9}
fcoll = FilteredCollection(self.coll, query=query)
result = fcoll.find_one_and_update({'$set': {'xy': 9000}})
# make sure we get what we wanted
self.assertIsInstance(result, dict)
self.assertEqual(result.get('x'), 9)
# be sure to get the same as before, then test it was updated
result_n = fcoll.find_one({'_id': result.get('_id')})
self.assertEqual(result_n.get('xy'), 9000)
self.assertEqual(result_n.get('y'), result.get('y'))
def _get_cursor(self, pipeline=None, use_cache=True):
# for apply functions, call the apply function, expecting a pipeline in return
if self.apply_fn:
pipeline = pipeline or self._build_pipeline()
cursor = self._get_cached_cursor(pipeline=pipeline,
use_cache=use_cache)
if cursor is None:
filter_criteria = self._get_filter_criteria()
cursor = FilteredCollection(self.collection).aggregate(
pipeline, filter=filter_criteria, allowDiskUse=True)
else:
cursor = super(ApplyMixin, self)._get_cursor()
return cursor
def query_inplace(self, *args, **kwargs):
"""
filters this MDataFrame and returns it.
Any subsequent operation on the dataframe will have the filter
applied. To reset the filter call .reset() without arguments.
:param args: a Q object or logical combination of Q objects
(optional)
:param kwargs: all AND filter criteria
:return: self
"""
self._evaluated = None
self.filter_criteria = self._get_filter_criteria(*args, **kwargs)
self.collection = FilteredCollection(
self.collection, query=self.filter_criteria)
return self
def test_distinct(self):
query = {'x': 9}
fcoll = FilteredCollection(self.coll, query=query)
result = fcoll.distinct('x')
self.assertEqual(result, [9])
def test_count(self):
query = {'x': 9}
fcoll = FilteredCollection(self.coll, query=query)
result = fcoll.count()
self.assertEqual(result, 2)
def test_find_one(self):
query = {'x': 9}
fcoll = FilteredCollection(self.coll, query=query)
result = fcoll.find_one()
self.assertIsInstance(result, dict)
self.assertEqual(result.get('x'), 9)
def test_find(self):
query = {'x': 1}
fcoll = FilteredCollection(self.coll, query=query)
result = list(fcoll.find())
self.assertTrue(len(result) == 2)