cassandra 0.13.0 → 0.14.0

data/conf/1.0/log4j-server.properties

@@ -0,0 +1,40 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# for production, you should probably set pattern to %c instead of %l.
+# (%l is slower.)
+
+# output messages into a rolling log file as well as stdout
+log4j.rootLogger=INFO,stdout,R
+
+# stdout
+log4j.appender.stdout=org.apache.log4j.ConsoleAppender
+log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
+log4j.appender.stdout.layout.ConversionPattern=%5p %d{HH:mm:ss,SSS} %m%n
+
+# rolling log file
+log4j.appender.R=org.apache.log4j.RollingFileAppender
+log4j.appender.R.maxFileSize=20MB
+log4j.appender.R.maxBackupIndex=50
+log4j.appender.R.layout=org.apache.log4j.PatternLayout
+log4j.appender.R.layout.ConversionPattern=%5p [%t] %d{ISO8601} %F (line %L) %m%n
+# Edit the next line to point to your logs directory
+log4j.appender.R.File=data/logs/system.log
+
+# Application logging options
+#log4j.logger.org.apache.cassandra=DEBUG
+#log4j.logger.org.apache.cassandra.db=DEBUG
+#log4j.logger.org.apache.cassandra.service.StorageProxy=DEBUG

data/conf/1.0/schema.json

@@ -0,0 +1,72 @@
+{"Twitter":{
+    "Users":{
+      "comparator_type":"org.apache.cassandra.db.marshal.UTF8Type",
+      "column_type":"Standard"},
+    "UserAudits":{
+      "comparator_type":"org.apache.cassandra.db.marshal.UTF8Type",
+      "column_type":"Standard"},
+    "UserCounters":{
+      "comparator_type":"org.apache.cassandra.db.marshal.UTF8Type",
+      "column_type":"Standard",
+      "default_validation_class":"CounterColumnType"},
+    "UserCounterAggregates":{
+      "subcomparator_type":"org.apache.cassandra.db.marshal.UTF8Type",
+      "comparator_type":"org.apache.cassandra.db.marshal.UTF8Type",
+      "column_type":"Super",
+      "default_validation_class":"CounterColumnType"},
+    "UserRelationships":{
+      "subcomparator_type":"org.apache.cassandra.db.marshal.TimeUUIDType",
+      "comparator_type":"org.apache.cassandra.db.marshal.UTF8Type",
+      "column_type":"Super"},
+    "Usernames":{
+      "comparator_type":"org.apache.cassandra.db.marshal.UTF8Type",
+      "column_type":"Standard"},
+    "Statuses":{
+      "comparator_type":"org.apache.cassandra.db.marshal.UTF8Type",
+      "column_type":"Standard"},
+    "StatusAudits":{
+      "comparator_type":"org.apache.cassandra.db.marshal.UTF8Type",
+      "column_type":"Standard"},
+    "StatusRelationships":{
+      "subcomparator_type":"org.apache.cassandra.db.marshal.TimeUUIDType",
+      "comparator_type":"org.apache.cassandra.db.marshal.UTF8Type",
+      "column_type":"Super"},
+    "Indexes":{
+      "comparator_type":"org.apache.cassandra.db.marshal.UTF8Type",
+      "column_type":"Super"},
+    "TimelinishThings":{
+      "comparator_type":"org.apache.cassandra.db.marshal.BytesType",
+      "column_type":"Standard"}
+  },
+"Multiblog":{
+    "Blogs":{
+      "comparator_type":"org.apache.cassandra.db.marshal.TimeUUIDType",
+      "column_type":"Standard"},
+    "Comments":{
+      "comparator_type":"org.apache.cassandra.db.marshal.TimeUUIDType",
+      "column_type":"Standard"}
+  },
+"MultiblogLong":{
+    "Blogs":{
+      "comparator_type":"org.apache.cassandra.db.marshal.LongType",
+      "column_type":"Standard"},
+    "Comments":{
+      "comparator_type":"org.apache.cassandra.db.marshal.LongType",
+      "column_type":"Standard"}
+  },
+"TypeConversions":{
+    "UUIDColumnConversion":{
+      "comparator_type":"org.apache.cassandra.db.marshal.TimeUUIDType",
+      "column_type":"Standard"},
+    "SuperUUID":{
+      "subcomparator_type":"org.apache.cassandra.db.marshal.TimeUUIDType",
+      "comparator_type":"org.apache.cassandra.db.marshal.TimeUUIDType",
+      "column_type":"Super"},
+    "CompositeColumnConversion":{
+      "comparator_type":"org.apache.cassandra.db.marshal.CompositeType(org.apache.cassandra.db.marshal.IntegerType,org.apache.cassandra.db.marshal.UTF8Type)",
+      "column_type":"Standard"},
+    "DynamicComposite":{
+      "comparator_type":"org.apache.cassandra.db.marshal.DynamicCompositeType(u=>org.apache.cassandra.db.marshal.UUIDType,t=>org.apache.cassandra.db.marshal.TimeUUIDType,s=>org.apache.cassandra.db.marshal.UTF8Type,b=>org.apache.cassandra.db.marshal.BytesType,a=>org.apache.cassandra.db.marshal.AsciiType,l=>org.apache.cassandra.db.marshal.LongType,x=>org.apache.cassandra.db.marshal.LexicalUUIDType,i=>org.apache.cassandra.db.marshal.IntegerType)",
+      "column_type":"Standard"}
+  }
+}

