whi-cassie 1.0.2 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b2075427502462684fe7e66c2bcad907c14c9d59
-  data.tar.gz: 4cde5df3910792c24792b59aa02df037b1275541
+  metadata.gz: 4ce98efa46e27e9c8e289912b596535b739d919f
+  data.tar.gz: c0f52098326237086aa9562a785ebee36b590a94
 SHA512:
-  metadata.gz: 0ab1b02c223b3a59b021f18e59f098ddc58371d7ee5c09494f027f31865addf4b8b1525f0775fd946a590388d62cb92af66bb2fd047f32c1cff129ca45101f1c
-  data.tar.gz: 2faf7b37e2ed54b39f69b396eddc5a0614e7ec5b6f912d7307ad7ea4d9a67305005f04779fec3e7e884f4f800f35279aebaec3b28e1d12d12bc84151123cb831
+  metadata.gz: b1023cae31d7fabc151f84db3f2a796f2519134753554968a62fcb771f535d893147c9cc59c2f231dd6586a05d08e2ca9160d9363911ed1b7d248cdea68161d0
+  data.tar.gz: c80b5b7e097f41262ca7dfa3816f92d00272e01ab96ffb0a2a9ba3eccbd99b4013254306c8db1eb6f4d3eb53858cf14b146283ead04df0ce072b4c622d5c4e94

data/HISTORY.txt

@@ -1,3 +1,7 @@
+1.0.3
+
+Fix bugs preventing counter and set data types from working on models.
+
 1.0.2
 
 Set cluster logger on the Cassandra cluster if not already set.

data/VERSION

@@ -1 +1 @@
-1.0.2
+1.0.3

data/lib/cassie/model.rb

@@ -46,6 +46,7 @@ module Cassie::Model
     class_attribute :_columns, :instance_reader => false, :instance_writer => false
     class_attribute :_column_aliases, :instance_reader => false, :instance_writer => false
     class_attribute :_ordering_keys, :instance_reader => false, :instance_writer => false
+    class_attribute :_counter_table, :instance_reader => false, :instance_writer => false
     define_model_callbacks :create, :update, :save, :destroy
     self._columns = {}
     self._column_aliases = HashWithIndifferentAccess.new
@@ -66,6 +67,11 @@ module Cassie::Model
     # Defining a column will also define getter and setter methods for both the column name
     # and the alias name (if specified). So `column :i, :int, as: :id` will define the methods
     # `i`, `i=`, `id`, and `id=`.
+    #
+    # If you define a counter column then it will define methods for `increment_i!` and `decrement_i!`
+    # which take an optional amount argument. Note that if you have a counter column you cannot have
+    # any other non-primary key columns and you cannot call create, update, or save and must use the
+    # increment and decrement commands.
     def column(name, type, as: nil)
       name = name.to_sym
       type_class = nil
@@ -77,13 +83,33 @@ module Cassie::Model
       
       self._columns = _columns.merge(name => type_class)
       self._column_aliases = self._column_aliases.merge(name => name)
-      
-      define_method("#{name}="){ |value| instance_variable_set(:"@#{name}", self.class.send(:coerce, value, type_class)) }
-      attr_reader name
-      if as && as.to_s != name.to_s
+
+      aliased = (as && as.to_s != name.to_s)
+      if aliased
         self._column_aliases = self._column_aliases.merge(as => name)
-        define_method(as){ send(name) }
-        define_method("#{as}="){|value| send("#{name}=", value) }
+      end
+
+      if type.to_s == "counter".freeze
+        self._counter_table = true
+        
+        define_method(name){ instance_variable_get(:"@#{name}") || 0 }
+        define_method("#{name}="){ |value| instance_variable_set(:"@#{name}", value.to_i) }
+        
+        define_method("increment_#{name}!"){ |amount=1, ttl: nil| send(:adjust_counter!, name, amount, ttl: ttl) }
+        define_method("decrement_#{name}!"){ |amount=1, ttl: nil| send(:adjust_counter!, name, -amount, ttl: ttl) }
+        if aliased
+          define_method(as){ send(name) }
+          define_method("increment_#{as}!"){ |amount=1, ttl: nil| send("increment_#{name}!", amount, ttl: ttl) }
+          define_method("decrement_#{as}!"){ |amount=1, ttl: nil| send("increment_#{name}!", amount, ttl: ttl) }
+        end
+      else
+        attr_reader name
+        define_method("#{name}="){ |value| instance_variable_set(:"@#{name}", self.class.send(:coerce, value, type_class)) }
+        attr_reader name
+        if aliased
+          define_method(as){ send(name) }
+          define_method("#{as}="){|value| send("#{name}=", value) }
+        end
       end
     end
     
