olaf 0.1.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 38457075dee68f9c3e32b378eee876418db09bee36922f8fca9e4f56ee4cc942
-  data.tar.gz: c7dc384252160cdb65f5f0405cd575025a103924d65492df00baba336f40bce9
+  metadata.gz: 4d1640a5221b0ed5a71b4fbb2ca11d113d69ef7436e7b7c2628497c4767a4245
+  data.tar.gz: fd816660fe86290c5f5d8148a11823b2c2580e66096817d343b958fcbb1fc30e
 SHA512:
-  metadata.gz: 143444dd698a5780ce2524c65e3f6bcc068a6c2adcb6901369f8427f761f72a817e0601d75a59cfcc887507e842a73a69193c716f8d1369f9a0f296cee4635d3
-  data.tar.gz: 1e13774b2cd3d361ae2847adb7ece1470f304cbc23141e2a57b098baf06677a025ce4e63afafdd99a744d5c8cf464939bb140ae2b813cf1da40f77bb4176ab85
+  metadata.gz: b1f71e253ff7cb95a7eef3d97324f6615d43c57aaa39e9128fcdce5f8ef683ed2a742d852aff034adf3cbd8fd04ddfa2d58a1c7372edea79843f0ab12581735a
+  data.tar.gz: db997081fd2f622d354cd7bcb65a73c45ef55eba1bb71d8788b08590cb02e3500cdc428da78697ff838666daac3996d6f8a83cdfd14bbd3750655e308967507c

data/README.md

@@ -1,21 +1,21 @@
 # Olaf