data/conf/1.0/schema.txt

@@ -0,0 +1,57 @@
+create keyspace Twitter with
+  placement_strategy = 'org.apache.cassandra.locator.SimpleStrategy' AND
+  strategy_options = {replication_factor:1};
+use Twitter;
+create column family Users with comparator = 'UTF8Type';
+create column family UserAudits with comparator = 'UTF8Type';
+create column family UserCounters with comparator = 'UTF8Type' and
+  default_validation_class = CounterColumnType;
+create column family UserCounterAggregates with column_type = 'Super'
+  and comparator = 'UTF8Type' and
+  subcomparator = 'UTF8Type' and
+  default_validation_class = CounterColumnType;
+create column family UserRelationships with
+  comparator = 'UTF8Type' and
+  column_type = 'Super' and
+  subcomparator = 'TimeUUIDType';
+create column family Usernames with comparator = 'UTF8Type';
+create column family Statuses
+  with comparator = 'UTF8Type'
+  and column_metadata = [
+    {column_name: 'tags', validation_class: 'BytesType', index_type: 'KEYS'}
+  ];
+create column family StatusAudits with comparator = 'UTF8Type';
+create column family StatusRelationships with
+  comparator = 'UTF8Type' and
+  column_type = 'Super' and
+  subcomparator = 'TimeUUIDType';
+create column family Indexes with
+  comparator = 'UTF8Type' and
+  column_type = 'Super';
+create column family TimelinishThings with
+  comparator = 'BytesType';
+
+create keyspace Multiblog with
+  placement_strategy = 'org.apache.cassandra.locator.SimpleStrategy' AND
+  strategy_options = {replication_factor:1};
+use Multiblog;
+create column family Blogs with comparator = 'TimeUUIDType';
+create column family Comments with comparator = 'TimeUUIDType';
+
+
+create keyspace MultiblogLong with
+  placement_strategy = 'org.apache.cassandra.locator.SimpleStrategy' AND
+  strategy_options = {replication_factor:1};
+use MultiblogLong;
+create column family Blogs with comparator = 'LongType';
+create column family Comments with comparator = 'LongType';
+
+create keyspace TypeConversions with
+  placement_strategy = 'org.apache.cassandra.locator.SimpleStrategy' AND
+  strategy_options = {replication_factor:1};
+use TypeConversions;
+create column family UUIDColumnConversion with comparator = TimeUUIDType;
+create column family SuperUUID with comparator = TimeUUIDType and column_type = Super;
+create column family CompositeColumnConversion with comparator = 'CompositeType(IntegerType, UTF8Type)';
+create column family DynamicComposite with comparator ='DynamicCompositeType
+   (a=>AsciiType,b=>BytesType,i=>IntegerType,x=>LexicalUUIDType,l=>LongType,t=>TimeUUIDType,s=>UTF8Type,u=>UUIDType)';

data/ext/cassandra_native.c

