cequel 0.5.6 → 1.0.0.pre.1

data/lib/cequel/schema/table_reader.rb

@@ -0,0 +1,139 @@
+module Cequel
+
+  module Schema
+
+    class TableReader
+
+      COMPOSITE_TYPE_PATTERN =
+        /^org\.apache\.cassandra\.db\.marshal\.CompositeType\((.+)\)$/
+      REVERSED_TYPE_PATTERN =
+        /^org\.apache\.cassandra\.db\.marshal\.ReversedType\((.+)\)$/
+      COLLECTION_TYPE_PATTERN =
+        /^org\.apache\.cassandra\.db\.marshal\.(List|Set|Map)Type\((.+)\)$/
+
+      STORAGE_PROPERTIES = %w[bloom_filter_fp_chance caching comment compaction
+        compression dclocal_read_repair_chance gc_grace_seconds
+        read_repair_chance replicate_on_write]
+
+      attr_reader :table
+
+      def self.read(keyspace, table_name)
+        new(keyspace, table_name).read
+      end
+
+      def initialize(keyspace, table_name)
+        @keyspace, @table_name = keyspace, table_name
+        @table = Table.new(table_name.to_sym)
+      end
+      private_class_method(:new)
+
+      def read
+        if table_data.present?
+          read_partition_keys
+          read_clustering_columns
+          read_data_columns
+          read_properties
+          table
+        end
+      end
+
+      protected
+      attr_reader :keyspace, :table_name, :table
+
+      private
+
+      def read_partition_keys
+        validator = table_data['key_validator']
+        types = parse_composite_types(validator) || [validator]
+        JSON.parse(table_data['key_aliases']).zip(types) do |key_alias, type|
+          name = key_alias.to_sym
+          table.add_partition_key(key_alias.to_sym, Type.lookup_internal(type))
+        end
+      end
+
+      def read_clustering_columns
+        column_aliases = JSON.parse(table_data['column_aliases'])
+        comparators = parse_composite_types(table_data['comparator'])
+        unless comparators
+          table.compact_storage = true
+          comparators = [table_data['comparator']]
+        end
+        column_aliases.zip(comparators) do |column_alias, type|
+          if REVERSED_TYPE_PATTERN =~ type
+            type = $1
+            clustering_order = :desc
+          end
+          table.add_clustering_column(
+            column_alias.to_sym,
+            Type.lookup_internal(type),
+            clustering_order
+          )
+        end
+      end
+
+      def read_data_columns
+        column_data.each do |result|
+          if COLLECTION_TYPE_PATTERN =~ result['validator']
+            read_collection_column(
+              result['column_name'],
+              $1.underscore,
+              *$2.split(',')
+            )
+          else
+            table.add_data_column(
+              result['column_name'].to_sym,
+              Type.lookup_internal(result['validator']),
+              result['index_name'].try(:to_sym)
+            )
+          end
+        end
+      end
+
+      def read_collection_column(name, collection_type, *internal_types)
+        types = internal_types.map { |internal| Type.lookup_internal(internal) }
+        table.__send__("add_#{collection_type}", name.to_sym, *types)
+      end
+
+      def read_properties
+        table_data.slice(*STORAGE_PROPERTIES).each do |name, value|
+          table.add_property(name, value)
+        end
+        compaction = JSON.parse(table_data['compaction_strategy_options']).
+          symbolize_keys
+        compaction[:class] = table_data['compaction_strategy_class']
+        table.add_property(:compaction, compaction)
+        compression = JSON.parse(table_data['compression_parameters'])
+        table.add_property(:compression, compression)
+      end
+
+      def parse_composite_types(type_string)
+        if COMPOSITE_TYPE_PATTERN =~ type_string
+          $1.split(',')
+        end
+      end
+
+      def table_data
+        return @table_data if defined? @table_data
+        table_query = keyspace.execute(<<-CQL, keyspace.name, table_name)
+              SELECT * FROM system.schema_columnfamilies
+              WHERE keyspace_name = ? AND columnfamily_name = ?
+        CQL
+        @table_data = table_query.first.try(:to_hash)
+      end
+
+      def column_data
+        @column_data ||=
+          if table_data
+            column_query = keyspace.execute(<<-CQL, keyspace.name, table_name)
+              SELECT * FROM system.schema_columns
+              WHERE keyspace_name = ? AND columnfamily_name = ?
+            CQL
+            column_query.map(&:to_hash)
+          end
+      end
+
+    end
+
+  end
+
+end

data/lib/cequel/schema/table_synchronizer.rb

