Connecting to Couchbase Server

private static CouchbaseClient client;
new CouchbaseClient(urls, bucket, password)

Parameters:

Disconnecting from Couchbase Server

client.shutdown();
client.shutdown(long TimeValue, TimeUnit);

Parameters:

Add Operations

The add method adds a value to the database with the specified key, but will fail if the key already exists in the database.

client.add(key, expiry, value [, persistTo] ,[ replicateTo] )
client.add(key, expiry, value, transcoder)

Replace Operations

The replace method will replace an existing key with a new value but will fail if the key does not exist in the database.

client.replace(key, expiry, value [, persistTo] ,[ replicateTo])
client.replace(key, expiry, value, transcoder)

Set Operations (Durability Requirements)

The set method stores a value to the database with a specified key.

client.set(key, expiry, value [, persistTo] ,[ replicateTo])
client.set(key, expiry, value, transcoder)

Parameters:

There are several different flavors of retrieve operations in the Couchbase Server 1.1 Java SDK

client.asyncGet(key)
client.asyncGet(key, transcoder)
client.asyncGetAndLock(key, expiry)
client.asyncGetAndLock(key, expiry, transcoder)
client.asyncGetAndTouch(key, expiry)
client.asyncGetAndTouch(key, expiry, transcoder)
client.asyncGetBulk(keycollection)
client.asyncGetBulk(keyn)
client.asyncGetBulk(transcoder, keyn)
client.asyncGetBulk(keycollection, transcoder)
client.asyncGet(key, transcoder)
client.get(key)
client.getAndTouch(key, expiry)
client.getAndTouch(key, expiry, transcoder)
client.getBulk(keycollection)
client.getBulk(keyn)
client.getBulk(transcoder, keyn)
client.getBulk(keycollection, transcoder)
client.get(key, transcoder)
client.asyncGetLock(key [,getl-expiry])
client.asyncGetLock(key [,getl-expiry], transcoder)
client.getAndLock(key, getl-expiry)
client.getAndLock(key, getl-expiry, transcoder)
client.asyncGets(key)
client.asyncGets(key, transcoder)
client.gets(key)
client.gets(key, transcoder)
client.unlock(key, casunique)

Parameters:

For more information to create design documents using Java or for cluster management operations, take a look at http://www.couchbase.com/develop/java/current

The update methods support different methods of updating and changing existing information within Couchbase Server.

client.append(casunique, key, value)
client.append(casunique, key, value, transcoder)
client.asyncCAS(key, casunique, value)
client.asyncCAS(key, casunique, expiry, value, transcoder)
client.asyncCAS(key, casunique, value, transcoder)
client.cas(key, casunique, value [, persistTo] ,[ replicateTo])
client.cas(key, casunique, expiry, value, transcoder)
client.cas(key, casunique, value, transcoder)
client.asyncDecr(key, offset)
client.decr(key, offset)
client.decr(key, offset, default)
client.decr(key, offset, default, expiry)
client.delete(key [, persistTo] ,[ replicateTo])
client.asyncIncr(key, offset)
client.incr(key, offset)
client.incr(key, offset, default)
client.incr(key, offset, default, expiry)
client.prepend(casunique, key, value)
client.prepend(casunique, key, value, transcoder)
client.touch(key, expiry)

Parameters:

With Couchbase Server 2.0, you can add the power of views and querying those views to your applications.

Create a view object to be used when querying a view:

client.getView(ddocname, viewname)

Parameters:

Then create a new query object to be used when querying the view:

Query.new()
Query query = new Query();

Once, the view and query objects are available, the results of the server view can be accessed using

client.query(view, query)

Parameters:

Before accessing the view, a list of options can be set with the query object:

query.setKey(String key)to set the key to query in the view

query.setKey(ComplexKey key)to set the key to query in the view

query.setRangeStart(String startKey)to set the starting key

query.setRangeStart(ComplexKey startKey)to set the key to query in the view

query.setKey(String key)to set the starting key

query.setRangeEnd(String endKey)to set the key to query in the view

query.setRangeEnd(ComplexKey endKey)to set the ending key

query.setRange(String startKey, String endKey)to set a range

query.setRange(ComplexKey startKey, ComplexKey endKey)

query.setDescending(boolean descending)to sort in descending order

query.setIncludeDocs(boolean include)to include the JSON doc

query.setReduce(boolean reduce)execute the reduce function

query.setStale(Stale reduce)set to OK will not refresh the view even if it is stale, set to UPDATE_AFTER will update the view after the stale result is returned, FALSE will update the view and return the latest results.

The format of the returned information of the query method is : ViewResponse or any of the other inherited objects such as ViewResponseWithDocs, ViewResponseNoDocs, ViewResponseReduced

The ViewResponse method provides an iterator() method for iterating through the rows as a ViewRow interface. The ViewResponse method also provides a getMap() method where the result is available as a map.

Ruby

client = Couchbase.connect(url, options = {});
client = Couchbase.connect(options = {});

