Python ColumnFamily.remove方法代码示例

# 需要导入模块: from pycassa.columnfamily import ColumnFamily [as 别名]
# 或者: from pycassa.columnfamily.ColumnFamily import remove [as 别名]
class TestBigInt(unittest.TestCase):

    @classmethod
    def setup_class(cls):
        sys = SystemManager()
        sys.create_column_family(TEST_KS, 'StdInteger', comparator_type=IntegerType())

    @classmethod
    def teardown_class(cls):
        sys = SystemManager()
        sys.drop_column_family(TEST_KS, 'StdInteger')

    def setUp(self):
        self.key = 'TestBigInt'
        self.cf = ColumnFamily(pool, 'StdInteger')

    def tearDown(self):
        self.cf.remove(self.key)

    def test_negative_integers(self):
        self.cf.insert(self.key, {-1: '-1'})
        self.cf.insert(self.key, {-12342390: '-12342390'})
        self.cf.insert(self.key, {-255: '-255'})
        self.cf.insert(self.key, {-256: '-256'})
        self.cf.insert(self.key, {-257: '-257'})
        for key, cols in self.cf.get_range():
            self.assertEquals(str(cols.keys()[0]), cols.values()[0])

# 需要导入模块: from pycassa.columnfamily import ColumnFamily [as 别名]
# 或者: from pycassa.columnfamily.ColumnFamily import remove [as 别名]
def remove_column(columnFamily, uid, columns) :
	"To remove columns from a key"
	try:
		column = ColumnFamily(pool, columnFamily)
		column.remove(uid,columns)
	except:
		return {'status':0}

# 需要导入模块: from pycassa.columnfamily import ColumnFamily [as 别名]
# 或者: from pycassa.columnfamily.ColumnFamily import remove [as 别名]
	def column_family_remove(self,machine_id,keyspace_name,column_family_name,key):
		"""Remove a key from column family for a given keyspace """
		if (self.keyspace_contains(keyspace_name,column_family_name) == False):
			print "Error : Keyspace:column family could not be found."
			return False
		pool = ConnectionPool(keyspace = keyspace_name, server_list =  keyspace.server_ips, prefill=False)
		col_fam = ColumnFamily(pool, column_family_name)
		col_fam.remove(key)
		return True

# 需要导入模块: from pycassa.columnfamily import ColumnFamily [as 别名]
# 或者: from pycassa.columnfamily.ColumnFamily import remove [as 别名]
    def truncate_build_metadata(self):
        """Truncates all derived build metadata.

        This bulk removes all build metadata and should not be performed
        unless you want to reload all derived data!
        """
        for cf in ['slaves', 'masters', 'builders', 'builds']:
            cf = ColumnFamily(self.pool, cf)
            cf.truncate()

        cf = ColumnFamily(self.pool, 'indices')
        for key in BUILD_METADATA_INDICES:
            cf.remove(key)

        cf = ColumnFamily(self.pool, 'simple_indices')
        for key in BUILD_METADATA_SIMPLE_INDICES:
            cf.remove(key)

        cf = ColumnFamily(self.pool, 'counters')
        for key in BUILD_METADATA_COUNTERS:
            cf.remove(key)

        cf = ColumnFamily(self.pool, 'super_counters')
        for key in BUILD_METADATA_SUPER_COUNTERS:
            cf.remove(key)

# 需要导入模块: from pycassa.columnfamily import ColumnFamily [as 别名]
# 或者: from pycassa.columnfamily.ColumnFamily import remove [as 别名]
class TestTypeErrors(unittest.TestCase):
    def test_packing_enabled(self):
        self.cf = ColumnFamily(pool, "Standard1")
        self.cf.insert("key", {"col": "val"})
        assert_raises(TypeError, self.cf.insert, args=("key", {123: "val"}))
        assert_raises(TypeError, self.cf.insert, args=("key", {"col": 123}))
        assert_raises(TypeError, self.cf.insert, args=("key", {123: 123}))
        self.cf.remove("key")

    def test_packing_disabled(self):
        self.cf = ColumnFamily(pool, "Standard1", autopack_names=False, autopack_values=False)
        self.cf.insert("key", {"col": "val"})
        assert_raises(TypeError, self.cf.insert, args=("key", {123: "val"}))
        assert_raises(TypeError, self.cf.insert, args=("key", {"col": 123}))
        assert_raises(TypeError, self.cf.insert, args=("key", {123: 123}))
        self.cf.remove("key")

