cassandra_migrations 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c812cb0c202ab7c93f145b144dc36664734588f4
-  data.tar.gz: 5aa232dd59bcd781a41b5e6bb7f2fb2b1b50b089
+  metadata.gz: 176ea1fc4dd207d821e6e128a4753582187eb49b
+  data.tar.gz: ac4409ef8ccf0290e55c73c034991964ba47c2aa
 SHA512:
-  metadata.gz: 3eb66aa211265871e762ad3b56f1df6a79e5a0299174d3454ff38dc2b62eda8d981f591eb51efaa17331e669909c15ee53143b1f049d3440c93bd008aafb6d66
-  data.tar.gz: f3768b62b72d021660f7a6ef8bf634585ee777c8a8c84649d70d299b926e960d9121abd5ee35e619427bfaaf61498edbcdd5172dea764c6061679340dcd30f64
+  metadata.gz: 7b37cf578a202b2d26ee5e97de8b3ea6775792311d93f8b5baa8ccf39af98d17c3d6aae1dcb56d228c4ed27578898c03dabefa46db7596d0616d629a7ea210f8
+  data.tar.gz: 150fb7344b9c8eb6eae4049fa502c230de30d30df13a73492e99b99084a76f1df210f28715610046ff3772c9ed5bc5a3e8a45b3c0d4d747e3578ecbdd6b0c150

data/lib/cassandra_migrations/cassandra/queries.rb

@@ -3,122 +3,139 @@
 module CassandraMigrations
   module Cassandra
     module Queries
-  
+
       def write!(table, value_hash, options={})
         columns = []
         values = []
-        
-        value_hash.each do |column, value| 
+
+        value_hash.each do |column, value|
           columns << column.to_s
           values << to_cql_value(column, value, table, options)
         end
-    
+
         query = "INSERT INTO #{table} (#{columns.join(', ')}) VALUES (#{values.join(', ')})"
-        
+
         if options[:ttl]
           query += " USING TTL #{options[:ttl]}"
         end
-        
+
         execute(query)
       end
-      
+
       def update!(table, selection, value_hash, options={})
         set_terms = []
-        value_hash.each do |column, value| 
+        value_hash.each do |column, value|
           set_terms << "#{column} = #{to_cql_value(column, value, table, options)}"
         end
-        
+
         query = "UPDATE #{table}"
-        
+
         if options[:ttl]
           query += " USING TTL #{options[:ttl]}"
         end
-        
+
         query += " SET #{set_terms.join(', ')} WHERE #{selection}"
-        
+
         execute(query)
       end
-      
+
       def select(table, options={})
         query_string = "SELECT #{options[:projection] || '*'} FROM #{table}"
-        
+
         if options[:selection]
           query_string << " WHERE #{options[:selection]}"
         end
-        
+
         if options[:order_by]
           query_string << " ORDER BY #{options[:order_by]}"
         end
-        
+
         if options[:limit]
           query_string << " LIMIT #{options[:limit]}"
         end
-        
+
         if options[:allow_filtering]
           query_string << " ALLOW FILTERING"
         end
-    
+
         execute(query_string)
       end
-      
+
       def delete!(table, selection, options={})
         options[:projection] = options[:projection].to_s + ' ' if options[:projection]
         execute("DELETE #{options[:projection]}FROM #{table} WHERE #{selection}")
       end
-      
+
       def truncate!(table)
         execute("TRUNCATE #{table}")
       end
-      
+
     private
-    
+
+      SYMBOL_FOR_TYPE = {
+        'SetType' => :set,
+        'ListType' => :list,
+        'MapType' => :map,
+        'BooleanType' => :boolean,
+        'FloatType' => :float,
+        'Int32Type' => :int,
+        'DateType' => :timestamp,
+        'UTF8Type' => :string,
+        'BytesType' => :blob,
+        'UUIDType' => :uuid,
+        'DoubleType' => :double,
+        'InetAddressType' => :inet,
+        'AsciiType' => :ascii,
+        'LongType' => :bigint ,
+        'DecimalType' => :decimal,
+        'TimeUUIDType' => :timeuuid
+      }
+
       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
+        SYMBOL_FOR_TYPE[column_info.first['validator']]
       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')}'"
+          datetime_to_cql(value)
         elsif value.is_a?(String)
-          "'#{value}'"   
+          string_to_cql(value)
         elsif value.is_a?(Array)
