query_builder 0.0.1

data/lib/query_builder/cql/modifiers/with.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+module QueryBuilder::CQL
+
+  module Modifiers
+
+    # Provides WITH clauses for statements
+    #
+    module With
+
+      # Adds WITH clause to the statement
+      #
+      # @param [Hash] options
+      #
+      # @return [QueryBuilder::Core::Statement] updated statement
+      #
+      def with(options)
+        options
+          .map { |key, value| Clause.new(column: key, value: value) }
+          .inject(self, :<<)
+      end
+
+      private
+
+      def maybe_with
+        list = clauses(:with)
+        ["WITH", list.join(" AND ")] if list.any?
+      end
+
+      # The clause for adding to a statement
+      #
+      # @api private
+      #
+      class Clause < BaseCondition
+
+        type :with
+
+      end # class Clause
+
+    end # module With
+
+  end # module Modifiers
+
+end # module QueryBuilder::CQL

data/lib/query_builder/cql/modifiers/with_options.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+module QueryBuilder::CQL
+
+  module Modifiers
+
+    # Provides WITH OPTIONS clauses for statements
+    #
+    module WithOptions
+
+      # Adds WITH OPTIONS clause to the statement
+      #
+      # @param [Hash] options
+      #
+      # @return [QueryBuilder::Core::Statement] updated statement
+      #
+      def with(options)
+        self << Clause.new(column: :options, value: options)
+      end
+
+      private
+
+      def maybe_with
+        list = clauses(:with)
+        ["WITH", list.last] if list.any?
+      end
+
+      # The clause for adding to a statement
+      #
+      # @api private
+      #
+      class Clause < BaseCondition
+
+        type :with
+
+      end # class Clause
+
+    end # module WithOptions
+
+  end # module Modifiers
+
+end # module QueryBuilder::CQL

data/lib/query_builder/cql/operators.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module QueryBuilder
+
+  module CQL
+
+    # The collection of CQL-specific operators (building blocks for statements)
+    #
+    module Operators
+
+      extend Transproc::Registry
+
+      private
+
+      def respond_to_missing?(name, *)
+        Operators.respond_to?(name)
+      end
+
+      def method_missing(name, *args)
+        Operators[name, *args]
+      end
+
+      Dir[File.expand_path("../operators/*.rb", __FILE__)].each(&method(:load))
+
+    end # module Clauses
+
+  end # module CQL
+
+end # module QueryBuilder

data/lib/query_builder/cql/operators/cql.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+module QueryBuilder::CQL::Operators
+
+  # Provides CQL statement from chunks
+  #
+  # @example
+  #   fn = Operators[:cql]
+  #   fn["USE", "", [], "my_keyspace"]
+  #   # => "USE my_keyspace;"
+  #
+  # @param [Array<String, Array<String>>] parts
+  #
+  # @return [String]
+  #
+  def self.cql(*parts)
+    parts
+      .flatten
+      .reject { |item| item.nil? || item.empty? }
+      .join(" ") << ";"
+  end
+
+end # module QueryBuilder::CQL::Operators

data/lib/query_builder/cql/operators/cql_composite.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module QueryBuilder::CQL::Operators
+
+  # 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]
+  #
+  def self.cql_composite(*columns)
+    "(#{columns.join(", ")})"
+  end
+
+end # module QueryBuilder::CQL::Operators

data/lib/query_builder/cql/operators/cql_dec.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+module QueryBuilder::CQL::Operators
+
+  # 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]
+  #
+  def self.cql_dec(column, value)
+    "#{column} = #{column} - #{value}"
+  end
+
+end # module QueryBuilder::CQL::Operators

data/lib/query_builder/cql/operators/cql_element.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require_relative "cql_literal"
+
+module QueryBuilder::CQL::Operators
+
+  # 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]
+  #
+  def self.cql_element(column, key)
+    "#{column}[#{cql_literal(key)}]"
+  end
+
+end # module QueryBuilder::CQL::Operators

data/lib/query_builder/cql/operators/cql_entries.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module QueryBuilder::CQL::Operators
+
+  # Describes entries index
+  #
+  # @example
+  #   fn = Operators[:cql_entries]
+  #   fn[:foo]
+  #   # => "ENTRIES(foo)"
+  #
+  # @param [#to_s] column
+  #
+  # @return [String]
+  #
+  def self.cql_entries(column)
+    "ENTRIES(#{column})"
+  end
+
+end # module QueryBuilder::CQL::Operators

data/lib/query_builder/cql/operators/cql_frozen.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module QueryBuilder::CQL::Operators
+
+  # Marks value as frozen
+  #
+  # @example
+  #   fn = Operators[:cql_frozen]
+  #   fn[:foo]
+  #   # => "FROZEN <foo>"
+  #
+  # @param [#to_s] value
+  #
+  # @return [String]
+  #
+  def self.cql_frozen(value)
+    "FROZEN <#{value}>"
+  end
+
+end # module QueryBuilder::CQL::Operators

