pre-merge

cmake/build_configurations/mysql_release.cmake

@@ -46,6 +46,8 @@ SET(FEATURE_SET_large   5)
 SET(FEATURE_SET_xlarge  6)
 SET(FEATURE_SET_community 7)
 
+SET(WITH_CASSANDRA_STORAGE_ENGINE  ON)
+
 IF(FEATURE_SET)
   STRING(TOLOWER ${FEATURE_SET} feature_set)
   SET(num ${FEATURE_SET_${feature_set}})

include/ma_dyncol.h

@@ -34,10 +34,10 @@
 #include <mysql_time.h>
 
 /*
-  Max length for data in a dynamic colums. This comes from how the
-  how the offset are stored.
+  Limits of implementation
 */
-#define MAX_DYNAMIC_COLUMN_LENGTH 0X1FFFFFFFL
+#define MAX_TOTAL_NAME_LENGTH 65535
+#define MAX_NAME_LENGTH (MAX_TOTAL_NAME_LENGTH/4)
 
 /* NO and OK is the same used just to show semantics */
 #define ER_DYNCOL_NO ER_DYNCOL_OK
@@ -50,7 +50,8 @@ enum enum_dyncol_func_result
   ER_DYNCOL_LIMIT=  -2,            /* Some limit reached */
   ER_DYNCOL_RESOURCE= -3,          /* Out of resourses */
   ER_DYNCOL_DATA= -4,              /* Incorrect input data */
-  ER_DYNCOL_UNKNOWN_CHARSET= -5    /* Unknown character set */
+  ER_DYNCOL_UNKNOWN_CHARSET= -5,   /* Unknown character set */
+  ER_DYNCOL_TRUNCATED= 2           /* OK, but data was truncated */
 };
 
 typedef DYNAMIC_STRING DYNAMIC_COLUMN;
@@ -65,7 +66,8 @@ enum enum_dynamic_column_type
   DYN_COL_DECIMAL,
   DYN_COL_DATETIME,
   DYN_COL_DATE,
-  DYN_COL_TIME
+  DYN_COL_TIME,
+  DYN_COL_DYNCOL
 };
 
 typedef enum enum_dynamic_column_type DYNAMIC_COLUMN_TYPE;
@@ -92,6 +94,7 @@ struct st_dynamic_column_value
 
 typedef struct st_dynamic_column_value DYNAMIC_COLUMN_VALUE;
 
+#ifdef MADYNCOL_DEPRECATED
 enum enum_dyncol_func_result
 dynamic_column_create(DYNAMIC_COLUMN *str,
                       uint column_nr, DYNAMIC_COLUMN_VALUE *value);
@@ -101,7 +104,6 @@ dynamic_column_create_many(DYNAMIC_COLUMN *str,
                            uint column_count,
                            uint *column_numbers,
                            DYNAMIC_COLUMN_VALUE *values);
-
 enum enum_dyncol_func_result
 dynamic_column_update(DYNAMIC_COLUMN *org, uint column_nr,
                       DYNAMIC_COLUMN_VALUE *value);
@@ -110,38 +112,104 @@ dynamic_column_update_many(DYNAMIC_COLUMN *str,
                            uint add_column_count,
                            uint *column_numbers,
                            DYNAMIC_COLUMN_VALUE *values);
-
 enum enum_dyncol_func_result
 dynamic_column_delete(DYNAMIC_COLUMN *org, uint column_nr);
 
 enum enum_dyncol_func_result
 dynamic_column_exists(DYNAMIC_COLUMN *org, uint column_nr);
 
-/* List of not NULL columns */
 enum enum_dyncol_func_result
 dynamic_column_list(DYNAMIC_COLUMN *org, DYNAMIC_ARRAY *array_of_uint);
 
+enum enum_dyncol_func_result
+dynamic_column_get(DYNAMIC_COLUMN *org, uint column_nr,
+                   DYNAMIC_COLUMN_VALUE *store_it_here);
+#endif
+
+/* new functions */
+enum enum_dyncol_func_result
+mariadb_dyncol_create_many(DYNAMIC_COLUMN *str,
+                           uint column_count,
+                           uint *column_numbers,
+                           DYNAMIC_COLUMN_VALUE *values,
+                           my_bool new_string);
+enum enum_dyncol_func_result
+mariadb_dyncol_create_many_named(DYNAMIC_COLUMN *str,
+                                 uint column_count,
+                                 LEX_STRING *column_keys,
+                                 DYNAMIC_COLUMN_VALUE *values,
+                                 my_bool new_string);
+
+
+enum enum_dyncol_func_result
+mariadb_dyncol_update_many(DYNAMIC_COLUMN *str,
+                           uint add_column_count,
+                           uint *column_keys,
+                           DYNAMIC_COLUMN_VALUE *values);
+enum enum_dyncol_func_result
+mariadb_dyncol_update_many_named(DYNAMIC_COLUMN *str,
+                                 uint add_column_count,
+                                 LEX_STRING *column_keys,
+                                 DYNAMIC_COLUMN_VALUE *values);
+
+
+enum enum_dyncol_func_result
+mariadb_dyncol_exists(DYNAMIC_COLUMN *org, uint column_nr);
+enum enum_dyncol_func_result
+mariadb_dyncol_exists_named(DYNAMIC_COLUMN *str, LEX_STRING *name);
+
+/* List of not NULL columns */
+enum enum_dyncol_func_result
+mariadb_dyncol_list(DYNAMIC_COLUMN *str, uint *count, uint **nums);
+enum enum_dyncol_func_result
+mariadb_dyncol_list_named(DYNAMIC_COLUMN *str, uint *count, LEX_STRING **names);
+
 /*
    if the column do not exists it is NULL
 */
 enum enum_dyncol_func_result
