cassandra-driver 3.0.0.beta.1-java → 3.0.0-java

data/lib/cassandra/keyspace.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 #--
-# Copyright 2013-2015 DataStax, Inc.
+# 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.
@@ -42,7 +42,7 @@ module Cassandra
           @klass == other.klass &&
           @options == other.options
       end
-      alias :== :eql?
+      alias == eql?
     end
 
     # @return [String] this keyspace name
@@ -51,7 +51,14 @@ module Cassandra
     attr_reader :replication
 
     # @private
-    def initialize(name, durable_writes, replication, tables, types, functions, aggregates)
+    def initialize(name,
+                   durable_writes,
+                   replication,
+                   tables,
+                   types,
+                   functions,
+                   aggregates,
+                   views)
       @name           = name
       @durable_writes = durable_writes
       @replication    = replication
@@ -59,6 +66,15 @@ module Cassandra
       @types          = types
       @functions      = functions
       @aggregates     = aggregates
+      @views          = views
+
+      # Set the keyspace attribute on the tables and views.
+      @tables.each_value do |t|
+        t.set_keyspace(self)
+      end
+      @views.each_value do |v|
+        v.set_keyspace(self)
+      end
     end
 
     # @return [Boolean] whether durables writes are enabled for this keyspace
@@ -69,7 +85,7 @@ module Cassandra
     # @return [Boolean] whether this keyspace has a table with the given name
     # @param name [String] table name
     def has_table?(name)
-      @tables.has_key?(name)
+      @tables.key?(name)
     end
 
     # @return [Cassandra::Table, nil] a table or nil
@@ -92,13 +108,41 @@ module Cassandra
         @tables.values
       end
     end
-    alias :tables :each_table
+    alias tables each_table
+
+    # @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)
+    end
+
+    # @return [Cassandra::MaterializedView, nil] a materialized view or nil
+    # @param name [String] materialized view name
+    def materialized_view(name)
+      @views[name]
+    end
+
+    # Yield or enumerate each materialized view defined in this keyspace
+    # @overload each_materialized_view
+    #   @yieldparam view [Cassandra::MaterializedView] current materialized view
+    #   @return [Cassandra::Keyspace] self
+    # @overload each_materialized_view
+    #   @return [Array<Cassandra::MaterializedView>] a list of materialized views
+    def each_materialized_view(&block)
+      if block_given?
+        @views.each_value(&block)
+        self
+      else
+        @views.values
+      end
+    end
+    alias materialized_views each_materialized_view
 
     # @return [Boolean] whether this keyspace has a user-defined type with the
     #   given name
     # @param name [String] user-defined type name
     def has_type?(name)
-      @types.has_key?(name)
+      @types.key?(name)
     end
 
     # @return [Cassandra::Types::UserDefined, nil] a type or nil
@@ -121,13 +165,14 @@ module Cassandra
         @types.values
       end
     end
-    alias :types :each_type
+    alias types each_type
 
-    # @return [Boolean] whether this keyspace has a function with the given name and arguments
+    # @return [Boolean] whether this keyspace has a function with the given name and
+    #   arguments
     # @param name [String] function name
     # @param args [Array<String>] (var-args style) function argument types
     def has_function?(name, *args)
-      @functions.has_key?([name.downcase, args])
+      !@functions.get(name.downcase, args).nil?
     end
 
     # @return [Cassandra::Function, nil] a function or nil
@@ -136,7 +181,7 @@ module Cassandra
     def function(name, *args)
       # The functions_hash datastructure is a hash <[func-name, args], Function>.
       # So construct the array-key we're looking for.
-      @functions[[name.downcase, args]]
+      @functions.get(name.downcase, args)
     end
 
     # Yield or enumerate each function defined in this keyspace
@@ -147,27 +192,27 @@ module Cassandra
     #   @return [Array<Cassandra::Function>] a list of functions
     def each_function(&block)
       if block_given?
-        @functions.each_value(&block)
+        @functions.each_function(&block)
         self
       else
-        @functions.values
+        @functions.functions
       end
     end
-    alias :functions :each_function
+    alias functions each_function
 
     # @return [Boolean] whether this keyspace has an aggregate with the given
     #                   name and arguments
     # @param name [String] aggregate name
     # @param args [Array<String>] (var-args style) aggregate function argument types
     def has_aggregate?(name, *args)
-      @aggregates.has_key?([name.downcase, args])
+      !@aggregates.get(name.downcase, args).nil?
     end
 
     # @return [Cassandra::Aggregate, nil] an aggregate or nil
     # @param name [String] aggregate name
     # @param args [Array<String>] (var-args style) aggregate function argument types
     def aggregate(name, *args)
-      @aggregates[[name.downcase, args]]
+      @aggregates.get(name.downcase, args)
     end
 
     # Yield or enumerate each aggregate defined in this keyspace
@@ -178,17 +223,19 @@ module Cassandra
     #   @return [Array<Cassandra::Aggregate>] a list of aggregates
     def each_aggregate(&block)
       if block_given?
-        @aggregates.each_value(&block)
+        @aggregates.each_function(&block)
         self
       else
