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 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 _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 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(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)