Module: QueryBuilder::CQL::Operators

Extended by:
Transproc::Registry
Included in:
Modifiers::Base, Statements::Base
Defined in:
lib/query_builder/cql/operators.rb,
lib/query_builder/cql/operators/cql.rb,
lib/query_builder/cql/operators/cql_gt.rb,
lib/query_builder/cql/operators/cql_in.rb,
lib/query_builder/cql/operators/cql_lt.rb,
lib/query_builder/cql/operators/cql_dec.rb,
lib/query_builder/cql/operators/cql_gte.rb,
lib/query_builder/cql/operators/cql_inc.rb,
lib/query_builder/cql/operators/cql_lte.rb,
lib/query_builder/cql/operators/cql_map.rb,
lib/query_builder/cql/operators/cql_set.rb,
lib/query_builder/cql/operators/cql_ttl.rb,
lib/query_builder/cql/operators/cql_full.rb,
lib/query_builder/cql/operators/cql_keys.rb,
lib/query_builder/cql/operators/cql_list.rb,
lib/query_builder/cql/operators/cql_token.rb,
lib/query_builder/cql/operators/cql_tuple.rb,
lib/query_builder/cql/operators/cql_frozen.rb,
lib/query_builder/cql/operators/cql_element.rb,
lib/query_builder/cql/operators/cql_entries.rb,
lib/query_builder/cql/operators/cql_literal.rb,
lib/query_builder/cql/operators/cql_composite.rb,
lib/query_builder/cql/operators/cql_writetime.rb,
lib/query_builder/cql/operators/cql_token_value.rb,
lib/query_builder/cql/operators/cql_tuple_value.rb

Overview

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

Class Method Summary collapse

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(name, *args) ⇒ Object (private) 



19
20
21
 
# File 'lib/query_builder/cql/operators.rb', line 19

def method_missing(name, *args)
  Operators[name, *args]
end

Class Method Details

.cql(*parts) ⇒ String

Provides CQL statement from chunks

Examples:

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

Parameters:

  • parts (Array<String, Array<String>>)

Returns:

  • (String) 


16
17
18
19
20
21
 
# 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) ⇒ String

Returns a description for the composite partition key

Examples:

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