# 需要导入模块: from pycassa.columnfamily import ColumnFamily [as 别名]
# 或者: from pycassa.columnfamily.ColumnFamily import remove [as 别名]
    def remove(self, instance, columns=None, write_consistency_level=None):
        """
        Removes a stored instance.

        The `columns` parameter is a list of columns that should be removed.
        If this is left as the default value of ``None``, the entire stored
        instance will be removed.

        """
        if self.super:
            return ColumnFamily.remove(self, instance.key,
                                       super_column=instance.super_column,
                                       columns=columns,
                                       write_consistency_level=write_consistency_level)
        else:
            return ColumnFamily.remove(self, instance.key, columns,
                                       write_consistency_level=write_consistency_level)

# 需要导入模块: from pycassa.columnfamily import ColumnFamily [as 别名]
# 或者: from pycassa.columnfamily.ColumnFamily import remove [as 别名]
    def create_new_thread(self, thread_name):
        threads = ColumnFamily(self.conn, 'threads')

        ret = list(threads.get_range())
        if len(ret) > 99:
            oldest_thread = self._get_oldest_thread()
            oldest_thread_id = str(oldest_thread['thread_id'])
            threads.remove(oldest_thread_id)
            self._drop_cf(oldest_thread_id)

        thread_id = '%s' % random.randint(1,sys.maxint)

        dt = datetime.datetime.today()
        str_dt = dt.strftime('%Y-%m-%d %H:%M:%S')
        threads.insert(thread_id, {'thread_name': thread_name, 'post_count': '1', 'create_time': str_dt, 'update_time': str_dt})

        self._create_cf(thread_id)
        return thread_id

# 需要导入模块: from pycassa.columnfamily import ColumnFamily [as 别名]
# 或者: from pycassa.columnfamily.ColumnFamily import remove [as 别名]
    def test_validated_columns(self):
        sys = SystemManager()
        sys.create_column_family(TEST_KS, "Validators")
        sys.alter_column(TEST_KS, "Validators", "long", LongType())
        sys.alter_column(TEST_KS, "Validators", "int", IntegerType())
        sys.alter_column(TEST_KS, "Validators", "time", TimeUUIDType())
        sys.alter_column(TEST_KS, "Validators", "lex", LexicalUUIDType())
        sys.alter_column(TEST_KS, "Validators", "ascii", AsciiType())
        sys.alter_column(TEST_KS, "Validators", "utf8", UTF8Type())
        sys.alter_column(TEST_KS, "Validators", "bytes", BytesType())
        sys.close()

        cf = ColumnFamily(pool, "Validators")
        key = "key1"

        col = {"long": 1L}
        cf.insert(key, col)
        assert_equal(cf.get(key)["long"], 1L)

        col = {"int": 1}
        cf.insert(key, col)
        assert_equal(cf.get(key)["int"], 1)

        col = {"time": TIME1}
        cf.insert(key, col)
        assert_equal(cf.get(key)["time"], TIME1)

        col = {"lex": uuid.UUID(bytes="aaa aaa aaa aaaa")}
        cf.insert(key, col)
        assert_equal(cf.get(key)["lex"], uuid.UUID(bytes="aaa aaa aaa aaaa"))

        col = {"ascii": "aaa"}
        cf.insert(key, col)
        assert_equal(cf.get(key)["ascii"], "aaa")

        col = {"utf8": u"a\u0020"}
        cf.insert(key, col)
        assert_equal(cf.get(key)["utf8"], u"a\u0020")

        col = {"bytes": "aaa"}
        cf.insert(key, col)
        assert_equal(cf.get(key)["bytes"], "aaa")

        cf.remove(key)

