yancya-big_query 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6d5bd68e33c49a23f96f348b24d41aa9e2140af2
+  data.tar.gz: a4ae4adae7acf4754728e94ca31a9726239aa1ad
+SHA512:
+  metadata.gz: dcae7d1b73287106727ac1ebbf5a4e0f344ad6f981c78686f4ae47de33cda2b93fbf36a0e108a6052b56ad763f1e1eed93bf9af891589aafa94cf8f37a653025
+  data.tar.gz: aa6af3940f7b669a3b00a727cc75638f550f1fa4690bbfffb83fee0d145fb7c95142963d74865dfe84f4f5dda11c229ebcf4ea238f6b3fe593593422ad203ba4

data/.gitignore

@@ -0,0 +1,37 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+# IDEA config file
+.idea

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+# 0.0.2
+
+* Can use streaming insert
+* Add simple tests
+
+# 0.0.1
+
+* Initial release

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in big_query.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,80 @@
+PATH
+  remote: .
+  specs:
+    big_query (0.0.2)
+      google-api-client
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (4.2.1)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    addressable (2.3.8)
+    autoparse (0.3.3)
+      addressable (>= 2.3.1)
+      extlib (>= 0.9.15)
+      multi_json (>= 1.0.0)
+    extlib (0.9.16)
+    faraday (0.9.1)
+      multipart-post (>= 1.2, < 3)
+    google-api-client (0.8.6)
+      activesupport (>= 3.2)
+      addressable (~> 2.3)
+      autoparse (~> 0.3)
+      extlib (~> 0.9)
+      faraday (~> 0.9)
+      googleauth (~> 0.3)
+      launchy (~> 2.4)
+      multi_json (~> 1.10)
+      retriable (~> 1.4)
+      signet (~> 0.6)
+    googleauth (0.4.1)
+      faraday (~> 0.9)
+      jwt (~> 1.4)
+      logging (~> 2.0)
+      memoist (~> 0.12)
+      multi_json (= 1.11)
+      signet (~> 0.6)
+    i18n (0.7.0)
+    json (1.8.3)
+    jwt (1.5.0)
+    launchy (2.4.3)
+      addressable (~> 2.3)
+    little-plugger (1.1.3)
+    logging (2.0.0)
+      little-plugger (~> 1.1)
+      multi_json (~> 1.10)
+    memoist (0.12.0)
+    minitest (5.7.0)
+    multi_json (1.11.0)
+    multipart-post (2.0.0)
+    power_assert (0.2.3)
+    rake (10.4.2)
+    retriable (1.4.1)
+    signet (0.6.1)
+      addressable (~> 2.3)
+      extlib (~> 0.9)
+      faraday (~> 0.9)
+      jwt (~> 1.5)
+      multi_json (~> 1.10)
+    test-unit (3.1.1)
+      power_assert
+    thread_safe (0.3.5)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  big_query!
+  bundler (~> 1.6)
+  rake
+  test-unit
+
+BUNDLED WITH
+   1.10.3

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Shinta Koyanagi
+
+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/README.md

