cassandra-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jbel...@apache.org
Subject svn commit: r1090905 [1/3] - in /cassandra/trunk: ./ conf/ drivers/py/cql/cassandra/ interface/ interface/thrift/gen-java/org/apache/cassandra/thrift/ src/avro/ src/java/org/apache/cassandra/cli/ src/java/org/apache/cassandra/config/ src/java/org/apach...
Date Sun, 10 Apr 2011 22:59:59 GMT
Author: jbellis
Date: Sun Apr 10 22:59:57 2011
New Revision: 1090905

URL: http://svn.apache.org/viewvc?rev=1090905&view=rev
Log:
push replication_factor into strategy_options
patch by jhermes and jbellis; reviewed by jhanna for CASSANDRA-1263

Modified:
    cassandra/trunk/CHANGES.txt
    cassandra/trunk/conf/schema-sample.txt
    cassandra/trunk/drivers/py/cql/cassandra/Cassandra.py
    cassandra/trunk/drivers/py/cql/cassandra/constants.py
    cassandra/trunk/drivers/py/cql/cassandra/ttypes.py
    cassandra/trunk/interface/cassandra.thrift
    cassandra/trunk/interface/thrift/gen-java/org/apache/cassandra/thrift/Constants.java
    cassandra/trunk/interface/thrift/gen-java/org/apache/cassandra/thrift/KsDef.java
    cassandra/trunk/src/avro/internode.genavro
    cassandra/trunk/src/java/org/apache/cassandra/cli/Cli.g
    cassandra/trunk/src/java/org/apache/cassandra/cli/CliClient.java
    cassandra/trunk/src/java/org/apache/cassandra/cli/CliUserHelp.java
    cassandra/trunk/src/java/org/apache/cassandra/config/DatabaseDescriptor.java
    cassandra/trunk/src/java/org/apache/cassandra/config/KSMetaData.java
    cassandra/trunk/src/java/org/apache/cassandra/cql/CreateKeyspaceStatement.java
    cassandra/trunk/src/java/org/apache/cassandra/cql/QueryProcessor.java
    cassandra/trunk/src/java/org/apache/cassandra/db/migration/AddColumnFamily.java
    cassandra/trunk/src/java/org/apache/cassandra/db/migration/DropColumnFamily.java
    cassandra/trunk/src/java/org/apache/cassandra/db/migration/RenameColumnFamily.java
    cassandra/trunk/src/java/org/apache/cassandra/db/migration/RenameKeyspace.java
    cassandra/trunk/src/java/org/apache/cassandra/db/migration/UpdateKeyspace.java
    cassandra/trunk/src/java/org/apache/cassandra/locator/AbstractReplicationStrategy.java
    cassandra/trunk/src/java/org/apache/cassandra/locator/LocalStrategy.java
    cassandra/trunk/src/java/org/apache/cassandra/locator/NetworkTopologyStrategy.java
    cassandra/trunk/src/java/org/apache/cassandra/locator/OldNetworkTopologyStrategy.java
    cassandra/trunk/src/java/org/apache/cassandra/locator/SimpleStrategy.java
    cassandra/trunk/src/java/org/apache/cassandra/thrift/CassandraServer.java
    cassandra/trunk/test/system/__init__.py
    cassandra/trunk/test/system/test_cql.py
    cassandra/trunk/test/system/test_thrift_server.py
    cassandra/trunk/test/unit/org/apache/cassandra/SchemaLoader.java
    cassandra/trunk/test/unit/org/apache/cassandra/cli/CliTest.java
    cassandra/trunk/test/unit/org/apache/cassandra/config/DatabaseDescriptorTest.java
    cassandra/trunk/test/unit/org/apache/cassandra/db/DefsTest.java
    cassandra/trunk/test/unit/org/apache/cassandra/locator/OldNetworkTopologyStrategyTest.java
    cassandra/trunk/test/unit/org/apache/cassandra/locator/SimpleStrategyTest.java
    cassandra/trunk/test/unit/org/apache/cassandra/service/ConsistencyLevelTest.java
    cassandra/trunk/test/unit/org/apache/cassandra/service/LeaveAndBootstrapTest.java
    cassandra/trunk/test/unit/org/apache/cassandra/service/MoveTest.java

Modified: cassandra/trunk/CHANGES.txt
URL: http://svn.apache.org/viewvc/cassandra/trunk/CHANGES.txt?rev=1090905&r1=1090904&r2=1090905&view=diff
==============================================================================
--- cassandra/trunk/CHANGES.txt (original)
+++ cassandra/trunk/CHANGES.txt Sun Apr 10 22:59:57 2011
@@ -16,7 +16,8 @@
  * Fix clustertool to not throw exception when calling get_endpoints (CASSANDRA-2437)
  * upgrade to thrift 0.6 (CASSANDRA-2412) 
  * repair works on a token range instead of full ring (CASSANDRA-2324)
- * purge tombstone from row cache (CASSANDRA-2305)
+ * purge tombstones from row cache (CASSANDRA-2305)
+ * push replication_factor into strategy_options (CASSANDRA-1263)
 
 
 0.7.5

Modified: cassandra/trunk/conf/schema-sample.txt
URL: http://svn.apache.org/viewvc/cassandra/trunk/conf/schema-sample.txt?rev=1090905&r1=1090904&r2=1090905&view=diff
==============================================================================
--- cassandra/trunk/conf/schema-sample.txt (original)
+++ cassandra/trunk/conf/schema-sample.txt Sun Apr 10 22:59:57 2011
@@ -9,7 +9,7 @@ client and typing "help;"
 */
 
 create keyspace Keyspace1
-    with replication_factor = 1
+    with strategy_options=[{replication_factor:1}]
     and placement_strategy = 'org.apache.cassandra.locator.SimpleStrategy';
 
 use Keyspace1;

Modified: cassandra/trunk/drivers/py/cql/cassandra/Cassandra.py
URL: http://svn.apache.org/viewvc/cassandra/trunk/drivers/py/cql/cassandra/Cassandra.py?rev=1090905&r1=1090904&r2=1090905&view=diff
==============================================================================
--- cassandra/trunk/drivers/py/cql/cassandra/Cassandra.py (original)
+++ cassandra/trunk/drivers/py/cql/cassandra/Cassandra.py Sun Apr 10 22:59:57 2011
@@ -128,52 +128,6 @@ class Iface:
     """
     pass
 
-  def remove(self, key, column_path, timestamp, consistency_level):
-    """
-    Remove data from the row specified by key at the granularity specified by column_path, and the given timestamp. Note
-    that all the values in column_path besides column_path.column_family are truly optional: you can remove the entire
-    row by just specifying the ColumnFamily, or you can remove a SuperColumn or a single Column by specifying those levels too.
-
-    Note that counters have limited support for deletes: if you remove
-    a counter, you must wait to issue any following update until the
-    delete has reached all the nodes and all of them have been fully
-    compacted.
-
-    Parameters:
-     - key
-     - column_path
-     - timestamp
-     - consistency_level
-    """
-    pass
-
-  def batch_mutate(self, mutation_map, consistency_level):
-    """
-      Mutate many columns or super columns for many row keys. See also: Mutation.
-
-      mutation_map maps key to column family to a list of Mutation objects to take place at that scope.
-    *
-
-    Parameters:
-     - mutation_map
-     - consistency_level
-    """
-    pass
-
-  def truncate(self, cfname):
-    """
-    Truncate will mark and entire column family as deleted.
-    From the user's perspective a successful call to truncate will result complete data deletion from cfname.
-    Internally, however, disk space will not be immediatily released, as with all deletes in cassandra, this one
-    only marks the data as deleted.
-    The operation succeeds only if all hosts in the cluster at available and will throw an UnavailableException if
-    some hosts are down.
-
-    Parameters:
-     - cfname
-    """
-    pass
-
   def add(self, key, column_parent, column, consistency_level):
     """
     Increment or decrement a counter.
@@ -186,49 +140,57 @@ class Iface:
     """
     pass
 
-  def get_counter(self, key, path, consistency_level):
+  def remove(self, key, column_path, timestamp, consistency_level):
     """
-    Return the counter at the specified column path.
+    Remove data from the row specified by key at the granularity specified by column_path, and the given timestamp. Note
+    that all the values in column_path besides column_path.column_family are truly optional: you can remove the entire
+    row by just specifying the ColumnFamily, or you can remove a SuperColumn or a single Column by specifying those levels too.
 
     Parameters:
      - key
-     - path
+     - column_path
+     - timestamp
      - consistency_level
     """
     pass
 
-  def get_counter_slice(self, key, column_parent, predicate, consistency_level):
+  def remove_counter(self, key, path, consistency_level):
     """
-    Get a list of counters from the specified columns.
+    Remove a counter at the specified location.
+    Note that counters have limited support for deletes: if you remove a counter, you must wait to issue any following update
+    until the delete has reached all the nodes and all of them have been fully compacted.
 
     Parameters:
      - key
-     - column_parent
-     - predicate
+     - path
      - consistency_level
     """
     pass
 
-  def multiget_counter_slice(self, keys, column_parent, predicate, consistency_level):
+  def batch_mutate(self, mutation_map, consistency_level):
     """
