td-client 0.8.68 → 0.8.69

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a6f4ce3a275f3c038d731feb43dda2ec4cc477e5
-  data.tar.gz: b6affcd7ad8e6430af814d9459cfbabde9ae50f9
+  metadata.gz: cce938755d8baa274b4129395cc3bf025852123d
+  data.tar.gz: 251fa5c0007d67a8bcbae03f01f31d7748a2654d
 SHA512:
-  metadata.gz: 3127bd887d7fff303cde39f92932d8d9a263cfb37201e3c299a24e53a3767390a70ce4195fe34ce9003ecd815465a0776e3e094cc1c35d3da37f181bc4273c98
-  data.tar.gz: d002d279379a09a63c10882503cf09f6d25d7e3d12198281c55e82881d8f1ef5a7e2ca2af3cb66856b89d8056667da7003a5172f91d424e87fba8a1c625ddcdf
+  metadata.gz: ebe285884532e4683d0ca58db039433d5f53fd5cf047db0318ceb93230f0bf0b151fd1f5bd321bbfc55f23784ecd4650764fa57019ec3b6e8d8762a74b6486e1
+  data.tar.gz: d37ce150f9a65d5d5a5231c4d277cd1867f193e0c9dec8c5920424faa67acfa75ff5e0e114130156ebc6db991af4eb58b6095784c5afc8cb0124724180ffb687

data/lib/td/client.rb

@@ -5,53 +5,70 @@ require 'td/client/model'
 
 
 class Client
+  # @param [String] user TreasureData username
+  # @param [String] password TreasureData password
+  # @param [Hash] opts options for API
+  # @return [Client] instance of this class
   def self.authenticate(user, password, opts={})
     api = API.new(nil, opts)
     apikey = api.authenticate(user, password)
     new(apikey)
   end
 
+  # @param [Hash] opts options for API
+  # @return [String] HTTP status code of server returns
   def self.server_status(opts={})
     api = API.new(nil, opts)
     api.server_status
   end
 
+  # @param [String] apikey TreasureData API key
+  # @param [Hash] opts options for API
   def initialize(apikey, opts={})
     @api = API.new(apikey, opts)
   end
 
+  # @!attribute [r] api
   attr_reader :api
 
+  # @return [String] API key
   def apikey
     @api.apikey
   end
 
+  # @return [String] HTTP status code of server returns
   def server_status
     @api.server_status
   end
 
-  # => true
+  # @param [String] db_name
+  # @param [Hash] opts
+  # @return [true]
   def create_database(db_name, opts={})
     @api.create_database(db_name, opts)
   end
 
-  # => true
+  # @param [String] db_name
+  # @return [Symbol]
   def delete_database(db_name)
     @api.delete_database(db_name)
   end
 
-  # => Account
+  # @return [Account]
   def account
     account_id, plan, storage, guaranteed_cores, maximum_cores, created_at = @api.show_account
     return Account.new(self, account_id, plan, storage, guaranteed_cores, maximum_cores, created_at)
   end
 
+  # @param [Fixnum] from
+  # @param [Fixnum] to
+  # @return [Array] from, to, interval, history
   def core_utilization(from, to)
     from, to, interval, history = @api.account_core_utilization(from, to)
     return from, to, interval, history
   end
 
-  # => [Database]
+  # @return [Array] databases
   def databases
     m = @api.list_databases
     m.map {|db_name,(count, created_at, updated_at, org, permission)|
@@ -59,7 +76,8 @@ class Client
     }
   end
 