# 需要导入模块: from pycassa.columnfamily import ColumnFamily [as 别名]
# 或者: from pycassa.columnfamily.ColumnFamily import remove [as 别名]
    def test_validated_columns(self):
        sys = SystemManager()
        sys.create_column_family(TEST_KS, 'Validators',)
        sys.alter_column(TEST_KS, 'Validators', 'long', LONG_TYPE)
        sys.alter_column(TEST_KS, 'Validators', 'int', INT_TYPE)
        sys.alter_column(TEST_KS, 'Validators', 'time', TIME_UUID_TYPE)
        sys.alter_column(TEST_KS, 'Validators', 'lex', LEXICAL_UUID_TYPE)
        sys.alter_column(TEST_KS, 'Validators', 'ascii', ASCII_TYPE)
        sys.alter_column(TEST_KS, 'Validators', 'utf8', UTF8_TYPE)
        sys.alter_column(TEST_KS, 'Validators', 'bytes', BYTES_TYPE)
        sys.close()

        cf = ColumnFamily(pool, 'Validators')
        key = 'key1'

        col = {'long':1L}
        cf.insert(key, col)
        assert_equal(cf.get(key)['long'], 1L)

        col = {'int':1}
        cf.insert(key, col)
        assert_equal(cf.get(key)['int'], 1)

        col = {'time':TIME1}
        cf.insert(key, col)
        assert_equal(cf.get(key)['time'], TIME1)

        col = {'lex':uuid.UUID(bytes='aaa aaa aaa aaaa')}
        cf.insert(key, col)
        assert_equal(cf.get(key)['lex'], uuid.UUID(bytes='aaa aaa aaa aaaa'))

        col = {'ascii':'aaa'}
        cf.insert(key, col)
        assert_equal(cf.get(key)['ascii'], 'aaa')

        col = {'utf8':u'a\u0020'}
        cf.insert(key, col)
        assert_equal(cf.get(key)['utf8'], u'a\u0020')

        col = {'bytes':'aaa'}
        cf.insert(key, col)
        assert_equal(cf.get(key)['bytes'], 'aaa')

        cf.remove(key)

# 需要导入模块: from pycassa.columnfamily import ColumnFamily [as 别名]
# 或者: from pycassa.columnfamily.ColumnFamily import remove [as 别名]
    def test_validated_columns(self):
        sys = SystemManager()
        sys.create_column_family(TEST_KS, 'Validators',)
        sys.alter_column(TEST_KS, 'Validators', 'long', LongType())
        sys.alter_column(TEST_KS, 'Validators', 'int', IntegerType())
        sys.alter_column(TEST_KS, 'Validators', 'time', TimeUUIDType())
        sys.alter_column(TEST_KS, 'Validators', 'lex', LexicalUUIDType())
        sys.alter_column(TEST_KS, 'Validators', 'ascii', AsciiType())
        sys.alter_column(TEST_KS, 'Validators', 'utf8', UTF8Type())
        sys.alter_column(TEST_KS, 'Validators', 'bytes', BytesType())
        sys.close()

        cf = ColumnFamily(pool, 'Validators')
        key = 'key1'

        col = {'long':1L}
        cf.insert(key, col)
        assert_equal(cf.get(key)['long'], 1L)

        col = {'int':1}
        cf.insert(key, col)
        assert_equal(cf.get(key)['int'], 1)

        col = {'time':TIME1}
        cf.insert(key, col)
        assert_equal(cf.get(key)['time'], TIME1)

        col = {'lex':uuid.UUID(bytes='aaa aaa aaa aaaa')}
        cf.insert(key, col)
        assert_equal(cf.get(key)['lex'], uuid.UUID(bytes='aaa aaa aaa aaaa'))

        col = {'ascii':'aaa'}
        cf.insert(key, col)
        assert_equal(cf.get(key)['ascii'], 'aaa')

        col = {'utf8':u'a\u0020'}
        cf.insert(key, col)
        assert_equal(cf.get(key)['utf8'], u'a\u0020')

        col = {'bytes':'aaa'}
        cf.insert(key, col)
        assert_equal(cf.get(key)['bytes'], 'aaa')

        cf.remove(key)