-    Get counter slices from multiple keys.
+      Mutate many columns or super columns for many row keys. See also: Mutation.
+
+      mutation_map maps key to column family to a list of Mutation objects to take place at that scope.
+    *
 
     Parameters:
-     - keys
-     - column_parent
-     - predicate
+     - mutation_map
      - consistency_level
     """
     pass
 
-  def remove_counter(self, key, path, consistency_level):
+  def truncate(self, cfname):
     """
-    Remove a counter at the specified location.
+    Truncate will mark and entire column family as deleted.
+    From the user's perspective a successful call to truncate will result complete data deletion from cfname.
+    Internally, however, disk space will not be immediatily released, as with all deletes in cassandra, this one
+    only marks the data as deleted.
+    The operation succeeds only if all hosts in the cluster at available and will throw an UnavailableException if
+    some hosts are down.
 
     Parameters:
-     - key
-     - path
-     - consistency_level
+     - cfname
     """
     pass
 
@@ -799,17 +761,54 @@ class Client(Iface):
       raise result.te
     return
 
+  def add(self, key, column_parent, column, consistency_level):
+    """
+    Increment or decrement a counter.
+
+    Parameters:
+     - key
+     - column_parent
+     - column
+     - consistency_level
+    """
+    self.send_add(key, column_parent, column, consistency_level)
+    self.recv_add()
+
+  def send_add(self, key, column_parent, column, consistency_level):
+    self._oprot.writeMessageBegin('add', TMessageType.CALL, self._seqid)
+    args = add_args()
+    args.key = key
+    args.column_parent = column_parent
+    args.column = column
+    args.consistency_level = consistency_level
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_add(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = add_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.ire != None:
+      raise result.ire
+    if result.ue != None:
+      raise result.ue
+    if result.te != None:
+      raise result.te
+    return
+
   def remove(self, key, column_path, timestamp, consistency_level):
     """
     Remove data from the row specified by key at the granularity specified by column_path, and the given timestamp. Note
     that all the values in column_path besides column_path.column_family are truly optional: you can remove the entire
     row by just specifying the ColumnFamily, or you can remove a SuperColumn or a single Column by specifying those levels too.
 
-    Note that counters have limited support for deletes: if you remove
-    a counter, you must wait to issue any following update until the
-    delete has reached all the nodes and all of them have been fully
-    compacted.
-
     Parameters:
      - key
      - column_path
@@ -848,6 +847,48 @@ class Client(Iface):
       raise result.te
     return
 
