cassandra-driver 1.0.0.beta.2-java

data/lib/cassandra/table.rb

@@ -0,0 +1,299 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2014 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
+    # @private
+    class Options
+      attr_reader :comment, :read_repair_chance, :local_read_repair_chance,
+                  :gc_grace_seconds, :caching, :bloom_filter_fp_chance,
+                  :populate_io_cache_on_flush, :memtable_flush_period_in_ms,
+                  :default_time_to_live, :speculative_retry, :index_interval,
+                  :replicate_on_write, :compaction_strategy, :compact_storage,
+                  :compression_parameters
+
+      def initialize(data, compaction_strategy, compression_parameters, compact_storage, cassandra_version)
+        @comment                     = data['comment']
+        @read_repair_chance          = data['read_repair_chance']
+        @local_read_repair_chance    = data['local_read_repair_chance']
+        @gc_grace_seconds            = data['gc_grace_seconds']
+        @caching                     = data['caching']
+        @bloom_filter_fp_chance      = data['bloom_filter_fp_chance']      || 0.01
+        @populate_io_cache_on_flush  = data['populate_io_cache_on_flush']  || false
+        @memtable_flush_period_in_ms = data['memtable_flush_period_in_ms'] || 0
+        @default_time_to_live        = data['default_time_to_live']        || 0
+        @speculative_retry           = data['speculative_retry']           || 'NONE'
+        @index_interval              = data['index_interval']              || 128
+        @replicate_on_write          = data['replicate_on_write']          || true
+        @compaction_strategy         = compaction_strategy
+        @compression_parameters      = compression_parameters
+        @compact_storage             = compact_storage
+        @cassandra_version           = cassandra_version
+      end
+
+      def replicate_on_write?
+        @replicate_on_write
+      end
+
+      def populate_io_cache_on_flush?
+        @populate_io_cache_on_flush
+      end
+
+      def compact_storage?
+        @compact_storage
+      end
+
+      def to_cql
+        options = []
+
+        options << 'COMPACT STORAGE' if @compact_storage
+        options << "bloom_filter_fp_chance = #{@bloom_filter_fp_chance}"
+        options << "caching = '#{@caching}'"
+        options << "comment = '#{@comment}'" if @comment
+        options << "compaction = #{@compaction_strategy.to_cql}"
+        options << "compression = #{Util.encode_hash(@compression_parameters)}"
+        options << "dclocal_read_repair_chance = #{@local_read_repair_chance}"
+        options << "default_time_to_live = #{@default_time_to_live}" if !@cassandra_version.start_with?('1')
+        options << "gc_grace_seconds = #{@gc_grace_seconds}"
+        options << "index_interval = #{@index_interval}" if !@cassandra_version.start_with?('1')
+        options << "populate_io_cache_on_flush = '#{@populate_io_cache_on_flush}'"
+        options << "read_repair_chance = #{@read_repair_chance}"
+        options << "replicate_on_write = '#{@replicate_on_write}'" if @cassandra_version.start_with?('1') || @cassandra_version.start_with?('2.0')
+        options << "speculative_retry = '#{@speculative_retry}'" if !@cassandra_version.start_with?('1')
+
+        options.join("\nAND ")
+      end
+
+      def eql?(other)
+        other.is_a?(Options) &&
+          @comment == other.comment &&
+          @read_repair_chance == other.read_repair_chance &&
+          @local_read_repair_chance == other.local_read_repair_chance &&
+          @gc_grace_seconds == other.gc_grace_seconds &&
+          @caching == other.caching &&
+          @bloom_filter_fp_chance == other.bloom_filter_fp_chance &&
+          @populate_io_cache_on_flush == other.populate_io_cache_on_flush &&
+          @memtable_flush_period_in_ms == other.memtable_flush_period_in_ms &&
+          @default_time_to_live == other.default_time_to_live &&
+          @speculative_retry == other.speculative_retry &&
+          @index_interval == other.index_interval &&
+          @replicate_on_write == other.replicate_on_write &&
+          @compaction_strategy == other.compaction_strategy &&
+          @compression_parameters == other.compression_parameters &&
+          @compact_storage == other.compact_storage &&
+          @cassandra_version == other.cassandra_version
+      end
+      alias :== :eql?
+
+      attr_reader :cassandra_version
+      protected :cassandra_version
+    end
+
+    # @private
+    class Compaction
+      attr_reader :klass, :options
+
+      def initialize(klass, options)
+        @klass   = klass
+        @options = options
+      end
+
+      def to_cql
+        compaction = {'class' => @klass}
+        compaction.merge!(@options)
+
+        Util.encode_hash(compaction)
+      end
+
+      def eql?(other)
+        other.is_a?(Compaction) &&
+          @klass == other.klass &&
+          @options == other.options
+      end
+      alias :== :eql?
+    end
+
+    # @private
+    attr_reader :keyspace
+    # @return [String] table name
+    attr_reader :name
+    # @private
+    attr_reader :options
+
+    # @private
+    def initialize(keyspace, name, partition_key, clustering_columns, columns, options, clustering_order)
+      @keyspace           = keyspace
+      @name               = name
+      @partition_key      = partition_key
+      @clustering_columns = clustering_columns
+      @columns            = columns
+      @options            = options
+      @clustering_order   = clustering_order
+    end
+
+    # @param name [String] column name
+    # @return [Boolean] whether this table has a given column
+    def has_column?(name)
+      @columns.has_key?(name)
+    end
+
+    # @param name [String] column name
+    # @return [Cassandra::Column, nil] a column or nil
+    def column(name)
+      @columns[name]
+    end
+
+    # Yield or enumerate each column defined in this table
+    # @overload each_column
+    #   @yieldparam column [Cassandra::Column] current column
+    #   @return [Cassandra::Table] self
+    # @overload each_column
+    #   @return [Array<Cassandra::Column>] a list of columns
+    def each_column(&block)
+      if block_given?
+        @columns.each_value(&block)
+        self
+      else
+        @columns.values
+      end
+    end
+    alias :columns :each_column
+
+    # @return [String] a cql representation of this table
+    def to_cql
+      cql   = "CREATE TABLE #{Util.escape_name(@keyspace)}.#{Util.escape_name(@name)} (\n"
+      first = true
+      @columns.each do |(_, column)|
+        if first
+          first = false
+        else
+          cql << ",\n" unless first
+        end
+        cql << "  #{column.to_cql}"
+      end
+      cql << ",\n  PRIMARY KEY ("
+      if @partition_key.one?
+        cql << @partition_key.first.name
+      else
+        cql << '('
+        first = true
+        @partition_key.each do |column|
+          if first
+            first = false
+          else
+            cql << ', '
+          end
+          cql << column.name
+        end
+        cql << ')'
+      end
+      @clustering_columns.each do |column|
+        cql << ", #{column.name}"
+      end
+      cql << ')'
+
+      cql << "\n)\nWITH "
+
+      if @clustering_order.any? {|o| o != :asc}
+        cql << "CLUSTERING ORDER BY ("
+        first = true
+        @clustering_columns.zip(@clustering_order) do |column, order|
+          if first
+            first = false
+          else
+            cql << ', '
+          end
+          cql << "#{column.name} #{order.to_s.upcase}"
+        end
+        cql << ")\n AND "
+      end
+
+      cql << @options.to_cql.split("\n").join("\n ")
+
+      cql << ';'
+    end
+
+    # @return [Boolean] whether this table is equal to the other
+    def eql?(other)
+      other.is_a?(Table) &&
+        @keyspace == other.keyspace &&
+        @name == other.name &&
+        @partition_key == other.partition_key &&
+        @clustering_columns == other.clustering_columns &&
+        @columns == other.raw_columns &&
+        @options == other.options &&
+        @clustering_order == other.clustering_order
+    end
+    alias :== :eql?
+
+    # @private
+    def create_partition_key(values)
+      partition_key = @partition_key
+      return nil unless partition_key.size == values.size
+
+      if partition_key.one?
+        column      = partition_key.first
+        column_name = column.name
+        return nil unless values.has_key?(column_name)
+
+        buffer = Protocol::CqlByteBuffer.new
+
+        TYPE_CONVERTER.to_bytes(buffer, column.type, values[column_name])
+        buffer.discard(4)
+      else
+        buf    = nil
+        buffer = nil
+
+        partition_key.each do |column|
+          column_name = column.name
+          return nil unless values.has_key?(column_name)
+
+          buf    ||= Protocol::CqlByteBuffer.new
+          buffer ||= Protocol::CqlByteBuffer.new
+
+          TYPE_CONVERTER.to_bytes(buf, column.type, values[column_name])
+          buf.discard(4) # discard size
+
+          size = buf.length
+          buffer.append_short(size)
+          buffer << buf.read(size) << NULL_BYTE
+        end
+      end
+
+      buffer.to_str
+    end
+
+    private
+
+    NULL_BYTE = "\x00".freeze
+    TYPE_CONVERTER = Protocol::TypeConverter.new
+
+    attr_reader :partition_key, :clustering_columns, :clustering_order
+    protected :partition_key, :clustering_columns, :clustering_order
+
+    protected
+
+    # @private
+    def raw_columns
+      @columns
+    end
+  end
+end