@@ -0,0 +1,114 @@
+module Cequel
+
+  module Schema
+
+    class TableSynchronizer
+
+      def self.apply(keyspace, existing, updated)
+        if existing
+          TableUpdater.apply(keyspace, existing.name) do |updater|
+            new(updater, existing, updated).apply
+          end
+        else
+          TableWriter.apply(keyspace, updated)
+        end
+      end
+
+      def initialize(updater, existing, updated)
+        @updater, @existing, @updated = updater, existing, updated
+      end
+      private_class_method :new
+
+      def apply
+        update_keys
+        update_columns
+        update_properties
+      end
+
+      protected
+      attr_reader :updater, :existing, :updated
+
+      private
+
+      def update_keys
+        each_key_pair do |old_key, new_key|
+          if old_key.type != new_key.type
+            raise InvalidSchemaMigration,
+              "Can't change type of key column #{old_key.name} from #{old_key.type} to #{new_key.type}"
+          end
+          if old_key.name != new_key.name
+            updater.rename_column(old_key.name, new_key.name)
+          end
+        end
+      end
+
+      def update_columns
+        each_column_pair do |old_column, new_column|
+          if old_column.nil?
+            add_column(new_column)
+          elsif new_column
+            if old_column.class != new_column.class
+              raise InvalidSchemaMigration,
+                "Can't change #{old_column.name} from #{old_column.class.name.demodulize} to #{new_column.class.name.demodulize}"
+            end
+            update_column(old_column, new_column)
+          end
+        end
+      end
+
+      def add_column(column)
+        updater.add_data_column(column)
+        if column.indexed?
+          updater.create_index(column.name, column.index_name)
+        end
+      end
+
+      def update_column(old_column, new_column)
+        if old_column.type != new_column.type
+          updater.change_column(new_column.name, new_column.type)
+        end
+        if !old_column.indexed? && new_column.indexed?
+          updater.create_index(new_column.name, new_column.index_name)
+        elsif old_column.indexed? && !new_column.indexed?
+          updater.drop_index(old_column.index_name)
+        end
+      end
+
+      def update_properties
+        changes = {}
+        updated.properties.each_pair do |name, new_property|
+          old_property = existing.property(name)
+          if old_property != new_property.value
+            changes[name] = new_property.value
+          end
+        end
+        updater.change_properties(changes) if changes.any?
+      end
+
+      def each_key_pair(&block)
+        if existing.partition_keys.length != updated.partition_keys.length
+          raise InvalidSchemaMigration,
+            "Existing partition keys #{existing.partition_keys.map { |key| key.name }.join(',')} differ from specified partition keys #{updated.partition_keys.map { |key| key.name }.join(',')}"
+        end
+        if existing.clustering_columns.length != updated.clustering_columns.length
+          raise InvalidSchemaMigration,
+            "Existing clustering keys #{existing.clustering_columns.map { |key| key.name }.join(',')} differ from specified clustering keys #{updated.clustering_columns.map { |key| key.name }.join(',')}"
+        end
+        existing.partition_keys.zip(updated.partition_keys, &block)
+        existing.clustering_columns.zip(updated.clustering_columns, &block)
+      end
+
+      def each_column_pair(&block)
+        old_columns = existing.data_columns.index_by { |col| col.name }
+        new_columns = updated.data_columns.index_by { |col| col.name }
+        all_column_names = (old_columns.keys + new_columns.keys).uniq!
+        all_column_names.each do |name|
+          yield old_columns[name], new_columns[name]
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/cequel/schema/table_updater.rb

@@ -0,0 +1,83 @@
+module Cequel
+
+  module Schema
+
+    class TableUpdater
+
+      def self.apply(keyspace, table_name)
+        new(keyspace, table_name).
+          tap { |updater| yield updater if block_given? }.
+          apply
+      end
+
+      def initialize(keyspace, table_name)
+        @keyspace, @table_name = keyspace, table_name
+        @statements = []
+      end
+      private_class_method :new
+
+      def apply
+        statements.each { |statement| keyspace.execute(statement) }
+      end
+
+      def add_column(name, type)
+        add_data_column(Column.new(name, type))
+      end
+
+      def add_list(name, type)
+        add_data_column(List.new(name, type))
+      end
+
+      def add_set(name, type)
+        add_data_column(Set.new(name, type))
+      end
+
+      def add_map(name, key_type, value_type)
+        add_data_column(Map.new(name, key_type, value_type))
+      end
+
+      def change_column(name, type)
+        alter_table("ALTER #{name} TYPE #{type.cql_name}")
+      end
+
+      def rename_column(old_name, new_name)
+        alter_table("RENAME #{old_name} TO #{new_name}")
+      end
+
+      def change_properties(options)
+        properties = options.
+          map { |name, value| TableProperty.new(name, value).to_cql }
+        alter_table("WITH #{properties.join(' AND ')}")
+      end
+
+      def create_index(column, index_name)
+        index_name ||= "#{table_name}_#{column}_idx"
+        statements << "CREATE INDEX #{index_name} ON #{table_name} (#{column})"
+      end
+
+      def drop_index(index_name)
+        statements << "DROP INDEX #{index_name}"
+      end
+
+      def add_data_column(column)
+        add_column_statement(column)
+      end
+
+      protected
+      attr_reader :keyspace, :table_name, :statements
+
+      private
+
+      def alter_table(statement)
+        statements << "ALTER TABLE #{table_name} #{statement}"
+      end
+
+      def add_column_statement(column)
+        alter_table("ADD #{column.to_cql}")
+      end
+
+    end
+
+  end
+
+end

