def test_create_doc(self): cb = self.cb key = self.gen_key('create_doc') cb.mutate_in(key, SD.upsert('new.path', 'newval'), upsert_doc=True) self.assertEqual('newval', cb.retrieve_in(key, 'new.path')[0]) # Check 'insert_doc' self.assertRaises(E.KeyExistsError, cb.mutate_in, key, SD.upsert('new.path', 'newval'), insert_doc=True) cb.remove(key) cb.mutate_in(key, SD.upsert('new.path', 'newval'), insert_doc=True) self.assertEqual('newval', cb.retrieve_in(key, 'new.path')[0])
def __load_chain(self, start_num=0): for i, cluster in enumerate(self.get_cb_clusters()): if self._rdirection == REPLICATION_DIRECTION.BIDIRECTION: if i > len(self.get_cb_clusters()) - 1: break else: if i >= len(self.get_cb_clusters()) - 1: break if not self._dgm_run: for bucket in cluster.get_buckets(): client = SDKClient(scheme="couchbase", hosts=[cluster.get_master_node().ip], bucket=bucket.name).cb for i in xrange(start_num, start_num + self._num_items): key = 'k_%s_%s' % (i, str(cluster).replace(' ','_'). replace('.','_').replace(',','_').replace(':','_')) value = {'xattr_%s' % i:'value%s' % i} client.upsert(key, value) client.mutate_in(key, SD.upsert('xattr_%s' % i, 'value%s' % i, xattr=True, create_parents=True)) partition = bucket.kvs[1].acquire_partition(key)#["partition"] if self.only_store_hash: value = str(crc32.crc32_hash(value)) res = client.get(key) partition.set(key, json.dumps(value), 0, res.flags) bucket.kvs[1].release_partition(key) else: cluster.load_all_buckets_till_dgm( active_resident_threshold=self._active_resident_threshold, items=self._num_items)
def test_counter_in(self): cb = self.cb key = self.gen_key('sdcounter') cb.upsert(key, {}) rv = cb.mutate_in(key, SD.counter('counter', 100)) self.assertTrue(rv.success) self.assertFalse(rv.cas == 0) self.assertEqual(100, rv[0]) self.assertRaises(E.SubdocBadDeltaError, cb.mutate_in, key, SD.counter('not_a_counter', 'blah')) # Do an upsert cb.mutate_in(key, SD.upsert('not_a_counter', 'blah')) self.assertRaises(E.SubdocPathMismatchError, cb.mutate_in, key, SD.counter('not_a_counter', 25)) self.assertRaises(E.SubdocPathNotFoundError, cb.mutate_in, key, SD.counter('path.to.newcounter', 99)) rv = cb.mutate_in(key, SD.counter('path.to.newcounter', 99, create_parents=True)) self.assertEqual(99, rv[0]) # Increment first counter again rv = cb.mutate_in(key, SD.counter('counter', -25)) self.assertEqual(75, rv[0]) self.assertRaises(ValueError, SD.counter, 'counter', 0)
def test_enhanced_err_present_authorisation(self): import couchbase.subdocument as SD users=[('writer',('s3cr3t',[('data_reader', 'default'), ('data_writer', 'default')])), ('reader',('s3cr3t',[('data_reader', 'default')]))] #self.mockclient._do_request("SET_ENHANCED_ERRORS",{"enabled":True}) for user in users: print(str(user)) (userid, password, roles) = user[0],user[1][0],user[1][1] # add user self.admin.user_upsert(AuthDomain.Local, userid, password, roles) time.sleep(1) try: connection = self.make_connection(username=userid,password=password) key = self.gen_key('create_doc') connection.mutate_in(key, SD.upsert('new.path', 'newval'), upsert_doc=True) except CouchbaseError as e: print(str(e)) if userid=="writer": raise e else: self.assertRegexpMatches(e.context,r".*Authorization failure.*","doesn't have correct Context field") self.assertRegexpMatches(e.ref,r"(.*?)-(.*?)-.*","doesn't have correct Ref field") self.assertRegexpMatches(str(e),r".*Context=Authorization failure.*,.*Ref=.*","exception as string doesn't contain both fields") finally: #remove user self.admin.user_remove(AuthDomain.Local, userid)
def test_eventing_processes_mutations_when_mutated_through_subdoc_api_and_set_expiry_through_sdk(self): # set expiry pager interval ClusterOperationHelper.flushctl_set(self.master, "exp_pager_stime", 1, bucket=self.src_bucket_name) url = 'couchbase://{ip}/{name}'.format(ip=self.master.ip, name=self.src_bucket_name) bucket = Bucket(url, username="******", password="******") for docid in ['customer123', 'customer1234', 'customer12345']: bucket.insert(docid, {'some': 'value'}) body = self.create_save_function_body(self.function_name, self.handler_code, dcp_stream_boundary="from_now") # deploy eventing function self.deploy_function(body) # upserting a new sub-document bucket.mutate_in('customer123', SD.upsert('fax', '775-867-5309')) # inserting a sub-document bucket.mutate_in('customer1234', SD.insert('purchases.complete', [42, True, None], create_parents=True)) # Creating and populating an array document bucket.mutate_in('customer12345', SD.array_append('purchases.complete', ['Hello'], create_parents=True)) self.verify_eventing_results(self.function_name, 3, skip_stats_validation=True) for docid in ['customer123', 'customer1234', 'customer12345']: # set expiry on all the docs created using sub doc API bucket.touch(docid, ttl=5) self.sleep(10, "wait for expiry of the documents") # Wait for eventing to catch up with all the expiry mutations and verify results self.verify_eventing_results(self.function_name, 0, skip_stats_validation=True) self.undeploy_and_delete_function(body)
def set_xattr(self, sdk_conn): try: k = "sdk_1" sdk_conn.upsert(k, {}) sdk_conn.mutate_in(k, SD.upsert('my', {'value': 1}, xattr=True)) return True except Exception as e: log.info("Exception is from set_xattr function {0}".format(e)) return False
def dict_upsert(self, client, key='', path='', value=None): try: if self.verbose_func_usage: self.log.info(" dict_upsert ----> {0} :: {1}".format(path, value)) if self.use_sdk_client: client.mutate_in(key, SD.upsert(path, value, xattr=self.xattr)) else: client.dict_upsert_sd(key, path, value) except Exception: raise
def dict_upsert(self, client, key='', path='', value=None, xattr=None, create_parents=None): try: new_path = self.generate_path(self.nesting_level, path) if self.is_sdk_client: client.mutate_in(key, SD.upsert(path, value, xattr=xattr, create_parents=create_parents)) else: client.dict_upsert_sd(key, new_path, json.dumps(value)) except Exception as e: self.log.error(e) self.fail("Unable to add key {0} for path {1} after {2} tries".format(key, path, 1))
def create_xattr_data(self, type="system"): cluster = Cluster('couchbase://'+str(self.master.ip)) authenticator = PasswordAuthenticator(self.username, self.password) cluster.authenticate(authenticator) cb = cluster.open_bucket('default') docs = self.get_meta_ids() self.log.info("Docs: " + str(docs[0:5])) xattr_data = [] self.log.info("Adding xattrs to data") val = 0 for doc in docs: if type == "system": rv = cb.mutate_in(doc["id"], SD.upsert('_system1', val, xattr=True, create_parents=True)) xattr_data.append({'_system1': val}) rv = cb.mutate_in(doc["id"], SD.upsert('_system2', {'field1': val, 'field2': val*val}, xattr=True, create_parents=True)) xattr_data.append({'_system2': {'field1': val, 'field2': val*val}}) rv = cb.mutate_in(doc["id"], SD.upsert('_system3', {'field1': {'sub_field1a': val, 'sub_field1b': val*val}, 'field2': {'sub_field2a': 2*val, 'sub_field2b': 2*val*val}}, xattr=True, create_parents=True)) xattr_data.append({'_system3': {'field1': {'sub_field1a': val, 'sub_field1b': val*val}, 'field2': {'sub_field2a': 2*val, 'sub_field2b': 2*val*val}}}) if type == "user": rv = cb.mutate_in(doc["id"], SD.upsert('user1', val, xattr=True, create_parents=True)) xattr_data.append({'user1': val}) rv = cb.mutate_in(doc["id"], SD.upsert('user2', {'field1': val, 'field2': val*val}, xattr=True, create_parents=True)) xattr_data.append({'user2': {'field1': val, 'field2': val*val}}) rv = cb.mutate_in(doc["id"], SD.upsert('user3', {'field1': {'sub_field1a': val, 'sub_field1b': val*val}, 'field2': {'sub_field2a': 2*val, 'sub_field2b': 2*val*val}}, xattr=True, create_parents=True)) xattr_data.append({'user3': {'field1': {'sub_field1a': val, 'sub_field1b': val*val}, 'field2': {'sub_field2a': 2*val, 'sub_field2b': 2*val*val}}}) val = val + 1 self.log.info("Completed adding " + type + "xattrs to data to " + str(val) + " docs") return xattr_data
def test_eventing_processes_mutation_when_xattrs_is_updated(self): url = 'couchbase://{ip}/{name}'.format(ip=self.master.ip, name=self.src_bucket_name) bucket = Bucket(url, username="******", password="******") for docid in ['customer123', 'customer1234', 'customer12345']: bucket.upsert(docid, {}) body = self.create_save_function_body(self.function_name, self.handler_code, dcp_stream_boundary="from_now") # deploy eventing function self.deploy_function(body) # update multiple xattrs and update the documents for docid in ['customer123', 'customer1234', 'customer12345']: bucket.mutate_in(docid, SD.upsert('my1', {'value': 1}, xattr=True)) bucket.mutate_in(docid, SD.upsert('my2', {'value': 2}, xattr=True)) bucket.mutate_in(docid, SD.upsert('fax', '775-867-5309')) self.verify_eventing_results(self.function_name, 3, skip_stats_validation=True) # add new multiple xattrs , delete old xattrs and delete the documents for docid in ['customer123', 'customer1234', 'customer12345']: bucket.mutate_in(docid, SD.upsert('my3', {'value': 3}, xattr=True)) bucket.mutate_in(docid, SD.upsert('my4', {'value': 4}, xattr=True)) bucket.mutate_in(docid, SD.remove('my3', xattr=True)) bucket.mutate_in(docid, SD.remove('my4', xattr=True)) bucket.remove(docid) self.verify_eventing_results(self.function_name, 0, skip_stats_validation=True) self.undeploy_and_delete_function(body)
def test_eventing_processes_mutations_when_mutated_through_subdoc_api_and_set_expiry_through_sdk( self): # set expiry pager interval ClusterOperationHelper.flushctl_set(self.master, "exp_pager_stime", 1, bucket=self.src_bucket_name) url = 'couchbase://{ip}/{name}'.format(ip=self.master.ip, name=self.src_bucket_name) bucket = Bucket(url, username="******", password="******") for docid in ['customer123', 'customer1234', 'customer12345']: bucket.insert(docid, {'some': 'value'}) body = self.create_save_function_body(self.function_name, self.handler_code, dcp_stream_boundary="from_now") # deploy eventing function self.deploy_function(body) # upserting a new sub-document bucket.mutate_in('customer123', SD.upsert('fax', '775-867-5309')) # inserting a sub-document bucket.mutate_in( 'customer1234', SD.insert('purchases.complete', [42, True, None], create_parents=True)) # Creating and populating an array document bucket.mutate_in( 'customer12345', SD.array_append('purchases.complete', ['Hello'], create_parents=True)) self.verify_eventing_results(self.function_name, 3, skip_stats_validation=True) for docid in ['customer123', 'customer1234', 'customer12345']: # set expiry on all the docs created using sub doc API bucket.touch(docid, ttl=5) self.sleep(10, "wait for expiry of the documents") # Wait for eventing to catch up with all the expiry mutations and verify results self.verify_eventing_results(self.function_name, 0, skip_stats_validation=True) self.undeploy_and_delete_function(body)
def test_fulldoc(self): cb = self.cb key = self.gen_key('fulldoc') cb.mutate_in(key, SD.upsert_fulldoc({'val': True}), SD.upsert('my.xattr', 'attrval', create_parents=True, xattr=True), insert_doc=True) self.assertEqual(True, cb.retrieve_in(key, 'val')[0]) self.assertEqual('attrval', cb.lookup_in(key, SD.get('my.xattr', xattr=True))[0]) rv = cb.lookup_in(key, SD.get('my.xattr')) self.assertFalse(rv.exists(0)) # Get the document back rv = cb.lookup_in(key, SD.get_fulldoc()) self.assertEqual(True, rv[0]['val'])
def test_scenario_B(self): """ Scenario B: 1) fetch a document fragment which is a json array with elements 2) make modifications to the content 3) replace the fragment in the original document """ self.coll.upsert("id", {'someArray': ['wibble', 'gronk']}) subdoc = self.coll.get("id", GetOptions().project("someArray")) result = None if subdoc: arr = subdoc.content_as_array() arr.append("foo") result = self.coll.mutate_in( "id", [SD.upsert("someArray", arr)], MutateInOptions().timeout(Seconds(10))) self.assertIsInstance(result, MutateInResult)
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 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 __load_chain(self, start_num=0): for i, cluster in enumerate(self.get_cb_clusters()): if self._rdirection == REPLICATION_DIRECTION.BIDIRECTION: if i > len(self.get_cb_clusters()) - 1: break else: if i >= len(self.get_cb_clusters()) - 1: break if not self._dgm_run: for bucket in cluster.get_buckets(): client = SDKClient(scheme="couchbase", hosts=[cluster.get_master_node().ip], bucket=bucket.name).cb for i in range(start_num, start_num + self._num_items): key = 'k_%s_%s' % (i, str(cluster).replace( ' ', '_').replace('.', '_').replace( ',', '_').replace(':', '_')) value = {'xattr_%s' % i: 'value%s' % i} client.upsert(key, value) client.mutate_in( key, SD.upsert('xattr_%s' % i, 'value%s' % i, xattr=True, create_parents=True)) partition = bucket.kvs[1].acquire_partition( key) #["partition"] if self.only_store_hash: value = str(crc32.crc32_hash(value)) res = client.get(key) partition.set(key, json.dumps(value), 0, res.flags) bucket.kvs[1].release_partition(key) else: cluster.load_all_buckets_till_dgm( active_resident_threshold=self._active_resident_threshold, items=self._num_items)
def set_doc(self, client, key, value, exp, flags, xattr=None): if self.is_sdk_client: if xattr: # for verification xattr in subdoc client.cb.set(key, {}, exp, flags, ) if isinstance(value, dict): for k, v in value.items(): print(k, ":", v) rv = client.cb.mutate_in(key, SD.upsert(k, v, xattr=xattr)) self.log.info("xattr '%s' added successfully?: %s" % (k, rv.success)) self.assertTrue(rv.success) rv = client.cb.lookup_in(key, SD.exists(k, xattr=xattr)) self.log.info("xattr '%s' exists?: %s" % (k, rv.success)) try: self.assertTrue(rv.success) except Exception as e: raise e else: self.fail("Unable to handle non-json docs. Please review behavior") else: client.set(key, value, exp, flags,) else: client.set(key, exp, flags, value)
def set_doc(self, client, key, value, exp, flags, xattr=None): if self.is_sdk_client: if xattr: # for verification xattr in subdoc client.cb.set(key, {}, exp, flags, ) if isinstance(value, dict): for k, v in value.iteritems(): print k, ":", v rv = client.cb.mutate_in(key, SD.upsert(k, v, xattr=xattr)) self.log.info("xattr '%s' added successfully?: %s" % (k, rv.success)) self.assertTrue(rv.success) rv = client.cb.lookup_in(key, SD.exists(k, xattr=xattr)) self.log.info("xattr '%s' exists?: %s" % (k, rv.success)) try: self.assertTrue(rv.success) except Exception as e: raise e else: self.fail("Unable to handle non-json docs. Please review behavior") else: client.set(key, value, exp, flags,) else: client.set(key, exp, flags, value)
def update(self, key, subdoc_fields, size): newdoc = NewDocument(size) alphabet = newdoc._build_alphabet(key) for field in subdoc_fields.split(','): new_field_value = getattr(newdoc, '_build_' + field)(alphabet) self.client.mutate_in(key, SD.upsert(field, new_field_value))
def update_xattr(self, key: str, field: str, doc: dict): self.client.mutate_in(key, subdocument.upsert(path=field, value=doc, xattr=True, create_parents=True))
def update_xattr(self, key: str, field: str, doc: dict): self.client.mutate_in(key, subdocument.upsert(path=field, value=doc, xattr=True, create_parents=True))
def test_mutate_in(self): cb = self.cb key = self.gen_key('sdstore_upsert') cb.upsert(key, {}) cb.mutate_in(key, SD.upsert('newDict', ['hello'])) result = cb.retrieve_in(key, 'newDict') self.assertEqual(['hello'], result[0]) # Create deep path without create_parents self.assertRaises(E.SubdocPathNotFoundError, cb.mutate_in, key, SD.upsert('path.with.missing.parents', 'value')) # Create deep path using create_parents cb.mutate_in(key, SD.upsert('new.parent.path', 'value', create_parents=True)) result = cb.retrieve_in(key, 'new.parent') self.assertEqual('value', result[0]['path']) # Test CAS operations self.assertTrue(result.cas) self.assertRaises(E.KeyExistsError, cb.mutate_in, key, SD.upsert('newDict', None), cas=result.cas+1) # Try it again, using the CAS result2 = cb.mutate_in(key, SD.upsert('newDict', {}), cas=result.cas) self.assertNotEqual(result.cas, result2.cas) # Test insert, should fail self.assertRaises(E.SubdocPathExistsError, cb.mutate_in, key, SD.insert('newDict', {})) # Test insert on new path, should succeed cb.mutate_in(key, SD.insert('anotherDict', {})) self.assertEqual({}, cb.retrieve_in(key, 'anotherDict')[0]) # Test replace, should not fail cb.mutate_in(key, SD.replace('newDict', {'Hello': 'World'})) self.assertEqual('World', cb.retrieve_in(key, 'newDict')[0]['Hello']) # Test replace with missing value, should fail self.assertRaises(E.SubdocPathNotFoundError, cb.mutate_in, key, SD.replace('nonexist', {})) # Test with empty string (should be OK) cb.mutate_in(key, SD.upsert('empty', '')) self.assertEqual('', cb.retrieve_in(key, 'empty')[0]) # Test with null (None). Should be OK cb.mutate_in(key, SD.upsert('null', None)) self.assertEqual(None, cb.retrieve_in(key, 'null')[0]) # Test with empty path. Should throw some kind of error? self.assertRaises( (E.SubdocCantInsertValueError, E.SubdocEmptyPathError), cb.mutate_in, key, SD.upsert('', {})) cb.mutate_in(key, SD.upsert('array', [1, 2, 3])) self.assertRaises(E.SubdocPathMismatchError, cb.mutate_in, key, SD.upsert('array.newKey', 'newVal')) self.assertRaises(E.SubdocPathInvalidError, cb.mutate_in, key, SD.upsert('array[0]', 'newVal')) self.assertRaises(E.SubdocPathNotFoundError, cb.mutate_in, key, SD.upsert('array[3].bleh', 'newVal'))
bucket_name = settings.BUCKET_NAME user = settings.USERNAME password = settings.PASSWORD node = settings.CLUSTER_NODES[0] SDK_CLIENT = Bucket('couchbase://{0}/{1}'.format(node, bucket_name), username=user, password=password) SDK_CLIENT.timeout = 15 while True: try: print "." results = SDK_CLIENT.n1ql_query( 'SELECT symbol,price FROM {} WHERE symbol IS NOT MISSING AND price IS NOT MISSING' .format(bucket_name, )) for row in results: stock_key = "stock:" + (row['symbol']) # perturb the price and round it to 2 decimal places price_multiplier = random.normalvariate(1, 0.025) if row['symbol'] == "CBSE" and price_multiplier < 1: price_multiplier = 1 new_price = float(row['price']) * price_multiplier new_price = round(new_price, 2) SDK_CLIENT.mutate_in(stock_key, SD.upsert('price', new_price)) except Exception: pass time.sleep(8)
except PathNotFoundException: print("Path does not exist") # tag::lookup_in_multi[] result = collection.lookup_in( "customer123", [SD.get("addresses.delivery.country"), SD.exists("purchases.complete[-1]")]) print("{0}".format(result.content_as[str](0))) print("Path exists: {}.".format(result.exists(1))) # path exists: True. # end::lookup_in_multi[] # tag::mutate_in_upsert[] collection.mutate_in("customer123", [SD.upsert("fax", "311-555-0151")]) # end::mutate_in_upsert[] # tag::mutate_in_insert[] collection.mutate_in( "customer123", [SD.insert("purchases.pending", [42, True, "None"])]) try: collection.mutate_in( "customer123", [ SD.insert( "purchases.complete", [42, True, "None"])]) except PathExistsException: print("Path exists, cannot use insert.") # end::mutate_in_insert[]
def test_mutate_in_durability(self): if self.is_mock: raise SkipTest("mock doesn't support getting xattrs (like $document.expiry)") self.assertRaises(DurabilityImpossibleException, self.coll.mutate_in,self.KEY, (SD.upsert("c", "ccc"), SD.replace("b", "XXX"),), MutateInOptions(durability=ClientDurability(replicate_to=5)))
def test_mutate_in(self): cb = self.cb key = self.gen_key('sdstore_upsert') cb.upsert(key, {}) cb.mutate_in(key, SD.upsert('newDict', ['hello'])) result = cb.retrieve_in(key, 'newDict') self.assertEqual(['hello'], result[0]) # Create deep path without create_parents self.assertRaises(E.SubdocPathNotFoundError, cb.mutate_in, key, SD.upsert('path.with.missing.parents', 'value')) # Create deep path using create_parents cb.mutate_in( key, SD.upsert('new.parent.path', 'value', create_parents=True)) result = cb.retrieve_in(key, 'new.parent') self.assertEqual('value', result[0]['path']) # Test CAS operations self.assertTrue(result.cas) self.assertRaises(E.KeyExistsError, cb.mutate_in, key, SD.upsert('newDict', None), cas=result.cas + 1) # Try it again, using the CAS result2 = cb.mutate_in(key, SD.upsert('newDict', {}), cas=result.cas) self.assertNotEqual(result.cas, result2.cas) # Test insert, should fail self.assertRaises(E.SubdocPathExistsError, cb.mutate_in, key, SD.insert('newDict', {})) # Test insert on new path, should succeed cb.mutate_in(key, SD.insert('anotherDict', {})) self.assertEqual({}, cb.retrieve_in(key, 'anotherDict')[0]) # Test replace, should not fail cb.mutate_in(key, SD.replace('newDict', {'Hello': 'World'})) self.assertEqual('World', cb.retrieve_in(key, 'newDict')[0]['Hello']) # Test replace with missing value, should fail self.assertRaises(E.SubdocPathNotFoundError, cb.mutate_in, key, SD.replace('nonexist', {})) # Test with empty string (should be OK) cb.mutate_in(key, SD.upsert('empty', '')) self.assertEqual('', cb.retrieve_in(key, 'empty')[0]) # Test with null (None). Should be OK cb.mutate_in(key, SD.upsert('null', None)) self.assertEqual(None, cb.retrieve_in(key, 'null')[0]) # Test with empty path. Should throw some kind of error? self.assertRaises( (E.SubdocCantInsertValueError, E.SubdocEmptyPathError), cb.mutate_in, key, SD.upsert('', {})) cb.mutate_in(key, SD.upsert('array', [1, 2, 3])) self.assertRaises(E.SubdocPathMismatchError, cb.mutate_in, key, SD.upsert('array.newKey', 'newVal')) self.assertRaises(E.SubdocPathInvalidError, cb.mutate_in, key, SD.upsert('array[0]', 'newVal')) self.assertRaises(E.SubdocPathNotFoundError, cb.mutate_in, key, SD.upsert('array[3].bleh', 'newVal'))
def update(self, key: str, field: str, doc: dict): new_field_value = doc[field] self.client.mutate_in(key, subdocument.upsert(path=field, value=new_field_value))
def zero_enrollment_count(quarterId, courseNum, offeringId): return list( offering_bucket.mutate_in( quarterId, subdoc.upsert(courseNum + '.' + offeringId + '.enrolled', 0)))[0]
from couchbase.bucket import Bucket import couchbase.exceptions as E import couchbase.subdocument as SD cb = Bucket('couchbase://localhost/default') cb.upsert('docid', { 'name': 'Mark', 'email': '*****@*****.**', 'array': [1, 2, 3, 4] }) cb.mutate_in('docid', # Add 42 as a new element to 'array' SD.array_append('array', '42'), # Increment the numeric value of the first element by 99 SD.counter('array[0]', 99), # Add a new 'description' field SD.upsert('description', 'just a dev')) print('Document is now:', cb.get('docid').value) try: cb.mutate_in('docid', SD.upsert('deep.nested.path', 'some-value')) except E.SubdocPathNotFoundError as e: print('Caught exception', e) # Use `create` cb.mutate_in('docid', SD.upsert( 'deep.nested.path', 'some-value', create_parents=True)) print('Getting value back:', cb.retrieve_in('docid', 'deep.nested.path')[0])
def update(self, key: str, field: str, doc: dict): new_field_value = doc[field] self.client.mutate_in( key, subdocument.upsert(path=field, value=new_field_value))
def test_mutate_in_simple(self): cas = self.coll.mutate_in(self.KEY, (SD.upsert("c", "ccc"), SD.replace("b", "XXX"),)).cas self.try_n_times(10, 3, self._cas_matches, self.KEY, cas) result = self.coll.get(self.KEY).content_as[dict] self.assertDictEqual({"a": "aaa", "b": "XXX", "c": "ccc"}, result)
def update(self, key, subdoc_fields, size): newdoc = NewDocument(size) alphabet = newdoc._build_alphabet(key) for field in subdoc_fields.split(','): new_field_value = getattr(newdoc, '_build_' + field)(alphabet) self.client.mutate_in(key, SD.upsert(field, new_field_value))
def sd_upsert(self, key, path, doc, cas=None): if cas is not None: return self._cb.mutate_in(key, SD.upsert(path, doc, True), cas=cas) else: return self._cb.mutate_in(key, SD.upsert(path, doc, True))
print("Path exists? {0}", result.content_as[bool](1)) #end::combine[] """ ---- == Mutating Mutation operations modify one or more paths in the document. The simplest of these operations is _subdoc-upsert_, which, similar to the fulldoc-level _upsert_, will either modify the value of an existing path or create it if it does not exist: .Upserting a new sub-document [source,csharp] ---- """ #tag::upsert[] collection.mutate_in("customer123", [SD.upsert("fax", "311-555-0151")]) #end::upsert[] """ ---- Likewise, the _subdoc-insert_ operation will only add the new value to the path if it does not exist: .Inserting a sub-document [source,csharp] ---- """ #tag::insert[] collection.mutate_in("customer123", [SD.insert("purchases.complete", [42, True, "None"])]) # SubdocPathExistsError