data/lib/cassandra/time_uuid.rb

@@ -0,0 +1,142 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2014 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
+  # A variant of UUID which can extract its time component.
+  #
+  class TimeUuid < Uuid
+    include Comparable
+
+    # Returns the time component from this UUID as a Time.
+    #
+    # @return [Time]
+    def to_time
+      t = time_bits - GREGORIAN_OFFSET
+      seconds = t/10_000_000
+      microseconds = (t - seconds * 10_000_000)/10.0
+      Time.at(seconds, microseconds).utc
+    end
+
+    def <=>(other)
+      return nil unless other.kind_of?(Cassandra::Uuid)
+      c = self.value <=> other.value
+      return c if c == 0
+      self.time_bits <=> other.time_bits
+    end
+
+    protected
+
+    def time_bits
+      n = (value >> 64)
+      t = 0
+      t |= (n & 0x0000000000000fff) << 48
+      t |= (n & 0x00000000ffff0000) << 16
+      t |= (n & 0xffffffff00000000) >> 32
+      t
+    end
+
+    private
+
+    # @private
+    LOWER_HALF_MASK = 0xffffffff_ffffffff
+
+    public
+
+    # A UUID version 1, variant 1 generator. It can generate a sequence of UUIDs
+    # with reasonable uniqueness guarantees:
+    #
+    # * The clock ID and node ID components are set to random numbers when the
+    #   generator is created.
+    # * If two calls to {#next} happen within the time afforded by the system
+    #   clock resolution a counter is incremented and added to the time
+    #   component.
+    # * If the clock moves backwards the clock ID is reset to a new random
+    #   number.
+    #
+    # Instances of this class are absolutely not threadsafe. You should
+    # never share instances between threads.
+    #
+    class Generator
+      # Create a new UUID generator.
+      #
+      # @param [Integer] node_id an alternate node ID (defaults to a random number)
+      # @param [Integer] clock_id an alternate clock ID (defaults to a random number)
+      #
+      def initialize(node_id=nil, clock_id=nil, clock=Time)
+        @node_id = node_id || (rand(2**47) | 0x010000000000)
+        @clock_id = clock_id || rand(2**16)
+        @clock = clock
+      end
+
+      # Returns a new UUID with a time component that is the current time.
+      #
+      # @return [Cassandra::TimeUuid] a new UUID
+      #
+      def next
+        now = @clock.now
+        usecs = now.to_i * 1_000_000 + now.usec
+        if @last_usecs && @last_usecs - @sequence <= usecs && usecs <= @last_usecs
+          @sequence += 1
+        elsif @last_usecs && @last_usecs > usecs
+          @sequence = 0
+          @clock_id = rand(2**16)
+        else
+          @sequence = 0
+        end
+        @last_usecs = usecs + @sequence
+        from_usecs(@last_usecs)
+      end
+
+      # Returns a new UUID with a time component based on the specified Time.
+      # A piece of jitter is added to ensure that multiple calls with the same
+      # time do not generate the same UUID (if you want determinism you can set
+      # the second parameter to zero).
+      #
+      # @param [Time] time the time to encode into the UUID
+      # @param [Integer] jitter a number of microseconds to add to the time to make it unique
+      # @return [Cassandra::TimeUuid] a new UUID
+      #
+      def from_time(time, jitter=rand(2**16))
+        usecs = time.to_i * 1_000_000 + time.usec + jitter
+        from_usecs(usecs)
+      end
+
+      # @private
+      def from_usecs(usecs)
+        t = GREGORIAN_OFFSET + usecs * 10
+        time_hi  = t & 0x0fff000000000000
+        time_mid = t & 0x0000ffff00000000
+        time_low = t & 0x00000000ffffffff
+        version = 1
+        clock_id = @clock_id & 0x3fff
+        node_id = @node_id & 0xffffffffffff
+        variant = 0x8000
+        n = (time_low << 96) | (time_mid << 48) | (time_hi << 16)
+        n |= version << 76
+        n |= (clock_id | variant) << 48
+        n |= node_id
+        TimeUuid.new(n)
+      end
+    end
+
+    private
+
+    # @private
+    GREGORIAN_OFFSET = 122192928000000000
+  end
+end

