Class List Method List File List

# Class: VertxSql::SQLConnection

Inherits:
  Object
  - Object
  - VertxSql::SQLConnection
  show all
Includes:
  SQLOperations
Defined in:
  /Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-sql/sql_connection.rb

## Overview

Represents a connection to a SQL database

## Constant Summary

@@j_api_type =

      Object.new

## Class Method Summary (collapse)

- + (Boolean) accept?(obj)
- + (Object) j_api_type
- + (Object) j_class
- + (Object) unwrap(obj)
- + (Object) wrap(obj)

## Instance Method Summary (collapse)

- - (self) batch(sqlStatements = nil) { ... }
  Batch simple SQL strings and execute the batch where the async result contains a array of Integers.
- - (self) batch_callable_with_params(sqlStatement = nil, inArgs = nil, outArgs = nil) { ... }
  Batch a callable statement with all entries from the args list.
- - (self) batch_with_params(sqlStatement = nil, args = nil) { ... }
  Batch a prepared statement with all entries from the args list.
- - (self) call(sql = nil) { ... }
  Calls the given SQL PROCEDURE which returns the result from the procedure.
- - (self) call_with_params(sql = nil, params = nil, outputs = nil) { ... }
  Calls the given SQL PROCEDURE which returns the result from the procedure.
- - (void) close { ... }
  Closes the connection.
- - (self) commit { ... }
  Commits all changes made since the previous commit/rollback.
- - (self) execute(sql = nil) { ... }
  Executes the given SQL statement.
- - (self) get_transaction_isolation { ... }
  Attempts to return the transaction isolation level for this Connection object to the one given.
- - (self) query(sql = nil) { ... }
  Executes the given SQL SELECT statement which returns the results of the query.
- - (self) query_single(sql = nil) { ... }
  Execute a one shot SQL statement that returns a single SQL row.
- - (self) query_single_with_params(sql = nil, arguments = nil) { ... }
  Execute a one shot SQL statement with arguments that returns a single SQL row.
- - (self) query_stream(sql = nil) { ... }
  Executes the given SQL SELECT statement which returns the results of the query as a read stream.
- - (self) query_stream_with_params(sql = nil, params = nil) { ... }
  Executes the given SQL SELECT statement which returns the results of the query as a read stream.
- - (self) query_with_params(sql = nil, params = nil) { ... }
  Executes the given SQL SELECT prepared statement which returns the results of the query.
- - (self) rollback { ... }
  Rolls back all changes made since the previous commit/rollback.
- - (self) set_auto_commit(autoCommit = nil) { ... }
  Sets the auto commit flag for this connection.
- - (self) set_options(options = nil)
  Sets the desired options to be applied to the current connection when statements are executed.
- - (self) set_query_timeout(timeoutInSeconds = nil)
  Sets a connection wide query timeout.
- - (self) set_transaction_isolation(isolation = nil) { ... }
  Attempts to change the transaction isolation level for this Connection object to the one given.
- - (self) update(sql = nil) { ... }
  Executes the given SQL statement which may be an INSERT, UPDATE, or DELETE statement.
- - (self) update_with_params(sql = nil, params = nil) { ... }
  Executes the given prepared statement which may be an INSERT, UPDATE, or DELETE statement with the given parameters.

## Class Method Details

### + (`Boolean`) accept?(obj)

Returns:

- (`Boolean`)

    20
    21
    22
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-sql/sql_connection.rb', line 20

    def @@j_api_type.accept?(obj)
      obj.class == SQLConnection
    end

### + (`Object`) j_api_type

    29
    30
    31
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-sql/sql_connection.rb', line 29

    def self.j_api_type
      @@j_api_type
    end

### + (`Object`) j_class

    32
    33
    34
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-sql/sql_connection.rb', line 32

    def self.j_class
      Java::IoVertxExtSql::SQLConnection.java_class
    end

### + (`Object`) unwrap(obj)

    26
    27
    28
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-sql/sql_connection.rb', line 26

    def @@j_api_type.unwrap(obj)
      obj.j_del
    end

### + (`Object`) wrap(obj)

    23
    24
    25
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-sql/sql_connection.rb', line 23

    def @@j_api_type.wrap(obj)
      SQLConnection.new(obj)
    end

## Instance Method Details

### - (`self`) batch(sqlStatements = nil) { ... }

Batch simple SQL strings and execute the batch where the async result contains a array of Integers.

Parameters:

- sqlStatements (`Array<String>`) (defaults to: `nil`) —
  sql statement

Yields:

- the result handler

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    250
    251
    252
    253
    254
    255
    256
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-sql/sql_connection.rb', line 250

    def batch(sqlStatements=nil)
      if sqlStatements.class == Array && block_given?
        @j_del.java_method(:batch, [Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(sqlStatements.map { |element| element },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result.to_a.map { |elt| elt } : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling batch(#{sqlStatements})"
    end

### - (`self`) batch_callable_with_params(sqlStatement = nil, inArgs = nil, outArgs = nil) { ... }

Batch a callable statement with all entries from the args list. Each entry is a batch. The size of the lists inArgs and outArgs MUST be the equal. The operation completes with the execution of the batch where the async result contains a array of Integers.

Parameters:

- sqlStatement (`String`) (defaults to: `nil`) —
  sql statement
- inArgs (`Array<Array<String,Object>>`) (defaults to: `nil`) —
  the callable statement input arguments
- outArgs (`Array<Array<String,Object>>`) (defaults to: `nil`) —
  the callable statement output arguments

Yields:

- the result handler

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    278
    279
    280
    281
    282
    283
    284
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-sql/sql_connection.rb', line 278

    def batch_callable_with_params(sqlStatement=nil,inArgs=nil,outArgs=nil)
      if sqlStatement.class == String && inArgs.class == Array && outArgs.class == Array && block_given?
        @j_del.java_method(:batchCallableWithParams, [Java::java.lang.String.java_class,Java::JavaUtil::List.java_class,Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(sqlStatement,inArgs.map { |element| ::Vertx::Util::Utils.to_json_array(element) },outArgs.map { |element| ::Vertx::Util::Utils.to_json_array(element) },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result.to_a.map { |elt| elt } : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling batch_callable_with_params(#{sqlStatement},#{inArgs},#{outArgs})"
    end

### - (`self`) batch_with_params(sqlStatement = nil, args = nil) { ... }

Batch a prepared statement with all entries from the args list. Each entry is a batch. The operation completes with the execution of the batch where the async result contains a array of Integers.

Parameters:

- sqlStatement (`String`) (defaults to: `nil`) —
  sql statement
- args (`Array<Array<String,Object>>`) (defaults to: `nil`) —
  the prepared statement arguments

Yields:

- the result handler

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    263
    264
    265
    266
    267
    268
    269
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-sql/sql_connection.rb', line 263

    def batch_with_params(sqlStatement=nil,args=nil)
      if sqlStatement.class == String && args.class == Array && block_given?
        @j_del.java_method(:batchWithParams, [Java::java.lang.String.java_class,Java::JavaUtil::List.java_class,Java::IoVertxCore::Handler.java_class]).call(sqlStatement,args.map { |element| ::Vertx::Util::Utils.to_json_array(element) },(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result.to_a.map { |elt| elt } : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling batch_with_params(#{sqlStatement},#{args})"
    end

### - (`self`) call(sql = nil) { ... }

Calls the given SQL `PROCEDURE` which returns the result from the procedure.

Parameters:

- sql (`String`) (defaults to: `nil`) —
  the SQL to execute. For example `{call getEmpName}`.

Yields:

- the handler which is called once the operation completes. It will return a `ResultSet`.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    175
    176
    177
    178
    179
    180
    181
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-sql/sql_connection.rb', line 175

    def call(sql=nil)
      if sql.class == String && block_given?
        @j_del.java_method(:call, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(sql,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.toJson.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling call(#{sql})"
    end

### - (`self`) call_with_params(sql = nil, params = nil, outputs = nil) { ... }

Calls the given SQL `PROCEDURE` which returns the result from the procedure. The index of params and outputs are important for both arrays, for example when dealing with a prodecure that takes the first 2 arguments as input values and the 3 arg as an output then the arrays should be like:

       params = [VALUE1, VALUE2, null]
       outputs = [null, null, "VARCHAR"]

Parameters:

- sql (`String`) (defaults to: `nil`) —
  the SQL to execute. For example `{call getEmpName (?, ?)}`.
- params (`Array<String,Object>`) (defaults to: `nil`) —
  these are the parameters to fill the statement.
- outputs (`Array<String,Object>`) (defaults to: `nil`) —
  these are the outputs to fill the statement.

Yields:

- the handler which is called once the operation completes. It will return a `ResultSet`.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    196
    197
    198
    199
    200
    201
    202
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-sql/sql_connection.rb', line 196

    def call_with_params(sql=nil,params=nil,outputs=nil)
      if sql.class == String && params.class == Array && outputs.class == Array && block_given?
        @j_del.java_method(:callWithParams, [Java::java.lang.String.java_class,Java::IoVertxCoreJson::JsonArray.java_class,Java::IoVertxCoreJson::JsonArray.java_class,Java::IoVertxCore::Handler.java_class]).call(sql,::Vertx::Util::Utils.to_json_array(params),::Vertx::Util::Utils.to_json_array(outputs),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.toJson.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling call_with_params(#{sql},#{params},#{outputs})"
    end

### - (`void`) close { ... }

This method returns an undefined value.

Closes the connection. Important to always close the connection when you are done so it's returned to the pool.

Yields:

- the handler called when this operation completes.

Raises:

- (`ArgumentError`)

    206
    207
    208
    209
    210
    211
    212
    213
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-sql/sql_connection.rb', line 206

    def close
      if !block_given?
        return @j_del.java_method(:close, []).call()
      elsif block_given?
        return @j_del.java_method(:close, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
      end
      raise ArgumentError, "Invalid arguments when calling close()"
    end

### - (`self`) commit { ... }

Commits all changes made since the previous commit/rollback.

Yields:

- the handler called when this operation completes.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    217
    218
    219
    220
    221
    222
    223
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-sql/sql_connection.rb', line 217

    def commit
      if block_given?
        @j_del.java_method(:commit, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling commit()"
    end

### - (`self`) execute(sql = nil) { ... }

Executes the given SQL statement

Parameters:

- sql (`String`) (defaults to: `nil`) —
  the SQL to execute. For example `CREATE TABLE IF EXISTS table ...`

Yields:

- the handler which is called once this operation completes.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    93
    94
    95
    96
    97
    98
    99
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-sql/sql_connection.rb', line 93

    def execute(sql=nil)
      if sql.class == String && block_given?
        @j_del.java_method(:execute, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(sql,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling execute(#{sql})"
    end

### - (`self`) get_transaction_isolation { ... }

Attempts to return the transaction isolation level for this Connection object to the one given.

Yields:

- the handler called when this operation completes.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    301
    302
    303
    304
    305
    306
    307
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-sql/sql_connection.rb', line 301

    def get_transaction_isolation
      if block_given?
        @j_del.java_method(:getTransactionIsolation, [Java::IoVertxCore::Handler.java_class]).call(nil)
        return self
      end
      raise ArgumentError, "Invalid arguments when calling get_transaction_isolation()"
    end

### - (`self`) query(sql = nil) { ... }

Executes the given SQL `SELECT` statement which returns the results of the query.

Parameters:

- sql (`String`) (defaults to: `nil`) —
  the SQL to execute. For example `SELECT * FROM table ...`.

Yields:

- the handler which is called once the operation completes. It will return a `ResultSet`.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    104
    105
    106
    107
    108
    109
    110
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-sql/sql_connection.rb', line 104

    def query(sql=nil)
      if sql.class == String && block_given?
        @j_del.java_method(:query, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(sql,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.toJson.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling query(#{sql})"
    end

### - (`self`) query_single(sql = nil) { ... }

Execute a one shot SQL statement that returns a single SQL row. This method will reduce the boilerplate code by getting a connection from the pool (this object) and return it back after the execution. Only the first result from the result set is returned.

Parameters:

- sql (`String`) (defaults to: `nil`) —
  the statement to execute

Yields:

- the result handler

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    41
    42
    43
    44
    45
    46
    47
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-sql/sql_connection.rb', line 41

    def query_single(sql=nil)
      if sql.class == String && block_given?
        @j_del.java_method(:querySingle, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(sql,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling query_single(#{sql})"
    end

### - (`self`) query_single_with_params(sql = nil, arguments = nil) { ... }

Execute a one shot SQL statement with arguments that returns a single SQL row. This method will reduce the boilerplate code by getting a connection from the pool (this object) and return it back after the execution. Only the first result from the result set is returned.

Parameters:

- sql (`String`) (defaults to: `nil`) —
  the statement to execute
- arguments (`Array<String,Object>`) (defaults to: `nil`) —
  the arguments

Yields:

- the result handler

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    55
    56
    57
    58
    59
    60
    61
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-sql/sql_connection.rb', line 55

    def query_single_with_params(sql=nil,arguments=nil)
      if sql.class == String && arguments.class == Array && block_given?
        @j_del.java_method(:querySingleWithParams, [Java::java.lang.String.java_class,Java::IoVertxCoreJson::JsonArray.java_class,Java::IoVertxCore::Handler.java_class]).call(sql,::Vertx::Util::Utils.to_json_array(arguments),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling query_single_with_params(#{sql},#{arguments})"
    end

### - (`self`) query_stream(sql = nil) { ... }

Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.

Parameters:

- sql (`String`) (defaults to: `nil`) —
  the SQL to execute. For example `SELECT * FROM table ...`.

Yields:

- the handler which is called once the operation completes. It will return a `SQLRowStream`.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    115
    116
    117
    118
    119
    120
    121
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-sql/sql_connection.rb', line 115

    def query_stream(sql=nil)
      if sql.class == String && block_given?
        @j_del.java_method(:queryStream, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(sql,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ::Vertx::Util::Utils.safe_create(ar.result,::VertxSql::SQLRowStream) : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling query_stream(#{sql})"
    end

### - (`self`) query_stream_with_params(sql = nil, params = nil) { ... }

Executes the given SQL `SELECT` statement which returns the results of the query as a read stream.

Parameters:

- sql (`String`) (defaults to: `nil`) —
  the SQL to execute. For example `SELECT * FROM table ...`.
- params (`Array<String,Object>`) (defaults to: `nil`) —
  these are the parameters to fill the statement.

Yields:

- the handler which is called once the operation completes. It will return a `SQLRowStream`.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    139
    140
    141
    142
    143
    144
    145
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-sql/sql_connection.rb', line 139

    def query_stream_with_params(sql=nil,params=nil)
      if sql.class == String && params.class == Array && block_given?
        @j_del.java_method(:queryStreamWithParams, [Java::java.lang.String.java_class,Java::IoVertxCoreJson::JsonArray.java_class,Java::IoVertxCore::Handler.java_class]).call(sql,::Vertx::Util::Utils.to_json_array(params),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ::Vertx::Util::Utils.safe_create(ar.result,::VertxSql::SQLRowStream) : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling query_stream_with_params(#{sql},#{params})"
    end

### - (`self`) query_with_params(sql = nil, params = nil) { ... }

Executes the given SQL `SELECT` prepared statement which returns the results of the query.

Parameters:

- sql (`String`) (defaults to: `nil`) —
  the SQL to execute. For example `SELECT * FROM table ...`.
- params (`Array<String,Object>`) (defaults to: `nil`) —
  these are the parameters to fill the statement.

Yields:

- the handler which is called once the operation completes. It will return a `ResultSet`.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    127
    128
    129
    130
    131
    132
    133
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-sql/sql_connection.rb', line 127

    def query_with_params(sql=nil,params=nil)
      if sql.class == String && params.class == Array && block_given?
        @j_del.java_method(:queryWithParams, [Java::java.lang.String.java_class,Java::IoVertxCoreJson::JsonArray.java_class,Java::IoVertxCore::Handler.java_class]).call(sql,::Vertx::Util::Utils.to_json_array(params),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.toJson.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling query_with_params(#{sql},#{params})"
    end

### - (`self`) rollback { ... }

Rolls back all changes made since the previous commit/rollback.

Yields:

- the handler called when this operation completes.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    227
    228
    229
    230
    231
    232
    233
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-sql/sql_connection.rb', line 227

    def rollback
      if block_given?
        @j_del.java_method(:rollback, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling rollback()"
    end

### - (`self`) set_auto_commit(autoCommit = nil) { ... }

Sets the auto commit flag for this connection. True by default.

Parameters:

- autoCommit (`true`, `false`) (defaults to: `nil`) —
  the autoCommit flag, true by default.

Yields:

- the handler which is called once this operation completes.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    82
    83
    84
    85
    86
    87
    88
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-sql/sql_connection.rb', line 82

    def set_auto_commit(autoCommit=nil)
      if (autoCommit.class == TrueClass || autoCommit.class == FalseClass) && block_given?
        @j_del.java_method(:setAutoCommit, [Java::boolean.java_class,Java::IoVertxCore::Handler.java_class]).call(autoCommit,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling set_auto_commit(#{autoCommit})"
    end

### - (`self`) set_options(options = nil)

Sets the desired options to be applied to the current connection when statements are executed. The options are not applied globally but applicable to the current connection. For example changing the transaction isolation level will only affect statements run on this connection and not future or current connections acquired from the connection pool. This method is not async in nature since the apply will only happen at the moment a query is run.

Parameters:

- options (`Hash`) (defaults to: `nil`) —
  the options to modify the unwrapped connection.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    71
    72
    73
    74
    75
    76
    77
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-sql/sql_connection.rb', line 71

    def set_options(options=nil)
      if options.class == Hash && !block_given?
        @j_del.java_method(:setOptions, [Java::IoVertxExtSql::SQLOptions.java_class]).call(Java::IoVertxExtSql::SQLOptions.new(::Vertx::Util::Utils.to_json_object(options)))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling set_options(#{options})"
    end

### - (`self`) set_query_timeout(timeoutInSeconds = nil)

Sets a connection wide query timeout. It can be over written at any time and becomes active on the next query call.

Parameters:

- timeoutInSeconds (`Fixnum`) (defaults to: `nil`) —
  the max amount of seconds the query can take to execute.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    239
    240
    241
    242
    243
    244
    245
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-sql/sql_connection.rb', line 239

    def set_query_timeout(timeoutInSeconds=nil)
      if timeoutInSeconds.class == Fixnum && !block_given?
        @j_del.java_method(:setQueryTimeout, [Java::int.java_class]).call(timeoutInSeconds)
        return self
      end
      raise ArgumentError, "Invalid arguments when calling set_query_timeout(#{timeoutInSeconds})"
    end

### - (`self`) set_transaction_isolation(isolation = nil) { ... }

Attempts to change the transaction isolation level for this Connection object to the one given. The constants defined in the interface Connection are the possible transaction isolation levels.

Parameters:

- isolation (`:READ_UNCOMMITTED`, `:READ_COMMITTED`, `:REPEATABLE_READ`, `:SERIALIZABLE`, `:NONE`) (defaults to: `nil`) —
  the level of isolation

Yields:

- the handler called when this operation completes.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    291
    292
    293
    294
    295
    296
    297
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-sql/sql_connection.rb', line 291

    def set_transaction_isolation(isolation=nil)
      if isolation.class == Symbol && block_given?
        @j_del.java_method(:setTransactionIsolation, [Java::IoVertxExtSql::TransactionIsolation.java_class,Java::IoVertxCore::Handler.java_class]).call(Java::IoVertxExtSql::TransactionIsolation.valueOf(isolation.to_s),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling set_transaction_isolation(#{isolation})"
    end

### - (`self`) update(sql = nil) { ... }

Executes the given SQL statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement.

Parameters:

- sql (`String`) (defaults to: `nil`) —
  the SQL to execute. For example `INSERT INTO table ...`

Yields:

- the handler which is called once the operation completes.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    151
    152
    153
    154
    155
    156
    157
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-sql/sql_connection.rb', line 151

    def update(sql=nil)
      if sql.class == String && block_given?
        @j_del.java_method(:update, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(sql,(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.toJson.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling update(#{sql})"
    end

### - (`self`) update_with_params(sql = nil, params = nil) { ... }

Executes the given prepared statement which may be an `INSERT`, `UPDATE`, or `DELETE` statement with the given parameters

Parameters:

- sql (`String`) (defaults to: `nil`) —
  the SQL to execute. For example `INSERT INTO table ...`
- params (`Array<String,Object>`) (defaults to: `nil`) —
  these are the parameters to fill the statement.

Yields:

- the handler which is called once the operation completes.

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    164
    165
    166
    167
    168
    169
    170
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-sql/sql_connection.rb', line 164

    def update_with_params(sql=nil,params=nil)
      if sql.class == String && params.class == Array && block_given?
        @j_del.java_method(:updateWithParams, [Java::java.lang.String.java_class,Java::IoVertxCoreJson::JsonArray.java_class,Java::IoVertxCore::Handler.java_class]).call(sql,::Vertx::Util::Utils.to_json_array(params),(Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? ar.result != nil ? JSON.parse(ar.result.toJson.encode) : nil : nil) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling update_with_params(#{sql},#{params})"
    end