cassie 1.0.0.beta.33 → 1.0.0.1

data/lib/cassie/schema/migration/dsl/table_definition.rb

@@ -0,0 +1,299 @@
+module Cassie::Schema::Migration::DSL
+  class Errors
+    class MigrationDefinitionError < StandardError; end
+  end
+
+  # Used to define a table in a migration of table creation or to
+  # add columns to an existing table.
+  #
+  # An instance of this class is passed to the block of the method
+  # +create_table+, available on every migration.
+  #
+  # This class is also internally used in the method +add_column+.
+  class TableDefinition
+
+    #
+    # 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
+    # Type       |           | Class         |
+    # ------------------------------------------------------------------------
+    # string     | varchar	 | String        | UTF-8 encoded 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
+    # varint	   | varint    | Bignum        | Arbitrary-precision integer
+    # ------------------------------------------------------------------------
+    # decimal	   | decimal   | BigDecimal    | Variable-precision decimal
+    # float(4)	 | float	   |               | 32-bit IEEE-754 floating point
+    # double     | double	   |	             | Float 64-bit IEEE-754 floating point
+    # float(8)   | double    |               |
+    # ------------------------------------------------------------------------
+    # boolean    | boolean	 | TrueClass     | true or false
+    #            |           | FalseClass    |
+    # ------------------------------------------------------------------------
+    # uuid	     | uuid      | Cql::Uuid     | A UUID in standard UUID format
+    # timeuuid	 | timeuuid  | Cql::TimeUuid | Type 1 UUID only (CQL 3)
+    # ------------------------------------------------------------------------
+    # inet	     | inet      | IPAddr        | IP address string in IPv4 or
+    #            |           |               | IPv6 format*
+    # ------------------------------------------------------------------------
+    # timestamp  | timestamp | Time          | Date plus time, encoded as 8
+    #            |           |               | bytes since epoch
+    # datetime   | timestamp |               |
+    # ------------------------------------------------------------------------
+    # list       | list	     | Array	       | A collection of one or more
+    #            |           |               | ordered elements
+    # 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),
+    #            |           |               | expressed as hexadecimal
+    # 	         | counter   |               | Distributed counter value
+    #            |           |               | (64-bit long)
+    # ------------------------------------------------------------------------
+    def initialize()
+      @columns_name_type_hash = {}
+      @primary_keys = []
+      @partition_keys = []
+      @options = nil
+    end
+
+    def to_create_cql
+      cql = []
+      build_name_type_cql(cql)
+      check_for_non_key_fields_in_counter_table
+      build_pk_clause(cql)
+      cql.join(', ')
+    end
+
+    def to_add_column_cql
+      cql = ""
+
+      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.'
+      else
+        raise Errors::MigrationDefinitionError, 'Only one column can be added at once.'
+      end
+
+      cql
+    end
+
+    def options
+      @options ? " WITH %s" % (@options.map {|option| build_option(option)}.join(" AND ")) : ''
+    end
+
+    def boolean(column_name, options={})
+      @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={})
+      @columns_name_type_hash[column_name.to_sym] = column_type_for(:integer, options)
+      define_primary_keys(column_name) if options[:primary_key]
+    end
+
+    def decimal(column_name, options={})
+      @columns_name_type_hash[column_name.to_sym] = column_type_for(:decimal, options)
+      define_primary_keys(column_name) if options[:primary_key]
+    end
+
+    def float(column_name, options={})
+      @columns_name_type_hash[column_name.to_sym] = column_type_for(:float, options)
+      define_primary_keys(column_name) if options[:primary_key]
+    end
+
+    def double(column_name, options={})
+      options[:limit] = 8
+      @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] = 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] = column_type_for(:text, options)
+      define_primary_keys(column_name) if options[:primary_key]
+    end
+
+    def ascii(column_name, options={})
+      @columns_name_type_hash[column_name.to_sym] = column_type_for(:ascii, options)
+      define_primary_keys(column_name) if options[:primary_key]
+    end
+
+    def datetime(column_name, options={})
+      @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] = 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] = 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] = column_type_for(:timeuuid, options)
+      define_primary_keys(column_name) if options[:primary_key]
+    end
+
+    def binary(column_name, options={})
+      @columns_name_type_hash[column_name.to_sym] = column_type_for(:binary, options)
+      define_primary_keys(column_name) if options[:primary_key]
+    end
+
+    def counter(column_name, options={})
+      @columns_name_type_hash[column_name.to_sym] = column_type_for(:counter, options)
+      if options[:primary_key]
+        raise Errors::MigrationDefinitionError, 'Counter columns cannot be primary keys'
+      end
+    end
+
+    def list(column_name, options={})
+      list_or_set(:list, column_name, options)
+    end
+
+    def set(column_name, options={})
+      list_or_set(:set, column_name, options)
+    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.'
+      end
+
+      @primary_keys = keys.flatten
+    end
+
+    def define_partition_keys(*keys)
+      if !@partition_keys.empty?
+        raise Errors::MigrationDefinitionError, 'Partition key defined twice for the same table.'
+      end
+
+      @partition_keys = keys.flatten
+    end
+
+    def define_options(hash)
+      @options = hash
+    end
+
+    private
+
+    PASSTHROUGH_TYPES = [:text, :ascii, :decimal, :double, :boolean,
+                         :uuid, :timeuuid, :inet, :timestamp, :list,
+                         :map, :set, :counter]
+    TYPES_MAP = { string: :varchar,
+                  datetime: :timestamp,
+                  binary: :blob }
+
+    PRECISION_MAP = {
+                      integer: { 4 => :int, 8 => :bigint, nil => :int },
+                      float: { 4 => :float, 8 => :double, nil => :float }
+                    }
+
+    SPECIAL_OPTIONS_MAP = {
+                    compact_storage: 'COMPACT STORAGE',
+                    clustering_order: 'CLUSTERING ORDER'
+                  }
+
+    def column_type_for(type, options={})
+      cql_type = type if PASSTHROUGH_TYPES.include?(type)
+      cql_type ||= TYPES_MAP[type]
+      if PRECISION_MAP.keys.include?(type)
+        limit = options[:limit]
+        unless PRECISION_MAP[type].keys.include?(limit)
+          raise Errors::MigrationDefinitionError, ":limit option should be #{PRECISION_MAP[type].keys.compact.join(' or ')} for #{type}."
+        end
+        cql_type ||= PRECISION_MAP[type][limit]
+      end
+      cql_type
+    end
+
+    def build_option(option)
+      name, value = option
+      cql_name = SPECIAL_OPTIONS_MAP.fetch(name, name.to_s)
+      case name
+        when :clustering_order
+          "#{cql_name} BY (#{value})"
+        when :compact_storage
+          cql_name
+        else
+          "#{cql_name} = #{value}"
+      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