@@ -0,0 +1,34 @@
+#include <ruby.h>
+#include <arpa/inet.h>
+
+VALUE parts_ivar_id;
+
+VALUE rb_cassandra_composite_fast_unpack(VALUE self, VALUE packed_string_value) {
+  int i = 0;
+  int index = 0;
+  int message_length = RSTRING_LEN(packed_string_value);
+  char *packed_string = (char *)RSTRING_PTR(packed_string_value);
+
+  VALUE parts = rb_ary_new();
+  while (index < message_length) {
+    uint16_t length = ntohs(((uint16_t *)(packed_string+index))[0]);
+    VALUE part = rb_str_new("", length);
+    for (i = 0; i < length; i++) {
+      ((char *)RSTRING_PTR(part))[i] = packed_string[index+2+i];
+    }
+    rb_ary_push(parts, part);
+    index += length + 3;
+  }
+
+  rb_ivar_set(self, parts_ivar_id, parts);
+
+  return Qnil;
+}
+
+void Init_cassandra_native(void) {
+  VALUE cassandra_module = rb_const_get(rb_cObject, rb_intern("Cassandra"));
+  VALUE cassandra_composite_class = rb_define_class_under(cassandra_module, "Composite", rb_cObject);
+  rb_define_method(cassandra_composite_class, "fast_unpack", rb_cassandra_composite_fast_unpack, 1);
+
+  parts_ivar_id = rb_intern("@parts");
+}

data/ext/extconf.rb

@@ -0,0 +1,9 @@
+if defined?(RUBY_ENGINE) && RUBY_ENGINE =~ /jruby/
+  File.open('Makefile', 'w'){|f| f.puts "all:\n\ninstall:\n" }
+else
+  require 'mkmf'
+
+  $CFLAGS = "-g -O2 -Wall -Werror"
+
+  create_makefile 'cassandra_native'
+end

data/lib/cassandra.rb

@@ -24,6 +24,7 @@ require 'cassandra/time'
 require 'cassandra/comparable'
 require 'cassandra/long'
 require 'cassandra/composite'
+require 'cassandra/dynamic_composite'
 require 'cassandra/ordered_hash'
 require 'cassandra/columns'
 require 'cassandra/protocol'

data/lib/cassandra/0.6/protocol.rb

@@ -12,7 +12,7 @@ class Cassandra
       client.remove(@keyspace, key, column_path, timestamp, consistency_level)
     end
 
-    def _count_columns(column_family, key, super_column, consistency)
+    def _count_columns(column_family, key, super_column, start, stop, count, consistency)
       client.get_count(@keyspace, key,
         CassandraThrift::ColumnParent.new(:column_family => column_family, :super_column => super_column),
         consistency
@@ -55,11 +55,11 @@ class Cassandra
 
       # Slices
       else
-        predicate = CassandraThrift::SlicePredicate.new(:slice_range => 
+        predicate = CassandraThrift::SlicePredicate.new(:slice_range =>
           CassandraThrift::SliceRange.new(
-            :reversed => reversed, 
-            :count => count, 
-            :start => start, 
+            :reversed => reversed,
+            :count => count,
+            :start => start,
             :finish => finish))
 
         if is_super(column_family) and column
@@ -72,16 +72,17 @@ class Cassandra
       end
     end
 
-    def _get_range(column_family, start_key, finish_key, key_count, columns, start, finish, count, consistency)
+    def _get_range(column_family, start_key, finish_key, key_count, columns, start, finish, count, consistency, reversed=false)
       column_parent = CassandraThrift::ColumnParent.new(:column_family => column_family)
       predicate = if columns
                     CassandraThrift::SlicePredicate.new(:column_names => columns)
                   else
-                    CassandraThrift::SlicePredicate.new(:slice_range => 
+                    CassandraThrift::SlicePredicate.new(:slice_range =>
                       CassandraThrift::SliceRange.new(
-                        :start  => start, 
+                        :start  => start,
                         :finish => finish,
-                        :count  => count))
+                        :count  => count,
+                        :reversed => reversed))
                   end
       range = CassandraThrift::KeyRange.new(:start_key => start_key, :end_key => finish_key, :count => key_count)
       client.get_range_slices(@keyspace, column_parent, predicate, range, consistency)

data/lib/cassandra/cassandra.rb

@@ -3,7 +3,7 @@
 Create a new Cassandra client instance. Accepts a keyspace name, and optional host and port.
 
   client = Cassandra.new('twitter', '127.0.0.1:9160')
-  
+
 If the server requires authentication, you must authenticate before make calls
 
   client.login!('username','password')
@@ -64,6 +64,8 @@ class Cassandra
     :thrift_client_class  => ThriftClient
   }
 
+  THRIFT_DEFAULTS[:protocol] = Thrift::BinaryProtocolAccelerated if Thrift.const_defined?(:BinaryProtocolAccelerated)
+
   attr_reader :keyspace, :servers, :schema, :thrift_client_options, :thrift_client_class, :auth_request
 
   def self.DEFAULT_TRANSPORT_WRAPPER
@@ -75,6 +77,8 @@ class Cassandra
     @is_super = {}
     @column_name_class = {}
     @sub_column_name_class = {}
