cassandra-cql 1.1.5 → 1.2.0

data/spec/conf/1.2/log4j-server.properties

@@ -0,0 +1,44 @@
+# 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=/var/log/cassandra/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
+
+# Adding this to avoid thrift logging disconnect errors.
+log4j.logger.org.apache.thrift.server.TNonblockingServer=ERROR
+

data/spec/conf/1.2/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/spec/conf/1.2/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/spec/misc_spec.rb

@@ -4,7 +4,7 @@ include CassandraCQL
 describe "Miscellaneous tests that handle specific failures/regressions" do
   before(:each) do
     @connection = setup_cassandra_connection
-    @connection.execute("DROP COLUMNFAMILY misc_tests") if @connection.schema.column_family_names.include?('misc_tests')
+    drop_column_family_if_exists(@connection, 'misc_tests')
     @connection.execute("CREATE COLUMNFAMILY misc_tests (id text PRIMARY KEY)")
   end
 
@@ -12,7 +12,7 @@ describe "Miscellaneous tests that handle specific failures/regressions" do
     before(:each) do
       @connection.execute("ALTER COLUMNFAMILY misc_tests ADD test_column ascii")
     end
-    
+
     it "should be consistent with ascii-encoded text" do
       @connection.execute("INSERT INTO misc_tests (id, test_column) VALUES (?, ?)", 'test', 'test_column').should be_nil
       row = @connection.execute("SELECT test_column FROM misc_tests WHERE id=?", 'test').fetch
@@ -25,11 +25,13 @@ describe "Miscellaneous tests that handle specific failures/regressions" do
 
   context "with unvalidatable data" do
     before(:each) do
+      @connection.execute("ALTER COLUMNFAMILY misc_tests ADD good_column varchar")
+      @connection.execute("ALTER COLUMNFAMILY misc_tests ADD bad_column varchar")
       @connection.execute("INSERT INTO misc_tests (id, good_column, bad_column) VALUES (?, ?, ?)", 'test', 'blah', '')
-      @connection.execute("ALTER COLUMNFAMILY misc_tests ADD bad_column int")
+      @connection.execute("ALTER COLUMNFAMILY misc_tests ALTER bad_column TYPE int")
       @row = @connection.execute("SELECT good_column, bad_column FROM misc_tests WHERE id=?", 'test').fetch
     end
-    
+
     it "should have valid column_names" do
       @row.column_names.should eq ['good_column', 'bad_column']
     end

data/spec/result_spec.rb

@@ -11,10 +11,12 @@ describe "void results" do
   end
 end
 
-describe "sparse row results" do
+# CQL3 does not directly model wide rows as sparse rows, so this test is only
+# needed for CQL2
+describe "sparse row results", :cql_version => '2.0.0' do
   before(:each) do
     @connection = setup_cassandra_connection
-    if !@connection.schema.column_family_names.include?('sparse_results')
+    if !column_family_exists?(@connection, 'sparse_results')
       @connection.execute("CREATE COLUMNFAMILY sparse_results (id varchar PRIMARY KEY)")
     else
       @connection.execute("TRUNCATE sparse_results")
@@ -43,6 +45,18 @@ end
 describe "row results" do
   before(:each) do
     @connection = setup_cassandra_connection
+    drop_column_family_if_exists(@connection, 'sparse_results')
+    @connection.execute(<<-CQL)
+      CREATE TABLE sparse_results (
+        id varchar PRIMARY KEY,
+        col1 varchar,
+        col2 varchar,
+        col3 varchar,
+        col4 varchar,
+        col5 varchar,
+        col6 varchar
+      )
+    CQL
     @connection.execute("INSERT INTO sparse_results (id, col1, col2, col3) VALUES (?, ?, ?, ?)", 'key1', 'val1', 'val2', 'val3').should be_nil
     @connection.execute("INSERT INTO sparse_results (id, col4, col5, col6) VALUES (?, ?, ?, ?)", 'key2', 'val4', 'val5', 'val6').should be_nil
     @result = @connection.execute("SELECT col1, col2, col3, col4 FROM sparse_results")

data/spec/row_spec.rb

@@ -6,12 +6,10 @@ describe "basic methods" do
   context 'with basic column family' do
     before(:each) do
       @connection = setup_cassandra_connection
