yancya-big_query 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6d5bd68e33c49a23f96f348b24d41aa9e2140af2
-  data.tar.gz: a4ae4adae7acf4754728e94ca31a9726239aa1ad
+  metadata.gz: 06183ec4fd4344c825bbc907b5e7ac62807cf921
+  data.tar.gz: 7bef7e5f244f514cb418503ab44f57448c5c1ff0
 SHA512:
-  metadata.gz: dcae7d1b73287106727ac1ebbf5a4e0f344ad6f981c78686f4ae47de33cda2b93fbf36a0e108a6052b56ad763f1e1eed93bf9af891589aafa94cf8f37a653025
-  data.tar.gz: aa6af3940f7b669a3b00a727cc75638f550f1fa4690bbfffb83fee0d145fb7c95142963d74865dfe84f4f5dda11c229ebcf4ea238f6b3fe593593422ad203ba4
+  metadata.gz: 2b25247ed836fc651980505d1b89270d91bd9b1207e91bad8f258d9e945419381001365b1cd5ef2bc45af96929bc1f6a5a4a7521658c073fd36e5f12b6773e23
+  data.tar.gz: a9fd32c9c007d101e9b221fee9e35ff5a78f7c6a3c49adac08e868ba704dc2a49a464e2df86e62dde8dd9343a4eacc41617a8a9cbb3d184db43034d357ed10cb

data/README.md

@@ -8,22 +8,20 @@ Google BigQuery API client library
 
 Add this line to your application's Gemfile:
 
-    gem 'big_query', github: "yancya/big_query"
+    gem 'yancya-big_query'
 
 And then execute:
 
     $ bundle
 
-Or build and install it yourself as:
+Or install it yourself as:
 
