cequel 0.5.6 → 1.0.0.pre.1

data/lib/cequel/schema.rb

@@ -0,0 +1,15 @@
+require 'cequel/schema/column'
+require 'cequel/schema/create_table_dsl'
+require 'cequel/schema/keyspace'
+require 'cequel/schema/table'
+require 'cequel/schema/table_property'
+require 'cequel/schema/table_reader'
+require 'cequel/schema/table_synchronizer'
+require 'cequel/schema/table_updater'
+require 'cequel/schema/table_writer'
+require 'cequel/schema/update_table_dsl'
+
+module Cequel
+  module Schema
+  end
+end

data/lib/cequel/schema/column.rb

@@ -0,0 +1,135 @@
+module Cequel
+
+  module Schema
+
+    class Column
+
+      attr_reader :name, :type
+
+      def initialize(name, type)
+        @name, @type = name, type
+      end
+
+      def to_cql
+        "#{@name} #{@type}"
+      end
+
+      def cast(value)
+        @type.cast(value)
+      end
+
+      def ==(other)
+        to_cql == other.to_cql
+      end
+
+      def to_s
+        name
+      end
+
+      def inspect
+        %Q(#<#{self.class.name}: #{to_cql}>)
+      end
+
+    end
+
+    class PartitionKey < Column
+
+      def partition_key?
+        true
+      end
+
+    end
+
+    class ClusteringColumn < Column
+
+      attr_reader :clustering_order
+
+      def initialize(name, type, clustering_order = nil)
+        super(name, type)
+        @clustering_order = (clustering_order || :asc).to_sym
+      end
+
+      def clustering_order_cql
+        "#{@name} #{@clustering_order}"
+      end
+
+      def partition_key?
+        false
+      end
+
+    end
+
+    class DataColumn < Column
+
+      attr_reader :index_name
+
+      def initialize(name, type, index_name = nil)
+        super(name, type)
+        @index_name = index_name
+      end
+
+      def indexed?
+        !!@index_name
+      end
+
+    end
+
+    class CollectionColumn < Column
+
+      def indexed?
+        false
+      end
+
+    end
+
+    class List < CollectionColumn
+
+      def to_cql
+        "#{@name} LIST <#{@type}>"
+      end
+
+      def cast(value)
+        value.map { |element| @type.cast(element) }
+      end
+
+    end
+
+    class Set < CollectionColumn
+
+      def to_cql
+        "#{@name} SET <#{@type}>"
+      end
+
+      def cast(value)
+        value.each_with_object(::Set[]) do |element, set|
+          set << @type.cast(element)
+        end
+      end
+
+    end
+
+    class Map < CollectionColumn
+
+      attr_reader :key_type
+      alias_method :value_type, :type
+
+      def initialize(name, key_type, value_type)
+        super(name, value_type)
+        @key_type = key_type
+      end
+
+      def to_cql
+        "#{@name} MAP <#{@key_type}, #{@type}>"
+      end
+
+      def cast(value)
+        value.each_with_object({}) do |(key, element), hash|
+          hash[@key_type.cast(key)] = @type.cast(element)
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/cequel/schema/create_table_dsl.rb

@@ -0,0 +1,56 @@
+module Cequel
+
+  module Schema
+
+    class CreateTableDSL < BasicObject
+
+      def self.apply(table, &block)
+        dsl = new(table)
+        dsl.instance_eval(&block)
+      end
+
+      def initialize(table)
+        @table = table
+      end
+
+      def partition_key(name, type)
+        @table.add_partition_key(name, type)
+      end
+
+      def key(name, type, clustering_order = nil)
+        @table.add_key(name, type, clustering_order)
+      end
+
+      def column(name, type, options = {})
+        column = @table.add_data_column(name, type, options[:index])
+      end
+
+      def list(name, type)
+        @table.add_list(name, type)
+      end
+
+      def set(name, type)
+        @table.add_set(name, type)
+      end
+
+      def map(name, key_type, value_type)
+        @table.add_map(
+          name,
+          key_type,
+          value_type
+        )
+      end
+
+      def with(name, value)
+        @table.add_property(name, value)
+      end
+
+      def compact_storage
+        @table.compact_storage = true
+      end
+
+    end
+
+  end
+
+end

data/lib/cequel/schema/keyspace.rb

@@ -0,0 +1,50 @@
+module Cequel
+
+  module Schema
+
+    class Keyspace
+
+      def initialize(keyspace)
+        @keyspace = keyspace
+      end
+
+      def read_table(name)
+        TableReader.read(keyspace, name)
+      end
+
+      def create_table(name, &block)
+        table = Table.new(name)
+        CreateTableDSL.apply(table, &block)
+        TableWriter.apply(keyspace, table)
+      end
+
+      def alter_table(name, &block)
+        updater = TableUpdater.apply(keyspace, name) do |updater|
+          UpdateTableDSL.apply(updater, &block)
+        end
+      end
+
+      def truncate_table(name)
+        keyspace.execute("TRUNCATE #{name}")
+      end
+
+      def drop_table(name)
+        keyspace.execute("DROP TABLE #{name}")
+      end
+
+      def sync_table(name, &block)
+        existing = read_table(name)
+        updated = Table.new(name)
+        CreateTableDSL.apply(updated, &block)
+        TableSynchronizer.apply(keyspace, existing, updated)
+      end
+      alias_method :synchronize_table, :sync_table
+
+      protected
+      attr_reader :keyspace
+
+    end
+
+  end
+
+end

data/lib/cequel/schema/table.rb

@@ -0,0 +1,120 @@
+require 'stringio'
+
+module Cequel
+
+  module Schema
+
+    class Table
+
+      attr_reader :name,
+                  :columns,
+                  :partition_keys,
+                  :clustering_columns,
+                  :data_columns,
+                  :properties
+      attr_writer :compact_storage
+
+      def initialize(name)
+        @name = name
+        @partition_keys, @clustering_columns, @data_columns = [], [], []
+        @columns, @columns_by_name = [], {}
+        @properties = ActiveSupport::HashWithIndifferentAccess.new
+      end
+
+      def add_key(name, type, clustering_order = nil)
+        if @partition_keys.empty?
+          unless clustering_order.nil?
+            raise ArgumentError,
+              "Can't set clustering order for partition key #{name}"
+          end
+          add_partition_key(name, type)
+        else
+          add_clustering_column(name, type, clustering_order)
+        end
+      end
+
+      def add_partition_key(name, type)
+        column = PartitionKey.new(name, type(type))
+        @partition_keys << add_column(column)
+      end
+
+      def add_clustering_column(name, type, clustering_order = nil)
+        column = ClusteringColumn.new(name, type(type), clustering_order)
+        @clustering_columns << add_column(column)
+      end
+
+      def add_data_column(name, type, index_name)
+        index_name = :"#{@name}_#{name}_idx" if index_name == true
+        DataColumn.new(name, type(type), index_name).
+          tap { |column| @data_columns << add_column(column) }
+      end
+
+      def add_list(name, type)
+        @data_columns << add_column(List.new(name, type(type)))
+      end
+
+      def add_set(name, type)
+        @data_columns << add_column(Set.new(name, type(type)))
+      end
+
+      def add_map(name, key_type, value_type)
+        @data_columns <<
+          add_column(Map.new(name, type(key_type), type(value_type)))
+      end
+
+      def add_property(name, value)
+        @properties[name] = TableProperty.new(name, value)
+      end
+
+      def column(name)
+        columns_by_name[name.to_sym]
+      end
+
+      def key_columns
+        @partition_keys + @clustering_columns
+      end
+
+      def key_column_names
+        key_columns.map { |key| key.name }
+      end
+
+      def partition_key(name)
+        @partition_keys.find { |column| column.name == name }
+      end
+
+      def clustering_column(name)
+        @clustering_columns.find { |column| column.name == name }
+      end
+
+      def data_column(name)
+        name = name.to_sym
+        @data_columns.find { |column| column.name == name }
+      end
+
+      def property(name)
+        @properties[name].try(:value)
+      end
+
+      def compact_storage?
+        !!@compact_storage
+      end
+
+      protected
+      attr_reader :columns_by_name
+
+      private
+
+      def add_column(column)
+        columns << column
+        columns_by_name[column.name] = column
+      end
+
+      def type(type)
+        ::Cequel::Type[type]
+      end
+
+    end
+
+  end
+
+end

data/lib/cequel/schema/table_property.rb

@@ -0,0 +1,67 @@
+module Cequel
+
+  module Schema
+
+    class TableProperty
+
+      attr_reader :name, :value
+
+      def initialize(name, value)
+        @name = name
+        set_normalized_value(value)
+      end
+
+      def to_cql
+        if Hash === @value
+          map_pairs = @value.each_pair.
+            map { |key, value| "#{quote(key.to_s)} : #{quote(value)}" }.
+            join(', ')
+          value_cql = "{ #{map_pairs} }"
+        else
+          value_cql = quote(@value)
+        end
+        "#{@name} = #{value_cql}"
+      end
+
+      private
+
+      def quote(value)
+        CassandraCQL::Statement.quote(value)
+      end
+
+      def set_normalized_value(map)
+        return @value = map unless Hash === map
+        @value = {}
+        map.each_pair do |key, value|
+          key = key.to_sym
+          @value[key] = normalize_map_property(key, value)
+        end
+      end
+
+      def normalize_map_property(key, value)
+        case @name
+        when :compaction
+          case key
+          when :class
+            value.sub(/^org\.apache\.cassandra\.db\.compaction\./, '')
+          when :bucket_high, :bucket_low, :tombstone_threshold then value.to_f
+          when :max_threshold, :min_threshold, :min_sstable_size,
+            :sstable_size_in_mb, :tombstone_compaction_interval then value.to_i
+          else value.to_s
+          end
+        when :compression
+          case key
+          when :sstable_compression
+            value.sub(/^org\.apache\.cassandra\.io\.compress\./, '')
+          when :chunk_length_kb then value.to_i
+          when :crc_check_chance then value.to_f
+          else value.to_s
+          end
+        end
+      end
+
+    end
+
+  end
+
+end