cassandra_migrations 0.0.4 → 0.0.5

data/lib/cassandra_migrations/cassandra/queries.rb

@@ -10,7 +10,7 @@ module CassandraMigrations
         
         value_hash.each do |column, value| 
           columns << column.to_s
-          values << to_cql_value(value)
+          values << to_cql_value(column, value, table, options)
         end
     
         query = "INSERT INTO #{table} (#{columns.join(', ')}) VALUES (#{values.join(', ')})"
@@ -25,7 +25,7 @@ module CassandraMigrations
       def update!(table, selection, value_hash, options={})
         set_terms = []
         value_hash.each do |column, value| 
-          set_terms << "#{column} = #{to_cql_value(value)}"
+          set_terms << "#{column} = #{to_cql_value(column, value, table, options)}"
         end
         
         query = "UPDATE #{table}"
@@ -53,6 +53,10 @@ module CassandraMigrations
         if options[:limit]
           query_string << " LIMIT #{options[:limit]}"
         end
+        
+        if options[:allow_filtering]
+          query_string << " ALLOW FILTERING"
+        end
     
         execute(query_string)
       end
@@ -68,13 +72,49 @@ module CassandraMigrations
       
     private
     
-      def to_cql_value(value)
+      def get_column_type(table, column)
+        column_info = client.execute("SELECT VALIDATOR FROM system.schema_columns WHERE keyspace_name = '#{client.keyspace}' AND columnfamily_name = '#{table}' AND column_name = '#{column}'")
+        raw_type = column_info.first['validator']
+        
+        case
+          when raw_type.include?('SetType'); :set
+          when raw_type.include?('ListType'); :list
+          when raw_type.include?('MapType'); :map
+          when raw_type.include?('BooleanType'); :boolean
+          when raw_type.include?('FloatType'); :float
+          when raw_type.include?('Int32Type'); :int
+          when raw_type.include?('DateType'); :timestamp
+          when raw_type.include?('UTF8Type'); :string
+          when raw_type.include?('BytesType'); :blob
+          when raw_type.include?('UUIDType'); :uuid
+          when raw_type.include?('DoubleType'); :double
+          when raw_type.include?('InetAddressType'); :inet
+          when raw_type.include?('AsciiType'); :ascii
+          when raw_type.include?('LongType'); :bigint          
+          when raw_type.include?('DecimalType'); :decimal   
+          when raw_type.include?('TimeUUIDType'); :timeuuid    
+        end
+      end
+    
+      def to_cql_value(column, value, table, options={})
+        operator = options[:operations] ? options[:operations][column.to_sym] : nil
+        operation = operator ? "#{column} #{operator} " : ''
+        
         if value.respond_to?(:strftime)
           "'#{value.strftime('%Y-%m-%d %H:%M:%S%z')}'"
         elsif value.is_a?(String)
