Merge pull request #181 from datastax/RUBY-241

RUBY-241 - Don't expose materialized view's with nil base-table's.

Author: stamhankar999

CHANGELOG.md

@@ -3,6 +3,10 @@
 Features:
 
 Bug Fixes:
+# 3.0.3
+
+Bug Fixes:
+* [RUBY-241](https://datastax-oss.atlassian.net/browse/RUBY-241) Materialied views sometimes have nil ref to base-table.
 
 # 3.0.2
 

lib/cassandra/cluster/schema/fetchers.rb

@@ -107,10 +107,8 @@ def fetch_materialized_view(connection, keyspace_name, view_name)
               nil
             else
               view_row = rows_views.first
-              base_table = @schema.keyspace(keyspace_name).table(view_row['base_table_name'])
               create_materialized_view(view_row,
-                                       rows_columns,
-                                       base_table)
+                                       rows_columns)
             end
           end
         end
@@ -1216,10 +1214,8 @@ def create_keyspace(keyspace_data, rows_tables, rows_columns, rows_types,
 
             views = rows_views.each_with_object({}) do |row, h|
               view_name = row['view_name']
-              base_table = tables[row['base_table_name']]
               h[view_name] = create_materialized_view(row,
                                                       lookup_columns[view_name],
-                                                      base_table,
                                                       types)
             end
 
@@ -1366,9 +1362,10 @@ def create_index(table, row_index)
                                                  options['target'], options))
           end
 
-          def create_materialized_view(view_data, rows_columns, base_table, types = nil)
+          def create_materialized_view(view_data, rows_columns, types = nil)
             keyspace_name   = view_data['keyspace_name']
             view_name       = view_data['view_name']
+            base_table_name = view_data['base_table_name']
             include_all_columns = view_data['include_all_columns']
             where_clause = view_data['where_clause']
 
@@ -1406,7 +1403,7 @@ def create_materialized_view(view_data, rows_columns, base_table, types = nil)
                                  view_options,
                                  include_all_columns,
                                  where_clause,
-                                 base_table,
+                                 base_table_name,
                                  view_data['id'])
           end
         end

lib/cassandra/keyspace.rb

@@ -113,13 +113,15 @@ def each_table(&block)
     # @return [Boolean] whether this keyspace has a materialized view with the given name
     # @param name [String] materialized view name
     def has_materialized_view?(name)
-      @views.key?(name)
+      # We check if the view exists *and* that its base-table is set. If base-table isn't available,
+      # it will be soon, so the user can poll on this method until we return a fully-baked materialized view.
+      @views.key?(name) && @views[name].base_table
     end
 
     # @return [Cassandra::MaterializedView, nil] a materialized view or nil
     # @param name [String] materialized view name
     def materialized_view(name)
-      @views[name]
+      @views[name] if has_materialized_view?(name)
     end
 
     # Yield or enumerate each materialized view defined in this keyspace
@@ -130,10 +132,16 @@ def materialized_view(name)
     #   @return [Array<Cassandra::MaterializedView>] a list of materialized views
     def each_materialized_view(&block)
       if block_given?
-        @views.each_value(&block)
+        @views.each_value do |v|
+          block.call(v) if v.base_table
+        end
         self
       else
-        @views.values
+        result = []
+        @views.each_value do |v|
+          result << v if v.base_table
+        end
+        result
       end
     end
     alias materialized_views each_materialized_view

lib/cassandra/materialized_view.rb

@@ -21,9 +21,6 @@ module Cassandra
   # @see Cassandra::Keyspace#each_materialized_view
   # @see Cassandra::Keyspace#materialized_view
   class MaterializedView < ColumnContainer
