Merge branch 'cassandra-2.1' into trunk

CHANGES.txt

@@ -18,6 +18,8 @@
 
 
 2.1.1
+ * (cqlsh) Order UDTs according to cross-type dependencies in DESCRIBE
+   output (CASSANDRA-7659)
  * (cqlsh) Fix handling of CAS statement results (CASSANDRA-7671)
  * (cqlsh) COPY TO/FROM improvements (CASSANDRA-7405)
  * Support list index operations with conditions (CASSANDRA-7499)

bin/cqlsh

@@ -652,16 +652,21 @@ class Shell(cmd.Cmd):
         if ksname is None:
             ksname = self.current_keyspace
 
-        return self.get_usertypes_meta().get_usertypes_names(ksname)
+        return self.get_keyspace_meta(ksname).user_types.keys()
 
     def get_usertype_layout(self, ksname, typename):
         if ksname is None:
             ksname = self.current_keyspace
-        layout = self.get_usertypes_meta().get_fields_with_types(ksname, typename)
 
-        if not layout:
+        ks_meta = self.get_keyspace_meta(ksname)
+
+        try:
+            user_type = ks_meta.user_types[typename]
+        except KeyError:
             raise UserTypeNotFound("User type %r not found" % typename)
-        return layout
+
+        return [(field_name, field_type.cql_parameterized_type())
+                for field_name, field_type in zip(user_type.field_names, user_type.field_types)]
 
     def get_cluster_name(self):
         return self.conn.metadata.cluster_name
@@ -1070,32 +1075,8 @@ class Shell(cmd.Cmd):
             return cqlruleset.dequote_value(valstr)
 
     def print_recreate_keyspace(self, ksdef, out):
-        ksname = protect_name(ksdef.name)
-        out.write(ksdef.as_cql_query())
-        out.write("\n\n")
-
-        uts = self.get_usertypes_meta().get_usertypes_names(ksdef.name)
-        if uts:
-            out.write("USE %s;\n" % ksname)
-            for ut in uts:
-                out.write('\n')
-                self.print_recreate_usertype(ksdef.name, ut, out)
-
-        cfs = self.get_columnfamily_names(ksdef.name)
-        if cfs:
-            for cf in cfs:
-                out.write('\n')
-                self.print_recreate_columnfamily(ksdef.name, cf, out)
-
-    def print_recreate_usertype(self, ksname, utname, out):
-        layout = self.get_usertype_layout(ksname, utname)
-        out.write("CREATE TYPE %s (\n" % utname)
-        for (index,(tname,ttype)) in enumerate(layout, 1):
-            out.write("  %s %s" % (tname, ttype))
-            if index < len(layout):
-                out.write(",\n")
-            else:
-                out.write("\n); \n")
+        out.write(ksdef.export_as_string())
+        out.write("\n")
 
     def print_recreate_columnfamily(self, ksname, cfname, out):
         """
@@ -1140,21 +1121,27 @@ class Shell(cmd.Cmd):
     def describe_usertypes(self, ksname):
         print
         if ksname is None:
-            for k in self.get_keyspaces():
-                name = protect_name(k.name)
+            for ksmeta in self.get_keyspaces():
+                name = protect_name(ksmeta.name)
                 print 'Keyspace %s' % (name,)
                 print '---------%s' % ('-' * len(name))
-                cmd.Cmd.columnize(self, protect_names(self.get_usertype_names(k.name)))
+                cmd.Cmd.columnize(self, protect_names(ksmeta.user_types.keys()))
                 print
         else:
-            cmd.Cmd.columnize(self, protect_names(self.get_usertype_names(ksname)))
+            ksmeta = self.get_keyspace_meta(ksname)
+            cmd.Cmd.columnize(self, protect_names(ksmeta.user_types.keys()))
             print
 
     def describe_usertype(self, ksname, typename):
         if ksname is None:
             ksname = self.current_keyspace
         print
-        self.print_recreate_usertype(ksname, typename, sys.stdout)
+        ksmeta = self.get_keyspace_meta(ksname)
+        try:
+            usertype = ksmeta.user_types[typename]
+        except KeyError:
+            raise UserTypeNotFound("User type %r not found" % typename)
+        print usertype.as_cql_query(formatted=True)
         print
 
     def describe_cluster(self):

pylib/cqlshlib/cql3handling.py

@@ -26,11 +26,6 @@ simple_cql_types.difference_update(('set', 'map', 'list'))
 from . import helptopics
 cqldocs = helptopics.CQL3HelpTopics()
 
-try:
-    import json
-except ImportError:
-    import simplejson as json
-
 class UnexpectedTableStructure(UserWarning):
     def __init__(self, msg):
         self.msg = msg
@@ -131,13 +126,12 @@ class Cql3ParsingRuleSet(CqlParsingRuleSet):
 CqlRuleSet = Cql3ParsingRuleSet()
 
 # convenience for remainder of module
-shorthands = ('completer_for', 'explain_completion',
-              'dequote_value', 'dequote_name',
-              'escape_value',
-              'maybe_escape_name')
-
-for shorthand in shorthands:
-    globals()[shorthand] = getattr(CqlRuleSet, shorthand)
+completer_for = CqlRuleSet.completer_for
+explain_completion = CqlRuleSet.explain_completion
+dequote_value = CqlRuleSet.dequote_value
+dequote_name = CqlRuleSet.dequote_name
+escape_value = CqlRuleSet.escape_value
+maybe_escape_name = CqlRuleSet.maybe_escape_name
 
 
 # BEGIN SYNTAX/COMPLETION RULE DEFINITIONS
@@ -1186,33 +1180,3 @@ def username_name_completer(ctxt, cass):
 # END SYNTAX/COMPLETION RULE DEFINITIONS
 
 CqlRuleSet.append_rules(syntax_rules)
-
-from cassandra.cqltypes import lookup_casstype
-
-class UserTypesMeta(object):
-    _meta = {}
-
-    def __init__(self, meta):
-        self._meta = meta
-
-    @classmethod
-    def from_layout(cls, layout):
-        result = {}
-        for row in layout:
-            ksname = row['keyspace_name']
-            if ksname not in result:
-                result[ksname] = {}
-            utname = row['type_name']
-
-            result[ksname][utname] = zip(row['field_names'], row['field_types'])
-        return cls(meta=result)
-
-    def get_usertypes_names(self, keyspace):
-        return map(str, self._meta.get(keyspace, {}).keys())
-
-    def get_field_names(self, keyspace, type):
-        return [row[0] for row in self._meta.get(keyspace, {}).get(type, [])]
-
-    def get_fields_with_types(self, ksname, typename):
-        return [(field[0], lookup_casstype(field[1]).cql_parameterized_type()) for field in
-                self._meta.get(ksname, {}).get(typename, [])]