@@ -0,0 +1,54 @@
+# BigQuery
+
+[![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/yancya/big_query?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+Google BigQuery API client library
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'big_query', github: "yancya/big_query"
+
+And then execute:
+
+    $ bundle
+
+Or build and install it yourself as:
+
+    $ git clone git@github.com:yancya/big_query.git
+    $ cd big_query
+    $ rake install
+
+## Usage
+
+```rb
+bq = BigQuery.new(
+  key_path: "path_to_secret_key"
+  issuer: "mail@address"
+)
+
+job = bq.jobs.query(
+  project_id: "name_of_project",
+  sql: "select 1 as a, 2 as b, 3 as c"
+)
+
+begin
+  result = job.query_results
+end until result["jobComplete"]
+
+result["schema"]["fields"].map{|f| f["name"]}.join(",") #=> "a,b,c"
+result["rows"].map{|row| row["f"].map{|col| col["v"]}.join(",")} #=> ["1,2,3"]
+```
+
+## Google BigQuery API Reference
+
+https://developers.google.com/bigquery/docs/reference/v2/
+
+## Contributing
+
+1. Fork it ( https://github.com/yancya/big_query/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+
+task :default => :test
+
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = Dir["test/**/test_*.rb"]
+end

data/big_query.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'yancya/big_query/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "yancya-big_query"
+  spec.version       = Yancya::BigQuery::VERSION
+  spec.authors       = ["yancya"]
+  spec.email         = ["yancya@upec.jp"]
+  spec.summary       = %q{Google BigQuery API client library.}
+  spec.description   = %q{Google BigQuery API client library. This is simple wrapper.}
+  spec.homepage      = "https://github.com/yancya/big_query"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "google-api-client", "~> 0"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake", "~> 0"
+  spec.add_development_dependency "test-unit", "~> 0"
+end

data/bin/big_query

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+require 'big_query'

data/lib/yancya/big_query/dataset.rb

@@ -0,0 +1,31 @@
+require_relative 'tables'
+
+module Yancya
+  class BigQuery::Dataset
+    def initialize(resource:, bq:)
+      @resource = resource
+      @tables = BigQuery::Tables.new(bq: bq)
+    end
+
+    def tables
+      @tables.list(
+        project_id: project_id,
+        dataset_id: dataset_id
+      )
+    end
+
+    def project_id
+      dataset_reference["projectId"]
+    end
+
+    def dataset_id
+      dataset_reference["datasetId"]
+    end
+
+    private
+
+    def dataset_reference
+      @resource["datasetReference"]
+    end
+  end
+end

data/lib/yancya/big_query/datasets.rb

@@ -0,0 +1,63 @@
+require_relative 'initializer'
+require_relative 'request_executor'
+
+require_relative 'dataset'
+
+module Yancya
+  class BigQuery::Datasets
+    include Initializer
+    include RequestExecutor
+
+    def delete(project_id:, dataset_id:)
+      execute(
+        api_method: @bq.api.datasets.delete,
+        parameters: {projectId: project_id, datasetId: dataset_id, deleteContents: true}
+      )
+    end
+
+    def get(project_id:, dataset_id:)
+      execute(
+        api_method: @bq.api.datasets.get,
+        parameters: {projectId: project_id, datasetId: dataset_id}
+      )
+    end
+
+    def insert(project_id:, dataset:)
+      execute(
+        api_method: @bq.api.datasets.insert,
+        parameters: {projectId: project_id},
+        body_object: dataset
+      )
+    end
+
+    def list(project_id:)
+      resources = execute(
+        api_method: @bq.api.datasets.list,
+        parameters: {projectId: project_id}
+      )
+
+      resources["datasets"].map{ |resource|
+        Yancya::BigQuery::Dataset.new(
+          resource: resource,
+          bq: @bq
+        )
+      }
+    end
+
+    def patch(project_id:, dataset_id:, dataset:)
+      execute(
+        api_method: @bq.api.datasets.patch,
+        parameters: {projectId: project_id, datasetId: dataset_id},
+        body_object: dataset
+      )
+    end
+
+    def update(project_id:, dataset_id:, dataset:)
+      execute(
+        api_method: @bq.api.datasets.update,
+        parameters: {projectId: project_id, datasetId: dataset_id},
+        body_object: dataset
+      )
+    end
+  end
+end

data/lib/yancya/big_query/initializer.rb

@@ -0,0 +1,9 @@
+module Yancya
+  module Initializer
+    def self.included(_)
+      define_method(:initialize) do |bq:|
+        @bq = bq
+      end
+    end
+  end
+end

data/lib/yancya/big_query/job.rb

@@ -0,0 +1,53 @@
+module Yancya
+  class BigQuery::Job
+    def initialize(resource:, bq:)
+      @resource = resource
+      @jobs = BigQuery::Jobs.new(bq: bq)
+    end
+
+    def query_results
+      @jobs.get_query_results(
+        project_id: project_id,
+        job_id: job_id
+      )
+    end
+
+    def reload
+      @jobs.get(project_id: project_id, job_id: job_id)
+    end
+
+    def project_id
+      job_reference["projectId"]
+    end
+
+    def job_id
+      job_reference["jobId"]
+    end
+
+    def query
+      (configuration["query"]||{})["query"]
+    end
+
+    def state
+      status["state"]
+    end
+
+    def errors
+      status["errors"]
+    end
+
+    private
+
+    def configuration
+      @resource["configuration"]
+    end
+
+    def status
+      @resource["status"]
+    end
+
+    def job_reference
+      @resource["jobReference"]
+    end
+  end
+end

data/lib/yancya/big_query/jobs.rb

@@ -0,0 +1,61 @@
+require 'json'
+
+require_relative 'initializer'
+require_relative 'request_executor'
+require_relative 'job'
+
+module Yancya
+  class BigQuery::Jobs
+    include Initializer
+    include RequestExecutor
+
+    def cancel(project_id:, job_id:)
+      execute(
+        api_method: @bq.api.jobs.cancel,
+        parameters: { projectId: project_id, jobId: job_id }
+      )
+    end
+
+    def get(project_id:, job_id:)
+      resource = execute(
+        api_method: @bq.api.jobs.get,
+        parameters: { projectId: project_id, jobId: job_id }
+      )
+
+      BigQuery::Job.new(resource: resource, bq: @bq)
+    end
+
+    def get_query_results(project_id:, job_id:)
+      execute(
+        api_method: @bq.api.jobs.get_query_results,
+        parameters: { projectId: project_id, jobId: job_id }
+      )
+    end
+
+    def insert(project_id:)
+      # TODO: https://developers.google.com/bigquery/docs/reference/v2/jobs/insert
+      raise "This method is not yet working"
+    end
+
+    def list(project_id:)
+      resources = execute(
+        api_method: @bq.api.jobs.list,
+        parameters: { projectId: project_id, projection: "full" }
+      )
+
+      resources["jobs"].map{|job|
+        BigQuery::Job.new(resource: job, bq: @bq)
+      }
+    end
+
+    def query(project_id:, sql:)
+      resource = execute(
+        api_method: @bq.api.jobs.query,
+        body_object: { query: sql },
+        parameters: { projectId: project_id }
+      )
+
+      BigQuery::Job.new(resource: resource, bq: @bq)
+    end
+  end
+end

data/lib/yancya/big_query/project.rb

@@ -0,0 +1,33 @@
+require_relative 'jobs'
+require_relative 'datasets'
+require_relative 'request_executor'
+
+module Yancya
+  class BigQuery::Project
+    include RequestExecutor
+
+    def initialize(resource:, bq:)
+      @resource = resource
+      @jobs = BigQuery::Jobs.new(bq: bq)
+      @datasets = BigQuery::Datasets.new(bq: bq)
+      @bq = bq
+    end
+
+    def query(sql)
+      @jobs.query(project_id: project_id, sql: sql)
+    end
+
+    def jobs
+      @jobs.list(project_id: project_id)
+    end
+
+    def datasets
+      @datasets.list(project_id: project_id)
+    end
+
+    def project_id
+      @resource["projectReference"]["projectId"]
+    end
+  end
+end
+

data/lib/yancya/big_query/projects.rb

@@ -0,0 +1,21 @@
+require_relative 'request_executor'
+require_relative 'initializer'
+
+require_relative 'project'
+
+module Yancya
+  class BigQuery::Projects
+    include Initializer
+    include RequestExecutor
+
+    def list
+      resources = execute(
+        api_method: @bq.api.projects.list
+      )
+
+      resources["projects"].map do |resource|
+        BigQuery::Project.new(resource: resource, bq: @bq)
+      end
+    end
+  end
+end

data/lib/yancya/big_query/request_executor.rb

@@ -0,0 +1,23 @@
+module Yancya
+  module RequestExecutor
+    private
+
+    def response_to_json(obj)
+      return {} if obj.response.body.empty?
+      JSON.parse(obj.response.body).tap do |resource|
+        raise resource["error"].to_s if resource["error"]
+        break resource
+      end
+    end
+
+    def execute(api_method:, body_object: nil, parameters: nil)
+      response_to_json(
+        @bq.client.execute(
+          api_method: api_method,
+          body_object: body_object,
+          parameters: parameters
+        )
+      )
+    end
+  end
+end

data/lib/yancya/big_query/table.rb

@@ -0,0 +1,68 @@
+module Yancya
+  class BigQuery::Table
+    def initialize(resource:, tables:)
+      @resource = resource
+      @tables = tables
+    end
+
+    def project_id
+      table_reference["projectId"]
+    end
+
+    def dataset_id
+      table_reference["datasetId"]
+    end
+
+    def table_id
+      table_reference["tableId"]
+    end
+
+    def description
+      @resource["description"]
+    end
+
+    def schema
+      @resource["schema"]
+    end
+
+    def reload
+      @tables.get(
+        project_id: project_id,
+        dataset_id: dataset_id,
+        table_id: table_id
+      )
+    end
+
+    def delete
+      @tables.delete(
+        project_id: project_id,
+        dataset_id: dataset_id,
+        table_id: table_id
+      )
+    end
+
+    def patch(table_reference:)
+      @tables.patch(
+        project_id: project_id,
+        dataset_id: dataset_id,
+        table_id: table_id,
+        table: table_reference
+      )
+    end
+
+    def update(table_reference:)
+      @tables.update(
+        project_id: project_id,
+        dataset_id: dataset_id,
+        table_id: table_id,
+        table: table_reference
+      )
+    end
+
+    private
+    def table_reference
+      @resource["tableReference"]
+    end
+  end
+end
+

data/lib/yancya/big_query/tabledata.rb

@@ -0,0 +1,37 @@
+require_relative 'request_executor'
+
+module Yancya
+  class BigQuery::Tabledata
+    include RequestExecutor
+
+    def initialize(project_id:, dataset_id:, table_id:, bq:)
+      @project_id = project_id
+      @dataset_id = dataset_id
+      @table_id = table_id
+      @bq = bq
+    end
+
+    def insert_all(rows)
+      execute(
+        api_method: @bq.api.tabledata.insert_all,
+        body_object: {rows: rows},
+        parameters: {
+          datasetId: @dataset_id,
+          projectId: @project_id,
+          tableId: @table_id
+        }
+      )
+    end
+
+    def list
+      execute(
+        api_method: @bq.api.tabledata.list,
+        parameters: {
+          datasetId: @dataset_id,
+          projectId: @project_id,
+          tableId: @table_id
+        }
+      )
+    end
+  end
+end

data/lib/yancya/big_query/tables.rb

@@ -0,0 +1,90 @@
+require_relative 'initializer'
+require_relative 'request_executor'
+
+require_relative 'table'
+
+module Yancya
+  class BigQuery::Tables
+    include Initializer
+    include RequestExecutor
+
+    def delete(project_id:, dataset_id:, table_id:)
+      execute(
+        api_method: @bq.api.tables.delete,
+        parameters: {
+          datasetId: dataset_id,
+          projectId: project_id,
+          tableId: table_id,
+        }
+      )
+    end
+
+    def get(project_id:, dataset_id:, table_id:)
+      resource = execute(
+        api_method: @bq.api.tables.get,
+        parameters: {
+          datasetId: dataset_id,
+          projectId: project_id,
+          tableId: table_id,
+        }
+      )
+
+      BigQuery::Table.new(resource: resource, tables: self)
+    end
+
+    def insert(project_id:, dataset_id:, table:)
+      resource = execute(
+        api_method: @bq.api.tables.insert,
+        parameters: {
+          datasetId: dataset_id,
+          projectId: project_id,
+        },
+        body_object: table
+      )
+
+      BigQuery::Table.new(resource: resource, tables: self)
+    end
+
+    def list(project_id:, dataset_id:)
+      resources = execute(
+        api_method: @bq.api.tables.list,
+        parameters: {
+          datasetId: dataset_id,
+          projectId: project_id,
+        }
+      )
+
+      (resources["tables"]||[]).map do |resource|
+        BigQuery::Table.new(resource: resource, tables: self)
+      end
+    end
+
+    def patch(project_id:, dataset_id:, table_id:, table:)
+      resource = execute(
+        api_method: @bq.api.tables.patch,
+        parameters: {
+          datasetId: dataset_id,
+          projectId: project_id,
+          tableId: table_id,
+        },
+        body_object: table
+      )
+
+      BigQuery::Table.new(resource: resource, tables: self)
+    end
+
+    def update(project_id:, dataset_id:, table_id:, table:)
+      resource = execute(
+        api_method: @bq.api.tables.update,
+        parameters: {
+          datasetId: dataset_id,
+          projectId: project_id,
+          tableId: table_id,
+        },
+        body_object: table
+      )
+
+      BigQuery::Table.new(resource: resource, tables: self)
+    end
+  end
+end

data/lib/yancya/big_query/version.rb

@@ -0,0 +1,5 @@
+module Yancya
+  class BigQuery
+    VERSION = "0.1.0"
+  end
+end

data/lib/yancya/big_query.rb

@@ -0,0 +1,68 @@
+require_relative "big_query/version"
+require_relative "big_query/datasets"
+require_relative "big_query/jobs"
+require_relative "big_query/projects"
+require_relative "big_query/tabledata"
+require_relative "big_query/tables"
+
+require 'google/api_client'
+
+module Yancya
+  class BigQuery
+    attr_reader :client
+
+    BQ = Struct.new(:client) do
+      def api
+        client.discovered_api("bigquery", "v2")
+      end
+    end
+
+    def initialize(key_path:,
+                   issuer:,
+                   application_name: "github.com/yancya/big_query",
+                   application_version: BigQuery::VERSION)
+
+      app_info = {
+        application_name: application_name,
+        application_version: application_version
+      }
+
+      client = Google::APIClient.new(app_info)
+
+      asserter = Google::APIClient::JWTAsserter.new(
+        issuer,
+        "https://www.googleapis.com/auth/bigquery",
+        Google::APIClient::PKCS12.load_key(File.open(key_path), "notasecret")
+      )
+
+      client.authorization = asserter.authorize
+
+      @bq = BQ.new(client)
+    end
+
+    def datasets
+      Datasets.new(bq: @bq)
+    end
+
+    def jobs
+      Jobs.new(bq: @bq)
+    end
+
+    def projects
+      Projects.new(bq: @bq)
+    end
+
+    def tabledata(project_id:, dataset_id:, table_id:)
+      Tabledata.new(
+        project_id: project_id,
+        dataset_id: dataset_id,
+        table_id: table_id,
+        bq: @bq
+      )
+    end
+
+    def tables
+      Tables.new(bq: @bq)
+    end
+  end
+end

data/test/test_big_query.rb

@@ -0,0 +1,176 @@
+require 'test-unit'
+require 'pp'
+require_relative '../lib/yancya/big_query'
+
+class TestBigQuery < Test::Unit::TestCase
+  TEST_DATASET_ID = "test_dataset_for_yancya_big_query_gem"
+  TEST_DATASET_ID_MODIFIED = "test_dataset_for_yancya_big_query_gem_"
+  TEST_TABLE_ID = "test_table"
+  TEST_TABLE_INFO = {
+    schema: {
+      fields: [
+        {name: "column_s", type: "STRING"},
+        {name: "column_i", type: "INTEGER"},
+        {name: "column_f", type: "FLOAT"},
+        {name: "column_b", type: "BOOLEAN"}
+      ]
+    },
+    tableReference: {
+      tableId: TEST_TABLE_ID
+    }
+  }
+
+  setup do
+    @bq = Yancya::BigQuery.new(
+      key_path: ENV["GCP_KEY_PATH"],
+      issuer: ENV["GCP_ISSUER"]
+    )
+
+    @project_id = ENV["BQ_PROJECT_ID"]
+
+    if @bq.datasets.list(project_id: @project_id).map{ |ds| ds.dataset_id }.include? TEST_DATASET_ID
+      @bq.datasets.delete(project_id: @project_id, dataset_id: TEST_DATASET_ID)
+    end
+
+    dataset = {
+      datasetReference: {
+        datasetId: TEST_DATASET_ID
+      }
+    }
+
+    @bq.datasets.insert(project_id: @project_id, dataset: dataset)
+  end
+
+  teardown do
+    @bq.datasets.delete(project_id: @project_id, dataset_id: TEST_DATASET_ID)
+  end
+
+  test "get dataset" do
+    dataset = @bq.
+      datasets.
+      get(
+        project_id: @project_id,
+        dataset_id: TEST_DATASET_ID
+      )["datasetReference"]
+
+    assert { TEST_DATASET_ID == dataset["datasetId"] }
+  end
+
+  test "jobs list" do
+    job_list = @bq.jobs.list(project_id: @project_id)
+    assert { job_list.is_a? Array }
+  end
+
+  test "get job" do
+    job_id = @bq.jobs.list(project_id: @project_id).last.job_id
+    assert do
+      job_id == @bq.jobs.get(project_id: @project_id, job_id: job_id).job_id
+    end
+  end
+
+  test "project list" do
+    assert do
+      @bq.projects.list.map{ |project| project.project_id }.include? @project_id
+    end
+  end
+
+  test "select without table" do
+    result = execute_query("select 1 as a, 2 as b, 3 as c")
+
+    assert do
+      "1,2,3" == result["rows"].map{|row| row["f"].map{|col| col["v"]}.join(",")}.first
+    end
+  end
+
+  test "create table" do
+    result = create_table
+
+    assert { TEST_TABLE_ID == result.table_id }
+  end
+
+  test "insert_all data" do
+    create_table
+
+    table_data = @bq.tabledata(
+      project_id: @project_id,
+      dataset_id: TEST_DATASET_ID,
+      table_id: TEST_TABLE_ID
+    )
+
+    rows = [{ json: { column_s: "hoge", column_i: 1, column_f: 0.1, column_b: false } }]
+
+    assert { table_data.insert_all(rows)["insertErrors"].nil? }
+    assert { table_data.list["totalRows"] }
+  end
+
+  test "table list" do
+    create_table
+
+    assert { 1 == @bq.tables.list(project_id: @project_id, dataset_id: TEST_DATASET_ID).size }
+  end
+
+  test "get table"do
+    create_table
+
+    table = @bq.tables.get(project_id: @project_id, dataset_id: TEST_DATASET_ID, table_id: TEST_TABLE_ID)
+
+    assert { TEST_TABLE_ID == table.table_id }
+  end
+
+  test "delete table" do
+    table = create_table
+    @bq.tables.delete(project_id: @project_id, dataset_id: TEST_DATASET_ID, table_id: table.table_id)
+
+    assert { @bq.tables.list(project_id: @project_id, dataset_id: TEST_DATASET_ID).empty? }
+  end
+
+  test "patch table" do
+    create_table
+
+    table = @bq.tables.patch(
+      project_id: @project_id,
+      dataset_id: TEST_DATASET_ID,
+      table_id: TEST_TABLE_ID,
+      table: {
+        description: "hello world"
+      }
+    )
+
+    assert { "hello world" == table.description }
+  end
+
+  test "update table" do
+    schema = create_table.schema
+
+    table = @bq.tables.update(
+      project_id: @project_id,
+      dataset_id: TEST_DATASET_ID,
+      table_id: TEST_TABLE_ID,
+      table: {
+        schema: schema.tap { |hash| hash["fields"] << { name: "hoge", type: "STRING" }; break hash }
+      }
+    )
+
+    assert { table.schema["fields"].map { |field| field["name"] }.include? "hoge" }
+  end
+
+  private
+
+  def create_table
+    @bq.tables.insert(
+      project_id: @project_id,
+      dataset_id: TEST_DATASET_ID,
+      table: TEST_TABLE_INFO
+    )
+  end
+
+  def execute_query(sql)
+    job = @bq.jobs.query(project_id: @project_id, sql: sql)
+
+    begin
+      result = job.query_results
+    end until result["jobComplete"]
+
+    result
+  end
+end

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: yancya-big_query
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- yancya
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: google-api-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: test-unit
+  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: Google BigQuery API client library. This is simple wrapper.
+email:
+- yancya@upec.jp
+executables:
+- big_query
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- big_query.gemspec
+- bin/big_query
+- lib/yancya/big_query.rb
+- lib/yancya/big_query/dataset.rb
+- lib/yancya/big_query/datasets.rb
+- lib/yancya/big_query/initializer.rb
+- lib/yancya/big_query/job.rb
+- lib/yancya/big_query/jobs.rb
+- lib/yancya/big_query/project.rb
+- lib/yancya/big_query/projects.rb
+- lib/yancya/big_query/request_executor.rb
+- lib/yancya/big_query/table.rb
+- lib/yancya/big_query/tabledata.rb
+- lib/yancya/big_query/tables.rb
+- lib/yancya/big_query/version.rb
+- test/test_big_query.rb
+homepage: https://github.com/yancya/big_query
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Google BigQuery API client library.
+test_files:
+- test/test_big_query.rb