data/lib/query_builder/cql/operators/cql_full.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module QueryBuilder::CQL::Operators
+
+  # Describes full frozen collection index
+  #
+  # @example
+  #   fn = Operators[:cql_full]
+  #   fn[:foo]
+  #   # => "FULL(foo)"
+  #
+  # @param [#to_s] column
+  #
+  # @return [String]
+  #
+  def self.cql_full(column)
+    "FULL(#{column})"
+  end
+
+end # module QueryBuilder::CQL::Operators

data/lib/query_builder/cql/operators/cql_gt.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require_relative "cql_literal"
+
+module QueryBuilder::CQL::Operators
+
+  # Describes 'greater than' operator
+  #
+  # @example
+  #   fn = Operators[:cql_gt, 3]
+  #   fn[:foo]
+  #   # => "foo > 3"
+  #
+  # @param [#to_s] column
+  # @param [Numeric] value
+  #
+  # @return [String]
+  #
+  def self.cql_gt(column, value)
+    "#{column} > #{cql_literal(value)}"
+  end
+
+end # module QueryBuilder::CQL::Operators

data/lib/query_builder/cql/operators/cql_gte.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require_relative "cql_literal"
+
+module QueryBuilder::CQL::Operators
+
+  # 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]
+  #
+  def self.cql_gte(column, value)
+    "#{column} >= #{cql_literal(value)}"
+  end
+
+end # module QueryBuilder::CQL::Operators

data/lib/query_builder/cql/operators/cql_in.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require_relative "cql_literal"
+
+module QueryBuilder::CQL::Operators
+
+  # 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]
+  #
+  def self.cql_in(column, *values)
+    "#{column} IN (#{values.map { |value| cql_literal(value) }.join(", ")})"
+  end
+
+end # module QueryBuilder::CQL::Operators

data/lib/query_builder/cql/operators/cql_inc.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+module QueryBuilder::CQL::Operators
+
+  # 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]
+  #
+  def self.cql_inc(column, value)
+    "#{column} = #{column} + #{value}"
+  end
+
+end # module QueryBuilder::CQL::Operators

data/lib/query_builder/cql/operators/cql_keys.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module QueryBuilder::CQL::Operators
+
+  # Describes keys index
+  #
+  # @example
+  #   fn = Operators[:cql_keys]
+  #   fn[:foo]
+  #   # => "KEYS(foo)"
+  #
+  # @param [#to_s] column
+  #
+  # @return [String]
+  #
+  def self.cql_keys(column)
+    "KEYS(#{column})"
+  end
+
+end # module QueryBuilder::CQL::Operators

data/lib/query_builder/cql/operators/cql_list.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+module QueryBuilder::CQL::Operators
+
+  # Returns the CQL LIST definition
+  #
+  # @example
+  #   fn = Operators[:cql_list]
+  #
+  #   fn[:int]
+  #   # => "LIST<int>"
+  #
+  # @param [#to_s] value
+  #
+  # @return [String]
+  #
+  def self.cql_list(value)
+    "LIST<#{value}>"
+  end
+
+end # module QueryBuilder::CQL::Operators

data/lib/query_builder/cql/operators/cql_literal.rb

@@ -0,0 +1,84 @@
+# encoding: utf-8
+
+module QueryBuilder::CQL::Operators
+
+  class << self
+
+    # Converts value to CQL literal
+    #
+    # @example
+    #   fn = Operators[:cql_literal]
+    #   fn[nil]      # => "NaN"
+    #   fn["0x9232"] # => "0x9232"
+    #   fn[:foo]     # => "'foo'"
+    #
+    # @param [Object] value
+    #
+    # @return [String]
+    #
+    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
+
+    private
+
+    def cql_literal_array(value)
+      "[#{value.map(&method(:cql_literal)).join(", ")}]"
+    end
+
+    def cql_literal_hash(value)
+      str =
+        value
+        .map { |k, v| [cql_literal(k), cql_literal(v)].join(": ") }
+        .join(", ")
+      "{#{str}}"
+    end
+
+    def quote(value)
+      "'#{value.to_s.gsub("\'", "\'\'")}'"
+    end
+
+    def nan?(value)
+      value.nil? || value.to_s.eql?("NaN")
+    end
+
+    def infinity?(value)
+      value.to_s.eql?("Infinity")
+    end
+
+    def unchanged?(value)
+      number?(value) || uuid?(value) || blob?(value) || bool?(value)
+    end
+
+    def uuid?(value)
+      value.to_s[/^\h{8}(-\h{4}){3}-\h{12}$/]
+    end
+
+    def blob?(value)
+      value.to_s[/^0[xX]./]
+    end
+
+    def number?(value)
+      value.is_a? Numeric
+    end
+
+    def bool?(value)
+      [true, false].include? value
+    end
+
+    def hash?(value)
+      value.instance_of? Hash
+    end
+
+    def array?(value)
+      value.instance_of? Array
+    end
+
+  end
+
+end # module QueryBuilder::CQL::Operators