-      if @connection.schema.column_family_names.include?('basic_methods')
-        @connection.execute("DROP COLUMNFAMILY basic_methods")
-      end
+      drop_column_family_if_exists(@connection, 'basic_methods')
       @connection.execute("CREATE COLUMNFAMILY basic_methods (id varchar PRIMARY KEY, created_at uuid, default_column varchar, name varchar, serial int)")
 
-      @connection.execute("INSERT INTO basic_methods (id, created_at, name, serial, default_column) VALUES (?, ?, ?, ?, ?)", 'test', Time.new, 'name', 12345, 'snork')
+      @connection.execute("INSERT INTO basic_methods (id, created_at, name, serial, default_column) VALUES (?, ?, ?, ?, ?)", 'test', CassandraCQL::UUID.new, 'name', 12345, 'snork')
       @row = @connection.execute("SELECT * FROM basic_methods WHERE id=?", "test").fetch
     end
 
@@ -48,7 +46,7 @@ describe "basic methods" do
     end
   end
 
-  context 'with a column family with int comparators' do
+  context 'with a column family with int comparators', :cql_version => '2.0.0' do
     before(:each) do
       @connection = setup_cassandra_connection
       if @connection.schema.column_family_names.include?('int_comparator')
@@ -73,4 +71,44 @@ describe "basic methods" do
       end
     end
   end
+
+  context 'collections', :cql_version => '3.0.0' do
+    before(:each) do
+      @connection = setup_cassandra_connection
+      if column_family_exists?(@connection, 'collections')
+        @connection.execute("DROP COLUMNFAMILY collections")
+      end
+      @connection.execute(<<-CQL)
+        CREATE COLUMNFAMILY collections (
+          key text PRIMARY KEY,
+          mylist LIST <int>,
+          myset SET <varchar>,
+          mymap MAP <uuid,timestamp>
+        )
+      CQL
+
+      @map = {
+        CassandraCQL::UUID.new => Time.at(Time.now.to_i),
+        CassandraCQL::UUID.new => Time.at(Time.now.to_i) - 60
+      }
+
+      @connection.execute(
+        "INSERT INTO collections (key, mylist, myset, mymap) VALUES (?, [?], {?}, {?:?,?:?})",
+        'test', [1, 2, 3], ['some', 'set'], *@map.to_a.flatten)
+
+      @row = @connection.execute("SELECT * FROM collections WHERE key=?", "test").fetch
+    end
+
+    it 'should return list' do
+      @row.to_hash['mylist'].should == [1, 2, 3]
+    end
+
+    it 'should return set' do
+      @row.to_hash['myset'].should == Set['some', 'set']
+    end
+
+    it 'should return map' do
+      @row.to_hash['mymap'].should == @map
+    end
+  end
 end

data/spec/rowkey_spec.rb

@@ -14,7 +14,7 @@ describe "Validation Roundtrip tests" do
   end
 
   def create_column_family(name, test_row_key_type)
-    if !@connection.schema.column_family_names.include?(name)
+    if !column_family_exists?(@connection, name)
       @connection.execute("CREATE COLUMNFAMILY #{name} (id #{test_row_key_type} PRIMARY KEY, test_column text)")
     end
   end
@@ -230,4 +230,4 @@ describe "Validation Roundtrip tests" do
       test_for_value(2**256)
     end
   end
-end
+end

data/spec/spec_helper.rb

@@ -11,24 +11,78 @@ require 'yaml'
 require 'rspec'
 
 CASSANDRA_VERSION = ENV['CASSANDRA_VERSION'] || '1.1' unless defined?(CASSANDRA_VERSION)
+CQL_VERSION = ENV['CQL_VERSION'] || '2.0.0'
+USE_CQL3 = CQL_VERSION.split('.').first.to_i == 3
 
 require "cassandra-cql/#{CASSANDRA_VERSION}"
 
