def test_access_ok(self):
cb = self.cb
key = self.gen_key('non-exist')
try:
cb.lookup_in(key, SD.get('pth1'), quiet=True)
except E.NotFoundError as e:
rv = e.all_results[key]
self.assertFalse(rv.access_ok)
cb.upsert(key, {'hello': 'world'})
rv = cb.lookup_in(key, SD.get('nonexist'))
self.assertTrue(rv.access_ok)
def test_multi_lookup(self):
cb = self.cb
key = self.gen_key('sdmlookup')
cb.upsert(key, {
'field1': 'value1',
'field2': 'value2',
'array': [1, 2, 3],
'boolean': False
})
rvs = cb.lookup_in(
key, SD.get('field1'), SD.exists('field2'), SD.exists('field3'),
quiet=True
)
self.assertFalse(rvs.success)
self.assertEqual(3, rvs.result_count)
self.assertEqual((0, 'value1'), rvs.get(0))
self.assertEqual((0, 'value1'), rvs.get('field1'))
self.assertEqual('value1', rvs[0])
self.assertEqual('value1', rvs['field1'])
self.assertEqual((0, None), rvs.get(1))
self.assertEqual((0, None), rvs.get('field2'))
self.assertEqual(None, rvs[1])
self.assertEqual(None, rvs['field2'])
self.assertTrue(rvs.exists('field2'))
self.assertTrue(rvs.exists(1))
self.assertTrue(1 in rvs)
self.assertTrue('field2' in rvs)
self.assertEqual((E.SubdocPathNotFoundError.CODE, None),
rvs.get('field3'))
self.assertEqual((E.SubdocPathNotFoundError.CODE, None),
rvs.get(2))
self.assertFalse(rvs.exists('field3'))
self.assertFalse(rvs.exists(2))
def _getix(rv_, ix):
return rv_[ix]
self.assertRaises(E.SubdocPathNotFoundError, _getix, rvs, 2)
self.assertRaises(E.SubdocPathNotFoundError, _getix, rvs, 'field3')
self.assertFalse(rvs.exists('field3'))
# See what happens when we mix operations
self.assertRaises(E.CouchbaseError, cb.lookup_in, key,
SD.get('field1'), SD.insert('a', 'b'))
# Empty path (invalid)
self.assertRaises(E.CouchbaseError, cb.lookup_in, SD.get(''))
def get_subdoc():
print("\n[kv-get-subdoc]")
# tag::kv-get-subdoc[]
lookup_in_result = hotel_collection.lookup_in("hotel-123",
[subdocument.get("geo")])
print("CAS:", lookup_in_result.cas)
print("Data:", lookup_in_result.content_as[dict](0))
def retrieve_in(self, key, *paths, **kwargs):
"""Atomically fetch one or more paths from a document.
Convenience method for retrieval operations. This functions
identically to :meth:`lookup_in`. As such, the following two
forms are equivalent:
.. code-block:: python
import couchbase_v2.subdocument as SD
rv = cb.lookup_in(key,
SD.get('email'),
SD.get('name'),
SD.get('friends.therock')
email, name, friend = rv
.. code-block:: python
rv = cb.retrieve_in(key, 'email', 'name', 'friends.therock')
email, name, friend = rv
.. seealso:: :meth:`lookup_in`
"""
import couchbase_core.subdocument as SD
return self.lookup_in(key, *tuple(SD.get(x) for x in paths), **kwargs)
def with_expiry():
# type: (...) -> Spec
"""
Fetches the expiry from the xattrs of the doc
:return: Spec
"""
return SD.get('$document.exptime', xattr=True)
def get(path, # type: str
xattr=False # type: bool
):
# type: (...) -> Spec
"""
Fetches an element's value given a path.
:param str path: String path - path to the element
:param bool xattr: operation is done on an Extended Attribute.
:return: Spec
"""
return SD.get(path,xattr=xattr)
def test_xattrs_basic(self):
cb = self.cb
k = self.gen_key('xattrs')
cb.upsert(k, {})
# Try to upsert a single xattr
rv = cb.mutate_in(
k, SD.upsert('my.attr', 'value', xattr=True, create_parents=True))
self.assertTrue(rv.success)
body = cb.get(k)
self.assertFalse('my' in body.value)
self.assertFalse('my.attr' in body.value)
# Try using lookup_in
rv = cb.retrieve_in(k, 'my.attr')
self.assertFalse(rv.exists('my.attr'))
# Finally, use lookup_in with 'xattrs' attribute enabled
rv = cb.lookup_in(k, SD.get('my.attr', xattr=True))
self.assertTrue(rv.exists('my.attr'))
self.assertEqual('value', rv['my.attr'])
def generate(path):
if path is None:
return with_expiry()
if path:
return SD.get(path)
return get_full()