Parameters:

  • columns (Array<#to_s>) —

    List of columns for the composite

Returns:

  • (String) 


16
17
18
 
# File 'lib/query_builder/cql/operators/cql_composite.rb', line 16

def self.cql_composite(*columns)
  "(#{columns.join(", ")})"
end

.cql_dec(column, value) ⇒ String

Describes decrementing of the column

Examples:

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

Parameters:

  • column (#to_s)
  • value (Numeric)

Returns:

  • (String) 


17
18
19
 
# 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) ⇒ String

Returns a description for element of CQL collection

Examples:

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

Parameters:

  • column (#to_s)
  • key (#to_s)

Returns:

  • (String) 


19
20
21
 
# 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) ⇒ String

Describes entries index

Examples:

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

Parameters:

  • column (#to_s)

Returns:

  • (String) 


16
17
18
 
# File 'lib/query_builder/cql/operators/cql_entries.rb', line 16

def self.cql_entries(column)
  "ENTRIES(#{column})"
end

.cql_frozen(value) ⇒ String

Marks value as frozen

Examples:

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

Parameters:

  • value (#to_s)

Returns:

  • (String) 


16
17
18
 
# File 'lib/query_builder/cql/operators/cql_frozen.rb', line 16

def self.cql_frozen(value)
  "FROZEN <#{value}>"
end

.cql_full(column) ⇒ String

Describes full frozen collection index

Examples:

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

Parameters:

  • column (#to_s)

Returns:

  • (String) 


16
17
18
 
# File 'lib/query_builder/cql/operators/cql_full.rb', line 16

def self.cql_full(column)
  "FULL(#{column})"
end

.cql_gt(column, value) ⇒ String

Describes ‘greater than’ operator

Examples:

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

Parameters:

  • column (#to_s)
  • value (Numeric)

Returns:

  • (String) 


19
20
21
 
# 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) ⇒ String

Describes ‘greater than or equal’ operator

Examples:

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

Parameters:

  • column (#to_s)
  • value (Numeric)

Returns:

  • (String) 


19
20
21
 
# 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) ⇒ String

Returns IN condition

Examples:

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

Parameters:

  • column (#to_s)
  • values (Array<#to_s>)

Returns:

  • (String) 


19
20
21
 
# 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) ⇒ String

Describes incrementing of the column

Examples:

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

Parameters:

  • column (#to_s)
  • value (Numeric)

Returns:

  • (String) 


17
18
19
 
# File 'lib/query_builder/cql/operators/cql_inc.rb', line 17

def self.cql_inc(column, value)
  "#{column} = #{column} + #{value}"
end

.cql_keys(column) ⇒ String

Describes keys index

Examples:

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

Parameters:

  • column (#to_s)

Returns:

  • (String) 


16
17
18
 
# File 'lib/query_builder/cql/operators/cql_keys.rb', line 16

def self.cql_keys(column)
  "KEYS(#{column})"
end

.cql_list(value) ⇒ String

Returns the CQL LIST definition

Examples:

fn = Operators[:cql_list]

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

Parameters:

  • value (#to_s)

Returns:

  • (String) 


17
18
19
 
# File 'lib/query_builder/cql/operators/cql_list.rb', line 17

def self.cql_list(value)
  "LIST<#{value}>"
end

.cql_literal(value) ⇒ String

Converts value to CQL literal

Examples:

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

Parameters:

  • value (Object)

Returns:

  • (String) 


19
20
21
22
23
24
25
26
 
# 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) ⇒ String

Describes ‘less than’ operator

Examples:

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

Parameters:

  • column (#to_s)
  • value (Numeric)

Returns:

  • (String) 


19
20
21
 
# 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) ⇒ String

Describes ‘less than or equal’ operator

Examples:

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

Parameters:

  • column (#to_s)
  • value (Numeric)

Returns:

  • (String) 


19
20
21
 
# 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) ⇒ String

Returns the CQL MAP definition

Examples:

fn = Operators[:cql_map]

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

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

Parameters:

  • values (Array<#to_s>)

Returns:

  • (String) 


20
21
22
23
 
# 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) ⇒ String

Returns the CQL SET definition

Examples:

fn = Operators[:cql_set]

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

Parameters:

  • value (#to_s)

Returns:

  • (String) 


17
18
19
 
# File 'lib/query_builder/cql/operators/cql_set.rb', line 17

def self.cql_set(value)
  "SET<#{value}>"
end

.cql_token(type) ⇒ String

Returns the CQL TOKEN() definition

Examples:

fn = Operators[:cql_token]

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

Parameters:

  • type (#to_s)

Returns:

  • (String) 


17
18
19
 
# File 'lib/query_builder/cql/operators/cql_token.rb', line 17

def self.cql_token(type)
  "TOKEN(#{type})"
end

.cql_token_value(value) ⇒ String

Returns value of CQL TOKEN

Examples:

fn = Operators[:cql_token_value]

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

Parameters:

  • value (#to_s)

Returns:

  • (String) 


19
20
21
 
# 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) ⇒ String

Describes TTL() function

Examples:

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

Parameters:

  • column (#to_s)

Returns:

  • (String) 


16
17
18
 
# File 'lib/query_builder/cql/operators/cql_ttl.rb', line 16

def self.cql_ttl(column)
  "TTL(#{column})"
end

.cql_tuple(*types) ⇒ String

Returns the CQL TUPLE definition

Examples:

fn = Operators[:cql_tuple]

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

Parameters:

  • types (Array<#to_s>)

Returns:

  • (String) 


17
18
19
 
# File 'lib/query_builder/cql/operators/cql_tuple.rb', line 17

def self.cql_tuple(*types)
  "TUPLE<#{types.join(", ")}>"
end

.cql_tuple_value(*values) ⇒ String

Returns value of CQL tuple

Examples:

fn = Operators[:cql_tuple_value]

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

Parameters:

  • values (Array<#to_s>)

Returns:

  • (String) 


19
20
21
 
# 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) ⇒ String

Describes WRITETIME() function

Examples:

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

Parameters:

  • column (#to_s)

Returns:

  • (String) 


16
17
18
 
# File 'lib/query_builder/cql/operators/cql_writetime.rb', line 16

def self.cql_writetime(column)
  "WRITETIME(#{column})"
end