-def yaml_fixture(file)
-  if file.kind_of?(Symbol)
-    file = "#{file}.yaml"
-  elsif file !~ /\.yaml$/
-    file = "#{file}.yaml"
+module Helpers
+  def yaml_fixture(file)
+    if file.kind_of?(Symbol)
+      file = "#{file}.yaml"
+    elsif file !~ /\.yaml$/
+      file = "#{file}.yaml"
+    end
+    YAML::load_file(File.dirname(__FILE__) + "/fixtures/#{file}")
+  end
+
+  def setup_cassandra_connection
+    host = ENV['CASSANDRA_CQL_HOST'] || '127.0.0.1'
+    port = ENV['CASSANDRA_CQL_PORT'] || 9160
+
+    cassandra_cql_options = {}
+    if CASSANDRA_VERSION >= '1.2'
+      cassandra_cql_options.merge!(:cql_version => CQL_VERSION)
+    end
+
+    keyspace_name = "cassandra_cql_test_keyspace_#{CASSANDRA_VERSION.gsub(/\D/, '')}_#{CQL_VERSION.gsub(/\D/, '')}"
+    connection = CassandraCQL::Database.new(["#{host}:#{port}"], cassandra_cql_options, :retries => 5, :timeout => 5)
+    if !connection.keyspaces.map(&:name).include?(keyspace_name)
+      create_keyspace(connection, keyspace_name)
+    end
+    connection.execute("USE #{keyspace_name}")
+
+    connection
+  end
+
+  def drop_column_family_if_exists(connection, cf)
+    if column_family_exists?(connection, cf)
+      connection.execute("DROP COLUMNFAMILY #{cf}")
+    end
   end
-  YAML::load_file(File.dirname(__FILE__) + "/fixtures/#{file}")
 end
 
-def setup_cassandra_connection
-  connection = CassandraCQL::Database.new(["127.0.0.1:9160"], {}, :retries => 5, :timeout => 1)
-  if !connection.keyspaces.map(&:name).include?("CassandraCQLTestKeyspace")
-    connection.execute("CREATE KEYSPACE CassandraCQLTestKeyspace WITH strategy_class='org.apache.cassandra.locator.SimpleStrategy' AND strategy_options:replication_factor=1")
+module Cql2Helpers
+  def column_family_exists?(connection, cf)
+    @connection.schema.column_family_names.include?(cf.to_s)
   end
-  connection.execute("USE CassandraCQLTestKeyspace")
 
-  connection
+  def create_keyspace(connection, ks)
+    connection.execute("CREATE KEYSPACE #{ks} WITH strategy_class='org.apache.cassandra.locator.SimpleStrategy' AND strategy_options:replication_factor=1")
+  end
+end
+
+module Cql3Helpers
+  def column_family_exists?(connection, cf)
+    connection.execute(<<-CQL, connection.keyspace, cf).fetch_row
+      SELECT * FROM system.schema_columnfamilies
+      WHERE keyspace_name = ? AND columnfamily_name = ?
+    CQL
+  end
+
+  def create_keyspace(connection, ks)
+    connection.execute("CREATE KEYSPACE #{ks} WITH REPLICATION = {'class': 'SimpleStrategy', 'replication_factor': 1}")
+  end
+end
+
+RSpec.configure do |config|
+  config.filter_run_excluding :cql_version =>
+    lambda { |version| version != CQL_VERSION }
+
+  config.include Helpers
+  if CQL_VERSION == '3.0.0'
+    config.include Cql3Helpers
+  else
+    config.include Cql2Helpers
+  end
 end

data/spec/statement_spec.rb

@@ -40,8 +40,8 @@ describe "execute" do
   context "when performing void-returning column_family operations" do
     before(:each) do
       @connection = setup_cassandra_connection
-      if !@connection.schema.column_family_names.include?('colfam_ops')
-        @connection.execute("CREATE COLUMNFAMILY colfam_ops (id varchar PRIMARY KEY)")
+      if !column_family_exists?(@connection, 'colfam_ops')
+        @connection.execute("CREATE COLUMNFAMILY colfam_ops (id varchar PRIMARY KEY, column varchar)")
       else
         @connection.execute("TRUNCATE colfam_ops")
       end
@@ -70,29 +70,53 @@ describe "escape" do
 end
 
 describe "quote" do
+  
   context "with a string" do
     it "should add quotes" do
-      Statement.quote("test").should eq("'test'")
+      Statement.quote("test", USE_CQL3).should eq("'test'")
     end
   end
 
   context "with an integer" do
     it "should not add quotes" do
-      Statement.quote(15).should eq(15)
+      Statement.quote(15, USE_CQL3).should eq("15")
     end
   end
 
   context "with an array" do
     it "should return a comma-separated list" do