+    @column_name_maker = {}
+    @sub_column_name_maker = {}
     @auto_discover_nodes = true
     thrift_client_options[:transport_wrapper] ||= Cassandra.DEFAULT_TRANSPORT_WRAPPER
     @thrift_client_options = THRIFT_DEFAULTS.merge(thrift_client_options)
@@ -462,7 +466,7 @@ class Cassandra
 
   ##
   # This method is used to delete (actually marking them as deleted with a
-  # tombstone)  rows, columns, or super columns depending on the parameters 
+  # tombstone)  rows, columns, or super columns depending on the parameters
   # passed.  If only a key is passed the entire row will be marked as deleted.
   # If a column name is passed in that column will be deleted.
   #
@@ -483,14 +487,14 @@ class Cassandra
     column_family, column, sub_column, options = extract_and_validate_params(column_family, key, columns_and_options, WRITE_DEFAULTS)
 
     if @batch
-      mutation_map = 
+      mutation_map =
         {
           key => {
             column_family => [ _delete_mutation(column_family, column, sub_column, options[:timestamp]|| Time.stamp) ]
           }
         }
       @batch << [mutation_map, options[:consistency]]
-    else 
+    else
       # Let's continue using the 'remove' thrift method...not sure about the implications/performance of using the mutate instead
       # Otherwise we coul get use the mutation_map above, and do _mutate(mutation_map, options[:consistency])
       args = {:column_family => column_family}
@@ -514,8 +518,8 @@ class Cassandra
   #   * :consistency - Uses the default read consistency if none specified.
   #
   def count_columns(column_family, key, *columns_and_options)
-    column_family, super_column, _, options = 
-      extract_and_validate_params(column_family, key, columns_and_options, READ_DEFAULTS)      
+    column_family, super_column, _, options =
+      extract_and_validate_params(column_family, key, columns_and_options, READ_DEFAULTS)
     _count_columns(column_family, key, super_column, options[:start], options[:stop], options[:count], options[:consistency])
   end
 
@@ -538,7 +542,7 @@ class Cassandra
   end
 
   ##
-  # Return a hash of column value pairs for the path you request. 
+  # Return a hash of column value pairs for the path you request.
   #
   # * column_family - The column_family that you are inserting into.
   # * key - The row key to insert.
@@ -548,8 +552,8 @@ class Cassandra
   #   * :consistency - Uses the default read consistency if none specified.
   #
   def get_columns(column_family, key, *columns_and_options)
-    column_family, columns, sub_columns, options = 
-      extract_and_validate_params(column_family, key, columns_and_options, READ_DEFAULTS)      
+    column_family, columns, sub_columns, options =
+      extract_and_validate_params(column_family, key, columns_and_options, READ_DEFAULTS)
     _get_columns(column_family, key, columns, sub_columns, options[:consistency])
   end
 
@@ -574,7 +578,7 @@ class Cassandra
   ##
   # Return a hash (actually, a Cassandra::OrderedHash) or a single value
   # representing the element at the column_family:key:[column]:[sub_column]
-  # path you request. 
+  # path you request.
   #
   # * column_family - The column_family that you are inserting into.
   # * key - The row key to insert.
@@ -613,7 +617,7 @@ class Cassandra
   #   * :consistency  - Uses the default read consistency if none specified.
   #
   def multi_get(column_family, keys, *columns_and_options)
-    column_family, column, sub_column, options = 
+    column_family, column, sub_column, options =
       extract_and_validate_params(column_family, keys, columns_and_options, READ_DEFAULTS)
 
     hash = _multiget(column_family, keys, column, sub_column, options[:count], options[:start], options[:finish], options[:reversed], options[:consistency])
@@ -642,7 +646,7 @@ class Cassandra
   #   * :consistency - Uses the default read consistency if none specified.
   #
   def exists?(column_family, key, *columns_and_options)
-    column_family, column, sub_column, options = 
+    column_family, column, sub_column, options =
       extract_and_validate_params(column_family, key, columns_and_options, READ_DEFAULTS)
     result = if column
                _multiget(column_family, [key], column, sub_column, 1, '', '', false, options[:consistency])[key]
@@ -663,7 +667,7 @@ class Cassandra
   # Cassandra#get_range_single will be used.
   #
   # The start_key and finish_key parameters are only useful for iterating of all records
-  # as is done in the Cassandra#each and Cassandra#each_key methods if you are using the 
+  # as is done in the Cassandra#each and Cassandra#each_key methods if you are using the
   # RandomPartitioner.
   #
   # If the table is partitioned with OrderPreservingPartitioner you may
