cequel 1.0.0.pre.3 → 1.0.0.pre.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2f70439ec577904a2fbe7a6c8f8689f45636e800
-  data.tar.gz: b0ede82f2cdafba89f308d1f744252803d824c56
+  metadata.gz: af518e804a2ce5cf3e021b7a2ba92302011c0cd4
+  data.tar.gz: dadafdee945a8c961ac58fcf29ed3a76f84e616e
 SHA512:
-  metadata.gz: d5d46692ee7904443fb60418ff003d1c04c14f7b947b1685e08ba73945839028e09371b81368532881f3f230160314d946db1238d1652077cb6d4a11d6ffe52e
-  data.tar.gz: 7ac1535e9338974c0b8e545c7715810b763c8f02f3e98225c94bef6bf3502287c33fcd67c422e272371248cd7d22cdc12a71cc1a24b6305f7ae48f496670ebfa
+  metadata.gz: f90d210ad3a9ab787fcd6e70bba0e950f5983ade9d41f5f17f160b91eab470a84e4f5ca4f828be938db04ccb4bafda1f1be5fba1ea2db75667a2a82ee0d6043b
+  data.tar.gz: 22436304a692c25bd34ce86b58d317630b81af527a28234e3d4bc4884617699cb0fc1092138e7c1a54867059f8118b183e8c4263bef175f735041948a5a53a93

data/lib/cequel/record/associations.rb

@@ -32,11 +32,23 @@ module Cequel
           def_parent_association_accessors
         end
 
-        def has_many(name)
+        def has_many(name, options = {})
+          options.assert_valid_keys(:dependent)
+
           association = HasManyAssociation.new(self, name.to_sym)
           self.child_associations =
             child_associations.merge(name => association)
           def_child_association_reader(association)
+
+          case options[:dependent]
+          when :destroy
+            after_destroy { delete_children(name, true) }
+          when :delete
+            after_destroy { delete_children(name) }
+          when nil
+          else
+            raise ArgumentError, "Invalid option #{options[:dependent].inspect} provided for :dependent. Specify :destroy or :delete."
+          end
         end
 
         private
@@ -117,6 +129,17 @@ module Cequel
           ivar, AssociationCollection.new(association_record_set))
       end
 
+      def delete_children(association_name, run_callbacks = false)
+        if run_callbacks
+          self.send(association_name).each do |c|
+            c.run_callbacks(:destroy)
+          end
+        end
+        connection[association_name].where(
+          send(association_name).scoped_key_attributes
+        ).delete
+      end
+
     end
 
   end

data/lib/cequel/record/schema.rb

@@ -16,7 +16,7 @@ module Cequel
         extend Forwardable
 
         def_delegators :table_schema, :key_columns, :key_column_names,
-          :partition_key_columns, :clustering_columns
+          :partition_key_columns, :clustering_columns, :compact_storage?
         def_delegator :table_schema, :column, :reflect_on_column
 
         def synchronize_schema
@@ -63,6 +63,10 @@ module Cequel
           table_schema.add_property(name, value)
         end
 
+        def compact_storage
+          table_schema.compact_storage = true
+        end
+
       end
 
       protected

data/lib/cequel/schema/table_reader.rb

@@ -56,6 +56,8 @@ module Cequel
         comparators = parse_composite_types(table_data['comparator'])
         unless comparators
           table.compact_storage = true
+          return unless column_data.empty?
+          column_aliases << nil if column_aliases.empty?
           comparators = [table_data['comparator']]
         end
         column_aliases.zip(comparators) do |column_alias, type|
@@ -64,7 +66,7 @@ module Cequel
             clustering_order = :desc
           end
           table.add_clustering_column(
-            column_alias.to_sym,
+            column_alias.try(:to_sym),
             Type.lookup_internal(type),
             clustering_order
           )
@@ -72,19 +74,27 @@ module Cequel
       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)
-            )
+        if column_data.empty?
+          table.add_data_column(
+            table_data['value_alias'],
+            Type.lookup_internal(table_data['default_validator']),
+            false
+          )
+        else
+          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
       end

data/lib/cequel/schema/table_synchronizer.rb

@@ -37,7 +37,7 @@ module Cequel
               "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)
+            updater.rename_column(old_key.name || :column1, new_key.name)
           end
         end
       end
@@ -64,6 +64,9 @@ module Cequel
       end
 
       def update_column(old_column, new_column)
+        if old_column.name != new_column.name
+          updater.rename_column(old_column.name || :value, new_column.name)
+        end
         if old_column.type != new_column.type
           updater.change_column(new_column.name, new_column.type)
         end
