query_builder 0.0.1

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

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

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

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+module QueryBuilder::CQL
+
+  module Modifiers
+
+    # Provides STYPE clauses for statements
+    #
+    module Stype
+
+      # Adds STYPE clause to the statement
+      #
+      # @param [#to_s] name
+      #
+      # @return [QueryBuilder::Core::Statement] updated statement
+      #
+      def stype(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
+          "STYPE #{name}"
+        end
+
+      end # class Clause
+
+    end # module Stype
+
+  end # module Modifiers
+
+end # module QueryBuilder::CQL

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

@@ -0,0 +1,54 @@
+# encoding: utf-8
+
+module QueryBuilder::CQL
+
+  module Modifiers
+
+    # Provides (NO)SUPERUSER clauses for statements
+    #
+    module Superuser
+
+      # Adds (NO)SUPERUSER clause to the statement
+      #
+      # @param [Boolean] option (true)
+      #
+      # @return [QueryBuilder::Core::Statement] updated statement
+      #
+      def superuser(option = true)
+        self << Clause.new(reverse: !option)
+      end
+
+      private
+
+      def maybe_superuser
+        clauses(:superuser)
+      end
+
+      # The clause for adding to a statement
+      #
+      # @api private
+      #
+      class Clause < Base
+
+        unique
+        type :superuser
+        attribute :reverse, default: false
+
+        # @private
+        def to_s
+          "#{maybe_no}SUPERUSER"
+        end
+
+        private
+
+        def maybe_no
+          "NO" if reverse
+        end
+
+      end # class Clause
+
+    end # module Superuser
+
+  end # module Modifiers
+
+end # module QueryBuilder::CQL

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

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+module QueryBuilder::CQL
+
+  module Modifiers
+
+    # Provides LIMIT clauses for statements
+    #
+    module Timestamp
+
+      # Adds LIMIT clause to the statement
+      #
+      # @param [Integer] value
+      #
+      # @return [QueryBuilder::Core::Statement] updated statement
+      #
+      def timestamp(value)
+        self << Clause.new(value: value)
+      end
+
+      private
+
+      def maybe_using
+        list = clauses(:using)
+        ["USING", list.sort.join(" AND ")] if list.any?
+      end
+
+      # The clause for adding to a statement
+      #
+      # @api private
+      #
+      class Clause < Base
+
+        unique
+        type :using
+
+        attribute :value, required: true
+
+        # @private
+        def to_s
+          "TIMESTAMP #{value}"
+        end
+
+      end # class Clause
+
+    end # module Timestamp
+
+  end # module Modifiers
+
+end # module QueryBuilder::CQL

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

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+module QueryBuilder::CQL
+
+  module Modifiers
+
+    # Provides UNLOGGED batch type
+    #
+    module Unlogged
+
+      # Adds a clause to the statement
+      #
+      # @return [QueryBuilder::Core::Statement] updated statement
+      #
+      def unlogged
+        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
+          "UNLOGGED"
+        end
+
+      end # class Clause
+
+    end # module Unlogged
+
+  end # module Modifiers
+
+end # module QueryBuilder::CQL

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

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

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

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+module QueryBuilder::CQL
+
+  module Modifiers
+
+    # Provides USING clauses for statements
+    #
+    module Using
+
+      # Defines java class for the index
+      #
+      # @param [#to_s] java_class
+      #
+      # @return [QueryBuilder::Core::Statement] updated statement
+      #
+      def using(java_class)
+        self << Clause.new(value: java_class)
+      end
+
+      private
+
+      def maybe_using
+        list = clauses(:using)
+        ["USING", list.sort.join(" AND ")] if list.any?
+      end
+
+      # The clause for adding to a statement
+      #
+      # @api private
+      #
+      class Clause < Base
+
+        type :using
+        attribute :value, required: true
+
+        # @private
+        def to_s
+          cql_literal[value]
+        end
+
+      end # class Clause
+
+    end # module Using
+
+  end # module Modifiers
+
+end # module QueryBuilder::CQL

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

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+module QueryBuilder::CQL
+
+  module Modifiers
+
+    # Provides USING clauses for statements with various options
+    #
+    module UsingOptions
+
+      # Adds USING clause to the statement
+      #
+      # @param [Hash] options
+      #
+      # @return [QueryBuilder::Core::Statement] updated statement
+      #
+      def using(options)
+        options
+          .map { |key, value| Clause.new(property: key, value: value) }
+          .inject(self, :<<)
+      end
+
+      private
+
+      def maybe_using
+        list = clauses(:using)
+        ["USING", list.sort.join(" AND ")] if list.any?
+      end
+
+      # The clause for adding to a statement
+      #
+      # @api private
+      #
+      class Clause < Base
+
+        type :using
+        attribute :property, required: true
+        attribute :value, required: true
+
+        # @private
+        def to_s
+          "#{property.upcase} #{cql_literal[value]}"
+        end
+
+      end # class Clause
+
+    end # module UsingOptions
+
+  end # module Modifiers
+
+end # module QueryBuilder::CQL

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

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

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

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+module QueryBuilder::CQL
+
+  module Modifiers
+
+    # Provides WHERE clauses for clustered columns in statements
+    #
+    module WhereClustered
+
+      # Adds WHERE clause to the statement
+      #
+      # @param [Hash] options
+      #
+      # @return [QueryBuilder::Core::Statement] updated statement
+      #
+      def where_clustered(options)
+        self << Clause.new(columns: options.keys, values: options.values)
+      end
+
+      private
+
+      def maybe_where
+        list = clauses(:where)
+        ["WHERE", list.join(" AND ")] if list.any?
+      end
+
+      # The clause for adding to a statement
+      #
+      # @api private
+      #
+      class Clause < Base
+
+        type :where
+        attribute :columns, required: true
+        attribute :values,  required: true
+
+        def to_s
+          [
+            "(#{columns.join(", ")})",
+            "(#{values.map { |value| cql_literal[value] }.join(", ")})"
+          ].join(" = ")
+        end
+
+      end # class Clause
+
+    end # module WhereClustered
+
+  end # module Modifiers
+
+end # module QueryBuilder::CQL