@@ -674,11 +678,11 @@ class Cassandra
   # each record returned.
   #
   # Please note that Cassandra returns a row for each row that has existed in the
-  # system since gc_grace_seconds. This is because deleted row keys are marked as 
+  # system since gc_grace_seconds. This is because deleted row keys are marked as
   # deleted, but left in the system until the cluster has had resonable time to replicate the deletion.
   # This function attempts to suppress deleted rows (actually any row returned without
   # columns is suppressed).
-  # 
+  #
   # Please note that when enabling the :reversed option, :start and :finish should be swapped (e.g.
   # reversal happens before selecting the range).
   #
@@ -712,8 +716,8 @@ class Cassandra
   def get_range_single(column_family, options = {})
     return_empty_rows = options.delete(:return_empty_rows) || false
 
-    column_family, _, _, options = 
-      extract_and_validate_params(column_family, "", [options], 
+    column_family, _, _, options =
+      extract_and_validate_params(column_family, "", [options],
                                   READ_DEFAULTS.merge(:start_key  => '',
                                                       :finish_key => '',
                                                       :key_count  => 100,
@@ -847,10 +851,10 @@ class Cassandra
       @batch = []
       yield(self)
       compacted_map,seen_clevels = compact_mutations!
-      clevel = if options[:consistency] != nil # Override any clevel from individual mutations if 
+      clevel = if options[:consistency] != nil # Override any clevel from individual mutations if
                  options[:consistency]
                elsif seen_clevels.length > 1 # Cannot choose which CLevel to use if there are several ones
-                 raise "Multiple consistency levels used in the batch, and no override...cannot pick one" 
+                 raise "Multiple consistency levels used in the batch, and no override...cannot pick one"
                else # if no consistency override has been provided but all the clevels in the batch are the same: use that one
                  seen_clevels.first
                end
@@ -950,7 +954,7 @@ class Cassandra
 
   ##
   # This method is used to query a secondary index with a set of
-  # provided search parameters
+  # provided search parameters.
   #
   # Please note that you can either specify a
   # CassandraThrift::IndexClause or an array of hashes with the
@@ -963,7 +967,7 @@ class Cassandra
   #   * :comparison  - Type of comparison to do.
   # * options
   #   * :key_count    - Set maximum number of rows to return. (Only works if CassandraThrift::IndexClause is not passed in.)
-  #   * :key_start    - Set starting row key for search. (Only works if CassandraThrift::IndexClause is not passed in.)
+  #   * :start_key    - Set starting row key for search. (Only works if CassandraThrift::IndexClause is not passed in.)
   #   * :consistency
   #
   # TODO: Supercolumn support.
@@ -971,14 +975,17 @@ class Cassandra
     return false if Cassandra.VERSION.to_f < 0.7
 
     column_family, columns, _, options =
-      extract_and_validate_params(column_family, [], columns_and_options, READ_DEFAULTS.merge(:key_count => 100, :key_start => ""))
+      extract_and_validate_params(column_family, [], columns_and_options,
+      READ_DEFAULTS.merge(:key_count => 100, :start_key => nil, :key_start => nil))
+
+    start_key = options[:start_key] || options[:key_start] || ""
 
     if index_clause.class != CassandraThrift::IndexClause
       index_expressions = index_clause.collect do |expression|
         create_index_expression(expression[:column_name], expression[:value], expression[:comparison])
       end
 
-      index_clause = create_index_clause(index_expressions, options[:key_start], options[:key_count])
+      index_clause = create_index_clause(index_expressions, start_key, options[:key_count])
     end
 
     key_slices = _get_indexed_slices(column_family, index_clause, columns, options[:count], options[:start],
@@ -1005,13 +1012,13 @@ class Cassandra
     @batch.each do |mutation_op|
       # A single mutation op looks like:
       # For an insert/update
-      #[ { key1 => 
+      #[ { key1 =>
       #            { CF1 => [several of CassThrift:Mutation(colname,value,TS,ttl)]
       #              CF2 => [several mutations]
       #            },
       #    key2 => {...} # Not sure if they can come batched like this...so there might only be a single key (and CF)
       #      }, # [0]
-      #  consistency # [1] 
+      #  consistency # [1]
       #]
       mmap = mutation_op[0] # :remove OR a hash like {"key"=> {"CF"=>[mutationclass1,...] } }
       used_clevels[mutation_op[1]] = true #save the clevel required for this operation