@@ -99,11 +102,15 @@ module Cequel
       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]
+        if existing.compact_storage? && existing.clustering_columns.any?
+          yield existing.data_columns.first, updated.data_columns.first
+        else
+          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).tap(&:uniq!)
+          all_column_names.each do |name|
+            yield old_columns[name], new_columns[name]
+          end
         end
       end
 

data/lib/cequel/schema/table_updater.rb

@@ -41,7 +41,7 @@ module Cequel
       end
 
       def rename_column(old_name, new_name)
-        alter_table("RENAME #{old_name} TO #{new_name}")
+        alter_table(%(RENAME "#{old_name}" TO "#{new_name}"))
       end
 
       def change_properties(options)

data/lib/cequel/version.rb

@@ -1,3 +1,3 @@
 module Cequel
-  VERSION = '1.0.0.pre.3'
+  VERSION = '1.0.0.pre.4'
 end

data/spec/examples/record/associations_spec.rb

@@ -18,6 +18,21 @@ describe Cequel::Record::Associations do
     belongs_to :blog
     key :id, :uuid, auto: true
     column :title, :text
+
+    has_many :comments, dependent: :destroy
+    has_many :attachments, dependent: :delete
+  end
+
+  model :Comment do
+    belongs_to :post
+    key :id, :uuid, auto: true
+    column :content, :text
+  end
+
+  model :Attachment do
+    belongs_to :post
+    key :id, :uuid, auto: true
+    column :caption, :text
   end
 
   describe '::belongs_to' do
@@ -114,6 +129,79 @@ describe Cequel::Record::Associations do
       posts.first.destroy
       blog.posts(true).map(&:title).should == ['Post 1', 'Post 2']
     end
-  end
 
+    it "does not allow invalid :dependent options" do
+      expect {
+        Post.class_eval do
+          has_many :users, dependent: :bar
+        end
+      }.to raise_error(ArgumentError)
+    end
+
+    it "does not allow unrecognized options" do
+      expect {
+        Post.class_eval do
+          has_many :users, bogus: :buffalo
+        end
+      }.to raise_error(ArgumentError)
+    end
+
+    context "with dependent => destroy" do
+      let(:post_with_comments) { posts.first }
+
+      before :each do
+        2.times.map do |i|
+          Comment.new do |comment|
+            comment.content = "cat #{i} is awesome"
+            comment.post = post_with_comments
+          end.tap(&:save)
+        end
+        @callback_count = 0
+        Comment.any_instance.stub(:run_callbacks).with(:destroy) do
+          @callback_count += 1
+        end
+      end
+
+      it "deletes all children when destroying the parent" do
+        expect {
+          post_with_comments.destroy
+        }.to change { Comment.count }.by(-2)
+      end
+
+      it "executes :destroy callbacks on the children" do
+        expect {
+          post_with_comments.destroy
+        }.to change { @callback_count }.by(2)
+      end
+    end
+
+    context "with dependent => delete" do
+      let(:post_with_attachments) { posts.first }
+
+      before :each do
+        2.times.map do |i|
+          Attachment.new do |comment|
+            comment.caption = "cat #{i} is awesome"
+            comment.post = post_with_attachments
+          end.tap(&:save)
+        end
+        @callback_count = 0
+        Attachment.any_instance.stub(:run_callbacks).with(:destroy) do
+          @callback_count += 1
+        end
+      end
+
+      it "deletes all children when destroying the parent" do
+        expect {
+          post_with_attachments.destroy
+        }.to change { Attachment.count }.by(-2)
+      end
+
+      it "executes :destroy callbacks on the children" do
+        expect {
+          post_with_attachments.destroy
+        }.to change { @callback_count }.by(0)
+      end
+    end
+  end
 end

data/spec/examples/record/schema_spec.rb

@@ -1,45 +1,88 @@
 require File.expand_path('../spec_helper', __FILE__)
 
 describe Cequel::Record::Schema do
-  after { cequel.schema.drop_table(:posts) }
-  subject { cequel.schema.read_table(:posts) }
-
-  let(:model) do
-    Class.new do
-      include Cequel::Record
-      self.table_name = 'posts'
-
-      key :permalink, :text
-      column :title, :text
-      list :categories, :text
-      set :tags, :text
-      map :trackbacks, :timestamp, :text
-      table_property :comment, 'Blog Posts'
-    end
-  end
-
-  context 'new model with simple primary key' do
-    before { model.synchronize_schema }
+  context 'CQL3 table' do
+    after { cequel.schema.drop_table(:posts) }
+    subject { cequel.schema.read_table(:posts) }
 
