yugabyte-ycql-driver 3.2.3.1

data/lib/cassandra/statements/simple.rb

@@ -0,0 +1,118 @@
+# encoding: utf-8
+
+#--
+# Copyright DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#++
+
+module Cassandra
+  module Statements
+    class Simple
+      include Statement
+
+      # @return [String] original cql used to prepare this statement
+      attr_reader :cql
+      # @return [Array<Object>] a list of positional parameters for the cql
+      attr_reader :params
+
+      # @private
+      attr_reader :params_types
+
+      # @private
+      attr_reader :params_names
+
+      # @param cql [String] a cql statement
+      # @param params [Array, Hash] (nil) positional or named arguments
+      #   for the query
+      # @param type_hints [Array, Hash] (nil) positional or named types
+      #   to override type guessing for the query
+      # @param idempotent [Boolean] (false) whether this statement can be
+      #   safely retries on timeouts
+      #
+      # @note Positional arguments for simple statements are only supported
+      #   starting with Apache Cassandra 2.0 and above.
+      #
+      # @note Named arguments for simple statements are only supported
+      #   starting with Apache Cassandra 2.1 and above.
+      #
+      # @raise [ArgumentError] if cql statement given is not a String
+      def initialize(cql, params = nil, type_hints = nil, idempotent = false)
+        Util.assert_instance_of(::String, cql) do
+          "cql must be a string, #{cql.inspect} given"
+        end
+
+        params ||= EMPTY_LIST
+
+        if params.is_a?(::Hash)
+          params_names = []
+          params = params.each_with_object([]) do |(name, value), collector|
+            params_names << name
+            collector    << value
+          end
+          if type_hints && !type_hints.empty?
+            Util.assert_instance_of(::Hash, type_hints) do
+              'type_hints must be a Hash when using named params'
+            end
+          end
+        else
+          Util.assert_instance_of(::Array, params) do
+            "params must be an Array or a Hash, #{params.inspect} given"
+          end
+          params_names = EMPTY_LIST
+        end
+
+        type_hints ||= EMPTY_LIST
+
+        if type_hints.is_a?(::Hash)
+          type_hints = params_names.map {|name| type_hints[name] }
+        else
+          Util.assert_instance_of(::Array, type_hints) do
+            "type_hints must be an Array or a Hash, #{type_hints.inspect} given"
+          end
+        end
+
+        @cql          = cql
+        @params       = params
+        @params_types = params.each_with_index.map do |value, index|
+          (!type_hints.empty? && type_hints[index] && type_hints[index].is_a?(Type)) ?
+              type_hints[index] :
+              Util.guess_type(value)
+        end
+        @params_names = params_names
+        @idempotent   = idempotent
+      end
+
+      # @private
+      def accept(client, options)
+        client.query(self, options)
+      end
+
+      # @return [String] a CLI-friendly simple statement representation
+      def inspect
+        "#<#{self.class.name}:0x#{object_id.to_s(16)} @cql=#{@cql.inspect} " \
+            "@params=#{@params.inspect}>"
+      end
+
+      # @param other [Object, Cassandra::Statements::Simple] object to compare
+      # @return [Boolean] whether the statements are equal
+      def eql?(other)
+        other.is_a?(Simple) &&
+          @cql == other.cql &&
+          @params == other.params
+      end
+
+      alias == eql?
+    end
+  end
+end

data/lib/cassandra/statements/void.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+#--
+# Copyright DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#++
+
+module Cassandra
+  module Statements
+    # This statement is passed to {Cassandra::LoadBalancing::Policy#plan} when
+    # establishing connections and preparing statements
+    class Void
+      include Statement
+
+      # @private
+      def accept(client, options)
+        nil
+      end
+
+      # Returns nothing
+      # @return [nil] there is no cql for the void statement
+      def cql
+        nil
+      end
+    end
+  end
+end

data/lib/cassandra/table.rb

@@ -0,0 +1,240 @@
+# encoding: utf-8
+
+#--
+# Copyright DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#++
+
+module Cassandra
+  # Represents a cassandra table
+  # @see Cassandra::Keyspace#each_table
+  # @see Cassandra::Keyspace#table
+  class Table < ColumnContainer
+    # @return [Array<Symbol>] an array of order values (`:asc` or `:desc`) that apply to the
+    #   `clustering_columns` array.
+    attr_reader :clustering_order
+
+    # @private
+    def initialize(keyspace,
+                   name,
+                   partition_key,
+                   clustering_columns,
+                   other_columns,
+                   options,
+                   clustering_order,
+                   id)
+      super(keyspace, name, partition_key, clustering_columns, other_columns, options, id)
+      @clustering_order = clustering_order.freeze
+      @indexes = []
+      @indexes_hash = {}
+      @materialized_views = []
+      @materialized_views_hash = {}
+      @triggers = []
+      @triggers_hash = {}
+    end
+
+    # @param name [String] index name
+    # @return [Boolean] whether this table has a given index
+    def has_index?(name)
+      @indexes_hash.key?(name)
+    end
+
+    # @param name [String] index name
+    # @return [Cassandra::Index, nil] an index or nil
+    def index(name)
+      @indexes_hash[name]
+    end
+
+    # Yield or enumerate each index bound to this table
+    # @overload each_index
+    #   @yieldparam index [Cassandra::Index] current index
+    #   @return [Cassandra::Table] self
+    # @overload each_index
+    #   @return [Array<Cassandra::Index>] a list of indexes
+    def each_index(&block)
+      if block_given?
+        @indexes.each(&block)
+        self
+      else
+        @indexes.freeze
+      end
+    end
+    alias indexes each_index
+
+    # @param name [String] trigger name
+    # @return [Boolean] whether this table has a given trigger
+    def has_trigger?(name)
+      @triggers_hash.key?(name)
+    end
+
+    # @param name [String] trigger name
+    # @return [Cassandra::Trigger, nil] a trigger or nil
+    def trigger(name)
+      @triggers_hash[name]
+    end
+
+    # Yield or enumerate each trigger bound to this table
+    # @overload each_trigger
+    #   @yieldparam trigger [Cassandra::Index] current trigger
+    #   @return [Cassandra::Table] self
+    # @overload each_trigger
+    #   @return [Array<Cassandra::Trigger>] a list of triggers
+    def each_trigger(&block)
+      if block_given?
+        @triggers.each(&block)
+        self
+      else
+        @triggers.freeze
+      end
+    end
+    alias triggers each_trigger
+
+    # @param name [String] materialized view name
+    # @return [Boolean] whether this table has a given materialized view
+    def has_materialized_view?(name)
+      @materialized_views_hash.key?(name)
+    end
+
+    # @param name [String] materialized view name
+    # @return [Cassandra::MaterializedView, nil] a materialized view or nil
+    def materialized_view(name)
+      @materialized_views_hash[name]
+    end
+
+    # Yield or enumerate each materialized view bound to this table
+    # @overload each_materialized_view
+    #   @yieldparam materialized_view [Cassandra::MaterializedView] current materialized view
+    #   @return [Cassandra::Table] self
+    # @overload each_materialized_view
+    #   @return [Array<Cassandra::MaterializedView>] a list of materialized views
+    def each_materialized_view(&block)
+      if block_given?
+        @materialized_views.each(&block)
+        self
+      else
+        @materialized_views.freeze
+      end
+    end
+    alias materialized_views each_materialized_view
+
+    # @return [String] a cql representation of this table
+    def to_cql
+      cql = "CREATE TABLE #{Util.escape_name(@keyspace.name)}.#{Util.escape_name(@name)} (\n"
+      primary_key = @partition_key.first.name if @partition_key.one? && @clustering_columns.empty?
+
+      first = true
+      @columns.each do |column|
+        if first
+          first = false
+        else
+          cql << ",\n"
+        end
+        cql << "  #{Util.escape_name(column.name)} #{type_to_cql(column.type, column.frozen?)}"
+        cql << ' PRIMARY KEY' if primary_key && column.name == primary_key
+      end
+
+      unless primary_key
+        cql << ",\n  PRIMARY KEY ("
+        if @partition_key.one?
+          cql << Util.escape_name(@partition_key.first.name)
+        else
+          cql << '('
+          first = true
+          @partition_key.each do |column|
+            if first
+              first = false
+            else
+              cql << ', '
+            end
+            cql << Util.escape_name(column.name)
+          end
+          cql << ')'
+        end
+        @clustering_columns.each do |column|
+          cql << ", #{Util.escape_name(column.name)}"
+        end
+        cql << ')'
+      end
+
+      cql << "\n)\nWITH "
+
+      if !@clustering_order.empty? && !@clustering_columns.empty?
+        cql << 'CLUSTERING ORDER BY ('
+        first = true
+        @clustering_columns.zip(@clustering_order) do |column, order|
+          if first
+            first = false
+          else
+            cql << ', '
+          end
+          cql << "#{Util.escape_name(column.name)} #{order.to_s.upcase}"
+        end
+        cql << ")\n AND "
+      end
+
+      cql << @options.to_cql.split("\n").join("\n ")
+
+      cql << ';'
+    end
+
+    # @private
+    def add_index(index)
+      @indexes << index
+      @indexes_hash[index.name] = index
+    end
+
+    # @private
+    def add_view(view)
+      @materialized_views << view
+      @materialized_views_hash[view.name] = view
+    end
+
+    # @private
+    def add_trigger(trigger)
+      @triggers << trigger
+      @triggers_hash[trigger.name] = trigger
+    end
+
+    # @private
+    def eql?(other)
+      other.is_a?(Table) &&
+        super.eql?(other) &&
+        @clustering_order == other.clustering_order &&
+        @indexes == other.indexes
+    end
+    alias == eql?
+
+    private
+
+    # @private
+    def type_to_cql(type, is_frozen)
+      case type.kind
+      when :tuple
+        "frozen <#{type}>"
+      when :udt
+        if @keyspace.name == type.keyspace
+          "frozen <#{Util.escape_name(type.name)}>"
+        else
+          "frozen <#{Util.escape_name(type.keyspace)}.#{Util.escape_name(type.name)}>"
+        end
+      else
+        if is_frozen
+          "frozen <#{type}>"
+        else
+          type.to_s
+        end
+      end
+    end
+  end
+end