-      Statement.quote([1, 2, 3]).should eq("1,2,3")
-      Statement.quote(["a", "b''", "c"]).should eq("'a','b''','c'")
+      Statement.quote([1, 2, 3], USE_CQL3).should eq("1,2,3")
+      Statement.quote(["a", "b''", "c"], USE_CQL3).should eq("'a','b''','c'")
+    end
+  end
+
+  context "with a big decimal" do
+    let :big_decimal do
+      BigDecimal.new('129182739481237481341234123411.1029348102934810293481039') 
+    end
+    let :result do 
+      '0.1291827394812374813412341234111029348102934810293481039E30'
+    end
+    
+    it "should add quotes", cql_version: '2.0.0' do
+      Statement.quote(BigDecimal.new(big_decimal), USE_CQL3).should eq("'#{result}'")
+    end
+
+    it "should not add quotes", cql_version: '3.0.0' do
+      Statement.quote(big_decimal, USE_CQL3).should eq(result)
+    end  
+  end
+  context "with a boolean" do
+    it "should not add quotes" do
+      Statement.quote(true, USE_CQL3).should eq("true")
+      Statement.quote(false, USE_CQL3).should eq("false")
     end
   end
 
   context "with an unsupported object" do
     it "should raise an exception" do
       expect {
-        Statement.quote(Time.new)
+        Statement.quote(Time.new, USE_CQL3)
       }.to raise_error(CassandraCQL::Error::UnescapableObject)
     end
   end
@@ -126,7 +150,7 @@ describe "cast_to_cql" do
     it "should return the a guid" do
       uuid = UUID.new
       guid = Statement.cast_to_cql(uuid)
-      guid.should eq(uuid.to_guid)
+      guid.should eq(uuid)
     end
   end
 
@@ -134,7 +158,7 @@ describe "cast_to_cql" do
     it "should return the guid" do
       uuid = SimpleUUID::UUID.new
       guid = Statement.cast_to_cql(uuid)
-      guid.should eq(uuid.to_guid)
+      guid.should eq(uuid)
     end
   end
 
@@ -183,40 +207,41 @@ describe "cast_to_cql" do
 end
 
 describe "sanitize" do
+
   context "with no bind vars" do
     it "should return itself" do
-      Statement.sanitize("use keyspace").should eq("use keyspace")
+      Statement.sanitize("use keyspace", [], USE_CQL3).should eq("use keyspace")
     end
   end
   
   context "when expecting bind vars" do
     it "should raise an exception with bind variable mismatch" do
       expect {
-        Statement.sanitize("use keyspace ?", ['too', 'many'])
+        Statement.sanitize("use keyspace ?", ['too', 'many'], USE_CQL3)
       }.to raise_error(Error::InvalidBindVariable)
     end
 
     it "should not raise an exception with matching bind vars" do
       expect {
-        Statement.sanitize("use keyspace ?", ["test"]).should eq("use keyspace 'test'")
+        Statement.sanitize("use keyspace ?", ["test"], USE_CQL3).should eq("use keyspace 'test'")
       }.to_not raise_error(Error::InvalidBindVariable)
     end
 
     it "should have bind vars in the right order" do
       expect {
-        Statement.sanitize("use keyspace ? with randomness (?)", ["test", "stuff"]).should eq("use keyspace 'test' with randomness ('stuff')")
+        Statement.sanitize("use keyspace ? with randomness (?)", ["test", "stuff"], USE_CQL3).should eq("use keyspace 'test' with randomness ('stuff')")
       }.to_not raise_error(Error::InvalidBindVariable)
     end
 
     it "should not double-escape the single quotes in your string" do
       Statement.sanitize(
-        "insert into keyspace (key, ?) values (?)", ["vanilla", %Q{I\'m a string with \'cool\' quotes}]
+        "insert into keyspace (key, ?) values (?)", ["vanilla", %Q{I\'m a string with \'cool\' quotes}], USE_CQL3
       ).should eq("insert into keyspace (key, 'vanilla') values ('I''m a string with ''cool'' quotes')")
     end
 
     it "should handle numbers and stuff appropriately" do
       Statement.sanitize(
-        "insert into keyspace (key, ?) values (?)", [488, 60.368]
+        "insert into keyspace (key, ?) values (?)", [488, 60.368], USE_CQL3
       ).should eq("insert into keyspace (key, 488) values (60.368)")
     end
 
@@ -227,4 +252,4 @@ describe "finish" do
   it "should just return true .. nothing to clean up yet" do
     Statement.new(nil, 'whatever').finish.should be_true
   end
-end
+end