bigquery 0.2.9 → 0.2.10

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2a6b70cb84d6ff943f8b0df09c7d78aafdddb60f
+  data.tar.gz: 31bf68de60cb4f6e10773605f007df26a35d7ae3
+SHA512:
+  metadata.gz: 16f52a1058e60c9cf7a9dc89da0c1fd7a0b4ddc5685912cedefef4d68432658eb0aaf9001611e07c97eef8757d529e53ccfbd1e1ce5762488fdec5f1f7e79a26
+  data.tar.gz: fce727fc5ebfcbe1ef232fc8c32f79a0e7df0351fcb70f131b2c3755e4cc2d8f52347db40d9011d7b29dde8521c39a338c35977edf84640ba8a089218ba747e3

data/.gitignore

@@ -0,0 +1,3 @@
+*.gem
+.*.yml
+*.p12

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,67 @@
+PATH
+  remote: .
+  specs:
+    bigquery (0.2.9)
+      google-api-client (>= 0.4.6)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.3.6)
+    autoparse (0.3.3)
+      addressable (>= 2.3.1)
+      extlib (>= 0.9.15)
+      multi_json (>= 1.0.0)
+    byebug (2.7.0)
+      columnize (~> 0.3)
+      debugger-linecache (~> 1.2)
+    coderay (1.1.0)
+    columnize (0.8.9)
+    debugger-linecache (1.2.0)
+    extlib (0.9.16)
+    faraday (0.9.0)
+      multipart-post (>= 1.2, < 3)
+    google-api-client (0.7.1)
+      addressable (>= 2.3.2)
+      autoparse (>= 0.3.3)
+      extlib (>= 0.9.15)
+      faraday (>= 0.9.0)
+      jwt (>= 0.1.5)
+      launchy (>= 2.1.1)
+      multi_json (>= 1.0.0)
+      retriable (>= 1.4)
+      signet (>= 0.5.0)
+      uuidtools (>= 2.1.0)
+    jwt (1.0.0)
+    launchy (2.4.2)
+      addressable (~> 2.3)
+    method_source (0.8.2)
+    minitest (5.3.4)
+    multi_json (1.10.1)
+    multipart-post (2.0.0)
+    pry (0.9.12.6)
+      coderay (~> 1.0)
+      method_source (~> 0.8)
+      slop (~> 3.4)
+    pry-byebug (1.3.2)
+      byebug (~> 2.7)
+      pry (~> 0.9.12)
+    rake (10.3.2)
+    retriable (1.4.1)
+    signet (0.5.1)
+      addressable (>= 2.2.3)
+      faraday (>= 0.9.0.rc5)
+      jwt (>= 0.1.5)
+      multi_json (>= 1.0.0)
+    slop (3.5.0)
+    uuidtools (2.1.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bigquery!
+  bundler
+  minitest
+  pry-byebug
+  rake

data/README.md

@@ -0,0 +1,151 @@
+# BigQuery
+
+BigQuery is a wrapper around the Google api ruby gem designed to make interacting with BigQuery easier.
+
+## Install
+
+    gem install bigquery
+
+## Authorization
+
+Only service accounts are supported right now. https://developers.google.com/accounts/docs/OAuth2#serviceaccount
+
+## Available methods
+
+* query
+* tables
+* load
+* tables_formatted
+* job
+* jobs
+* refresh_auth
+
+## Example
+
+    require 'big_query'
+
+    opts = {}
+    opts['client_id']     = '1234.apps.googleusercontent.com'
+    opts['service_email'] = '1234@developer.gserviceaccount.com'
+    opts['key']           = '/path/to/somekeyfile-privatekey.p12'
+    opts['project_id']    = '54321'
+    opts['dataset']       = 'yourdataset'
+
+    bq = BigQuery::Client.new(opts)
+
+    puts bq.tables
+
+## Tables
+
+List tables in dataset
+
+    bq.tables
+
+List table names
+
+    bq.tables_formatted
+
+Fetch table data
+
+    bq.table_data('table_name')
+
+Delete exiting table
+
+    bq.delete_table('test123')
+
+Create table. First param is the table name second one is the table schema defined with the following format
+
+    {
+        field_name: {
+            type: 'TYPE_VALUE BETWEEN (STRING, INTEGER, FLOAT, BOOLEAN, RECORD)',
+            mode: 'MODE_VALUE BETWEEN (NULLABLE, REQUIRED, REPEATED)'
+        },
+        other_field_name: { ... }
+    }
+
+
+As this example defines
+
+    table_name = 'test123'
+    table_schema = { id: { type: 'INTEGER' },
+                     name: { type: 'STRING' } }
+    bq.create_table(table_name, table_schema)
+
+Describe table schema
+
+    bq.describe_table('table_name')
+
+## Query
+
+You can either select
+
+    bq.query("SELECT * FROM [#{config['dataset']}.table_name] LIMIT 1")
+
+Or insert
+
+    bq.insert('table_name', 'id' => 123, 'type' => 'Task')
+
+## Keys
+
+To get the keys you need to have a:
+
+* google API project (link)[https://console.developers.google.com/project]
+* bigquery activated (link)[https://bigquery.cloud.google.com]
+* create a bigquery dataset in the project (link)[https://bigquery.cloud.google.com]
+
+1- Goto your project google api access
+
+https://code.google.com/apis/console/b/0/?noredirect&pli=1#project:YOUR_PROJECT_ID:access
+
+2- Create a new client-ID for service_account
+3- Download de key file
+
+Now you have everything:
+
+* client_id: API access client-ID
+* service_email: API access Email address
+* key: API access key file path
+* project_id: your google API project id
+* dataset: your big query dataset name
+
+## Troubleshooting
+
+If you're getting an "invalid_grant" error it usually means your system clock is off.
+
+If you're getting unauthorized requested but you've been able to successfully connect before, you need to refresh your auth by running the "refresh_auth" method.
+
+## How to run test
+
+Before run test, you must create file named `.bigquery_settings.yml` on root of this repository. `.bigquery_settings.yml` must include following infomation.
+
+```yaml
+client_id:     '1234.apps.googleusercontent.com'
+service_email: '1234@developer.gserviceaccount.com'
+key:           '/path/to/somekeyfile-privatekey.p12'
+project_id:    '54321'
+dataset:       'yourdataset'
+```
+
+Then run tests via rake.
+
+```
+$ bundle install && bundle exec rake test
+```
+
+## Contributing
+
+Fork and submit a pull request and make sure you add a test for any feature you add.
+
+## License
+
+LICENSE:
+
+(The MIT License)
+
+Copyright © 2012 Adam Bronte
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the ‘Software’), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED ‘AS IS’, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler/setup'
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/*.rb'
+  test.verbose = true
+end

data/bigquery.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "big_query/version"
+
+Gem::Specification.new do |s|
+  s.name            = "bigquery"
+  s.version         = BigQuery::VERSION
+  s.authors         = ["Adam Bronte", "Andres Bravo"]
+  s.email           = ["adam@brontesaurus.com", "andresbravog@gmail.com"]
+  s.description     = "This library is a wrapper around the google-api-client ruby gem.
+                       It's meant to make calls to BigQuery easier and streamlined."
+  s.require_paths   = ["lib"]
+  s.summary         = "A nice wrapper for Google Big Query"
+  s.homepage        = "https://github.com/abronte/BigQuery"
+  s.files           = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+
+  s.add_dependency  "google-api-client", ">= 0.4.6"
+
+  s.add_development_dependency "bundler"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "minitest"
+  s.add_development_dependency "pry-byebug"
+end

data/lib/big_query.rb

@@ -0,0 +1,9 @@
+require 'json'
+require 'google/api_client'
+require 'big_query/version'
+require 'big_query/errors'
+require 'big_query/client'
+
+module BigQuery
+  include BigQuery::Errors
+end

data/lib/big_query/client.rb

@@ -0,0 +1,73 @@
+require 'big_query/client/errors'
+require 'big_query/client/query'
+require 'big_query/client/jobs'
+require 'big_query/client/tables'
+
+module BigQuery
+  class Client
+    include BigQuery::Client::Errors
+    include BigQuery::Client::Query
+    include BigQuery::Client::Jobs
+    include BigQuery::Client::Tables
+
+    attr_accessor :dataset, :project_id
+
+    def initialize(opts = {})
+      @client = Google::APIClient.new(
+        application_name: 'BigQuery ruby app',
+        application_version: BigQuery::VERSION
+      )
+
+      key = Google::APIClient::PKCS12.load_key(File.open(
+        opts['key'], mode: 'rb'),
+        "notasecret"
+      )
+
+      @asserter = Google::APIClient::JWTAsserter.new(
+        opts['service_email'],
+        "https://www.googleapis.com/auth/bigquery",
+        key
+      )
+
+      refresh_auth
+
+      @bq = @client.discovered_api("bigquery", "v2")
+
+      @project_id = opts['project_id']
+      @dataset = opts['dataset']
+    end
+
+    def refresh_auth
+      @client.authorization = @asserter.authorize
+    end
+
+    private
+
+    # Performs the api calls with the given params adding the defined project and
+    # dataset params if not defined
+    #
+    # @param opts [Hash] options for the api call
+    # @return [Hash] json response
+    def api(opts)
+      if opts[:parameters]
+        opts[:parameters] = opts[:parameters].merge({"projectId" => @project_id})
+      else
+        opts[:parameters] = {"projectId" => @project_id}
+      end
+
+      resp = @client.execute(opts)
+      data = parse_body(resp)
+      handle_error(data) if data && is_error?(data)
+      data
+    end
+
+    # Parses json body if present and is a json formatted
+    #
+    # @param resp [Faraday::Response] response object
+    # @return [Hash]
+    def parse_body(resp)
+      return nil unless resp.body && !resp.body.empty?
+      JSON.parse(resp.body)
+    end
+  end
+end

data/lib/big_query/client/errors.rb

@@ -0,0 +1,27 @@
+module BigQuery
+  class Client
+    module Errors
+      # Defines whenever the response is an error or not
+      #
+      # @param response [Hash] parsed json response
+      # @return [Boolean]
+      def is_error?(response)
+        !response["error"].nil?
+      end
+
+      # handles the error and raises an understandable error
+      #
+      # @param response [Hash] parsed json response
+      # @raise [BigQueryError]
+      def handle_error(response)
+        error = response['error']
+        case error['code']
+        when 404
+          fail BigQuery::Errors::NotFound, error['message']
+        else
+          fail BigQuery::Errors::BigQueryError, error['message']
+        end
+      end
+    end
+  end
+end

data/lib/big_query/client/jobs.rb

@@ -0,0 +1,38 @@
+module BigQuery
+  class Client
+    module Jobs
+      # Fetches a bigquery job by id
+      #
+      # @param id [Integer] job id to fetch
+      # @param options [Hash] bigquery opts accepted
+      # @return [Hash] json api response
+      def job(id, opts = {})
+        opts['jobId'] ||= id
+
+        api(api_method: @bq.jobs.get,
+            parameters: opts)
+      end
+
+      # lists all the jobs
+      #
+      # @param options [Hash] bigquery opts accepted
+      # @return [Hash] json api response
+      def jobs(opts = {})
+        api(api_method: @bq.jobs.list,
+            parameters: opts)
+      end
+
+      # Gets the results of a given job
+      #
+      # @param id [Integer] job id to fetch
+      # @param options [Hash] bigquery opts accepted
+      # @return [Hash] json api response
+      def get_query_results(id, opts = {})
+        opts['jobId'] ||= id
+
+        api(api_method: @bq.jobs.get_query_results,
+            parameters: opts)
+      end
+    end
+  end
+end

data/lib/big_query/client/load.rb

@@ -0,0 +1,21 @@
+module BigQuery
+  class Client
+    module Insert
+      # Loads file content into a table
+      #
+      # see https://developers.google.com/bigquery/loading-data-into-bigquery for possible opts
+      # @param opts [Hash] field value hash to be inserted
+      # @return [Hash]
+      def load(opts)
+        api(
+          api_method: @bq.jobs.insert,
+          body_object: {
+            'configuration' => {
+              'load' => opts
+            }
+          }
+        )
+      end
+    end
+  end
+end

data/lib/big_query/client/query.rb

@@ -0,0 +1,49 @@
+module BigQuery
+  class Client
+    module Query
+      # Performs the given query in the bigquery api
+      #
+      # @param given_query [String] query to perform
+      # @param options [Hash] query options
+      # @option options [Integer] timeout (90 * 1000) timeout in miliseconds
+      # @return [Hash] json api response
+      def query(given_query, options={})
+        timeout = options.fetch(:timeout, 90 * 1000)
+        response = api(
+          api_method: @bq.jobs.query,
+          body_object: { 'query' => given_query,
+                         'timeoutMs' => timeout}
+        )
+
+        response
+      end
+
+      # perform a query synchronously
+      # fetch all result rows, even when that takes >1 query
+      # invoke /block/ once for each row, passing the row
+      #
+      # @param q [String] query to be executed
+      # @param options [Hash] query options
+      # @option options [Integer] timeout (90 * 1000) timeout in miliseconds
+      def each_row(q, options = {}, &block)
+        current_row = 0
+        # repeatedly fetch results, starting from current_row
+        # invoke the block on each one, then grab next page if there is one
+        # it'll terminate when res has no 'rows' key or when we've done enough rows
+        # perform query...
+        res = query(q, options)
+        job_id = res['jobReference']['jobId']
+        # call the block on the first page of results
+        if( res && res['rows'] )
+          res['rows'].each(&block)
+          current_row += res['rows'].size
+        end
+        # keep grabbing pages from the API and calling the block on each row
+        while(( res = get_query_results(job_id, :startIndex => current_row) ) && res['rows'] && current_row < res['totalRows'].to_i ) do
+          res['rows'].each(&block)
+          current_row += res['rows'].size
+        end
+      end
+    end
+  end
+end

data/lib/big_query/client/tables.rb

@@ -0,0 +1,124 @@
+
+# Module to handle table actions
+# https://developers.google.com/bigquery/docs/tables
+module BigQuery
+  class Client
+    module Tables
+      ALLOWED_FIELD_TYPES = ['STRING', 'INTEGER', 'FLOAT', 'BOOLEAN', 'RECORD']
+      ALLOWED_FIELD_MODES = ['NULLABLE', 'REQUIRED', 'REPEATED']
+
+      # Lists the tables
+      #
+      # @param dataset [String] dataset to look for
+      # @return [Hash] json api response
+      def tables(dataset = @dataset)
+        response = api({
+          :api_method => @bq.tables.list,
+          :parameters => {"datasetId" => dataset}
+        })
+
+        response['tables'] || []
+      end
+
+      # Lists the tables returnning only the tableId
+      #
+      # @param dataset [String] dataset to look for
+      # @return [Hash] json api response
+      def tables_formatted(dataset = @dataset)
+        tables(dataset).map { |t| t['tableReference']['tableId'] }
+      end
+
+      # Returns all rows of table data
+      #
+      # @param tableId [String] id of the table to look for
+      # @param dataset [String] dataset to look for
+      # @return [Hash] json api response
+      def table_data(tableId, dataset = @dataset)
+        response = api(api_method: @bq.tabledata.list,
+                       parameters: { 'datasetId' => dataset,
+                                     'tableId' => tableId })
+        response['rows'] || []
+      end
+
+      # insert row into table
+      #
+      # @param tableId [String] table id to insert into
+      # @param opts [Hash] field value hash to be inserted
+      # @return [Hash]
+      def insert(tableId, opts)
+        api(
+          api_method: @bq.tabledata.insert_all,
+          parameters: { 'tableId' => tableId,
+                        'datasetId' => @dataset },
+          body_object: { 'rows' => [{ 'json' => opts }] }
+        )
+      end
+
+      # Creating a new table
+      #
+      # @param tableId [String] table id to insert into
+      # @param schema [Hash] name => opts hash for the schema
+      #
+      # examples:
+      #
+      # @bq.create_table('new_table', id: { type: 'INTEGER', mode: 'required' })
+      # @bq.create_table('new_table', price: { type: 'FLOAT' })
+      def create_table(tableId, schema={})
+        api(
+          api_method: @bq.tables.insert,
+          parameters: { "datasetId" => @dataset },
+          body_object: { "tableReference" => {
+                            "tableId" => tableId,
+                            "projectId" => @project_id,
+                            "datasetId" => @dataset
+                          },
+                          "schema" => {
+                            "fields" => validate_schema(schema)
+                          }
+                        }
+        )
+      end
+
+      # Deletes the given tableId
+      #
+      # @param tableId [String] table id to insert into
+      def delete_table(tableId)
+        api(api_method: @bq.tables.delete,
+            parameters: { 'tableId' => tableId,
+                          'datasetId' => @dataset }
+        )
+      end
+
+      # Describe the schema of the given tableId
+      #
+      # @param tableId [String] table id to describe
+      # @param dataset [String] dataset to look for
+      # @return [Hash] json api response
+      def describe_table(tableId, dataset = @dataset)
+        api(
+          api_method: @bq.tables.get,
+          parameters: { 'tableId' => tableId,
+                        'datasetId' => @dataset }
+        )
+      end
+
+      protected
+
+      # Translate given schema to a one understandable by bigquery
+      #
+      # @param [Hash] schema like { field_nane => { type: 'TYPE', mode: 'MODE' }, ... }
+      # @return [Array<Hash>]
+      def validate_schema(schema)
+        fields = []
+        schema.map do |name, options|
+          type = (ALLOWED_FIELD_TYPES & [options[:type].to_s]).first
+          mode = (ALLOWED_FIELD_MODES & [options[:mode].to_s]).first
+          field = { "name" => name.to_s, "type" => type }
+          field["mode"] = mode if mode
+          fields << field
+        end
+        fields
+      end
+    end
+  end
+end

data/lib/big_query/errors.rb

@@ -0,0 +1,8 @@
+# BigQuery API errors
+module BigQuery
+  module Errors
+    class BigQueryError < StandardError; end
+    class NotFound < BigQueryError; end
+    class BadDataset < BigQueryError; end
+  end
+end

data/lib/big_query/version.rb

@@ -0,0 +1,3 @@
+module BigQuery
+  VERSION = '0.2.10'
+end

data/test/bigquery.rb

@@ -0,0 +1,91 @@
+# encoding: UTF-8
+require 'minitest/autorun'
+require 'yaml'
+require 'big_query'
+require 'pry-byebug'
+
+class BigQueryTest < MiniTest::Unit::TestCase
+  def setup
+    @bq = BigQuery::Client.new(config)
+    if @bq.tables_formatted.include? 'test'
+      @bq.delete_table('test')
+    end
+    result = @bq.create_table('test', id: { type: 'INTEGER', mode: 'REQUIRED' }, type: { type: 'STRING', mode: 'NULLABLE' })
+  end
+
+  def config
+    return @config if @config
+    config_data ||= File.expand_path(File.dirname(__FILE__) + "/../.bigquery_settings.yml")
+    @config = YAML.load_file(config_data)
+  end
+
+  def test_for_tables
+    tables = @bq.tables
+
+    assert_equal tables[0]['kind'], "bigquery#table"
+    assert_equal tables[0]['id'], "#{config['project_id']}:#{config['dataset']}.test"
+    assert_equal tables[0]['tableReference']['tableId'], 'test'
+  end
+
+  def test_for_tables_formatted
+    result = @bq.tables_formatted
+
+    assert_includes result, 'test'
+  end
+
+  def test_for_table_data
+    result = @bq.table_data('test')
+
+    assert_kind_of Array, result
+  end
+
+  def test_for_create_table
+    if @bq.tables_formatted.include? 'test123'
+      @bq.delete_table('test123')
+    end
+    result = @bq.create_table('test123', id: { type: 'INTEGER' })
+
+    assert_equal result['kind'], "bigquery#table"
+    assert_equal result['tableReference']['tableId'], "test123"
+    assert_equal result['schema']['fields'], [{"name"=>"id", "type"=>"INTEGER"}]
+  end
+
+  def test_for_delete_table
+    if !@bq.tables_formatted.include? 'test123'
+      @bq.create_table('test123', id: { type: 'INTEGER' })
+    end
+    result = @bq.delete_table('test123')
+
+    tables = @bq.tables_formatted
+
+    refute_includes tables, 'test123'
+  end
+
+  def test_for_describe_table
+    result = @bq.describe_table('test')
+
+    assert_equal result['kind'], "bigquery#table"
+    assert_equal result['type'], "TABLE"
+    assert_equal result['id'], "#{config['project_id']}:#{config['dataset']}.test"
+    assert_equal result['tableReference']['tableId'], 'test'
+    assert_equal result['schema']['fields'][0]['name'], 'id'
+    assert_equal result['schema']['fields'][0]['type'], 'INTEGER'
+    assert_equal result['schema']['fields'][0]['mode'], 'REQUIRED'
+    assert_equal result['schema']['fields'][1]['name'], 'type'
+    assert_equal result['schema']['fields'][1]['type'], 'STRING'
+    assert_equal result['schema']['fields'][1]['mode'], 'NULLABLE'
+  end
+
+  def test_for_query
+    result = @bq.query("SELECT * FROM [#{config['dataset']}.test] LIMIT 1")
+
+    assert_equal result['kind'], "bigquery#queryResponse"
+    assert_equal result['jobComplete'], true
+  end
+
+  def test_for_insert
+    result = @bq.insert('test' ,"id" => 123, "type" => "Task")
+
+    assert_equal result['kind'], "bigquery#tableDataInsertAllResponse"
+  end
+end

metadata

@@ -1,124 +1,135 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: bigquery
-version: !ruby/object:Gem::Version 
-  hash: 5
-  prerelease: 
-  segments: 
-  - 0
-  - 2
-  - 9
-  version: 0.2.9
+version: !ruby/object:Gem::Version
+  version: 0.2.10
 platform: ruby
-authors: 
+authors:
 - Adam Bronte
+- Andres Bravo
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-10-09 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  version_requirements: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+date: 2014-08-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: google-api-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        - 4
-        - 6
+      - !ruby/object:Gem::Version
         version: 0.4.6
-  prerelease: false
   type: :runtime
-  name: google-api-client
-  requirement: *id001
-- !ruby/object:Gem::Dependency 
-  version_requirements: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
   prerelease: false
-  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.6
+- !ruby/object:Gem::Dependency
   name: bundler
-  requirement: *id002
-- !ruby/object:Gem::Dependency 
-  version_requirements: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  prerelease: false
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
   name: rake
-  requirement: *id003
-- !ruby/object:Gem::Dependency 
-  version_requirements: &id004 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  prerelease: false
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
   name: minitest
-  requirement: *id004
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: |-
   This library is a wrapper around the google-api-client ruby gem.
-  It's meant to make calls to BigQuery easier and streamlined.
-email: adam@brontesaurus.com
+                         It's meant to make calls to BigQuery easier and streamlined.
+email:
+- adam@brontesaurus.com
+- andresbravog@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-- lib/bigquery.rb
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- bigquery.gemspec
+- lib/big_query.rb
+- lib/big_query/client.rb
+- lib/big_query/client/errors.rb
+- lib/big_query/client/jobs.rb
+- lib/big_query/client/load.rb
+- lib/big_query/client/query.rb
+- lib/big_query/client/tables.rb
+- lib/big_query/errors.rb
+- lib/big_query/version.rb
+- test/bigquery.rb
 homepage: https://github.com/abronte/BigQuery
 licenses: []
-
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A nice wrapper for Google Big Query
-test_files: []
-
+test_files:
+- test/bigquery.rb
+has_rdoc: 

data/lib/bigquery.rb

@@ -1,130 +0,0 @@
-require 'google/api_client'
-
-class BigQuery
-
-  attr_accessor :dataset, :project_id
-
-  def initialize(opts = {})
-    @client = Google::APIClient.new
-
-    key = Google::APIClient::PKCS12.load_key(
-      opts['key'],
-      "notasecret"
-    )
-
-    @asserter = Google::APIClient::JWTAsserter.new(
-      opts['service_email'], 
-      "https://www.googleapis.com/auth/bigquery",
-      key
-    )
-
-    refresh_auth
-
-    @bq = @client.discovered_api("bigquery", "v2")
-
-    @project_id = opts['project_id']
-    @dataset = opts['dataset']
-  end
-
-  def query(q)
-    res = api({
-      :api_method => @bq.jobs.query,
-      :body_object => { "query" => q, 'timeoutMs' => 90 * 1000}
-    })
-
-    if res.has_key? "errors"
-      raise BigQueryError, "BigQuery has returned an error :: #{res['errors'].inspect}" 
-    else
-      res
-    end
-  end
-
-  def load(opts)
-    api({
-      :api_method => @bq.jobs.insert,
-      :body_object => {
-        "configuration" => {
-          "load" => opts
-        }
-      }
-    })
-  end
-
-  def job(id, opts = {})
-    opts['jobId'] = id
-
-    api({ 
-      :api_method => @bq.jobs.get,
-      :parameters => opts
-    })
-  end
-
-  def jobs(opts = {})
-    api({ 
-      :api_method => @bq.jobs.list,
-      :parameters => opts
-    })
-  end
-
-  def get_query_results(jobId, opts = {})
-    opts['jobId'] = jobId
-    api({ 
-      :api_method => @bq.jobs.get_query_results,
-      :parameters => opts
-    })
-  end
-
-  # perform a query synchronously
-  # fetch all result rows, even when that takes >1 query
-  # invoke /block/ once for each row, passing the row
-  def each_row(q, &block)
-    current_row = 0
-    # repeatedly fetch results, starting from current_row
-    # invoke the block on each one, then grab next page if there is one
-    # it'll terminate when res has no 'rows' key or when we've done enough rows
-    # perform query...
-    res = query(q)
-    job_id = res['jobReference']['jobId']
-    # call the block on the first page of results
-    if( res && res['rows'] )
-      res['rows'].each(&block)
-      current_row += res['rows'].size
-    end
-    # keep grabbing pages from the API and calling the block on each row
-    while(( res = get_query_results(job_id, :startIndex => current_row) ) && res['rows'] && current_row < res['totalRows'].to_i ) do
-      res['rows'].each(&block)
-      current_row += res['rows'].size
-    end
-  end
-
-  def tables(dataset = @dataset)
-    api({
-      :api_method => @bq.tables.list,
-      :parameters => {"datasetId" => dataset}
-    })['tables']
-  end
-
-  def tables_formatted(dataset = @dataset)
-    tables(dataset).map {|t| "[#{dataset}.#{t['tableReference']['tableId']}]"}
-  end
-
-  def refresh_auth
-    @client.authorization = @asserter.authorize
-  end
-
-  private
-
-  def api(opts)
-    if opts[:parameters]
-      opts[:parameters] = opts[:parameters].merge({"projectId" => @project_id})
-    else
-      opts[:parameters] = {"projectId" => @project_id}
-    end
-
-    resp = @client.execute(opts)
-    JSON.parse(resp.body)
-  end
-end
-
-class BigQueryError < StandardError  
-end