data/lib/cassie/schema/migration/dsl/table_operations.rb

@@ -0,0 +1,64 @@
+require_relative 'table_definition'
+
+module Cassie::Schema::Migration::DSL
+  # 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.
+
+    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
+
+      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"
+      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

data/lib/cassie/schema/migration/dsl.rb

@@ -0,0 +1,17 @@
+module Cassie::Schema
+  class Migration
+    module DSL
+      require_relative 'dsl/table_operations'
+      require_relative 'dsl/column_operations'
+      require_relative 'dsl/announcing'
+
+      extend ActiveSupport::Concern
+
+      included do
+        include ColumnOperations
+        include TableOperations
+        include Announcing
+      end
+    end
+  end
+end

data/lib/cassie/schema/migration.rb

@@ -0,0 +1,12 @@
+module Cassie::Schema
+  class Migration
+    require_relative 'migration/cassandra_support'
+
+    include CassandraSupport
+
+    def path
+      method = method(:up) || method(:down)
+      method.source_location.first
+    end
+  end
+end

data/lib/cassie/schema/migrator.rb

@@ -0,0 +1,115 @@
+require 'benchmark'
+
+module Cassie::Schema
+  require_relative 'apply_command'
+  require_relative 'rollback_command'
+
+  class Migrator
+    attr_reader :target_version, :current_version, :direction
+    attr_reader :commands
+    attr_accessor :before_each, :after_each
+
+
+    def initialize(target)
+      @target_version   = build_target_version(target)
+      @current_version  = Cassie::Schema.version
+      @direction        = build_direction
+      @before_each      = Proc.new{}
+      @after_each       = Proc.new{}
+      @commands         = send("build_#{direction}_commands")
+    end
+
+    def migrate
+      commands_with_callbacks do |command|
+        command.execute
+      end
+    end
+
+    # versions applied to the database
+    # enumerated in most recent first order
+    def applied_versions
+      @applied_versions ||= Cassie::Schema.applied_versions.to_a
+    end
+
+    protected
+
+    def local_versions
+      Cassie::Schema.local_versions
+    end
+
+    def build_target_version(target)
+      case target
+      when Version
+        target
+      when /^[\d\.]+$/
+        Version.new(target)
+      when nil
+        local_versions.last || Cassie::Schema.version
+      else
+        raise ArgumentError, "Migrator target must be a `Version` object, version string, or nil"
+      end
+    end
+
+    def build_direction
+      target_version >= current_version ? :up : :down
+    end
+
+    def commands_with_callbacks
+      commands.each do |command|
+        before_each.call(command.version, command.direction)
+        duration = Benchmark.realtime do
+          yield(command)
+        end
+        after_each.call(command.version, (duration*1000).round(2))
+      end
+    end
+
+    # install all local versions since current
+    #
+    # a (current) | b | c | d (target) | e
+    def build_up_commands
+      local_versions.select{ |v| v > current_version && v <= target_version }
+                    .map{ |v| ApplyCommand.new(v) }
+    end
+
+    # rollback all versions applied past the target
+    # and apply missing versions to get to target
+    #
+    # 0 | a (target) (not applied) | b | c | d (current) | e
+    def build_down_commands
+      rollbacks = rollback_versions.map{ |v| RollbackCommand.new(v) }
+      missing = missing_versions_before(rollbacks.last.version).map{ |v| ApplyCommand.new(v) }
+      rollbacks + missing
+    end
+
+    # all versions applied since target
+    # 0 | a (target) (not applied) | b | c | d (current) | e
+    def rollback_versions
+      applied_versions.select{ |a| a > target_version && a <= current_version }
+    end
+
+    # versions that are not applied yet
+    # but need to get applied
+    # to get up the target version
+    #
+    # | 0 (stop) | a (target) | b | c
+    def missing_versions_before(last_rollback)
+      return [] unless last_rollback
+
+      rollback_index = applied_versions.index(last_rollback)
+
+      stop = if rollback_index == applied_versions.length - 1
+        # rolled back to oldest version, a rollback
+        # would put us in a versionless state.
+        # Any versions up to target should be applied
+        Version.new('0')
+      else
+        applied_versions[rollback_index + 1]
+      end
+
+      return [] if stop == target_version
+
+      local_versions.select{ |v| v > stop && v <= target_version }
+    end
+  end
+end