data/lib/cassandra/util.rb

@@ -0,0 +1,167 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2014 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
+  # @private
+  module Util extend self
+    def encode_hash(hash, io = StringIO.new)
+      first = true
+
+      io.putc(CRL_OPN)
+      hash.each do |k, v|
+        if first
+          first = false
+        else
+          io.print(COMMA)
+        end
+
+        encode_object(k, io)
+        io.print(COLON)
+        encode_object(v, io)
+      end
+      io.putc(CRL_CLS)
+
+      io.string
+    end
+
+    def encode_set(set, io = StringIO.new)
+      first = true
+
+      io.putc(CRL_OPN)
+      set.each do |object|
+        if first
+          first = false
+        else
+          io.print(COMMA)
+        end
+
+        encode_object(object, io)
+      end
+      io.putc(CRL_CLS)
+
+      io.string
+    end
+
+    def encode_array(array, io = StringIO.new)
+      first = true
+
+      io.putc(SQR_OPN)
+      array.each do |object|
+        if first
+          first = false
+        else
+          io.print(COMMA)
+        end
+
+        encode_object(object, io)
+      end
+      io.putc(SQR_CLS)
+
+      io.string
+    end
+
+    def encode_string(string, io = StringIO.new)
+      io.putc(QUOT)
+      string.chars do |c|
+        case c
+        when QUOT then io.print(ESC_QUOT)
+        else
+          io.putc(c)
+        end
+      end
+      io.putc(QUOT)
+
+      io.string
+    end
+
+    def encode_object(object, io = StringIO.new)
+      case object
+      when ::Hash    then encode_hash(object, io)
+      when ::Array   then encode_array(object, io)
+      when ::Set     then encode_set(object, io)
+      when ::String  then encode_string(object, io)
+      when ::Time    then encode_timestamp(object, io)
+      when ::Numeric then encode_number(object, io)
+      when ::IPAddr  then encode_inet(object, io)
+      when Uuid      then encode_uuid(object, io)
+      when nil       then io.print(NULL_STR)
+      when false     then io.print(FALSE_STR)
+      when true      then io.print(TRUE_STR)
+      else
+        raise "unsupported type: #{object.inspect}"
+      end
+
+      io.string
+    end
+    alias :encode :encode_object
+
+    def encode_timestamp(time, io = StringIO.new)
+      io.print(time.to_i)
+      io.string
+    end
+
+    def encode_number(number, io = StringIO.new)
+      io.print(number)
+      io.string
+    end
+
+    def encode_uuid(uuid, io = StringIO.new)
+      io.print(uuid)
+      io.string
+    end
+
+    def encode_inet(inet, io = StringIO.new)
+      io.putc(QUOT)
+      io.print(inet)
+      io.putc(QUOT)
+      io.string
+    end
+
+    def escape_name(name)
+      return name if name[LOWERCASE_REGEXP] == name
+      DBL_QUOT + name + DBL_QUOT
+    end
+
+    # @private
+    LOWERCASE_REGEXP = /[[:lower:]\_]*/
+    # @private
+    NULL_STR = 'null'.freeze
+    # @private
+    FALSE_STR = 'false'.freeze
+    # @private
+    TRUE_STR = 'true'.freeze
+    # @private
+    CRL_OPN = '{'.freeze
+    # @private
+    CRL_CLS = '}'.freeze
+    # @private
+    SQR_OPN = '['.freeze
+    # @private
+    SQR_CLS = ']'.freeze
+    # @private
+    COMMA = ', '.freeze
+    # @private
+    COLON = ' : '.freeze
+    # @private
+    QUOT = ?'.freeze
+    # @private
+    ESC_QUOT = "''".freeze
+    # @private
+    DBL_QUOT = ?".freeze
+  end
+end

data/lib/cassandra/uuid.rb

@@ -0,0 +1,104 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2014 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 UUID value.
+  #
+  # This is a very basic implementation of UUIDs and exists more or less just
+  # to encode and decode UUIDs from and to Cassandra.
+  #
+  # If you want to generate UUIDs see {Cassandra::TimeUuid::Generator}.
+  #
+  class Uuid
+    # Creates a new UUID either from a string (expected to be on the standard 8-4-4-4-12 form, or just 32 characters without hyphens), or from a 128 bit number.
+    #
+    # @param uuid [String] a 32 char uuid
+    #
+    # @raise [ArgumentError] if the string does not conform to the expected format
+    #
+    def initialize(uuid)
+      case uuid
+      when String
+        @n = from_s(uuid)
+      else
+        @n = uuid
+      end
+    end
+
+    # Returns a string representation of this UUID in the standard 8-4-4-4-12 form.
+    #
+    def to_s
+      @s ||= begin
+        s = RAW_FORMAT % @n
+        s.insert(20, HYPHEN)
+        s.insert(16, HYPHEN)
+        s.insert(12, HYPHEN)
+        s.insert( 8, HYPHEN)
+        s
+      end
+    end
+
+    def hash
+      @n.hash
+    end
+
+    # Returns the numerical representation of this UUID
+    #
+    # @return [Bignum] the 128 bit numerical representation
+    #
+    def value
+      @n
+    end
+    alias_method :to_i, :value
+
+    # @private
+    def eql?(other)
+      other.respond_to?(:value) && self.value == other.value
+    end
+    alias_method :==, :eql?
+
+    private
+
+    # @private
+    RAW_FORMAT = '%032x'.force_encoding(Encoding::ASCII).freeze
+    # @private
+    HYPHEN = '-'.force_encoding(Encoding::ASCII).freeze
+    # @private
+    EMPTY_STRING = ''.freeze
+
+    if RUBY_ENGINE == 'jruby'
+      # @private
+      HEX_RE = /^[A-Fa-f0-9]+$/
+      # See https://github.com/jruby/jruby/issues/1608
+      # @private
+      def from_s(str)
+        str = str.gsub(HYPHEN, EMPTY_STRING)
+        raise ArgumentError, "Expected 32 hexadecimal digits but got #{str.length}" unless str.length == 32
+        raise ArgumentError, "invalid value for Integer(): \"#{str}\"" unless str =~ HEX_RE
+        Integer(str, 16)
+      end
+    else
+      # @private
+      def from_s(str)
+        str = str.gsub(HYPHEN, EMPTY_STRING)
+        raise ArgumentError, "Expected 32 hexadecimal digits but got #{str.length}" unless str.length == 32
+        Integer(str, 16)
+      end
+    end
+  end
+end