query_builder 0.0.1

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

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+module QueryBuilder::CQL
+
+  module Modifiers
+
+    # Provides column for CREATE INDEX statement
+    #
+    # @api public
+    #
+    module AddColumn
+
+      # Adds columns to the index
+      #
+      # @param [#to_s, Array<#to_s>] cols
+      #
+      # @return [QueryBuilder::Core::Statement] updated statement
+      #
+      def add(*cols)
+        cols.map { |col| Clause.new(name: col) }.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 AddColumn
+
+  end # module Modifiers
+
+end # module QueryBuilder::CQL

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

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+module QueryBuilder::CQL
+
+  module Modifiers
+
+    # Provides fields for CREATE TYPE statement
+    #
+    module AddField
+
+      # Adds field to the type
+      #
+      # @param [#to_s] name
+      # @param [#to_s] type
+      #
+      # @return [QueryBuilder::Core::Statement] updated statement
+      #
+      def add(name, type)
+        self << Clause.new(name: name, type_name: type)
+      end
+
+      private
+
+      def maybe_fields
+        "(#{clauses(:column).join(", ")})"
+      end
+
+      # The clause for adding to a statement
+      #
+      # @api private
+      #
+      class Clause < Base
+
+        type :column
+        attribute :name, required: true
+        attribute :type_name, required: true
+
+        # @private
+        def to_s
+          [name, type_name].join(" ")
+        end
+
+      end # class Clause
+
+    end # module AddField
+
+  end # module Modifiers
+
+end # module QueryBuilder::CQL

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

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

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

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+module QueryBuilder::CQL
+
+  module Modifiers
+
+    # Provides WITH clauses for statements like ALTER TABLE
+    #
+    module Alter
+
+      # Adds WITH clause to the statement
+      #
+      # @param [Hash] options
+      #
+      # @return [QueryBuilder::Core::Statement] updated statement
+      #
+      def alter(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 Alter
+
+  end # module Modifiers
+
+end # module QueryBuilder::CQL

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

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+module QueryBuilder::CQL
+
+  module Modifiers
+
+    # Provides column for CALLED ON NULL statement
+    #
+    # @api public
+    #
+    module CalledOnNull
+
+      # Adds CALLED ON NULL to the index
+      #
+      # @return [QueryBuilder::Core::Statement] updated statement
+      #
+      def called_on_null
+        self << Clause.new
+      end
+
+      private
+
+      def maybe_called
+        called = clauses(:called).last
+        [(called ? called : "RETURNS NULL"), "ON NULL INPUT"].join(" ")
+      end
+
+      # The clause for adding to a statement
+      #
+      # @api private
+      #
+      class Clause < Base
+
+        type :called
+
+        # @private
+        def to_s
+          "CALLED"
+        end
+
+      end # class Clause
+
+    end # module CalledOnNull
+
+  end # module Modifiers
+
+end # module QueryBuilder::CQL

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

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+module QueryBuilder::CQL
+
+  module Modifiers
+
+    # Provides CLUSTERING ORDER clauses for statements
+    #
+    module ClusteringOrder
+
+      # Adds CLUSTERNING ORDER clause to the statement
+      #
+      # @param [#to_s] name The name of the column
+      # @param [:asc, :desc] order The order of clustering
+      #
+      # @return [QueryBuilder::Core::Statement] updated statement
+      #
+      def clustering_order(name, order = :asc)
+        self << Clause.new(name: name, desc: order.equal?(:desc))
+      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
+
+        unique
+        type :with
+        attribute :name, required: true
+        attribute :desc, default: false
+
+        # @private
+        def to_s
+          "CLUSTERING ORDER BY (#{name} #{desc ? "DESC" : "ASC"})"
+        end
+
+      end # class Clause
+
+    end # module ClusteringOrder
+
+  end # module Modifiers
+
+end # module QueryBuilder::CQL

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

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+module QueryBuilder::CQL
+
+  module Modifiers
+
+    # Provides columns for CREATE TYPE statement
+    #
+    module Column
+
+      # Adds column to the table
+      #
+      # @param [#to_s] name
+      # @param [#to_s] type_name
+      # @param [Hash] options
+      # @option options [Boolean] :static
+      #
+      # @return [QueryBuilder::Core::Statement] updated statement
+      #
+      def add(name, type_name, options = {})
+        self << Clause
+          .new(name: name, type_name: type_name, static: options[:static])
+      end
+
+      private
+
+      def maybe_columns
+        "(#{(clauses(:column) + clauses(:primary_key)).compact.join(", ")})"
+      end
+
+      # The clause for adding to a statement
+      #
+      # @api private
+      #
+      class Clause < Base
+
+        type :column
+        attribute :name, required: true
+        attribute :type_name, required: true
+        attribute :static, default: false
+
+        # @private
+        def to_s
+          [name, type_name, maybe_static].compact.join(" ")
+        end
+
+        private
+
+        def maybe_static
+          "STATIC" if static
+        end
+
+      end # class Clause
+
+    end # module Column
+
+  end # module Modifiers
+
+end # module QueryBuilder::CQL

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

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+module QueryBuilder::CQL
+
+  module Modifiers
+
+    # Provides COMPACT STORAGE clauses for statements
+    #
+    module CompactStorage
+
+      # Adds COMPACT STORAGE clause to the statement
+      #
+      # @return [QueryBuilder::Core::Statement] updated statement
+      #
+      def compact_storage
+        self << Clause.new
+      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
+
+        unique
+        type :with
+
+        # @private
+        def to_s
+          "COMPACT STORAGE"
+        end
+
+      end # class Clause
+
+    end # module CompactStorage
+
+  end # module Modifiers
+
+end # module QueryBuilder::CQL

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

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+module QueryBuilder::CQL
+
+  module Modifiers
+
+    # Provides COUNT(*|1) clause to SELECT statement
+    #
+    module Count
+
+      # Adds COUNT clause to the statement
+      #
+      # @param [Integer] value
+      #
+      # @return [QueryBuilder::Core::Statement] updated statement
+      #
+      def count(value = nil)
+        self << Clause.new(value: value)
+      end
+
+      private
+
+      def maybe_selected
+        list = clauses(:selected)
+        list.any? ? list.join(", ") : "*"
+      end
+
+      # The clause for adding to a statement
+      #
+      # @api private
+      #
+      class Clause < Base
+
+        type :selected
+        attribute :value
+
+        def to_s
+          "COUNT(#{value ? value : "*"})"
+        end
+
+      end # class Clause
+
+    end # module Count
+
+  end # module Modifiers
+
+end # module QueryBuilder::CQL