data/lib/cassie/schema/queries/create_keyspace_query.rb

@@ -0,0 +1,26 @@
+module Cassie::Schema
+  class CreateKeyspaceQuery < Cassie::Definition
+    self.prepare = false
+    self.keyspace = nil
+
+    attr_accessor :name,
+                  :replication_class,
+                  :replication_factor,
+                  :durable_writes
+
+    def initialize(*args)
+      super(*args)
+      @replication_class ||= 'SimpleStrategy'
+      @replication_factor ||= 1
+      @durable_writes = true unless defined?(@durable_writes)
+    end
+
+    def statement
+      cql = %(
+        CREATE KEYSPACE IF NOT EXISTS #{name}
+        WITH replication = {'class': '#{replication_class}', 'replication_factor': '#{replication_factor}'}
+        AND durable_writes = #{!!durable_writes};
+       )
+    end
+  end
+end

data/lib/cassie/{migration → schema}/queries/create_versions_table_query.rb

@@ -1,23 +1,23 @@
-module Cassie::Migration
+module Cassie::Schema
   class CreateVersionsTableQuery < Cassie::Definition
     self.prepare = false
 
     def statement
       %(
-         CREATE TABLE #{Cassie::Migration.versions_table} (
+         CREATE TABLE #{Cassie::Schema.versions_table} (
            bucket int,
            id timeuuid,
-           version_number text,
+           number text,
            description text,
-           migrator text,
-           migrated_at timestamp,
+           executor text,
+           executed_at timestamp,
            PRIMARY KEY (bucket, id)
          ) WITH CLUSTERING ORDER BY (id DESC);
         )
     end
 
     def keyspace