-dynamic_column_get(DYNAMIC_COLUMN *org, uint column_nr,
+mariadb_dyncol_get(DYNAMIC_COLUMN *org, uint column_nr,
                    DYNAMIC_COLUMN_VALUE *store_it_here);
+enum enum_dyncol_func_result
+mariadb_dyncol_get_named(DYNAMIC_COLUMN *str, LEX_STRING *name,
+                         DYNAMIC_COLUMN_VALUE *store_it_here);
+
+my_bool mariadb_dyncol_has_names(DYNAMIC_COLUMN *str);
+
+enum enum_dyncol_func_result
+mariadb_dyncol_check(DYNAMIC_COLUMN *str);
+
+enum enum_dyncol_func_result
+mariadb_dyncol_json(DYNAMIC_COLUMN *str, DYNAMIC_STRING *json);
 
 #define dynamic_column_initialize(A) memset((A), 0, sizeof(*(A)))
 #define dynamic_column_column_free(V) dynstr_free(V)
 
-/***************************************************************************
- Internal functions, don't use if you don't know what you are doing...
-***************************************************************************/
+/* conversion of values to 3 base types */
+enum enum_dyncol_func_result
+mariadb_dyncol_val_str(DYNAMIC_STRING *str, DYNAMIC_COLUMN_VALUE *val,
+                       CHARSET_INFO *cs, my_bool quote);
+enum enum_dyncol_func_result
+mariadb_dyncol_val_long(longlong *ll, DYNAMIC_COLUMN_VALUE *val);
+enum enum_dyncol_func_result
+mariadb_dyncol_val_double(double *dbl, DYNAMIC_COLUMN_VALUE *val);
+
+
+enum enum_dyncol_func_result
+mariadb_dyncol_unpack(DYNAMIC_COLUMN *str,
+                      uint *count,
+                      LEX_STRING **names, DYNAMIC_COLUMN_VALUE **vals);
 
-#define dynamic_column_reassociate(V,P,L, A) dynstr_reassociate((V),(P),(L),(A))
+int mariadb_dyncol_column_cmp_named(const LEX_STRING *s1, const LEX_STRING *s2);
+
+enum enum_dyncol_func_result
+mariadb_dyncol_column_count(DYNAMIC_COLUMN *str, uint *column_count);
 
-#define dynamic_column_value_init(V) (V)->type= DYN_COL_NULL
+#define mariadb_dyncol_value_init(V) (V)->type= DYN_COL_NULL
 
 /*
   Prepare value for using as decimal
 */
-void dynamic_column_prepare_decimal(DYNAMIC_COLUMN_VALUE *value);
+void mariadb_dyncol_prepare_decimal(DYNAMIC_COLUMN_VALUE *value);
 
 #endif

include/my_sys.h

@@ -801,12 +801,23 @@ my_bool dynstr_append_mem(DYNAMIC_STRING *str, const char *append,
 			  size_t length);
 extern my_bool dynstr_append_os_quoted(DYNAMIC_STRING *str, const char *append,
                                        ...);
+extern my_bool dynstr_append_quoted(DYNAMIC_STRING *str,
+                                    const char *append, size_t len,
+                                    char quote);
 extern my_bool dynstr_set(DYNAMIC_STRING *str, const char *init_str);
 extern my_bool dynstr_realloc(DYNAMIC_STRING *str, size_t additional_size);
 extern my_bool dynstr_trunc(DYNAMIC_STRING *str, size_t n);
 extern void dynstr_free(DYNAMIC_STRING *str);
+extern uint32 copy_and_convert_extended(char *to, uint32 to_length,
+                                        CHARSET_INFO *to_cs,
+                                        const char *from, uint32 from_length,
+                                        CHARSET_INFO *from_cs, uint *errors);
 extern void dynstr_reassociate(DYNAMIC_STRING *str, char **res, size_t *length,
                                size_t *alloc_length);
+extern uint32 copy_and_convert_extended(char *to, uint32 to_length,
+                                        CHARSET_INFO *to_cs,
+                                        const char *from, uint32 from_length,
+                                        CHARSET_INFO *from_cs, uint *errors);
 #ifdef HAVE_MLOCK
 extern void *my_malloc_lock(size_t length,myf flags);
 extern void my_free_lock(void *ptr);

mysql-test/include/have_cassandra.inc

+#
+# suite.pm will make sure that all tests including this file
+# will be skipped unless innodb or xtradb is enabled
+#
+# The test below is redundant
+
+if (`SELECT COUNT(*) = 0 FROM INFORMATION_SCHEMA.ENGINES WHERE engine = 'cassandra' AND support IN ('YES', 'DEFAULT', 'ENABLED')`)
+{
+  --skip Test requires Cassandra.
+}

mysql-test/include/have_cassandra.opt

+--cassandra=on

mysql-test/r/mysqld--help.result

@@ -89,6 +89,24 @@ The following options may be given as the first argument:
  --bulk-insert-buffer-size=# 
  Size of tree cache used in bulk insert optimisation. Note
  that this is a limit per thread!
+ --cassandra[=name]  Enable or disable CASSANDRA plugin. Possible values are
+ ON, OFF, FORCE (don't start if the plugin fails to load).
+ --cassandra-default-thrift-host=name 
+ Default host for Cassandra thrift connections
+ --cassandra-failure-retries=# 
+ Number of times to retry Cassandra calls that failed due
+ to timeouts or network communication problems. The
+ default, 0, means not to retry.
+ --cassandra-insert-batch-size=# 
+ Number of rows in an INSERT batch
+ --cassandra-multiget-batch-size=# 
+ Number of rows in a multiget(MRR) batch
+ --cassandra-read-consistency=name 
+ Cassandra consistency level to use for read operations
+ --cassandra-rnd-batch-size=# 
+ Number of rows in an rnd_read (full scan) batch
+ --cassandra-write-consistency=name 
+ Cassandra consistency level to use for write operations
  --character-set-client-handshake 
  Don't ignore client side character set value sent during
  handshake.
@@ -872,6 +890,14 @@ binlog-optimize-thread-scheduling TRUE
 binlog-row-event-max-size 1024
 binlog-stmt-cache-size 32768
 bulk-insert-buffer-size 8388608
+cassandra ON
+cassandra-default-thrift-host (No default value)
+cassandra-failure-retries 0
+cassandra-insert-batch-size 100
+cassandra-multiget-batch-size 100
+cassandra-read-consistency ONE
+cassandra-rnd-batch-size 10000
+cassandra-write-consistency ONE
 character-set-client-handshake TRUE
 character-set-filesystem binary
 character-set-server latin1

mysql-test/t/dyncol.test

@@ -550,3 +550,164 @@ select hex(COLUMN_CREATE(0, COLUMN_GET(@a, 9 AS DECIMAL(19,0))));
 
 select hex(COLUMN_CREATE(0, COLUMN_GET(COLUMN_CREATE(0, 0.0 as decimal), 0 as decimal)));
 select hex(COLUMN_CREATE(0, 0.0 as decimal));
+
+--echo #
+--echo # test of symbolic names
+--echo #
+--echo # creation test (names)
+set names utf8;
+select hex(column_create("адын", 1212));
+select hex(column_create("1212", 1212));
+select hex(column_create(1212, 2, "www", 3));
+select hex(column_create("1212", 2, "www", 3));
+select hex(column_create("1212", 2, 3, 3));
+select hex(column_create("1212", 2, "адын", 1, 3, 3));
+set names default;
+
+--echo # fetching column test (names)
+set names utf8;
+select column_get(column_create("адын", 1212), "адын" as int);
+select column_get(column_create("1212", 2, "адын", 1, 3, 3), "адын" as int);
+select column_get(column_create("1212", 2, "адын", 1, 3, 3), 1212 as int);
+select column_get(column_create("1212", 2, "адын", 1, 3, 3), "3" as int);
+select column_get(column_create("1212", 2, "адын", 1, 3, 3), 3 as int);
+select column_get(column_create("1212", 2, "адын", 1, 3, 3), 4 as int);
+select column_get(column_create("1212", 2, "адын", 1, 3, 3), "4" as int);
+set names default;
+
+--echo # column existance test (names)
+set names utf8;
+select column_exists(column_create("адын", 1212), "адын");
+select column_exists(column_create("адын", 1212), "aады");
+select column_exists(column_create("1212", 2, "адын", 1, 3, 3), "адын");
+select column_exists(column_create("1212", 2, "адын", 1, 3, 3), 1212);
+select column_exists(column_create("1212", 2, "адын", 1, 3, 3), "3");
+select column_exists(column_create("1212", 2, "адын", 1, 3, 3), 3);
+select column_exists(column_create("1212", 2, "адын", 1, 3, 3), 4);
+select column_exists(column_create("1212", 2, "адын", 1, 3, 3), "4");
+set names default;
+
+--echo # column changing test (names)
+select hex(column_add(column_create(1, "AAA"), "b", "BBB"));
+select hex(column_add(column_create("1", "AAA"), "b", "BBB"));
+select column_get(column_add(column_create(1, "AAA"), "b", "BBB"), 1 as char);
+select column_get(column_add(column_create(1, "AAA"), "b", "BBB"), "b" as char);
+select hex(column_add(column_create("a", "AAA"), 1, "BBB"));
+select hex(column_add(column_create("a", "AAA"), "1", "BBB"));
+select hex(column_add(column_create("a", 1212 as integer), "b", "1212" as integer));
+select hex(column_add(column_create("a", 1212 as integer), "a", "1212" as integer));
+select hex(column_add(column_create("a", 1212 as integer), "a", NULL as integer));
+select hex(column_add(column_create("a", 1212 as integer), "b", NULL as integer));
+select hex(column_add(column_create("a", 1212 as integer), "b", 1212 as integer, "a", 11 as integer));
+select column_get(column_add(column_create("a", 1212 as integer), "b", 1212 as integer, "a", 11 as integer), "a" as integer);
+select column_get(column_add(column_create("a", 1212 as integer), "b", 1212 as integer, "a", 11 as integer), "b" as integer);
+select hex(column_add(column_create("a", 1212 as integer), "a", 1212 as integer, "b", 11 as integer));
+select hex(column_add(column_create("a", NULL as integer), "a", 1212 as integer, "b", 11 as integer));
+select hex(column_add(column_create("a", 1212 as integer, "b", 1212 as integer), "a", 11 as integer));
+select hex(column_add(column_create("a", 1), "a", null));
+select column_list(column_add(column_create("a", 1), "a", null));
+select column_list(column_add(column_create("a", 1), "a", ""));
+select hex(column_add("", "a", 1));
+
+-- echo # column delete (names)
+select hex(column_delete(column_create("a", 1212 as integer, "b", 1212 as integer), "a"));
+select hex(column_delete(column_create("a", 1 as integer, "b", 2 as integer, "c", 3 as integer), "b"));
+select hex(column_create("a", 1 as integer, "b", 2 as integer, "c", 3 as integer));
+select hex(column_delete(column_create("a", 1 as integer, "b", 2 as integer, "c", 3 as integer), "c"));
+select hex(column_delete(column_create("a", 1 as integer, "b", 2 as integer, "c", 3 as integer), "d"));
+select hex(column_delete(column_create("a", 1 as integer, "b", 2 as integer, "c", 3 as integer), "b", "a"));
+select hex(column_delete(column_create("a", 1 as integer, "b", 2 as integer, "c", 3 as integer), "b", "c"));
+select hex(column_delete(column_create("a", 1 as integer, "b", 2 as integer, "c", 3 as integer), "a", "b", "c"));
+select hex(column_delete(column_create("a", 1 as integer, "b", 2 as integer, "c", 3 as integer), "a", "b", "c", "e"));
+select hex(column_delete(column_create("a", 1), "a"));
+select hex(column_delete("", "a"));
+
+--echo #
+--echo # MDEV-458 DNAMES: Server crashes on using an unquoted string
+--echo # as a dynamic column name
+--echo #
+--error ER_BAD_FIELD_ERROR
+select COLUMN_CREATE(color, "black");
+
+--echo #
+--echo # MDEV-489 Assertion `offset < 0x1f' failed in
+--echo # type_and_offset_store on COLUMN_ADD
+--echo #
+CREATE TABLE t1 (f1 tinyblob);
+
+INSERT INTO t1 VALUES (COLUMN_CREATE('col1', REPEAT('a',30)));
+select column_check(f1) from t1;
+UPDATE t1 SET f1 = COLUMN_ADD( f1, REPEAT('b',211), 'val2' );
+# we can't detect last string cut with 100% probability,
+# because we detect it by string end
+select column_check(f1) from t1;
+UPDATE t1 SET f1 = COLUMN_ADD( f1, REPEAT('c',211), 'val3' );
+select column_check(f1) from t1;
+
+drop table t1;
+
+--echo #
+--echo # MDEV-490/MDEV-491 null as arguments
+--echo #
+SELECT COLUMN_GET( COLUMN_CREATE( 'col', 'val' ), NULL AS CHAR );
+SELECT COLUMN_GET( NULL, 'col' as char );
+SELECT COLUMN_EXISTS( COLUMN_CREATE( 'col', 'val' ), NULL);
+SELECT COLUMN_EXISTS( NULL, 'col');
+SELECT COLUMN_CREATE( NULL, 'val' );
+SELECT COLUMN_ADD( NULL, 'val', 'col');
+
+--echo #
+--echo # MDEV-488: Assertion `column_name->length < 255' failed on a
+--echo # column name with length 255 (precisely)
+--echo #
+SELECT hex(COLUMN_CREATE(REPEAT('a',255),1));
+--error ER_DYN_COL_DATA
+SELECT hex(COLUMN_CREATE(REPEAT('a',65536),1));
+
+--echo #
+--echo # JSON conversion
+--echo #
+select column_json(column_create("int", -1212 as int, "uint", 12334 as unsigned int, "decimal", "23.344" as decimal, "double", 1.23444e50 as double, "string", 'gdgd\\dhdjh"dhdhd' as char, "time", "0:45:49.000001" AS time, "datetime", "2011-04-05 0:45:49.000001" AS datetime, "date", "2011-04-05" AS date));
+select column_json(column_create(1, -1212 as int, 2, 12334 as unsigned int, 3, "23.344" as decimal, 4, 1.23444e50 as double, 5, 'gdgd\\dhdjh"dhdhd' as char, 6, "0:45:49.000001" AS time, 7, "2011-04-05 0:45:49.000001" AS datetime, 8, "2011-04-05" AS date));
+
+--echo #
+--echo # CHECK test
+--echo #
+SELECT COLUMN_CHECK(COLUMN_CREATE(1,'a'));
+SELECT COLUMN_CHECK('abracadabra');
+SELECT COLUMN_CHECK('');
+SELECT COLUMN_CHECK(NULL);
+
+--echo #
+--echo # escaping check
+--echo #
+select column_json(column_create("string", "'\"/\\`.,whatever")),hex(column_create("string", "'\"/\\`.,whatever"));
+
+--echo #
+--echo # embedding test
+--echo #
+select column_json(column_create("val", "val", "emb", column_create("val2", "val2")));
+select column_json(column_create(1, "val", 2, column_create(3, "val2")));
+
+--echo #
+--echo # Time encoding
+--echo #
+select hex(column_create("t", "800:46:06.23434" AS time)) as hex,
+       column_json(column_create("t", "800:46:06.23434" AS time)) as json;
+select hex(column_create(1, "800:46:06.23434" AS time)) as hex,
+       column_json(column_create(1, "800:46:06.23434" AS time)) as json;
+
+select hex(column_create("t", "800:46:06" AS time)) as hex,
+       column_json(column_create("t", "800:46:06" AS time)) as json;
+select hex(column_create(1, "800:46:06" AS time)) as hex,
+       column_json(column_create(1, "800:46:06" AS time)) as json;
+
+select hex(column_create("t", "2012-12-21 10:46:06.23434" AS datetime)) as hex,
+       column_json(column_create("t", "2012-12-21 10:46:06.23434" AS datetime)) as json;
+select hex(column_create(1, "2012-12-21 10:46:06.23434" AS datetime)) as hex,
+       column_json(column_create(1, "2012-12-21 10:46:06.23434" AS datetime)) as json;
+
+select hex(column_create("t", "2012-12-21 10:46:06" AS datetime)) as hex,
+       column_json(column_create("t", "2012-12-21 10:46:06" AS datetime)) as json;
+select hex(column_create(1, "2012-12-21 10:46:06" AS datetime)) as hex,
+       column_json(column_create(1, "2012-12-21 10:46:06" AS datetime)) as json;

mysys/string.c

@@ -175,6 +175,36 @@ my_bool dynstr_append_os_quoted(DYNAMIC_STRING *str, const char *append, ...)
   return ret;
 }
 
+my_bool dynstr_append_quoted(DYNAMIC_STRING *str,
+                             const char *append, size_t len,
+                             char quote)
+{
+  uint additional= (str->alloc_increment ? str->alloc_increment : 10);
+  uint lim= additional;
+  uint i;
+  if (dynstr_realloc(str, len + additional + 2))
+    return TRUE;
+  str->str[str->length++]= quote;
+  for (i= 0; i < len; i++)
+  {
+    register char c= append[i];
+    if (c == quote || c == '\\')
+    {
+      if (!lim)
+      {
+        if (dynstr_realloc(str, additional))
+          return TRUE;
+        lim= additional;
+      }
+      lim--;
+      str->str[str->length++]= '\\';
+    }
+    str->str[str->length++]= c;
+  }
+  str->str[str->length++]= quote;
+  return FALSE;
+}
+
 
 void dynstr_free(DYNAMIC_STRING *str)
 {
@@ -193,3 +223,77 @@ void dynstr_reassociate(DYNAMIC_STRING *str, char **ptr, size_t *length,
   *alloc_length= str->max_length;
   str->str=0;
 }
+
+
+/*
+  copy a string from one character set to another
+
+  SYNOPSIS
+    copy_and_convert()
+    to			Store result here
+    to_cs		Character set of result string
+    from		Copy from here
+    from_length		Length of from string
+    from_cs		From character set
+
+  NOTES
+    'to' must be big enough as form_length * to_cs->mbmaxlen
+
+  RETURN
+    length of bytes copied to 'to'
+*/
+
+uint32
+copy_and_convert_extended(char *to, uint32 to_length, CHARSET_INFO *to_cs, 
+                          const char *from, uint32 from_length,
+                          CHARSET_INFO *from_cs,
+                          uint *errors)
+{
+  int         cnvres;
+  my_wc_t     wc;
+  const uchar *from_end= (const uchar*) from+from_length;
+  char *to_start= to;
+  uchar *to_end= (uchar*) to+to_length;
+  my_charset_conv_mb_wc mb_wc= from_cs->cset->mb_wc;
+  my_charset_conv_wc_mb wc_mb= to_cs->cset->wc_mb;
+  uint error_count= 0;
+
+  while (1)
+  {
+    if ((cnvres= (*mb_wc)(from_cs, &wc, (uchar*) from,
+				      from_end)) > 0)
+      from+= cnvres;
+    else if (cnvres == MY_CS_ILSEQ)
+    {
+      error_count++;
+      from++;
+      wc= '?';
+    }
+    else if (cnvres > MY_CS_TOOSMALL)
+    {
+      /*
+        A correct multibyte sequence detected
+        But it doesn't have Unicode mapping.
+      */
+      error_count++;
+      from+= (-cnvres);
+      wc= '?';
+    }
+    else
+      break;  // Not enough characters
+
+outp:
+    if ((cnvres= (*wc_mb)(to_cs, wc, (uchar*) to, to_end)) > 0)
+      to+= cnvres;
+    else if (cnvres == MY_CS_ILUNI && wc != '?')
+    {
+      error_count++;
+      wc= '?';
+      goto outp;
+    }
+    else
+      break;
+  }
+  *errors= error_count;
+  return (uint32) (to - to_start);
+}

sql/item.h

@@ -523,7 +523,7 @@ public:
 
 struct st_dyncall_create_def
 {
-  Item  *num, *value;
+  Item  *key, *value;
   CHARSET_INFO *cs;
   uint len, frac;
   DYNAMIC_COLUMN_TYPE type;

sql/item_cmpfunc.cc

@@ -6068,23 +6068,87 @@ Item* Item_equal::get_first(JOIN_TAB *context, Item *field_item)
 }
 
 
-longlong Item_func_dyncol_exists::val_int()
+longlong Item_func_dyncol_check::val_int()
 {
   char buff[STRING_BUFFER_USUAL_SIZE];
   String tmp(buff, sizeof(buff), &my_charset_bin);
   DYNAMIC_COLUMN col;
   String *str;
-  ulonglong num;
   enum enum_dyncol_func_result rc;
 
-  num= args[1]->val_int();
+  str= args[0]->val_str(&tmp);
+  if (args[0]->null_value)
+    goto null;
+  col.length= str->length();
+  /* We do not change the string, so could do this trick */
+  col.str= (char *)str->ptr();
+  rc= mariadb_dyncol_check(&col);
+  if (rc < 0 && rc != ER_DYNCOL_FORMAT)
+  {
+    dynamic_column_error_message(rc);
+    goto null;
+  }
+  null_value= FALSE;
+  return rc == ER_DYNCOL_OK;
+
+null:
+  null_value= TRUE;
+  return 0;
+}
+
+longlong Item_func_dyncol_exists::val_int()
+{
+  char buff[STRING_BUFFER_USUAL_SIZE], nmstrbuf[11];
+  String tmp(buff, sizeof(buff), &my_charset_bin),
+         nmbuf(nmstrbuf, sizeof(nmstrbuf), system_charset_info);
+  DYNAMIC_COLUMN col;
+  String *str;
+  LEX_STRING buf, *name= NULL;
+  ulonglong num= 0;
+  enum enum_dyncol_func_result rc;
+
+  if (args[1]->result_type() == INT_RESULT)
+    num= args[1]->val_int();
+  else
+  {
+    String *nm= args[1]->val_str(&nmbuf);
+    if (!nm || args[1]->null_value)
+    {
+      null_value= 1;
+      return 1;
+    }
+    if (my_charset_same(nm->charset(), &my_charset_utf8_general_ci))
+    {
+      buf.str= (char *) nm->ptr();
+      buf.length= nm->length();
+    }
+    else
+    {
+      uint strlen;
+      uint dummy_errors;
+      buf.str= (char *)sql_alloc((strlen= nm->length() *
+                                     my_charset_utf8_general_ci.mbmaxlen + 1));
+      if (buf.str)
+      {
+        buf.length=
+          copy_and_convert(buf.str, strlen, &my_charset_utf8_general_ci,
+                           nm->ptr(), nm->length(), nm->charset(),
+                           &dummy_errors);
+      }
+      else
+        buf.length= 0;
+    }
+    name= &buf;
+  }
   str= args[0]->val_str(&tmp);
   if (args[0]->null_value || args[1]->null_value || num > UINT_MAX16)
     goto null;
   col.length= str->length();
   /* We do not change the string, so could do this trick */
   col.str= (char *)str->ptr();
-  rc= dynamic_column_exists(&col, (uint) num);
+  rc= ((name == NULL) ?
+       mariadb_dyncol_exists(&col, (uint) num) :
+       mariadb_dyncol_exists_named(&col, name));
   if (rc < 0)
   {
     dynamic_column_error_message(rc);

sql/item_cmpfunc.h

@@ -1861,6 +1861,14 @@ public:
   Item *neg_transformer(THD *thd);
 };
 
+class Item_func_dyncol_check :public Item_bool_func
+{
+public:
+  Item_func_dyncol_check(Item *str) :Item_bool_func(str) {}
+  longlong val_int();
+  const char *func_name() const { return "column_check"; }
+};
+
 class Item_func_dyncol_exists :public Item_bool_func
 {
 public:

sql/item_create.cc

@@ -526,6 +526,54 @@ protected:
   virtual ~Create_func_coercibility() {}
 };
 
+class Create_func_dyncol_check : public Create_func_arg1
+{
+public:
+  virtual Item *create_1_arg(THD *thd, Item *arg1);
+
+  static Create_func_dyncol_check s_singleton;
+
+protected:
+  Create_func_dyncol_check() {}
+  virtual ~Create_func_dyncol_check() {}
+};
+
+class Create_func_dyncol_exists : public Create_func_arg2
+{
+public:
+  virtual Item *create_2_arg(THD *thd, Item *arg1, Item *arg2);
+
+  static Create_func_dyncol_exists s_singleton;
+
+protected:
+  Create_func_dyncol_exists() {}
+  virtual ~Create_func_dyncol_exists() {}
+};
+
+class Create_func_dyncol_list : public Create_func_arg1
+{
+public:
+  virtual Item *create_1_arg(THD *thd, Item *arg1);
+
+  static Create_func_dyncol_list s_singleton;
+
+protected:
+  Create_func_dyncol_list() {}
+  virtual ~Create_func_dyncol_list() {}
+};
+
+class Create_func_dyncol_json : public Create_func_arg1
+{
+public:
+  virtual Item *create_1_arg(THD *thd, Item *arg1);
+
+  static Create_func_dyncol_json s_singleton;
+
+protected:
+  Create_func_dyncol_json() {}
+  virtual ~Create_func_dyncol_json() {}
+};
+
 
 class Create_func_compress : public Create_func_arg1
 {
@@ -3108,6 +3156,38 @@ Create_func_coercibility::create_1_arg(THD *thd, Item *arg1)
 }
 
 
+Create_func_dyncol_check Create_func_dyncol_check::s_singleton;
+
+Item*
+Create_func_dyncol_check::create_1_arg(THD *thd, Item *arg1)
+{
+  return new (thd->mem_root) Item_func_dyncol_check(arg1);
+}
+
+Create_func_dyncol_exists Create_func_dyncol_exists::s_singleton;
+
+Item*
+Create_func_dyncol_exists::create_2_arg(THD *thd, Item *arg1, Item *arg2)
+{
+  return new (thd->mem_root) Item_func_dyncol_exists(arg1, arg2);
+}
+
+Create_func_dyncol_list Create_func_dyncol_list::s_singleton;
+
+Item*
+Create_func_dyncol_list::create_1_arg(THD *thd, Item *arg1)
+{
+  return new (thd->mem_root) Item_func_dyncol_list(arg1);
+}
+
+Create_func_dyncol_json Create_func_dyncol_json::s_singleton;
+
+Item*
+Create_func_dyncol_json::create_1_arg(THD *thd, Item *arg1)
+{
+  return new (thd->mem_root) Item_func_dyncol_json(arg1);
+}
+
 Create_func_concat Create_func_concat::s_singleton;
 
 Item*
@@ -5252,6 +5332,10 @@ static Native_func_registry func_array[] =
   { { C_STRING_WITH_LEN("CHARACTER_LENGTH") }, BUILDER(Create_func_char_length)},
   { { C_STRING_WITH_LEN("CHAR_LENGTH") }, BUILDER(Create_func_char_length)},
   { { C_STRING_WITH_LEN("COERCIBILITY") }, BUILDER(Create_func_coercibility)},
+  { { C_STRING_WITH_LEN("COLUMN_CHECK") }, BUILDER(Create_func_dyncol_check)},
+  { { C_STRING_WITH_LEN("COLUMN_EXISTS") }, BUILDER(Create_func_dyncol_exists)},
+  { { C_STRING_WITH_LEN("COLUMN_LIST") }, BUILDER(Create_func_dyncol_list)},
+  { { C_STRING_WITH_LEN("COLUMN_JSON") }, BUILDER(Create_func_dyncol_json)},
   { { C_STRING_WITH_LEN("COMPRESS") }, BUILDER(Create_func_compress)},
   { { C_STRING_WITH_LEN("CONCAT") }, BUILDER(Create_func_concat)},
   { { C_STRING_WITH_LEN("CONCAT_WS") }, BUILDER(Create_func_concat_ws)},
@@ -5711,7 +5795,7 @@ static List<Item> *create_func_dyncol_prepare(THD *thd,
   for (uint i= 0; (def= li++) ;)
   {
     dfs[0][i++]= *def;
-    args->push_back(def->num);
+    args->push_back(def->key);
     args->push_back(def->value);
   }
   return args;
@@ -5727,7 +5811,6 @@ Item *create_func_dyncol_create(THD *thd, List<DYNCALL_CREATE_DEF> &list)
   return new (thd->mem_root) Item_func_dyncol_create(*args, dfs);
 }
 
-
 Item *create_func_dyncol_add(THD *thd, Item *str,
                              List<DYNCALL_CREATE_DEF> &list)
 {
@@ -5747,7 +5830,7 @@ Item *create_func_dyncol_add(THD *thd, Item *str,
 Item *create_func_dyncol_delete(THD *thd, Item *str, List<Item> &nums)
 {
   DYNCALL_CREATE_DEF *dfs;
-  Item *num;
+  Item *key;
   List_iterator_fast<Item> it(nums);
   List<Item> *args= new (thd->mem_root) List<Item>;
 
@@ -5757,12 +5840,12 @@ Item *create_func_dyncol_delete(THD *thd, Item *str, List<Item> &nums)
   if (!args || !dfs)
     return NULL;
 
-  for (uint i= 0; (num= it++); i++)
+  for (uint i= 0; (key= it++); i++)
   {
-    dfs[i].num= num;
+    dfs[i].key= key;
     dfs[i].value= new Item_null();
     dfs[i].type= DYN_COL_INT;
-    args->push_back(dfs[i].num);
+    args->push_back(dfs[i].key);
     args->push_back(dfs[i].value);
   }
 

sql/item_create.h

@@ -180,5 +180,6 @@ Item *create_func_dyncol_get(THD *thd, Item *num, Item *str,
                              Cast_target cast_type,
                              const char *c_len, const char *c_dec,
                              CHARSET_INFO *cs);
+Item *create_func_dyncol_json(THD *thd, Item *str);
 #endif
 

sql/item_func.h

@@ -58,7 +58,7 @@ public:
                   NOW_FUNC, TRIG_COND_FUNC,
                   SUSERVAR_FUNC, GUSERVAR_FUNC, COLLATE_FUNC,
                   EXTRACT_FUNC, CHAR_TYPECAST_FUNC, FUNC_SP, UDF_FUNC,
-                  NEG_FUNC, GSYSVAR_FUNC };
+                  NEG_FUNC, GSYSVAR_FUNC, DYNCOL_FUNC };
   enum optimize_type { OPTIMIZE_NONE,OPTIMIZE_KEY,OPTIMIZE_OP, OPTIMIZE_NULL,
                        OPTIMIZE_EQUAL };
   enum Type type() const { return FUNC_ITEM; }

sql/item_strfunc.h

@@ -1001,9 +1001,10 @@ class Item_func_dyncol_create: public Item_str_func
 protected:
   DYNCALL_CREATE_DEF *defs;
   DYNAMIC_COLUMN_VALUE *vals;
-  uint *nums;
-  void prepare_arguments();
-  void cleanup_arguments();
+  uint *keys_num;
+  LEX_STRING *keys_str;
+  bool names, force_names;
+  bool prepare_arguments(bool force_names);
   void print_arguments(String *str, enum_query_type query_type);
 public:
   Item_func_dyncol_create(List<Item> &args, DYNCALL_CREATE_DEF *dfs);
@@ -1012,6 +1013,7 @@ public:
   const char *func_name() const{ return "column_create"; }
   String *val_str(String *);
   virtual void print(String *str, enum_query_type query_type);
+  virtual enum Functype functype() const   { return DYNCOL_FUNC; }
 };
 
 
@@ -1026,6 +1028,19 @@ public:
   virtual void print(String *str, enum_query_type query_type);
 };
 
+class Item_func_dyncol_json: public Item_str_func
+{
+public:
+  Item_func_dyncol_json(Item *str) :Item_str_func(str) {}
+  const char *func_name() const{ return "column_json"; }
+  String *val_str(String *);
+  void fix_length_and_dec()
+  {
+    maybe_null= TRUE;
+    collation.set(&my_charset_bin);
+    decimals= 0;
+  }
+};
 
 /*
   The following functions is always called from an Item_cast function
@@ -1036,11 +1051,9 @@ class Item_dyncol_get: public Item_str_func
 public:
   Item_dyncol_get(Item *str, Item *num)
     :Item_str_func(str, num)
-  {
-    max_length= MAX_DYNAMIC_COLUMN_LENGTH;
-  }
+  {}
   void fix_length_and_dec()
-  { maybe_null= 1; }
+  { maybe_null= 1; max_length= MAX_BLOB_WIDTH; }
   /* Mark that collation can change between calls */
   bool dynamic_result() { return 1; }
 
@@ -1067,3 +1080,4 @@ public:
 extern String my_empty_string;
 
 #endif /* ITEM_STRFUNC_INCLUDED */
+

sql/lex.h

@@ -123,11 +123,10 @@ static SYMBOL symbols[] = {
   { "COLUMN_NAME",      SYM(COLUMN_NAME_SYM)},
   { "COLUMNS",		SYM(COLUMNS)},
   { "COLUMN_ADD",       SYM(COLUMN_ADD_SYM)},
+  { "COLUMN_CHECK",     SYM(COLUMN_CHECK_SYM)},
   { "COLUMN_CREATE",    SYM(COLUMN_CREATE_SYM)},
   { "COLUMN_DELETE",    SYM(COLUMN_DELETE_SYM)},
-  { "COLUMN_EXISTS",    SYM(COLUMN_EXISTS_SYM)},
   { "COLUMN_GET",       SYM(COLUMN_GET_SYM)},
-  { "COLUMN_LIST",      SYM(COLUMN_LIST_SYM)},
   { "COMMENT",		SYM(COMMENT_SYM)},
   { "COMMIT",		SYM(COMMIT_SYM)},
   { "COMMITTED",	SYM(COMMITTED_SYM)},

sql/sql_base.cc

@@ -9820,6 +9820,7 @@ int dynamic_column_error_message(enum_dyncol_func_result rc)
   switch (rc) {
   case ER_DYNCOL_YES:
   case ER_DYNCOL_OK:
+  case ER_DYNCOL_TRUNCATED:
     break; // it is not an error
   case ER_DYNCOL_FORMAT:
     my_error(ER_DYN_COL_WRONG_FORMAT, MYF(0));

sql/sql_base.h

@@ -272,6 +272,7 @@ bool rename_temporary_table(THD* thd, TABLE *table, const char *new_db,
 			    const char *table_name);
 bool is_equal(const LEX_STRING *a, const LEX_STRING *b);
 
+class Open_tables_backup;
 /* Functions to work with system tables. */
 bool open_system_tables_for_read(THD *thd, TABLE_LIST *table_list,
                                  Open_tables_backup *backup);

sql/sql_string.cc

@@ -768,79 +768,6 @@ String *copy_if_not_alloced(String *to,String *from,uint32 from_length)
   Help functions
 ****************************************************************************/
 
-/*
-  copy a string from one character set to another
-  
-  SYNOPSIS
-    copy_and_convert()
-    to			Store result here
-    to_cs		Character set of result string
-    from		Copy from here
-    from_length		Length of from string
-    from_cs		From character set
-
-  NOTES
-    'to' must be big enough as form_length * to_cs->mbmaxlen
-
-  RETURN
-    length of bytes copied to 'to'
-*/
-
-
-static uint32
-copy_and_convert_extended(char *to, uint32 to_length, CHARSET_INFO *to_cs, 
-                          const char *from, uint32 from_length,
-                          CHARSET_INFO *from_cs,
-                          uint *errors)
-{
-  int         cnvres;
-  my_wc_t     wc;
-  const uchar *from_end= (const uchar*) from+from_length;
-  char *to_start= to;
-  uchar *to_end= (uchar*) to+to_length;
-  my_charset_conv_mb_wc mb_wc= from_cs->cset->mb_wc;
-  my_charset_conv_wc_mb wc_mb= to_cs->cset->wc_mb;
-  uint error_count= 0;
-
-  while (1)
-  {
-    if ((cnvres= (*mb_wc)(from_cs, &wc, (uchar*) from,
-				      from_end)) > 0)
-      from+= cnvres;
-    else if (cnvres == MY_CS_ILSEQ)
-    {
-      error_count++;
-      from++;
-      wc= '?';
-    }
-    else if (cnvres > MY_CS_TOOSMALL)
-    {
-      /*
-        A correct multibyte sequence detected
-        But it doesn't have Unicode mapping.
-      */
-      error_count++;
-      from+= (-cnvres);
-      wc= '?';
-    }
-    else
-      break;  // Not enough characters
-
-outp:
-    if ((cnvres= (*wc_mb)(to_cs, wc, (uchar*) to, to_end)) > 0)
-      to+= cnvres;
-    else if (cnvres == MY_CS_ILUNI && wc != '?')
-    {
-      error_count++;
-      wc= '?';
-      goto outp;
-    }
-    else
-      break;
-  }
-  *errors= error_count;
-  return (uint32) (to - to_start);
-}
 
 
 /*

sql/sql_yacc.yy

@@ -883,11 +883,10 @@ bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
 %token  COLLATION_SYM                 /* SQL-2003-N */
 %token  COLUMNS
 %token  COLUMN_ADD_SYM
+%token  COLUMN_CHECK_SYM
 %token  COLUMN_CREATE_SYM
 %token  COLUMN_DELETE_SYM
-%token  COLUMN_EXISTS_SYM
 %token  COLUMN_GET_SYM
-%token  COLUMN_LIST_SYM
 %token  COLUMN_SYM                    /* SQL-2003-R */
 %token  COLUMN_NAME_SYM               /* SQL-2003-N */
 %token  COMMENT_SYM
@@ -8403,7 +8402,7 @@ dyncall_create_element:
        alloc_root(YYTHD->mem_root, sizeof(DYNCALL_CREATE_DEF));
      if ($$ == NULL)
        MYSQL_YYABORT;
-     $$->num= $1;
+     $$->key= $1;
      $$->value= $3;
      $$->type= (DYNAMIC_COLUMN_TYPE)$4;
      $$->cs= lex->charset;
@@ -8957,16 +8956,9 @@ function_call_nonkeyword:
               MYSQL_YYABORT;
           }
         |
-          COLUMN_EXISTS_SYM '(' expr ',' expr ')'
+          COLUMN_CHECK_SYM '(' expr ')'
           {
-            $$= new (YYTHD->mem_root) Item_func_dyncol_exists($3, $5);
-            if ($$ == NULL)
-              MYSQL_YYABORT;
-          }
-        |
-          COLUMN_LIST_SYM '(' expr ')'
-          {
-            $$= new (YYTHD->mem_root) Item_func_dyncol_list($3);
+            $$= new (YYTHD->mem_root) Item_func_dyncol_check($3);
             if ($$ == NULL)
               MYSQL_YYABORT;
           }
@@ -13114,11 +13106,10 @@ keyword:
         | CHECKPOINT_SYM        {}
         | CLOSE_SYM             {}
         | COLUMN_ADD_SYM        {}
+        | COLUMN_CHECK_SYM      {}
         | COLUMN_CREATE_SYM     {}
         | COLUMN_DELETE_SYM     {}
-        | COLUMN_EXISTS_SYM     {}
         | COLUMN_GET_SYM        {}
-        | COLUMN_LIST_SYM       {}
         | COMMENT_SYM           {}
         | COMMIT_SYM            {}
         | CONTAINS_SYM          {}

storage/cassandra/CMakeLists.txt

+
+SET(cassandra_sources 
+     ha_cassandra.cc 
+     ha_cassandra.h 
+     cassandra_se.h
+     cassandra_se.cc
+     gen-cpp/Cassandra.cpp
+     gen-cpp/cassandra_types.h 
+     gen-cpp/cassandra_types.cpp
+     gen-cpp/cassandra_constants.h 
+     gen-cpp/cassandra_constants.cpp
+     gen-cpp/Cassandra.h)
+
+#INCLUDE_DIRECTORIES(BEFORE ${Boost_INCLUDE_DIRS})
+
+INCLUDE_DIRECTORIES(AFTER /usr/local/include/thrift)
+#INCLUDE_DIRECTORIES(AFTER /home/buildbot/build/thrift-inst/include/thrift/) 
+#INCLUDE_DIRECTORIES(AFTER /home/psergey/cassandra/thrift/include/thrift/) 
+
+# 
+STRING(REPLACE "-fno-exceptions" "" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
+STRING(REPLACE "-fno-implicit-templates" "" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
+#LINK_DIRECTORIES(/home/psergey/cassandra/thrift/lib)
+
+MYSQL_ADD_PLUGIN(cassandra ${cassandra_sources} STORAGE_ENGINE LINK_LIBRARIES thrift)
+# was: STORAGE_ENGINE MANDATORY 

storage/cassandra/cassandra_se.h

+
+/*
+  This file is a "bridge" interface between cassandra+Thrift and MariaDB.
+
+  It is #included by both sides, so it must itself include neither (including
+  both together causes compile errors due to conflicts).
+*/
+
+struct st_mysql_lex_string;
+typedef struct st_mysql_lex_string LEX_STRING;
+
+/* We need to define this here so that ha_cassandra.cc also has access to it */
+typedef enum
+{
+  ONE = 1-1,
+  QUORUM = 2-1,
+  LOCAL_QUORUM = 3-1,
+  EACH_QUORUM = 4-1,
+  ALL = 5-1,
+  ANY = 6-1,
+  TWO = 7-1,
+  THREE = 8-1,
+} enum_cassandra_consistency_level;
+
+
+class Column_name_enumerator
+{
+public:
+  virtual const char* get_next_name()=0;
+  virtual ~Column_name_enumerator(){}
+};
+
+/*
+  Interface to one cassandra column family, i.e. one 'table'
+*/
+class Cassandra_se_interface
+{
+public:
+  Cassandra_se_interface() { err_buffer[0]=0; }
+
+  virtual ~Cassandra_se_interface(){};
+  /* Init */
+  virtual bool connect(const char *host, int port, const char *keyspace)=0;
+  virtual void set_column_family(const char *cfname) = 0;
+
+  /* Settings */
+  virtual void set_consistency_levels(ulong read_cons_level, ulong write_cons_level)=0;
+
+  /* Check underlying DDL */
+  virtual bool setup_ddl_checks()=0;
+  virtual void first_ddl_column()=0;
+  virtual bool next_ddl_column(char **name, int *name_len, char **value,
+                               int *value_len)=0;
+  virtual void get_rowkey_type(char **name, char **type)=0;
+  virtual size_t get_ddl_size()=0;
+  virtual const char* get_default_validator()=0;
+
+  /* Writes */
+  virtual void clear_insert_buffer()=0;
+  virtual void add_row_deletion(const char *key, int key_len,
+                                Column_name_enumerator *col_names,
+                                LEX_STRING *names, uint nnames)=0;
+  virtual void start_row_insert(const char *key, int key_len)=0;
+  virtual void add_insert_delete_column(const char *name, int name_len)= 0;
+  virtual void add_insert_column(const char *name, int name_len,
+                                 const char *value,
+                                 int value_len)=0;
+  virtual bool do_insert()=0;
+
+  /* Reads */
+  virtual bool get_slice(char *key, size_t key_len, bool *found)=0 ;
+  virtual bool get_next_read_column(char **name, int *name_len,
+                                    char **value, int *value_len)=0;
+  virtual void get_read_rowkey(char **value, int *value_len)=0;
+
+  /* Reads, multi-row scans */
+  int read_batch_size;
+  virtual bool get_range_slices(bool last_key_as_start_key)=0;
+  virtual void finish_reading_range_slices()=0;
+  virtual bool get_next_range_slice_row(bool *eof)=0;
+
+  /* Reads, MRR scans */
+  virtual void new_lookup_keys()=0;
+  virtual int  add_lookup_key(const char *key, size_t key_len)=0;
+  virtual bool multiget_slice()=0;
+  virtual bool get_next_multiget_row()=0;
+
+  /* read_set setup */
+  virtual void clear_read_columns()=0;
+  virtual void clear_read_all_columns()=0;
+  virtual void add_read_column(const char *name)=0;
+
+  virtual bool truncate()=0;
+  virtual bool remove_row()=0;
+
+  /* Passing error messages up to ha_cassandra */
+  char err_buffer[512];
+  const char *error_str() { return err_buffer; }
+  void print_error(const char *format, ...);
+};
+
+
+/* A structure with global counters */
+class Cassandra_status_vars
+{
+public:
+  ulong row_inserts;
+  ulong row_insert_batches;
+
+  ulong multiget_reads;
+  ulong multiget_keys_scanned;
+  ulong multiget_rows_read;
+
+  ulong timeout_exceptions;
+  ulong unavailable_exceptions;
+};
+
+
+extern Cassandra_status_vars cassandra_counters;
+
+
+Cassandra_se_interface *create_cassandra_se();
+

storage/cassandra/gen-cpp/Cassandra_server.skeleton.cpp

+// This autogenerated skeleton file illustrates how to build a server.
+// You should copy it to another filename to avoid overwriting it.
+
+#include "Cassandra.h"
+#include <protocol/TBinaryProtocol.h>
+#include <server/TSimpleServer.h>
+#include <transport/TServerSocket.h>
+#include <transport/TBufferTransports.h>
+
+using namespace ::apache::thrift;
+using namespace ::apache::thrift::protocol;
+using namespace ::apache::thrift::transport;
+using namespace ::apache::thrift::server;
+
+using boost::shared_ptr;
+
+using namespace  ::org::apache::cassandra;
+
+class CassandraHandler : virtual public CassandraIf {
+ public:
+  CassandraHandler() {
+    // Your initialization goes here
+  }
+
+  void login(const AuthenticationRequest& auth_request) {
+    // Your implementation goes here
+    printf("login\n");
+  }
+
+  void set_keyspace(const std::string& keyspace) {
+    // Your implementation goes here
+    printf("set_keyspace\n");
+  }
+
+  void get(ColumnOrSuperColumn& _return, const std::string& key, const ColumnPath& column_path, const ConsistencyLevel::type consistency_level) {
+    // Your implementation goes here
+    printf("get\n");
+  }
+
+  void get_slice(std::vector<ColumnOrSuperColumn> & _return, const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) {
+    // Your implementation goes here
+    printf("get_slice\n");
+  }
+
+  int32_t get_count(const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) {
+    // Your implementation goes here
+    printf("get_count\n");
+  }
+
+  void multiget_slice(std::map<std::string, std::vector<ColumnOrSuperColumn> > & _return, const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) {
+    // Your implementation goes here
+    printf("multiget_slice\n");
+  }
+
+  void multiget_count(std::map<std::string, int32_t> & _return, const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) {
+    // Your implementation goes here
+    printf("multiget_count\n");
+  }
+
+  void get_range_slices(std::vector<KeySlice> & _return, const ColumnParent& column_parent, const SlicePredicate& predicate, const KeyRange& range, const ConsistencyLevel::type consistency_level) {
+    // Your implementation goes here
+    printf("get_range_slices\n");
+  }
+
+  void get_paged_slice(std::vector<KeySlice> & _return, const std::string& column_family, const KeyRange& range, const std::string& start_column, const ConsistencyLevel::type consistency_level) {
+    // Your implementation goes here
+    printf("get_paged_slice\n");
+  }
+
+  void get_indexed_slices(std::vector<KeySlice> & _return, const ColumnParent& column_parent, const IndexClause& index_clause, const SlicePredicate& column_predicate, const ConsistencyLevel::type consistency_level) {
+    // Your implementation goes here
+    printf("get_indexed_slices\n");
+  }
+
+  void insert(const std::string& key, const ColumnParent& column_parent, const Column& column, const ConsistencyLevel::type consistency_level) {
+    // Your implementation goes here
+    printf("insert\n");
+  }
+
+  void add(const std::string& key, const ColumnParent& column_parent, const CounterColumn& column, const ConsistencyLevel::type consistency_level) {
+    // Your implementation goes here
+    printf("add\n");
+  }
+
+  void remove(const std::string& key, const ColumnPath& column_path, const int64_t timestamp, const ConsistencyLevel::type consistency_level) {
+    // Your implementation goes here
+    printf("remove\n");
+  }
+
+  void remove_counter(const std::string& key, const ColumnPath& path, const ConsistencyLevel::type consistency_level) {
+    // Your implementation goes here
+    printf("remove_counter\n");
+  }
+
+  void batch_mutate(const std::map<std::string, std::map<std::string, std::vector<Mutation> > > & mutation_map, const ConsistencyLevel::type consistency_level) {
+    // Your implementation goes here
+    printf("batch_mutate\n");
+  }
+
+  void truncate(const std::string& cfname) {
+    // Your implementation goes here
+    printf("truncate\n");
+  }
+
+  void describe_schema_versions(std::map<std::string, std::vector<std::string> > & _return) {
+    // Your implementation goes here
+    printf("describe_schema_versions\n");
+  }
+
+  void describe_keyspaces(std::vector<KsDef> & _return) {
+    // Your implementation goes here
+    printf("describe_keyspaces\n");
+  }
+
+  void describe_cluster_name(std::string& _return) {
+    // Your implementation goes here
+    printf("describe_cluster_name\n");
+  }
+
+  void describe_version(std::string& _return) {
+    // Your implementation goes here
+    printf("describe_version\n");
+  }
+
+  void describe_ring(std::vector<TokenRange> & _return, const std::string& keyspace) {
+    // Your implementation goes here
+    printf("describe_ring\n");
+  }
+
+  void describe_token_map(std::map<std::string, std::string> & _return) {
+    // Your implementation goes here
+    printf("describe_token_map\n");
+  }
+
+  void describe_partitioner(std::string& _return) {
+    // Your implementation goes here
+    printf("describe_partitioner\n");
+  }
+
+  void describe_snitch(std::string& _return) {
+    // Your implementation goes here
+    printf("describe_snitch\n");
+  }
+
+  void describe_keyspace(KsDef& _return, const std::string& keyspace) {
+    // Your implementation goes here
+    printf("describe_keyspace\n");
+  }
+
+  void describe_splits(std::vector<std::string> & _return, const std::string& cfName, const std::string& start_token, const std::string& end_token, const int32_t keys_per_split) {
+    // Your implementation goes here
+    printf("describe_splits\n");
+  }
+
+  void system_add_column_family(std::string& _return, const CfDef& cf_def) {
+    // Your implementation goes here
+    printf("system_add_column_family\n");
+  }
+
+  void system_drop_column_family(std::string& _return, const std::string& column_family) {
+    // Your implementation goes here
+    printf("system_drop_column_family\n");
+  }
+
+  void system_add_keyspace(std::string& _return, const KsDef& ks_def) {
+    // Your implementation goes here
+    printf("system_add_keyspace\n");
+  }
+
+  void system_drop_keyspace(std::string& _return, const std::string& keyspace) {
+    // Your implementation goes here
+    printf("system_drop_keyspace\n");
+  }
+
+  void system_update_keyspace(std::string& _return, const KsDef& ks_def) {
+    // Your implementation goes here
+    printf("system_update_keyspace\n");
+  }
+
+  void system_update_column_family(std::string& _return, const CfDef& cf_def) {
+    // Your implementation goes here
+    printf("system_update_column_family\n");
+  }
+
+  void execute_cql_query(CqlResult& _return, const std::string& query, const Compression::type compression) {
+    // Your implementation goes here
+    printf("execute_cql_query\n");
+  }
+
+  void prepare_cql_query(CqlPreparedResult& _return, const std::string& query, const Compression::type compression) {
+    // Your implementation goes here
+    printf("prepare_cql_query\n");
+  }
+
+  void execute_prepared_cql_query(CqlResult& _return, const int32_t itemId, const std::vector<std::string> & values) {
+    // Your implementation goes here
+    printf("execute_prepared_cql_query\n");
+  }
+
+  void set_cql_version(const std::string& version) {
+    // Your implementation goes here
+    printf("set_cql_version\n");
+  }
+
+};
+
+int main(int argc, char **argv) {
+  int port = 9090;
+  shared_ptr<CassandraHandler> handler(new CassandraHandler());
+  shared_ptr<TProcessor> processor(new CassandraProcessor(handler));
+  shared_ptr<TServerTransport> serverTransport(new TServerSocket(port));
+  shared_ptr<TTransportFactory> transportFactory(new TBufferedTransportFactory());
+  shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
+
+  TSimpleServer server(processor, serverTransport, transportFactory, protocolFactory);
+  server.serve();
+  return 0;
+}
+

storage/cassandra/gen-cpp/cassandra_constants.cpp

+/**
+ * Autogenerated by Thrift Compiler (0.8.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#include "cassandra_constants.h"
+
+namespace org { namespace apache { namespace cassandra {
+
+const cassandraConstants g_cassandra_constants;
+
+cassandraConstants::cassandraConstants() {
+  cassandra_const_VERSION = (char *)"19.32.0";
+}
+
+}}} // namespace
+

storage/cassandra/gen-cpp/cassandra_constants.h

+/**
+ * Autogenerated by Thrift Compiler (0.8.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#ifndef cassandra_CONSTANTS_H
+#define cassandra_CONSTANTS_H
+
+#include "cassandra_types.h"
+
+namespace org { namespace apache { namespace cassandra {
+
+class cassandraConstants {
+ public:
+  cassandraConstants();
+
+//  std::string VERSION;
+  char*  cassandra_const_VERSION;
+};
+
+extern const cassandraConstants g_cassandra_constants;
+
+}}} // namespace
+
+#endif