-    $ git clone git@github.com:yancya/big_query.git
-    $ cd big_query
-    $ rake install
+    $ gem install yancya-big_query
 
 ## Usage
 
 ```rb
-bq = BigQuery.new(
+bq = Yancya::BigQuery.new(
   key_path: "path_to_secret_key"
   issuer: "mail@address"
 )

data/lib/yancya/big_query/dataset.rb

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

data/lib/yancya/big_query/datasets.rb

@@ -1,63 +1,60 @@
-require_relative 'initializer'
-require_relative 'request_executor'
-
+require_relative 'resource'
 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
+  class BigQuery
+    class Datasets < Resource
+      def delete(project_id:, dataset_id:)
+        execute(
+          api_method: @bq.api.datasets.delete,
+          parameters: {projectId: project_id, datasetId: dataset_id, deleteContents: true}
+        )
+      end
 
-    def insert(project_id:, dataset:)
-      execute(
-        api_method: @bq.api.datasets.insert,
-        parameters: {projectId: project_id},
-        body_object: dataset
-      )
-    end
+      def get(project_id:, dataset_id:)
+        execute(
+          api_method: @bq.api.datasets.get,
+          parameters: {projectId: project_id, datasetId: dataset_id}
+        )
+      end
 
-    def list(project_id:)
-      resources = execute(
-        api_method: @bq.api.datasets.list,
-        parameters: {projectId: project_id}
-      )
+      def insert(project_id:, dataset:)
+        execute(
+          api_method: @bq.api.datasets.insert,
+          parameters: {projectId: project_id},
+          body_object: dataset
+        )
+      end
 
-      resources["datasets"].map{ |resource|
-        Yancya::BigQuery::Dataset.new(
-          resource: resource,
-          bq: @bq
+      def list(project_id:)
+        resources = execute(
+          api_method: @bq.api.datasets.list,
+          parameters: {projectId: project_id}
         )
-      }
-    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
+        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
-      )
+      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
 end

data/lib/yancya/big_query/job.rb

@@ -1,53 +1,82 @@
 module Yancya
-  class BigQuery::Job
-    def initialize(resource:, bq:)
-      @resource = resource
-      @jobs = BigQuery::Jobs.new(bq: bq)
-    end
+  class BigQuery
+    class 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 query_results
+        @jobs.get_query_results(
+          project_id: project_id,
+          job_id: job_id
+        ).tap do |qr|
+          if qr["pageToken"]
+            warn <<-TEXT
+ This is a slice in all results.
+ You have not took rest results.
+ Perhaps all_query_results is useful.
+            TEXT
+          end
+        end
+      end
 
-    def reload
-      @jobs.get(project_id: project_id, job_id: job_id)
-    end
+      # caution: This method might return huge results
+      def all_query_results
+        loop.reduce([]) do |ary, _|
+          ary.tap do |a|
+            a << @jobs.get_query_results(
+              project_id: project_id,
+              job_id: job_id,
+              page_token: (ary.last||{})["pageToken"]
+            )
+          end
 
-    def project_id
-      job_reference["projectId"]
-    end
+          if (ary.last||{})["pageToken"].nil?
+            break ary
+          else
+            ary
+          end
+        end
+      end
 
-    def job_id
-      job_reference["jobId"]
-    end
+      def reload
+        @jobs.get(project_id: project_id, job_id: job_id)
+      end
 
-    def query
-      (configuration["query"]||{})["query"]
-    end
+      def project_id
+        job_reference["projectId"]
+      end
 
-    def state
-      status["state"]
-    end
+      def job_id
+        job_reference["jobId"]
+      end
 
-    def errors
-      status["errors"]
-    end
+      def query
+        (configuration["query"]||{})["query"]
+      end
 
-    private
+      def state
+        status["state"]
+      end
 
-    def configuration
-      @resource["configuration"]
-    end
+      def errors
+        status["errors"]
+      end
 
-    def status
-      @resource["status"]
-    end
+      private
+
+      def configuration
+        @resource["configuration"]
+      end
+
+      def status
+        @resource["status"]
+      end
 
-    def job_reference
-      @resource["jobReference"]
+      def job_reference
+        @resource["jobReference"]
+      end
     end
   end
 end

data/lib/yancya/big_query/jobs.rb

@@ -1,61 +1,61 @@
-require 'json'
-
-require_relative 'initializer'
-require_relative 'request_executor'
+require_relative 'resource'
 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)
+  class BigQuery
+    class Jobs < Resource
+     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:, page_token: nil)
+       execute(
+         api_method: @bq.api.jobs.get_query_results,
+         parameters: {
+           projectId: project_id,
+           jobId: job_id,
+           pageToken: page_token
+         }
+       )
+     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
 end

data/lib/yancya/big_query/project.rb

@@ -3,30 +3,32 @@ require_relative 'datasets'
 require_relative 'request_executor'
 
 module Yancya
-  class BigQuery::Project
-    include RequestExecutor
+  class BigQuery
+    class 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 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 query(sql)
+        @jobs.query(project_id: project_id, sql: sql)
+      end
 
-    def jobs
-      @jobs.list(project_id: project_id)
-    end
+      def jobs
+        @jobs.list(project_id: project_id)
+      end
 
-    def datasets
-      @datasets.list(project_id: project_id)
-    end
+      def datasets
+        @datasets.list(project_id: project_id)
+      end
 
-    def project_id
-      @resource["projectReference"]["projectId"]
+      def project_id
+        @resource["projectReference"]["projectId"]
+      end
     end
   end
 end

data/lib/yancya/big_query/projects.rb

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

data/lib/yancya/big_query/request_executor.rb

@@ -1,12 +1,14 @@
+require 'json'
+
 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
 

data/lib/yancya/big_query/resource.rb

@@ -0,0 +1,13 @@
+require_relative 'request_executor'
+
+module Yancya
+  class BigQuery
+    class Resource
+      include RequestExecutor
+
+      def initialize(bq:)
+        @bq = bq
+      end
+    end
+  end
+end

data/lib/yancya/big_query/table.rb

@@ -1,67 +1,69 @@
 module Yancya
-  class BigQuery::Table
-    def initialize(resource:, tables:)
-      @resource = resource
-      @tables = tables
-    end
+  class BigQuery
+    class Table
+      def initialize(resource:, tables:)
+        @resource = resource
+        @tables = tables
+      end
 
-    def project_id
-      table_reference["projectId"]
-    end
+      def project_id
+        table_reference["projectId"]
+      end
 
-    def dataset_id
-      table_reference["datasetId"]
-    end
+      def dataset_id
+        table_reference["datasetId"]
+      end
 
-    def table_id
-      table_reference["tableId"]
-    end
+      def table_id
+        table_reference["tableId"]
+      end
 
-    def description
-      @resource["description"]
-    end
+      def description
+        @resource["description"]
+      end
 
-    def schema
-      @resource["schema"]
-    end
+      def schema
+        @resource["schema"]
+      end
 
-    def reload
-      @tables.get(
-        project_id: project_id,
-        dataset_id: dataset_id,
-        table_id: table_id
-      )
-    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 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 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
+      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"]
+      private
+      def table_reference
+        @resource["tableReference"]
+      end
     end
   end
 end

data/lib/yancya/big_query/tabledata.rb

@@ -1,37 +1,39 @@
 require_relative 'request_executor'
 
 module Yancya
-  class BigQuery::Tabledata
-    include RequestExecutor
+  class BigQuery
+    class 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 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 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
-        }
-      )
+      def list
+        execute(
+          api_method: @bq.api.tabledata.list,
+          parameters: {
+            datasetId: @dataset_id,
+            projectId: @project_id,
+            tableId: @table_id
+          }
+        )
+      end
     end
   end
 end

data/lib/yancya/big_query/tables.rb

@@ -1,90 +1,87 @@
-require_relative 'initializer'
-require_relative 'request_executor'
-
+require_relative 'resource'
 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
+  class BigQuery
+    class Tables < Resource
+      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,
-        }
-      )
+      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
+        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
-      )
+      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
+        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,
-        }
-      )
+      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)
+        (resources["tables"]||[]).map do |resource|
+          BigQuery::Table.new(resource: resource, tables: self)
+        end
       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
-      )
+      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
+        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
-      )
+      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)
+        BigQuery::Table.new(resource: resource, tables: self)
+      end
     end
   end
 end

data/lib/yancya/big_query/version.rb

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

data/test/test_big_query.rb

@@ -147,13 +147,28 @@ class TestBigQuery < Test::Unit::TestCase
       dataset_id: TEST_DATASET_ID,
       table_id: TEST_TABLE_ID,
       table: {
-        schema: schema.tap { |hash| hash["fields"] << { name: "hoge", type: "STRING" }; break hash }
+        schema: schema.tap { |hash| hash["fields"] << { name: "hoge", type: "STRING" } }
       }
     )
 
     assert { table.schema["fields"].map { |field| field["name"] }.include? "hoge" }
   end
 
+  test "all_query_results" do
+    job = @bq.jobs.query(project_id: @project_id, sql: <<-SQL)
+    SELECT 2 as a, 4 as b, 6 as c
+    SQL
+
+    begin
+      results = job.all_query_results
+      sleep(1)
+    end until results.first["jobComplete"]
+
+    assert do
+      "2,4,6" == results.first["rows"].map{|row| row["f"].map{|col| col["v"]}.join(",")}.first
+    end
+  end
+
   private
 
   def create_table
@@ -167,10 +182,14 @@ class TestBigQuery < Test::Unit::TestCase
   def execute_query(sql)
     job = @bq.jobs.query(project_id: @project_id, sql: sql)
 
-    begin
+    loop.each_with_index do |_, index|
+      raise 'Job timeout' if index > 60
+
       result = job.query_results
-    end until result["jobComplete"]
 
-    result
+      break result if result["jobComplete"]
+
+      sleep(1)
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yancya-big_query
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - yancya
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-11 00:00:00.000000000 Z
+date: 2015-07-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: google-api-client
@@ -86,12 +86,12 @@ files:
 - 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/resource.rb
 - lib/yancya/big_query/table.rb
 - lib/yancya/big_query/tabledata.rb
 - lib/yancya/big_query/tables.rb

data/lib/yancya/big_query/initializer.rb

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