-    # @return [Table] the table that this materialized view applies to.
-    attr_reader :base_table
-
     # @private
     def initialize(keyspace,
                    name,
@@ -33,12 +30,17 @@ def initialize(keyspace,
                    options,
                    include_all_columns,
                    where_clause,
-                   base_table,
+                   base_table_name,
                    id)
       super(keyspace, name, partition_key, clustering_columns, other_columns, options, id)
       @include_all_columns = include_all_columns
       @where_clause = where_clause
-      @base_table = base_table
+      @base_table_name = base_table_name
+    end
+
+    # @return [Table] the table that this materialized view applies to.
+    def base_table
+      @keyspace.table(@base_table_name)
     end
 
     # @return [String] a cql representation of this materialized view
@@ -52,7 +54,7 @@ def to_cql
                  Util.escape_name(column.name)
                end.join(', ')
              end
-      cql << "\nFROM #{keyspace_name}.#{Util.escape_name(@base_table.name)}"
+      cql << "\nFROM #{keyspace_name}.#{Util.escape_name(@base_table_name)}"
       cql << "\nWHERE #{@where_clause}" if @where_clause
       cql << "\nPRIMARY KEY (("
       cql << @partition_key.map do |column|
@@ -74,7 +76,7 @@ def eql?(other)
         super.eql?(other) &&
         @include_all_columns == other.include_all_columns &&
         @where_clause == other.where_clause &&
-        @base_table == other.base_table
+        @base_table_name == other.base_table.name
     end
     alias == eql?
 

spec/cassandra/keyspace_spec.rb

@@ -0,0 +1,91 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2016 DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#++
+
+require 'spec_helper'
+
+include Cassandra::Types
+module Cassandra
+  describe(Keyspace) do
+    let(:view) { double('view') }
+    let(:table) { double('table') }
+    let(:ks) { Keyspace.new('myks', true, nil, {'mytable' => table}, nil, nil, nil, {'myview' => view}) }
+
+    before do
+      allow(view).to receive(:set_keyspace)
+      allow(table).to receive(:set_keyspace)
+    end
+
+    context :has_materialized_view? do
+      it 'should return true if the view exists and has a base-table' do
+        expect(view).to receive(:base_table).and_return(:table)
+        expect(ks.has_materialized_view?('myview')).to be_truthy
+      end
+
+      it 'should return false if the view exists but does not have a base-table' do
+        expect(view).to receive(:base_table).and_return(nil)
+        expect(ks.has_materialized_view?('myview')).to be_falsey
+      end
+    end
+
+    context :materialized_view do
+      it 'should return the view if it exists and has a base-table' do
+        expect(view).to receive(:base_table).and_return(:table)
+        expect(ks.materialized_view('myview')).to be(view)
+      end
+
+      it 'should return nil if the view exists but does not have a base-table' do
+        expect(view).to receive(:base_table).and_return(nil)
+        expect(ks.materialized_view('myview')).to be_nil
+      end
+    end
+
+    context :materialized_views do
+      it 'should return the view if it exists and has a base-table' do
+        expect(view).to receive(:base_table).and_return(:table)
+        expect(ks.materialized_views).to eq([view])
+      end
+
+      it 'should not return view if the view exists but does not have a base-table' do
+        expect(view).to receive(:base_table).and_return(nil)
+        expect(ks.materialized_views).to be_empty
+      end
+    end
+
+    context :each_materialized_view do
+      it 'should return the view if it exists and has a base-table' do
+        expect(view).to receive(:base_table).and_return(:table)
+        result = []
+        ks.each_materialized_view do |v|
+          result << v
+        end
+
+        expect(result).to eq([view])
+      end
+
+      it 'should not return view if the view exists but does not have a base-table' do
+        expect(view).to receive(:base_table).and_return(nil)
+        result = []
+        ks.each_materialized_view do |v|
+          result << v
+        end
+
+        expect(result).to be_empty
+      end
+    end
+  end
+end

spec/cassandra/materialized_view_spec.rb

@@ -34,6 +34,7 @@ module Cassandra
 
       before do
         allow(ks).to receive(:name).and_return('myks1')
+        allow(ks).to receive(:table).with('table1').and_return(table)
         allow(table).to receive(:name).and_return('table1')
         allow(col).to receive(:name).and_return('col')
         allow(col).to receive(:type).and_return(Cassandra::Types.int)
@@ -45,7 +46,7 @@ module Cassandra
       end
 
       it 'should quote keyspace, view name, table name, columns properly' do
-        t = MaterializedView.new(ks, 'myview1', [col], [], [col2, col3], options, false, where, table,id)
+        t = MaterializedView.new(ks, 'myview1', [col], [], [col2, col3], options, false, where, 'table1', id)
         expected_cql = <<-EOF
 CREATE MATERIALIZED VIEW "myks1"."myview1" AS
 SELECT col, "col2", "from"
@@ -58,7 +59,7 @@ module Cassandra
       end
 
       it 'should quote primary key properly for simple partition key' do
-        t = MaterializedView.new(ks, 'myview1', [col], [col2], [col3], options, false, where, table,id)
+        t = MaterializedView.new(ks, 'myview1', [col], [col2], [col3], options, false, where, 'table1', id)
         expected_cql = <<-EOF
 CREATE MATERIALIZED VIEW "myks1"."myview1" AS
 SELECT col, "col2", "from"
@@ -71,7 +72,7 @@ module Cassandra
       end
 
       it 'should quote primary key properly for composite partition key' do
-        t = MaterializedView.new(ks, 'myview1', [col, col2], [col3], [], options, false, where, table,id)
+        t = MaterializedView.new(ks, 'myview1', [col, col2], [col3], [], options, false, where, 'table1', id)
         expected_cql = <<-EOF
 CREATE MATERIALIZED VIEW "myks1"."myview1" AS
 SELECT col, "col2", "from"
@@ -84,7 +85,7 @@ module Cassandra
       end
 
       it 'should handle no where-clause properly' do
-        t = MaterializedView.new(ks, 'myview1', [col, col2], [col3], [], options, false, nil, table,id)
+        t = MaterializedView.new(ks, 'myview1', [col, col2], [col3], [], options, false, nil, 'table1', id)
         expected_cql = <<-EOF
 CREATE MATERIALIZED VIEW "myks1"."myview1" AS
 SELECT col, "col2", "from"
@@ -96,7 +97,7 @@ module Cassandra
       end
 
       it 'should handle include-all-columns properly' do
-        t = MaterializedView.new(ks, 'myview1', [col, col2], [col3], [], options, true, nil, table,id)
+        t = MaterializedView.new(ks, 'myview1', [col, col2], [col3], [], options, true, nil, 'table1', id)
         expected_cql = <<-EOF
 CREATE MATERIALIZED VIEW "myks1"."myview1" AS
 SELECT *