@@ -383,7 +409,7 @@ module Cassie::Model
       elsif type_class == Cassandra::Types::List
         Array.new(value)
       elsif type_class == Cassandra::Types::Set
-        Array.new(value).to_set
+        Set.new(value)
       elsif type_class == Cassandra::Types::Map
         Hash[value]
       else
@@ -402,20 +428,26 @@ module Cassie::Model
     @persisted
   end
   
+  # Return true if the table is used for a counter.
+  def counter_table?
+    !!self.class._counter_table
+  end
+  
   # Save a record. Returns true if the record was persisted and false if it was invalid.
   # This method will run the save callbacks as well as either the update or create
   # callbacks as necessary.
   def save(validate: true, ttl: nil)
+    raise ArgumentError.new("Cannot call save on a counter table") if counter_table?
     valid_record = (validate ? valid? : true)
     if valid_record
       run_callbacks(:save) do
         if persisted?
           run_callbacks(:update) do
-            self.class.connection.update(self.class.full_table_name, values_hash, key_hash, :ttl => persistence_ttl || ttl)
+            self.class.connection.update(self.class.full_table_name, values_hash, key_hash, :ttl => (ttl || persistence_ttl))
           end
         else
           run_callbacks(:create) do
-            self.class.connection.insert(self.class.full_table_name, attributes, :ttl => persistence_ttl || ttl)
+            self.class.connection.insert(self.class.full_table_name, attributes, :ttl => (ttl || persistence_ttl))
             @persisted = true
           end
         end
@@ -478,12 +510,26 @@ module Cassie::Model
   
   private
   
+  # Used for updating counter columns.
+  def adjust_counter!(name, amount, ttl: nil)
+    amount = amount.to_i
+    if amount != 0
+      run_callbacks(:update) do
+        adjustment = (amount < 0 ? "#{name} = #{name} - #{amount.abs}" : "#{name} = #{name} + #{amount}")
+        self.class.connection.update(self.class.full_table_name, adjustment, key_hash, :ttl => (ttl || persistence_ttl))
+      end
+    end
+    record = self.class.find(key_hash)
+    value = (record ? record.send(name) : send(name) + amount)
+    send("#{name}=", value)
+  end
+  
   # Returns a hash of value except for the ones that constitute the primary key
   def values_hash
     pk = self.class.primary_key
     hash = {}
     self.class.column_names.each do |name|
-      hash[name] = send(name) unless pk.include?(name)
+      hash[name] = send(name) unless pk.include?(name) 
     end
     hash
   end

data/lib/cassie.rb

@@ -219,9 +219,13 @@ class Cassie
     key_cql, key_values = key_clause(key_hash)
     update_cql = []
     update_values = []
-    values_hash.each do |column, value|
-      update_cql << "#{column} = ?"
-      update_values << value
+    if values_hash.is_a?(String)
+      update_cql << values_hash
+    else
+      values_hash.each do |column, value|
+        update_cql << "#{column} = ?"
+        update_values << value
+      end
     end
     values = update_values + key_values
     

data/spec/cassie/model_spec.rb

@@ -189,163 +189,318 @@ describe Cassie::Model do
     let(:model){ Cassie::TypeTester.new }
     
     it "should work with varchar columns" do
-      model.varchar = "foo"
-      model.varchar.should == "foo"
-      model.varchar = nil
-      model.varchar.should == nil
+      model.varchar_value = "foo"
+      model.varchar_value.should == "foo"
+      model.save
+      id = model.id
+      model = Cassie::TypeTester.find(:id => id)
+      model.varchar_value.should == "foo"
+      
+      model.varchar_value = nil
+      model.varchar_value.should == nil
+      model.save
+      model = Cassie::TypeTester.find(:id => id)
+      model.varchar_value.should == nil
     end
     
     it "should work with ascii columns" do
-      model.ascii = "foo"
-      model.ascii.should == "foo"
-      model.ascii = nil
-      model.ascii.should == nil
+      model.ascii_value = "foo"
+      model.ascii_value.should == "foo"
+      model.save
+      id = model.id
+      model = Cassie::TypeTester.find(:id => id)
+      model.ascii_value.should == "foo"
+
+      model.ascii_value = nil
+      model.ascii_value.should == nil
+      model.save
+      model = Cassie::TypeTester.find(:id => id)
+      model.ascii_value.should == nil
     end
     
     it "should work with text columns" do
