Class: Cassanity::Keyspace

Inherits:
Object
  • Object
show all
Defined in:
lib/cassanity/keyspace.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(args = {}) ⇒ Keyspace

Public: Initializes a Keyspace.

args - The Hash of arguments (default: {}).

:name - The String name of the keyspace.
:executor - What will execute the queries. Must respond to `call`.
:replication - Hash of replication options (e.g., :class,
               :replication_factor)



22
23
24
25
26
 
# File 'lib/cassanity/keyspace.rb', line 22

def initialize(args = {})
  @name = args.fetch(:name).to_sym
  @executor = args.fetch(:executor)
  @replication = args.fetch(:replication, {})
end

Instance Attribute Details

#executor ⇒ Object (readonly)

Internal



9
10
11
 
# File 'lib/cassanity/keyspace.rb', line 9

def executor
  @executor
end

#name ⇒ Object (readonly)

Public



6
7
8
 
# File 'lib/cassanity/keyspace.rb', line 6

def name
  @name
end

#replication ⇒ Object (readonly)

Internal



12
13
14
 
# File 'lib/cassanity/keyspace.rb', line 12

def replication
  @replication
end

Instance Method Details

#batch(args = {}) ⇒ Object

Public: Group multiple statements into a batch.

args - The Hash of arguments to pass to the argument generator

(default: {}).

Examples

batch({
  modifications: [
    [:insert, name: 'apps', data: {id: '1', name: 'github'}],
    [:insert, name: 'apps', data: {id: '2', name: 'gist'}],
    [:update, name: 'apps', set: {name: 'github.com'}, where: {id: '1'}],
    [:delete, name: 'apps', where: {id: '2'}],
  ]
})

Returns whatever is returned by executor.



171
172
173
174
175
176
177
178
179
180
 
# File 'lib/cassanity/keyspace.rb', line 171

def batch(args = {})
  default_arguments = {
    keyspace_name: @name,
  }

  @executor.call({
    command: :batch,
    arguments: default_arguments.merge(args),
  })
end

#column_families ⇒ Object

Public: Get all column families for keyspace.

Returns Array of Cassanity::ColumnFamily instances.



122
123
124
125
126
127
128
129
130
131
132
 
# File 'lib/cassanity/keyspace.rb', line 122

def column_families
  @executor.call({
    command: :column_families,
    arguments: {
      keyspace_name: @name,
    },
    transformer_arguments: {
      keyspace: self,
    }
  })
end

#column_family(name_or_args, args = {}) ⇒ Object Also known as: table, []

Public: Get a column family instance

name_or_args - The String name of the column family or a Hash which has

the name key and possibly other arguments.

args - The Hash of arguments to use for ColumnFamily initialization

(optional, default: {}). :keyspace is always included.

Returns a Cassanity::ColumnFamily instance.



142
143
144
145
146
147
148
149
150
 
# File 'lib/cassanity/keyspace.rb', line 142

def column_family(name_or_args, args = {})
  column_family_args = if name_or_args.is_a?(Hash)
    name_or_args.merge(args)
  else
    args.merge(name: name_or_args)
  end

  ColumnFamily.new(column_family_args.merge(keyspace: self))
end

#create(args = {}) ⇒ Object

Public: Creates the keyspace

args - The Hash of arguments to pass to the argument generator

(default: {}). :keyspace_name is always included.

Examples

create # uses options from initialization

# override options from initialization
create({
  replication: {
    class: 'NetworkTopologyStrategy',
    dc1: 1,
    dc2: 3,
  }
})

Returns whatever is returned by executor.



62
63
64
65
66
67
68
69
70
71
 
# File 'lib/cassanity/keyspace.rb', line 62

def create(args = {})
  create_arguments = {}.merge(args)
  create_arguments[:replication] = @replication.merge(create_arguments[:replication] || {})
  create_arguments[:keyspace_name] = @name

  @executor.call({
    command: :keyspace_create,
    arguments: create_arguments,
  })
end

#drop(args = {}) ⇒ Object

Public: Drops a keyspace

args - The Hash of arguments to pass to the argument generator

(default: {}). :keyspace_name is always included.

Examples

drop # you shouldn't really ever need more than this

Returns whatever is returned by executor.



110
111
112
113
114
115
116
117
 
# File 'lib/cassanity/keyspace.rb', line 110

def drop(args = {})
  @executor.call({
    command: :keyspace_drop,
    arguments: args.merge({
      keyspace_name: @name,
    }),
  })
end

#exists? ⇒ Boolean Also known as: exist?

Public: Returns true or false depending on if keyspace exists in the current cluster.

Returns true if keyspace exists, false if it does not.



32
33
34
35
36
37
38
39
 
# File 'lib/cassanity/keyspace.rb', line 32

def exists?
  @executor.call({
    command: :keyspaces,
    transformer_arguments: {
      executor: @executor,
    },
  }).any? { |keyspace| keyspace.name == @name }
end

#inspect ⇒ Object

Public



183
184
185
186
187
188
 
# File 'lib/cassanity/keyspace.rb', line 183

def inspect
  attributes = [
    "name=#{@name.inspect}",
  ]
  "#<#{self.class.name}:#{object_id} #{attributes.join(', ')}>"
end

#recreate ⇒ Object

Public: Drops keyspace if it exists and then calls create.

Returns nothing.



76
77
78
79
 
# File 'lib/cassanity/keyspace.rb', line 76

def recreate
  drop if exists?
  create
end

#use(args = {}) ⇒ Object

Public: Uses a keyspace

args - The Hash of arguments to pass to the argument generator

(default: {}). :keyspace_name is always included.

Examples

use # you shouldn't really ever need more than this

Returns whatever is returned by executor.



91
92
93
94
95
96
97
98
 
# File 'lib/cassanity/keyspace.rb', line 91

def use(args = {})
  @executor.call({
    command: :keyspace_use,
    arguments: args.merge({
      keyspace_name: @name,
    }),
  })
end