Page tree
Skip to end of metadata
Go to start of metadata

CAST supports Couchbase via its NoSQL for Java extension. Details about the support provided for Java SDK source code is discussed below.

Supported Libraries

LibraryVersionSupported
Couchbase2.0.0 to 3.4.7

(tick)

Supported Operations (2.x)

Support is provided for CRUD operations only when jars are configured inside the classpath. In all other situations, CRUD operations for Couchbase 2.x are NOT supported.


Operation

Methods Supported

Insert
 Insert API's support by couchbase V2
  • com.couchbase.client.java.Bucket.insert
  • com.couchbase.client.java.AsyncBucket.insert
  • com.couchbase.client.java.Bucket.upsert
  • com.couchbase.client.java.Bucket.append
  • com.couchbase.client.java.Bucket.prepend
Select
 select API's support by couchbase V2
  • com.couchbase.client.java.Bucket.get
  • com.couchbase.client.java.AsyncBucket.get
  • com.couchbase.client.java.Bucket.getAndLock
  • com.couchbase.client.java.Bucket.getAndTouch
  • com.couchbase.client.java.AsyncBucket.getAndLock
  • com.couchbase.client.java.query.N1qlQuery.parameterized
  • com.couchbase.client.java.query.N1qlQuery.simple
  • com.couchbase.client.java.AsyncBucket.exists
Delete
 Delete API's support by couchbase V2
  • com.couchbase.client.java.Bucket.remove
  • com.couchbase.client.java.AsyncBucket.remove
Update
 Update API's support by couchbase V2
  • com.couchbase.client.java.Bucket.replace
  • com.couchbase.client.java.AsyncBucket.replace

Supported Operations (3.x)

Support is provided for CRUD operations in Couchbase 3.x in all situations.

OperationMethods Supported
Insert
 Insert API's support by couchbase V3
  • com.couchbase.client.java.Collection.insert
  • com.couchbase.client.java.Collection.upsert
  • com.couchbase.client.java.AsyncCollection.insert
  • com.couchbase.client.java.AsyncCollection.upsert
  • com.couchbase.client.java.ReactiveCollection.insert
  • com.couchbase.client.java.ReactiveCollection.upsert
Select
 Select API's support by couchbase V3
  • com.couchbase.client.java.Collection.get
  • com.couchbase.client.java.Collection.getAndTouch
  • com.couchbase.client.java.Collection.getAndLock
  • com.couchbase.client.java.Collection.exists
  • com.couchbase.client.java.Cluster.query
  • com.couchbase.client.java.Scope.query
  • com.couchbase.client.java.AsyncCollection.get
  • com.couchbase.client.java.AsyncCollection.getAndTouch
  • com.couchbase.client.java.AsyncCollection.getAndLock
  • com.couchbase.client.java.AsyncCollection.exists
  • com.couchbase.client.java.AsyncCollection.query
  • com.couchbase.client.java.AsyncCollection.query
  • com.couchbase.client.java.ReactiveCollection.get
  • com.couchbase.client.java.ReactiveCollection.getAndTouch
  • com.couchbase.client.java.ReactiveCollection.getAndLock
  • com.couchbase.client.java.ReactiveCollection.exists
  • com.couchbase.client.java.ReactiveCollection.query
  • com.couchbase.client.java.ReactiveCollection.query
Delete
 Delete API's support by couchbase V3
  • com.couchbase.client.java.Collection.remove
  • com.couchbase.client.java.AsyncCollection.remove
  • com.couchbase.client.java.ReactiveCollection.remove
Update
 Update API's support by couchbase V3
  • com.couchbase.client.java.Collection.replace
  • com.couchbase.client.java.AsyncCollection.replace
  • com.couchbase.client.java.ReactiveCollection.replace

What results can you expect?

Objects (Couchbase 2.x)

Icon 

Description

Java Couchbase Cluster

Java Couchbase Bucket

Java Couchbase Unknown Cluster

 

Java Couchbase Unknown Bucket 

Objects (Couchbase 3.x)

IconDescription

Java Couchbase Cluster

Java Couchbase Bucket

Java Couchbase Collection

Java Couchbase Unknown Cluster

 

Java Couchbase Unknown Bucket 

Java Couchbase Unknown Collection