-        @aggregates.values
+        @aggregates.functions
       end
     end
-    alias :aggregates :each_aggregate
+    alias aggregates each_aggregate
 
     # @return [String] a cql representation of this keyspace
     def to_cql
-      "CREATE KEYSPACE #{Util.escape_name(@name)} WITH replication = #{@replication.to_cql} AND durable_writes = #{@durable_writes};"
+      "CREATE KEYSPACE #{Util.escape_name(@name)} " \
+          "WITH replication = #{@replication.to_cql} AND " \
+          "durable_writes = #{@durable_writes};"
     end
 
     # @private
@@ -202,67 +249,151 @@ module Cassandra
         @functions == other.raw_functions &&
         @aggregates == other.raw_aggregates
     end
-    alias :== :eql?
+    alias == eql?
 
     # @private
     def inspect
-      "#<#{self.class.name}:0x#{self.object_id.to_s(16)} @name=#{@name}>"
+      "#<#{self.class.name}:0x#{object_id.to_s(16)} @name=#{@name}>"
     end
 
     # @private
     def update_table(table)
       tables = @tables.dup
       tables[table.name] = table
-      Keyspace.new(@name, @durable_writes, @replication, tables, @types, @functions, @aggregates)
+      Keyspace.new(@name,
+                   @durable_writes,
+                   @replication,
+                   tables,
+                   @types,
+                   @functions,
+                   @aggregates,
+                   @views)
     end
 
     # @private
     def delete_table(table_name)
       tables = @tables.dup
       tables.delete(table_name)
-      Keyspace.new(@name, @durable_writes, @replication, tables, @types, @functions, @aggregates)
+      Keyspace.new(@name,
+                   @durable_writes,
+                   @replication,
+                   tables,
+                   @types,
+                   @functions,
+                   @aggregates,
+                   @views)
+    end
+
+    # @private
+    def update_materialized_view(view)
+      views = @views.dup
+      views[view.name] = view
+      Keyspace.new(@name,
+                   @durable_writes,
+                   @replication,
+                   @tables,
+                   @types,
+                   @functions,
+                   @aggregates,
+                   views)
+    end
+
+    # @private
+    def delete_materialized_view(view_name)
+      views = @views.dup
+      views.delete(view_name)
+      Keyspace.new(@name,
+                   @durable_writes,
+                   @replication,
+                   @tables,
+                   @types,
+                   @functions,
+                   @aggregates,
+                   views)
     end
 
     # @private
     def update_type(type)
       types = @types.dup
       types[type.name] = type
-      Keyspace.new(@name, @durable_writes, @replication, @tables, types, @functions, @aggregates)
+      Keyspace.new(@name,
+                   @durable_writes,
+                   @replication,
+                   @tables,
+                   types,
+                   @functions,
+                   @aggregates,
+                   @views)
     end
 
     # @private
     def delete_type(type_name)
       types = @types.dup
       types.delete(type_name)
-      Keyspace.new(@name, @durable_writes, @replication, @tables, types, @functions, @aggregates)
+      Keyspace.new(@name,
+                   @durable_writes,
+                   @replication,
+                   @tables,
+                   types,
+                   @functions,
+                   @aggregates,
+                   @views)
     end
 
     # @private
     def update_function(function)
       functions = @functions.dup
-      functions[[function.name, function.argument_types]] = function
-      Keyspace.new(@name, @durable_writes, @replication, @tables, @types, functions, @aggregates)
+      functions.add_or_update(function)
+      Keyspace.new(@name,
+                   @durable_writes,
+                   @replication,
+                   @tables,
+                   @types,
+                   functions,
+                   @aggregates,
+                   @views)
     end
 
     # @private
     def delete_function(function_name, function_args)
       functions = @functions.dup
-      functions.delete([function_name, function_args])
-      Keyspace.new(@name, @durable_writes, @replication, @tables, @types, functions, @aggregates)
+      functions.delete(function_name, function_args)
+      Keyspace.new(@name,
+                   @durable_writes,
+                   @replication,
+                   @tables,
+                   @types,
+                   functions,
+                   @aggregates,
+                   @views)
     end
 
     # @private
     def update_aggregate(aggregate)
       aggregates = @aggregates.dup
-      aggregates[[aggregate.name, aggregate.argument_types]] = aggregate
-      Keyspace.new(@name, @durable_writes, @replication, @tables, @types, @functions, aggregates)
+      aggregates.add_or_update(aggregate)
+      Keyspace.new(@name,
+                   @durable_writes,
+                   @replication,
+                   @tables,
+                   @types,
+                   @functions,
+                   aggregates,
+                   @views)
     end
 
     # @private
     def delete_aggregate(aggregate_name, aggregate_args)
       aggregates = @aggregates.dup
-      aggregates.delete([aggregate_name, aggregate_args])
-      Keyspace.new(@name, @durable_writes, @replication, @tables, @types, @functions, aggregates)
+      aggregates.delete(aggregate_name, aggregate_args)
+      Keyspace.new(@name,
+                   @durable_writes,
+                   @replication,
+                   @tables,
+                   @types,
+                   @functions,
+                   aggregates,
+                   @views)
     end
 
     # @private
