cequel 2.1.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 31fac6cdfcc42c42c1cd03489d11aa97e4791193
-  data.tar.gz: 5d86e45f0dac711e70936c61ff7a4879095b28d8
+  metadata.gz: c970b068b50a1215dc4bf58af07dfc5b1b936214
+  data.tar.gz: c7470426d1cac668b2bd698d7f35608835b2bf0a
 SHA512:
-  metadata.gz: b4a4696642f07aed6bf5e777b57fd48a9f570eb7ae370e31f8b37d92770874b9d25b0b72d0159dc3501d2d94671e0845f33119895cadc4bbe3498c668ee38fe7
-  data.tar.gz: 7600517db78e87916d1f40584d21f181388ee91b2c21a73d26db17a598ce5c4bbee627ed26cfab4c33f0a84908bd568ab3e0cd9df67df76eec1eaa4242c5969c
+  metadata.gz: 5ce7dfd8aa2d73dc6d6748a789b4cd84ab137fb7c3d98bc70df830c6f64d8fb86a0e4e3fb26de6ce0d0c8167db8fcb8a0a2e3c57799f6847cf239db0ae73e4e0
+  data.tar.gz: 886e98099ef58ee431a76f4560e89ad10e3146a0850293671aa8bef45b852fa1bcdab41d2968639ec24dd7bfcba45c516ac88bf1de0f119f3fecf8b15a0eda95

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 3.0.0
+* Drop support for changing the type of cluster keys as it is no longer support by Cassandra.
+* Drop support for non-option based index specification in table schema DSL. For example, `column :author_name, :text, true` must be rewritten as `column :author_name, :text, index: true`.
+* Fix Relic instrumentation for batch statements [PR 361](https://github.com/cequel/cequel/pull/361)
+* Don't set table name when it is already present [PR 364](https://github.com/cequel/cequel/pull/364)
+
 ## 2.1.0
 
 * Add ActiveRecord::Enum like support `column :status, :enum, values: { open: 1, closed: 2 }` ([PR 354](https://github.com/cequel/cequel/pull/354))

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    cequel (2.1.0)
+    cequel (3.0.0)
       activemodel (>= 4.0)
       cassandra-driver (~> 3.0)
 
@@ -357,4 +357,4 @@ DEPENDENCIES
   yard (~> 0.6)
 
 BUNDLED WITH
-   1.12.5
+   1.14.6

data/README.md

@@ -612,6 +612,14 @@ you require this functionality.
 
 ## Breaking API changes
 
+### 3.0
+
+ * Dropped support for changing the type of cluster keys because the ability has
+   been removed from Cassandra. Calls to `#change_column` must be removed.
+ * Dropped support for previously deprecated signature of the `#column` method
+   of schema DSL. Uses like `column :my_column, :text, true` must be rewritten
+   as `#column :my_column, :text, indexed: true`
+
 ### 2.0
 
  * dropped support for jruby (Due to difficult to work around bugs in jruby. PRs welcome to restore jruby compatibility.)

data/lib/cequel/errors.rb

@@ -10,4 +10,6 @@ module Cequel
   InvalidSchemaMigration = Class.new(StandardError)
 
   NoSuchKeyspaceError = Class.new(StandardError)
+
+  NoSuchTableError = Class.new(StandardError)
 end

data/lib/cequel/metal/new_relic_instrumentation.rb

@@ -16,7 +16,7 @@ module Cequel
       define_method :execute_with_options_with_newrelic do |statement, options|
 
         operation = nil
-        statement_txt = nil 
+        statement_txt = nil
         statement_words = nil
 
         if statement.is_a?(::Cequel::Metal::Statement)
@@ -25,6 +25,7 @@ module Cequel
           operation = statement_words.first.downcase
         elsif statement.is_a?(::Cassandra::Statements::Batch)
           operation = "batch"
+          statement_txt = 'BEGIN BATCH'
         end
 
         callback = Proc.new do |result, scoped_metric, elapsed|

data/lib/cequel/record.rb

@@ -136,6 +136,14 @@ module Cequel
         weak_descendants << WeakRef.new(base)
       end
 
+      # This is probably not the method you are looking for.
+      #
+      # Clear descendants list. Useful in tests to ensure bogus record classes
+      # are not synced. 
+      def forget_all_descendants!
+        weak_descendants.clear
+      end
+
       private
 
       def weak_descendants

data/lib/cequel/record/schema.rb

@@ -20,7 +20,7 @@ module Cequel
 
       included do
         class_attribute :table_name, instance_writer: false
-        self.table_name = name.demodulize.tableize.to_sym unless name.nil?
+        self.table_name = name.demodulize.tableize.to_sym unless name.nil? || self.table_name.present?
       end
 
       #
@@ -80,21 +80,24 @@ module Cequel
         # @return [void]
         #
         def synchronize_schema
-          reader = get_table_reader
-          return if reader.materialized_view?
-          Cequel::Schema::TableSynchronizer
-            .apply(connection, reader.read, table_schema)
-        end
-
-        #
-        # Return a {TableReader} instance
-        #
-        # @return [Schema::TableReader] object
-        #
-        def get_table_reader
           fail MissingTableNameError unless table_name
 
-          connection.schema.get_table_reader(table_name)
+          patch =
+            begin
+              existing_table_descriptor = Cequel::Schema::TableReader.read(connection,
+                                                                           table_name)
+
+              return if existing_table_descriptor.materialized_view?
+
+              Cequel::Schema::TableDiffer.new(existing_table_descriptor,
+                                              table_schema)
+                .call
+
+            rescue NoSuchTableError
+              Cequel::Schema::TableWriter.new(table_schema)
+            end
+
+          patch.statements.each { |stmt| connection.execute(stmt) }
         end
 
         #
@@ -113,46 +116,50 @@ module Cequel
         #   specified in the class definition
         #
         def table_schema
-          @table_schema ||= Cequel::Schema::Table.new(table_name)
+          dsl.table
         end
 
         protected
 
+        def dsl
+          @dsl ||= Cequel::Schema::TableDescDsl.new(table_name)
+        end
+
         def key(name, type, options = {})
           super
           if options[:partition]
-            table_schema.add_partition_key(name, type)
+            dsl.partition_key(name, type)
           else
-            table_schema.add_key(name, type, options[:order])
+            dsl.key(name, type, options[:order])
           end
         end
 
         def column(name, type, options = {})
           super
-          table_schema.add_data_column(name, type, options[:index])
+          dsl.column(name, type, options)
         end
 
         def list(name, type, options = {})
           super
-          table_schema.add_list(name, type)
+          dsl.list(name, type)
         end
 
         def set(name, type, options = {})
           super
-          table_schema.add_set(name, type)
+          dsl.set(name, type)
         end
 
         def map(name, key_type, value_type, options = {})
           super
-          table_schema.add_map(name, key_type, value_type)
+          dsl.map(name, key_type, value_type)
         end
 
         def table_property(name, value)
-          table_schema.add_property(name, value)
+          dsl.with(name, value)
         end
 
         def compact_storage
-          table_schema.compact_storage = true
+          dsl.compact_storage
         end
       end
 

data/lib/cequel/schema.rb

@@ -1,12 +1,13 @@
 # -*- encoding : utf-8 -*-
 require 'cequel/schema/column'
-require 'cequel/schema/create_table_dsl'
+require 'cequel/schema/table_desc_dsl'
 require 'cequel/schema/keyspace'
 require 'cequel/schema/migration_validator'
 require 'cequel/schema/table'
 require 'cequel/schema/table_property'
 require 'cequel/schema/table_reader'
-require 'cequel/schema/table_synchronizer'
+require 'cequel/schema/table_differ'
+require 'cequel/schema/patch'
 require 'cequel/schema/table_updater'
 require 'cequel/schema/table_writer'
 require 'cequel/schema/update_table_dsl'

data/lib/cequel/schema/column.rb

@@ -71,6 +71,15 @@ module Cequel
         false
       end
 
+      # Indicates if this column is indexed. Overridden by subclasses that
+      # support indexing.
+      #
+      # @return [Boolean] true if this column has a secondary index
+      #
+      def indexed?
+        false
+      end
+
       #
       # @param type_in [Symbol,Type] type to check against
       # @return [Boolean] true if this column has the type given by `type_in`
@@ -96,7 +105,7 @@ module Cequel
       # @api private
       #
       def to_cql
-        "#{@name} #{@type}"
+        %Q|"#{@name}" #{@type}|
       end
 
       #
@@ -107,6 +116,7 @@ module Cequel
       def ==(other)
         to_cql == other.to_cql
       end
+      alias_method :eql?, :==
 
       #
       # @return [String] the column's name

data/lib/cequel/schema/keyspace.rb

@@ -52,7 +52,7 @@ module Cequel
         }
 
         options = options.symbolize_keys
-        options.reverse_merge!(keyspace.configuration)
+        options.reverse_merge!(keyspace.configuration.symbolize_keys)
         options.reverse_merge!(default_options)
 
         if options.key?(:class)
@@ -148,8 +148,7 @@ module Cequel
       # @see CreateTableDSL
       #
       def create_table(name, &block)
-        table = Table.new(name)
-        CreateTableDSL.apply(table, &block)
+        table = TableDescDsl.new(name).eval(&block)
         TableWriter.apply(keyspace, table)
       end
 
@@ -224,13 +223,25 @@ module Cequel
       # @see #create_table Example of DSL usage
       #
       def sync_table(name, &block)
-        existing = read_table(name)
-        updated = Table.new(name)
-        CreateTableDSL.apply(updated, &block)
-        TableSynchronizer.apply(keyspace, existing, updated)
+        new_table_desc = TableDescDsl.new(name).eval(&block)
+        patch = if has_table?(name)
+                  existing_table_desc = read_table(name)
+                  TableDiffer.new(existing_table_desc, new_table_desc).call
+                else
+                  TableWriter.new(new_table_desc) # close enough to a patch
+                end
+
+        patch.statements.each{|stmt| keyspace.execute(stmt) }
       end
       alias_method :synchronize_table, :sync_table
 
+
+      # Returns true iff the specified table name exists in the keyspace.
+      #
+      def has_table?(table_name)
+        !!read_table(table_name)
+      end
+
       protected
 
       attr_reader :keyspace

data/lib/cequel/schema/patch.rb

@@ -0,0 +1,152 @@
+# -*- encoding : utf-8 -*-
+module Cequel
+  module Schema
+    #
+    # The set of changes needed to transform a table from its current form to a
+    # desired form. `Patch`es are immutable.
+    #
+    class Patch
+      extend Forwardable
+
+      protected def initialize(changes)
+        @changes = changes
+      end
+
+      attr_reader :changes
+
+      def_delegator :changes, :empty?
+
+      def statements
+        changes.map(&:to_cql)
+      end
+
+      class AbstractChange
+        protected def initialize(table, *post_init_args)
+          @table = table
+
+          post_init(*post_init_args)
+        end
+
+        attr_reader :table
+
+        def to_cql
+          fail NotImplementedError
+        end
+
+        def inspect
+          "#<#{self.class.name} #{to_cql}>"
+        end
+
+        def ==(other)
+          other.class == self.class &&
+            other.table == self.table &&
+            subclass_eql?(other)
+        end
+
+        def eql?(other)
+          self == other
+        end
+
+        protected
+
+        def subclass_eql?(other)
+          fail NotImplementedError
+        end
+      end
+
+      class SetTableProperties < AbstractChange
+        protected def post_init()
+        end
+
+        def to_cql
+          %Q|ALTER TABLE "#{table.name}" WITH #{properties.map(&:to_cql).join(' AND ')}|
+        end
+
+        def properties
+          table.properties.values
+        end
+
+        protected
+
+        def subclass_eql?(other)
+          other.properties == propreties
+        end
+      end
+
+      class DropIndex < AbstractChange
+        protected def post_init(column_with_obsolete_idx)
+          @index_name = column_with_obsolete_idx.index_name
+        end
+
+        attr_reader :index_name
+
+        def to_cql
+          %Q|DROP INDEX IF EXISTS "#{index_name}"|
+        end
+
+        protected
+
+        def subclass_eql?(other)
+          other.index_name == index_name
+        end
+      end
+
+      class AddIndex < AbstractChange
+        protected def post_init(column)
+          @column = column
+          @index_name = column.index_name
+        end
+
+        attr_reader :column, :index_name
+
+        def to_cql
+          %Q|CREATE INDEX "#{index_name}" ON "#{table.name}" ("#{column.name}")|
+        end
+
+        protected
+
+        def subclass_eql?(other)
+          other.column == column &&
+            other.index_name == index_name
+        end
+      end
+
+      class AddColumn < AbstractChange
+        protected def post_init(column)
+          @column = column
+        end
+
+        attr_reader :column
+
+        def to_cql
+          %Q|ALTER TABLE "#{table.name}" ADD #{column.to_cql}|
+        end
+
+        protected
+
+        def subclass_eql?(other)
+          other.column == column
+        end
+      end
+
+      class RenameColumn < AbstractChange
+        protected def post_init(old_column, new_column)
+          @old_name, @new_name = old_column.name, new_column.name
+        end
+
+        attr_reader :old_name, :new_name
+
+        def to_cql
+          %Q|ALTER TABLE "#{table.name}" RENAME "#{old_name}" TO "#{new_name}"|
+        end
+
+        protected
+
+        def subclass_eql?(other)
+          other.old_name == old_name &&
+            other.new_name == new_name
+        end
+      end
+    end
+  end
+end