You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cassandra.apache.org by al...@apache.org on 2012/12/10 16:06:13 UTC
[2/2] git commit: cqlsh: make it possible to describe thrift CFs;
patch by Aleksey Yeschenko, reviewed by Jonathan Ellis for
CASSANDRA-4827
cqlsh: make it possible to describe thrift CFs;
patch by Aleksey Yeschenko, reviewed by Jonathan Ellis for CASSANDRA-4827
Project: http://git-wip-us.apache.org/repos/asf/cassandra/repo
Commit: http://git-wip-us.apache.org/repos/asf/cassandra/commit/9210d577
Tree: http://git-wip-us.apache.org/repos/asf/cassandra/tree/9210d577
Diff: http://git-wip-us.apache.org/repos/asf/cassandra/diff/9210d577
Branch: refs/heads/cassandra-1.2
Commit: 9210d5776c26ca7f64ff896100890eb640ed2fe1
Parents: cb45b41
Author: Aleksey Yeschenko <al...@apache.org>
Authored: Mon Dec 10 18:01:32 2012 +0300
Committer: Aleksey Yeschenko <al...@apache.org>
Committed: Mon Dec 10 18:04:10 2012 +0300
----------------------------------------------------------------------
CHANGES.txt | 1 +
pylib/cqlshlib/cql3handling.py | 93 +++++++++++++++++++++-------------
2 files changed, 58 insertions(+), 36 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/cassandra/blob/9210d577/CHANGES.txt
----------------------------------------------------------------------
diff --git a/CHANGES.txt b/CHANGES.txt
index b92984d..301afd2 100644
--- a/CHANGES.txt
+++ b/CHANGES.txt
@@ -11,6 +11,7 @@ Merged from 1.1
* reduce log spam from invalid counter shards (CASSANDRA-5026)
* Improve schema propagation performance (CASSANDRA-5025)
* Fix for IndexHelper.IndexFor throws OOB Exception (CASSANDRA-5030)
+ * cqlsh: make it possible to describe thrift CFs (CASSANDRA-4827)
1.2-beta3
http://git-wip-us.apache.org/repos/asf/cassandra/blob/9210d577/pylib/cqlshlib/cql3handling.py
----------------------------------------------------------------------
diff --git a/pylib/cqlshlib/cql3handling.py b/pylib/cqlshlib/cql3handling.py
index 3c24114..0089f12 100644
--- a/pylib/cqlshlib/cql3handling.py
+++ b/pylib/cqlshlib/cql3handling.py
@@ -1403,7 +1403,7 @@ class CqlTableDef:
colname_type = UTF8Type
column_class = CqlColumnDef
- """True if this CF has compact storage"""
+ """True if this CF has compact storage (isn't a CQL3 table)"""
compact_storage = False
"""Names of all columns which are part of the primary key, whether or not
@@ -1446,48 +1446,75 @@ class CqlTableDef:
setattr(cf, attr, json.loads(getattr(cf, attr)))
except AttributeError:
pass
- if not cf.key_aliases:
- if cf.key_alias:
- cf.key_aliases = [cf.key_alias.decode('ascii')]
- else:
- cf.key_aliases = [u'key']
- cf.partition_key_components = cf.key_aliases
- cf.primary_key_components = cf.key_aliases + list(cf.column_aliases)
cf.partition_key_validator = lookup_casstype(cf.key_validator)
- cf.default_validator = lookup_casstype(cf.default_validator)
cf.comparator = lookup_casstype(cf.comparator)
+ cf.default_validator = lookup_casstype(cf.default_validator)
cf.coldefs = coldefs
- cf.parse_types()
+ cf.compact_storage = cf.is_compact_storage()
+ cf.key_aliases = cf.get_key_aliases()
+ cf.partition_key_components = cf.key_aliases
+ cf.column_aliases = cf.get_column_aliases()
+ cf.primary_key_components = cf.key_aliases + list(cf.column_aliases)
+ cf.columns = cf.get_columns()
return cf
+ # not perfect, but good enough; please read CFDefinition constructor comments
+ # returns False if we are dealing with a CQL3 table, True otherwise.
+ # 'compact' here means 'needs WITH COMPACT STORAGE option for CREATE TABLE in CQL3'.
def is_compact_storage(self):
if not issubclass(self.comparator, CompositeType):
return True
for subtype in self.comparator.subtypes:
if issubclass(subtype, ColumnToCollectionType):
return False
- return bool(len(self.comparator.subtypes) == len(self.column_aliases))
+ if len(self.column_aliases) == len(self.comparator.subtypes) - 1:
+ if self.comparator.subtypes[-1] is UTF8Type:
+ return False
+ return True
- def parse_types(self):
- self.compact_storage = self.is_compact_storage()
+ def get_key_aliases(self):
+ if not issubclass(self.partition_key_validator, CompositeType):
+ return self.key_aliases or [u'key']
+ expected = len(self.partition_key_validator.subtypes)
+ # key, key2, key3, ..., keyN
+ aliases = [u'key'] + [ u'key' + str(i) for i in range(2, expected + 1) ]
+ # append the missing (non-renamed) aliases (if any)
+ return self.key_aliases + aliases[len(self.key_aliases):]
+
+ def get_column_aliases(self):
+ # CQL3 table
+ if not self.compact_storage:
+ return self.column_aliases
+ if not issubclass(self.comparator, CompositeType):
+ # static cf
+ if self.coldefs:
+ return []
+ else:
+ return self.column_aliases or [u'column1']
+ expected = len(self.comparator.subtypes)
+ # column1, column2, column3, ..., columnN
+ aliases = [ u'column' + str(i) for i in range(1, expected + 1) ]
+ # append the missing (non-renamed) aliases (if any)
+ return self.column_aliases + aliases[len(self.column_aliases):]
+
+ def get_columns(self):
if self.compact_storage:
- self.columns = self.parse_types_compact()
+ return self.get_columns_compact()
else:
- self.columns = self.parse_types_dynamic()
+ return self.get_columns_cql3()
- def parse_types_compact(self):
+ # dense composite or dynamic cf or static cf (technically not compact).
+ def get_columns_compact(self):
if issubclass(self.partition_key_validator, CompositeType):
partkey_types = self.partition_key_validator.subtypes
else:
partkey_types = [self.partition_key_validator]
- if len(partkey_types) != len(self.key_aliases):
- warn(UnexpectedTableStructure("Compact storage CF key-validator-types %r is not"
- " the same length as its key_aliases %r"
- % (partkey_types, self.key_aliases)))
+ partkey_cols = map(self.column_class, self.partition_key_components, partkey_types)
+
if len(self.column_aliases) == 0:
if self.comparator is not UTF8Type:
warn(UnexpectedTableStructure("Compact storage CF %s has no column aliases,"
- " but comparator is not UTF8Type."))
+ " but comparator is not UTF8Type." % (self,)))
colalias_types = []
elif issubclass(self.comparator, CompositeType):
colalias_types = self.comparator.subtypes
@@ -1497,8 +1524,6 @@ class CqlTableDef:
warn(UnexpectedTableStructure("Compact storage CF comparator-types %r is not"
" the same length as its column_aliases %r"
% (colalias_types, self.column_aliases)))
-
- partkey_cols = map(self.column_class, self.partition_key_components, partkey_types)
colalias_cols = map(self.column_class, self.column_aliases, colalias_types)
if self.value_alias is not None:
@@ -1510,24 +1535,22 @@ class CqlTableDef:
value_cols = []
else:
value_cols = [self.column_class(self.value_alias, self.default_validator)]
+ elif self.value_alias is None and not self.coldefs:
+ value_cols = [self.column_class("value", self.default_validator)]
else:
value_cols = map(self.column_class.from_layout, self.coldefs)
value_cols.sort(key=lambda c: c.name)
return partkey_cols + colalias_cols + value_cols
- def parse_types_dynamic(self):
- if not issubclass(self.comparator, CompositeType):
- warn(UnexpectedTableStructure("Dynamic storage CF comparator is %r, not"
- " composite" % (self.comparator,)))
+ # sparse composite (CQL3 table).
+ def get_columns_cql3(self):
if issubclass(self.partition_key_validator, CompositeType):
partkey_types = self.partition_key_validator.subtypes
else:
partkey_types = [self.partition_key_validator]
- if len(partkey_types) != len(self.key_aliases):
- warn(UnexpectedTableStructure("Dynamic storage CF key-validator-types %r "
- "is not the same length as its key_aliases %r"
- % (partkey_types, self.key_aliases)))
+ partkey_cols = map(self.column_class, self.partition_key_components, partkey_types)
+
for subtype in self.comparator.subtypes[:-1]:
if issubclass(subtype, ColumnToCollectionType):
warn(UnexpectedTableStructure("ColumnToCollectionType found, but not in "
@@ -1537,14 +1560,12 @@ class CqlTableDef:
# all this information should be available in schema_columns
coltypes.pop(-1)
if len(coltypes) != len(self.column_aliases) + 1 or coltypes[-1] is not UTF8Type:
- warn(UnexpectedTableStructure("Dynamic storage CF does not have UTF8Type"
+ warn(UnexpectedTableStructure("CQL3 CF does not have UTF8Type"
" added to comparator"))
- colalias_types = coltypes[:-1]
- partkey_cols = map(self.column_class, self.partition_key_components, partkey_types)
- colalias_cols = map(self.column_class, self.column_aliases, colalias_types)
+ colalias_cols = map(self.column_class, self.column_aliases, coltypes[:-1])
if self.value_alias is not None:
- warn(UnexpectedTableStructure("Dynamic storage CF has a value_alias (%r)"
+ warn(UnexpectedTableStructure("CQL3 CF has a value_alias (%r)"
% (self.value_alias,)))
value_cols = map(self.column_class.from_layout, self.coldefs)
value_cols.sort(key=lambda c: c.name)