cassandra-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Apache Wiki <wikidi...@apache.org>
Subject [Cassandra Wiki] Update of "API07" by ToddBlose
Date Thu, 22 Apr 2010 06:19:37 GMT
Dear Wiki user,

You have subscribed to a wiki page or wiki category on "Cassandra Wiki" for change notification.

The "API07" page has been changed by ToddBlose.
http://wiki.apache.org/cassandra/API07?action=diff&rev1=1&rev2=2

--------------------------------------------------

  Authenticates with the cluster for operations on the specified keyspace using the specified
`AuthenticationRequest` credentials. Throws `AuthenticationException` if the credentials are
invalid or `AuthorizationException` if the credentials are valid, but not for the specified
keyspace.
  
  === get ===
-  . `ColumnOrSuperColumn get(keyspace, key, column_path, consistency_level)`
+  . `ColumnOrSuperColumn get(key, column_path, consistency_level)`
  
  Get the `Column` or `SuperColumn` at the given `column_path`.  If no value is present, `NotFoundException`
is thrown.  (This is the only method that can throw an exception under non-failure conditions.)
  
  === get_slice ===
-  . `list<ColumnOrSuperColumn> get_slice(keyspace, key, column_parent, predicate, consistency_level)`
+  . `list<ColumnOrSuperColumn> get_slice(key, column_parent, predicate, consistency_level)`
  
  Get the group of columns contained by `column_parent` (either a `ColumnFamily` name or a
`ColumnFamily/SuperColumn` name pair) specified by the given `SlicePredicate` struct.
  
  === multiget_slice ===
-  . `map<string,list<ColumnOrSuperColumn>> multiget_slice(keyspace, keys, column_parent,
predicate, consistency_level)`
+  . `map<string,list<ColumnOrSuperColumn>> multiget_slice(keys, column_parent,
predicate, consistency_level)`
  
  Retrieves slices for `column_parent` and `predicate` on each of the given keys in parallel.
Keys are a `list<string> of the keys to get slices for.
  
  This is similar to `get_range_slice` (Cassandra 0.5) except operating on a set of non-contiguous
keys instead of a range of keys.
  
  === get_count ===
-  . `i32 get_count(keyspace, key, column_parent, consistency_level)`
+  . `i32 get_count(key, column_parent, consistency_level)`
  
  Counts the columns present in `column_parent`.
  
  The method is not O(1). It takes all the columns from disk to calculate the answer. The
only benefit of the method is that you do not need to pull all the columns over Thrift interface
to count them.
  
  === get_range_slices ===
-  . `list<KeySlice> get_range_slices(keyspace, column_parent, predicate, range, consistency_level)`
+  . `list<KeySlice> get_range_slices(column_parent, predicate, range, consistency_level)`
  
  Replaces `get_range_slice`. Returns a list of slices for the keys within the specified `KeyRange`.
Unlike get_key_range, this applies the given predicate to all keys in the range, not just
those with undeleted matching data.  This method is only allowed when using an order-preserving
partitioner.
  
  === insert ===
-  . `insert(keyspace, key, column_path, value, timestamp, consistency_level)`
+  . `insert(key, column_path, value, timestamp, consistency_level)`
  
  Insert a `Column` consisting of (`column_path.column`, `value`, `timestamp`) at the given
`column_path.column_family` and optional `column_path.super_column`.  Note that `column_path.column`
is here required, since a !SuperColumn cannot directly contain binary values -- it can only
contain sub-Columns.
  
  === batch_mutate ===
-  . `batch_mutate(keyspace, mutation_map, consistency_level)`
+  . `batch_mutate(mutation_map, consistency_level)`
  
  Executes the specified mutations on the keyspace. `mutation_map` is a `map<string, map<string,
list<Mutation>>>`; the outer map maps the key to the inner map, which maps the
column family to the `Mutation`; can be read as: `map<key : string, map<column_family
: string, list<Mutation>>>`.  To be more specific, the outer map key is a row
key, the inner map key is the column family name.
  
  A `Mutation` specifies either columns to insert or columns to delete. See `Mutation` and
`Deletion` above for more details.
  
  === remove ===
-  . `remove(keyspace, key, column_path, timestamp, consistency_level)`
+  . `remove(key, column_path, timestamp, consistency_level)`
  
  Remove data from the row specified by `key` at the granularity specified by `column_path`,
and the given `timestamp`.  Note that all the values in `column_path` besides `column_path.column_family`
are truly optional: you can remove the entire row by just specifying the !ColumnFamily, or
you can remove a !SuperColumn or a single Column by specifying those levels too. Note that
the `timestamp` is needed, so that if the commands are replayed in a different order on different
nodes, the same result is produced.
  

Mime
View raw message