-          type = get_column_type(table, column)
-          values = %[#{value.map { |v| to_cql_value(nil, v, nil) } * ', '}] 
-          
-          if type && type == :list
-            %[#{operation}[#{values}]]
-          else # it must be a set!
-            %[#{operation}{#{values}}]
-          end
+          array_value_to_cql(column, value, table, operation)
         elsif value.is_a?(Hash)
-          "#{operation}{ #{value.reduce([]) {|sum, (key, value)| sum << "'#{key}': '#{value}'" }.join(", ") } }"
+          hash_to_cql(value, operation)
         else
           value.to_s
         end
       end
+
+      def string_to_cql(value)
+        "'#{value}'"
+      end
+
+      def datetime_to_cql(value)
+        "'#{value.strftime('%Y-%m-%d %H:%M:%S%z')}'"
+      end
+
+      def array_value_to_cql(column, value, table, operation)
+        type = get_column_type(table, column)
+        values = %[#{value.map { |v| to_cql_value(nil, v, nil) } * ', '}]
+
+        if type && type == :list
+          %[#{operation}[#{values}]]
+        else # it must be a set!
+          %[#{operation}{#{values}}]
+        end
+      end
+
+      def hash_to_cql(value, operation)
+        "#{operation}{ #{value.reduce([]) {|sum, (key, value)| sum << "'#{key}': '#{value}'" }.join(", ") } }"
+      end
+
     end
   end
 end

data/lib/cassandra_migrations/cql-rb-wrapper.rb

@@ -34,7 +34,7 @@ end
 
 class Client
   def self.connect(options)
-    @cluster = Cassandra.connect(options)
+    @cluster = Cassandra.cluster(options)
     self.new(@cluster)
   end
 

data/lib/cassandra_migrations/migration/table_definition.rb

@@ -16,21 +16,21 @@ module CassandraMigrations
       #
       # C* Data Types. See http://www.datastax.com/documentation/cql/3.0/cql/cql_reference/cql_data_types_c.html
       #
-
-      # Migration  | CQL Type	| Ruby          | Description
+      # ------------------------------------------------------------------------
+      # Migration  | CQL Type	 | Ruby          | Description
       # Type       |           | Class         |
       # ------------------------------------------------------------------------
       # string     | varchar	 | String        | UTF-8 encoded string
-      # text       | text	    | String	      | UTF-8 encoded string
-      # ascii      | ascii     | String	      | US-ASCII character string
+      # text       | text	     | String	       | UTF-8 encoded string
+      # ascii      | ascii     | String	       | US-ASCII character string
       # ------------------------------------------------------------------------
       # integer(4) | int	     | Integer	     | 32-bit signed integer
-      # integer(8) | bigint	  | Fixnum        | 64-bit signed long
+      # integer(8) | bigint	   | Fixnum         | 64-bit signed long
       # varint	   | varint    | Bignum        | Arbitrary-precision integer
       # ------------------------------------------------------------------------
-      # decimal	  | decimal   | BigDecimal    | Variable-precision decimal
+      # decimal	   | decimal   | BigDecimal    | Variable-precision decimal
       # float(4)	 | float	   |               | 32-bit IEEE-754 floating point
-      # double     | double	  |	             | Float 64-bit IEEE-754 floating point
+      # double     | double	   |	             | Float 64-bit IEEE-754 floating point
       # float(8)   | double    |               |
       # ------------------------------------------------------------------------
       # boolean    | boolean	 | TrueClass     | true or false
@@ -46,19 +46,17 @@ module CassandraMigrations
       #            |           |               | bytes since epoch
       # datetime   | timestamp |               |
       # ------------------------------------------------------------------------
-      # list       | list	    | Array	       | A collection of one or more
+      # list       | list	     | Array	       | A collection of one or more
       #            |           |               | ordered elements
-      # map        | map	     | Hash	        | A JSON-style array of literals:
+      # map        | map	     | Hash	         | A JSON-style array of literals:
       #            |           |               | { literal : literal, ... }
       # set        | set	     | Set	         | A collection of one or more
       #            |           |               | elements
-      # binary     | blob	    | 	            | Arbitrary bytes (no validation),
+      # binary     | blob	     | 	             | Arbitrary bytes (no validation),
       #            |           |               | expressed as hexadecimal
       # 	         | counter   |               | Distributed counter value
       #            |           |               | (64-bit long)
-
-
-
+      # ------------------------------------------------------------------------
       def initialize()
         @columns_name_type_hash = {}
         @primary_keys = []
@@ -67,32 +65,9 @@ module CassandraMigrations
 
       def to_create_cql
         cql = []
-
-        if !@columns_name_type_hash.empty?
-          @columns_name_type_hash.each do |column_name, type|
-            cql << "#{column_name} #{type}"
-          end
-        else
-          raise Errors::MigrationDefinitionError, 'No columns defined for table.'
-        end
-
-        if (@columns_name_type_hash.values.include? :counter)
-          non_key_columns = @columns_name_type_hash.keys - @primary_keys
-          counter_columns = @columns_name_type_hash.select { |name, type| type == :counter }.keys
-          if (non_key_columns - counter_columns).present?
-            raise Errors::MigrationDefinitionError, 'Non key fields not allowed in tables with counter'
-          end
-        end
-
-        key_info = (@primary_keys - @partition_keys)
-        key_info = ["(#{@partition_keys.join(', ')})", *key_info] if @partition_keys.any?
-
-        if key_info.any?
-          cql << "PRIMARY KEY(#{key_info.join(', ')})"
-        else
-          raise Errors::MigrationDefinitionError, 'No primary key defined.'
-        end
-
+        build_name_type_cql(cql)
+        check_for_non_key_fields_in_counter_table
+        build_pk_clause(cql)
         cql.join(', ')
       end
 
@@ -188,29 +163,11 @@ module CassandraMigrations
       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)}>"
+        list_or_set(:list, column_name, options)
       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)}>"
+        list_or_set(:set, column_name, options)
       end
 
       def map(column_name, options={})
@@ -294,6 +251,50 @@ module CassandraMigrations
         end
       end
 
+      def build_name_type_cql(cql)
+        if !@columns_name_type_hash.empty?
+          @columns_name_type_hash.each do |column_name, type|
+            cql << "#{column_name} #{type}"
+          end
+        else
+          raise Errors::MigrationDefinitionError, 'No columns defined for table.'
+        end
+      end
+
+      def check_for_non_key_fields_in_counter_table
+        if (@columns_name_type_hash.values.include? :counter)
+          non_key_columns = @columns_name_type_hash.keys - @primary_keys
+          counter_columns = @columns_name_type_hash.select { |name, type| type == :counter }.keys
+          if (non_key_columns - counter_columns).present?
+            raise Errors::MigrationDefinitionError, 'Non key fields not allowed in tables with counter'
+          end
+        end
+      end
+
+      def build_pk_clause(cql)
+        key_info = (@primary_keys - @partition_keys)
+        key_info = ["(#{@partition_keys.join(', ')})", *key_info] if @partition_keys.any?
+
+        if key_info.any?
+          cql << "PRIMARY KEY(#{key_info.join(', ')})"
+        else
+          raise Errors::MigrationDefinitionError, 'No primary key defined.'
+        end
+      end
+
+      def list_or_set(collection_type, column_name, options={})
+        type = options[:type]
+        if type.nil?
+          raise Errors::MigrationDefinitionError, "A #{collection_type} 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] = :"#{collection_type}<#{column_type_for(type)}>"
+      end
+
     end
   end
 end

data/lib/cassandra_migrations/migration/table_operations.rb

@@ -4,18 +4,18 @@ require 'cassandra_migrations/migration/table_definition'
 
 module CassandraMigrations
   class Migration
-    
+
     # Module grouping methods used in migrations to make table operations like:
     # - creating tables
     # - dropping tables
     module TableOperations
-  
+
       # Creates a new table in the keyspace
       #
       # options:
       # - :primary_keys: single value or array (for compound primary keys). If
-      # not defined, some column must be chosen as primary key in the table definition. 
-      
+      # not defined, some column must be chosen as primary key in the table definition.
+
       def create_table(table_name, options = {})
         table_definition = TableDefinition.new
         table_definition.define_primary_keys(options[:primary_keys]) if options[:primary_keys]
@@ -30,29 +30,29 @@ module CassandraMigrations
         create_cql << table_definition.to_create_cql
         create_cql << ")"
         create_cql << table_definition.options
-        
+
         announce_suboperation create_cql
-        
+
         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})"
         drop_cql =  "DROP TABLE #{table_name}"
         announce_suboperation drop_cql
