def test_skeleton_simple(self):
self.assertEqual(s.skeleton({'hello': 'world'}), '{hello}')
self.assertEqual(s.skeleton({
'hello': 'world',
'foo': 'bar'
}), '{foo,hello}')
self.assertEqual(s.skeleton({}), '{}')
def test_error_message(self):
class NonBsonType(object):
def __init__(self, value):
self.value = value
def __repr__(self):
return 'NonBsonType(%r)' % self.value
self.assertRaises(InvalidDocument, s.sanitize, ({
'a': NonBsonType(1)
}, ))
try:
s.skeleton({'a': NonBsonType(1)})
except InvalidDocument as e:
msg = e.args[0]
self.assertTrue(
re.match(r'unknown BSON type <.*NonBsonType.*>', msg))
self.assertRaises(InvalidDocument, s.desanitize, ({
'a': NonBsonType(1)
}, ))
try:
s.skeleton({'a': NonBsonType(1)})
except InvalidDocument as e:
msg = e.args[0]
self.assertTrue(
re.match(r'unknown BSON type <.*NonBsonType.*>', msg))
def test_skeleton_list(self):
self.assertEqual(s.skeleton({'a': []}), '{a:[]}')
self.assertEqual(s.skeleton({'a': [1,2,3]}), '{a:[]}')
self.assertEqual(s.skeleton({'a': [{'b': 1}, {'b': 2}]}), '{a:[{b},{b}]}')
self.assertEqual(s.skeleton({'a': [{'b': 1}, {'c': 2}]}), '{a:[{b},{c}]}')
# TODO: this is weird, what should this do?
self.assertEqual(s.skeleton({'a': [{'b': 1}, 2]}), '{a:[{b}]}')
def test_error_message(self):
class NonBsonType(object):
def __init__(self, value):
self.value = value
def __repr__(self):
return 'NonBsonType(%r)' % self.value
self.assertRaises(InvalidDocument, s.skeleton, ({'a': NonBsonType(1)}, ))
try:
s.skeleton({'a': NonBsonType(1)})
except InvalidDocument as e:
msg = e.args[0]
self.assertTrue(re.match(r'unknown BSON type <.*NonBsonType.*>', msg))
def test_skeleton_list(self):
self.assertEqual(s.skeleton({'a': []}), '{a:[]}')
self.assertEqual(s.skeleton({'a': [1, 2, 3]}), '{a:[]}')
self.assertEqual(s.skeleton({'a': [{
'b': 1
}, {
'b': 2
}]}), '{a:[{b},{b}]}')
self.assertEqual(s.skeleton({'a': [{
'b': 1
}, {
'c': 2
}]}), '{a:[{b},{c}]}')
# TODO: this is weird, what should this do?
self.assertEqual(s.skeleton({'a': [{'b': 1}, 2]}), '{a:[{b}]}')
def skeleton(query_part):
"""
Generate a "skeleton" of a document (or embedded document). A
skeleton is a (unicode) string indicating the keys present in
a document, but not the values, and is used to group queries
together which have identical key patterns regardless of the
particular values used. Keys in the skeleton are always sorted
lexicographically.
Raises :class:`~bson.errors.InvalidDocument` when the document
cannot be converted into a skeleton (this usually indicates that
the type of a key or value in the document is not known to
Professor).
For example:
>>> skeleton({'hello': 'World'})
u'{hello}'
>>> skeleton({'title': 'My Blog Post', 'author': 'Dan Crosta'})
u'{author,title}
>>> skeleton({})
u'{}'
"""
t = type(query_part)
if t == list:
out = []
for element in query_part:
sub = skeleton(element)
if sub is not None:
out.append(sub)
return u'[%s]' % ','.join(out)
elif t in (dict, SON):
out = []
for key in sorted(query_part.keys()):
sub = skeleton(query_part[key])
if sub is not None:
out.append('%s:%s' % (key, sub))
else:
out.append(key)
return u'{%s}' % ','.join(out)
elif t not in BSON_TYPES:
raise InvalidDocument('unknown BSON type %r' % t)
def skeleton(query_part):
"""
Generate a "skeleton" of a document (or embedded document). A
skeleton is a (unicode) string indicating the keys present in
a document, but not the values, and is used to group queries
together which have identical key patterns regardless of the
particular values used. Keys in the skeleton are always sorted
lexicographically.
Raises :class:`~bson.errors.InvalidDocument` when the document
cannot be converted into a skeleton (this usually indicates that
the type of a key or value in the document is not known to
Professor).
For example:
>>> skeleton({'hello': 'World'})
u'{hello}'
>>> skeleton({'title': 'My Blog Post', 'author': 'Dan Crosta'})
u'{author,title}
>>> skeleton({})
u'{}'
"""
t = type(query_part)
if t == list:
out = []
for element in query_part:
sub = skeleton(element)
if sub is not None:
out.append(sub)
return u'[%s]' % ','.join(out)
elif t in (dict, SON):
out = []
for key in sorted(query_part.keys()):
sub = skeleton(query_part[key])
if sub is not None:
out.append('%s:%s' % (key, sub))
else:
out.append(key)
return u'{%s}' % ','.join(out)
elif t not in BSON_TYPES:
raise InvalidDocument('unknown BSON type %r' % t)
def test_skeleton_embedded_objects(self):
self.assertEqual(s.skeleton({'a': {'b': 1}}), '{a:{b}}')
self.assertEqual(s.skeleton({'a': {'b': 1}, 'c': 1}), '{a:{b},c}')
self.assertEqual(s.skeleton({'a': {'b': 1, 'd': 2}, 'c': 1}), '{a:{b,d},c}')
# make sure top-level SON objects work
self.assertEqual(s.skeleton(SON([('a', 1)])), '{a}')
# and embedded SON objects
self.assertEqual(s.skeleton({'a': SON([('b', 1)])}), '{a:{b}}')
self.assertEqual(s.skeleton({'a': SON([('b', 1)]), 'c': 1}), '{a:{b},c}')
self.assertEqual(s.skeleton({'a': SON([('b', 1), ('d', 2)]), 'c': 1}), '{a:{b,d},c}')
def parse_query(entry):
# {'responseLength': 20,
# 'millis': 40,
# 'ts': datetime.datetime(2011, 9, 19, 15, 8, 1, 976000),
# 'scanAndOrder': True,
# 'client': '127.0.0.1',
# 'user': '',
# 'query': {'$orderby': {'date': 1},
# '$query': {'processing.status': 'new'}},
# 'ns': 'www.formcapture',
# 'nscanned': 12133,
# 'op': 'query'}
query = entry.get('query', {}).get('$query', None)
if query is None:
query = entry.get('query', {})
orderby = entry.get('query', {}).get('$orderby', None)
if orderby is None:
orderby = {}
entry['skel'] = skeleton(query)
entry['sort'] = skeleton(orderby)
return True
def parse_query(entry):
# {'responseLength': 20,
# 'millis': 40,
# 'ts': datetime.datetime(2011, 9, 19, 15, 8, 1, 976000),
# 'scanAndOrder': True,
# 'client': '127.0.0.1',
# 'user': '',
# 'query': {'$orderby': {'date': 1},
# '$query': {'processing.status': 'new'}},
# 'ns': 'www.formcapture',
# 'nscanned': 12133,
# 'op': 'query'}
query = entry.get('query', {}).get('$query', None)
if query is None:
query = entry.get('query', {})
orderby = entry.get('query', {}).get('$orderby', None)
if orderby is None:
orderby = {}
entry['skel'] = skeleton(query)
entry['sort'] = skeleton(orderby)
return True
def test_skeleton_embedded_objects(self):
self.assertEqual(s.skeleton({'a': {'b': 1}}), '{a:{b}}')
self.assertEqual(s.skeleton({'a': {'b': 1}, 'c': 1}), '{a:{b},c}')
self.assertEqual(s.skeleton({
'a': {
'b': 1,
'd': 2
},
'c': 1
}), '{a:{b,d},c}')
# make sure top-level SON objects work
self.assertEqual(s.skeleton(SON([('a', 1)])), '{a}')
# and embedded SON objects
self.assertEqual(s.skeleton({'a': SON([('b', 1)])}), '{a:{b}}')
self.assertEqual(s.skeleton({
'a': SON([('b', 1)]),
'c': 1
}), '{a:{b},c}')
self.assertEqual(s.skeleton({
'a': SON([('b', 1), ('d', 2)]),
'c': 1
}), '{a:{b,d},c}')
def test_skeleton_types(self):
# ensure that all valid BSON types can be
# skeleton'd; lists and subobjects are
# tested in other functions and omitted here
self.assertEqual(s.skeleton({'a': 1}), '{a}')
self.assertEqual(s.skeleton({'a': 1L}), '{a}')
self.assertEqual(s.skeleton({'a': 1.0}), '{a}')
self.assertEqual(s.skeleton({'a': '1'}), '{a}')
self.assertEqual(s.skeleton({'a': u'1'}), '{a}')
self.assertEqual(s.skeleton({'a': True}), '{a}')
self.assertEqual(s.skeleton({'a': datetime.now()}), '{a}')
self.assertEqual(
s.skeleton({'a': ObjectId('000000000000000000000000')}), '{a}')
self.assertEqual(s.skeleton({'a': re.compile(r'^$')}), '{a}')
self.assertEqual(s.skeleton({'a': Code('function(){}')}), '{a}')
self.assertEqual(s.skeleton({'a': None}), '{a}')
self.assertEqual(s.skeleton({'a': Binary('123456')}), '{a}')
self.assertEqual(s.skeleton({'a': DBRef('coll', 123)}), '{a}')
def test_skeleton_types(self):
# ensure that all valid BSON types can be
# skeleton'd; lists and subobjects are
# tested in other functions and omitted here
self.assertEqual(s.skeleton({'a': 1}), '{a}')
self.assertEqual(s.skeleton({'a': 1L}), '{a}')
self.assertEqual(s.skeleton({'a': 1.0}), '{a}')
self.assertEqual(s.skeleton({'a': '1'}), '{a}')
self.assertEqual(s.skeleton({'a': u'1'}), '{a}')
self.assertEqual(s.skeleton({'a': True}), '{a}')
self.assertEqual(s.skeleton({'a': datetime.now()}), '{a}')
self.assertEqual(s.skeleton({'a': ObjectId('000000000000000000000000')}), '{a}')
self.assertEqual(s.skeleton({'a': re.compile(r'^$')}), '{a}')
self.assertEqual(s.skeleton({'a': Code('function(){}')}), '{a}')
self.assertEqual(s.skeleton({'a': None}), '{a}')
self.assertEqual(s.skeleton({'a': Binary('123456')}), '{a}')
self.assertEqual(s.skeleton({'a': DBRef('coll', 123)}), '{a}')
def test_skeleton_simple(self):
self.assertEqual(s.skeleton({'hello': 'world'}), '{hello}')
self.assertEqual(s.skeleton({'hello': 'world', 'foo': 'bar'}), '{foo,hello}')
self.assertEqual(s.skeleton({}), '{}')