Links (Couchbase 2.x)

Links are created for transaction and function point needs:

Link typeSource and destination of linkMethods supported
belongsTo

From Java Couchbase Collection object to Java Couchbase Bucket object and Java Couchbase Bucket object to Java Couchbase Cluster object


useLinkBetween the caller Couchbase Java Method objects and Java Couchbase Buckets/Collection objects
  • Upsert
  • N1QL.parameterized
  • N1QL.simple

useSelectLink

  • get()
  • async().get()
  • getAndTouch()
  • async().getAndTouch()
  • getAndLock()
  • async().getAndLock()
  • exists()
  • async().exists()
useUpdateLink
  • replace()
  • async().replace()
  • append()
  • async().append()
  • prepend()
  • async.prepend()
useDeleteLink
  • remove()
  • async().remove()
useInsertLink
  • insert
  • async().insert()

Links (Couchbase 3.x)

Link typeSource and destination of linkMethods supported
parentLink
  • Between Couchbase Connection object and Bucket object
  • Between Couchbase bucket object and Collection object



useLinkBetween the caller Couchbase Java Method objects and Couchbase Buckets objects
  • Upsert

useSelectLink

  • get()
  • async().get()
  • getAndTouch()
  • async().getAndTouch()
  • getAndLock()
  • async().getAndLock()
  • exists()
  • async().exists()
  • Cluster().query()
  • Scope().query()
useUpdateLink
  • replace()
  • async().replace()
useDeleteLink
  • remove()
  • async().remove()
useInsertLink
  • insert
  • async().insert()

Code examples

Cluster and Bucket Object 

 Cluster and Bucket (2.x)
public class App 
{
    public static void main( String[] args )
    {
    	
        System.out.println("Create connection");
	   	final Cluster cluster = CouchbaseCluster.create("127.0.0.1");
    	cluster.authenticate("Administrator", "Password");
	}
}

public class App 
{
    public static void main( String[] args )
    {
    	
        System.out.println("Create connection");
    	final Cluster cluster = CouchbaseCluster.create("127.0.0.1");
    	cluster.authenticate("Administrator", "Password");
    	Bucket myBucket1 = cluster.openBucket("example1");
    }
}

 Connection,bucket and collection objects(3.x)