# 需要导入模块: from pycassa.columnfamily import ColumnFamily [as 别名]
# 或者: from pycassa.columnfamily.ColumnFamily import remove [as 别名]
    def truncate_log_metadata(self):
        for cf in ['build_timelines']:
            cf = ColumnFamily(self.pool, cf)
            cf.truncate()

        cf = ColumnFamily(self.pool, 'indices')
        for key in LOG_METADATA_INDICES:
            cf.remove(key)

        cf = ColumnFamily(self.pool, 'counters')
        for key in LOG_METADATA_COUNTERS:
            cf.remove(key)

        cf = ColumnFamily(self.pool, 'super_counters')
        for key in LOG_METADATA_SUPER_COUNTERS:
            cf.remove(key)

        cf = ColumnFamily(self.pool, 'builds')
        batch = cf.batch()
        # Remove log parsing state from builds.
        for key, cols in cf.get_range(columns=['log_parsing_version']):
            if 'log_parsing_version' not in cols:
                continue

            batch.remove(key, ['log_parsing_version'])

        batch.send()

# 需要导入模块: from pycassa.columnfamily import ColumnFamily [as 别名]
# 或者: from pycassa.columnfamily.ColumnFamily import remove [as 别名]
 def column_family_remove(self, keyspace_name, column_family_name, key):
     """Remove a key from column family for a given keyspace """
     keyspace.error = "Unknown error occur please check your inputs"
     if not self.keyspace_contains(keyspace.local_system, keyspace_name, column_family_name):
         keyspace.error = "Desired Keyspace,Column Family pair could not be found."
         return False
     try:
         pool = ConnectionPool(keyspace=keyspace_name, server_list=keyspace.server_ips, prefill=False)
     except Exception as e:
         print e
         return False
     try:
         col_fam = ColumnFamily(pool, column_family_name)
     except Exception as e:
         print e
         return False
     try:
         col_fam.remove(key)
     except Exception as e:
         print e
         return False
     return True

# 需要导入模块: from pycassa.columnfamily import ColumnFamily [as 别名]
# 或者: from pycassa.columnfamily.ColumnFamily import remove [as 别名]
class TestDateTypes(unittest.TestCase):
    def _compare_dates(self, d1, d2):
        self.assertEquals(d1.timetuple(), d2.timetuple())
        self.assertEquals(int(d1.microsecond / 1e3), int(d2.microsecond / 1e3))

    def test_compatibility(self):
        self.cf = ColumnFamily(pool, "Standard1")
        self.cf.column_validators["date"] = OldPycassaDateType()

        d = datetime.utcnow()
        self.cf.insert("key1", {"date": d})
        self._compare_dates(self.cf.get("key1")["date"], d)

        self.cf.column_validators["date"] = IntermediateDateType()
        self._compare_dates(self.cf.get("key1")["date"], d)
        self.cf.insert("key1", {"date": d})
        self._compare_dates(self.cf.get("key1")["date"], d)

        self.cf.column_validators["date"] = DateType()
        self._compare_dates(self.cf.get("key1")["date"], d)
        self.cf.insert("key1", {"date": d})
        self._compare_dates(self.cf.get("key1")["date"], d)
        self.cf.remove("key1")

# 需要导入模块: from pycassa.columnfamily import ColumnFamily [as 别名]
# 或者: from pycassa.columnfamily.ColumnFamily import remove [as 别名]
def Remove(pool, columnFamily, key, val,*args, **kwargs):
    col_fam = ColumnFamily(pool, columnFamily)
    d = col_fam.remove(key, columns=val,*args, **kwargs)

# 需要导入模块: from pycassa.columnfamily import ColumnFamily [as 别名]
# 或者: from pycassa.columnfamily.ColumnFamily import remove [as 别名]
def remove_row(columnFamily, uid) :
	"To remove row from a column family"
	column = ColumnFamily(pool, columnFamily)
	column.remove(uid)