-          "'#{value}'"          
-	elsif value.is_a?(Hash)
-          "{ #{value.reduce([]) {|sum, (key, value)| sum << "'#{key}': '#{value}'" }.join(", ") } }"
+          "'#{value}'"   
+        elsif value.is_a?(Array)
+          type = get_column_type(table, column)
+          values = %[#{value.map {|v| "'#{v}'"} * ', '}] 
+          
+          if type && type == :list
+            %[#{operation}[#{values}]]
+          else # it must be a set!
+            %[#{operation}{#{values}}]
+          end
+        elsif value.is_a?(Hash)
+          "#{operation}{ #{value.reduce([]) {|sum, (key, value)| sum << "'#{key}': '#{value}'" }.join(", ") } }"
         else
           value.to_s
         end

data/lib/cassandra_migrations/migration/table_definition.rb

@@ -26,13 +26,13 @@ module CassandraMigrations
             cql << "#{column_name} #{type}"
           end
         else
-          raise Errors::MigrationDefinitionError('No columns defined for table.')
+          raise Errors::MigrationDefinitionError, 'No columns defined for table.'
         end
 
         if !@primary_keys.empty?
           cql << "PRIMARY KEY(#{@primary_keys.join(', ')})"
         else
-          raise Errors::MigrationDefinitionError('No primary key defined.')
+          raise Errors::MigrationDefinitionError, 'No primary key defined.'
         end
         
         cql.join(', ')
@@ -44,78 +44,138 @@ module CassandraMigrations
         if @columns_name_type_hash.size == 1
           cql = "#{@columns_name_type_hash.keys.first} #{@columns_name_type_hash.values.first}"
         elsif @columns_name_type_hash.empty?
-          raise Errors::MigrationDefinitionError('No column to add.')
+          raise Errors::MigrationDefinitionError, 'No column to add.'
         else
-          raise Errors::MigrationDefinitionError('Only one column can be added at once.')
+          raise Errors::MigrationDefinitionError, 'Only one column can be added at once.'
         end
         
         cql
       end
       
       def boolean(column_name, options={})
-        @columns_name_type_hash[column_name.to_sym] = :boolean
+        @columns_name_type_hash[column_name.to_sym] = column_type_for(:boolean, options)
         define_primary_keys(column_name) if options[:primary_key]
       end
       
       def integer(column_name, options={})
-        if options[:limit].nil? || options[:limit] == 4
-          @columns_name_type_hash[column_name.to_sym] = :int
-        elsif options[:limit] == 8
-          @columns_name_type_hash[column_name.to_sym] = :bigint
-        else
-          raise Errors::MigrationDefinitionError(':limit option should be 4 or 8 for integers.')
-        end 
+        @columns_name_type_hash[column_name.to_sym] = column_type_for(:integer, options) 
         define_primary_keys(column_name) if options[:primary_key]
       end
       
       def float(column_name, options={})
-        if options[:limit].nil? || options[:limit] == 4
-          @columns_name_type_hash[column_name.to_sym] = :float
-        elsif options[:limit] == 8
-          @columns_name_type_hash[column_name.to_sym] = :double
-        else
-          raise Errors::MigrationDefinitionError(':limit option should be 4 or 8 for floats.')
-        end
+        @columns_name_type_hash[column_name.to_sym] = column_type_for(:float, options) 
         define_primary_keys(column_name) if options[:primary_key]
       end
       
       def string(column_name, options={})
-        @columns_name_type_hash[column_name.to_sym] = :varchar
+        @columns_name_type_hash[column_name.to_sym] = column_type_for(:string, options)
         define_primary_keys(column_name) if options[:primary_key]
       end
       
       def text(column_name, options={})
-        @columns_name_type_hash[column_name.to_sym] = :text
+        @columns_name_type_hash[column_name.to_sym] = column_type_for(:text, options)
         define_primary_keys(column_name) if options[:primary_key]
       end
       
       def datetime(column_name, options={})
-        @columns_name_type_hash[column_name.to_sym] = :timestamp
+        @columns_name_type_hash[column_name.to_sym] = column_type_for(:datetime, options)
         define_primary_keys(column_name) if options[:primary_key]
       end
       
       def timestamp(column_name, options={})
-        @columns_name_type_hash[column_name.to_sym] = :timestamp
+        @columns_name_type_hash[column_name.to_sym] = column_type_for(:timestamp, options)
         define_primary_keys(column_name) if options[:primary_key]
       end
       
       def uuid(column_name, options={})
-        @columns_name_type_hash[column_name.to_sym] = :uuid
+        @columns_name_type_hash[column_name.to_sym] = column_type_for(:uuid, options)
         define_primary_keys(column_name) if options[:primary_key]
       end
       
       def timeuuid(column_name, options={})
-        @columns_name_type_hash[column_name.to_sym] = :timeuuid
+        @columns_name_type_hash[column_name.to_sym] = column_type_for(:timeuuid, options)
         define_primary_keys(column_name) if options[:primary_key]
       end
       
+      def list(column_name, options={})
+        type = options[:type]
+        if type.nil?
+          raise Errors::MigrationDefinitionError, 'A list must define a collection type.'
+        elsif !self.respond_to?(type)
+          raise Errors::MigrationDefinitionError, "Type '#{type}' is not valid for cassandra migration."
+        end
+        if options[:primary_key]
+          raise Errors::MigrationDefinitionError, 'A collection cannot be used as a primary key.'
+        end
+        @columns_name_type_hash[column_name.to_sym] = :"list<#{column_type_for(type)}>"
+      end
+      
+      def set(column_name, options={})
+        type = options[:type]
+        if type.nil?
+          raise Errors::MigrationDefinitionError, 'A set must define a collection type.'
+        elsif !self.respond_to?(type)
+          raise Errors::MigrationDefinitionError, "Type '#{type}' is not valid for cassandra migration."
+        end
+        if options[:primary_key]
+          raise Errors::MigrationDefinitionError, 'A collection cannot be used as a primary key.'
+        end
+        @columns_name_type_hash[column_name.to_sym] = :"set<#{column_type_for(type)}>"
+      end
+      
+      def map(column_name, options={})
+        key_type, value_type = options[:key_type], options[:value_type]
+        [key_type, value_type].each_with_index do |type, index|
+          if type.nil?
+            raise Errors::MigrationDefinitionError, "A map must define a #{index = 0 ? 'key' : 'value'} type." 
+          elsif !self.respond_to?(type)
+            raise Errors::MigrationDefinitionError, "Type '#{type}' is not valid for cassandra migration."
+          end
+        end
+
+        if options[:primary_key]
+          raise Errors::MigrationDefinitionError, 'A collection cannot be used as a primary key.'
+        end
+        @columns_name_type_hash[column_name.to_sym] = :"map<#{column_type_for(key_type)},#{column_type_for(value_type)}>"        
+      end
+      
       def define_primary_keys(*keys)
         if !@primary_keys.empty?
-          raise Errors::MigrationDefinitionError('Primary key defined twice for the same table.')
+          raise Errors::MigrationDefinitionError, 'Primary key defined twice for the same table.'
         end
         
         @primary_keys = keys.flatten
       end
+      
+      private
+      
+        def column_type_for(ruby_type, options={})
+          limit = options[:limit]
+          case ruby_type
+            when :boolean, :text, :timestamp, :uuid, :timeuuid
+              ruby_type
+            when :integer
+              if limit.nil? || limit == 4
+                :int
+              elsif limit == 8
+                :bigint
+              else
+                raise Errors::MigrationDefinitionError, ':limit option should be 4 or 8 for integers.'
+              end
+            when :float
+              if limit.nil? || limit == 4
+                :float
+              elsif limit == 8
+                :double
+              else
+                raise Errors::MigrationDefinitionError, ':limit option should be 4 or 8 for floats.'
+              end
+            when :string
+              :varchar
+            when :datetime
+              :timestamp
+          end
+        end
     end
   end
 end

data/lib/cassandra_migrations/migration/table_operations.rb

@@ -33,6 +33,14 @@ module CassandraMigrations
         execute create_cql
       end
       
+      def create_index(table_name, column_name, options = {})
+        announce_operation "create_index(#{table_name})"
+        create_index_cql = "CREATE INDEX #{options[:name]} ON #{table_name} (#{column_name})".squeeze(' ')
+        announce_suboperation create_index_cql
+        
+        execute create_index_cql
+      end
+      
       # Drops a table
       def drop_table(table_name)
         announce_operation "drop_table(#{table_name})"
@@ -41,6 +49,19 @@ module CassandraMigrations
         
         execute drop_cql
       end
+      
+      def drop_index(table_or_index_name, column_name = nil, options = {})
+        if column_name
+          index_name = "#{table_or_index_name}_#{column_name}_idx"
+        else
+          index_name = table_or_index_name
+        end
+        drop_index_cql = "DROP INDEX #{options[:if_exists] ? 'IF EXISTS' : ''}#{index_name}"
+        announce_suboperation drop_index_cql
+        
+        execute drop_index_cql        
+      end
+
     end
   end
 end

data/spec/cassandra_migrations/cassandra/queries_spec.rb

@@ -5,6 +5,16 @@ describe CassandraMigrations::Cassandra::Queries do
   
   class TestQueryExecutor
     extend CassandraMigrations::Cassandra::Queries
+    
+    def self.column_type=(column_type)
+      @column_type = column_type
+    end
+    
+    private 
+    
+      def self.get_column_type(table, column)
+        @column_type
+      end
   end
   
   describe '.write!' do
@@ -28,6 +38,39 @@ describe CassandraMigrations::Cassandra::Queries do
       
       TestQueryExecutor.write!('people', {:name => 'John'}, :ttl => 3600)
     end
+    
+    context 'when dealing with collections' do
+      
+      it 'should handle setting a set collection column value' do
+        TestQueryExecutor.column_type = :set
+        
+        TestQueryExecutor.should_receive(:execute).with(
+          "INSERT INTO people (friends) VALUES ({'John', 'Ringo', 'Paul', 'George'})"
+        )
+      
+        TestQueryExecutor.write!('people', {friends: ['John', 'Ringo', 'Paul', 'George']})
+      end
+      
+      it 'should handle setting a list collection column value' do
+        TestQueryExecutor.column_type = :list
+        
+        TestQueryExecutor.should_receive(:execute).with(
+          "INSERT INTO people (friends) VALUES (['John', 'Ringo', 'Paul', 'George'])"
+        )
+      
+        TestQueryExecutor.write!('people', {friends: ['John', 'Ringo', 'Paul', 'George']})
+      end
+      
+      it 'should handle setting a map collection column value' do
+        TestQueryExecutor.column_type = :map
+        
+        TestQueryExecutor.should_receive(:execute).with(
+          "INSERT INTO people (friends) VALUES ({ 'talent': 'John', 'drums': 'Ringo', 'voice': 'Paul', 'rhythm': 'George' })"
+        )
+      
+        TestQueryExecutor.write!('people', {friends: {talent: 'John', drums: 'Ringo', voice: 'Paul', rhythm: 'George'}})
+      end
+    end
   end
   
   describe '.update!' do
@@ -49,6 +92,109 @@ describe CassandraMigrations::Cassandra::Queries do
       
       TestQueryExecutor.update!('people', "name = 'John'", {:name => 'Johnny'}, :ttl => 3600)
     end
+    
+    context 'when dealing with collections' do
+      
+      it 'should handle setting a set collection column' do
+        TestQueryExecutor.column_type = :set
+        
+        TestQueryExecutor.should_receive(:execute).with(
+          "UPDATE people SET friends = {'John', 'Ringo', 'Paul', 'George'} WHERE name = 'Stuart'"
+        )
+      
+        TestQueryExecutor.update!('people', "name = 'Stuart'", {friends: ['John', 'Ringo', 'Paul', 'George']})
+      end
+      
+      it 'should handle adding elements to a set collection column' do
+        TestQueryExecutor.column_type = :set
+        
+        TestQueryExecutor.should_receive(:execute).with(
+          "UPDATE people SET friends = friends + {'John', 'Ringo', 'Paul', 'George'} WHERE name = 'Stuart'"
+        )
+      
+        TestQueryExecutor.update!('people', "name = 'Stuart'", 
+                                            {friends: ['John', 'Ringo', 'Paul', 'George']},
+                                            {operations: {friends: :+}})
+      end
+
+      it 'should handle removing elements from a set collection column' do
+        TestQueryExecutor.column_type = :set
+        
+        TestQueryExecutor.should_receive(:execute).with(
+          "UPDATE people SET friends = friends - {'John', 'Ringo', 'Paul', 'George'} WHERE name = 'Stuart'"
+        )
+      
+        TestQueryExecutor.update!('people', "name = 'Stuart'", 
+                                            {friends: ['John', 'Ringo', 'Paul', 'George']},
+                                            {operations: {friends: :-}})
+      end
+      
+      it 'should handle setting a list collection column' do
+        TestQueryExecutor.column_type = :list
+        
+        TestQueryExecutor.should_receive(:execute).with(
+          "UPDATE people SET friends = ['John', 'Ringo', 'Paul', 'George'] WHERE name = 'Stuart'"
+        )
+      
+        TestQueryExecutor.update!('people', "name = 'Stuart'", {friends: ['John', 'Ringo', 'Paul', 'George']})
+      end
+      
+      it 'should handle adding elements to a list collection column' do
+        TestQueryExecutor.column_type = :list
+        
+        TestQueryExecutor.should_receive(:execute).with(
+          "UPDATE people SET friends = friends + ['John', 'Ringo', 'Paul', 'George'] WHERE name = 'Stuart'"
+        )
+      
+        TestQueryExecutor.update!('people', "name = 'Stuart'", 
+                                            {friends: ['John', 'Ringo', 'Paul', 'George']},
+                                            {operations: {friends: :+}})
+      end
+
+      it 'should handle removing elements from a list collection column' do
+        TestQueryExecutor.column_type = :list
+        
+        TestQueryExecutor.should_receive(:execute).with(
+          "UPDATE people SET friends = friends - ['John', 'Ringo', 'Paul', 'George'] WHERE name = 'Stuart'"
+        )
+      
+        TestQueryExecutor.update!('people', "name = 'Stuart'", 
+                                            {friends: ['John', 'Ringo', 'Paul', 'George']},
+                                            {operations: {friends: :-}})
+      end      
+      
+      it 'should handle setting a map collection column' do
+        TestQueryExecutor.column_type = :map
+        
+        TestQueryExecutor.should_receive(:execute).with(
+          "UPDATE people SET friends = { 'talent': 'John', 'drums': 'Ringo', 'voice': 'Paul', 'rhythm': 'George' } WHERE name = 'Stuart'"
+        )
+      
+        TestQueryExecutor.update!('people', "name = 'Stuart'", {friends: {talent: 'John', drums: 'Ringo', voice: 'Paul', rhythm: 'George'}})
+      end
+      
+      it 'should handle adding elements to a map collection column' do
+        TestQueryExecutor.column_type = :map
+        
+        TestQueryExecutor.should_receive(:execute).with(
+          "UPDATE people SET friends = friends + { 'talent': 'John', 'drums': 'Ringo', 'voice': 'Paul', 'rhythm': 'George' } WHERE name = 'Stuart'"
+        )
+      
+        TestQueryExecutor.update!('people', "name = 'Stuart'", 
+                                            {friends: {talent: 'John', drums: 'Ringo', voice: 'Paul', rhythm: 'George'}},
+                                            {operations: {friends: :+}})
+      end
+      
+      it 'should handle removing elements from a map collection column' do
+        TestQueryExecutor.column_type = :map
+        
+        TestQueryExecutor.should_receive(:execute).with(
+          "DELETE friends['drums'] FROM people WHERE name = 'Stuart'"
+        )
+      
+        TestQueryExecutor.delete!('people', "name = 'Stuart'", :projection => "friends['drums']")
+      end
+    end
   end
   
   describe '.select' do

data/spec/cassandra_migrations_spec.rb

@@ -1,7 +1,26 @@
 # encoding : utf-8
 require 'spec_helper'
 
+module CassandraMigrations
+  
+  # Temporarily monkey path Migration to allow for testing generated CQL
+  # and suppress announcements
+  class Migration
+    attr_reader :cql
+    
+    def execute(cql)
+      @cql = cql
+    end
+    
+    private
+      def announce_migration(message); end
+      def announce_operation(message); end
+      def announce_suboperation(message); end
+  end
+end
+
 describe CassandraMigrations do
+  
   it "should define modules" do
     defined?(CassandraMigrations).should be_true
     defined?(CassandraMigrations::Railtie).should be_true
@@ -11,4 +30,139 @@ describe CassandraMigrations do
     defined?(CassandraMigrations::Migrator).should be_true
     defined?(CassandraMigrations::Config).should be_true
   end
+  
+  context 'a migration' do
+    before do
+      require_relative 'fixtures/migrations/migrations'
+    end
+    
+    context 'without a primary key' do
+      before do
+        @migration = WithoutAPrimaryKey.new
+      end
+      
+      it 'should be invalid' do
+        expect { @migration.up }.to raise_error(CassandraMigrations::Errors::MigrationDefinitionError, /No primary key defined./)
+      end
+    end
+    
+    context 'that is valid' do
+      before do
+        @migration = CreateKitchenSink.new
+      end
+      
+      it 'should have a name' do
+        expect(@migration.send(:name)).to eq('CreateKitchenSink')
+      end
+      
+      it 'should produce a valid CQL create statement' do
+        @migration.up
+        expected_cql = "CREATE TABLE kitchen_sink (id uuid, a_string varchar, a_timestamp timestamp, a_float float, a_list_of_strings list<varchar>, PRIMARY KEY(id))"
+        expect(@migration.cql).to eq(expected_cql)
+      end
+    end
+    
+    context 'with a list collection column declaration' do
+      before do
+        @migration = CollectionsListMigration.new
+      end
+      
+      it 'should produce a valid CQL create statement' do
+        @migration.up
+        expected_cql = "CREATE TABLE collection_lists (id uuid, list_1 list<varchar>, PRIMARY KEY(id))"
+        expect(@migration.cql).to eq(expected_cql)
+      end
+      
+      context 'using invalid types' do
+        before do
+          @migration = BadCollectionsListMigration.new
+        end
+
+        it 'should be invalid' do
+          expect { @migration.up }.to raise_error(CassandraMigrations::Errors::MigrationDefinitionError, /Type 'chupacabra' is not valid for cassandra migration./)
+        end
+      end
+    end
+    
+    context 'with a set collection column declaration' do
+      before do
+        @migration = CollectionsSetMigration.new
+      end
+      
+      it 'should produce a valid CQL create statement' do
+        @migration.up
+        expected_cql = "CREATE TABLE collection_lists (id uuid, set_2 set<float>, PRIMARY KEY(id))"
+        expect(@migration.cql).to eq(expected_cql)
+      end
+      
+      context 'using invalid types' do
+        before do
+          @migration = BadCollectionsSetMigration.new
+        end
+
+        it 'should be invalid' do
+          expect { @migration.up }.to raise_error(CassandraMigrations::Errors::MigrationDefinitionError, /Type 'narwhal' is not valid for cassandra migration./)
+        end
+      end
+    end
+    
+    context 'with a map collection column declaration' do
+      before do
+        @migration = CollectionsMapMigration.new
+      end
+      
+      it 'should produce a valid CQL create statement' do
+        @migration.up
+        expected_cql = "CREATE TABLE collection_lists (id uuid, map_1 map<varchar,float>, PRIMARY KEY(id))"
+        expect(@migration.cql).to eq(expected_cql)
+      end
+      
+      context 'using invalid types' do
+        before do
+          @migration = BadCollectionsMapMigration.new
+        end
+
+        it 'should be invalid' do
+          expect { @migration.up }.to raise_error(CassandraMigrations::Errors::MigrationDefinitionError, /Type 'unicorns' is not valid for cassandra migration./)
+        end
+      end
+    end
+    
+    context 'with an secondary index definition' do
+      before do
+        @migration = MigrationWithSecondaryIndex.new
+      end
+      
+      it 'should produce a valid CQL create statement' do
+        @migration.up
+        expected_cql = "CREATE INDEX ON with_indexes (a_string)"
+        expect(@migration.cql).to eq(expected_cql)
+      end
+      
+      it 'should produce a valid CQL drop statement' do
+        @migration.down
+        expected_cql = "DROP INDEX with_indexes_a_string_idx"
+        expect(@migration.cql).to eq(expected_cql)
+      end
+    end
+    
+    context 'with a named secondary index definition' do
+      before do
+        @migration = MigrationWithANamedSecondaryIndex.new
+      end
+      
+      it 'should produce a valid CQL create statement' do
+        @migration.up
+        expected_cql = "CREATE INDEX by_another_string ON with_indexes (another_string)"
+        expect(@migration.cql).to eq(expected_cql)
+      end
+      
+      it 'should produce a valid CQL drop statement' do
+        @migration.down
+        expected_cql = "DROP INDEX by_another_string"
+        expect(@migration.cql).to eq(expected_cql)
+      end
+    end
+
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cassandra_migrations
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
   prerelease: 
 platform: ruby
 authors: