cassandra-driver 3.0.3-java → 3.1.0-java

data/lib/cassandra/result.rb

@@ -32,7 +32,7 @@ module Cassandra
                                     @consistency,
                                     @retries,
                                     @trace_id ?
-                                        Execution::Trace.new(@trace_id, @client) :
+                                        Execution::Trace.new(@trace_id, @client, @options.load_balancing_policy) :
                                         nil)
     end
 

data/lib/cassandra/session.rb

@@ -29,10 +29,11 @@ module Cassandra
     def_delegators :@client, :keyspace
 
     # @private
-    def initialize(client, default_options, futures_factory)
+    def initialize(client, default_options, futures_factory, profile_manager)
       @client  = client
       @options = default_options
       @futures = futures_factory
+      @profile_manager = profile_manager
     end
 
     # Executes a given statement and returns a future result
@@ -66,6 +67,8 @@ module Cassandra
     #   statement can be retried safely on timeout.
     # @option options [Hash<[String, Symbol], String>] :payload (nil) custom
     #   outgoing payload to be sent with the request.
+    # @option options [String, Symbol] :execution_profile (nil) name of {Cassandra::Execution::Profile}
+    #   from which to obtain certain query options. Defaults to the cluster's default execution profile.
     #
     # @see Cassandra.cluster Options that can be specified on the cluster-level
     #   and their default values.
@@ -78,14 +81,9 @@ module Cassandra
     #
     # @return [Cassandra::Future<Cassandra::Result>]
     #
-    # @see Cassandra::Session#execute A list of errors this future can be
-    #   resolved with
+    # @see Cassandra::Session#execute A list of errors this future can be resolved with
     def execute_async(statement, options = nil)
-      options = if options
-                  @options.override(options)
-                else
-                  @options
-                end
+      options = merge_execution_options(options)
 
       case statement
       when ::String
@@ -110,7 +108,7 @@ module Cassandra
     #   Cassandra::Statements::Bound, Cassandra::Statements::Prepared]
     #   statement to execute
     #
-    # @param options [Hash] (nil) a customizable set of options
+    # @param options [Hash] (nil) a customizable set of options. See {#execute_async} for details.
     #
     # @see Cassandra::Session#execute_async
     # @see Cassandra::Future#get
@@ -138,15 +136,13 @@ module Cassandra
     # @option options [Boolean] :idempotent (false) specify whether the
     #   statement being prepared can be retried safely on timeout during
     #   execution.
+    # @option options [String, Symbol] :execution_profile (nil) name of {Cassandra::Execution::Profile}
+    #   from which to obtain certain query options. Defaults to the cluster's default execution profile.
     #
     # @return [Cassandra::Future<Cassandra::Statements::Prepared>] future
     #   prepared statement
     def prepare_async(statement, options = nil)
-      options = if options.is_a?(::Hash)
-                  @options.override(options)
-                else
-                  @options
-                end
+      options = merge_execution_options(options)
 
       case statement
       when ::String
@@ -161,14 +157,20 @@ module Cassandra
     end
 
     # A blocking wrapper around {Cassandra::Session#prepare_async}
+    #
+    # @param statement [String, Cassandra::Statements::Simple] a statement to
+    #   prepare
+    #
+    # @param options [Hash] (nil) a customizable set of options. See {#prepare_async} for details.
+    #
     # @see Cassandra::Session#prepare_async
     # @see Cassandra::Future#get
     #
     # @return [Cassandra::Statements::Prepared] prepared statement
     # @raise [Cassandra::Errors::NoHostsAvailable] if none of the hosts can be reached
     # @raise [Cassandra::Errors::ExecutionError] if Cassandra returns an error response
-    def prepare(*args)
-      prepare_async(*args).get
+    def prepare(statement, options = nil)
+      prepare_async(statement, options).get
     end
 
     # Returns a logged {Statements::Batch} instance and optionally yields it to
@@ -235,5 +237,30 @@ module Cassandra
       "@keyspace=#{keyspace.inspect}, " \
       "@options=#{@options.inspect}>"
     end
