cassandra-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From alek...@apache.org
Subject git commit: cqlsh: make it possible to describe thrift CFs; patch by Aleksey Yeschenko, reviewed by Jonathan Ellis for CASSANDRA-4827
Date Mon, 10 Dec 2012 15:05:02 GMT
Updated Branches:
  refs/heads/cassandra-1.2.0 cb45b4149 -> 9210d5776


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.0
Commit: 9210d5776c26ca7f64ff896100890eb640ed2fe1
Parents: cb45b41
Author: Aleksey Yeschenko <aleksey@apache.org>
Authored: Mon Dec 10 18:01:32 2012 +0300
Committer: Aleksey Yeschenko <aleksey@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)


Mime
View raw message