module QueryBuilder::CQL::Operators

The collection of CQL-specific operators (building blocks for statements)

Public Class Methods

cql(*parts) click to toggle source

Provides CQL statement from chunks

@example

fn = Operators[:cql]
fn["USE", "", [], "my_keyspace"]
# => "USE my_keyspace;"

@param [Array<String, Array<String>>] parts

@return [String]

# File lib/query_builder/cql/operators/cql.rb, line 16
def self.cql(*parts)
  parts
    .flatten
    .reject { |item| item.nil? || item.empty? }
    .join(" ") << ";"
end
cql_composite(*columns) click to toggle source

Returns a description for the composite partition key

@example

fn = Operators[:cql_composite]
fn[:foo, :bar, :baz]
# => "(foo, bar, baz)"

@param [Array<#to_s>] columns List of columns for the composite

@return [String]

# File lib/query_builder/cql/operators/cql_composite.rb, line 16
def self.cql_composite(*columns)
  "(#{columns.join(", ")})"
end
cql_dec(column, value) click to toggle source

Describes decrementing of the column

@example

fn = Operators[:cql_dec, 3]
fn[:foo]
# => "foo = foo - 3"

@param [#to_s] column @param [Numeric] value

@return [String]

# File lib/query_builder/cql/operators/cql_dec.rb, line 17
def self.cql_dec(column, value)
  "#{column} = #{column} - #{value}"
end
cql_element(column, key) click to toggle source

Returns a description for element of CQL collection

@example

fn = Operators[:cql_element]
fn[:foo, :bar]
# => "foo['bar']"

@param [#to_s] column @param [#to_s] key

@return [String]

# File lib/query_builder/cql/operators/cql_element.rb, line 19
def self.cql_element(column, key)
  "#{column}[#{cql_literal(key)}]"
end
cql_entries(column) click to toggle source

Describes entries index

@example

fn = Operators[:cql_entries]
fn[:foo]
# => "ENTRIES(foo)"

@param [#to_s] column

@return [String]

# File lib/query_builder/cql/operators/cql_entries.rb, line 16
def self.cql_entries(column)
  "ENTRIES(#{column})"
end
cql_frozen(value) click to toggle source

Marks value as frozen

@example

fn = Operators[:cql_frozen]
fn[:foo]
# => "FROZEN <foo>"

@param [#to_s] value

@return [String]

# File lib/query_builder/cql/operators/cql_frozen.rb, line 16
def self.cql_frozen(value)
  "FROZEN <#{value}>"
end
cql_full(column) click to toggle source

Describes full frozen collection index

@example

fn = Operators[:cql_full]
fn[:foo]
# => "FULL(foo)"

@param [#to_s] column

@return [String]

# File lib/query_builder/cql/operators/cql_full.rb, line 16
def self.cql_full(column)
  "FULL(#{column})"
end
cql_gt(column, value) click to toggle source

Describes ‘greater than’ operator

@example

fn = Operators[:cql_gt, 3]
fn[:foo]
# => "foo > 3"

@param [#to_s] column @param [Numeric] value

@return [String]

# File lib/query_builder/cql/operators/cql_gt.rb, line 19
def self.cql_gt(column, value)
  "#{column} > #{cql_literal(value)}"
end
cql_gte(column, value) click to toggle source

Describes ‘greater than or equal’ operator

@example

fn = Operators[:cql_gt, 3]
fn[:foo]
# => "foo >= 3"

@param [#to_s] column @param [Numeric] value

@return [String]

# File lib/query_builder/cql/operators/cql_gte.rb, line 19
def self.cql_gte(column, value)
  "#{column} >= #{cql_literal(value)}"
end
cql_in(column, *values) click to toggle source

Returns IN condition

@example

fn = Operators[:cql_in]
fn[:foo, :bar, :baz]
# => "foo IN ('bar', 'baz')"

@param [#to_s] column @param [Array<#to_s>] values

@return [String]

# File lib/query_builder/cql/operators/cql_in.rb, line 19
def self.cql_in(column, *values)
  "#{column} IN (#{values.map { |value| cql_literal(value) }.join(", ")})"
end
cql_inc(column, value) click to toggle source

Describes incrementing of the column

@example

fn = Operators[:cql_inc, 3]
fn[:foo]
# => "foo = foo + 3"

@param [#to_s] column @param [Numeric] value

@return [String]

# File lib/query_builder/cql/operators/cql_inc.rb, line 17
def self.cql_inc(column, value)
  "#{column} = #{column} + #{value}"
end
cql_keys(column) click to toggle source

Describes keys index

@example

fn = Operators[:cql_keys]
fn[:foo]
# => "KEYS(foo)"

@param [#to_s] column

@return [String]

# File lib/query_builder/cql/operators/cql_keys.rb, line 16
def self.cql_keys(column)
  "KEYS(#{column})"
end
cql_list(value) click to toggle source

Returns the CQL LIST definition

@example

fn = Operators[:cql_list]

fn[:int]
# => "LIST<int>"

@param [#to_s] value

@return [String]

# File lib/query_builder/cql/operators/cql_list.rb, line 17
def self.cql_list(value)
  "LIST<#{value}>"
end
cql_literal(value) click to toggle source

Converts value to CQL literal

@example

fn = Operators[:cql_literal]
fn[nil]      # => "NaN"
fn["0x9232"] # => "0x9232"
fn[:foo]     # => "'foo'"

@param [Object] value

@return [String]

# File lib/query_builder/cql/operators/cql_literal.rb, line 19
def cql_literal(value)
  return "NaN"                    if nan?(value)
  return "Infinity"               if infinity?(value)
  return value.to_s               if unchanged?(value)
  return cql_literal_array(value) if array?(value)
  return cql_literal_hash(value)  if hash?(value)
  quote(value)
end
cql_lt(column, value) click to toggle source

Describes ‘less than’ operator

@example

fn = Operators[:cql_lt, 3]
fn[:foo]
# => "foo < 3"

@param [#to_s] column @param [Numeric] value

@return [String]

# File lib/query_builder/cql/operators/cql_lt.rb, line 19
def self.cql_lt(column, value)
  "#{column} < #{cql_literal(value)}"
end
cql_lte(column, value) click to toggle source

Describes ‘less than or equal’ operator

@example

fn = Operators[:cql_lte, 3]
fn[:foo]
# => "foo <= 3"

@param [#to_s] column @param [Numeric] value

@return [String]

# File lib/query_builder/cql/operators/cql_lte.rb, line 19
def self.cql_lte(column, value)
  "#{column} <= #{cql_literal(value)}"
end
cql_map(*values) click to toggle source

Returns the CQL MAP definition

@example

fn = Operators[:cql_map]

fn[:foo, :bar]
# => "MAP<foo, bar>"

fn[:foo, cql_frozen(:bar)]
# => "MAP<foo, FROZEN <bar>>"

@param [Array<#to_s>] values

@return [String]

# File lib/query_builder/cql/operators/cql_map.rb, line 20
def self.cql_map(*values)
  key, value = values.flatten
  "MAP<#{key}, #{value}>"
end
cql_set(value) click to toggle source

Returns the CQL SET definition

@example

fn = Operators[:cql_set]

fn[:foo]
# => "SET<foo>"

@param [#to_s] value

@return [String]

# File lib/query_builder/cql/operators/cql_set.rb, line 17
def self.cql_set(value)
  "SET<#{value}>"
end
cql_token(type) click to toggle source

Returns the CQL TOKEN() definition

@example

fn = Operators[:cql_token]

fn[:int]
# => "TOKEN(int)"

@param [#to_s] type

@return [String]

# File lib/query_builder/cql/operators/cql_token.rb, line 17
def self.cql_token(type)
  "TOKEN(#{type})"
end
cql_token_value(value) click to toggle source

Returns value of CQL TOKEN

@example

fn = Operators[:cql_token_value]

fn[:tiger]
# => "TOKEN('tiger')"

@param [#to_s] value

@return [String]

# File lib/query_builder/cql/operators/cql_token_value.rb, line 19
def self.cql_token_value(value)
  "TOKEN(#{cql_literal(value)})"
end
cql_ttl(column) click to toggle source

Describes TTL() function

@example

fn = Operators[:cql_ttl]
fn[:name]
# => "TTL(name)"

@param [#to_s] column

@return [String]

# File lib/query_builder/cql/operators/cql_ttl.rb, line 16
def self.cql_ttl(column)
  "TTL(#{column})"
end
cql_tuple(*types) click to toggle source

Returns the CQL TUPLE definition

@example

fn = Operators[:cql_tuple]

fn[:int, :text]
# => "TUPLE<int, text>"

@param [Array<#to_s>] types

@return [String]

# File lib/query_builder/cql/operators/cql_tuple.rb, line 17
def self.cql_tuple(*types)
  "TUPLE<#{types.join(", ")}>"
end
cql_tuple_value(*values) click to toggle source

Returns value of CQL tuple

@example

fn = Operators[:cql_tuple_value]

fn[:tiger, 1]
# => "('tiger', 1)"

@param [Array<#to_s>] values

@return [String]

# File lib/query_builder/cql/operators/cql_tuple_value.rb, line 19
def self.cql_tuple_value(*values)
  "(#{values.flatten.map { |value| cql_literal(value) }.join(", ")})"
end
cql_writetime(column) click to toggle source

Describes WRITETIME() function

@example

fn = Operators[:cql_writetime]
fn[:name]
# => "WRITETIME(name)"

@param [#to_s] column

@return [String]

# File lib/query_builder/cql/operators/cql_writetime.rb, line 16
def self.cql_writetime(column)
  "WRITETIME(#{column})"
end

Private Class Methods

array?(value) click to toggle source
# File lib/query_builder/cql/operators/cql_literal.rb, line 78
def array?(value)
  value.instance_of? Array
end
blob?(value) click to toggle source
# File lib/query_builder/cql/operators/cql_literal.rb, line 62
def blob?(value)
  value.to_s[/^0[xX]./]
end
bool?(value) click to toggle source
# File lib/query_builder/cql/operators/cql_literal.rb, line 70
def bool?(value)
  [true, false].include? value
end
cql_literal_array(value) click to toggle source
# File lib/query_builder/cql/operators/cql_literal.rb, line 30
def cql_literal_array(value)
  "[#{value.map(&method(:cql_literal)).join(", ")}]"
end
cql_literal_hash(value) click to toggle source
# File lib/query_builder/cql/operators/cql_literal.rb, line 34
def cql_literal_hash(value)
  str =
    value
    .map { |k, v| [cql_literal(k), cql_literal(v)].join(": ") }
    .join(", ")
  "{#{str}}"
end
hash?(value) click to toggle source
# File lib/query_builder/cql/operators/cql_literal.rb, line 74
def hash?(value)
  value.instance_of? Hash
end
infinity?(value) click to toggle source
# File lib/query_builder/cql/operators/cql_literal.rb, line 50
def infinity?(value)
  value.to_s.eql?("Infinity")
end
nan?(value) click to toggle source
# File lib/query_builder/cql/operators/cql_literal.rb, line 46
def nan?(value)
  value.nil? || value.to_s.eql?("NaN")
end
number?(value) click to toggle source
# File lib/query_builder/cql/operators/cql_literal.rb, line 66
def number?(value)
  value.is_a? Numeric
end
quote(value) click to toggle source
# File lib/query_builder/cql/operators/cql_literal.rb, line 42
def quote(value)
  "'#{value.to_s.gsub("\'", "\'\'")}'"
end
unchanged?(value) click to toggle source
# File lib/query_builder/cql/operators/cql_literal.rb, line 54
def unchanged?(value)
  number?(value) || uuid?(value) || blob?(value) || bool?(value)
end
uuid?(value) click to toggle source
# File lib/query_builder/cql/operators/cql_literal.rb, line 58
def uuid?(value)
  value.to_s[/^\h{8}(-\h{4}){3}-\h{12}$/]
end

Private Instance Methods

method_missing(name, *args) click to toggle source
# File lib/query_builder/cql/operators.rb, line 19
def method_missing(name, *args)
  Operators[name, *args]
end
respond_to_missing?(name, *) click to toggle source
# File lib/query_builder/cql/operators.rb, line 15
def respond_to_missing?(name, *)
  Operators.respond_to?(name)
end