Class: Cassandra::Session

Inherits:
Object
  • Object
show all
Extended by:
Forwardable
Defined in:
lib/cassandra/session.rb

Overview

Sessions are used for query execution. Each session tracks its current keyspace. A session should be reused as much as possible, however it is ok to create several independent session for interacting with different keyspaces in the same application.

Instance Method Summary collapse

Instance Method Details

#close ⇒ self

Synchronously closes current session

Returns:

  • (self) —

    this session

See Also:



221
222
223
 
# File 'lib/cassandra/session.rb', line 221

def close
  close_async.get
end

#close_async ⇒ Cassandra::Future<Cassandra::Session>

Asynchronously closes current session

Returns:



202
203
204
205
206
207
208
209
210
211
212
213
214
 
# File 'lib/cassandra/session.rb', line 202

def close_async
  promise = @futures.promise

  @client.close.on_complete do |f|
    if f.resolved?
      promise.fulfill(self)
    else
      f.on_failure {|e| promise.break(e)}
    end
  end

  promise.future
end

#counter_batch {|batch| ... } ⇒ Statements::Batch

Returns a counter Cassandra::Statements::Batch instance and optionally yields it to a given block

Yield Parameters:

Returns:



192
193
194
195
196
 
# File 'lib/cassandra/session.rb', line 192

def counter_batch
  statement = Statements::Batch::Counter.new
  yield(statement) if block_given?
  statement
end

#execute(statement, options = nil) ⇒ Cassandra::Result

A blocking wrapper around #execute_async

Parameters:

Returns:

Raises:

See Also:



120
121
122
 
# File 'lib/cassandra/session.rb', line 120

def execute(statement, options = nil)
  execute_async(statement, options).get
end

#execute_async(statement, options = nil) ⇒ Cassandra::Future<Cassandra::Result>

Note:

Positional arguments for simple statements are only supported starting with Apache Cassandra 2.0 and above.

Note:

Named arguments for simple statements are only supported starting with Apache Cassandra 2.1 and above.

Executes a given statement and returns a future result

Parameters:

Options Hash (options):

  • :consistency (Symbol) —

    consistency level for the request. Must be one of CONSISTENCIES

  • :page_size (Integer) —

    size of results page. You can page through results using Result#next_page or Result#next_page_async

  • :trace (Boolean) — default: false —

    whether to enable request tracing

  • :timeout (Numeric) — default: nil —

    if specified, it is a number of seconds after which to time out the request if it hasn't completed

  • :serial_consistency (Symbol) — default: nil —

    this option is only relevant for conditional updates and specifies a serial consistency to be used, one of Cassandra::SERIAL_CONSISTENCIES

  • :paging_state (String) — default: nil —

    this option is used for stateless paging, where result paging is resumed some time after the initial request.

  • :arguments (Array, Hash) — default: nil —

    positional or named arguments for the statement.

  • :type_hints (Array, Hash) — default: nil —

    override Util.guess_type to determine the CQL type for an argument; nil elements will fall-back to Util.guess_type.

Returns:

See Also:



77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
 
# File 'lib/cassandra/session.rb', line 77

def execute_async(statement, options = nil)
  if options
    options = @options.override(options)
  else
    options = @options
  end

  case statement
  when ::String
    @client.query(Statements::Simple.new(statement, options.arguments, options.type_hints), options)
  when Statements::Simple
    @client.query(statement, options)
  when Statements::Prepared
    @client.execute(statement.bind(options.arguments), options)
  when Statements::Bound
    @client.execute(statement, options)
  when Statements::Batch
    @client.batch(statement, options)
  else
    @futures.error(::ArgumentError.new("unsupported statement #{statement.inspect}"))
  end
rescue => e
  @futures.error(e)
end

#inspect ⇒ String

Returns a CLI-friendly session representation.

Returns:

  • (String) —

    a CLI-friendly session representation



226
227
228
 
# File 'lib/cassandra/session.rb', line 226

def inspect
  "#<#{self.class.name}:0x#{self.object_id.to_s(16)}>"
end

#keyspace ⇒ String

Returns current keyspace

Returns:

  • (String) —

    current keyspace



27
 
# File 'lib/cassandra/session.rb', line 27

def_delegators :@client, :keyspace

#logged_batch {|batch| ... } ⇒ Statements::Batch Also known as: batch

Returns a logged Cassandra::Statements::Batch instance and optionally yields it to a given block

Yield Parameters:

Returns:



171
172
173
174
175
 
# File 'lib/cassandra/session.rb', line 171

def logged_batch(&block)
  statement = Statements::Batch::Logged.new
  yield(statement) if block_given?
  statement
end

#prepare(*args) ⇒ Cassandra::Statements::Prepared

A blocking wrapper around #prepare_async

Returns:

Raises:

See Also:



163
164
165
 
# File 'lib/cassandra/session.rb', line 163

def prepare(*args)
  prepare_async(*args).get
end

#prepare_async(statement, options = nil) ⇒ Cassandra::Future<Cassandra::Statements::Prepared>

Prepares a given statement and returns a future prepared statement

Parameters:

  • statement (String, Cassandra::Statements::Simple) —

    a statement to prepare

  • options (Hash) (defaults to: nil) —

    (nil) a customizable set of options

Options Hash (options):

  • :trace (Boolean) — default: false —

    whether to enable request tracing

  • :timeout (Numeric) — default: nil —

    if specified, it is a number of seconds after which to time out the request if it hasn't completed

Returns:



137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
 
# File 'lib/cassandra/session.rb', line 137

def prepare_async(statement, options = nil)
  if options.is_a?(::Hash)
    options = @options.override(options)
  else
    options = @options
  end

  case statement
  when ::String
    @client.prepare(statement, options)
  when Statements::Simple
    @client.prepare(statement.cql, options)
  else
    @futures.error(::ArgumentError.new("unsupported statement #{statement.inspect}"))
  end
rescue => e
  @futures.error(e)
end

#unlogged_batch {|batch| ... } ⇒ Statements::Batch

Returns a unlogged Cassandra::Statements::Batch instance and optionally yields it to a given block

Yield Parameters:

Returns:



182
183
184
185
186
 
# File 'lib/cassandra/session.rb', line 182

def unlogged_batch
  statement = Statements::Batch::Unlogged.new
  yield(statement) if block_given?
  statement
end