-    its(:partition_key_columns) { should == [Cequel::Schema::Column.new(:permalink, :text)] }
-    its(:data_columns) { should include(Cequel::Schema::Column.new(:title, :text)) }
-    its(:data_columns) { should include(Cequel::Schema::List.new(:categories, :text)) }
-    its(:data_columns) { should include(Cequel::Schema::Set.new(:tags, :text)) }
-    its(:data_columns) { should include(Cequel::Schema::Map.new(:trackbacks, :timestamp, :text)) }
-    specify { subject.property(:comment).should == 'Blog Posts' }
-  end
+    let(:model) do
+      Class.new do
+        include Cequel::Record
+        self.table_name = 'posts'
 
-  context 'existing model with additional attribute' do
-    before do
-      cequel.schema.create_table :posts do
         key :permalink, :text
         column :title, :text
         list :categories, :text
         set :tags, :text
+        map :trackbacks, :timestamp, :text
+        table_property :comment, 'Blog Posts'
+      end
+    end
+
+    context 'new model with simple primary key' do
+      before { model.synchronize_schema }
+
+      its(:partition_key_columns) { should == [Cequel::Schema::Column.new(:permalink, :text)] }
+      its(:data_columns) { should include(Cequel::Schema::Column.new(:title, :text)) }
+      its(:data_columns) { should include(Cequel::Schema::List.new(:categories, :text)) }
+      its(:data_columns) { should include(Cequel::Schema::Set.new(:tags, :text)) }
+      its(:data_columns) { should include(Cequel::Schema::Map.new(:trackbacks, :timestamp, :text)) }
+      specify { subject.property(:comment).should == 'Blog Posts' }
+    end
+
+    context 'existing model with additional attribute' do
+      before do
+        cequel.schema.create_table :posts do
+          key :permalink, :text
+          column :title, :text
+          list :categories, :text
+          set :tags, :text
+        end
+        model.synchronize_schema
       end
-      model.synchronize_schema
+
+      its(:data_columns) { should include(Cequel::Schema::Map.new(:trackbacks, :timestamp, :text)) }
     end
+  end
 
-    its(:data_columns) { should include(Cequel::Schema::Map.new(:trackbacks, :timestamp, :text)) }
+  context 'wide-row legacy table' do
+    let(:legacy_model) do
+      Class.new do
+        include Cequel::Record
+        self.table_name = 'legacy_posts'
+
+        key :blog_subdomain, :text
+        key :id, :uuid
+        column :data, :text
+
+        compact_storage
+      end
+    end
+    after { cequel.schema.drop_table(:legacy_posts) }
+    subject { cequel.schema.read_table(:legacy_posts) }
+
+    context 'new model' do
+      before { legacy_model.synchronize_schema }
+
+      its(:partition_key_columns) { should == [Cequel::Schema::Column.new(:blog_subdomain, :text)] }
+      its(:clustering_columns) { should == [Cequel::Schema::Column.new(:id, :uuid)] }
+      it { should be_compact_storage }
+      its(:data_columns) { should == [Cequel::Schema::Column.new(:data, :text)] }
+    end
+
+    context 'existing model' do
+      before do
+        legacy_connection.execute(<<-CQL2)
+          CREATE COLUMNFAMILY legacy_posts (blog_subdomain text PRIMARY KEY)
+          WITH comparator=uuid AND default_validation=text
+        CQL2
+        legacy_model.synchronize_schema
+      end
+
+      its(:partition_key_columns) { should == [Cequel::Schema::Column.new(:blog_subdomain, :text)] }
+      its(:clustering_columns) { should == [Cequel::Schema::Column.new(:id, :uuid)] }
+      it { should be_compact_storage }
+      its(:data_columns) { should == [Cequel::Schema::Column.new(:data, :text)] }
+    end
   end
 end

data/spec/examples/schema/table_reader_spec.rb

@@ -304,25 +304,86 @@ describe Cequel::Schema::TableReader do
       table.property(:compression)[:crc_check_chance].should == 0.5
     end
 
-  end # describe 'reading storage properties'
+    it 'should recognize no compact storage' do
+      table.should_not be_compact_storage
+    end
 
-  describe 'compact storage' do
+  end # describe 'reading storage properties'
 
-    it 'should read non-compact storage status' do
+  describe 'skinny-row compact storage' do
+    before do
       cequel.execute <<-CQL
