def set(key, name, value, timestamp=None, consistency=None):
"""Set a column's value."""
timestamp = timestamp or timestamp()
consistency = consistency or cas_types.ConsistencyLevel.ONE
get_pool(key.keyspace).insert(
key.key, key.get_path(column=name), value, timestamp,
consistency)
def remove(key, column, timestamp=None, consistency=None):
"""Remove a column."""
timestamp = timestamp or timestamp()
consistency = consistency or cas_types.ConsistencyLevel.ONE
get_pool(key.keyspace).remove(key.key,
key.get_path(column=column), timestamp,
consistency)
def test_get_pool(self):
client = conn.get_pool(self.pool)
self.assert_(type(client) is conn.Client)
# Again, to cover the short-circuit conditional
client = conn.get_pool(self.pool)
self.assert_(type(client) is conn.Client)
self.assertRaises(TypeError, conn.Client)
self.assertRaises(ErrorCassandraClientNotFound, conn.get_pool, (__name__))
def test_get_pool(self):
client = conn.get_pool(self.pool)
self.assert_(type(client) is conn.Client)
# Again, to cover the short-circuit conditional
client = conn.get_pool(self.pool)
self.assert_(type(client) is conn.Client)
self.assertRaises(TypeError, conn.Client)
self.assertRaises(ErrorCassandraClientNotFound, conn.get_pool,
(__name__))
def sparse_get(key, columns):
"""Return an iterator over a specific set of columns."""
client = get_pool(key.keyspace)
res = client.get_slice(key.key, key, SlicePredicate(column_names=columns), ConsistencyLevel.ONE)
return unpack(res)
def get_count(key, consistency=None):
""" Get the column count for a key """
consistency = consistency or cas_types.ConsistencyLevel.ONE
count = get_pool(key.keyspace).get_count(
key.keyspace, key.key, key.get_path(), consistency
)
return count
def get_column(key, column_name, consistency=None):
"""Get a column."""
consistency = consistency or cas_types.ConsistencyLevel.ONE
return unpack([
get_pool(key.keyspace).get(key.key, key.get_path(column=column_name),
consistency)
]).next()
def get_column(key, column_name, consistency=None):
"""Get a column."""
consistency = consistency or cas_types.ConsistencyLevel.ONE
return unpack(
[get_pool(key.keyspace).get(
key.key,
key.get_path(column=column_name), consistency)]).next()
def test_get_pool(self):
client = conn.get_pool(self.pool)
self.assert_(type(client) is conn.Client)
self.assertRaises(TypeError, conn.Client)
self.assertRaises(ErrorCassandraClientNotFound,
conn.get_pool, (__name__))
def sparse_get(key, columns):
"""Return an iterator over a specific set of columns."""
client = get_pool(key.keyspace)
res = client.get_slice(key.key, key, SlicePredicate(column_names=columns),
ConsistencyLevel.ONE)
return unpack(res)
def _get_cas(self, keyspace=None):
"""Return the cassandra client."""
if not keyspace and (not hasattr(self, 'key') or not self.key):
raise ErrorIncompleteKey("Instance has no key.")
keyspace = keyspace or self.key.keyspace
if keyspace not in self._clients:
self._clients[keyspace] = connection.get_pool(keyspace)
return self._clients[keyspace]
def _get_cas(self, keyspace=None):
"""Return the cassandra client."""
if not keyspace and (not hasattr(self, 'key') or not self.key):
raise ErrorIncompleteKey("Instance has no key.")
keyspace = keyspace or self.key.keyspace
if keyspace not in self._clients:
self._clients[keyspace] = connection.get_pool(keyspace)
return self._clients[keyspace]
def _get_cas(self, table=None):
"""Return the cassandra client."""
if not table and (not hasattr(self, 'pk') or \
not hasattr(self.pk, 'table')):
raise ErrorUnknownTable()
table = table or self.pk.table
if table not in self._clients:
self._clients[table] = connection.get_pool(table)
return self._clients[table]
def sparse_multiget(keys, columns):
"""Return an iterator over a specific set of columns."""
first_key = iter(keys).next()
client = get_pool(first_key.keyspace)
row_keys = [key.key for key in keys]
res = client.multiget_slice(row_keys, first_key, SlicePredicate(column_names=columns), ConsistencyLevel.ONE)
out = {}
for (row_key, cols) in res.iteritems():
out[row_key] = [corsc.column or corsc.super_column for corsc in cols]
return out
def sparse_multiget(keys, columns):
"""Return an iterator over a specific set of columns."""
first_key = iter(keys).next()
client = get_pool(first_key.keyspace)
row_keys = [key.key for key in keys]
res = client.multiget_slice(row_keys, first_key,
SlicePredicate(column_names=columns),
ConsistencyLevel.ONE)
out = {}
for (row_key, cols) in res.iteritems():
out[row_key] = [corsc.column or corsc.super_column for corsc in cols]
return out
def slice_iterator(key, consistency, **range_args):
"""Return an iterator over a row."""
kwargs = {'start': "", 'finish': "",
'count': 100000, 'reversed': 0}
kwargs.update(range_args)
consistency = consistency or ConsistencyLevel.ONE
client = get_pool(key.keyspace)
res = client.get_slice(
key.keyspace, key.key, key,
SlicePredicate(slice_range=SliceRange(**kwargs)),
consistency)
if not res:
raise exc.ErrorNoSuchRecord("No record matching key %s" % key)
return unpack(res)
def slice_iterator(key, consistency, **predicate_args):
"""Return an iterator over a row."""
predicate = SlicePredicate()
if 'columns' in predicate_args:
predicate.column_names = predicate_args['columns']
else:
args = {'start': "", 'finish': "", 'count': 100000, 'reversed': False}
args.update(predicate_args)
predicate.slice_range = SliceRange(**args)
consistency = consistency or ConsistencyLevel.ONE
client = get_pool(key.keyspace)
res = client.get_slice(key.key, key, predicate, consistency)
if not res:
raise exc.ErrorNoSuchRecord("No record matching key %s" % key)
return unpack(res)
def slice_iterator(key, consistency, **predicate_args):
"""Return an iterator over a row."""
predicate = SlicePredicate()
if "columns" in predicate_args:
predicate.column_names = predicate_args["columns"]
else:
args = {"start": "", "finish": "", "count": 100000, "reversed": False}
args.update(predicate_args)
predicate.slice_range = SliceRange(**args)
consistency = consistency or ConsistencyLevel.ONE
client = get_pool(key.keyspace)
res = client.get_slice(key.key, key, predicate, consistency)
if not res:
raise exc.ErrorNoSuchRecord("No record matching key %s" % key)
return unpack(res)
def multigetterator(keys, consistency, **range_args):
"""Return a dictionary of data from Cassandra.
This fetches data with the minumum number of network requests. It
DOES NOT preserve order.
If you depend on ordering, use list_multigetterator. This may
require more requests.
"""
kwargs = {'start': "", 'finish': "",
'count': 100000, 'reversed': False}
kwargs.update(range_args)
predicate = SlicePredicate(slice_range=SliceRange(**kwargs))
consistency = consistency or ConsistencyLevel.ONE
out = {}
for (keyspace, ks_keys) in groupsort(keys, GET_KEYSPACE):
client = get_pool(keyspace)
out[keyspace] = {}
for (colfam, cf_keys) in groupsort(ks_keys, GET_COLFAM):
if colfam not in keyspace:
out[keyspace][colfam] = defaultdict(dict)
for (supercol, sc_keys) in groupsort(cf_keys, GET_SUPERCOL):
records = client.multiget_slice(
keyspace, map(GET_KEY, sc_keys),
ColumnParent(colfam, supercol), predicate, consistency)
for (row_key, cols) in records.iteritems():
cols = unpack(cols)
if supercol is None:
out[keyspace][colfam][row_key] = cols
else:
out[keyspace][colfam][row_key][supercol] = cols
return out
def multigetterator(keys, consistency, **range_args):
"""Return a dictionary of data from Cassandra.
This fetches data with the minumum number of network requests. It
DOES NOT preserve order.
If you depend on ordering, use list_multigetterator. This may
require more requests.
"""
kwargs = {'start': "", 'finish': "", 'count': 100000, 'reversed': False}
kwargs.update(range_args)
predicate = SlicePredicate(slice_range=SliceRange(**kwargs))
consistency = consistency or ConsistencyLevel.ONE
out = {}
for (keyspace, ks_keys) in groupsort(keys, GET_KEYSPACE):
client = get_pool(keyspace)
out[keyspace] = {}
for (colfam, cf_keys) in groupsort(ks_keys, GET_COLFAM):
if colfam not in out[keyspace]:
out[keyspace][colfam] = defaultdict(dict)
for (supercol, sc_keys) in groupsort(cf_keys, GET_SUPERCOL):
records = client.multiget_slice(map(GET_KEY, sc_keys),
ColumnParent(colfam, supercol),
predicate, consistency)
for (row_key, cols) in records.iteritems():
cols = unpack(cols)
if supercol is None:
out[keyspace][colfam][row_key] = cols
else:
out[keyspace][colfam][row_key][supercol] = cols
return out
def key_range(key, start="", finish="", count=100):
"""Return an iterator over a range of keys."""
cas = get_pool(key.keyspace)
return cas.get_key_range(key.keyspace, key.column_family, start,
finish, count, ConsistencyLevel.ONE)
def remove_key(cls, key, consistency=None):
"""Remove a row based on a key."""
consistency = consistency or cls.consistency
get_pool(key.keyspace).remove(key.keyspace, key.key,
key.get_path(), cls.timestamp(),
consistency)
def test_add_pool(self):
servers = ['localhost:1234', 'localhost:5678']
conn.add_pool(__name__, servers)
self.failUnless(conn.get_pool(__name__))
def set(key, name, value, timestamp=None, consistency=None):
"""Set a column's value."""
timestamp = timestamp or timestamp()
consistency = consistency or cas_types.ConsistencyLevel.ONE
get_pool(key.keyspace).insert(key.key, key.get_path(column=name), value,
timestamp, consistency)
def remove(key, column, timestamp=None, consistency=None):
"""Remove a column."""
timestamp = timestamp or timestamp()
consistency = consistency or cas_types.ConsistencyLevel.ONE
get_pool(key.keyspace).remove(key.key, key.get_path(column=column),
timestamp, consistency)
def remove_key(cls, key, consistency=None):
"""Remove a row based on a key."""
consistency = consistency or cls.consistency
get_pool(key.keyspace).remove(key.key, key.get_path(), cls.timestamp(),
consistency)
def key_range(key, start="", finish="", count=100):
"""Return an iterator over a range of keys."""
cas = get_pool(key.keyspace)
return cas.get_key_range(key.column_family, start, finish, count,
ConsistencyLevel.ONE)
