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()