-        CREATE TABLE posts (permalink text PRIMARY KEY, body text)
+        CREATE TABLE posts (permalink text PRIMARY KEY, title text, body text)
+        WITH COMPACT STORAGE
       CQL
-      table.should_not be_compact_storage
     end
+    subject { table }
+
+    it { should be_compact_storage }
+    its(:partition_key_columns) { should ==
+      [Cequel::Schema::PartitionKey.new(:permalink, :text)] }
+    its(:clustering_columns) { should be_empty }
+    its(:data_columns) { should =~
+      [Cequel::Schema::DataColumn.new(:title, :text),
+        Cequel::Schema::DataColumn.new(:body, :text)] }
+  end
 
-    it 'should read compact storage status' do
+  describe 'wide-row compact storage' do
+    before do
       cequel.execute <<-CQL
-        CREATE TABLE posts (permalink text PRIMARY KEY, body text)
+        CREATE TABLE posts (
+          blog_subdomain text,
+          id uuid,
+          data text,
+          PRIMARY KEY (blog_subdomain, id)
+        )
         WITH COMPACT STORAGE
       CQL
-      table.should be_compact_storage
     end
+    subject { table }
+
+    it { should be_compact_storage }
+    its(:partition_key_columns) { should ==
+      [Cequel::Schema::PartitionKey.new(:blog_subdomain, :text)] }
+    its(:clustering_columns) { should ==
+      [Cequel::Schema::ClusteringColumn.new(:id, :uuid)] }
+    its(:data_columns) { should ==
+      [Cequel::Schema::DataColumn.new(:data, :text)] }
+  end
 
+  describe 'skinny-row legacy table' do
+    before do
+      legacy_connection.execute <<-CQL
+        CREATE TABLE posts (permalink text PRIMARY KEY, title text, body text)
+      CQL
+    end
+    subject { table }
+
+    it { should be_compact_storage }
+    its(:partition_key_columns) { should ==
+      [Cequel::Schema::PartitionKey.new(:permalink, :text)] }
+    its(:clustering_columns) { should be_empty }
+    its(:data_columns) { should =~
+      [Cequel::Schema::DataColumn.new(:title, :text),
+        Cequel::Schema::DataColumn.new(:body, :text)] }
+  end
+
+  describe 'wide-row legacy table' do
+    before do
+      legacy_connection.execute(<<-CQL2)
+        CREATE COLUMNFAMILY posts (blog_subdomain text PRIMARY KEY)
+        WITH comparator=uuid AND default_validation=text
+      CQL2
+    end
+    subject { table }
+
+    it { should be_compact_storage }
+    its(:partition_key_columns) { should ==
+      [Cequel::Schema::PartitionKey.new(:blog_subdomain, :text)] }
+    its(:clustering_columns) { should ==
+      [Cequel::Schema::ClusteringColumn.new(nil, :uuid)] }
+    its(:data_columns) { should ==
+      [Cequel::Schema::DataColumn.new(nil, :text)] }
   end
 
 end

data/spec/support/helpers.rb

@@ -52,8 +52,9 @@ module Cequel
 
       def self.cequel
         @cequel ||= Cequel.connect(
-          :host => host,
-          :keyspace => keyspace_name
+          host: host,
+          keyspace: keyspace_name,
+          thrift: {retries: 5, cached_connections: true}
         ).tap do |cequel|
           cequel.logger = Logger.new(STDOUT) if ENV['CEQUEL_LOG_QUERIES']
         end
@@ -67,10 +68,22 @@ module Cequel
         ENV['CEQUEL_TEST_KEYSPACE'] || 'cequel_test'
       end
 
+      def self.legacy_connection
+        @legacy_connection ||= CassandraCQL::Database.new(
+          Cequel::SpecSupport::Helpers.host,
+          :keyspace => Cequel::SpecSupport::Helpers.keyspace_name,
+          :cql_version => '2.0.0'
+        )
+      end
+
       def cequel
         Helpers.cequel
       end
 
+      def legacy_connection
+        Helpers.legacy_connection
+      end
+
       def max_statements!(number)
         cequel.should_receive(:execute).at_most(number).times.and_call_original
       end

metadata

@@ -1,17 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: cequel
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre.3
+  version: 1.0.0.pre.4
 platform: ruby
 authors:
 - Mat Brown
 - Aubrey Holland
 - Keenan Brock
 - Insoo Buzz Jung
+- Louis Simoneau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-26 00:00:00.000000000 Z
+date: 2013-09-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport