class Voltdb::Client
Attributes
Public Class Methods
Factory of Voltdb::Client
@param config Voltdb::ClientConfig
@return Voltdb::Client
# File lib/voltdb/client.rb, line 18 def self.create_client(config) client = ClientFactory.create_client(config) self.new(client) end
# File lib/voltdb/client.rb, line 24 def initialize(java_client) @java_client = java_client end
Public Instance Methods
The method uses system procedure @GetPartitionKeys to get a set of partition values and then execute the stored procedure one partition at a time, and return an aggregated response. If a block is passed to the method an asyncronous call will be made
@param proc_name [String] proc_name the stored procedure name @param *param [Array<Object>] a list of params @return [ClientResponseWithPartitionKey, True, False] instances of
procedure call results
@raise [ProcCallException, NoConnectionsException, IOException]
# File lib/voltdb/client.rb, line 182 def call_all_partition_procedure(proc_name, *params, &block) if block_given? cb = AllPartitionProcCallback.new(&block) java_client.call_all_partition_procedure(cb, proc_name, *params_to_java_objects(*params)) else java_client.call_all_partition_procedure(proc_name, *params_to_java_objects(*params)).map do |partition| partition.response.extend(ClientResponseUtils) partition end end end
Invokes a voltdb stored procedure based on its procedure name, a list of params and a block only if an asynchronous call is required
@param proc_name [String] the stored procedure name @param *params [Array<Object>] a list of params @return [Java::OrgVoltdbClient::ClientResponse, True, False] Voltdb
client response if the procedure was called synchronously, else will return true if the procedure was properly queued or false if it was not
@raise [ProcCallException, NoConnectionsException, IOException]
ProcCallException will be returned if called synchronously
# File lib/voltdb/client.rb, line 38 def call_procedure(proc_name, *params, &block) if block_given? cb = ProcCallback.new(&block) java_client.call_procedure(cb, proc_name, *params_to_java_objects(*params)) else response = java_client.call_procedure(proc_name, *params_to_java_objects(*params)) response.extend(ClientResponseUtils) response end end
Invokes a voltdb stored procedure with an specific timeout a procedure name, a list of params and a block only if an asynchronous call is required
@param query_timeout [Fixnum] the stored procedure timeout @param proc_name [String] the stored procedure name @param *params [Array<Object>] a list of params @return [Java::OrgVoltdbClient::ClientResponse, True, False] Voltdb
client response if the procedure was called synchronously, else will return true if the procedure was properly queued or false if it was not
@raise [ProcCallException, NoConnectionsException, IOException]
ProcCallException will be returned if called synchronously
# File lib/voltdb/client.rb, line 61 def call_procedure_with_timeout(query_timeout, proc_name, *params, &block) if block_given? cb = ProcCallback.new(&block) java_client.call_procedure_with_timeout(cb, query_timeout, proc_name, *params_to_java_objects(*params)) else response = java_client.call_procedure_with_timeout(query_timeout, proc_name, *params_to_java_objects(*params)) response.extend(ClientResponseUtils) response end end
Get the list of VoltDB server hosts that this client has open TCP connections to
@return [Array<InetSocketAddress>] An list of InetSocketAddress
representing the connected hosts
# File lib/voltdb/client.rb, line 147 def get_connected_host_list java_client.get_connected_host_list.to_ary end
Get an identifier for the cluster that this client is currently connected to. This will be null if the client has not been connected. Currently these values have logical meaning, but they should just be interpreted as a unique per-cluster value
@return [Array<Fixnum>] An array of Fixnum containing the millisecond
timestamp when the cluster was started and the leader IP address
# File lib/voltdb/client.rb, line 130 def get_instance_id java_client.get_instance_id.to_ary end
Creates a new instance of a VoltBulkLoader that is bound to this Client
. Multiple instances of a VoltBulkLoader created by a single Client
will share some resources, particularly if they are inserting into the same table
@param table_name [String] that bulk inserts are to be applied to @param max_batch_size [Fixnum] to collect for the table before pushing a
bulk insert
@param [Boolean] upsert true if want upsert instead of insert @return [VoltBulkLoader] @raise [Exception] if tableName can't be found in the catalog
# File lib/voltdb/client.rb, line 162 def get_new_bulk_loader(table_name, max_batch_size, upsert, &block) cb = BulkLoaderFailureCallback.new(&block) if upsert java_client.get_new_bulk_loader(table_name, max_batch_size, upsert, cb) else java_client.get_new_bulk_loader(table_name, max_batch_size, cb) end end
Get the instantaneous values of the rate limiting values for this client
@return [Array<Fixnum>] Array of Fixnum representing max throughput/sec
and max outstanding txns
# File lib/voltdb/client.rb, line 138 def get_throughput_and_outstanding_txn_limits java_client.get_throughput_and_outstanding_txn_limits.to_ary end
This method is a convenience method that is equivalent to reading the catalog file into a byte array in Java code, then calling call_procedure
with “@UpdateApplicationCatalog” as the procedure name, followed by they bytes of the catalog and the string value of the deployment file. If a block is passed to the method an asyncronous call will be made
@param catalog_path [String] the path to the voltdb catalog @param deployment_path [String] deployment_path the path to the
deployment.xml file
@return [Java::OrgVoltdbClient::ClientResponse, True, False] Voltdb
client response if the procedure was called synchronously, else will return true if the procedure was properly queued or false if it was not
@raise [ProcCallException, NoConnectionsException, IOException]
ProcCallException will be returned if called synchronously
# File lib/voltdb/client.rb, line 86 def update_application_catalog(catalog_path, deployment_path, &block) if block_given? cb = ProcCallback.new(&block) java_client.update_application_catalog(cb, catalog_path, deployment_path) else response = java_client.update_application_catalog(catalog_path, deployment_path) response.extend(ClientResponseUtils) response end end
This method is a convenience method that is equivalent to reading a jarfile containing to be added/updated into a byte array in Java code, then calling call_procedure
with “@UpdateClasses” as the procedure name, followed by the bytes of the jarfile and a string containing a comma-separates list of classes to delete from the catalog.If a block is passed to the method an asyncronous call will be made
@param jar_path [String] path to the jar file with new/update clases @param classes_to_delete [String,String] comma-separated list of classes
to delete
@return [Java::OrgVoltdbClient::ClientResponse, True, False] Voltdb
client response if the procedure was called synchronously, else will return true if the procedure was properly queued or false if it was not
@raise [ProcCallException, NoConnectionsException, IOException]
ProcCallException will be returned if called synchronously
# File lib/voltdb/client.rb, line 112 def update_classes(jar_path, classes_to_delete, &block) if block_given? cb = ProcCallback.new(&block) java_client.update_classes(cb, jar_path, classes_to_delete) else response = java_client.update_classes(jar_path, classes_to_delete) response.extend(ClientResponseUtils) response end end