@@ -276,6 +407,11 @@ module Cassandra
       @tables
     end
 
+    # @private
+    def raw_materialized_views
+      @views
+    end
+
     # @private
     def raw_types
       @types

data/lib/cassandra/listener.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 #--
-# Copyright 2013-2015 DataStax, Inc.
+# 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.

data/lib/cassandra/load_balancing.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 #--
-# Copyright 2013-2015 DataStax, Inc.
+# 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.
@@ -83,7 +83,7 @@ module Cassandra
 
       # @private
       def inspect
-        "#<#{self.class.name}:0x#{self.object_id.to_s(16)}>"
+        "#<#{self.class.name}:0x#{object_id.to_s(16)}>"
       end
     end
 

data/lib/cassandra/load_balancing/policies.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright 2013-2015 DataStax, Inc.
+# 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.

data/lib/cassandra/load_balancing/policies/dc_aware_round_robin.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 #--
-# Copyright 2013-2015 DataStax, Inc.
+# 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.
@@ -20,6 +20,11 @@ module Cassandra
   module LoadBalancing
     module Policies
       class DCAwareRoundRobin < Policy
+        # @private
+        LOCAL_CONSISTENCIES = [:local_quorum, :local_one].freeze
+        # @private
+        EMPTY_ARRAY         = [].freeze
+
         # @private
         class Plan
           def initialize(local, remote, index)
@@ -56,16 +61,25 @@ module Cassandra
 
         include MonitorMixin
 
-        def initialize(datacenter = nil, max_remote_hosts_to_use = nil, use_remote_hosts_for_local_consistency = false)
-          datacenter              = datacenter && String(datacenter)
-          max_remote_hosts_to_use = max_remote_hosts_to_use && Integer(max_remote_hosts_to_use)
+        def initialize(datacenter = nil,
+                       max_remote_hosts_to_use = 0,
+                       use_remote_hosts_for_local_consistency = false)
+          datacenter              &&= String(datacenter)
+          max_remote_hosts_to_use &&= Integer(max_remote_hosts_to_use)
 
-          unless datacenter.nil?
-            Util.assert_not_empty(datacenter) { "datacenter cannot be empty" }
-          end
+          Util.assert_not_empty(datacenter) { 'datacenter cannot be empty' } unless datacenter.nil?
 
           unless max_remote_hosts_to_use.nil?
-            Util.assert(max_remote_hosts_to_use >= 0) { "max_remote_hosts_to_use must be nil or >= 0" }
+            Util.assert(max_remote_hosts_to_use >= 0) do
+              'max_remote_hosts_to_use must be nil or >= 0'
+            end
+          end
+
+          # If use_remote* is true, max_remote* must be > 0
+          if use_remote_hosts_for_local_consistency
+            Util.assert(max_remote_hosts_to_use.nil? || max_remote_hosts_to_use > 0,
+                        'max_remote_hosts_to_use must be nil (meaning unlimited) or > 0 when ' \
+                        'use_remote_hosts_for_local_consistency is true')
           end
 
           @datacenter = datacenter
@@ -80,16 +94,12 @@ module Cassandra
         end
 
         def host_up(host)
-          if !@datacenter && host.datacenter
-            @datacenter = host.datacenter
-          end
+          @datacenter = host.datacenter if !@datacenter && host.datacenter
 
           if host.datacenter.nil? || host.datacenter == @datacenter
             synchronize { @local = @local.dup.push(host) }
-          else
-            if @max_remote.nil? || @remote.size < @max_remote
-              synchronize { @remote = @remote.dup.push(host) }
-            end
+          elsif @max_remote.nil? || @remote.size < @max_remote
+            synchronize { @remote = @remote.dup.push(host) }
           end
 
           self
@@ -130,11 +140,11 @@ module Cassandra
         def plan(keyspace, statement, options)
           local = @local
 
-          if LOCAL_CONSISTENCIES.include?(options.consistency) && !@use_remote
-            remote = EMPTY_ARRAY
-          else
-            remote = @remote
-          end
+          remote = if LOCAL_CONSISTENCIES.include?(options.consistency) && !@use_remote
+                     EMPTY_ARRAY
+                   else
+                     @remote
+                   end
 
           total = local.size + remote.size
 
@@ -146,12 +156,16 @@ module Cassandra
           Plan.new(local, remote, position)
         end
 
-        private
-
         # @private
-        LOCAL_CONSISTENCIES = [:local_quorum, :local_one].freeze
-        # @private
-        EMPTY_ARRAY         = [].freeze
+        def inspect
+          "#<#{self.class.name}:0x#{object_id.to_s(16)} " \
+          "datacenter=#{@datacenter.inspect}, " \
+          "use_remote=#{@use_remote.inspect}, " \
+          "max_remote=#{@max_remote.inspect}, " \
+          "local=#{@local.inspect}, " \
+          "remote=#{@remote.inspect}, " \
+          "position=#{@position.inspect}>"
+        end
       end
     end
   end