-      model.text = "foo"
-      model.text.should == "foo"
-      model.text = nil
-      model.text.should == nil
+      model.text_value = "foo"
+      model.text_value.should == "foo"
+      model.save
+      id = model.id
+      model = Cassie::TypeTester.find(:id => id)
+      model.text_value.should == "foo"
+
+      model.text_value = nil
+      model.text_value.should == nil
+      model.save
+      model = Cassie::TypeTester.find(:id => id)
+      model.text_value.should == nil
     end
     
     it "should work with blob columns" do
-      model.blob = "foo"
-      model.blob.should == "foo"
-      model.blob = nil
-      model.blob.should == nil
+      model.blob_value = "foo"
+      model.blob_value.should == "foo"
+      model.save
+      id = model.id
+      model = Cassie::TypeTester.find(:id => id)
+      model.blob_value.should == "foo"
+
+      model.blob_value = nil
+      model.blob_value.should == nil
+      model.save
+      model = Cassie::TypeTester.find(:id => id)
+      model.blob_value.should == nil
     end
     
     it "should work with int columns" do
-      model.int = "1"
-      model.int.should == 1
-      model.int = 2
-      model.int.should == 2
-      model.int = nil
-      model.int.should == nil
+      model.int_value = "1"
+      model.int_value.should == 1
+      model.int_value = 2
+      model.int_value.should == 2
+      model.save
+      id = model.id
+      model = Cassie::TypeTester.find(:id => id)
+      model.int_value.should == 2
+
+      model.int_value = nil
+      model.int_value.should == nil
+      model.save
+      model = Cassie::TypeTester.find(:id => id)
+      model.int_value.should == nil
     end
     
     it "should work with bigint columns" do
-      model.bigint = "1"
-      model.bigint.should == 1
-      model.bigint = 2
-      model.bigint.should == 2
-      model.bigint = nil
-      model.bigint.should == nil
+      model.bigint_value = "1"
+      model.bigint_value.should == 1
+      model.bigint_value = 2
+      model.bigint_value.should == 2
+      model.save
+      id = model.id
+      model = Cassie::TypeTester.find(:id => id)
+      model.bigint_value.should == 2
+
+      model.bigint_value = nil
+      model.bigint_value.should == nil
+      model.save
+      model = Cassie::TypeTester.find(:id => id)
+      model.bigint_value.should == nil
     end
     
     it "should work with varint columns" do
-      model.varint = "1"
-      model.varint.should == 1
-      model.varint = 2
-      model.varint.should == 2
-      model.varint = nil
-      model.varint.should == nil
-    end
-    
-    it "should work with counter columns" do
-      model.counter = "1"
-      model.counter.should == 1
-      model.counter = 2
-      model.counter.should == 2
-      model.counter = nil
-      model.counter.should == nil
+      model.varint_value = "1"
+      model.varint_value.should == 1
+      model.varint_value = 2
+      model.varint_value.should == 2
+      model.save
+      id = model.id
+      model = Cassie::TypeTester.find(:id => id)
+      model.varint_value.should == 2
+
+      model.varint_value = nil
+      model.varint_value.should == nil
+      model.save
+      model = Cassie::TypeTester.find(:id => id)
+      model.varint_value.should == nil
     end
     
     it "should work with float columns" do
-      model.float = "1.1"
-      model.float.should == 1.1
-      model.float = 2.2
-      model.float.should == 2.2
-      model.float = nil
-      model.float.should == nil
+      model.float_value = "1.1"
+      model.float_value.should == 1.1
+      model.float_value = 2.2
+      model.float_value.should == 2.2
+      model.save
+      id = model.id
+      model = Cassie::TypeTester.find(:id => id)
+      model.float_value.round(4).should == 2.2
+
+      model.float_value = nil
+      model.float_value.should == nil
+      model.save
+      model = Cassie::TypeTester.find(:id => id)
+      model.float_value.should == nil
     end
     
     it "should work with double columns" do
