hallelujah-cassandra-cql 1.0.4

data/lib/cassandra-cql/types/integer_type.rb

@@ -0,0 +1,27 @@
+=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
+  module Types
+    class IntegerType < AbstractType
+      def self.cast(value)
+        bytes_to_int(value)
+      end
+    end
+    
+    class Int32Type < IntegerType; end
+  end
+end

data/lib/cassandra-cql/types/long_type.rb

@@ -0,0 +1,27 @@
+=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
+  module Types
+    class LongType < AbstractType
+      def self.cast(value)
+        bytes_to_long(value)
+      end
+    end
+    
+    class CounterColumnType < LongType; end
+  end
+end

data/lib/cassandra-cql/types/utf8_type.rb

@@ -0,0 +1,25 @@
+=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
+  module Types
+    class UTF8Type < AbstractType
+      def self.cast(value)
+        RUBY_VERSION >= "1.9" ? value.to_s.dup.force_encoding('UTF-8') : value.to_s.dup
+      end
+    end
+  end
+end

data/lib/cassandra-cql/types/uuid_type.rb

@@ -0,0 +1,27 @@
+=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
+  module Types
+    class UUIDType < AbstractType
+      def self.cast(value)
+        UUID.new(value)
+      end
+    end
+    
+    class TimeUUIDType < UUIDType; end
+  end
+end

data/lib/cassandra-cql/utility.rb

@@ -0,0 +1,37 @@
+=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 'zlib'
+
+module CassandraCQL
+  class Utility
+    def self.compress(source, level=2)
+      Zlib::Deflate.deflate(source, level)
+    end
+    
+    def self.decompress(source)
+      Zlib::Inflate.inflate(source)
+    end
+
+    def self.binary_data?(string)
+      if RUBY_VERSION >= "1.9"
+        string.encoding.name == "ASCII-8BIT"
+      else
+        string.count("\x00-\x7F", "^ -~\t\r\n").fdiv(string.size) > 0.3 || string.index("\x00") unless string.empty?
+      end
+    end
+  end
+end

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.4"
+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,249 @@
+# 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 date comparator" do
+    let(:cf_name) { "comparator_cf_date" }
+    before(:each) { create_column_family(cf_name, 'DateType') }
+
+    it "should return a Time object" do
+      ts = Time.new
+      res = create_and_fetch_column(cf_name, ts)
+      res.to_f.should be_within(0.001).of(ts.to_f)
+      res.should be_kind_of(Time)
+    end
+    
+    it "should return a timestamp given a date" do
+      date = Date.today
+      res = create_and_fetch_column(cf_name, date)
+      [:year, :month, :day].each do |sym|
+        res.send(sym).should eq(date.send(sym))
+      end
+      res.class.should eq(Time)
+    end
+  end
+
+  if CASSANDRA_VERSION.to_f >= 1.0
+    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
+
+      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
+  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
+
+  if CASSANDRA_VERSION.to_f >= 1.0
+    #Int32Type was added in 1.0 (CASSANDRA-3031)
+    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
+  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