-      Cassie::Migration.schema_keyspace
+      Cassie::Schema.schema_keyspace
     end
   end
 end

data/lib/cassie/schema/queries/delete_version_query.rb

@@ -0,0 +1,17 @@
+module Cassie::Schema
+  class DeleteVersionQuery < Cassie::Modification
+
+    delete_from Cassie::Schema.versions_table
+
+    where :id, :eq
+    where :bucket, :eq
+
+    def bucket
+      0
+    end
+
+    def keyspace
+      Cassie::Schema.schema_keyspace
+    end
+  end
+end

data/lib/cassie/schema/queries/drop_keyspace_query.rb

@@ -0,0 +1,14 @@
+module Cassie::Schema
+  class DropKeyspaceQuery < Cassie::Definition
+    self.prepare = false
+    consistency :all
+
+    attr_accessor :keyspace
+
+    def statement
+      cql = %(
+        DROP KEYSPACE IF EXISTS #{keyspace};
+       )
+    end
+  end
+end

data/lib/cassie/schema/queries/insert_version_query.rb

@@ -0,0 +1,22 @@
+module Cassie::Schema
+  class InsertVersionQuery < Cassie::Modification
+    # use fully-qualified tablename
+    # for cql generation for standalone queries
+    self.keyspace = nil
+
+    insert_into "#{Cassie::Schema.schema_keyspace}.#{Cassie::Schema.versions_table}"
+
+    set :bucket
+    set :id
+    set :number
+    set :description
+    set :executor
+    set :executed_at
+
+    map_from :version
+
+    def bucket
+      0
+    end
+  end
+end

data/lib/cassie/schema/queries/select_versions_query.rb

@@ -0,0 +1,18 @@
+module Cassie::Schema
+  class SelectVersionsQuery < Cassie::Query
+
+    select_from Cassie::Schema.versions_table
+
+    def build_result(row)
+      Version.new(row["number"],
+                  row["description"],
+                  row["id"],
+                  row["executor"],
+                  row["executed_at"])
+    end
+
+    def keyspace
+      Cassie::Schema.schema_keyspace
+    end
+  end
+end

data/lib/cassie/{migration → schema}/queries.rb

@@ -1,8 +1,10 @@
-module Cassie::Migration
+module Cassie::Schema
   module Queries
-    require_relative 'queries/create_schema_keyspace_query'
+    require_relative 'queries/create_keyspace_query'
     require_relative 'queries/create_versions_table_query'
     require_relative 'queries/insert_version_query'
+    require_relative 'queries/delete_version_query'
     require_relative 'queries/select_versions_query'
+    require_relative 'queries/drop_keyspace_query'
   end
 end

data/lib/cassie/schema/rollback_command.rb

@@ -0,0 +1,24 @@
+module Cassie::Schema
+  class RollbackCommand
+    attr_reader :version
+
+    def initialize(version)
+      @version = version
+    end
+
+    def direction
+      :down
+    end
+
+    def execute
+      version.migration.down
+      remove_from_history
+    end
+
+    protected
+
+    def remove_from_history
+      Cassie::Schema.forget_version(version)
+    end
+  end
+end