-      model.double = "1.1"
-      model.double.should == 1.1
-      model.double = 2.2
-      model.double.should == 2.2
-      model.double = nil
-      model.double.should == nil
+      model.double_value = "1.1"
+      model.double_value.should == 1.1
+      model.double_value = 2.2
+      model.double_value.should == 2.2
+      model.save
+      id = model.id
+      model = Cassie::TypeTester.find(:id => id)
+      model.double_value.should == 2.2
+
+      model.double_value = nil
+      model.double_value.should == nil
+      model.save
+      model = Cassie::TypeTester.find(:id => id)
+      model.double_value.should == nil
     end
     
     it "should work with decimal columns" do
-      model.decimal = "1.1"
-      model.decimal.should == 1.1
-      model.decimal.should be_a(BigDecimal)
-      model.decimal = BigDecimal.new("3.3", 2)
-      model.decimal.should == BigDecimal.new("3.3", 2)
-      model.decimal = nil
-      model.decimal.should == nil
+      model.decimal_value = "1.1"
+      model.decimal_value.should == 1.1
+      model.decimal_value.should be_a(BigDecimal)
+      model.decimal_value = BigDecimal.new("3.3", 2)
+      model.decimal_value.should == BigDecimal.new("3.3", 2)
+      model.save
+      id = model.id
+      model = Cassie::TypeTester.find(:id => id)
+      model.decimal_value.should == BigDecimal.new("3.3", 2)
+
+      model.decimal_value = nil
+      model.decimal_value.should == nil
+      model.save
+      model = Cassie::TypeTester.find(:id => id)
+      model.decimal_value.should == nil
     end
     
     it "should work with timestamp columns" do
-      model.timestamp = "2015-04-23T15:23:30"
-      model.timestamp.should == Time.new(2015, 4, 23, 15, 23, 30)
-      model.timestamp = Time.new(2015, 4, 23, 15, 25, 30)
-      model.timestamp.should == Time.new(2015, 4, 23, 15, 25, 30)
-      model.timestamp = nil
-      model.timestamp.should == nil
+      model.timestamp_value = "2015-04-23T15:23:30"
+      model.timestamp_value.should == Time.new(2015, 4, 23, 15, 23, 30)
+      model.timestamp_value = Time.new(2015, 4, 23, 15, 25, 30)
+      model.timestamp_value.should == Time.new(2015, 4, 23, 15, 25, 30)
+      model.save
+      id = model.id
+      model = Cassie::TypeTester.find(:id => id)
+      model.timestamp_value.should == Time.new(2015, 4, 23, 15, 25, 30)
+
+      model.timestamp_value = nil
+      model.timestamp_value.should == nil
+      model.save
+      model = Cassie::TypeTester.find(:id => id)
+      model.timestamp_value.should == nil
     end
     
     it "should work with boolean columns" do
-      model.boolean = true
-      model.boolean.should == true
-      model.boolean = false
-      model.boolean.should == false
-      model.boolean = nil
-      model.boolean.should == nil
+      model.boolean_value = true
+      model.boolean_value.should == true
+      model.boolean_value = false
+      model.boolean_value.should == false
+      model.save
+      id = model.id
+      model = Cassie::TypeTester.find(:id => id)
+      model.boolean_value.should == false
+
+      model.boolean_value = nil
+      model.boolean_value.should == nil
+      model.save
+      model = Cassie::TypeTester.find(:id => id)
+      model.boolean_value.should == nil
     end
     
     it "should work with inet columns" do
-      model.inet = "127.0.0.1"
-      model.inet.should == IPAddr.new("127.0.0.1")
-      model.inet = IPAddr.new("10.1.0.1")
-      model.inet.should == IPAddr.new("10.1.0.1")
-      model.inet = nil
-      model.inet.should == nil
+      model.inet_value = "127.0.0.1"
+      model.inet_value.should == IPAddr.new("127.0.0.1")
+      model.inet_value = IPAddr.new("10.1.0.1")
+      model.inet_value.should == IPAddr.new("10.1.0.1")
+      model.save
+      id = model.id
+      model = Cassie::TypeTester.find(:id => id)
+      model.inet_value.should == IPAddr.new("10.1.0.1")
+      
+      model.inet_value = nil
+      model.inet_value.should == nil
+      model.save
+      model = Cassie::TypeTester.find(:id => id)
+      model.inet_value.should == nil
     end
     
     it "should work with uuid columns" do