data/lib/cassandra/time.rb

@@ -0,0 +1,103 @@
+# encoding: utf-8
+
+#--
+# Copyright DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#++
+
+module Cassandra
+  # Represents a Cassandra time type.
+  class Time
+    # @private
+    NANOSECONDS_IN_MILISECOND = 1_000_000
+    # @private
+    NANOSECONDS_IN_SECOND     = NANOSECONDS_IN_MILISECOND * 1000
+    # @private
+    NANOSECONDS_IN_MINUTE     = NANOSECONDS_IN_SECOND * 60
+    # @private
+    NANOSECONDS_IN_HOUR       = NANOSECONDS_IN_MINUTE * 60
+    # @private
+    NANOSECONDS_IN_DAY        = NANOSECONDS_IN_HOUR * 24
+
+    include ::Comparable
+
+    # @private
+    def initialize(nanoseconds = 0)
+      if nanoseconds < 0 && nanoseconds > NANOSECONDS_IN_DAY - 1
+        raise ::ArgumentError, 'value must be between 0 and ' \
+                               "#{NANOSECONDS_IN_DAY}, #{value.inspect} given"
+      end
+
+      @nanoseconds = nanoseconds
+    end
+
+    # @return [Integer] an integer between 0 and 24, the number of full hours
+    #   since midnight that this time represents
+    def hours
+      @nanoseconds / NANOSECONDS_IN_HOUR
+    end
+
+    # @return [Integer] an integer between 0 and 60, the number of full minutes
+    #   since the last full hour that this time represents
+    def minutes
+      (@nanoseconds - (hours * NANOSECONDS_IN_HOUR)) / NANOSECONDS_IN_MINUTE
+    end
+
+    # @return [Integer] an integer between 0 and 60, the number of full seconds
+    #   since the last full minutes that this time represents
+    def seconds
+      (@nanoseconds -
+          (hours * NANOSECONDS_IN_HOUR) -
+          (minutes * NANOSECONDS_IN_MINUTE)) / NANOSECONDS_IN_SECOND
+    end
+
+    # @return [Integer] an integer between 0 and 60, the number of full
+    #   miliseconds since the last full second that this time represents
+    def miliseconds
+      (@nanoseconds -
+          (hours * NANOSECONDS_IN_HOUR) -
+          (minutes * NANOSECONDS_IN_MINUTE) -
+          (seconds * NANOSECONDS_IN_SECOND)) / NANOSECONDS_IN_MILISECOND
+    end
+
+    # @return [String] a "%H:%M%S.%3N" formatted time string
+    def to_s
+      format('%.2d:%.2d:%.2d.%.3d', hours, minutes, seconds, miliseconds)
+    end
+
+    # @return [Integer] an integer between 0 and 86400000000000, the number of
+    #   nanoseconds since midnight that this time represents
+    def to_nanoseconds
+      @nanoseconds
+    end
+
+    # @private
+    def eql?(other)
+      other.is_a?(Time) && other.to_nanoseconds == @nanoseconds
+    end
+    alias == eql?
+
+    # @private
+    def <=>(other)
+      other <=> nanoseconds
+    end
+
+    # @private
+    def hash
+      # Modeled after http://developer.android.com/reference/java/lang/Object.html#writing_hashCode, but
+      # simplified since only one field participates in the hash.
+      @hash ||= 31 * 17 + @nanoseconds.hash
+    end
+  end
+end