+
+    private
+
+    # @private
+    def merge_execution_options(options)
+      if options
+        Util.assert_instance_of(::Hash, options, "options must be a Hash, #{options.inspect} given")
+        # Yell if the caller gave us a bad profile name.
+        execution_profile = nil
+        if options.key?(:execution_profile)
+          execution_profile = @profile_manager.profiles[options[:execution_profile]]
+          raise ::ArgumentError.new("Unknown execution profile #{options[:execution_profile]}") unless execution_profile
+        end
+
+        # This looks a little hokey, so let's explain: Execution::Options.override takes a
+        # varargs-style array of things to merge into the base options object (to produce
+        # a new Options object, not mutate the base). If an execution profile was specified,
+        # we want its attributes to override the base options. In addition, if individual options
+        # were specified, we want *those* to take precedence over the execution profile attributes.
+        # So we override in this order.
+        @options.override(execution_profile, options)
+      else
+        @options
+      end
+    end
   end
 end

data/lib/cassandra/statements/bound.rb

@@ -28,15 +28,19 @@ module Cassandra
       attr_reader :params
       # @private
       attr_reader :params_types, :result_metadata, :keyspace, :partition_key
+      # @private prepared-statement id
+      attr_reader :id
 
       # @private
-      def initialize(cql,
+      def initialize(id,
+                     cql,
                      params_types,
                      result_metadata,
                      params,
                      keyspace = nil,
                      partition_key = nil,
                      idempotent = false)
+        @id              = id
         @cql             = cql
         @params_types    = params_types
         @result_metadata = result_metadata

data/lib/cassandra/statements/prepared.rb

@@ -27,9 +27,12 @@ module Cassandra
       attr_reader :cql
       # @private
       attr_reader :result_metadata
+      # @private prepared-statement id
+      attr_reader :id
 
       # @private
-      def initialize(payload,
+      def initialize(id,
+                     payload,
                      warnings,
                      cql,
                      params_metadata,
@@ -44,6 +47,7 @@ module Cassandra
                      retries,
                      client,
                      connection_options)
+        @id                 = id
         @payload            = payload
         @warnings           = warnings
         @cql                = cql
@@ -131,7 +135,8 @@ module Cassandra
 
         partition_key = create_partition_key(params)
 
-        Bound.new(@cql,
+        Bound.new(@id,
+                  @cql,
                   param_types,
                   @result_metadata,
                   params,
@@ -151,7 +156,7 @@ module Cassandra
                                       @consistency,
                                       @retries,
                                       @trace_id ?
-                                          Execution::Trace.new(@trace_id, @client) :
+                                          Execution::Trace.new(@trace_id, @client, @options.load_balancing_policy) :
                                           nil)
       end
 

data/lib/cassandra/table.rb

@@ -38,6 +38,10 @@ module Cassandra
       @clustering_order = clustering_order.freeze
       @indexes = []
       @indexes_hash = {}
+      @materialized_views = []
+      @materialized_views_hash = {}
+      @triggers = []
+      @triggers_hash = {}
     end
 
     # @param name [String] index name
@@ -68,6 +72,62 @@ module Cassandra
     end
     alias indexes each_index
 
+    # @param name [String] trigger name
+    # @return [Boolean] whether this table has a given trigger
+    def has_trigger?(name)
+      @triggers_hash.key?(name)
+    end
+
+    # @param name [String] trigger name
+    # @return [Cassandra::Trigger, nil] a trigger or nil
+    def trigger(name)
+      @triggers_hash[name]
+    end
+
+    # Yield or enumerate each trigger bound to this table
+    # @overload each_trigger
+    #   @yieldparam trigger [Cassandra::Index] current trigger
+    #   @return [Cassandra::Table] self
+    # @overload each_trigger
+    #   @return [Array<Cassandra::Trigger>] a list of triggers
+    def each_trigger(&block)
+      if block_given?
+        @triggers.each(&block)
+        self
+      else
+        @triggers.freeze
+      end
+    end
+    alias triggers each_trigger
+
+    # @param name [String] materialized view name
+    # @return [Boolean] whether this table has a given materialized view
+    def has_materialized_view?(name)
+      @materialized_views_hash.key?(name)
+    end
+
+    # @param name [String] materialized view name
+    # @return [Cassandra::MaterializedView, nil] a materialized view or nil
+    def materialized_view(name)
+      @materialized_views_hash[name]
+    end
+
+    # Yield or enumerate each materialized view bound to this table
+    # @overload each_materialized_view
+    #   @yieldparam materialized_view [Cassandra::MaterializedView] current materialized view
+    #   @return [Cassandra::Table] self
+    # @overload each_materialized_view
+    #   @return [Array<Cassandra::MaterializedView>] a list of materialized views
+    def each_materialized_view(&block)
+      if block_given?
+        @materialized_views.each(&block)
+        self
+      else
+        @materialized_views.freeze
+      end
+    end
+    alias materialized_views each_materialized_view
+
     # @return [String] a cql representation of this table
     def to_cql
       cql = "CREATE TABLE #{Util.escape_name(@keyspace.name)}.#{Util.escape_name(@name)} (\n"
@@ -134,6 +194,18 @@ module Cassandra
       @indexes_hash[index.name] = index
     end
 
+    # @private
+    def add_view(view)
+      @materialized_views << view
+      @materialized_views_hash[view.name] = view
+    end
+
+    # @private
+    def add_trigger(trigger)
+      @triggers << trigger
+      @triggers_hash[trigger.name] = trigger
+    end
+
     # @private
     def eql?(other)
       other.is_a?(Table) &&

data/lib/cassandra/trigger.rb

@@ -0,0 +1,67 @@
+# 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.
+#++
+
+module Cassandra
+  # Represents a trigger on a cassandra table
+  class Trigger
+    # @return [Cassandra::Table] table that the trigger applies to.
+    attr_reader :table
+    # @return [String] name of the trigger.
+    attr_reader :name
+    # @return [Hash] options of the trigger.
+    attr_reader :options
+
+    # @private
+    def initialize(table,
+                   name,
+                   options)
+      @table = table
+      @name = name.freeze
+      @options = options.freeze
+    end
+
+    # @return [String] name of the trigger class
+    def custom_class_name
+      @options['class']
+    end
+
+    # @return [String] a cql representation of this trigger
+    def to_cql
+      keyspace_name = Util.escape_name(@table.keyspace.name)
+      table_name = Util.escape_name(@table.name)
+      trigger_name = Util.escape_name(@name)
+
+      "CREATE TRIGGER #{trigger_name} ON #{keyspace_name}.#{table_name} USING '#{@options['class']}';"
+    end
+
+    # @private
+    def eql?(other)
+      other.is_a?(Trigger) &&
+        @table == other.table &&
+        @name == other.name &&
+        @options == other.options
+    end
+    alias == eql?
+
+    # @private
+    def inspect
+      "#<#{self.class.name}:0x#{object_id.to_s(16)} " \
+          "@name=#{@name.inspect} @table=#{@table.inspect} @options=#{@options.inspect}>"
+    end
+  end
+end

data/lib/cassandra/types.rb

@@ -1518,8 +1518,7 @@ module Cassandra
     # @return [Cassandra::Types::List] list type
     def list(value_type)
       Util.assert_instance_of(Cassandra::Type, value_type,
-                              "list type must be a Cassandra::Type, #{value_type.inspect} given"
-                             )
+                              "list type must be a Cassandra::Type, #{value_type.inspect} given")
 
       List.new(value_type)
     end
@@ -1529,11 +1528,9 @@ module Cassandra
     # @return [Cassandra::Types::Map] map type
     def map(key_type, value_type)
       Util.assert_instance_of(Cassandra::Type, key_type,
-                              "map key type must be a Cassandra::Type, #{key_type.inspect} given"
-                             )
+                              "map key type must be a Cassandra::Type, #{key_type.inspect} given")
       Util.assert_instance_of(Cassandra::Type, value_type,
-                              "map value type must be a Cassandra::Type, #{value_type.inspect} given"
-                             )
+                              "map value type must be a Cassandra::Type, #{value_type.inspect} given")
 
       Map.new(key_type, value_type)
     end
