dse-driver 1.0.1 → 2.0.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    M2YwYzhhNTk0YzgxZTFkMzg2NGQyZWI0MDkyYmIxZTg4OWQ3OGZhZA==
+    OWQ3OTgyN2JlZWI5MWZkZmU3YWU5ZmY5MmI1ZWJjMjlkY2RmN2FiMw==
   data.tar.gz: !binary |-
-    YTQ2NWY1NDJjMTRiY2U5OGVhNWVjNTYxYTc3YjAxOTM3NmEyMDA3ZQ==
+    YWUzMjJkMWIwZjI5N2RlOGJiYjI5M2QzOTEwMTJlNmIyM2M5YjcxYg==
 SHA512:
   metadata.gz: !binary |-
-    NGEyZTY1NmMxMThiZTY0YjJlZmQxMzE2MmUxY2ZkODUwNGUyOWVmZjZkNTIw
-    NjQ3OWI3NDJiMjJhMTM3ODkxOGEzMGZhNmRjYjdhMzI5YjMzNWY0ZjZiZTFj
-    ZjcyNzlkMTU0YjIyNDRmODQ2Yjk3ODU3ODc3Yzk1NDdkY2ZmNzk=
+    ODViODg2OTU5ZDQ2ZmYzODJhYzZhNWM2ODNmNTllNTk3YmM3ODJhYWIzZmRj
+    YTE0ZjRhYzRlNTc4ZTBiNmQ2ZjRkYzVlYmNhMTA4YTgyOGMzNDhmYTdmZWFh
+    ODNjYTY4ZmQwYTM2NGVhMzY2ODY3MjU1MmNhZDcxOWRlNDg1ZjA=
   data.tar.gz: !binary |-
-    OGU0MTJkOTNmMzQ0YzgzNGNlNWMwMjQ1MDllNzhkNTcxYWQ5NTFhZTc4NTc2
-    NTc4NTljNDczNzQyOThlNDk5NTc3NjcwNzAwYmI0MjUyMjc1YTkyNjFmM2M5
-    YTVmZTZjZGMzMGU5ZTY2NzcwNzVmY2JhYWQ0ZGRhZTQ0YzRmODM=
+    MDM2ZTQyNTkzODg2MDZhZTE5NmJjNTFlMzg0M2E1YmFmMThhYTBhMjI2Y2Iy
+    MDlmNWU5YTE0OGNkNzZhZmEwYjJmZTc4NDRjMDM5Yjk1OTMwOTRiM2E0YzBj
+    NGViN2FjZjYwY2NhYzNmOGEzM2ZhYTcwNmQ4MTc2ODMyMjk3OTg=

data/README.md