-      model.uuid = "eed6d678-ea0b-11e4-8772-793f91a64daf"
-      model.uuid.should == Cassandra::Uuid.new("eed6d678-ea0b-11e4-8772-793f91a64daf")
-      model.uuid = Cassandra::Uuid.new("fed6d678-ea0b-11e4-8772-793f91a64daf")
-      model.uuid.should == Cassandra::Uuid.new("fed6d678-ea0b-11e4-8772-793f91a64daf")
-      model.uuid = nil
-      model.uuid.should == nil
+      model.uuid_value = "eed6d678-ea0b-11e4-8772-793f91a64daf"
+      model.uuid_value.should == Cassandra::Uuid.new("eed6d678-ea0b-11e4-8772-793f91a64daf")
+      model.uuid_value = Cassandra::Uuid.new("fed6d678-ea0b-11e4-8772-793f91a64daf")
+      model.uuid_value.should == Cassandra::Uuid.new("fed6d678-ea0b-11e4-8772-793f91a64daf")
+      model.save
+      id = model.id
+      model = Cassie::TypeTester.find(:id => id)
+      model.uuid_value.should == Cassandra::Uuid.new("fed6d678-ea0b-11e4-8772-793f91a64daf")
+
+      model.uuid_value = nil
+      model.uuid_value.should == nil
+      model.save
+      model = Cassie::TypeTester.find(:id => id)
+      model.uuid_value.should == nil
     end
     
     it "should work with timeuuid columns" do
-      model.timeuuid = "eed6d678-ea0b-11e4-8772-793f91a64daf"
-      model.timeuuid.should == Cassandra::TimeUuid.new("eed6d678-ea0b-11e4-8772-793f91a64daf")
-      model.timeuuid = Cassandra::TimeUuid.new("fed6d678-ea0b-11e4-8772-793f91a64daf")
-      model.timeuuid.should == Cassandra::TimeUuid.new("fed6d678-ea0b-11e4-8772-793f91a64daf")
-      model.timeuuid = nil
-      model.timeuuid.should == nil
+      model.timeuuid_value = "eed6d678-ea0b-11e4-8772-793f91a64daf"
+      model.timeuuid_value.should == Cassandra::TimeUuid.new("eed6d678-ea0b-11e4-8772-793f91a64daf")
+      model.timeuuid_value = Cassandra::TimeUuid.new("fed6d678-ea0b-11e4-8772-793f91a64daf")
+      model.timeuuid_value.should == Cassandra::TimeUuid.new("fed6d678-ea0b-11e4-8772-793f91a64daf")
+      model.save
+      id = model.id
+      model = Cassie::TypeTester.find(:id => id)
+      model.timeuuid_value.should == Cassandra::TimeUuid.new("fed6d678-ea0b-11e4-8772-793f91a64daf")
+
+      model.timeuuid_value = nil
+      model.timeuuid_value.should == nil
+      model.save
+      model = Cassie::TypeTester.find(:id => id)
+      model.timeuuid_value.should == nil
     end
     
     it "should work with list columns" do
-      model.list = ["a", "b", "c"]
-      model.list.should == ["a", "b", "c"]
-      model.list = nil
-      model.list.should == nil
+      model.list_value = ["a", "b", "c"]
+      model.list_value.should == ["a", "b", "c"]
+      model.save
+      id = model.id
+      model = Cassie::TypeTester.find(:id => id)
+      model.list_value.should == ["a", "b", "c"]
+
+      model.list_value = nil
+      model.list_value.should == nil
+      model.save
+      model = Cassie::TypeTester.find(:id => id)
+      model.list_value.should == nil
     end
     
     it "should work with set columns" do
-      model.set = ["a", "b", "c", "a"]
-      model.set.should == ["a", "b", "c"].to_set
-      model.set = nil
-      model.set.should == nil
+      model.set_value = ["a", "b", "c", "a"]
+      model.set_value.should == ["a", "b", "c"].to_set
+      model.save
+      id = model.id
+      model = Cassie::TypeTester.find(:id => id)
+      model.set_value.should == ["a", "b", "c"].to_set
+
+      model.set_value = nil
+      model.set_value.should == nil
+      model.save
+      model = Cassie::TypeTester.find(:id => id)
+      model.set_value.should == nil
     end
     
     it "should work with map columns" do