Connection, Bucket and Cluster object

  public static void main(String... args) {

    Cluster cluster = Cluster.connect("localhost", "Administrator", "password");

    Bucket bucket = cluster.bucket("travel-sample");
    Scope scope = bucket.scope("_default");
    Collection collection = scope.collection("_default");

Insert operations

 Insert link(2.x)
public class App 
{
    public static void main( String[] args )
    {
    	
        System.out.println("Create connection");
    	final Cluster cluster = CouchbaseCluster.create("127.0.0.1");
    	cluster.authenticate("Administrator", "Password");
    	Bucket myBucket = cluster.openBucket("example");
    	JsonObject content = JsonObject.empty()
    			  .put("name", "John Doe")
    			  .put("type", "Person")
    			  .put("email", "john.doe@mydomain.com")
    			  .put("homeTown", "Chicago");
		String id = UUID.randomUUID().toString();
    	JsonDocument document = JsonDocument.create(id, content);
		JsonDocument inserted = myBucket.insert(document);
	}
}

 Insert link(3.x)
public void insert()
{
      System.out.println("\nExample: [insert]");
      // tag::insert[]
      try {
        JsonObject content = JsonObject.create().put("title", "My Blog Post 2");
        MutationResult insertResult = collection.insert("document-key2", content);
      } catch (DocumentExistsException ex) {
        System.err.println("The document already exists!");
      } catch (CouchbaseException ex) {
        System.err.println("Something else happened: " + ex);
      }
      // end::insert[]
    }


Select operations

 Select link(2.x)
  • get()
    public class App 
    {
        public static void main( String[] args )
        {
        	
            System.out.println("Create connection");
        	final Cluster cluster = CouchbaseCluster.create("127.0.0.1");
        	cluster.authenticate("Administrator", "Password");
        	Bucket myBucket = cluster.openBucket("example");
        	JsonObject content = JsonObject.empty()
        			  .put("name", "John Doe")
        			  .put("type", "Person")
        			  .put("email", "john.doe@mydomain.com")
        			  .put("homeTown", "Chicago");
    		String id = UUID.randomUUID().toString();
        	JsonDocument document = JsonDocument.create(id, content);
    		JsonDocument inserted = myBucket.insert(document);
    		JsonDocument document1 = JsonDocument.create(id, content1);
    
    
    		JsonDocument gets = myBucket.get(document);
    		System.out.println(gets);
    
    	}
    }
  • getAndTouch()

    public class App 
    {
        public static void main( String[] args )
        {
        	
            System.out.println("Create connection");
        	final Cluster cluster = CouchbaseCluster.create("127.0.0.1");
        	cluster.authenticate("Administrator", "password");
        	Bucket myBucket = cluster.openBucket("example");
        	JsonObject content = JsonObject.empty()
        			  .put("name", "John Doe")
        			  .put("type", "Person")
        			  .put("email", "john.doe@mydomain.com")
        			  .put("homeTown", "Chicago");
    		String id = UUID.randomUUID().toString();
        	JsonDocument document = JsonDocument.create(id, content);
    		JsonDocument inserted = myBucket.insert(document);
    		JsonDocument document1 = JsonDocument.create(id, content1);
    
    		JsonDocument getandtouch = myBucket.getAndTouch(document);
    		System.out.println(getandtouch);
    	}
    }
  • getAndLock()
    public class App 
    {
        public static void main( String[] args )
        {
        	
            System.out.println("Create connection");
        	final Cluster cluster = CouchbaseCluster.create("127.0.0.1");
        	cluster.authenticate("Administrator", "Password");
        	Bucket myBucket = cluster.openBucket("example");
        	JsonObject content = JsonObject.empty()
        			  .put("name", "John Doe")
        			  .put("type", "Person")
        			  .put("email", "john.doe@mydomain.com")
        			  .put("homeTown", "Chicago");
    		String id = UUID.randomUUID().toString();
        	JsonDocument document = JsonDocument.create(id, content);
    		JsonDocument inserted = myBucket.insert(document);
    		JsonDocument document1 = JsonDocument.create(id, content1);
    
    		JsonDocument getandlock = myBucket.getAndLock(document, 10);
    		System.out.println(getandlock);
    	}
    }
  • exists()
    public class App 
    {
        public static void main( String[] args )
        {
        	
            System.out.println("Create connection");
        	final Cluster cluster = CouchbaseCluster.create("127.0.0.1");
        	cluster.authenticate("Administrator", "Password");
        	Bucket myBucket = cluster.openBucket("example");
        	JsonObject content = JsonObject.empty()
        			  .put("name", "John Doe")
        			  .put("type", "Person")
        			  .put("email", "john.doe@mydomain.com")
        			  .put("homeTown", "Chicago");
    		String id = UUID.randomUUID().toString();
        	JsonDocument document = JsonDocument.create(id, content);
    		JsonDocument inserted = myBucket.insert(document);
    		JsonDocument document1 = JsonDocument.create(id, content1);
    		
    		Boolean exists = myBucket.exists(document);
    		System.out.println(exists);
    	}
    }

 Select Link(3.x)
public void get()
{
      System.out.println("\nExample: [get-simple]");
      // tag::get-simple[]
      try {
        GetResult getResult = collection.get("document-key");
        String title = getResult.contentAsObject().getString("title");
        System.out.println(title); // title == "My Blog Post"
      } catch (DocumentNotFoundException ex) {
        System.out.println("Document not found!");
      }
      // end::get-simple[]
    }
public void getAndTouch()
    {
      System.out.println("\nExample: [expiry-touch]");
      // tag::expiry-touch[]
      GetResult result = collection.getAndTouch("my-document3", Duration.ofDays(1));
      // end::expiry-touch[]

      System.out.println("cas value: " + result.cas());
    }

Update Operations

 Update link(2.x)
  • replace()
    public class App 
    {
        public static void main( String[] args )
        {
        	
            System.out.println("Create connection");
        	final Cluster cluster = CouchbaseCluster.create("127.0.0.1");
        	cluster.authenticate("Administrator", "Password");
        	Bucket myBucket = cluster.openBucket("example");
        	JsonObject content = JsonObject.empty()
        			  .put("name", "John Doe")
        			  .put("type", "Person")
        			  .put("email", "john.doe@mydomain.com")
        			  .put("homeTown", "Chicago");
    
    		JsonObject content3 = JsonObject.empty()
        			.put("Emp_Trigram", "ABC")
        			.put("Emp_id", "001");
    		JsonDocument document1 = JsonDocument.create(id, content1);
    
    		String id = UUID.randomUUID().toString();
        	JsonDocument document = JsonDocument.create(id, content);
    		JsonDocument inserted = myBucket.insert(document);
    		JsonDocument document1 = JsonDocument.create(id, content1);
    		
    		JsonDocument removed = myBucket.replace(document1);
    		System.out.println(myBucket);
    	}
    }
  • prepend()
    public class App 
    {
        public static void main( String[] args )
        {
        	
            System.out.println("Create connection");
        	final Cluster cluster = CouchbaseCluster.create("127.0.0.1");
        	cluster.authenticate("Administrator", "Password");
        	Bucket myBucket = cluster.openBucket("example");
        	JsonObject content = JsonObject.empty()
        			  .put("name", "John Doe")
        			  .put("type", "Person")
        			  .put("email", "john.doe@mydomain.com")
        			  .put("homeTown", "Chicago");
    		String id = UUID.randomUUID().toString();
        	JsonDocument document = JsonDocument.create(id, content);
    		JsonDocument inserted = myBucket.insert(document);
    		JsonObject content3 = JsonObject.empty()
        			.put("Emp_Trigram", "ABC")
        			.put("Emp_id", "001");
    		JsonDocument document1 = JsonDocument.create(id, content1);
    
    		JsonDocument prepended = myBucket.prepend(document1);
    
    	}
    }
  • append()
    public class App 
    {
        public static void main( String[] args )
        {
        	
            System.out.println("Create connection");
        	final Cluster cluster = CouchbaseCluster.create("127.0.0.1");
        	cluster.authenticate("Administrator", "Password");
        	Bucket myBucket = cluster.openBucket("example");
        	JsonObject content = JsonObject.empty()
        			  .put("name", "John Doe")
        			  .put("type", "Person")
        			  .put("email", "john.doe@mydomain.com")
        			  .put("homeTown", "Chicago");
    		String id = UUID.randomUUID().toString();
        	JsonDocument document = JsonDocument.create(id, content);
    		JsonDocument inserted = myBucket.insert(document);
    		JsonObject content3 = JsonObject.empty()
        			.put("Emp_Trigram", "ABC")
        			.put("Emp_id", "001");
    		JsonDocument document1 = JsonDocument.create(id, content1);
    
    		JsonDocument upserted = myBucket1.upsert(document);
        	JsonDocument upserted1 = myBucket1.upsert(document, PersistTo.NONE);
        	JsonDocument upserted2 = myBucket1.upsert(document, ReplicateTo.NONE);
        	JsonDocument upserted3 = myBucket1.upsert(document, PersistTo.NONE, ReplicateTo.NONE);
        	JsonDocument upserted4 = myBucket1.upsert(document, 100, TimeUnit.MILLISECONDS);
        	JsonDocument upserted5 = myBucket1.upsert(document, PersistTo.NONE, 100, TimeUnit.MILLISECONDS);
        	JsonDocument upserted6 = myBucket1.upsert(document, ReplicateTo.NONE, 100, TimeUnit.MILLISECONDS);
        	JsonDocument upserted7 = myBucket1.upsert(document, PersistTo.NONE, ReplicateTo.NONE, 100, TimeUnit.MILLISECONDS);
    
    	}
    }

 Update link(3.x)
public void get()
{
      System.out.println("\nExample: [expiry-replace]");
      // tag::expiry-replace[]
      GetResult found = collection.get("my-document3", getOptions().withExpiry(true));

      MutationResult result = collection.replace("my-document3", json,
          replaceOptions().expiry(found.expiryTime().get()));
      // end::expiry-replace[]

      System.out.println("cas value: " + result.cas());
    }

Delete Operations

 Delete link(2.x)
  • remove()

       

public class App 
{
    public static void main( String[] args )
    {
    	
        System.out.println("Create connection");
    	final Cluster cluster = CouchbaseCluster.create("127.0.0.1");
    	cluster.authenticate("Administrator", "Password");
    	Bucket myBucket = cluster.openBucket("example");
    	JsonObject content = JsonObject.empty()
    			  .put("name", "John Doe")
    			  .put("type", "Person")
    			  .put("email", "john.doe@mydomain.com")
    			  .put("homeTown", "Chicago");
		String id = UUID.randomUUID().toString();
    	JsonDocument document = JsonDocument.create(id, content);
		JsonDocument inserted = myBucket.insert(document);
		JsonDocument document1 = JsonDocument.create(id, content1);
		
		JsonDocument removed = myBucket.remove(document);
		System.out.println(myBucket);
	}
}

 Delete link(3.x)
public void remove()

{
      System.out.println("\nExample: [remove]");
      // tag::remove[]
      try {
        collection.remove("my-document");
      } catch (DocumentNotFoundException ex) {
        System.out.println("Document did not exist when trying to remove");
      }
      // end::remove[]
    }

Batch Operations

 Batch Operations(2.x)
int docsToCreate = 100;
List<JsonDocument> documents = new ArrayList<JsonDocument>();
for (int i = 0; i < docsToCreate; i++) {
    JsonObject content = JsonObject.create()
        .put("counter", i)
        .put("name", "Foo Bar");
    documents.add(JsonDocument.create("doc-"+i, content));
}

// Insert them in one batch, waiting until the last one is done.
Observable
    .from(documents)
    .flatMap(new Func1<JsonDocument, Observable<JsonDocument>>() {
        @Override
        public Observable<JsonDocument> call(final JsonDocument docToInsert) {
            return bucket.async().insert(docToInsert);
        }
    })
    .last()
    .toBlocking()
    .single();

Queries

 N1QL(2.x)
protected static N1qlQuery buildQuery(Statement statement, JsonValue queryPlaceholderValues, ScanConsistency scanConsistency) {
		Cluster cluster = CouchbaseCluster.create("localhost");  
		N1qlParams n1qlParams = N1qlParams.build().consistency(scanConsistency);
		 N1qlQuery query;
		 if (queryPlaceholderValues instanceof JsonObject && !((JsonObject) queryPlaceholderValues).isEmpty()) {
		  query = N1qlQuery.parameterized(statement, (JsonObject) queryPlaceholderValues, n1qlParams);
		 } else if (queryPlaceholderValues instanceof JsonArray && !((JsonArray) queryPlaceholderValues).isEmpty()) {
		  query = N1qlQuery.parameterized(statement, (JsonArray) queryPlaceholderValues, n1qlParams);
		 } else {
		  query = N1qlQuery.simple(statement, n1qlParams);
		 }
		 return query;
		}

 Cluster query(3.x)
 private void initHotel(String bucketName) {
	  hotelcluster = Cluster.connect("HotelServer", "Administrator", "password");  
	  hotelBucket = hotelcluster.bucket(bucketName);
	  hotelScope = hotelBucket.scope("inventory");
	
  }
  
  public void clusterQuery() throws Exception {
	  
	  QueryResult result2 = hotelcluster.query("SELECT h.name, h.phone FROM default:`travel-sample`.inventory.hotel h\r\n"
	  		+ "WHERE h.city=\"Manchester\" AND h.directions IS NOT MISSING ORDER BY h.name LIMIT 10",
	            queryOptions().metrics(true));
	  
	  }

  public static void main(String[] args) throws Exception {
	App7 obj = new App7();
    obj.initHotel("hotelBucket");
    obj.scopeQuery();
    obj.clusterQuery();
  }

 Scope query(3.x)
 private void init(String bucketName) {
	    cluster = Cluster.connect("App5127.0.0.1", "Administrator", "password");  
	    bucket = cluster.bucket(bucketName);
	    scope = bucket.scope("inventory");
	
  }
  
  public void scopeQuery() throws Exception {
 
    QueryResult queryResult2 = scope.query("select *  FROM `passenger`", queryOptions().timeout(Duration.ofSeconds(3)));

  }

  public static void main(String[] args) throws Exception {
	App7 obj = new App7();
    obj.init("airlineBucket");
    obj.scopeQuery();
    obj.clusterQuery();
  }

Limitations

  • If the bucket or cluster name is not resolved, then "Java Couchbase Unknown Objects" will be created.
  • No labels