Hash Parameters:

client = Couchbase.bucket

Is a shared single instance of the Couchbase connection object in the Couchbase-model gem and can be used once connected, or when settings are specified in /config/couchbase.yml which connects on Rails startup.

Key

Keys can be any UTF-8 string up to 250 chars long. Metadata for keys is 125 bytes + length of key and always kept in RAM.

Value

If Value is a Hash, it is converted to JSON for Documents and decoded back to a Hash on Retrieve. Value can also be Strings, Binary Strings, Integers (for Atomic Counters, must be positive Integer), and Decimal. If Value is a JSON String you will get back a JSON String (like any other string) that is not parsed by JSON decoder into a Hash.

Add Operations

The add method adds a value to the database with the specified key, but will fail (Couchbase::Error::KeyExists) if the key already exists in the database.

client.add(key, value, options = {})
client.add[key, options = {}] = value

Replace Operations

The replace method will replace an existing key with a new value but will fail (Couchbase::Error::NotFound) if the key does not exist in the database

client.replace(key, value, options = {})
client.replace[key, options = {}] = value 

Set Operations

The set method stores a value to the database with a specified key, overwriting existing content if it exists (see add/replace above).

client.set(key, value, options = {})
client.set[key, options = {}] = value

options:

Asynchronous Store Example (Block)

client.run do
  client.add("foo" => "val1", "bar" => "val2") do |ret|
    ret.operation  #=> :add
    ret.success?   #=> true
    ret.keys       #=> "foo", "bar" in separate calls
    ret.cas              
    ret.flags           
  end
end

The Get method is a very versatile method, allowing for both optimistic and pessimistic locking, multiple gets, and hash like syntax.

Simple Get Operations

val = client.get(key, options = {})
val = client["key"]

Extended Tuple Get Operations

val, flags, cas = client.get(key, :extended => true)
val, flags, cas = client["key", :extended => true] 

Multi-Get Operations

val_array = client.get(keys)
val_hash = client.get(keys, :assemble_hash => true)

options:

Obtain stats from all servers for the connection (bucket)

client.stats
client.stats["stats"]

To Fetch Memory Stats

client.stats(:memory)

Parameters:

For Deleting of Keys/Values

client.delete(key)

Atomic Counter Operations

Atomic Counters are only atomic per cluster, but are useful for many different patterns and numeric data. They are unsigned positive integers. You cannot use atomic operations on floats or objects or arrays.

client.incr(key, delta, options = {})
client.decr(key, delta, options = {})

options:

Touch Operations

Reset the TTL expiration on one or more keys explicitly with the touch command, can also be done with a get command.

client.touch(key, ttl)
client.touch({"key1"=> ttl1, "key2" => ttl2})

Durability Requirements

Observe the state of the keys on all the nodes or using :replicated and :persisted it allows to set up the waiting rule

client.observe(*keys, options = {})
client.observe_and_wait(*keys, options = {})

Non-JSON Operations

For non-json values, prepend and append can concatenate to existing values accordingly. Defaults to:plain format for encoder/decoder.

client.prepend(key, value)
client.append(key, value)

Couchbase Website:http://www.couchbase.com

Couchbase Blog: http://blog.couchbase.com

Developer SDKs: http://www.couchbase.com/develop

Download: http://www.couchbase.com/download

Autodocs: http://www.couchbase.com/autodocs

With Couchbase Server 2.0, you can create Indexes through Map/Reduce functions. http://www.couchbase.com/docs/couchbase-manual-2.0/couchbase-views.html

Create Design Doc Object

Refer to the design_doc by name, the Views are an array of view names, as well as functions defined by name

ddoc = client.design_docs['design_doc_name']
ddoc.views   #=> ['view_name', 'view_name_2', …]

Use dot notation for accessing the view by your defined view name and pass in options for query parameters:

ddoc.view_name(params = {}).each do |doc|
  # do stuff with docs
end

options:

.NET