-        
+
         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"
@@ -61,16 +61,28 @@ module CassandraMigrations
         end
         drop_index_cql = "DROP INDEX #{options[:if_exists] ? 'IF EXISTS' : ''}#{index_name}"
         announce_suboperation drop_index_cql
-        
-        execute drop_index_cql        
+
+        execute drop_index_cql
       end
 
-      def add_options(table_name, options)
-        announce_operation "add_options_#{table_name}"
-        add_options_cql = "ALTER TABLE #{properties_cql(options)}"
-        announce_suboperation drop_index_cql
+      def create_table(table_name, options = {})
+        table_definition = TableDefinition.new
+        table_definition.define_primary_keys(options[:primary_keys]) if options[:primary_keys]
+        table_definition.define_partition_keys(options[:partition_keys]) if options[:partition_keys]
+        table_definition.define_options(options[:options]) if options[:options]
+
+        yield table_definition if block_given?
+
+        announce_operation "create_table(#{table_name})"
+
+        create_cql =  "CREATE TABLE #{table_name} ("
+        create_cql << table_definition.to_create_cql
+        create_cql << ")"
+        create_cql << table_definition.options
 
-        execute add_options_cql
+        announce_suboperation create_cql
+
+        execute create_cql
       end
 
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cassandra_migrations
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Henrique Gubert
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-15 00:00:00.000000000 Z
+date: 2014-12-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cassandra-driver
@@ -17,14 +17,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0.beta.3
+        version: 1.1.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0.beta.3
+        version: 1.1.1
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement