cassandra-cql 1.0.1

data/lib/cassandra-cql/uuid.rb

@@ -0,0 +1,21 @@
+=begin
+Copyright 2011 Inside Systems, Inc.
+
+Licensed 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.
+=end
+
+require 'simple_uuid'
+
+module CassandraCQL
+  class UUID < SimpleUUID::UUID; end
+end

data/lib/cassandra-cql/version.rb

@@ -0,0 +1,19 @@
+=begin
+Copyright 2011 Inside Systems, Inc.
+
+Licensed 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.
+=end
+
+module CassandraCQL
+  VERSION = "1.0.1"
+end

data/spec/column_family_spec.rb

@@ -0,0 +1,105 @@
+require File.expand_path('spec_helper.rb', File.dirname(__FILE__))
+include CassandraCQL
+
+describe "ColumnFamily class" do
+  before(:each) do
+    @connection = setup_cassandra_connection
+    @connection.execute("USE system")
+    @super_column_family = @connection.schema.column_families["HintsColumnFamily"]
+    @standard_column_family = @connection.schema.column_families["NodeIdInfo"]
+  end
+
+  context "initialize" do
+    it "should set a cf_def" do
+      @super_column_family.cf_def.should_not be_nil
+      @standard_column_family.cf_def.should_not be_nil
+    end
+
+    it "should have some common attributes" do
+      [@standard_column_family, @super_column_family].each do |column|
+        column.name.should_not be_nil
+        column.id.should_not be_nil
+        column.column_type.should_not be_nil
+      end
+    end
+
+    it "should super method_missing" do
+      expect {
+        @standard_column_family.this_method_does_not_exist
+      }.to raise_error NoMethodError
+      expect {
+        @super_column_family.this_method_does_not_exist
+      }.to raise_error NoMethodError
+    end
+  end
+
+  context "with a standard column family" do
+    it "should be standard" do
+      @standard_column_family.super?.should be_false
+      @standard_column_family.standard?.should be_true
+      @standard_column_family.type.should eq("Standard")
+    end
+  end
+
+  context "with a super column family" do
+    it "should be super" do
+      @super_column_family.super?.should be_true
+      @super_column_family.standard?.should be_false
+      @super_column_family.type.should eq("Super")
+    end
+  end
+
+  context "when calling self.cast" do
+    it "should turn UUID bytes into a UUID object" do
+      uuid = UUID.new
+      ColumnFamily.cast(uuid.bytes, "TimeUUIDType").should eq(uuid)
+    end
+
+    it "should turn a UUID bytes into a UUID object" do
+      uuid = UUID.new
+      ColumnFamily.cast(uuid.bytes, "UUIDType").should eq(uuid)
+    end
+
+    it "should turn a packed long into a number" do
+      number = 2**33
+      packed = [number >> 32, number].pack("N*")
+
+      ColumnFamily.cast(packed, "LongType").should eq(number)
+      ColumnFamily.cast(packed, "CounterColumnType").should eq(number)
+    end
+
+    it "should turn a packed negative long into a negative number" do
+      number = -2**33
+      packed = [number >> 32, number].pack("N*")
+
+      ColumnFamily.cast(packed, "LongType").should eq(number)
+      ColumnFamily.cast(packed, "CounterColumnType").should eq(number)
+    end
+
+    it "should call to_s with AsciiType" do
+      obj = double("String")
+      obj.stub(:to_s) { "string" }
+      obj.should_receive(:to_s)
+      ColumnFamily.cast(obj, "AsciiType")
+    end
+
+    it "should call to_s with UTF8Type" do
+      obj = double("String")
+      obj.stub(:to_s) { "string" }
+      obj.should_receive(:to_s)
+      ColumnFamily.cast(obj, "UTF8Type")
+    end
+
+    it "should return self with BytesType" do
+      obj = Object.new
+      ColumnFamily.cast(obj, "BytesType").object_id.should eq(obj.object_id)
+    end
+
+    it "should return nil for all types of nil" do
+      %w(TimeUUIDType UUIDType LongType IntegerType
+        UTF8Type AsciiType CounterColumnType).each do |type|
+        ColumnFamily.cast(nil, type).should eq(nil)
+      end
+    end
+  end
+end

data/spec/comparator_spec.rb

@@ -0,0 +1,225 @@
+# encoding: utf-8
+require File.expand_path('spec_helper.rb', File.dirname(__FILE__))
+include CassandraCQL
+
+describe "Comparator Roundtrip tests" do
+  before(:each) do
+    @connection = setup_cassandra_connection
+  end
+
+  def create_and_fetch_column(column_family, name)
+    @connection.execute("insert into #{column_family} (id, ?) values (?, ?)", name, 'test', 'test')
+    row =  @connection.execute("select ? from #{column_family} where id = ?", name, 'test').fetch
+    row.column_names[0]
+  end
+
+  def create_column_family(name, comparator_type)
+    if !@connection.schema.column_family_names.include?(name)
+      @connection.execute("CREATE COLUMNFAMILY #{name} (id text PRIMARY KEY) WITH comparator=?", comparator_type)
+    end
+  end
+
+  context "with ascii comparator" do
+    let(:cf_name) { "comparator_cf_ascii" }
+    before(:each) { create_column_family(cf_name, 'AsciiType') }
+
+    it "should return an ascii string" do
+      create_and_fetch_column(cf_name, "test string").should eq("test string")
+    end
+  end
+
+  context "with bigint comparator" do
+    let(:cf_name) { "comparator_cf_bigint" }
+    before(:each) { create_column_family(cf_name, 'LongType') }
+
+    def test_for_value(value)
+      create_and_fetch_column(cf_name, value).should eq(value)
+      create_and_fetch_column(cf_name, value*-1).should eq(value*-1)
+    end
+  
+    it "should properly convert integer values that fit into 1 byte" do
+      test_for_value(1)
+    end
+    it "should properly convert integer values that fit into 2 bytes" do
+      test_for_value(2**8 + 80)
+    end
+    it "should properly convert integer values that fit into 3 bytes" do
+      test_for_value(2**16 + 622)
+    end
+    it "should properly convert integer values that fit into 4 bytes" do
+      test_for_value(2**24 + 45820)
+    end
+    it "should properly convert integer values that fit into 5 bytes" do
+      test_for_value(2**32 + 618387)
+    end
+  end
+
+  context "with blob comparator" do
+    let(:cf_name) { "comparator_cf_blob" }
+    before(:each) { create_column_family(cf_name, 'BytesType') }
+
+    it "should return a blob" do
+      bytes = "binary\x00"
+      bytes = bytes.force_encoding('ASCII-8BIT') if RUBY_VERSION >= "1.9"
+      create_and_fetch_column(cf_name, bytes).should eq(bytes)
+    end
+  end
+
+  context "with boolean comparator" do
+    let(:cf_name) { "comparator_cf_boolean" }
+    before(:each) { create_column_family(cf_name, 'BooleanType') }
+
+    it "should return true" do
+      create_and_fetch_column(cf_name, true).should be_true
+    end
+
+    it "should return false" do
+      create_and_fetch_column(cf_name, false).should be_false
+    end
+  end
+
+
+  context "with decimal comparator" do
+    let(:cf_name) { "comparator_cf_decimal" }
+    before(:each) { create_column_family(cf_name, 'DecimalType') }
+
+    def test_for_value(value)
+      create_and_fetch_column(cf_name, value).should eq(value)
+      create_and_fetch_column(cf_name, value*-1).should eq(value*-1)
+    end
+  
+# These tests currently crash the node
+    it "should return a small decimal" #do
+#      test_for_value(15.333)
+#    end
+    it "should return a huge decimal" #do
+#      test_for_value(BigDecimal.new('129182739481237481341234123411.1029348102934810293481039'))
+#    end
+  end
+
+  context "with double comparator" do
+    let(:cf_name) { "comparator_cf_double" }
+    before(:each) { create_column_family(cf_name, 'DoubleType') }
+
+    def test_for_value(value)
+      create_and_fetch_column(cf_name, value).should be_within(0.1).of(value)
+      create_and_fetch_column(cf_name, value*-1).should be_within(0.1).of(value*-1)
+    end
+  
+    it "should properly convert some float values" do
+      test_for_value(1.125)
+      test_for_value(384.125)
+      test_for_value(65540.125)
+      test_for_value(16777217.125)
+      test_for_value(109911627776.125)
+    end
+  end
+
+  context "with float comparator" do
+    let(:cf_name) { "comparator_cf_float" }
+    before(:each) { create_column_family(cf_name, 'FloatType') }
+
+    def test_for_value(value)
+      create_and_fetch_column(cf_name, value*-1).should eq(value*-1)
+      create_and_fetch_column(cf_name, value).should eq(value)
+    end
+  
+    it "should properly convert some float values" do
+      test_for_value(1.125)
+      test_for_value(384.125)
+      test_for_value(65540.125)
+    end
+  end
+
+  context "with int comparator" do
+    let(:cf_name) { "comparator_cf_int" }
+    before(:each) { create_column_family(cf_name, 'Int32Type') }
+
+    def test_for_value(value)
+      create_and_fetch_column(cf_name, value).should eq(value)
+      create_and_fetch_column(cf_name, value*-1).should eq(value*-1)
+    end
+  
+    it "should properly convert integer values that fit into 1 byte" do
+      test_for_value(1)
+    end
+    it "should properly convert integer values that fit into 2 bytes" do
+      test_for_value(2**8 + 80)
+    end
+    it "should properly convert integer values that fit into 3 bytes" do
+      test_for_value(2**16 + 622)
+    end
+    it "should properly convert integer values that fit into 4 bytes" do
+      test_for_value(2**24 + 45820)
+    end
+  end
+
+  context "with text comparator" do
+    let(:cf_name) { "comparator_cf_text" }
+    before(:each) { create_column_family(cf_name, 'UTF8Type') }
+
+    it "should return a non-multibyte string" do
+      create_and_fetch_column(cf_name, "snark").should eq("snark")
+    end
+
+    it "should return a multibyte string" do
+      create_and_fetch_column(cf_name, "snårk").should eq("snårk")
+    end
+  end
+
+  context "with timestamp comparator" do
+    let(:cf_name) { "comparator_cf_timestamp" }
+    before(:each) { create_column_family(cf_name, 'TimeUUIDType') }
+
+    it "should return a timestamp" do
+      uuid = UUID.new
+      create_and_fetch_column(cf_name, uuid).should eq(uuid)
+    end
+  end
+
+  context "with uuid comparator" do
+    let(:cf_name) { "comparator_cf_uuid" }
+    before(:each) { create_column_family(cf_name, 'UUIDType') }
+
+    it "should return a uuid" do
+      uuid = UUID.new
+      create_and_fetch_column(cf_name, uuid).should eq(uuid)
+    end
+  end
+
+  context "with varchar comparator" do
+    let(:cf_name) { "comparator_cf_varchar" }
+    before(:each) { create_column_family(cf_name, 'UTF8Type') }
+
+    it "should return a non-multibyte string" do
+      create_and_fetch_column(cf_name, "snark").should eq("snark")
+    end
+    
+    it "should return a multibyte string" do
+      create_and_fetch_column(cf_name, "snårk").should eq("snårk")
+    end
+  end
+
+  context "with varint comparator" do
+    let(:cf_name) { "comparator_cf_varint" }
+    before(:each) { create_column_family(cf_name, 'IntegerType') }
+
+    def test_for_value(value)
+      create_and_fetch_column(cf_name, value).should eq(value)
+      create_and_fetch_column(cf_name, value*-1).should eq(value*-1)
+    end
+  
+    it "should properly convert integer values that fit into 1 byte" do
+      test_for_value(1)
+    end
+    it "should properly convert integer values that fit into 2 bytes" do
+      test_for_value(2**8 + 80)
+    end
+    it "should properly convert integer values that fit into 3 bytes" do
+      test_for_value(2**16 + 622)
+    end
+    it "should properly convert integer values that fit into more than 8 bytes" do
+      test_for_value(2**256)
+    end
+  end
+end

data/spec/conf/0.8/cassandra.in.sh

@@ -0,0 +1,41 @@
+# 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.
+
+if [ "x$CASSANDRA_HOME" = "x" ]; then
+  CASSANDRA_HOME=`dirname $0`/..
+fi
+
+# The directory where Cassandra's configs live (required)
+if [ "x$CASSANDRA_CONF" = "x" ]; then
+  CASSANDRA_CONF=$CASSANDRA_HOME/conf
+fi
+
+# This can be the path to a jar file, or a directory containing the
+# compiled classes. NOTE: This isn't needed by the startup script,
+# it's just used here in constructing the classpath.
+cassandra_bin=$CASSANDRA_HOME/build/classes/main
+cassandra_bin=$cassandra_bin:$CASSANDRA_HOME/build/classes/thrift
+#cassandra_bin=$cassandra_home/build/cassandra.jar
+
+# JAVA_HOME can optionally be set here
+#JAVA_HOME=/usr/local/jdk6
+
+# The java classpath (required)
+CLASSPATH=$CASSANDRA_CONF:$cassandra_bin
+
+for jar in $CASSANDRA_HOME/lib/*.jar; do
+  CLASSPATH=$CLASSPATH:$jar
+done

data/spec/conf/0.8/cassandra.yaml

@@ -0,0 +1,61 @@
+# Cassandra storage config YAML
+cluster_name: 'Test'
+initial_token:
+auto_bootstrap: false
+hinted_handoff_enabled: true
+max_hint_window_in_ms: 3600000 # one hour
+hinted_handoff_throttle_delay_in_ms: 50
+authenticator: org.apache.cassandra.auth.AllowAllAuthenticator
+authority: org.apache.cassandra.auth.AllowAllAuthority
+partitioner: org.apache.cassandra.dht.RandomPartitioner
+
+# directories where Cassandra should store data on disk.
+data_file_directories:
+    - data/data
+commitlog_directory: data/commitlog
+
+# saved caches
+saved_caches_directory: data/saved_caches
+
+commitlog_rotation_threshold_in_mb: 128
+commitlog_sync: periodic
+commitlog_sync_period_in_ms: 10000
+seed_provider:
+    - class_name: org.apache.cassandra.locator.SimpleSeedProvider
+      parameters:
+          - seeds: "127.0.0.1"
+flush_largest_memtables_at: 0.75
+reduce_cache_sizes_at: 0.85
+reduce_cache_capacity_to: 0.6
+concurrent_reads: 32
+concurrent_writes: 32
+memtable_flush_queue_size: 4
+sliced_buffer_size_in_kb: 64
+storage_port: 7000
+listen_address: localhost
+rpc_address: localhost
+rpc_port: 9160
+rpc_keepalive: true
+thrift_framed_transport_size_in_mb: 15
+thrift_max_message_length_in_mb: 16
+incremental_backups: false
+snapshot_before_compaction: false
+column_index_size_in_kb: 64
+in_memory_compaction_limit_in_mb: 64
+concurrent_compactors: 1
+compaction_throughput_mb_per_sec: 16
+compaction_preheat_key_cache: true
+rpc_timeout_in_ms: 10000
+endpoint_snitch: org.apache.cassandra.locator.SimpleSnitch
+dynamic_snitch: true
+dynamic_snitch_update_interval_in_ms: 100
+dynamic_snitch_reset_interval_in_ms: 600000
+dynamic_snitch_badness_threshold: 0.0
+request_scheduler: org.apache.cassandra.scheduler.NoScheduler
+index_interval: 128
+encryption_options:
+    internode_encryption: none
+    keystore: conf/.keystore
+    keystore_password: cassandra
+    truststore: conf/.truststore
+    truststore_password: cassandra