-[![Gem Version](https://badge.fury.io/rb/olaf.svg)](https://badge.fury.io/rb/olaf)
-[![CircleCI](https://circleci.com/gh/carwow/olaf.svg?style=shield&circle-token=:circle-ci-badge-token)](https://circleci.com/gh/carwow/olaf)
 
-
-
-Olaf is a small Ruby wrapper for Snowflake queries.
+Olaf is a small Ruby wrapper for warehouse queries, running them in Snowflake or
+in BigQuery.
 
 ![Olaf](https://user-images.githubusercontent.com/56375/96335285-8c86f080-106f-11eb-9489-999a884f1246.jpg)
 
 
 ## Dependencies
 
-`olaf` requires Ruby 2.6 or later, `sequel` and `odbc` driver to connect with DBs.
-
-Install dependencies using `bundler` is easy as run:
+`olaf` depends on nothing by itself. Each driver loads its own client library,
+and only when it is used, so add to your `Gemfile` the ones you configure:
 
-    bundle install
+| Driver            | Gems                    | Also needs              |
+| ----------------- | ----------------------- | ----------------------- |
+| `Olaf::Snowflake` | `sequel`, `ruby-odbc`   | the ODBC system library |
+| `Olaf::BigQuery`  | `google-cloud-bigquery` |                         |
+| `Olaf::Fake`      | —                       |                         |
 
 ## Installation
 
@@ -25,7 +25,7 @@ If you don't have Olaf, try this:
 
 ## Getting started
 
-Olaf helps developers to represent Snowflake queries as objects, to have more
+Olaf helps developers to represent warehouse queries as objects, to have more
 control in the code and in tests.
 
 ### Example
@@ -46,3 +46,84 @@ query = FetchUsers.prepare(department_id: 1337)
 Olaf.execute(query)
 => [#<User id: 41, department_id: 1337, name: 'Ian'>]
 ```
+
+## Configuration
+
+One driver, which every query runs on:
+
+```ruby
+Olaf.configure(user: 'olaf')             # Olaf::Snowflake, the default
+Olaf.configure(olaf_driver: Olaf::Fake)  # ideal for testing
+```
+
+Or several, which queries pick by name. The ones that don't declare a `driver`
+run on the `default:`, the first one given when it is not specified:
+
+```ruby
+Olaf.configure(
+  drivers: {
+    snowflake: Olaf::Snowflake.new(user: 'olaf'),
+    big_query: Olaf::BigQuery.new(project: 'carwow', labels: { service: 'flatmin' })
+  },
+  default: :snowflake
+)
+
+class FetchUsers
+  include Olaf::QueryDefinition
+
+  driver :big_query
+
+  template './big_query/users_in_department.sql'
+
+  argument :department_id
+end
+```
+
+`Olaf.instance(:big_query)` returns that driver. A single configured driver
+serves every query, whatever they declare, which is what keeps `Olaf::Fake`
+covering all of them in tests:
+
+```ruby
+Olaf.configure(olaf_driver: Olaf::Fake)
+
+Olaf.instance.register_result(FetchUsers, [{ id: 41 }])
+Olaf.instance.register_result(FetchUsers, [{ id: 42 }], with: { department_id: 1337 })
+```
+
+Whichever driver runs the query, a failure it reports is wrapped into
+`Olaf::QueryExecutionError`, carrying the query metadata.
+
+## BigQuery
+
+```ruby
+Olaf::BigQuery.new(
+  project: 'carwow',
+  credentials: JSON.parse(ENV['BIGQUERY_CREDENTIALS']),  # ambient Google credentials when omitted
+  maximum_bytes_billed: 5 * Olaf::BigQuery::GIGABYTE,    # default: 1 GiB
+  labels: { service: 'flatmin', country: 'uk' }
+)
+```
+
+The query runs as a job, so that it can be capped and labelled:
+
+* Olaf's `:placeholders` are rewritten to BigQuery's `@named` parameters, for
+  declared arguments only, and bound as query parameters. Arguments declared
+  `as: :literal` are substituted into the SQL before that, as usual.
+* Every job is capped with `maximum_bytes_billed`, and labelled with the driver
+  labels plus the name of the template. A query that scans more than the cap
+  raises its own, which keeps a regression failing instead of quietly costing
+  money:
+
+  ```ruby
+  driver :big_query, maximum_bytes_billed: 10 * Olaf::BigQuery::GIGABYTE
+  ```
+
+`Olaf.execute` returns the rows. `Olaf.instance(:big_query).run(query)` returns
+the finished job instead, for its statistics:
+
+```ruby
+job = Olaf.instance(:big_query).run(query)
+job.bytes_processed
+job.cache_hit?
+job.data.all.to_a
+```

data/lib/olaf/drivers/big_query.rb

@@ -0,0 +1,104 @@
+# Not a dependency of the gem: consumers of this driver add it themselves.
+require 'google/cloud/bigquery'
+
+# The API client debug-logs whole response bodies, which for a warehouse query
+# is the entire result set.
+Google::Apis.logger.level = [Google::Apis.logger.level, Logger::INFO].max
+
+module Olaf
+  class BigQuery
+    GIGABYTE = 1024**3
+
+    # Restrictive on purpose: a query that scans more says so with
+    # `driver :big_query, maximum_bytes_billed: ...`.
+    DEFAULT_MAXIMUM_BYTES_BILLED = GIGABYTE
+
+    # Labels only accept lowercase letters, numbers, dashes and underscores.
+    LABEL_FORMAT = /[^a-z0-9_-]/.freeze
+    LABEL_MAX_LENGTH = 63
+
+    # Credentials default to the ambient Google ones, and the client is built
+    # from the arguments unless one is given.
+    def initialize(project: nil, credentials: nil, maximum_bytes_billed: DEFAULT_MAXIMUM_BYTES_BILLED,
+                   labels: {}, client: nil)
+      @project = project
+      @credentials = credentials
+      @maximum_bytes_billed = maximum_bytes_billed
+      @labels = labels
+      @client = client
+    end
+
+    def fetch(olaf_query)
+      run(olaf_query).data.all.to_a
+    end
+
+    # Returns the finished job, so callers can read its stats (bytes billed,
+    # cache hit) on top of its rows.
+    #
+    #   @raises Olaf::QueryExecutionError
+    def run(olaf_query)
+      job = client.query_job(
+        sql(olaf_query),
+        params: params(olaf_query),
+        maximum_bytes_billed: maximum_bytes_billed(olaf_query),
+        labels: labels(olaf_query)
+      )
+      job.wait_until_done!
+
+      raise QueryExecutionError.new(job.error.to_h['message'].to_s, olaf_query) if job.failed?
+
+      job
+    rescue *wrapped_errors => error
+      raise QueryExecutionError.new(error.message, olaf_query)
+    end
+
+    private
+
+    def client
+      @client ||= Google::Cloud::Bigquery.new(project: @project, credentials: @credentials)
+    end
+
+    # Google::Cloud::Error covers everything the API reports, Google::Auth::Error
+    # credentials missing or expired before a call is made. The second one only
+    # exists in googleauth 1.14 and later.
+    def wrapped_errors
+      @wrapped_errors ||= [
+        Google::Cloud::Error,
+        (Google::Auth::Error if defined?(Google::Auth::Error))
+      ].compact
+    end
+
+    # olaf validates `:foo` placeholders, BigQuery binds `@foo`. Only declared
+    # argument names are rewritten, so casts and time literals are left alone.
+    def sql(olaf_query)
+      params(olaf_query).keys.reduce(olaf_query.sql_template) do |sql, name|
+        sql.gsub(/(?<!:):#{name}\b/, "@#{name}")
+      end
+    end
+
+    # Literal arguments were substituted into the template by `prepare`.
+    def params(olaf_query)
+      literal_arguments = literal_arguments(olaf_query)
+
+      olaf_query.variables.reject { |name, _value| literal_arguments.include?(name) }
+    end
+
+    def literal_arguments(olaf_query)
+      olaf_query.class.arguments.select { |_name, options| options[:literal] }.keys
+    end
+
+    def maximum_bytes_billed(olaf_query)
+      olaf_query.class.driver_options.fetch(:maximum_bytes_billed, @maximum_bytes_billed)
+    end
+
+    def labels(olaf_query)
+      @labels
+        .merge(query: File.basename(olaf_query.class.template.to_s, '.sql'))
+        .transform_values { |value| label_value(value) }
+    end
+
+    def label_value(value)
+      value.to_s.downcase.gsub(LABEL_FORMAT, '_')[0, LABEL_MAX_LENGTH]
+    end
+  end
+end

data/lib/olaf/drivers/snowflake.rb

@@ -1,17 +1,28 @@
+require 'sequel'
+
 module Olaf
   class Snowflake
+    WRAPPED_ERRORS = [Sequel::DatabaseError].freeze
+
     def initialize(**config)
       @config = config
     end
 
     def fetch(olaf_query)
       conn.fetch(olaf_query.sql_template, **olaf_query.variables).all
+    rescue *WRAPPED_ERRORS => error
+      raise QueryExecutionError.new(error.message, olaf_query)
     end
 
     private
 
     def conn
-      @conn ||= Sequel.odbc('snowflake', **@config)
+      # Only opening a connection needs the ODBC system library.
+      @conn ||= begin
+        require 'odbc_utf8'
+
+        Sequel.odbc('snowflake', **@config)
+      end
     end
   end
 end

data/lib/olaf/errors.rb

@@ -23,6 +23,18 @@ module Olaf
     end
   end
 
+  class UnknownArgumentsError < StandardError
+    def initialize(olaf_query)
+      super("Unknown arguments: #{olaf_query.unknown_arguments}")
+    end
+  end
+
+  class UnknownDriverError < StandardError
+    def initialize(name, configured_drivers)
+      super("Unknown driver #{name.inspect}, configured: #{configured_drivers.inspect}")
+    end
+  end
+
   class QueryExecutionError < StandardError
     attr_reader :metadata
 

data/lib/olaf/query_definition/class_methods.rb

@@ -58,6 +58,35 @@ module Olaf
         @template ||= file_name
       end
 
+      # Define the driver this query runs on, one of the names given to
+      # `Olaf.configure`. Defaults to the default driver.
+      #
+      # Options are driver specific: the BigQuery driver reads
+      # :maximum_bytes_billed.
+      #
+      # Example:
+      #
+      #     class OneQuery
+      #       include Olaf::QueryDefinition
+      #
+      #       driver :big_query, maximum_bytes_billed: 5 * Olaf::BigQuery::GIGABYTE
+      #     end
+      #
+      #
+      def driver(name = nil, **options)
+        return @driver if name.nil?
+
+        @driver ||= name
+        @driver_options ||= options
+
+        @driver
+      end
+
+      #   @return Hash of the options given to `driver`
+      def driver_options
+        @driver_options ||= {}
+      end
+
       # Define the object representing each row of the result.
       # When not specified, each row will be a hash by default.
       #

data/lib/olaf/query_definition.rb

@@ -27,6 +27,7 @@ module Olaf
 
       raise UndefinedArgumentsError, self if undefined_arguments.any?
       raise MissingArgumentsError, self if missing_arguments.any?
+      raise UnknownArgumentsError, self if unknown_arguments.any?
 
       literal_arguments = self.class.arguments.select { |_k, v| v[:literal] }.keys
 
@@ -57,15 +58,21 @@ module Olaf
       defined_arguments - @variables.keys
     end
 
-    # Find placeholders in the SQL file.
     # Every placeholder MUST be declared as an `argument` of the query.
     def undefined_arguments
-      @sql_template
-        .scan(/[^:]:(\w+)/)
-        .flatten
-        .map(&:to_sym)
-        .then { |required_arguments| required_arguments - defined_arguments }
-        .uniq
+      placeholders - defined_arguments
+    end
+
+    # Every `argument` declared in the query MUST have a placeholder in the SQL file.
+    def unknown_arguments
+      defined_arguments - placeholders
+    end
+
+    private
+
+    # Find placeholders in the SQL file.
+    def placeholders
+      @placeholders ||= @sql_template.scan(/[^:]:(\w+)/).flatten.map(&:to_sym).uniq
     end
   end
 end

data/lib/olaf.rb

@@ -1,46 +1,83 @@
-require 'sequel'
-require 'odbc_utf8'
-
 require_relative 'olaf/errors'
 require_relative 'olaf/query_definition'
-require_relative 'olaf/drivers/fake'
-require_relative 'olaf/drivers/snowflake'
 
 module Olaf
-  # Configures Olaf module to execute queries in Snowflake or in a local object
-  # to prevent external calls. Arguments passed will be forwarded directly
-  # to the `olaf_driver` class specified.
+  # Autoloaded: each driver pulls in its own client library.
+  autoload :BigQuery, File.expand_path('olaf/drivers/big_query', __dir__)
+  autoload :Fake, File.expand_path('olaf/drivers/fake', __dir__)
+  autoload :Snowflake, File.expand_path('olaf/drivers/snowflake', __dir__)
+
+  DEFAULT_DRIVER = :default
+
+  # Configures the drivers used to execute queries, either a single one built
+  # from the arguments given:
+  #
+  #     Olaf.configure(user: 'olaf')             # Olaf::Snowflake, the default
+  #     Olaf.configure(olaf_driver: Olaf::Fake)  # ideal for testing
   #
-  # By default, it will set a connection with Snowflake
-  def self.configure(olaf_driver: Olaf::Snowflake, **args)
-    @instance = olaf_driver.new(**args)
+  # or several instantiated ones, which queries pick by name with `driver`:
+  #
+  #     Olaf.configure(
+  #       drivers: { snowflake: Olaf::Snowflake.new(user: 'olaf'), big_query: Olaf::BigQuery.new(project: 'carwow') },
+  #       default: :snowflake
+  #     )
+  #
+  #   @return the default Olaf driver instance
+  def self.configure(olaf_driver: nil, drivers: nil, default: nil, **args)
+    @drivers, @default_driver =
+      if drivers
+        raise ArgumentError, 'Pass `drivers:` or a single `olaf_driver:`, not both' if olaf_driver || args.any?
+        raise ArgumentError, 'No drivers given to configure' if drivers.empty?
+
+        default_driver = default || drivers.keys.first
+        unless drivers.key?(default_driver)
+          raise ArgumentError, "Unknown default driver #{default_driver.inspect}, given: #{drivers.keys.inspect}"
+        end
+
+        [drivers.dup, default_driver]
+      else
+        [{ DEFAULT_DRIVER => (olaf_driver || Snowflake).new(**args) }, DEFAULT_DRIVER]
+      end
+
+    instance
   end
 
-  # Executes a query defined by Olaf::QueryDefinition with the driver
-  # configured previously.
+  # Executes a query defined by Olaf::QueryDefinition with the driver the query
+  # declares, or with the default driver when it declares none.
   #
   #   @return Enumerable of results.
   #     (i.e. Array of Hashes or `row_objects` when specified)
   #
   #   @raises Olaf::QueryExecutionError
+  #   @raises Olaf::UnknownDriverError
   def self.execute(olaf_query)
     row_object = olaf_query.class.row_object
     row_transformer = row_object ? ->(r) { row_object.new(**r) } : Proc.new(&:itself)
 
-    instance
+    instance(driver_name(olaf_query))
       .fetch(olaf_query)
       .map!(&row_transformer)
-  rescue Sequel::DatabaseError => error
-    raise QueryExecutionError.new(error.message, olaf_query)
   end
 
-  # Returns an instance to execute queries when its configured.
+  # Returns an instance to execute queries when its configured. Without a name,
+  # the default driver. A single configured driver serves every name, which is
+  # what keeps `Olaf::Fake` covering every query in tests.
   #
   #   @return Olaf driver instance
   #     * Olaf::Fake      - Ideal for testing
   #     * Olaf::Snowflake - Sequel.odbc driver to run queries in Snowflake
+  #     * Olaf::BigQuery  - google-cloud-bigquery driver to run queries in BigQuery
   #
-  def self.instance
-    @instance || raise('You need to configure Olaf before using it!')
+  def self.instance(name = nil)
+    drivers = @drivers || raise('You need to configure Olaf before using it!')
+
+    return drivers.fetch(@default_driver) if name.nil? || drivers.size == 1
+
+    drivers.fetch(name) { raise UnknownDriverError.new(name, drivers.keys) }
+  end
+
+  def self.driver_name(olaf_query)
+    olaf_query.class.driver if olaf_query.class.respond_to?(:driver)
   end
+  private_class_method :driver_name
 end

data/olaf.gemspec

@@ -1,8 +1,8 @@
 Gem::Specification.new do |s|
   s.name        = 'olaf'
-  s.version     = '0.1.2'
+  s.version     = '0.3.0'
   s.date        = Time.now.strftime('%Y-%m-%d')
-  s.summary     = 'Ruby wrapper for Snowflake queries.'
+  s.summary     = 'Ruby wrapper for warehouse queries.'
   s.authors     = ['Emiliano Mancuso']
   s.email       = ['emiliano.mancuso@gmail.com', 'developers@carwow.co.uk']
   s.homepage    = 'http://github.com/carwow/olaf'
@@ -16,7 +16,11 @@ Gem::Specification.new do |s|
   ]
   s.test_files = Dir['test/*.*']
 
-  s.add_runtime_dependency 'sequel', '~> 5.37'
-  s.add_runtime_dependency 'ruby-odbc', '~> 0.99'
+  # Drivers load their own client libraries, so consumers only install the ones
+  # they configure:
+  #   Olaf::Snowflake - sequel and ruby-odbc
+  #   Olaf::BigQuery  - google-cloud-bigquery
+  s.add_development_dependency 'google-cloud-bigquery', '~> 1.64'
+  s.add_development_dependency 'sequel', '~> 5.37'
   s.add_development_dependency 'test-unit', '~> 3.3'
 end

data/test/olaf_configure_test.rb

@@ -25,4 +25,70 @@ class OlafConfigureTest < Test::Unit::TestCase
 
     assert Olaf.instance.is_a?(Olaf::Snowflake)
   end
+
+  def test_configure_returns_the_default_driver
+    assert_equal Olaf.configure(olaf_driver: Olaf::Fake), Olaf.instance
+  end
+
+  def test_configure_registers_several_drivers
+    snowflake = MockDriver.new
+    big_query = MockDriver.new
+
+    Olaf.configure(drivers: { snowflake: snowflake, big_query: big_query }, default: :snowflake)
+
+    assert_equal Olaf.instance, snowflake
+    assert_equal Olaf.instance(:snowflake), snowflake
+    assert_equal Olaf.instance(:big_query), big_query
+  end
+
+  def test_configure_defaults_to_the_first_driver_registered
+    snowflake = MockDriver.new
+
+    Olaf.configure(drivers: { snowflake: snowflake, big_query: MockDriver.new })
+
+    assert_equal Olaf.instance, snowflake
+  end
+
+  def test_configure_rejects_a_default_that_was_not_registered
+    assert_raise_message(/Unknown default driver :redshift/) do
+      Olaf.configure(drivers: { snowflake: MockDriver.new }, default: :redshift)
+    end
+  end
+
+  def test_configure_rejects_both_forms_at_once
+    assert_raise ArgumentError do
+      Olaf.configure(olaf_driver: MockDriver, drivers: { snowflake: MockDriver.new })
+    end
+  end
+
+  def test_configure_rejects_an_empty_list_of_drivers
+    assert_raise ArgumentError do
+      Olaf.configure(drivers: {})
+    end
+  end
+
+  def test_instance_serves_every_name_when_a_single_driver_is_configured
+    Olaf.configure(olaf_driver: Olaf::Fake)
+
+    assert_equal Olaf.instance(:big_query), Olaf.instance
+  end
+
+  def test_instance_raises_for_a_driver_that_was_not_registered
+    Olaf.configure(drivers: { snowflake: MockDriver.new, big_query: MockDriver.new })
+
+    assert_raise Olaf::UnknownDriverError do
+      Olaf.instance(:redshift)
+    end
+  end
+
+  def test_instance_raises_until_olaf_is_configured
+    configured_drivers = Olaf.instance_variable_get(:@drivers)
+    Olaf.instance_variable_set(:@drivers, nil)
+
+    assert_raise_message(/You need to configure Olaf before using it!/) do
+      Olaf.instance
+    end
+  ensure
+    Olaf.instance_variable_set(:@drivers, configured_drivers)
+  end
 end

data/test/olaf_execute_test.rb

@@ -1,6 +1,23 @@
 require_relative 'helper'
 
 class OlafExecuteTest < Test::Unit::TestCase
+  Company = Struct.new(:company, keyword_init: true)
+
+  class RecordingDriver
+    attr_reader :executed
+
+    def initialize(**config)
+      @config = config
+      @executed = []
+    end
+
+    def fetch(olaf_query)
+      @executed << olaf_query
+
+      [{ company: 'carwow' }]
+    end
+  end
+
   def setup
     Olaf.configure(olaf_driver: Olaf::Fake)
 
@@ -17,9 +34,9 @@ class OlafExecuteTest < Test::Unit::TestCase
   end
 
   def test_execute_returns_a_list_of_row_objects_when_defined
-    @query.row_object OpenStruct
+    @query.row_object Company
 
-    all_row_objects = Olaf.execute(@query_instance).all? { |e| e.is_a? OpenStruct }
+    all_row_objects = Olaf.execute(@query_instance).all? { |e| e.is_a? Company }
 
     assert all_row_objects
   end
@@ -30,12 +47,12 @@ class OlafExecuteTest < Test::Unit::TestCase
     assert all_hashes
   end
 
-  def test_execute_raises_error
+  def test_execute_lets_the_error_wrapped_by_the_driver_through
     faulty_driver = Class.new do
       def initialize(**args); end
 
-      def fetch(*args)
-        raise Sequel::DatabaseError
+      def fetch(olaf_query)
+        raise Olaf::QueryExecutionError.new('something went wrong', olaf_query)
       end
     end
 
@@ -45,4 +62,48 @@ class OlafExecuteTest < Test::Unit::TestCase
       Olaf.execute(@query_instance)
     end
   end
+
+  def test_execute_uses_the_driver_declared_by_the_query
+    default_driver = RecordingDriver.new
+    other_driver = RecordingDriver.new
+
+    Olaf.configure(drivers: { default: default_driver, big_query: other_driver })
+
+    @query.driver :big_query
+
+    Olaf.execute(@query_instance)
+
+    assert_equal other_driver.executed, [@query_instance]
+    assert_equal default_driver.executed, []
+  end
+
+  def test_execute_uses_the_default_driver_when_the_query_declares_none
+    default_driver = RecordingDriver.new
+    other_driver = RecordingDriver.new
+
+    Olaf.configure(drivers: { big_query: other_driver, snowflake: default_driver }, default: :snowflake)
+
+    Olaf.execute(@query_instance)
+
+    assert_equal default_driver.executed, [@query_instance]
+    assert_equal other_driver.executed, []
+  end
+
+  def test_execute_uses_the_only_driver_configured_whatever_the_query_declares
+    @query.driver :big_query
+
+    Olaf.execute(@query_instance)
+
+    assert_equal Olaf.instance.execution_log, [@query_instance]
+  end
+
+  def test_execute_raises_when_the_driver_declared_is_not_configured
+    Olaf.configure(drivers: { default: RecordingDriver.new, snowflake: RecordingDriver.new })
+
+    @query.driver :big_query
+
+    assert_raise_message(/Unknown driver :big_query/) do
+      Olaf.execute(@query_instance)
+    end
+  end
 end

data/test/olaf_lazy_loading_test.rb

@@ -0,0 +1,40 @@
+require_relative 'helper'
+
+# Drivers pull in client libraries that not every consumer installs, so what
+# gets loaded, and when, is part of the interface. These run in a subprocess:
+# the rest of the suite has all of them loaded already.
+class OlafLazyLoadingTest < Test::Unit::TestCase
+  def test_requiring_olaf_loads_no_driver_dependency
+    assert_equal loaded_after('require "olaf"'), []
+  end
+
+  def test_configuring_the_fake_driver_loads_no_driver_dependency
+    assert_equal loaded_after('require "olaf"; Olaf.configure(olaf_driver: Olaf::Fake)'), []
+  end
+
+  def test_configuring_the_snowflake_driver_loads_sequel_only
+    assert_equal loaded_after('require "olaf"; Olaf.configure(user: "olaf")'), ['sequel']
+  end
+
+  private
+
+  DEPENDENCIES = {
+    'sequel' => 'Sequel',
+    'odbc_utf8' => 'ODBC',
+    'google-cloud-bigquery' => 'Google::Cloud::Bigquery'
+  }.freeze
+
+  def loaded_after(script)
+    report = "print #{DEPENDENCIES.values.inspect}.map { |c| Object.const_defined?(c) }.inspect"
+    # RUBYOPT carries bundler into the subprocess, which is not what is measured.
+    output = IO.popen({ 'RUBYOPT' => nil }, [RbConfig.ruby, '-I', lib_path, '-e', "#{script}; #{report}"], &:read)
+
+    assert $?.success?, "Failed to run: #{script}"
+
+    DEPENDENCIES.keys.zip(eval(output)).select { |_name, loaded| loaded }.map(&:first)
+  end
+
+  def lib_path
+    File.expand_path('../lib', File.dirname(__FILE__))
+  end
+end

metadata

@@ -1,43 +1,42 @@
 --- !ruby/object:Gem::Specification
 name: olaf
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Emiliano Mancuso
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-26 00:00:00.000000000 Z
+date: 2026-09-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: sequel
+  name: google-cloud-bigquery
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.37'
-  type: :runtime
+        version: '1.64'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.37'
+        version: '1.64'
 - !ruby/object:Gem::Dependency
-  name: ruby-odbc
+  name: sequel
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.99'
-  type: :runtime
+        version: '5.37'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.99'
+        version: '5.37'
 - !ruby/object:Gem::Dependency
   name: test-unit
   requirement: !ruby/object:Gem::Requirement
@@ -52,7 +51,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.3'
-description:
 email:
 - emiliano.mancuso@gmail.com
 - developers@carwow.co.uk
@@ -62,6 +60,7 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/olaf.rb
+- lib/olaf/drivers/big_query.rb
 - lib/olaf/drivers/fake.rb
 - lib/olaf/drivers/snowflake.rb
 - lib/olaf/errors.rb
@@ -72,11 +71,11 @@ files:
 - test/helper.rb
 - test/olaf_configure_test.rb
 - test/olaf_execute_test.rb
+- test/olaf_lazy_loading_test.rb
 homepage: http://github.com/carwow/olaf
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -91,11 +90,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key:
+rubygems_version: 4.0.20
 specification_version: 4
-summary: Ruby wrapper for Snowflake queries.
+summary: Ruby wrapper for warehouse queries.
 test_files:
 - test/helper.rb
-- test/olaf_execute_test.rb
 - test/olaf_configure_test.rb
+- test/olaf_execute_test.rb
+- test/olaf_lazy_loading_test.rb