mirror of https://github.com/apache/cassandra
385 lines
12 KiB
Plaintext
385 lines
12 KiB
Plaintext
/**
|
|
* Licensed to the Apache Software Foundation (ASF) under one
|
|
* or more contributor license agreements. See the NOTICE file
|
|
* distributed with this work for additional information
|
|
* regarding copyright ownership. The ASF licenses this file
|
|
* to you under the Apache License, Version 2.0 (the
|
|
* "License"); you may not use this file except in compliance
|
|
* with the License. You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
/**
|
|
* Cassandra client interface
|
|
*/
|
|
@namespace("org.apache.cassandra.avro")
|
|
|
|
protocol Cassandra {
|
|
record ColumnPath {
|
|
string column_family;
|
|
union { bytes, null } super_column;
|
|
union { bytes, null } column;
|
|
}
|
|
|
|
record ColumnParent {
|
|
string column_family;
|
|
union { bytes, null } super_column;
|
|
}
|
|
|
|
record Clock {
|
|
long timestamp;
|
|
}
|
|
|
|
record Column {
|
|
bytes name;
|
|
bytes value;
|
|
Clock clock;
|
|
union { int, null } ttl;
|
|
}
|
|
|
|
record SuperColumn {
|
|
bytes name;
|
|
array<Column> columns;
|
|
}
|
|
|
|
record ColumnOrSuperColumn {
|
|
union { Column, null } column;
|
|
union { SuperColumn, null } super_column;
|
|
}
|
|
|
|
record SliceRange {
|
|
bytes start;
|
|
bytes finish;
|
|
boolean reversed;
|
|
int count;
|
|
union { array<bytes>, null } bitmasks;
|
|
}
|
|
|
|
record SlicePredicate {
|
|
union { array<bytes>, null } column_names;
|
|
union { SliceRange, null } slice_range;
|
|
}
|
|
|
|
record TokenRange {
|
|
string start_token;
|
|
string end_token;
|
|
array<string> endpoints;
|
|
}
|
|
|
|
enum IndexOperator {
|
|
EQ, GTE, GT, LTE, LT
|
|
}
|
|
|
|
record IndexExpression {
|
|
bytes column_name;
|
|
IndexOperator op;
|
|
bytes value;
|
|
}
|
|
|
|
record IndexClause {
|
|
array<IndexExpression> expressions;
|
|
bytes start_key;
|
|
int count;
|
|
}
|
|
|
|
/**
|
|
* The semantics of start keys and tokens are slightly different.
|
|
* Keys are start-inclusive; tokens are start-exclusive. Token
|
|
* ranges may also wrap -- that is, the end token may be less
|
|
* than the start one. Thus, a range from keyX to keyX is a
|
|
* one-element range, but a range from tokenY to tokenY is the
|
|
* full ring.
|
|
*/
|
|
record KeyRange {
|
|
union { bytes, null } start_key;
|
|
union { bytes, null } end_key;
|
|
union { string, null } start_token;
|
|
union { string, null } end_token;
|
|
int count;
|
|
}
|
|
|
|
record KeySlice {
|
|
bytes key;
|
|
array<ColumnOrSuperColumn> columns;
|
|
}
|
|
|
|
record Deletion {
|
|
Clock clock;
|
|
union { bytes, null } super_column;
|
|
union { SlicePredicate, null } predicate;
|
|
}
|
|
|
|
record Mutation {
|
|
union { ColumnOrSuperColumn, null } column_or_supercolumn;
|
|
union { Deletion, null } deletion;
|
|
}
|
|
|
|
/* NB: Until AVRO-495: must be kept sync'd with src/avro/internode.genavro. */
|
|
enum IndexType {
|
|
KEYS
|
|
}
|
|
|
|
/* describes a column in a column family. */
|
|
/* NB: Until AVRO-495: must be kept sync'd with src/avro/internode.genavro. */
|
|
record ColumnDef {
|
|
bytes name;
|
|
string validation_class;
|
|
union { IndexType, null } index_type;
|
|
union { string, null } index_name;
|
|
}
|
|
|
|
/**
|
|
* describes a keyspace:
|
|
* NB: the id field is ignored during column family creation: the server will choose an appropriate value.
|
|
*/
|
|
/* NB: Until AVRO-495: must be kept sync'd with src/avro/internode.genavro. */
|
|
record CfDef {
|
|
string keyspace;
|
|
string name;
|
|
union { string, null } column_type;
|
|
union { string, null } clock_type;
|
|
union { string, null } comparator_type;
|
|
union { string, null } subcomparator_type;
|
|
union { string, null } reconciler;
|
|
union { string, null } comment;
|
|
union { double, null } row_cache_size;
|
|
union { boolean, null } preload_row_cache;
|
|
union { double, null } key_cache_size;
|
|
union { double, null } read_repair_chance;
|
|
union { int, null } gc_grace_seconds;
|
|
union { null, string } default_validation_class = null;
|
|
union { int, null } id;
|
|
union { array<ColumnDef>, null } column_metadata;
|
|
}
|
|
|
|
/* describes a keyspace. */
|
|
/* NB: Until AVRO-495: must be kept sync'd with src/avro/internode.genavro. */
|
|
record KsDef {
|
|
string name;
|
|
string strategy_class;
|
|
union{ map<string>, null } strategy_options;
|
|
int replication_factor;
|
|
array<CfDef> cf_defs;
|
|
}
|
|
|
|
record StreamingMutation {
|
|
bytes key;
|
|
Mutation mutation;
|
|
}
|
|
|
|
record MutationsMapEntry {
|
|
bytes key;
|
|
map<array<Mutation>> mutations;
|
|
}
|
|
|
|
record CoscsMapEntry {
|
|
bytes key;
|
|
array<ColumnOrSuperColumn> columns;
|
|
}
|
|
|
|
record KeyCountMapEntry {
|
|
bytes key;
|
|
int count;
|
|
}
|
|
|
|
record AuthenticationRequest {
|
|
map<string> credentials;
|
|
}
|
|
|
|
enum ConsistencyLevel {
|
|
ZERO, ONE, QUORUM, DCQUORUM, DCQUORUMSYNC, ALL
|
|
}
|
|
|
|
error InvalidRequestException {
|
|
union { string, null } why;
|
|
}
|
|
|
|
error NotFoundException {
|
|
union { string, null } why;
|
|
}
|
|
|
|
error UnavailableException {
|
|
union { string, null } why;
|
|
}
|
|
|
|
error TimedOutException {
|
|
union { string, null } why;
|
|
}
|
|
|
|
error AuthenticationException {
|
|
union { string, null } why;
|
|
}
|
|
|
|
error AuthorizationException {
|
|
union { string, null } why;
|
|
}
|
|
|
|
void login (AuthenticationRequest auth_request)
|
|
throws AuthenticationException, AuthorizationException;
|
|
|
|
void set_keyspace(string keyspace) throws InvalidRequestException;
|
|
|
|
ColumnOrSuperColumn get(bytes key,
|
|
ColumnPath column_path,
|
|
ConsistencyLevel consistency_level)
|
|
throws InvalidRequestException, NotFoundException, UnavailableException,
|
|
TimedOutException;
|
|
|
|
/**
|
|
* Get the group of columns contained by a column_parent (either a
|
|
* ColumnFamily name or a ColumnFamily/SuperColumn name pair) specified
|
|
* by the given SlicePredicate. If no matching values are found, an empty
|
|
* list is returned.
|
|
*/
|
|
array<ColumnOrSuperColumn> get_slice(bytes key,
|
|
ColumnParent column_parent,
|
|
SlicePredicate predicate,
|
|
ConsistencyLevel consistency_level)
|
|
throws InvalidRequestException, UnavailableException, TimedOutException;
|
|
|
|
/**
|
|
* Performs a get_slice for column_parent and predicate against the given
|
|
* set of keys in parallel.
|
|
*/
|
|
array<CoscsMapEntry> multiget_slice(array<bytes> keys,
|
|
ColumnParent column_parent,
|
|
SlicePredicate predicate,
|
|
ConsistencyLevel consistency_level)
|
|
throws InvalidRequestException, UnavailableException, TimedOutException;
|
|
|
|
/**
|
|
* Performs a get_count in parallel on the given list of keys. The
|
|
* return value maps keys to the count found.
|
|
*/
|
|
array<KeyCountMapEntry> multiget_count(array<bytes> keys,
|
|
ColumnParent column_parent,
|
|
SlicePredicate predicate,
|
|
ConsistencyLevel consistency_level)
|
|
throws InvalidRequestException, UnavailableException, TimedOutException;
|
|
|
|
/**
|
|
* Returns the subset of columns specified in SlicePredicate for
|
|
* the rows matching the IndexClause.
|
|
*/
|
|
array<KeySlice> get_indexed_slices(ColumnParent column_parent,
|
|
IndexClause index_clause,
|
|
SlicePredicate column_predicate,
|
|
ConsistencyLevel consistency_level)
|
|
throws InvalidRequestException, UnavailableException, TimedOutException;
|
|
|
|
/**
|
|
* Returns the number of columns matching a predicate for a particular
|
|
* key, ColumnFamily, and optionally SuperColumn.
|
|
*/
|
|
int get_count(bytes key,
|
|
ColumnParent column_parent,
|
|
SlicePredicate predicate,
|
|
ConsistencyLevel consistency_level)
|
|
throws InvalidRequestException, UnavailableException, TimedOutException;
|
|
|
|
void insert(bytes key,
|
|
ColumnParent column_parent,
|
|
Column column,
|
|
ConsistencyLevel consistency_level)
|
|
throws InvalidRequestException, UnavailableException, TimedOutException;
|
|
|
|
void remove(bytes key,
|
|
ColumnPath column_path,
|
|
Clock clock,
|
|
ConsistencyLevel consistency_level)
|
|
throws InvalidRequestException, UnavailableException, TimedOutException;
|
|
|
|
void batch_mutate(array<MutationsMapEntry> mutation_map,
|
|
ConsistencyLevel consistency_level)
|
|
throws InvalidRequestException, UnavailableException, TimedOutException;
|
|
|
|
/**
|
|
* Truncate will mark and entire column family as deleted. From the user's
|
|
* perspective a successful call to truncate will result in complete data
|
|
* deletion from column family. Internally, however, disk space will not be
|
|
* immediately released, as with all deletes in Cassandra, this one only
|
|
* marks the data as deleted. The operation succeeds only if all hosts in
|
|
* the cluster at available and will throw an UnavailableException if some
|
|
* hosts are down.
|
|
*/
|
|
void truncate(string column_family)
|
|
throws InvalidRequestException, UnavailableException;
|
|
|
|
/**
|
|
* Ask the cluster if they all are using the same migration id. Returns a
|
|
* map of version->hosts-on-that-version. Hosts that did not respond will
|
|
* be under the key DatabaseDescriptor.INITIAL_VERSION. Agreement can be
|
|
* determined by checking if the size of the map is 1.
|
|
*/
|
|
map<array<string>> check_schema_agreement()
|
|
throws InvalidRequestException;
|
|
|
|
string system_add_column_family(CfDef cf_def)
|
|
throws InvalidRequestException;
|
|
|
|
string system_add_keyspace(KsDef ks_def) throws InvalidRequestException;
|
|
|
|
string system_rename_column_family(string old_name, string new_name)
|
|
throws InvalidRequestException;
|
|
|
|
string system_drop_column_family(string column_family)
|
|
throws InvalidRequestException;
|
|
|
|
string system_drop_keyspace(string keyspace)
|
|
throws InvalidRequestException;
|
|
|
|
string system_rename_keyspace(string old_name, string new_name)
|
|
throws InvalidRequestException;
|
|
|
|
string system_update_column_family(CfDef cf_def)
|
|
throws InvalidRequestException;
|
|
|
|
string system_update_keyspace(KsDef ks_def)
|
|
throws InvalidRequestException;
|
|
|
|
array<string> describe_keyspaces();
|
|
|
|
KsDef describe_keyspace(string keyspace) throws NotFoundException;
|
|
|
|
string describe_cluster_name();
|
|
|
|
string describe_version();
|
|
|
|
string describe_partitioner();
|
|
|
|
/**
|
|
* experimental API for hadoop/parallel query support.
|
|
* may change violently and without warning.
|
|
*
|
|
* returns list of token strings such that first subrange is (list[0], list[1]],
|
|
* next is (list[1], list[2]], etc.
|
|
*/
|
|
array<string> describe_splits(string cfName,
|
|
string start_token,
|
|
string end_token,
|
|
int keys_per_split);
|
|
|
|
/**
|
|
* Get the token ring: a map of ranges to host addresses, represented as
|
|
* an array of TokenRange->start-end range and list of host addresses.
|
|
*/
|
|
array<TokenRange> describe_ring(string keyspace)
|
|
throws InvalidRequestException;
|
|
|
|
/**
|
|
*returns a subset of columns for a contiguous range of keys.
|
|
*/
|
|
array<KeySlice> get_range_slices(ColumnParent column_parent,
|
|
SlicePredicate predicate,
|
|
KeyRange range,
|
|
ConsistencyLevel consistency_level)
|
|
throws InvalidRequestException, UnavailableException, TimedOutException;
|
|
}
|