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:



218
219
220
 
# File 'lib/cassandra/session.rb', line 218

def close
  close_async.get
end

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

Asynchronously closes current session

Returns:



199
200
201
202
203
204
205
206
207
208
209
210
211
 
# File 'lib/cassandra/session.rb', line 199

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:



189
190
191
192
193
 
# File 'lib/cassandra/session.rb', line 189

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:



117
118
119
 
# File 'lib/cassandra/session.rb', line 117

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.

Returns:

See Also:



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

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)
  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



223
224
225
 
# File 'lib/cassandra/session.rb', line 223

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:



168
169
170
171
172
 
# File 'lib/cassandra/session.rb', line 168

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:



160
161
162
 
# File 'lib/cassandra/session.rb', line 160

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:



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

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:



179
180
181
182
183
 
# File 'lib/cassandra/session.rb', line 179

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