query_builder 0.0.1

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

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+module QueryBuilder::CQL
+
+  module Modifiers
+
+    # Provides COUNTER batch type
+    #
+    module Counter
+
+      # Adds a clause to the statement
+      #
+      # @return [QueryBuilder::Core::Statement] updated statement
+      #
+      def counter
+        self << Clause.new
+      end
+
+      private
+
+      def maybe_type
+        clauses(:type)
+      end
+
+      # The clause for adding to a statement
+      #
+      # @api private
+      #
+      class Clause < Base
+
+        unique
+        type :type
+
+        # @private
+        def to_s
+          "COUNTER"
+        end
+
+      end # class Clause
+
+    end # module Counter
+
+  end # module Modifiers
+
+end # module QueryBuilder::CQL

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

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+module QueryBuilder::CQL
+
+  module Modifiers
+
+    # Provides columns for DELETE statement
+    #
+    module Delete
+
+      # Adds columns that should be deleted
+      #
+      # @param [#to_s, Array<#to_s>] columns
+      #
+      # @return [QueryBuilder::Core::Statement] updated statement
+      #
+      def delete(*columns)
+        columns.map { |name| Clause.new(name: name) }.inject(self, :<<)
+      end
+
+      private
+
+      def maybe_columns
+        clauses(:column).join(", ")
+      end
+
+      # The clause for adding to a statement
+      #
+      # @api private
+      #
+      class Clause < Base
+
+        type :column
+        attribute :name, required: true
+
+        # @private
+        def to_s
+          return name.to_s unless name.instance_of? Array
+          "(#{name.join(", ")})"
+        end
+
+      end # class Clause
+
+    end # module Delete
+
+  end # module Modifiers
+
+end # module QueryBuilder::CQL

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

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+module QueryBuilder::CQL
+
+  module Modifiers
+
+    # Provides DISTINCT clauses for statements
+    #
+    module Distinct
+
+      # Adds DISTINCT clause to the statement
+      #
+      # @return [QueryBuilder::Core::Statement] updated statement
+      #
+      def distinct
+        self << Clause.new
+      end
+
+      private
+
+      def maybe_distinct
+        clauses(:distinct)
+      end
+
+      # The clause for adding to a statement
+      #
+      # @api private
+      #
+      class Clause < Base
+
+        unique
+        type :distinct
+
+        # @private
+        def to_s
+          "DISTINCT"
+        end
+
+      end # class Clause
+
+    end # module Distinct
+
+  end # module Modifiers
+
+end # module QueryBuilder::CQL

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

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+module QueryBuilder::CQL
+
+  module Modifiers
+
+    # Provides FINALFUNC clauses for statements
+    #
+    module Finalfunc
+
+      # Adds FINALFUNC clause to the statement
+      #
+      # @param [#to_s] name
+      #
+      # @return [QueryBuilder::Core::Statement] updated statement
+      #
+      def finalfunc(name)
+        self << Clause.new(name: name)
+      end
+
+      private
+
+      def maybe_functions
+        clauses(:function).join(" ")
+      end
+
+      # The clause for adding to a statement
+      #
+      # @api private
+      #
+      class Clause < Base
+
+        type :function
+        attribute :name, required: true
+
+        # @private
+        def to_s
+          "FINALFUNC #{name}"
+        end
+
+      end # class Clause
+
+    end # module Finalfunc
+
+  end # module Modifiers
+
+end # module QueryBuilder::CQL

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

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

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

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+module QueryBuilder::CQL
+
+  module Modifiers
+
+    # Provides IF EXISTS clauses for statements
+    #
+    module IfExists
+
+      # Adds IF EXISTS clause to the statement
+      #
+      # @return [QueryBuilder::Core::Statement] updated statement
+      #
+      def if_exists
+        self << Clause.new
+      end
+
+      private
+
+      def maybe_if
+        list = clauses(:if)
+        ["IF", list.sort.join(" AND ")] if list.any?
+      end
+
+      # The clause for adding to a statement
+      #
+      # @api private
+      #
+      class Clause < Base
+
+        unique
+        type :if
+
+        # @private
+        def to_s
+          "EXISTS"
+        end
+
+      end # class Clause
+
+    end # module IfExists
+
+  end # module Modifiers
+
+end # module QueryBuilder::CQL

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

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+module QueryBuilder::CQL
+
+  module Modifiers
+
+    # Provides IF NOT EXISTS clauses for statements
+    #
+    module IfNotExists
+
+      # Adds IF NOT EXISTS clause to the statement
+      #
+      # @return [QueryBuilder::Core::Statement] updated statement
+      #
+      def if_not_exists
+        self << Clause.new
+      end
+
+      private
+
+      def maybe_if
+        list = clauses(:if)
+        ["IF", list.sort.join(" AND ")] if list.any?
+      end
+
+      # The clause for adding to a statement
+      #
+      # @api private
+      #
+      class Clause < Base
+
+        unique
+        type :if
+
+        # @private
+        def to_s
+          "NOT EXISTS"
+        end
+
+      end # class Clause
+
+    end # module IfNotExists
+
+  end # module Modifiers
+
+end # module QueryBuilder::CQL

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

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+module QueryBuilder::CQL
+
+  module Modifiers
+
+    # Provides INITCOND clauses for statements
+    #
+    module Initcond
+
+      # Adds INITCOND clause to the statement
+      #
+      # @param [#to_s] left
+      # @param [#to_s] right
+      #
+      # @return [QueryBuilder::Core::Statement] updated statement
+      #
+      def initcond(left, right)
+        self << Clause.new(left: left, right: right)
+      end
+
+      private
+
+      def maybe_functions
+        clauses(:function).join(" ")
+      end
+
+      # The clause for adding to a statement
+      #
+      # @api private
+      #
+      class Clause < Base
+
+        type :function
+        attribute :left,  required: true
+        attribute :right, required: true
+
+        # @private
+        def to_s
+          "INITCOND (#{left}, #{right})"
+        end
+
+      end # class Clause
+
+    end # module Initcond
+
+  end # module Modifiers
+
+end # module QueryBuilder::CQL

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

@@ -0,0 +1,68 @@
+# encoding: utf-8
+
+module QueryBuilder::CQL
+
+  module Modifiers
+
+    # Provides columns and values for INSERT statement
+    #
+    module Insert
+
+      # Defines value to be inserted
+      #
+      # @param [Hash] options
+      #
+      # @return [QueryBuilder::Core::Statement] updated statement
+      #
+      def insert(options)
+        options
+          .flat_map { |k, v| [Column.new(name: k), Value.new(name: v)] }
+          .inject(self, :<<)
+      end
+
+      private
+
+      def maybe_insert
+        [:column, :value]
+          .map { |type| "(#{clauses(type).join(", ")})" }
+          .join(" VALUES ")
+      end
+
+      # The clause defining a column
+      #
+      # @api private
+      #
+      class Column < Base
+
+        type :column
+        attribute :name, required: true
+
+        # @private
+        def to_s
+          return name.to_s unless name.instance_of? Array
+          "(#{name.join(", ")})"
+        end
+
+      end # class Column
+
+      # The clause defining a value
+      #
+      # @api private
+      #
+      class Value < Base
+
+        type :value
+        attribute :name, required: true
+
+        # @private
+        def to_s
+          cql_literal[name]
+        end
+
+      end # class Value
+
+    end # module Insert
+
+  end # module Modifiers
+
+end # module QueryBuilder::CQL