-      model.map = [["a", "b"], ["c", "d"]]
-      model.map.should == {"a" => "b", "c" => "d"}
-      model.map = {"e" => "f", "g" => "h"}
-      model.map.should == {"e" => "f", "g" => "h"}
-      model.map = nil
-      model.map.should == nil
+      model.map_value = [["a", "b"], ["c", "d"]]
+      model.map_value.should == {"a" => "b", "c" => "d"}
+      model.map_value = {"e" => "f", "g" => "h"}
+      model.map_value.should == {"e" => "f", "g" => "h"}
+      model.save
+      id = model.id
+      model = Cassie::TypeTester.find(:id => id)
+      model.map_value.should == {"e" => "f", "g" => "h"}
+
+      model.map_value = nil
+      model.map_value.should == nil
+      model.save
+      model = Cassie::TypeTester.find(:id => id)
+      model.map_value.should == nil
+    end
+    
+    it "should work with counter columns" do
+      id = SecureRandom.uuid
+      model = Cassie::TypeTesterCounter.new(:id => id)
+      model.counter_value.should == 0
+      model.increment_counter_value!
+      model.counter_value.should == 1
+      model = Cassie::TypeTesterCounter.find(:id => id)
+      model.counter_value.should == 1
+
+      model.increment_counter_value!
+      model.counter_value.should == 2
+      model = Cassie::TypeTesterCounter.find(:id => id)
+      model.counter_value.should == 2
+      
+      model.decrement_counter_value!
+      model.counter_value.should == 1
+      model = Cassie::TypeTesterCounter.find(:id => id)
+      model.counter_value.should == 1
     end
   end
 end

data/spec/models/type_tester.rb

@@ -1,23 +1,42 @@
+require 'securerandom'
+
 class Cassie::TypeTester
   include Cassie::Model
   
-  column :int, :int
-  column :varint, :varint
-  column :bigint, :bigint
-  column :float, :float
-  column :double, :double
-  column :decimal, :decimal
-  column :ascii, :ascii
-  column :varchar, :varchar
-  column :text, :text
-  column :blob, :blob
-  column :boolean, :boolean
-  column :timestamp, :timestamp
-  column :counter, :counter
-  column :uuid, :uuid
-  column :timeuuid, :timeuuid
-  column :inet, :inet
-  column :list, :list
-  column :set, :set
-  column :map, :map
+  self.table_name = "type_testers"
+  self.keyspace = "test"
+  self.primary_key = [:id]
+  
+  column :id, :varchar
+  column :int_value, :int
+  column :varint_value, :varint
+  column :bigint_value, :bigint
+  column :float_value, :float
+  column :double_value, :double
+  column :decimal_value, :decimal
+  column :ascii_value, :ascii
+  column :varchar_value, :varchar
+  column :text_value, :text
+  column :blob_value, :blob
+  column :boolean_value, :boolean
+  column :timestamp_value, :timestamp
+  column :uuid_value, :uuid
+  column :timeuuid_value, :timeuuid
+  column :inet_value, :inet
+  column :list_value, :list
+  column :set_value, :set
+  column :map_value, :map
+  
+  before_create{ self.id = SecureRandom.uuid }
+end
+
+class Cassie::TypeTesterCounter
+  include Cassie::Model
+  
+  self.table_name = "type_tester_counters"
+  self.keyspace = "test"
+  self.primary_key = [:id]
+  
+  column :id, :varchar
+  column :counter_value, :counter, as: :counter_column
 end

data/spec/schema/test.cql

@@ -3,4 +3,33 @@ CREATE TABLE things (
   id INT,
   val VARCHAR,
   PRIMARY KEY (owner, id)
-) WITH CLUSTERING ORDER BY (id DESC)
+) WITH CLUSTERING ORDER BY (id DESC);
+
+CREATE TABLE type_testers (
+  id VARCHAR,
+  int_value INT,
+  varint_value VARINT,
+  bigint_value BIGINT,
+  float_value FLOAT,
+  double_value DOUBLE,
+  decimal_value DECIMAL,
+  ascii_value ASCII,
+  varchar_value VARCHAR,
+  text_value TEXT,
+  blob_value BLOB,
+  boolean_value BOOLEAN,
+  timestamp_value TIMESTAMP,
+  uuid_value UUID,
+  timeuuid_value TIMEUUID,
+  inet_value INET,
+  list_value LIST<VARCHAR>,
+  set_value SET<VARCHAR>,
+  map_value MAP<VARCHAR, VARCHAR>,
+  PRIMARY KEY (id)
+);
+
+CREATE TABLE type_tester_counters (
+  id VARCHAR,
+  counter_value COUNTER,
+  PRIMARY KEY (id)
+);

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: whi-cassie
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.3
 platform: ruby
 authors:
 - We Heart It
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-25 00:00:00.000000000 Z
+date: 2016-03-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cassandra-driver