data/lib/cequel/schema/table_writer.rb

@@ -0,0 +1,80 @@
+module Cequel
+
+  module Schema
+
+
+    class TableWriter
+
+      def self.apply(keyspace, table)
+        new(keyspace, table).apply
+      end
+
+      def initialize(keyspace, table)
+        @keyspace, @table = keyspace, table
+      end
+      private_class_method :new
+
+      def apply
+        keyspace.execute(create_statement)
+        index_statements.each { |statement| keyspace.execute(statement) }
+      end
+
+      protected
+      attr_reader :keyspace, :table
+
+      private
+
+      def create_statement
+        "CREATE TABLE #{table.name} (#{columns_cql}, #{keys_cql})".tap do |cql|
+          properties = properties_cql
+          cql << " WITH #{properties}" if properties
+        end
+      end
+
+      def index_statements
+        [].tap do |statements|
+          table.data_columns.each do |column|
+            if column.indexed?
+              statements <<
+                "CREATE INDEX #{column.index_name} ON #{table.name} (#{column.name})"
+            end
+          end
+        end
+      end
+
+      def columns_cql
+        table.columns.map(&:to_cql).join(', ')
+      end
+
+      def key_columns_cql
+        table.keys.map(&:to_cql).join(', ')
+      end
+
+      def keys_cql
+        partition_cql = table.partition_keys.map { |key| key.name }.join(', ')
+        if table.clustering_columns.any?
+          nonpartition_cql =
+            table.clustering_columns.map { |key| key.name }.join(', ')
+          "PRIMARY KEY ((#{partition_cql}), #{nonpartition_cql})"
+        else
+          "PRIMARY KEY ((#{partition_cql}))"
+        end
+      end
+
+      def properties_cql
+        properties_fragments = table.properties.
+          map { |_, property| property.to_cql }
+        properties_fragments << 'COMPACT STORAGE' if table.compact_storage?
+        if table.clustering_columns.any?
+          clustering_fragment =
+            table.clustering_columns.map(&:clustering_order_cql).join(',')
+          properties_fragments << "CLUSTERING ORDER BY (#{clustering_fragment})"
+        end
+        properties_fragments.join(' AND ') if properties_fragments.any?
+      end
+
+    end
+
+  end
+
+end

data/lib/cequel/schema/update_table_dsl.rb

@@ -0,0 +1,60 @@
+module Cequel
+
+  module Schema
+
+    class UpdateTableDSL < BasicObject
+
+      def self.apply(updater, &block)
+        dsl = new(updater)
+        dsl.instance_eval(&block)
+      end
+
+      def initialize(updater)
+        @updater = updater
+      end
+
+      def add_column(name, type)
+        @updater.add_column(name, ::Cequel::Type[type])
+      end
+
+      def add_list(name, type)
+        @updater.add_list(name, ::Cequel::Type[type])
+      end
+
+      def add_set(name, type)
+        @updater.add_set(name, ::Cequel::Type[type])
+      end
+
+      def add_map(name, key_type, value_type)
+        @updater.add_map(name, ::Cequel::Type[key_type],
+                         ::Cequel::Type[value_type])
+      end
+
+      def change_column(name, type)
+        @updater.change_column(name, ::Cequel::Type[type])
+      end
+
+      def rename_column(old_name, new_name)
+        @updater.rename_column(old_name, new_name)
+      end
+
+      def change_properties(options)
+        @updater.change_properties(options)
+      end
+      alias_method :change_options, :change_properties
+
+      def create_index(column_name, index_name = nil)
+        @updater.create_index(column_name, index_name)
+      end
+      alias_method :add_index, :create_index
+
+      def drop_index(index_name)
+        @updater.drop_index(index_name)
+      end
+      alias_method :remove_index, :drop_index
+
+    end
+
+  end
+
+end