@@ -2,15 +2,14 @@
 
 *NOTE: The DataStax Enterprise Ruby Driver can be used solely with DataStax Enterprise. Please consult [the license](http://www.datastax.com/terms/datastax-dse-driver-license-terms).*
 
-This driver is built on top of the [DataStax Ruby driver for Apache Cassandra](http://docs.datastax.com/en/latest-ruby-driver/ruby-driver/whatsNew.html)
+This driver is built on top of the [DataStax Ruby driver for Apache Cassandra](http://dsdocs30)
 and enhanced for the adaptive data management and mixed workload capabilities
 provided by DSE. Therefore a lot of the underlying concepts are the same.
 
 ## Documentation
-Driver documentation can be found [here](http://docs.datastax.com/en/latest-dse-ruby-driver/ruby-driver/whatsNew.html).
+Driver documentation can be found [here](http://docs.datastax.com/en/developer/ruby-driver-dse).
 
-In particular, you'll find our [Features](http://docs.datastax.com/en/latest-dse-ruby-driver/supplemental/features) and
-[API](http://docs.datastax.com/en/latest-dse-ruby-driver/supplemental/api) sections very enlightening.
+In particular, you'll find our [Features](features) and [API](api) sections very enlightening.
 
 ## Feedback Requested
 *Help us focus our efforts!* [Provide your input](http://goo.gl/forms/pCs8PTpHLf) on the Ruby Driver
@@ -51,6 +50,72 @@ session = cluster.connect
 rs = session.execute('select * from system.local')
 ```
 
+
+## Breaking changes in 2.0
+This release adds support for [graph execution profiles](features/graph#execution-profiles). As a result, the cluster-level `graph_options` object has
+been removed. That object is effectively stored in the `:default_graph` execution profile. However, since execution
+profiles are read-only, graph options in profiles cannot be manipulated. Instead, either specify new graph
+options at query execution time, or use separate execution profiles for your different scenarios. 
+
+Furthermore, the `Dse::Graph::Options` class is no longer in the public api. Instead of constructing a
+`Dse::Graph::Options` object and passing it to `Session.execute_graph*`, you must now pass the primitive graph options
+or specify the name of an execution profile that encapsulates the desired graph options. Similarly, when creating a
+`Dse::Graph::Statement`, you must specify primitive graph options instead of a `Dse::Graph::Options` object.
+
+Since execution profiles are immutable, you must set expert options at construction time with the `expert_options`
+hash. See the [documentation](features/graph#expert-options) for more details. 
+
+Another behavior change is that in v1.x, graph query timeout defaulted to unlimited. This caused queries to fall back to
+server timeouts. The default was set this way to accommodate multi-day analytics queries and multi-second OLTP queries
+without requiring intervention / special handling from the user. The introduction of execution profiles into the driver
+enables the user to more easily run different types of queries:
+
+```ruby
+# Use the default graph profile with its OLTP-motivated timeout (30 seconds)
+rs = session.execute_graph('g.V()')
+# Use the default graph analytics profile for an OLAP query (timeout 7 days)
+rs = session.execute_graph('g.V()', execution_profile: :default_graph_analytics
+# Use the default system query profile for graph system queries (timeout 3 minutes)
+rs = session.execute_graph("system.graph('mygraph').exists()",
+                           execution_profile: :default_graph_system)
+```
+Thus, no query runs with unlimited timeout by default as of this version of the driver.
+
+Finally, in v1.x, graph query timeout was specified via the `:timeout` option in calls to `Session.execute_graph*` or
+packaged up in a graph options object. Since the graph execution profile now assumes the role of graph options, use
+the `:timeout` attribute in the graph execution profile to specify graph timeout. In particular, to set the default
+graph timeout for graph queries, you must define your own `:default_graph` execution profile that will take precedence
+over one that would normally be generated by the driver:
+
+```ruby
+cluster = Dse.cluster(execution_profiles: {
+    default_graph: Dse::Graph::ExecutionProfile.new(timeout: 17, graph_name: 'mygraph')
+})
+```
+
+In the example above, the default graph timeout is set to 17 seconds. Note that you are not permitted to mix
+primitive options (that are now available in execution profiles) with an execution_profiles hash when creating
+the cluster object:
+
+```ruby
+# Illegal!
+cluster = Dse.cluster(execution_profiles: {
+    default_graph: Dse::Graph::ExecutionProfile.new(timeout: 17, graph_name: 'mygraph')
+}, timeout: 7)
+
+```
+
+Thus, in order to specify that non-graph queries should execute with a timeout of 7 seconds by default, you must
+override the Cassandra default execution profile, named `:default`:
+
+```ruby
+# Legal.
+cluster = Dse.cluster(execution_profiles: {
+    default_graph: Dse::Graph::ExecutionProfile.new(timeout: 17, graph_name: 'mygraph'),
+    default: Cassandra::Execution::Profile.new(timeout: 7)
+})
+```
+
 ## Determining driver versions
 Within a script or irb, you can determine the exact versions of the dse and core drivers by accessing the VERSION
 constant of the appropriate module:
@@ -69,4 +134,4 @@ previous versions of DSE.
 ## License
 Copyright (C) 2016 DataStax Inc.
 
-The full license terms are available at http://www.datastax.com/terms/datastax-dse-driver-license-terms
+The full license terms are available at http://www.datastax.com/terms/datastax-dse-driver-license-terms

data/lib/dse.rb

@@ -22,8 +22,6 @@ module Dse
   # The API is identical, except that it returns a {Dse::Session Dse::Session} (see below). It takes all of the same
   # options as Cassandra.cluster and the following extra options.
   #
-  # @option options [Dse::Graph::Options] :graph_options options for the DSE graph statement handler. Takes
-  #    priority over other `:graph_*` options specified below.
   # @option options [String] :graph_name name of graph to use in graph statements
   # @option options [String] :graph_source graph traversal source
   # @option options [String] :graph_language language used in graph queries
@@ -54,16 +52,20 @@ module Dse
   # @return [Cassandra::Future<Dse::Cluster>] a future resolving to the
   #   cluster instance.
   def self.cluster_async(options = {})
-    graph_options = if !options[:graph_options].nil?
-                      Cassandra::Util.assert_instance_of(Dse::Graph::Options, options[:graph_options])
-                      options[:graph_options]
-                    else
-                      Dse::Graph::Options.new(options)
-                    end
+    if options.key?(:execution_profiles)
+      [:graph_name, :graph_source, :graph_language, :graph_read_consistency, :graph_write_consistency].each do |opt|
+        raise ::ArgumentError, "#{opt} is not allowed when execution profiles are used" if options.key?(opt)
+      end
+    end
+
     username = options[:username]
     password = options[:password]
     options[:custom_types] ||= []
     options[:custom_types] << Dse::Geometry::Point << Dse::Geometry::LineString << Dse::Geometry::Polygon
+
+    # validate_and_massage will return a new options hash, with non-C* options removed. Hold onto the original hash
+    # for attributes we still need later.
+    full_options = options
     options, hosts = Cassandra.validate_and_massage_options(options)
 
     # Use the DSE plain text authenticator if we have a username and password. The above validation already
@@ -75,18 +77,45 @@ module Dse
   else
     options[:cluster_klass] = Dse::Cluster
     driver = ::Cassandra::Driver.new(options)
+    system_defaults = ::Cassandra::Driver.new
+    profile_manager = driver.profile_manager
+    unless profile_manager.profiles.key?(:default_graph)
+      # full_options has the graph options. But we don't want to use other attributes like load_balancing_policy, etc.
+      # in defining our default graph profile. So make a new hash that explicitly sets core profile attributes to
+      # system defaults.
+      graph_profile = Dse::Graph::ExecutionProfile.new(
+          full_options.merge(timeout: 30,
+                             load_balancing_policy: system_defaults.load_balancing_policy,
+                             retry_policy: system_defaults.retry_policy,
+                             consistency: system_defaults.consistency
+          ))
+      profile_manager.add_profile(:default_graph, graph_profile)
+    end
+    unless profile_manager.profiles.key?(:default_graph_system)
+      graph_profile = Dse::Graph::ExecutionProfile.new(graph_read_consistency: full_options[:graph_read_consistency],
+                                                       graph_write_consistency: full_options[:graph_write_consistency],
+                                                       timeout: 180)
+      profile_manager.add_profile(:default_graph_system, graph_profile)
+    end
+    unless profile_manager.profiles.key?(:default_graph_analytics)
+      # Wrap the system default load-balancing policy that we'd otherwise run, with a host-targeting policy, for the
+      # analytics profile.
 
-    # Wrap the load-balancing policy that we'd otherwise run with, with a host-targeting policy.
-    # We do this before driver.connect because driver.connect saves off the policy in the cluster
-    # registry and does a few other things.
-
-    lbp = driver.load_balancing_policy
-    driver.load_balancing_policy = Dse::LoadBalancing::Policies::HostTargeting.new(lbp)
-    future = driver.connect(hosts)
-    future.then do |cluster|
-      cluster.graph_options.merge!(graph_options)
-      cluster
+      # We do this before driver.connect because driver.connect saves off the policy in the cluster
+      # registry and does a few other things.
+      graph_profile = Dse::Graph::ExecutionProfile.new(
+        graph_source: 'a',
+        graph_name: full_options[:graph_name],
+        graph_read_consistency: full_options[:graph_read_consistency],
+        graph_write_consistency: full_options[:graph_write_consistency],
+        load_balancing_policy: Dse::LoadBalancing::Policies::HostTargeting.new(
+            system_defaults.load_balancing_policy
+        ),
+        timeout: (3600 * 24 * 7)
+      )
+      profile_manager.add_profile(:default_graph_analytics, graph_profile)
     end
+    driver.connect(hosts)
   end
 end
 

data/lib/dse/cluster.rb

@@ -11,9 +11,6 @@ module Dse
   # Cluster represents a DSE cluster. It serves as a {Dse::Session session factory} and a collection of metadata.
   # It wraps a {http://dsdocs30/api/cassandra/cluster Cassandra::Cluster} and exposes all of its functionality.
   class Cluster
-    # @return [Dse::Graph::Options] default graph options used by queries on this cluster.
-    attr_reader :graph_options
-
     # @private
     def initialize(logger,
                    io_reactor,
@@ -24,9 +21,8 @@ module Dse
                    cluster_metadata,
                    execution_options,
                    connection_options,
-                   load_balancing_policy,
+                   profile_manager,
                    reconnection_policy,
-                   retry_policy,
                    address_resolution_policy,
                    connector,
                    futures_factory,
@@ -40,21 +36,21 @@ module Dse
                                                  cluster_metadata,
                                                  execution_options,
                                                  connection_options,
-                                                 load_balancing_policy,
+                                                 profile_manager,
                                                  reconnection_policy,
-                                                 retry_policy,
                                                  address_resolution_policy,
                                                  connector,
                                                  futures_factory,
                                                  timestamp_generator)
-      @graph_options = Dse::Graph::Options.new
-
       # We need the futures factory ourselves for async error reporting and potentially for our
       # own async processing independent of the C* driver.
       @futures = futures_factory
+
+      # Similarly for profile-manager
+      @profile_manager = profile_manager
     end
 
-    # Delegates to {http://docs.datastax.com/en/developer/ruby-driver/3.0/supplemental/api/cassandra/cluster/?local=true&nav=toc#connect_async-instance_method
+    # Delegates to {http://dsdocs30/api/cassandra/cluster/?local=true&nav=toc#connect_async-instance_method
     # Cassandra::Cluster#connect_async}
     # to connect asynchronously to a cluster, but returns a future that will resolve to a DSE session rather than
     # Cassandra session.
@@ -66,7 +62,7 @@ module Dse
       future = @delegate_cluster.connect_async(keyspace)
       # We want to actually return a DSE session upon successful connection.
       future.then do |cassandra_session|
-        Dse::Session.new(cassandra_session, @graph_options, @futures)
+        Dse::Session.new(cassandra_session, @profile_manager, @futures)
       end
     end
 
@@ -79,6 +75,12 @@ module Dse
       connect_async(keyspace).get
     end
 
+    # @private
+    def inspect
+      "#<#{self.class.name}:0x#{object_id.to_s(16)} " \
+      "@delegate_cluster=#{@delegate_cluster.inspect}>"
+    end
+
     #### The following methods handle arbitrary delegation to the underlying cluster object. ####
     protected
 

data/lib/dse/graph.rb

@@ -8,6 +8,7 @@
 #++
 
 require 'dse/graph/edge'
+require 'dse/graph/execution_profile'
 require 'dse/graph/options'
 require 'dse/graph/path'
 require 'dse/graph/result'

data/lib/dse/graph/execution_profile.rb

@@ -0,0 +1,88 @@
+# encoding: utf-8
+
+#--
+#      Copyright (C) 2016 DataStax Inc.
+#
+#      This software can be used solely with DataStax Enterprise. Please consult the license at
+#      http://www.datastax.com/terms/datastax-dse-driver-license-terms
+#++
+
+module Dse
+  module Graph
+    # @!parse
+    #   # Execution profile class that adds graph option support
+    #   class ExecutionProfile < ::Cassandra::Execution::Profile
+    #     # @return [String] name of the targeted graph; required unless the statement is a system query.
+    #     attr_accessor :graph_name
+    #     # @return [String] graph traversal source (default "g")
+    #     attr_accessor :graph_source
+    #     # @return [String] language used in the graph statement (default "gremlin-groovy")
+    #     attr_accessor :graph_language
+    #     # @return [Cassandra::CONSISTENCIES] read consistency level for graph statement.
+    #     #   Overrides the standard statement consistency level. Defaults to ONE in the server,
+    #     #   but the default may be configured differently.
+    #     attr_accessor :graph_read_consistency
+    #     # @return [Cassandra::CONSISTENCIES] write consistency level for graph statement.
+    #     #   Overrides the standard statement consistency level. Defaults to QUORUM in the server,
+    #     #   but the default may be configured differently.
+    #     attr_accessor :graph_write_consistency
+    #   end
+
+
+    class ExecutionProfile < ::Cassandra::Execution::Profile
+      extend Forwardable
+
+      # @private
+      attr_reader :graph_options
+
+      def_delegators :@graph_options, :graph_name, :graph_source, :graph_language, :graph_read_consistency,
+                     :graph_write_consistency
+
+      # Creates a {ExecutionProfile} instance, which extends
+      # {http://dsdocs/api/cassandra/execution/profile Cassandra::Execution::Profile}.
+      # It takes all of the same options as the Cassandra::Execution::Profile constructor and
+      # the following extra options.
+      #
+      # @option options [String] :graph_name name of graph to use in graph statements
+      # @option options [String] :graph_source graph traversal source
+      # @option options [String] :graph_language language used in graph queries
+      # @option options [Cassandra::CONSISTENCIES] :graph_read_consistency read consistency level for graph statements.
+      #    Overrides the standard statement consistency level
+      # @option options [Cassandra::CONSISTENCIES] :graph_write_consistency write consistency level for
+      #    graph statements. Overrides the standard statement consistency level
+      def initialize(options = {})
+        options[:timeout] = 30 unless options[:timeout]
+        super(options)
+        @graph_options = Dse::Graph::Options.new(options)
+      end
+
+      # @private
+      def eql?(other)
+        other.is_a?(ExecutionProfile) && \
+          super(other) && \
+          @graph_options == other.graph_options
+      end
+      alias == eql?
+
+      # @private
+      def hash
+        @hash ||= begin
+          h = super.hash
+          h = 31 * h + @graph_options.hash
+          h
+        end
+      end
+
+      # @private
+      def inspect
+        "#<Dse::Graph::ExecutionProfile:0x#{object_id.to_s(16)} " \
+          "super=#{super.inspect}, " \
+        "@graph_name=#{@graph_options.graph_name.inspect}, " \
+        "@graph_source=#{@graph_options.graph_source.inspect}, " \
+        "@graph_language=#{@graph_options.graph_language.inspect}, " \
+        "@graph_read_consistency=#{@graph_options.graph_read_consistency.inspect}, " \
+        "@graph_write_consistency=#{@graph_options.graph_write_consistency.inspect}>"
+      end
+    end
+  end
+end

data/lib/dse/graph/options.rb

@@ -9,29 +9,8 @@
 
 module Dse
   module Graph
-    # @!parse
-    #   class Options
-    #     # @return [String] name of the targeted graph; required unless the statement is a system query.
-    #     attr_accessor :graph_name
-    #     # @return [String] graph traversal source (default "g")
-    #     attr_accessor :graph_source
-    #     # @return [String] language used in the graph statement (default "gremlin-groovy")
-    #     attr_accessor :graph_language
-    #     # @return [Cassandra::CONSISTENCIES] read consistency level for graph statement.
-    #     #   Overrides the standard statement consistency level. Defaults to ONE in the server,
-    #     #   but the default may be configured differently.
-    #     attr_accessor :graph_read_consistency
-    #     # @return [Cassandra::CONSISTENCIES] write consistency level for graph statement.
-    #     #   Overrides the standard statement consistency level. Defaults to QUORUM in the server,
-    #     #   but the default may be configured differently.
-    #     attr_accessor :graph_write_consistency
-    #   end
-
-    # Options for DSE Graph queries
+    # @private Options for DSE Graph queries
     class Options
-      # @return [Numeric] the timeout for graph requests
-      attr_reader :timeout
-
       # @private
       DEFAULT_GRAPH_OPTIONS = {
         'graph-source' => 'g',
@@ -59,64 +38,40 @@ module Dse
           set(k, v) if OPTION_NAMES.include?(k)
         end
 
-        set_timeout(options[:timeout])
+        # Set expert options, if available.
+        if options.key?(:expert_options)
+          options[:expert_options].each do |k, v|
+            set(k, v)
+          end
+        end
       end
 
       OPTION_NAMES.each do |attr|
         define_method(attr.to_s) do
           @real_options[stringify(attr)]
         end
-
-        define_method("#{attr}=") do |value|
-          @real_options[stringify(attr)] = value
-        end
       end
 
       # @private
-      def timeout=(val)
-        set_timeout(val)
-        val
+      def eql?(other)
+        other.is_a?(Options) && \
+          @real_options == other.instance_variable_get(:@real_options)
       end
+      alias == eql?
 
       # @private
-      # rubocop:disable Style/AccessorMethodName
-      def set_timeout(new_timeout)
-        @timeout = new_timeout
-        if @timeout
-          @real_options['request-timeout'] = [@timeout * 1000].pack('Q>')
-        else
-          @real_options.delete('request-timeout')
-        end
-        nil
-      end
-
-      # Set an option in this {Options} object. This is primarily used to set "expert" options that
-      # are not part of the public api and thus may change over time.
-      # @param key [String, Symbol] option to set.
-      # @param value [String] value to set for the option.
-      # @return [Options] self, thus allowing method chaining.
-      def set(key, value)
-        string_key = stringify(key)
-        if string_key == 'timeout'
-          set_timeout(value)
-        elsif value
-          @real_options[stringify(key)] = value
-        end
-        self
+      def hash
+        @hash ||= 31 * 17 + @real_options.hash
       end
 
-      # Delete an option from this {Options} object.
-      # @param key [String, Symbol] option to delete.
-      # @return nil
-      def delete(key)
-        string_key = stringify(key)
-        if string_key == 'timeout'
-          @timeout = nil
-          @real_options.delete('request-timeout')
-        else
-          @real_options.delete(string_key)
-        end
-        nil
+      # @private
+      def inspect
+        "#<Dse::Graph::Options:0x#{object_id.to_s(16)} " \
+        "@graph_name=#{@real_options['graph-name'].inspect}, " \
+        "@graph_source=#{@real_options['graph-source'].inspect}, " \
+        "@graph_language=#{@real_options['graph-language'].inspect}, " \
+        "@graph_read_consistency=#{@real_options['graph-read-consistency'].inspect}, " \
+        "@graph_write_consistency=#{@real_options['graph-write-consistency'].inspect}>"
       end
 
       # Merge another {Options} object with this one to produce a new merged {Options} object.
@@ -131,63 +86,38 @@ module Dse
         result = Options.new
         result.instance_variable_set(:@real_options,
                                      @real_options.merge(other.instance_variable_get(:@real_options)))
-        other_timeout = other.instance_variable_get(:@timeout)
-        result.instance_variable_set(:@timeout,
-                                     other_timeout ? other_timeout : @timeout)
         result
       end
 
-      # Clear the options within this {Options} object.
-      def clear
-        @real_options.clear
-        @timeout = nil
-      end
-
       # @private
       def stringify(attr)
         attr.to_s.tr('_', '-')
       end
 
-      # @private
-      def merge!(other)
-        result = merge(other)
-        @real_options = result.instance_variable_get(:@real_options)
-        @timeout = result.instance_variable_get(:@timeout)
-        self
-      end
-
       # @return whether or not this options object is configured for the analytics graph source.
       def analytics?
         @real_options['graph-source'] == 'a'
       end
 
       # @private
-      def as_payload
+      def as_payload(timeout = nil)
         # Merge in real options with defaults to get a final payload
-        DEFAULT_GRAPH_OPTIONS.merge(@real_options)
-      end
-
-      # @private
-      def eql?(other)
-        other.is_a?(Options) && \
-          @real_options == other.instance_variable_get(:@real_options)
+        result = DEFAULT_GRAPH_OPTIONS.merge(@real_options)
+        result['request-timeout'] = [timeout * 1000].pack('Q>') unless timeout.nil?
+        result
       end
-      alias == eql?
 
-      # @private
-      def hash
-        @hash ||= 31 * 17 + @real_options.hash
-      end
+      private
 
-      # @private
-      def inspect
-        "#<Dse::Graph::Options:0x#{object_id.to_s(16)} " \
-        "@graph_name=#{@real_options['graph-name'].inspect}, " \
-        "@graph_source=#{@real_options['graph-source'].inspect}, " \
-        "@graph_language=#{@real_options['graph-language'].inspect}, " \
-        "@graph_read_consistency=#{@real_options['graph-read-consistency'].inspect}, " \
-        "@graph_write_consistency=#{@real_options['graph-write-consistency'].inspect}, " \
-        "@timeout=#{@timeout.inspect}>"
+      # Set an option in this {Options} object. This is primarily used to set "expert" options that
+      # are not part of the public api and thus may change over time.
+      # @param key [String, Symbol] option to set.
+      # @param value [String] value to set for the option.
+      # @return [Options] self, thus allowing method chaining.
+      def set(key, value)
+        raise "can't modify frozen Dse::Graph::Options" if frozen?
+        @real_options[stringify(key)] = value if value
+        self
       end
     end
   end

data/lib/dse/graph/statement.rb

@@ -13,19 +13,40 @@ module Dse
     # re-issuing the same statement multiple times the same way.
     class Statement
       include Cassandra::Statement
+      extend Forwardable
+
+      # @!method graph_name
+      #   @return [String] name of the targeted graph; required unless the statement is a system query.
+      #
+      # @!method graph_source
+      #   @return [String] graph traversal source (default "g")
+      #
+      # @!method graph_language
+      #   @return [String] language used in the graph statement (default "gremlin-groovy")
+      #
+      # @!method graph_read_consistency
+      #   @return [Cassandra::CONSISTENCIES] read consistency level for graph statement.
+      #     Overrides the standard statement consistency level. Defaults to ONE in the server,
+      #     but the default may be configured differently.
+      # @!method graph_write_consistency
+      #   @return [Cassandra::CONSISTENCIES] write consistency level for graph statement.
+      #     Overrides the standard statement consistency level. Defaults to QUORUM in the server,
+      #     but the default may be configured differently.
+      def_delegators :@options, :graph_name, :graph_source, :graph_language, :graph_read_consistency,
+                     :graph_write_consistency
 
       # @return [String] graph statement string
       attr_reader :statement
       # @return [Hash<String, String>] parameters to the statement
       attr_reader :parameters
-      # @return [Options] graph options
+      # @private
       attr_reader :options
       # @private
       attr_reader :simple_statement
 
       # @param statement [String] graph statement
       # @param parameters [Hash<String, String>] (nil) parameters to the statement
-      # @param options [Hash, Options] (nil) graph options
+      # @param options [Hash] (nil) graph options
       # @param idempotent [Boolean] (false) whether or not the statement is idempotent
       def initialize(statement, parameters = nil, options = nil, idempotent = false)
         # Save off statement and idempotent; easy stuff.
@@ -46,22 +67,10 @@ module Dse
           parameters = [tweaked_params.to_json]
         end
 
-        # Graph options may be tricky. A few cases:
-        # 1. options is nil; then @options should be nil.
-        # 2. options is a Hash with a graph_options key; then @options is the referenced Options object.
-        #    We must validate that the referenced object *is* an Options.
-        # 3. options is an Options object; then just assign to @options.
-
-        unless options.nil?
-          Cassandra::Util.assert_instance_of_one_of([Dse::Graph::Options, ::Hash], options)
-          @options = if options.is_a?(Options)
-                       options
-                     elsif !options[:graph_options].nil?
-                       Cassandra::Util.assert_instance_of(Dse::Graph::Options, options[:graph_options])
-                       options[:graph_options]
-                     else
-                       Dse::Graph::Options.new(options)
-                     end
+        # Create a Graph::Options object only if we have non-nil options.
+        unless options.nil? || options.empty?
+          Cassandra::Util.assert_instance_of(::Hash, options)
+          @options = Dse::Graph::Options.new(options)
         end
 
         @simple_statement = Cassandra::Statements::Simple.new(@statement,

data/lib/dse/session.rb

@@ -16,9 +16,9 @@ module Dse
   # @see http://dsdocs30/api/cassandra/session Cassandra::Session
   class Session
     # @private
-    def initialize(cassandra_session, graph_options, futures_factory)
+    def initialize(cassandra_session, profile_manager, futures_factory)
       @cassandra_session = cassandra_session
-      @graph_options = graph_options
+      @profile_manager = profile_manager
       @futures = futures_factory
     end
 
@@ -28,8 +28,6 @@ module Dse
     #   {Cassandra::Session#execute_async} are valid here. However, there are some extras, noted below.
     # @option options [Hash] :arguments Parameters for the graph statement.
     #    NOTE: Unlike {#execute} and {#execute_async}, this must be a hash of <parameter-name,value>.
-    # @option options [Dse::Graph::Options] :graph_options options for the DSE graph statement handler. Takes
-    #    priority over other `:graph_*` options specified below.
     # @option options [String] :graph_name name of graph to use in graph statements
     # @option options [String] :graph_source graph traversal source
     # @option options [String] :graph_language language used in graph queries
@@ -37,6 +35,8 @@ module Dse
     #    Overrides the standard statement consistency level
     # @option options [Cassandra::CONSISTENCIES] :graph_write_consistency write consistency level for graph statements.
     #    Overrides the standard statement consistency level
+    # @option options [String, Symbol] :execution_profile (:default_graph) name of {Dse::Graph::ExecutionProfile}
+    #   from which to obtain certain query options.
     # @return [Cassandra::Future<Cassandra::Result>]
     # @see http://dsdocs30/api/cassandra/session#execute_async-instance_method
     #   Cassandra::Session::execute_async for all of the core options.
@@ -45,15 +45,28 @@ module Dse
       # about to do some destructive mutations.
 
       options = options.dup
+
       Cassandra::Util.assert_instance_of_one_of([String, Dse::Graph::Statement], graph_statement)
+      arguments = nil
+      if options
+        Cassandra::Util.assert_instance_of(::Hash, options)
+        arguments = options.delete(:arguments)
+      end
 
       if graph_statement.is_a?(String)
-        graph_statement = Dse::Graph::Statement.new(graph_statement, options[:arguments], options, options[:idempotent])
+        graph_statement = Dse::Graph::Statement.new(graph_statement, arguments, options, options[:idempotent])
       end
 
-      graph_options = @graph_options.merge(graph_statement.options)
-      options[:payload] = graph_options.as_payload
-      options[:timeout] = graph_options.timeout
+      options[:execution_profile] ||= :default_graph
+      profile = @profile_manager.profiles[options[:execution_profile]]
+      Cassandra::Util.assert(!profile.nil?, "Profile '#{options[:execution_profile]}' does not exist")
+      Cassandra::Util.assert_instance_of(Dse::Graph::ExecutionProfile, profile)
+
+      graph_options = profile.graph_options.merge(graph_statement.options)
+
+      # The custom payload should have a 'request-timeout' that is the value of the :timeout option, if specified.
+      # Otherwise, fall back to the timeout in the execution profile.
+      options[:payload] = graph_options.as_payload(options[:timeout] || profile.timeout)
 
       if graph_options.analytics?
         @cassandra_session.execute_async('CALL DseClientTool.getAnalyticsGraphServer()').then do |rows|

data/lib/dse/version.rb

@@ -8,5 +8,5 @@
 #++
 
 module Dse
-  VERSION = '1.0.1'.freeze
+  VERSION = '2.0.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dse-driver
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Sandeep Tamhankar
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-02 00:00:00.000000000 Z
+date: 2016-11-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cassandra-driver
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.0.3
+        version: 3.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.0.3
+        version: 3.1.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -77,6 +77,7 @@ files:
 - lib/dse/graph.rb
 - lib/dse/graph/duration.rb
 - lib/dse/graph/edge.rb
+- lib/dse/graph/execution_profile.rb
 - lib/dse/graph/options.rb
 - lib/dse/graph/path.rb
 - lib/dse/graph/result.rb