-  # => Database
+  # @param [String] db_name
+  # @return [Database]
   def database(db_name)
     m = @api.list_databases
     m.each {|name,(count, created_at, updated_at, org, permission)|
@@ -70,37 +88,55 @@ class Client
     raise NotFoundError, "Database '#{db_name}' does not exist"
   end
 
-  # => true
+  # @return [true]
   def create_log_table(db_name, table_name)
     @api.create_log_table(db_name, table_name)
   end
 
-  # => true
+  # @param [String] db_name
+  # @param [String] table_name
+  # @param [String] primary_key
+  # @param [String] primary_key_type
+  # @return [true]
   def create_item_table(db_name, table_name, primary_key, primary_key_type)
     @api.create_item_table(db_name, table_name, primary_key, primary_key_type)
   end
 
-  # => true
+  # Swap table names
+  #
+  # @param [String] db_name
+  # @param [String] table_name1
+  # @param [String] table_name2
+  # @return [true]
   def swap_table(db_name, table_name1, table_name2)
     @api.swap_table(db_name, table_name1, table_name2)
   end
 
-  # => true
+  # @param [String] db_name
+  # @param [String] table_name
+  # @param [String] schema
+  # @return [true]
   def update_schema(db_name, table_name, schema)
     @api.update_schema(db_name, table_name, schema.to_json)
   end
 
-  # => true
+  # @param [String] db_name
+  # @param [String] table_name
+  # @param [Fixnum] expire_days
+  # @return [true]
   def update_expire(db_name, table_name, expire_days)
     @api.update_expire(db_name, table_name, expire_days)
   end
 
-  # => type:Symbol
+  # @param [String] db_name
+  # @param [String] table_name
+  # @return [Symbol]
   def delete_table(db_name, table_name)
     @api.delete_table(db_name, table_name)
   end
 
-  # => [Table]
+  # @param [String] db_name
+  # @return [Array] Tables
   def tables(db_name)
     m = @api.list_tables(db_name)
     m.map {|table_name, (type, schema, count, created_at, updated_at, estimated_storage_size, last_import, last_log_timestamp, expire_days, primary_key, primary_key_type)|
@@ -110,7 +146,9 @@ class Client
     }
   end
 
-  # => Table
+  # @param [String] db_name
+  # @param [String] table_name
+  # @return [Table]
   def table(db_name, table_name)
     tables(db_name).each {|t|
       if t.name == table_name
@@ -120,11 +158,24 @@ class Client
     raise NotFoundError, "Table '#{db_name}.#{table_name}' does not exist"
   end
 
+  # @param [String] db_name
+  # @param [String] table_name
+  # @param [Fixnum] count
+  # @param [Fixnum] to
+  # @param [Fixnum] from
+  # @param [Proc] block
+  # @return [Array, nil]
   def tail(db_name, table_name, count, to=nil, from=nil, &block)
     @api.tail(db_name, table_name, count, to, from, &block)
   end
 
-  # => Job
+  # @param [String] db_name
+  # @param [String] q
+  # @param [String] result_url
+  # @param [Fixnum] priority
+  # @param [Fixnum] retry_limit
+  # @param [Hash] opts
+  # @return [Job]
   def query(db_name, q, result_url=nil, priority=nil, retry_limit=nil, opts={})
     # for compatibility, assume type is hive unless specifically specified
     type = opts[:type] || opts['type'] || :hive
@@ -133,7 +184,11 @@ class Client
     Job.new(self, job_id, type, q)
   end
 
-  # => [Job]
+  # @param [Fixnum] from
+  # @param [Fixnum] to
+  # @param [String] status
+  # @param [Hash] conditions
+  # @return [Job]
   def jobs(from=nil, to=nil, status=nil, conditions=nil)
     results = @api.list_jobs(from, to, status, conditions)
     results.map {|job_id, type, status, query, start_at, end_at, cpu_time,
@@ -143,7 +198,8 @@ class Client
     }
   end
 
-  # => Job
+  # @param [String] job_id
+  # @return [Job]
   def job(job_id)
     job_id = job_id.to_s
     type, query, status, url, debug, start_at, end_at, cpu_time,
@@ -152,112 +208,154 @@ class Client
             result_size, nil, result_url, hive_result_schema, priority, retry_limit, org, db)
   end
 
-  # => status:String
+  # @param [String] job_id
+  # @return [String] HTTP status code
   def job_status(job_id)
     return @api.job_status(job_id)
   end
 
-  # => result:[{column:String=>value:Object]
+  # @param [String] job_id
+  # @return [Object]
   def job_result(job_id)
     @api.job_result(job_id)
   end
 
-  # => result:String
+  # @param [String] job_id
+  # @param [String] format
+  # @param [IO] io
+  # @param [Proc] block
+  # @return [String]
   def job_result_format(job_id, format, io=nil, &block)
     @api.job_result_format(job_id, format, io, &block)
   end
 
-  # => nil
+  # @param [String] job_id
+  # @param [Proc] block
+  # @return [nil]
   def job_result_each(job_id, &block)
     @api.job_result_each(job_id, &block)
   end
 
-  # => nil
+  # @param [String] job_id
+  # @param [Proc] block
+  # @return [nil]
   def job_result_each_with_compr_size(job_id, &block)
     @api.job_result_each_with_compr_size(job_id, &block)
   end
 
-  # => former_status:String
+  # @param [String] job_id
+  # @return [String] former_status
   def kill(job_id)
     @api.kill(job_id)
   end
 
-  # => Job
+  # @param [String] db_name
+  # @param [String] table_name
+  # @param [String] storage_type
+  # @param [Hash] opts
+  # @return [Job]
   def export(db_name, table_name, storage_type, opts={})
     job_id = @api.export(db_name, table_name, storage_type, opts)
     Job.new(self, job_id, :export, nil)
   end
 
-  # => Job
+  # @param [String] db_name
+  # @param [String] table_name
+  # @param [Fixnum] to
+  # @param [Fixnum] from
+  # @param [Hash] opts
+  # @return [Job]
   def partial_delete(db_name, table_name, to, from, opts={})
     job_id = @api.partial_delete(db_name, table_name, to, from, opts)
     Job.new(self, job_id, :partialdelete, nil)
   end
 
-  # => nil
+  # @param [String] name
+  # @param [String] database
+  # @param [String] table
+  # @param [Hash] opts
+  # @return [nil]
   def create_bulk_import(name, database, table, opts={})
     @api.create_bulk_import(name, database, table, opts)
   end
 
-  # => nil
+  # @param [String] name
+  # @return [nil]
   def delete_bulk_import(name)
     @api.delete_bulk_import(name)
   end
 
-  # => nil
+  # @param [String] name
+  # @return [nil]
   def freeze_bulk_import(name)
     @api.freeze_bulk_import(name)
   end
 
-  # => nil
+  # @param [String] name
+  # @return [nil]
   def unfreeze_bulk_import(name)
     @api.unfreeze_bulk_import(name)
   end
 
-  # => Job
+  # @param [String] name
+  # @return [Job]
   def perform_bulk_import(name)
     job_id = @api.perform_bulk_import(name)
     Job.new(self, job_id, :bulk_import, nil)
   end
 
-  # => nil
+  # @param [String] name
+  # @return [nil]
   def commit_bulk_import(name)
     @api.commit_bulk_import(name)
   end
 
-  # => records:[row:Hash]
+  # @param [String] name
+  # @param [Proc] block
+  # @return [Hash]
   def bulk_import_error_records(name, &block)
     @api.bulk_import_error_records(name, &block)
   end
 
-  # => BulkImport
+  # @param [String] name
+  # @return [BulkImport]
   def bulk_import(name)
     data = @api.show_bulk_import(name)
     BulkImport.new(self, data)
   end
 
-  # => [BulkImport]
+  # @return [Array<BulkImport>]
   def bulk_imports
     @api.list_bulk_imports.map {|data|
       BulkImport.new(self, data)
     }
   end
 
-  # => nil
+  # @param [String] name
+  # @param [String] part_name
+  # @param [String, StringIO] stream
+  # @param [Fixnum] size
+  # @return [nil]
   def bulk_import_upload_part(name, part_name, stream, size)
     @api.bulk_import_upload_part(name, part_name, stream, size)
   end
 
-  # => nil
+  # @param [String] name
+  # @param [String] part_name
+  # @return [nil]
   def bulk_import_delete_part(name, part_name)
     @api.bulk_import_delete_part(name, part_name)
   end
 
+  # @param [String] name
+  # @return [Array]
   def list_bulk_import_parts(name)
     @api.list_bulk_import_parts(name)
   end
 
-  # => first_time:Time
+  # @param [String] name
+  # @param [Hash] opts
+  # @return [Time]
   def create_schedule(name, opts)
     raise ArgumentError, "'cron' option is required" unless opts[:cron] || opts['cron']
     raise ArgumentError, "'query' option is required" unless opts[:query] || opts['query']
@@ -265,12 +363,13 @@ class Client
     return Time.parse(start)
   end
 
-  # => true
+  # @param [String] name
+  # @return [Array]
   def delete_schedule(name)
     @api.delete_schedule(name)
   end
 
-  # [Schedule]
+  # @return [Array<Schedule>]
   def schedules
     result = @api.list_schedules
     result.map {|name,cron,query,database,result_url,timezone,delay,next_time,priority,retry_limit,org_name|
@@ -278,12 +377,18 @@ class Client
     }
   end
 
+  # @param [String] name
+  # @param [Hash] params
+  # @return [nil]
   def update_schedule(name, params)
     @api.update_schedule(name, params)
     nil
   end
 
-  # [ScheduledJob]
+  # @param [String] name
+  # @param [Fixnum] from
+  # @param [Fixnum] to
+  # @return [Array<ScheduledJob>]
   def history(name, from=nil, to=nil)
     result = @api.history(name, from, to)
     result.map {|scheduled_at,job_id,type,status,query,start_at,end_at,result_url,priority,database|
@@ -302,7 +407,10 @@ class Client
     }
   end
 
-  # [ScheduledJob]
+  # @param [String] name
+  # @param [Fixnum] time UNIX timestamp
+  # @param [Fixnum] num
+  # @return [Array<ScheduledJob>]
   def run_schedule(name, time, num)
     results = @api.run_schedule(name, time, num)
     results.map {|job_id,type,scheduled_at|
@@ -310,12 +418,18 @@ class Client
     }
   end
 
-  # => time:Flaot
+  # @param [String] db_name
+  # @param [String] table_name
+  # @param [String] format
+  # @param [String, StringIO] stream
+  # @param [Fixnum] size
+  # @param [String] unique_id
+  # @return [Float]
   def import(db_name, table_name, format, stream, size, unique_id=nil)
     @api.import(db_name, table_name, format, stream, size, unique_id)
   end
 
-  # => [Result]
+  # @return [Array<Result>]
   def results
     results = @api.list_result
     rs = results.map {|name,url,organizations|
@@ -324,17 +438,21 @@ class Client
     return rs
   end
 
-  # => true
+  # @param [String] name
+  # @param [String] url
+  # @param [Hash] opts
+  # @return [true]
   def create_result(name, url, opts={})
     @api.create_result(name, url, opts)
   end
 
-  # => true
+  # @param [String] name
+  # @return [true]
   def delete_result(name)
     @api.delete_result(name)
   end
 
-  # => [User]
+  # @return [Array<User>]
   def users
     list = @api.list_users
     list.map {|name,org,roles,email|
@@ -342,47 +460,62 @@ class Client
     }
   end
 
-  # => true
+  # @param [String] name
+  # @param [String] org
+  # @param [String] email
+  # @param [String] password
+  # @return [true]
   def add_user(name, org, email, password)
     @api.add_user(name, org, email, password)
   end
 
-  # => true
+  # @param [String] user
+  # @return [true]
   def remove_user(user)
     @api.remove_user(user)
   end
 
-  # => true
+  # @param [String] user
+  # @param [String] email
+  # @return [true]
   def change_email(user, email)
     @api.change_email(user, email)
   end
 
-  # => [apikey:String]
+  # @param [String] user
+  # @return [Array<String>]
   def list_apikeys(user)
     @api.list_apikeys(user)
   end
 
-  # => true
+  # @param [String] user
+  # @return [true]
   def add_apikey(user)
     @api.add_apikey(user)
   end
 
-  # => true
+  # @param [String] user
+  # @param [String] apikey
+  # @return [true]
   def remove_apikey(user, apikey)
     @api.remove_apikey(user, apikey)
   end
 
-  # => true
+  # @param [String] user
+  # @param [String] password
+  # @return [true]
   def change_password(user, password)
     @api.change_password(user, password)
   end
 
-  # => true
+  # @param [String] old_password
+  # @param [String] password
+  # @return [true]
   def change_my_password(old_password, password)
     @api.change_my_password(old_password, password)
   end
 
-  # => [User]
+  # @return [Array<AccessControl>]
   def access_controls
     list = @api.list_access_controls
     list.map {|subject,action,scope,grant_option|
@@ -390,20 +523,80 @@ class Client
     }
   end
 
-  # => true
+  # @param [String] subject
+  # @param [String] action
+  # @param [String] scope
+  # @param [Array] grant_option
+  # @return [true]
   def grant_access_control(subject, action, scope, grant_option)
     @api.grant_access_control(subject, action, scope, grant_option)
   end
 
-  # => true
+  # @param [String] subject
+  # @param [String] action
+  # @param [String] scope
+  # @return [true]
   def revoke_access_control(subject, action, scope)
     @api.revoke_access_control(subject, action, scope)
   end
 
-  # => true
+  # @param [String] user
+  # @param [String] action
+  # @param [String] scope
+  # @return [Array]
   def test_access_control(user, action, scope)
     @api.test_access_control(user, action, scope)
   end
+
+  # => BulkLoad::Job
+  def bulk_load_guess(job)
+    @api.bulk_load_guess(job)
+  end
+
+  # => BulkLoad::Job
+  def bulk_load_preview(job)
+    @api.bulk_load_preview(job)
+  end
+
+  # => String
+  def bulk_load_issue(database, table, job)
+    @api.bulk_load_issue(database, table, job)
+  end
+
+  # nil -> [BulkLoad]
+  def bulk_load_list
+    @api.bulk_load_list
+  end
+
+  # name: String, database: String, table: String, job: BulkLoad -> BulkLoad
+  def bulk_load_create(name, database, table, job, opts = {})
+    @api.bulk_load_create(name, database, table, job, opts)
+  end
+
+  # name: String -> BulkLoad
+  def bulk_load_show(name)
+    @api.bulk_load_show(name)
+  end
+
+  # name: String, job: BulkLoad -> BulkLoad
+  def bulk_load_update(name, job)
+    @api.bulk_load_update(name, job)
+  end
+
+  # name: String -> BulkLoad
+  def bulk_load_delete(name)
+    @api.bulk_load_delete(name)
+  end
+
+  # name: String -> [Job]
+  def bulk_load_history(name)
+    @api.bulk_load_history(name)
+  end
+
+  def bulk_load_run(name, scheduled_time = nil)
+    @api.bulk_load_run(name, scheduled_time)
+  end
+
 end
 
 end # module TreasureData