+  def remove_counter(self, key, path, consistency_level):
+    """
+    Remove a counter at the specified location.
+    Note that counters have limited support for deletes: if you remove a counter, you must wait to issue any following update
+    until the delete has reached all the nodes and all of them have been fully compacted.
+
+    Parameters:
+     - key
+     - path
+     - consistency_level
+    """
+    self.send_remove_counter(key, path, consistency_level)
+    self.recv_remove_counter()
+
+  def send_remove_counter(self, key, path, consistency_level):
+    self._oprot.writeMessageBegin('remove_counter', TMessageType.CALL, self._seqid)
+    args = remove_counter_args()
+    args.key = key
+    args.path = path
+    args.consistency_level = consistency_level
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_remove_counter(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = remove_counter_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.ire != None:
+      raise result.ire
+    if result.ue != None:
+      raise result.ue
+    if result.te != None:
+      raise result.te
+    return
+
   def batch_mutate(self, mutation_map, consistency_level):
     """
       Mutate many columns or super columns for many row keys. See also: Mutation.
@@ -928,313 +969,99 @@ class Client(Iface):
       raise result.ue
     return
 
-  def add(self, key, column_parent, column, consistency_level):
+  def describe_schema_versions(self, ):
     """
-    Increment or decrement a counter.
-
-    Parameters:
-     - key
-     - column_parent
-     - column
-     - consistency_level
+    for each schema version present in the cluster, returns a list of nodes at that version.
+    hosts that do not respond will be under the key DatabaseDescriptor.INITIAL_VERSION.
+    the cluster is all on the same version if the size of the map is 1.
     """
-    self.send_add(key, column_parent, column, consistency_level)
-    self.recv_add()
+    self.send_describe_schema_versions()
+    return self.recv_describe_schema_versions()
 
-  def send_add(self, key, column_parent, column, consistency_level):
-    self._oprot.writeMessageBegin('add', TMessageType.CALL, self._seqid)
-    args = add_args()
-    args.key = key
-    args.column_parent = column_parent
-    args.column = column
-    args.consistency_level = consistency_level
+  def send_describe_schema_versions(self, ):
+    self._oprot.writeMessageBegin('describe_schema_versions', TMessageType.CALL, self._seqid)
+    args = describe_schema_versions_args()
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
 
-  def recv_add(self, ):
+  def recv_describe_schema_versions(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = add_result()
+    result = describe_schema_versions_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
+    if result.success != None:
+      return result.success
     if result.ire != None:
       raise result.ire
-    if result.ue != None:
-      raise result.ue
-    if result.te != None:
-      raise result.te
-    return
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "describe_schema_versions failed: unknown result");
 
-  def get_counter(self, key, path, consistency_level):
+  def describe_keyspaces(self, ):
     """
-    Return the counter at the specified column path.
-
-    Parameters:
-     - key
-     - path
-     - consistency_level
+    list the defined keyspaces in this cluster
     """
-    self.send_get_counter(key, path, consistency_level)
-    return self.recv_get_counter()
+    self.send_describe_keyspaces()
+    return self.recv_describe_keyspaces()
 
-  def send_get_counter(self, key, path, consistency_level):
-    self._oprot.writeMessageBegin('get_counter', TMessageType.CALL, self._seqid)
-    args = get_counter_args()
-    args.key = key
-    args.path = path
-    args.consistency_level = consistency_level
+  def send_describe_keyspaces(self, ):
+    self._oprot.writeMessageBegin('describe_keyspaces', TMessageType.CALL, self._seqid)
+    args = describe_keyspaces_args()
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
 
-  def recv_get_counter(self, ):
+  def recv_describe_keyspaces(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = get_counter_result()
+    result = describe_keyspaces_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.success != None:
       return result.success
     if result.ire != None:
       raise result.ire
-    if result.nfe != None:
-      raise result.nfe
-    if result.ue != None:
-      raise result.ue
-    if result.te != None:
-      raise result.te
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "get_counter failed: unknown result");
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "describe_keyspaces failed: unknown result");
 
-  def get_counter_slice(self, key, column_parent, predicate, consistency_level):
+  def describe_cluster_name(self, ):
     """
-    Get a list of counters from the specified columns.
-
-    Parameters:
-     - key
-     - column_parent
-     - predicate
-     - consistency_level
+    get the cluster name
     """
-    self.send_get_counter_slice(key, column_parent, predicate, consistency_level)
-    return self.recv_get_counter_slice()
+    self.send_describe_cluster_name()
+    return self.recv_describe_cluster_name()
 
-  def send_get_counter_slice(self, key, column_parent, predicate, consistency_level):
-    self._oprot.writeMessageBegin('get_counter_slice', TMessageType.CALL, self._seqid)
-    args = get_counter_slice_args()
-    args.key = key
-    args.column_parent = column_parent
-    args.predicate = predicate
-    args.consistency_level = consistency_level
+  def send_describe_cluster_name(self, ):
+    self._oprot.writeMessageBegin('describe_cluster_name', TMessageType.CALL, self._seqid)
+    args = describe_cluster_name_args()
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
 
-  def recv_get_counter_slice(self, ):
+  def recv_describe_cluster_name(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = get_counter_slice_result()
+    result = describe_cluster_name_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.success != None:
       return result.success
-    if result.ire != None:
-      raise result.ire
-    if result.ue != None:
-      raise result.ue
-    if result.te != None:
-      raise result.te
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "get_counter_slice failed: unknown result");
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "describe_cluster_name failed: unknown result");
 
-  def multiget_counter_slice(self, keys, column_parent, predicate, consistency_level):
+  def describe_version(self, ):
     """
-    Get counter slices from multiple keys.
-
-    Parameters:
-     - keys
-     - column_parent
-     - predicate
-     - consistency_level
-    """
-    self.send_multiget_counter_slice(keys, column_parent, predicate, consistency_level)
-    return self.recv_multiget_counter_slice()
-
-  def send_multiget_counter_slice(self, keys, column_parent, predicate, consistency_level):
-    self._oprot.writeMessageBegin('multiget_counter_slice', TMessageType.CALL, self._seqid)
-    args = multiget_counter_slice_args()
-    args.keys = keys
-    args.column_parent = column_parent
-    args.predicate = predicate
-    args.consistency_level = consistency_level
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_multiget_counter_slice(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = multiget_counter_slice_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success != None:
-      return result.success
-    if result.ire != None:
-      raise result.ire
-    if result.ue != None:
-      raise result.ue
-    if result.te != None:
-      raise result.te
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "multiget_counter_slice failed: unknown result");
-
-  def remove_counter(self, key, path, consistency_level):
-    """
-    Remove a counter at the specified location.
-
-    Parameters:
-     - key
-     - path
-     - consistency_level
-    """
-    self.send_remove_counter(key, path, consistency_level)
-    self.recv_remove_counter()
-
-  def send_remove_counter(self, key, path, consistency_level):
-    self._oprot.writeMessageBegin('remove_counter', TMessageType.CALL, self._seqid)
-    args = remove_counter_args()
-    args.key = key
-    args.path = path
-    args.consistency_level = consistency_level
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_remove_counter(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = remove_counter_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.ire != None:
-      raise result.ire
-    if result.ue != None:
-      raise result.ue
-    if result.te != None:
-      raise result.te
-    return
-
-  def describe_schema_versions(self, ):
-    """
-    for each schema version present in the cluster, returns a list of nodes at that version.
-    hosts that do not respond will be under the key DatabaseDescriptor.INITIAL_VERSION.
-    the cluster is all on the same version if the size of the map is 1.
-    """
-    self.send_describe_schema_versions()
-    return self.recv_describe_schema_versions()
-
-  def send_describe_schema_versions(self, ):
-    self._oprot.writeMessageBegin('describe_schema_versions', TMessageType.CALL, self._seqid)
-    args = describe_schema_versions_args()
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_describe_schema_versions(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = describe_schema_versions_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success != None:
-      return result.success
-    if result.ire != None:
-      raise result.ire
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "describe_schema_versions failed: unknown result");
-
-  def describe_keyspaces(self, ):
-    """
-    list the defined keyspaces in this cluster
-    """
-    self.send_describe_keyspaces()
-    return self.recv_describe_keyspaces()
-
-  def send_describe_keyspaces(self, ):
-    self._oprot.writeMessageBegin('describe_keyspaces', TMessageType.CALL, self._seqid)
-    args = describe_keyspaces_args()
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_describe_keyspaces(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = describe_keyspaces_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success != None:
-      return result.success
-    if result.ire != None:
-      raise result.ire
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "describe_keyspaces failed: unknown result");
-
-  def describe_cluster_name(self, ):
-    """
-    get the cluster name
-    """
-    self.send_describe_cluster_name()
-    return self.recv_describe_cluster_name()
-
-  def send_describe_cluster_name(self, ):
-    self._oprot.writeMessageBegin('describe_cluster_name', TMessageType.CALL, self._seqid)
-    args = describe_cluster_name_args()
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-
-  def recv_describe_cluster_name(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = describe_cluster_name_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success != None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "describe_cluster_name failed: unknown result");
-
-  def describe_version(self, ):
-    """
-    get the thrift api version
+    get the thrift api version
     """
     self.send_describe_version()
     return self.recv_describe_version()
@@ -1711,14 +1538,11 @@ class Processor(Iface, TProcessor):
     self._processMap["get_range_slices"] = Processor.process_get_range_slices
     self._processMap["get_indexed_slices"] = Processor.process_get_indexed_slices
     self._processMap["insert"] = Processor.process_insert
+    self._processMap["add"] = Processor.process_add
     self._processMap["remove"] = Processor.process_remove
+    self._processMap["remove_counter"] = Processor.process_remove_counter
     self._processMap["batch_mutate"] = Processor.process_batch_mutate
     self._processMap["truncate"] = Processor.process_truncate
-    self._processMap["add"] = Processor.process_add
-    self._processMap["get_counter"] = Processor.process_get_counter
-    self._processMap["get_counter_slice"] = Processor.process_get_counter_slice
-    self._processMap["multiget_counter_slice"] = Processor.process_multiget_counter_slice
-    self._processMap["remove_counter"] = Processor.process_remove_counter
     self._processMap["describe_schema_versions"] = Processor.process_describe_schema_versions
     self._processMap["describe_keyspaces"] = Processor.process_describe_keyspaces
     self._processMap["describe_cluster_name"] = Processor.process_describe_cluster_name
@@ -1927,58 +1751,6 @@ class Processor(Iface, TProcessor):
     oprot.writeMessageEnd()
     oprot.trans.flush()
 
-  def process_remove(self, seqid, iprot, oprot):
-    args = remove_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = remove_result()
-    try:
-      self._handler.remove(args.key, args.column_path, args.timestamp, args.consistency_level)
-    except InvalidRequestException, ire:
-      result.ire = ire
-    except UnavailableException, ue:
-      result.ue = ue
-    except TimedOutException, te:
-      result.te = te
-    oprot.writeMessageBegin("remove", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_batch_mutate(self, seqid, iprot, oprot):
-    args = batch_mutate_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = batch_mutate_result()
-    try:
-      self._handler.batch_mutate(args.mutation_map, args.consistency_level)
-    except InvalidRequestException, ire:
-      result.ire = ire
-    except UnavailableException, ue:
-      result.ue = ue
-    except TimedOutException, te:
-      result.te = te
-    oprot.writeMessageBegin("batch_mutate", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
-  def process_truncate(self, seqid, iprot, oprot):
-    args = truncate_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = truncate_result()
-    try:
-      self._handler.truncate(args.cfname)
-    except InvalidRequestException, ire:
-      result.ire = ire
-    except UnavailableException, ue:
-      result.ue = ue
-    oprot.writeMessageBegin("truncate", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-
   def process_add(self, seqid, iprot, oprot):
     args = add_args()
     args.read(iprot)
@@ -1997,76 +1769,72 @@ class Processor(Iface, TProcessor):
     oprot.writeMessageEnd()
     oprot.trans.flush()
 
-  def process_get_counter(self, seqid, iprot, oprot):
-    args = get_counter_args()
+  def process_remove(self, seqid, iprot, oprot):
+    args = remove_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = get_counter_result()
+    result = remove_result()
     try:
-      result.success = self._handler.get_counter(args.key, args.path, args.consistency_level)
+      self._handler.remove(args.key, args.column_path, args.timestamp, args.consistency_level)
     except InvalidRequestException, ire:
       result.ire = ire
-    except NotFoundException, nfe:
-      result.nfe = nfe
     except UnavailableException, ue:
       result.ue = ue
     except TimedOutException, te:
       result.te = te
-    oprot.writeMessageBegin("get_counter", TMessageType.REPLY, seqid)
+    oprot.writeMessageBegin("remove", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
 
-  def process_get_counter_slice(self, seqid, iprot, oprot):
-    args = get_counter_slice_args()
+  def process_remove_counter(self, seqid, iprot, oprot):
+    args = remove_counter_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = get_counter_slice_result()
+    result = remove_counter_result()
     try:
-      result.success = self._handler.get_counter_slice(args.key, args.column_parent, args.predicate, args.consistency_level)
+      self._handler.remove_counter(args.key, args.path, args.consistency_level)
     except InvalidRequestException, ire:
       result.ire = ire
     except UnavailableException, ue:
       result.ue = ue
     except TimedOutException, te:
       result.te = te
-    oprot.writeMessageBegin("get_counter_slice", TMessageType.REPLY, seqid)
+    oprot.writeMessageBegin("remove_counter", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
 
-  def process_multiget_counter_slice(self, seqid, iprot, oprot):
-    args = multiget_counter_slice_args()
+  def process_batch_mutate(self, seqid, iprot, oprot):
+    args = batch_mutate_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = multiget_counter_slice_result()
+    result = batch_mutate_result()
     try:
-      result.success = self._handler.multiget_counter_slice(args.keys, args.column_parent, args.predicate, args.consistency_level)
+      self._handler.batch_mutate(args.mutation_map, args.consistency_level)
     except InvalidRequestException, ire:
       result.ire = ire
     except UnavailableException, ue:
       result.ue = ue
     except TimedOutException, te:
       result.te = te
-    oprot.writeMessageBegin("multiget_counter_slice", TMessageType.REPLY, seqid)
+    oprot.writeMessageBegin("batch_mutate", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
 
-  def process_remove_counter(self, seqid, iprot, oprot):
-    args = remove_counter_args()
+  def process_truncate(self, seqid, iprot, oprot):
+    args = truncate_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = remove_counter_result()
+    result = truncate_result()
     try:
-      self._handler.remove_counter(args.key, args.path, args.consistency_level)
+      self._handler.truncate(args.cfname)
     except InvalidRequestException, ire:
       result.ire = ire
     except UnavailableException, ue:
       result.ue = ue
-    except TimedOutException, te:
-      result.te = te
-    oprot.writeMessageBegin("remove_counter", TMessageType.REPLY, seqid)
+    oprot.writeMessageBegin("truncate", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
@@ -4240,536 +4008,24 @@ class insert_result:
   def __ne__(self, other):
     return not (self == other)
 
-class remove_args:
+class add_args:
   """
   Attributes:
    - key
-   - column_path
-   - timestamp
+   - column_parent
+   - column
    - consistency_level
   """
 
   thrift_spec = (
     None, # 0
     (1, TType.STRING, 'key', None, None, ), # 1
-    (2, TType.STRUCT, 'column_path', (ColumnPath, ColumnPath.thrift_spec), None, ), # 2
-    (3, TType.I64, 'timestamp', None, None, ), # 3
+    (2, TType.STRUCT, 'column_parent', (ColumnParent, ColumnParent.thrift_spec), None, ), # 2
+    (3, TType.STRUCT, 'column', (CounterColumn, CounterColumn.thrift_spec), None, ), # 3
     (4, TType.I32, 'consistency_level', None,     1, ), # 4
   )
 
-  def __init__(self, key=None, column_path=None, timestamp=None, consistency_level=thrift_spec[4][4],):
-    self.key = key
-    self.column_path = column_path
-    self.timestamp = timestamp
-    self.consistency_level = consistency_level
-
-  def read(self, iprot):
-    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
-      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
-      return
-    iprot.readStructBegin()
-    while True:
-      (fname, ftype, fid) = iprot.readFieldBegin()
-      if ftype == TType.STOP:
-        break
-      if fid == 1:
-        if ftype == TType.STRING:
-          self.key = iprot.readString();
-        else:
-          iprot.skip(ftype)
-      elif fid == 2:
-        if ftype == TType.STRUCT:
-          self.column_path = ColumnPath()
-          self.column_path.read(iprot)
-        else:
-          iprot.skip(ftype)
-      elif fid == 3:
-        if ftype == TType.I64:
-          self.timestamp = iprot.readI64();
-        else:
-          iprot.skip(ftype)
-      elif fid == 4:
-        if ftype == TType.I32:
-          self.consistency_level = iprot.readI32();
-        else:
-          iprot.skip(ftype)
-      else:
-        iprot.skip(ftype)
-      iprot.readFieldEnd()
-    iprot.readStructEnd()
-
-  def write(self, oprot):
-    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
-      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
-      return
-    oprot.writeStructBegin('remove_args')
-    if self.key != None:
-      oprot.writeFieldBegin('key', TType.STRING, 1)
-      oprot.writeString(self.key)
-      oprot.writeFieldEnd()
-    if self.column_path != None:
-      oprot.writeFieldBegin('column_path', TType.STRUCT, 2)
-      self.column_path.write(oprot)
-      oprot.writeFieldEnd()
-    if self.timestamp != None:
-      oprot.writeFieldBegin('timestamp', TType.I64, 3)
-      oprot.writeI64(self.timestamp)
-      oprot.writeFieldEnd()
-    if self.consistency_level != None:
-      oprot.writeFieldBegin('consistency_level', TType.I32, 4)
-      oprot.writeI32(self.consistency_level)
-      oprot.writeFieldEnd()
-    oprot.writeFieldStop()
-    oprot.writeStructEnd()
-    def validate(self):
-      if self.key is None:
-        raise TProtocol.TProtocolException(message='Required field key is unset!')
-      if self.column_path is None:
-        raise TProtocol.TProtocolException(message='Required field column_path is unset!')
-      if self.timestamp is None:
-        raise TProtocol.TProtocolException(message='Required field timestamp is unset!')
-      return
-
-
-  def __repr__(self):
-    L = ['%s=%r' % (key, value)
-      for key, value in self.__dict__.iteritems()]
-    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
-
-  def __eq__(self, other):
-    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
-
-  def __ne__(self, other):
-    return not (self == other)
-
-class remove_result:
-  """
-  Attributes:
-   - ire
-   - ue
-   - te
-  """
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ), # 1
-    (2, TType.STRUCT, 'ue', (UnavailableException, UnavailableException.thrift_spec), None, ), # 2
-    (3, TType.STRUCT, 'te', (TimedOutException, TimedOutException.thrift_spec), None, ), # 3
-  )
-
-  def __init__(self, ire=None, ue=None, te=None,):
-    self.ire = ire
-    self.ue = ue
-    self.te = te
-
-  def read(self, iprot):
-    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
-      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
-      return
-    iprot.readStructBegin()
-    while True:
-      (fname, ftype, fid) = iprot.readFieldBegin()
-      if ftype == TType.STOP:
-        break
-      if fid == 1:
-        if ftype == TType.STRUCT:
-          self.ire = InvalidRequestException()
-          self.ire.read(iprot)
-        else:
-          iprot.skip(ftype)
-      elif fid == 2:
-        if ftype == TType.STRUCT:
-          self.ue = UnavailableException()
-          self.ue.read(iprot)
-        else:
-          iprot.skip(ftype)
-      elif fid == 3:
-        if ftype == TType.STRUCT:
-          self.te = TimedOutException()
-          self.te.read(iprot)
-        else:
-          iprot.skip(ftype)
-      else:
-        iprot.skip(ftype)
-      iprot.readFieldEnd()
-    iprot.readStructEnd()
-
-  def write(self, oprot):
-    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
-      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
-      return
-    oprot.writeStructBegin('remove_result')
-    if self.ire != None:
-      oprot.writeFieldBegin('ire', TType.STRUCT, 1)
-      self.ire.write(oprot)
-      oprot.writeFieldEnd()
-    if self.ue != None:
-      oprot.writeFieldBegin('ue', TType.STRUCT, 2)
-      self.ue.write(oprot)
-      oprot.writeFieldEnd()
-    if self.te != None:
-      oprot.writeFieldBegin('te', TType.STRUCT, 3)
-      self.te.write(oprot)
-      oprot.writeFieldEnd()
-    oprot.writeFieldStop()
-    oprot.writeStructEnd()
-    def validate(self):
-      return
-
-
-  def __repr__(self):
-    L = ['%s=%r' % (key, value)
-      for key, value in self.__dict__.iteritems()]
-    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
-
-  def __eq__(self, other):
-    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
-
-  def __ne__(self, other):
-    return not (self == other)
-
-class batch_mutate_args:
-  """
-  Attributes:
-   - mutation_map
-   - consistency_level
-  """
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.MAP, 'mutation_map', (TType.STRING,None,TType.MAP,(TType.STRING,None,TType.LIST,(TType.STRUCT,(Mutation, Mutation.thrift_spec)))), None, ), # 1
-    (2, TType.I32, 'consistency_level', None,     1, ), # 2
-  )
-
-  def __init__(self, mutation_map=None, consistency_level=thrift_spec[2][4],):
-    self.mutation_map = mutation_map
-    self.consistency_level = consistency_level
-
-  def read(self, iprot):
-    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
-      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
-      return
-    iprot.readStructBegin()
-    while True:
-      (fname, ftype, fid) = iprot.readFieldBegin()
-      if ftype == TType.STOP:
-        break
-      if fid == 1:
-        if ftype == TType.MAP:
-          self.mutation_map = {}
-          (_ktype149, _vtype150, _size148 ) = iprot.readMapBegin() 
-          for _i152 in xrange(_size148):
-            _key153 = iprot.readString();
-            _val154 = {}
-            (_ktype156, _vtype157, _size155 ) = iprot.readMapBegin() 
-            for _i159 in xrange(_size155):
-              _key160 = iprot.readString();
-              _val161 = []
-              (_etype165, _size162) = iprot.readListBegin()
-              for _i166 in xrange(_size162):
-                _elem167 = Mutation()
-                _elem167.read(iprot)
-                _val161.append(_elem167)
-              iprot.readListEnd()
-              _val154[_key160] = _val161
-            iprot.readMapEnd()
-            self.mutation_map[_key153] = _val154
-          iprot.readMapEnd()
-        else:
-          iprot.skip(ftype)
-      elif fid == 2:
-        if ftype == TType.I32:
-          self.consistency_level = iprot.readI32();
-        else:
-          iprot.skip(ftype)
-      else:
-        iprot.skip(ftype)
-      iprot.readFieldEnd()
-    iprot.readStructEnd()
-
-  def write(self, oprot):
-    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
-      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
-      return
-    oprot.writeStructBegin('batch_mutate_args')
-    if self.mutation_map != None:
-      oprot.writeFieldBegin('mutation_map', TType.MAP, 1)
-      oprot.writeMapBegin(TType.STRING, TType.MAP, len(self.mutation_map))
-      for kiter168,viter169 in self.mutation_map.items():
-        oprot.writeString(kiter168)
-        oprot.writeMapBegin(TType.STRING, TType.LIST, len(viter169))
-        for kiter170,viter171 in viter169.items():
-          oprot.writeString(kiter170)
-          oprot.writeListBegin(TType.STRUCT, len(viter171))
-          for iter172 in viter171:
-            iter172.write(oprot)
-          oprot.writeListEnd()
-        oprot.writeMapEnd()
-      oprot.writeMapEnd()
-      oprot.writeFieldEnd()
-    if self.consistency_level != None:
-      oprot.writeFieldBegin('consistency_level', TType.I32, 2)
-      oprot.writeI32(self.consistency_level)
-      oprot.writeFieldEnd()
-    oprot.writeFieldStop()
-    oprot.writeStructEnd()
-    def validate(self):
-      if self.mutation_map is None:
-        raise TProtocol.TProtocolException(message='Required field mutation_map is unset!')
-      if self.consistency_level is None:
-        raise TProtocol.TProtocolException(message='Required field consistency_level is unset!')
-      return
-
-
-  def __repr__(self):
-    L = ['%s=%r' % (key, value)
-      for key, value in self.__dict__.iteritems()]
-    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
-
-  def __eq__(self, other):
-    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
-
-  def __ne__(self, other):
-    return not (self == other)
-
-class batch_mutate_result:
-  """
-  Attributes:
-   - ire
-   - ue
-   - te
-  """
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ), # 1
-    (2, TType.STRUCT, 'ue', (UnavailableException, UnavailableException.thrift_spec), None, ), # 2
-    (3, TType.STRUCT, 'te', (TimedOutException, TimedOutException.thrift_spec), None, ), # 3
-  )
-
-  def __init__(self, ire=None, ue=None, te=None,):
-    self.ire = ire
-    self.ue = ue
-    self.te = te
-
-  def read(self, iprot):
-    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
-      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
-      return
-    iprot.readStructBegin()
-    while True:
-      (fname, ftype, fid) = iprot.readFieldBegin()
-      if ftype == TType.STOP:
-        break
-      if fid == 1:
-        if ftype == TType.STRUCT:
-          self.ire = InvalidRequestException()
-          self.ire.read(iprot)
-        else:
-          iprot.skip(ftype)
-      elif fid == 2:
-        if ftype == TType.STRUCT:
-          self.ue = UnavailableException()
-          self.ue.read(iprot)
-        else:
-          iprot.skip(ftype)
-      elif fid == 3:
-        if ftype == TType.STRUCT:
-          self.te = TimedOutException()
-          self.te.read(iprot)
-        else:
-          iprot.skip(ftype)
-      else:
-        iprot.skip(ftype)
-      iprot.readFieldEnd()
-    iprot.readStructEnd()
-
-  def write(self, oprot):
-    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
-      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
-      return
-    oprot.writeStructBegin('batch_mutate_result')
-    if self.ire != None:
-      oprot.writeFieldBegin('ire', TType.STRUCT, 1)
-      self.ire.write(oprot)
-      oprot.writeFieldEnd()
-    if self.ue != None:
-      oprot.writeFieldBegin('ue', TType.STRUCT, 2)
-      self.ue.write(oprot)
-      oprot.writeFieldEnd()
-    if self.te != None:
-      oprot.writeFieldBegin('te', TType.STRUCT, 3)
-      self.te.write(oprot)
-      oprot.writeFieldEnd()
-    oprot.writeFieldStop()
-    oprot.writeStructEnd()
-    def validate(self):
-      return
-
-
-  def __repr__(self):
-    L = ['%s=%r' % (key, value)
-      for key, value in self.__dict__.iteritems()]
-    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
-
-  def __eq__(self, other):
-    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
-
-  def __ne__(self, other):
-    return not (self == other)
-
-class truncate_args:
-  """
-  Attributes:
-   - cfname
-  """
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.STRING, 'cfname', None, None, ), # 1
-  )
-
-  def __init__(self, cfname=None,):
-    self.cfname = cfname
-
-  def read(self, iprot):
-    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
-      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
-      return
-    iprot.readStructBegin()
-    while True:
-      (fname, ftype, fid) = iprot.readFieldBegin()
-      if ftype == TType.STOP:
-        break
-      if fid == 1:
-        if ftype == TType.STRING:
-          self.cfname = iprot.readString();
-        else:
-          iprot.skip(ftype)
-      else:
-        iprot.skip(ftype)
-      iprot.readFieldEnd()
-    iprot.readStructEnd()
-
-  def write(self, oprot):
-    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
-      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
-      return
-    oprot.writeStructBegin('truncate_args')
-    if self.cfname != None:
-      oprot.writeFieldBegin('cfname', TType.STRING, 1)
-      oprot.writeString(self.cfname)
-      oprot.writeFieldEnd()
-    oprot.writeFieldStop()
-    oprot.writeStructEnd()
-    def validate(self):
-      if self.cfname is None:
-        raise TProtocol.TProtocolException(message='Required field cfname is unset!')
-      return
-
-
-  def __repr__(self):
-    L = ['%s=%r' % (key, value)
-      for key, value in self.__dict__.iteritems()]
-    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
-
-  def __eq__(self, other):
-    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
-
-  def __ne__(self, other):
-    return not (self == other)
-
-class truncate_result:
-  """
-  Attributes:
-   - ire
-   - ue
-  """
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ), # 1
-    (2, TType.STRUCT, 'ue', (UnavailableException, UnavailableException.thrift_spec), None, ), # 2
-  )
-
-  def __init__(self, ire=None, ue=None,):
-    self.ire = ire
-    self.ue = ue
-
-  def read(self, iprot):
-    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
-      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
-      return
-    iprot.readStructBegin()
-    while True:
-      (fname, ftype, fid) = iprot.readFieldBegin()
-      if ftype == TType.STOP:
-        break
-      if fid == 1:
-        if ftype == TType.STRUCT:
-          self.ire = InvalidRequestException()
-          self.ire.read(iprot)
-        else:
-          iprot.skip(ftype)
-      elif fid == 2:
-        if ftype == TType.STRUCT:
-          self.ue = UnavailableException()
-          self.ue.read(iprot)
-        else:
-          iprot.skip(ftype)
-      else:
-        iprot.skip(ftype)
-      iprot.readFieldEnd()
-    iprot.readStructEnd()
-
-  def write(self, oprot):
-    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
-      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
-      return
-    oprot.writeStructBegin('truncate_result')
-    if self.ire != None:
-      oprot.writeFieldBegin('ire', TType.STRUCT, 1)
-      self.ire.write(oprot)
-      oprot.writeFieldEnd()
-    if self.ue != None:
-      oprot.writeFieldBegin('ue', TType.STRUCT, 2)
-      self.ue.write(oprot)
-      oprot.writeFieldEnd()
-    oprot.writeFieldStop()
-    oprot.writeStructEnd()
-    def validate(self):
-      return
-
-
-  def __repr__(self):
-    L = ['%s=%r' % (key, value)
-      for key, value in self.__dict__.iteritems()]
-    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
-
-  def __eq__(self, other):
-    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
-
-  def __ne__(self, other):
-    return not (self == other)
-
-class add_args:
-  """
-  Attributes:
-   - key
-   - column_parent
-   - column
-   - consistency_level
-  """
-
-  thrift_spec = (
-    None, # 0
-    (1, TType.STRING, 'key', None, None, ), # 1
-    (2, TType.STRUCT, 'column_parent', (ColumnParent, ColumnParent.thrift_spec), None, ), # 2
-    (3, TType.STRUCT, 'column', (CounterColumn, CounterColumn.thrift_spec), None, ), # 3
-    (4, TType.I32, 'consistency_level', None,     1, ), # 4
-  )
-
-  def __init__(self, key=None, column_parent=None, column=None, consistency_level=thrift_spec[4][4],):
+  def __init__(self, key=None, column_parent=None, column=None, consistency_level=thrift_spec[4][4],):
     self.key = key
     self.column_parent = column_parent
     self.column = column
@@ -4943,24 +4199,27 @@ class add_result:
   def __ne__(self, other):
     return not (self == other)
 
-class get_counter_args:
+class remove_args:
   """
   Attributes:
    - key
-   - path
+   - column_path
+   - timestamp
    - consistency_level
   """
 
   thrift_spec = (
     None, # 0
     (1, TType.STRING, 'key', None, None, ), # 1
-    (2, TType.STRUCT, 'path', (ColumnPath, ColumnPath.thrift_spec), None, ), # 2
-    (3, TType.I32, 'consistency_level', None,     1, ), # 3
+    (2, TType.STRUCT, 'column_path', (ColumnPath, ColumnPath.thrift_spec), None, ), # 2
+    (3, TType.I64, 'timestamp', None, None, ), # 3
+    (4, TType.I32, 'consistency_level', None,     1, ), # 4
   )
 
-  def __init__(self, key=None, path=None, consistency_level=thrift_spec[3][4],):
+  def __init__(self, key=None, column_path=None, timestamp=None, consistency_level=thrift_spec[4][4],):
     self.key = key
-    self.path = path
+    self.column_path = column_path
+    self.timestamp = timestamp
     self.consistency_level = consistency_level
 
   def read(self, iprot):
@@ -4979,11 +4238,16 @@ class get_counter_args:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.STRUCT:
-          self.path = ColumnPath()
-          self.path.read(iprot)
+          self.column_path = ColumnPath()
+          self.column_path.read(iprot)
         else:
           iprot.skip(ftype)
       elif fid == 3:
+        if ftype == TType.I64:
+          self.timestamp = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 4:
         if ftype == TType.I32:
           self.consistency_level = iprot.readI32();
         else:
@@ -4997,17 +4261,21 @@ class get_counter_args:
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('get_counter_args')
+    oprot.writeStructBegin('remove_args')
     if self.key != None:
       oprot.writeFieldBegin('key', TType.STRING, 1)
       oprot.writeString(self.key)
       oprot.writeFieldEnd()
-    if self.path != None:
-      oprot.writeFieldBegin('path', TType.STRUCT, 2)
-      self.path.write(oprot)
+    if self.column_path != None:
+      oprot.writeFieldBegin('column_path', TType.STRUCT, 2)
+      self.column_path.write(oprot)
+      oprot.writeFieldEnd()
+    if self.timestamp != None:
+      oprot.writeFieldBegin('timestamp', TType.I64, 3)
+      oprot.writeI64(self.timestamp)
       oprot.writeFieldEnd()
     if self.consistency_level != None:
-      oprot.writeFieldBegin('consistency_level', TType.I32, 3)
+      oprot.writeFieldBegin('consistency_level', TType.I32, 4)
       oprot.writeI32(self.consistency_level)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
@@ -5015,10 +4283,10 @@ class get_counter_args:
     def validate(self):
       if self.key is None:
         raise TProtocol.TProtocolException(message='Required field key is unset!')
-      if self.path is None:
-        raise TProtocol.TProtocolException(message='Required field path is unset!')
-      if self.consistency_level is None:
-        raise TProtocol.TProtocolException(message='Required field consistency_level is unset!')
+      if self.column_path is None:
+        raise TProtocol.TProtocolException(message='Required field column_path is unset!')
+      if self.timestamp is None:
+        raise TProtocol.TProtocolException(message='Required field timestamp is unset!')
       return
 
 
@@ -5033,28 +4301,23 @@ class get_counter_args:
   def __ne__(self, other):
     return not (self == other)
 
-class get_counter_result:
+class remove_result:
   """
   Attributes:
-   - success
    - ire
-   - nfe
    - ue
    - te
   """
 
   thrift_spec = (
-    (0, TType.STRUCT, 'success', (Counter, Counter.thrift_spec), None, ), # 0
+    None, # 0
     (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ), # 1
-    (2, TType.STRUCT, 'nfe', (NotFoundException, NotFoundException.thrift_spec), None, ), # 2
-    (3, TType.STRUCT, 'ue', (UnavailableException, UnavailableException.thrift_spec), None, ), # 3
-    (4, TType.STRUCT, 'te', (TimedOutException, TimedOutException.thrift_spec), None, ), # 4
+    (2, TType.STRUCT, 'ue', (UnavailableException, UnavailableException.thrift_spec), None, ), # 2
+    (3, TType.STRUCT, 'te', (TimedOutException, TimedOutException.thrift_spec), None, ), # 3
   )
 
-  def __init__(self, success=None, ire=None, nfe=None, ue=None, te=None,):
-    self.success = success
+  def __init__(self, ire=None, ue=None, te=None,):
     self.ire = ire
-    self.nfe = nfe
     self.ue = ue
     self.te = te
 
@@ -5067,13 +4330,7 @@ class get_counter_result:
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
-      if fid == 0:
-        if ftype == TType.STRUCT:
-          self.success = Counter()
-          self.success.read(iprot)
-        else:
-          iprot.skip(ftype)
-      elif fid == 1:
+      if fid == 1:
         if ftype == TType.STRUCT:
           self.ire = InvalidRequestException()
           self.ire.read(iprot)
@@ -5081,17 +4338,11 @@ class get_counter_result:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.STRUCT:
-          self.nfe = NotFoundException()
-          self.nfe.read(iprot)
-        else:
-          iprot.skip(ftype)
-      elif fid == 3:
-        if ftype == TType.STRUCT:
           self.ue = UnavailableException()
           self.ue.read(iprot)
         else:
           iprot.skip(ftype)
-      elif fid == 4:
+      elif fid == 3:
         if ftype == TType.STRUCT:
           self.te = TimedOutException()
           self.te.read(iprot)
@@ -5106,25 +4357,17 @@ class get_counter_result:
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('get_counter_result')
-    if self.success != None:
-      oprot.writeFieldBegin('success', TType.STRUCT, 0)
-      self.success.write(oprot)
-      oprot.writeFieldEnd()
+    oprot.writeStructBegin('remove_result')
     if self.ire != None:
-      oprot.writeFieldBegin('ire', TType.STRUCT, 1)
-      self.ire.write(oprot)
-      oprot.writeFieldEnd()
-    if self.nfe != None:
-      oprot.writeFieldBegin('nfe', TType.STRUCT, 2)
-      self.nfe.write(oprot)
+      oprot.writeFieldBegin('ire', TType.STRUCT, 1)
+      self.ire.write(oprot)
       oprot.writeFieldEnd()
     if self.ue != None:
-      oprot.writeFieldBegin('ue', TType.STRUCT, 3)
+      oprot.writeFieldBegin('ue', TType.STRUCT, 2)
       self.ue.write(oprot)
       oprot.writeFieldEnd()
     if self.te != None:
-      oprot.writeFieldBegin('te', TType.STRUCT, 4)
+      oprot.writeFieldBegin('te', TType.STRUCT, 3)
       self.te.write(oprot)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
@@ -5144,27 +4387,24 @@ class get_counter_result:
   def __ne__(self, other):
     return not (self == other)
 
-class get_counter_slice_args:
+class remove_counter_args:
   """
   Attributes:
    - key
-   - column_parent
-   - predicate
+   - path
    - consistency_level
   """
 
   thrift_spec = (
     None, # 0
     (1, TType.STRING, 'key', None, None, ), # 1
-    (2, TType.STRUCT, 'column_parent', (ColumnParent, ColumnParent.thrift_spec), None, ), # 2
-    (3, TType.STRUCT, 'predicate', (SlicePredicate, SlicePredicate.thrift_spec), None, ), # 3
-    (4, TType.I32, 'consistency_level', None,     1, ), # 4
+    (2, TType.STRUCT, 'path', (ColumnPath, ColumnPath.thrift_spec), None, ), # 2
+    (3, TType.I32, 'consistency_level', None,     1, ), # 3
   )
 
-  def __init__(self, key=None, column_parent=None, predicate=None, consistency_level=thrift_spec[4][4],):
+  def __init__(self, key=None, path=None, consistency_level=thrift_spec[3][4],):
     self.key = key
-    self.column_parent = column_parent
-    self.predicate = predicate
+    self.path = path
     self.consistency_level = consistency_level
 
   def read(self, iprot):
@@ -5183,17 +4423,11 @@ class get_counter_slice_args:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.STRUCT:
-          self.column_parent = ColumnParent()
-          self.column_parent.read(iprot)
+          self.path = ColumnPath()
+          self.path.read(iprot)
         else:
           iprot.skip(ftype)
       elif fid == 3:
-        if ftype == TType.STRUCT:
-          self.predicate = SlicePredicate()
-          self.predicate.read(iprot)
-        else:
-          iprot.skip(ftype)
-      elif fid == 4:
         if ftype == TType.I32:
           self.consistency_level = iprot.readI32();
         else:
@@ -5207,21 +4441,17 @@ class get_counter_slice_args:
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('get_counter_slice_args')
+    oprot.writeStructBegin('remove_counter_args')
     if self.key != None:
       oprot.writeFieldBegin('key', TType.STRING, 1)
       oprot.writeString(self.key)
       oprot.writeFieldEnd()
-    if self.column_parent != None:
-      oprot.writeFieldBegin('column_parent', TType.STRUCT, 2)
-      self.column_parent.write(oprot)
-      oprot.writeFieldEnd()
-    if self.predicate != None:
-      oprot.writeFieldBegin('predicate', TType.STRUCT, 3)
-      self.predicate.write(oprot)
+    if self.path != None:
+      oprot.writeFieldBegin('path', TType.STRUCT, 2)
+      self.path.write(oprot)
       oprot.writeFieldEnd()
     if self.consistency_level != None:
-      oprot.writeFieldBegin('consistency_level', TType.I32, 4)
+      oprot.writeFieldBegin('consistency_level', TType.I32, 3)
       oprot.writeI32(self.consistency_level)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
@@ -5229,10 +4459,8 @@ class get_counter_slice_args:
     def validate(self):
       if self.key is None:
         raise TProtocol.TProtocolException(message='Required field key is unset!')
-      if self.column_parent is None:
-        raise TProtocol.TProtocolException(message='Required field column_parent is unset!')
-      if self.predicate is None:
-        raise TProtocol.TProtocolException(message='Required field predicate is unset!')
+      if self.path is None:
+        raise TProtocol.TProtocolException(message='Required field path is unset!')
       if self.consistency_level is None:
         raise TProtocol.TProtocolException(message='Required field consistency_level is unset!')
       return
@@ -5249,24 +4477,22 @@ class get_counter_slice_args:
   def __ne__(self, other):
     return not (self == other)
 
-class get_counter_slice_result:
+class remove_counter_result:
   """
   Attributes:
-   - success
    - ire
    - ue
    - te
   """
 
   thrift_spec = (
-    (0, TType.LIST, 'success', (TType.STRUCT,(Counter, Counter.thrift_spec)), None, ), # 0
+    None, # 0
     (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ), # 1
     (2, TType.STRUCT, 'ue', (UnavailableException, UnavailableException.thrift_spec), None, ), # 2
     (3, TType.STRUCT, 'te', (TimedOutException, TimedOutException.thrift_spec), None, ), # 3
   )
 
-  def __init__(self, success=None, ire=None, ue=None, te=None,):
-    self.success = success
+  def __init__(self, ire=None, ue=None, te=None,):
     self.ire = ire
     self.ue = ue
     self.te = te
@@ -5280,18 +4506,7 @@ class get_counter_slice_result:
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
-      if fid == 0:
-        if ftype == TType.LIST:
-          self.success = []
-          (_etype176, _size173) = iprot.readListBegin()
-          for _i177 in xrange(_size173):
-            _elem178 = Counter()
-            _elem178.read(iprot)
-            self.success.append(_elem178)
-          iprot.readListEnd()
-        else:
-          iprot.skip(ftype)
-      elif fid == 1:
+      if fid == 1:
         if ftype == TType.STRUCT:
           self.ire = InvalidRequestException()
           self.ire.read(iprot)
@@ -5318,14 +4533,7 @@ class get_counter_slice_result:
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('get_counter_slice_result')
-    if self.success != None:
-      oprot.writeFieldBegin('success', TType.LIST, 0)
-      oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter179 in self.success:
-        iter179.write(oprot)
-      oprot.writeListEnd()
-      oprot.writeFieldEnd()
+    oprot.writeStructBegin('remove_counter_result')
     if self.ire != None:
       oprot.writeFieldBegin('ire', TType.STRUCT, 1)
       self.ire.write(oprot)
@@ -5355,27 +4563,21 @@ class get_counter_slice_result:
   def __ne__(self, other):
     return not (self == other)
 
-class multiget_counter_slice_args:
+class batch_mutate_args:
   """
   Attributes:
-   - keys
-   - column_parent
-   - predicate
+   - mutation_map
    - consistency_level
   """
 
   thrift_spec = (
     None, # 0
-    (1, TType.LIST, 'keys', (TType.STRING,None), None, ), # 1
-    (2, TType.STRUCT, 'column_parent', (ColumnParent, ColumnParent.thrift_spec), None, ), # 2
-    (3, TType.STRUCT, 'predicate', (SlicePredicate, SlicePredicate.thrift_spec), None, ), # 3
-    (4, TType.I32, 'consistency_level', None,     1, ), # 4
+    (1, TType.MAP, 'mutation_map', (TType.STRING,None,TType.MAP,(TType.STRING,None,TType.LIST,(TType.STRUCT,(Mutation, Mutation.thrift_spec)))), None, ), # 1
+    (2, TType.I32, 'consistency_level', None,     1, ), # 2
   )
 
-  def __init__(self, keys=None, column_parent=None, predicate=None, consistency_level=thrift_spec[4][4],):
-    self.keys = keys
-    self.column_parent = column_parent
-    self.predicate = predicate
+  def __init__(self, mutation_map=None, consistency_level=thrift_spec[2][4],):
+    self.mutation_map = mutation_map
     self.consistency_level = consistency_level
 
   def read(self, iprot):
@@ -5388,28 +4590,29 @@ class multiget_counter_slice_args:
       if ftype == TType.STOP:
         break
       if fid == 1:
-        if ftype == TType.LIST:
-          self.keys = []
-          (_etype183, _size180) = iprot.readListBegin()
-          for _i184 in xrange(_size180):
-            _elem185 = iprot.readString();
-            self.keys.append(_elem185)
-          iprot.readListEnd()
+        if ftype == TType.MAP:
+          self.mutation_map = {}
+          (_ktype149, _vtype150, _size148 ) = iprot.readMapBegin() 
+          for _i152 in xrange(_size148):
+            _key153 = iprot.readString();
+            _val154 = {}
+            (_ktype156, _vtype157, _size155 ) = iprot.readMapBegin() 
+            for _i159 in xrange(_size155):
+              _key160 = iprot.readString();
+              _val161 = []
+              (_etype165, _size162) = iprot.readListBegin()
+              for _i166 in xrange(_size162):
+                _elem167 = Mutation()
+                _elem167.read(iprot)
+                _val161.append(_elem167)
+              iprot.readListEnd()
+              _val154[_key160] = _val161
+            iprot.readMapEnd()
+            self.mutation_map[_key153] = _val154
+          iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       elif fid == 2:
-        if ftype == TType.STRUCT:
-          self.column_parent = ColumnParent()
-          self.column_parent.read(iprot)
-        else:
-          iprot.skip(ftype)
-      elif fid == 3:
-        if ftype == TType.STRUCT:
-          self.predicate = SlicePredicate()
-          self.predicate.read(iprot)
-        else:
-          iprot.skip(ftype)
-      elif fid == 4:
         if ftype == TType.I32:
           self.consistency_level = iprot.readI32();
         else:
@@ -5423,35 +4626,31 @@ class multiget_counter_slice_args:
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('multiget_counter_slice_args')
-    if self.keys != None:
-      oprot.writeFieldBegin('keys', TType.LIST, 1)
-      oprot.writeListBegin(TType.STRING, len(self.keys))
-      for iter186 in self.keys:
-        oprot.writeString(iter186)
-      oprot.writeListEnd()
-      oprot.writeFieldEnd()
-    if self.column_parent != None:
-      oprot.writeFieldBegin('column_parent', TType.STRUCT, 2)
-      self.column_parent.write(oprot)
-      oprot.writeFieldEnd()
-    if self.predicate != None:
-      oprot.writeFieldBegin('predicate', TType.STRUCT, 3)
-      self.predicate.write(oprot)
+    oprot.writeStructBegin('batch_mutate_args')
+    if self.mutation_map != None:
+      oprot.writeFieldBegin('mutation_map', TType.MAP, 1)
+      oprot.writeMapBegin(TType.STRING, TType.MAP, len(self.mutation_map))
+      for kiter168,viter169 in self.mutation_map.items():
+        oprot.writeString(kiter168)
+        oprot.writeMapBegin(TType.STRING, TType.LIST, len(viter169))
+        for kiter170,viter171 in viter169.items():
+          oprot.writeString(kiter170)
+          oprot.writeListBegin(TType.STRUCT, len(viter171))
+          for iter172 in viter171:
+            iter172.write(oprot)
+          oprot.writeListEnd()
+        oprot.writeMapEnd()
+      oprot.writeMapEnd()
       oprot.writeFieldEnd()
     if self.consistency_level != None:
-      oprot.writeFieldBegin('consistency_level', TType.I32, 4)
+      oprot.writeFieldBegin('consistency_level', TType.I32, 2)
       oprot.writeI32(self.consistency_level)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
     def validate(self):
-      if self.keys is None:
-        raise TProtocol.TProtocolException(message='Required field keys is unset!')
-      if self.column_parent is None:
-        raise TProtocol.TProtocolException(message='Required field column_parent is unset!')
-      if self.predicate is None:
-        raise TProtocol.TProtocolException(message='Required field predicate is unset!')
+      if self.mutation_map is None:
+        raise TProtocol.TProtocolException(message='Required field mutation_map is unset!')
       if self.consistency_level is None:
         raise TProtocol.TProtocolException(message='Required field consistency_level is unset!')
       return
@@ -5468,24 +4667,22 @@ class multiget_counter_slice_args:
   def __ne__(self, other):
     return not (self == other)
 
-class multiget_counter_slice_result:
+class batch_mutate_result:
   """
   Attributes:
-   - success
    - ire
    - ue
    - te
   """
 
   thrift_spec = (
-    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Counter, Counter.thrift_spec))), None, ), # 0
+    None, # 0
     (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ), # 1
     (2, TType.STRUCT, 'ue', (UnavailableException, UnavailableException.thrift_spec), None, ), # 2
     (3, TType.STRUCT, 'te', (TimedOutException, TimedOutException.thrift_spec), None, ), # 3
   )
 
-  def __init__(self, success=None, ire=None, ue=None, te=None,):
-    self.success = success
+  def __init__(self, ire=None, ue=None, te=None,):
     self.ire = ire
     self.ue = ue
     self.te = te
@@ -5499,24 +4696,7 @@ class multiget_counter_slice_result:
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
-      if fid == 0:
-        if ftype == TType.MAP:
-          self.success = {}
-          (_ktype188, _vtype189, _size187 ) = iprot.readMapBegin() 
-          for _i191 in xrange(_size187):
-            _key192 = iprot.readString();
-            _val193 = []
-            (_etype197, _size194) = iprot.readListBegin()
-            for _i198 in xrange(_size194):
-              _elem199 = Counter()
-              _elem199.read(iprot)
-              _val193.append(_elem199)
-            iprot.readListEnd()
-            self.success[_key192] = _val193
-          iprot.readMapEnd()
-        else:
-          iprot.skip(ftype)
-      elif fid == 1:
+      if fid == 1:
         if ftype == TType.STRUCT:
           self.ire = InvalidRequestException()
           self.ire.read(iprot)
@@ -5543,18 +4723,7 @@ class multiget_counter_slice_result:
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('multiget_counter_slice_result')
-    if self.success != None:
-      oprot.writeFieldBegin('success', TType.MAP, 0)
-      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
-      for kiter200,viter201 in self.success.items():
-        oprot.writeString(kiter200)
-        oprot.writeListBegin(TType.STRUCT, len(viter201))
-        for iter202 in viter201:
-          iter202.write(oprot)
-        oprot.writeListEnd()
-      oprot.writeMapEnd()
-      oprot.writeFieldEnd()
+    oprot.writeStructBegin('batch_mutate_result')
     if self.ire != None:
       oprot.writeFieldBegin('ire', TType.STRUCT, 1)
       self.ire.write(oprot)
@@ -5584,25 +4753,19 @@ class multiget_counter_slice_result:
   def __ne__(self, other):
     return not (self == other)
 
-class remove_counter_args:
+class truncate_args:
   """
   Attributes:
-   - key
-   - path
-   - consistency_level
+   - cfname
   """
 
   thrift_spec = (
     None, # 0
-    (1, TType.STRING, 'key', None, None, ), # 1
-    (2, TType.STRUCT, 'path', (ColumnPath, ColumnPath.thrift_spec), None, ), # 2
-    (3, TType.I32, 'consistency_level', None,     1, ), # 3
+    (1, TType.STRING, 'cfname', None, None, ), # 1
   )
 
-  def __init__(self, key=None, path=None, consistency_level=thrift_spec[3][4],):
-    self.key = key
-    self.path = path
-    self.consistency_level = consistency_level
+  def __init__(self, cfname=None,):
+    self.cfname = cfname
 
   def read(self, iprot):
     if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
@@ -5615,18 +4778,7 @@ class remove_counter_args:
         break
       if fid == 1:
         if ftype == TType.STRING:
-          self.key = iprot.readString();
-        else:
-          iprot.skip(ftype)
-      elif fid == 2:
-        if ftype == TType.STRUCT:
-          self.path = ColumnPath()
-          self.path.read(iprot)
-        else:
-          iprot.skip(ftype)
-      elif fid == 3:
-        if ftype == TType.I32:
-          self.consistency_level = iprot.readI32();
+          self.cfname = iprot.readString();
         else:
           iprot.skip(ftype)
       else:
@@ -5638,28 +4790,16 @@ class remove_counter_args:
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('remove_counter_args')
-    if self.key != None:
-      oprot.writeFieldBegin('key', TType.STRING, 1)
-      oprot.writeString(self.key)
-      oprot.writeFieldEnd()
-    if self.path != None:
-      oprot.writeFieldBegin('path', TType.STRUCT, 2)
-      self.path.write(oprot)
-      oprot.writeFieldEnd()
-    if self.consistency_level != None:
-      oprot.writeFieldBegin('consistency_level', TType.I32, 3)
-      oprot.writeI32(self.consistency_level)
+    oprot.writeStructBegin('truncate_args')
+    if self.cfname != None:
+      oprot.writeFieldBegin('cfname', TType.STRING, 1)
+      oprot.writeString(self.cfname)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
     def validate(self):
-      if self.key is None:
-        raise TProtocol.TProtocolException(message='Required field key is unset!')
-      if self.path is None:
-        raise TProtocol.TProtocolException(message='Required field path is unset!')
-      if self.consistency_level is None:
-        raise TProtocol.TProtocolException(message='Required field consistency_level is unset!')
+      if self.cfname is None:
+        raise TProtocol.TProtocolException(message='Required field cfname is unset!')
       return
 
 
@@ -5674,25 +4814,22 @@ class remove_counter_args:
   def __ne__(self, other):
     return not (self == other)
 
-class remove_counter_result:
+class truncate_result:
   """
   Attributes:
    - ire
    - ue
-   - te
   """
 
   thrift_spec = (
     None, # 0
     (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ), # 1
     (2, TType.STRUCT, 'ue', (UnavailableException, UnavailableException.thrift_spec), None, ), # 2
-    (3, TType.STRUCT, 'te', (TimedOutException, TimedOutException.thrift_spec), None, ), # 3
   )
 
-  def __init__(self, ire=None, ue=None, te=None,):
+  def __init__(self, ire=None, ue=None,):
     self.ire = ire
     self.ue = ue
-    self.te = te
 
   def read(self, iprot):
     if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
@@ -5715,12 +4852,6 @@ class remove_counter_result:
           self.ue.read(iprot)
         else:
           iprot.skip(ftype)
-      elif fid == 3:
-        if ftype == TType.STRUCT:
-          self.te = TimedOutException()
-          self.te.read(iprot)
-        else:
-          iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       iprot.readFieldEnd()
@@ -5730,7 +4861,7 @@ class remove_counter_result:
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('remove_counter_result')
+    oprot.writeStructBegin('truncate_result')
     if self.ire != None:
       oprot.writeFieldBegin('ire', TType.STRUCT, 1)
       self.ire.write(oprot)
@@ -5739,10 +4870,6 @@ class remove_counter_result:
       oprot.writeFieldBegin('ue', TType.STRUCT, 2)
       self.ue.write(oprot)
       oprot.writeFieldEnd()
-    if self.te != None:
-      oprot.writeFieldBegin('te', TType.STRUCT, 3)
-      self.te.write(oprot)
-      oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
     def validate(self):
@@ -5829,16 +4956,16 @@ class describe_schema_versions_result:
       if fid == 0:
         if ftype == TType.MAP:
           self.success = {}
-          (_ktype204, _vtype205, _size203 ) = iprot.readMapBegin() 
-          for _i207 in xrange(_size203):
-            _key208 = iprot.readString();
-            _val209 = []
-            (_etype213, _size210) = iprot.readListBegin()
-            for _i214 in xrange(_size210):
-              _elem215 = iprot.readString();
-              _val209.append(_elem215)
+          (_ktype174, _vtype175, _size173 ) = iprot.readMapBegin() 
+          for _i177 in xrange(_size173):
+            _key178 = iprot.readString();
+            _val179 = []
+            (_etype183, _size180) = iprot.readListBegin()
+            for _i184 in xrange(_size180):
+              _elem185 = iprot.readString();
+              _val179.append(_elem185)
             iprot.readListEnd()
-            self.success[_key208] = _val209
+            self.success[_key178] = _val179
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
@@ -5861,11 +4988,11 @@ class describe_schema_versions_result:
     if self.success != None:
       oprot.writeFieldBegin('success', TType.MAP, 0)
       oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
-      for kiter216,viter217 in self.success.items():
-        oprot.writeString(kiter216)
-        oprot.writeListBegin(TType.STRING, len(viter217))
-        for iter218 in viter217:
-          oprot.writeString(iter218)
+      for kiter186,viter187 in self.success.items():
+        oprot.writeString(kiter186)
+        oprot.writeListBegin(TType.STRING, len(viter187))
+        for iter188 in viter187:
+          oprot.writeString(iter188)
         oprot.writeListEnd()
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
@@ -5959,11 +5086,11 @@ class describe_keyspaces_result:
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype222, _size219) = iprot.readListBegin()
-          for _i223 in xrange(_size219):
-            _elem224 = KsDef()
-            _elem224.read(iprot)
-            self.success.append(_elem224)
+          (_etype192, _size189) = iprot.readListBegin()
+          for _i193 in xrange(_size189):
+            _elem194 = KsDef()
+            _elem194.read(iprot)
+            self.success.append(_elem194)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
@@ -5986,8 +5113,8 @@ class describe_keyspaces_result:
     if self.success != None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter225 in self.success:
-        iter225.write(oprot)
+      for iter195 in self.success:
+        iter195.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ire != None:
@@ -6298,11 +5425,11 @@ class describe_ring_result:
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype229, _size226) = iprot.readListBegin()
-          for _i230 in xrange(_size226):
-            _elem231 = TokenRange()
-            _elem231.read(iprot)
-            self.success.append(_elem231)
+          (_etype199, _size196) = iprot.readListBegin()
+          for _i200 in xrange(_size196):
+            _elem201 = TokenRange()
+            _elem201.read(iprot)
+            self.success.append(_elem201)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
@@ -6325,8 +5452,8 @@ class describe_ring_result:
     if self.success != None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter232 in self.success:
-        iter232.write(oprot)
+      for iter202 in self.success:
+        iter202.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ire != None:
@@ -6825,10 +5952,10 @@ class describe_splits_result:
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype236, _size233) = iprot.readListBegin()
-          for _i237 in xrange(_size233):
-            _elem238 = iprot.readString();
-            self.success.append(_elem238)
+          (_etype206, _size203) = iprot.readListBegin()
+          for _i207 in xrange(_size203):
+            _elem208 = iprot.readString();
+            self.success.append(_elem208)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
@@ -6851,8 +5978,8 @@ class describe_splits_result:
     if self.success != None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRING, len(self.success))
-      for iter239 in self.success:
-        oprot.writeString(iter239)
+      for iter209 in self.success:
+        oprot.writeString(iter209)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ire != None:

Modified: cassandra/trunk/drivers/py/cql/cassandra/constants.py
URL: http://svn.apache.org/viewvc/cassandra/trunk/drivers/py/cql/cassandra/constants.py?rev=1090905&r1=1090904&r2=1090905&view=diff
==============================================================================
--- cassandra/trunk/drivers/py/cql/cassandra/constants.py (original)
+++ cassandra/trunk/drivers/py/cql/cassandra/constants.py Sun Apr 10 22:59:57 2011
@@ -7,4 +7,4 @@
 from thrift.Thrift import *
 from ttypes import *
 
-VERSION = "19.5.0"
+VERSION = "20.0.0"



Mime
View raw message