@@ -1542,8 +1539,7 @@ module Cassandra
     # @return [Cassandra::Types::Set] set type
     def set(value_type)
       Util.assert_instance_of(Cassandra::Type, value_type,
-                              "set type must be a Cassandra::Type, #{value_type.inspect} given"
-                             )
+                              "set type must be a Cassandra::Type, #{value_type.inspect} given")
 
       Set.new(value_type)
     end
@@ -1555,8 +1551,7 @@ module Cassandra
       members.each do |member|
         Util.assert_instance_of(Cassandra::Type, member,
                                 'each tuple member must be a Cassandra::Type, ' \
-                                            "#{member.inspect} given"
-                               )
+                                            "#{member.inspect} given")
       end
 
       Tuple.new(*members)
@@ -1598,40 +1593,33 @@ module Cassandra
       fields = Array(fields.first) if fields.one?
 
       Util.assert_not_empty(fields,
-                            'user-defined type must contain at least one field'
-                           )
+                            'user-defined type must contain at least one field')
 
       if fields.first.is_a?(::Array)
         fields = fields.map do |pair|
           Util.assert(pair.size == 2,
                       'fields of a user-defined type must be an Array of name and ' \
-                                  "value pairs, #{pair.inspect} given"
-                     )
+                                  "value pairs, #{pair.inspect} given")
           Util.assert_instance_of(::String, pair[0],
                                   'each field name for a user-defined type must be a String, ' \
-                                              "#{pair[0].inspect} given"
-                                 )
+                                              "#{pair[0].inspect} given")
           Util.assert_instance_of(Cassandra::Type, pair[1],
                                   'each field type for a user-defined type must be a ' \
-                                              "Cassandra::Type, #{pair[1].inspect} given"
-                                 )
+                                              "Cassandra::Type, #{pair[1].inspect} given")
 
           UserDefined::Field.new(*pair)
         end
       else
         Util.assert(fields.size.even?,
                     'fields of a user-defined type must be an Array of alternating ' \
-                                "names and values pairs, #{fields.inspect} given"
-                   )
+                                "names and values pairs, #{fields.inspect} given")
         fields = fields.each_slice(2).map do |field_name, field_type|
           Util.assert_instance_of(::String, field_name,
                                   'each field name for a user-defined type must be a String, ' \
-                                              "#{field_name.inspect} given"
-                                 )
+                                              "#{field_name.inspect} given")
           Util.assert_instance_of(Cassandra::Type, field_type,
                                   'each field type for a user-defined type must be a ' \
-                                              "Cassandra::Type, #{field_type.inspect} given"
-                                 )
+                                              "Cassandra::Type, #{field_type.inspect} given")
 
           UserDefined::Field.new(field_name, field_type)
         end

data/lib/cassandra/udt.rb

@@ -224,15 +224,13 @@ module Cassandra
       values = Array(values.first) if values.one?
 
       Util.assert_not_empty(values,
-                            'user-defined type must contain at least one value'
-                           )
+                            'user-defined type must contain at least one value')
 
       if values.first.is_a?(::Array)
         @values = values.map do |pair|
           Util.assert(pair.size == 2,
                       'values of a user-defined type must be an Array of name and ' \
-                      "value pairs, #{pair.inspect} given"
-                     )
+                      "value pairs, #{pair.inspect} given")
           name, value = pair
 
           [String(name), value]
@@ -240,8 +238,7 @@ module Cassandra
       else
         Util.assert(values.size.even?,
                     'values of a user-defined type must be an Array of alternating ' \
-                    "names and values pairs, #{values.inspect} given"
-                   )
+                    "names and values pairs, #{values.inspect} given")
         @values = values.each_slice(2).map do |(name, value)|
           [String(name), value]
         end