python-driver: add support for in_memory table attribute

For cqlsh to show in_memory attribute properly python driver support is
needed.

Message-Id: <[email protected]>

Author: Gleb Natapov

cassandra/metadata.py

@@ -1732,6 +1732,7 @@ class SchemaParserV22(_SchemaParser):
         "dclocal_read_repair_chance",  # kept to be safe, but see _build_table_options()
         "local_read_repair_chance",
         "replicate_on_write",
+        'in_memory',
         "gc_grace_seconds",
         "bloom_filter_fp_chance",
         "caching",
@@ -1759,13 +1760,15 @@ def __init__(self, connection, timeout):
         self.types_result = []
         self.functions_result = []
         self.aggregates_result = []
+        self.scylla_result = []
 
         self.keyspace_table_rows = defaultdict(list)
         self.keyspace_table_col_rows = defaultdict(lambda: defaultdict(list))
         self.keyspace_type_rows = defaultdict(list)
         self.keyspace_func_rows = defaultdict(list)
         self.keyspace_agg_rows = defaultdict(list)
         self.keyspace_table_trigger_rows = defaultdict(lambda: defaultdict(list))
+        self.keyspace_scylla_rows = defaultdict(lambda: defaultdict(list))
 
     def get_all_keyspaces(self):
         self._query_all()
@@ -2176,9 +2179,24 @@ def _query_all(self):
         self._aggregate_results()
 
     def _aggregate_results(self):
+        m = self.keyspace_scylla_rows
+        for row in self.scylla_result:
+            ksname = row["keyspace_name"]
+            cfname = row[self._table_name_col]
+            m[ksname][cfname].append(row)
+
         m = self.keyspace_table_rows
         for row in self.tables_result:
-            m[row["keyspace_name"]].append(row)
+            ksname = row["keyspace_name"]
+            cfname = row[self._table_name_col]
+            # in_memory property is stored in scylla private table
+            # add it to table properties if enabled
+            try:
+                if self.keyspace_scylla_rows[ksname][cfname][0]["in_memory"] == True:
+                    row["in_memory"] = True
+            except (IndexError, KeyError):
+                pass
+            m[ksname].append(row)
 
         m = self.keyspace_table_col_rows
         for row in self.columns_result:
@@ -2220,6 +2238,7 @@ class SchemaParserV3(SchemaParserV22):
     _SELECT_FUNCTIONS = "SELECT * FROM system_schema.functions"
     _SELECT_AGGREGATES = "SELECT * FROM system_schema.aggregates"
     _SELECT_VIEWS = "SELECT * FROM system_schema.views"
+    _SELECT_SCYLLA = "SELECT * FROM system_schema.scylla_tables"
 
     _table_name_col = 'table_name'
 
@@ -2235,6 +2254,7 @@ class SchemaParserV3(SchemaParserV22):
         'crc_check_chance',
         'dclocal_read_repair_chance',
         'default_time_to_live',
+        'in_memory',
         'gc_grace_seconds',
         'max_index_interval',
         'memtable_flush_period_in_ms',
@@ -2262,23 +2282,33 @@ def get_table(self, keyspaces, keyspace, table):
         col_query = QueryMessage(query=self._SELECT_COLUMNS + where_clause, consistency_level=cl)
         indexes_query = QueryMessage(query=self._SELECT_INDEXES + where_clause, consistency_level=cl)
         triggers_query = QueryMessage(query=self._SELECT_TRIGGERS + where_clause, consistency_level=cl)
+        scylla_query = QueryMessage(query=self._SELECT_SCYLLA + where_clause, consistency_level=cl)
 
         # in protocol v4 we don't know if this event is a view or a table, so we look for both
         where_clause = bind_params(" WHERE keyspace_name = %s AND view_name = %s", (keyspace, table), _encoder)
         view_query = QueryMessage(query=self._SELECT_VIEWS + where_clause,
                                   consistency_level=cl)
         ((cf_success, cf_result), (col_success, col_result),
          (indexes_sucess, indexes_result), (triggers_success, triggers_result),
-         (view_success, view_result)) = (
+         (view_success, view_result),
+         (scylla_sucess, scylla_result)) = (
              self.connection.wait_for_responses(
                  cf_query, col_query, indexes_query, triggers_query,
-                 view_query, timeout=self.timeout, fail_on_error=False)
+                 view_query, scylla_query, timeout=self.timeout, fail_on_error=False)
         )
         table_result = self._handle_results(cf_success, cf_result)
         col_result = self._handle_results(col_success, col_result)
         if table_result:
             indexes_result = self._handle_results(indexes_sucess, indexes_result)
             triggers_result = self._handle_results(triggers_success, triggers_result)
+            # in_memory property is stored in scylla private table
+            # add it to table properties if enabled
+            scylla_result = self._handle_results(scylla_success, scylla_result)
+            try:
+                if scylla_result[0]["in_memory"] == True:
+                    table_result[0]["in_memory"] = True
+            except (IndexError, KeyError):
+                pass
             return self._build_table_metadata(table_result[0], col_result, triggers_result, indexes_result)
 
         view_result = self._handle_results(view_success, view_result)
@@ -2434,7 +2464,8 @@ def _query_all(self):
             QueryMessage(query=self._SELECT_AGGREGATES, consistency_level=cl),
             QueryMessage(query=self._SELECT_TRIGGERS, consistency_level=cl),
             QueryMessage(query=self._SELECT_INDEXES, consistency_level=cl),
-            QueryMessage(query=self._SELECT_VIEWS, consistency_level=cl)
+            QueryMessage(query=self._SELECT_VIEWS, consistency_level=cl),
+            QueryMessage(query=self._SELECT_SCYLLA, consistency_level=cl)
         ]
 
         ((ks_success, ks_result),
@@ -2445,7 +2476,8 @@ def _query_all(self):
          (aggregates_success, aggregates_result),
          (triggers_success, triggers_result),
          (indexes_success, indexes_result),
-         (views_success, views_result)) = self.connection.wait_for_responses(
+         (views_success, views_result),
+         (scylla_success, scylla_result)) = self.connection.wait_for_responses(
              *queries, timeout=self.timeout, fail_on_error=False
         )
 
@@ -2458,6 +2490,7 @@ def _query_all(self):
         self.aggregates_result = self._handle_results(aggregates_success, aggregates_result)
         self.indexes_result = self._handle_results(indexes_success, indexes_result)
         self.views_result = self._handle_results(views_success, views_result)
+        self.scylla_result = self._handle_results(scylla_success, scylla_result)
 
         self._aggregate_results()