var config = new CouchbaseClientConfiguration();
config.Urls.Add(new Uri("http://

   :8091/pools/"));
config.Bucket = "

    ";
var client = new CouchbaseClient(config);

Based on the storemode, Store and ExecuteStore may be an Add, Replace or Set operation. Execute API's return the operation result.

Store Operations

object.Store(storemode, key, value)
object.Store(storemode, key, value, validfor)
object.Store(storemode, key, value, expiresat)

ExecuteStore Operations

object.ExecuteStore(storemode, key, value)
object.ExecuteStore(storemode, key, value, expiresat)
object.ExecuteStore(storemode, key, value, validfor)
object.ExecuteStore(storemode, key, value, ReplicateTo)
object.ExecuteStore(storemode, key, value, PersistTo)
object.ExecuteStore(storemode, key, value, PersistTo, ReplicateTo)

Parameters:

Get Operations

Get a value from Couchbase Sever

object.Get(key, expiry)
object.ExecuteGet(key, expiry)
object.ExecuteGet(key)
object.ExecuteGet(keyarray)
object.Get(key)
object.Get(keyarray)
object.GetWithCas(key)

Parameters:

Support updating existing information on the server

object.Append(key, value)
object.Append(key, casvalue, value)
object.ExecuteAppend(key, value)
object.ExecuteAppend(key, casvalue, value)
object.Cas(storemode, key, value)
object.Cas(storemode, key, value, casunique)
object.Cas(storemode, key, value, validfor, casunique)
object.ExecuteCas(storemode, key, value)
object.ExecuteCas(storemode, key, value, casunique)
object.ExecuteCas(storemode, key, value, expiresat, casunique)
object.ExecuteCas(storemode, key, value, validfor, casunique)
object.Decrement(key, defaultvalue, offset)
object.Decrement(key, defaultvalue, offset, casunique)
object.Decrement(key, defaultvalue, offset, expiresat, casunique)
object.Decrement(key, defaultvalue, offset, validfor, casunique)
object.Decrement(key, defaultvalue, offset, expiresat)
object.Decrement(key, defaultvalue, offset, validfor)
object.Decrement(key, defaultvalue, offset)
object.Decrement(key, defaultvalue, offset, casunique)
object.Decrement(key, defaultvalue, offset, validfor, casunique)
object.Decrement(key, defaultvalue, offset, expiresat)
object.Decrement(key, defaultvalue, offset, validfor)
object.ExecuteDecrement(key, defaultvalue, offset)
object.ExecuteDecrement(key, defaultvalue, offset, casunique)
object.ExecuteDecrement(key, defaultvalue, offset, expiresat, casunique)
object.ExecuteDecrement(key, defaultvalue, offset, validfor, casunique)
object.ExecuteDecrement(key, defaultvalue, offset, expiresat)
object.ExecuteDecrement(key, defaultvalue, offset, validfor)
object.ExecuteRemove(key)
object.Remove(key)
object.ExecuteIncrement(key, defaultvalue, offset)
object.ExecuteIncrement(key, defaultvalue, offset, casunique)
object.ExecuteIncrement(key, defaultvalue, offset, expiresat, casunique)
object.ExecuteIncrement(key, defaultvalue, offset, validfor, casunique)
object.ExecuteIncrement(key, defaultvalue, offset, expiresat)
object.ExecuteIncrement(key, defaultvalue, offset, validfor)
object.Increment(key, defaultvalue, offset)
object.Increment(key, defaultvalue, offset, casunique)
object.Increment(key, defaultvalue, offset, expiresat, casunique)
object.Increment(key, defaultvalue, offset, validfor, casunique)
object.Increment(key, defaultvalue, offset, expiresat)
object.Increment(key, defaultvalue, offset, validfor)
object.ExecutePrepend(key, value)
object.ExecutePrepend(key, casunique, value)
object.Prepend(key, value)
object.Prepend(key, casunique, value)
object.Touch(key, expiry)

Parameters:

With Couchbase Server 2.0, you can add the power of views and querying those views using your applications.

Create a view object to be used when querying a view:

GetView(designName, viewName)

Parameters:

There is also a generic version of GetView, which has a third boolean parameter that tells the client to lookup the original document by its ID.

GetView

   (designName, viewName, bLookup)

You can iterate over the returned collection as follows :

var beersByNameAndABV = client.GetView

   ("beers", "by_name_and_abv");
foreach(var beer in beersByNameAndABV) { … }

If you iterate over a strongly typed view each item is of the type you specified. If you use the non-generic version, each item you enumerate over will be of type IViewRow. IViewRow provides methods for accessing details of the row that are not present when using strongly typed views.

To get the original document from Couchbase:

row.GetItem()

To get a Dictionary representation of the view:

row.Info

To get the original document's ID:

row.ItemId

To get the key emitted by the map function:

row.ViewKey

To limit the number of documents returned by the query to 10:

GetView(designName, viewName).Limit(10)

To limit the number of documents returned by the query to 10:

GetView(designName, viewName).Limit(10)

To group the results when using _count for example:

GetView(designName, viewName).Group(true)

To disallow stale results in the view:

GetView(designName, viewName).Stale(StaleMode.False)

To limit the number of results to and order the results in descending order:

GetView(designName, viewName).Limit(5).Descending(true)

Using the NuGet package manager you can get the Couchbase .Net client using 'Install-Package CouchbaseNetClient'

To create a new MVC project using Couchbase Server , select File -> New Project and then select Web -> ASP.Net MVC4 application under the Visual C# project templates. Give your project a name and click "OK" to create the solution.

Next, you'll need to add a reference to the Couchbase .Net Client Library in your project.

Enjoy building your application using C#.Net and Couchbase Server

Useful Links

Couchbase Website : http://www.couchbase.com
Couchbase Blog : http://blog.couchbase.com
Developer SDKs : http://www.couchbase.com/develop
Download: http://www.couchbase.com/download