cassandra-driver 1.0.0.beta.3-java → 1.0.0-java

data/lib/cassandra/protocol/frame_decoder.rb

@@ -47,7 +47,7 @@ module Cassandra
 
       def actual_decode(buffer, fields, size)
         if (fields >> 24) & 0x80 == 0
-          raise UnsupportedFrameTypeError, 'Request frames are not supported'
+          raise Errors::DecodingError, 'Request frames are not supported'
         end
         protocol_version = (fields >> 24) & 0x7f
         compression = (fields >> 16) & 0x01
@@ -78,7 +78,7 @@ module Cassandra
           compressed_body = buffer.read(size)
           CqlByteBuffer.new(@compressor.decompress(compressed_body))
         else
-          raise UnexpectedCompressionError, 'Compressed frame received, but no compressor configured'
+          raise Errors::DecodingError, 'Compressed frame received, but no compressor configured'
         end
       end
 

data/lib/cassandra/protocol/frame_encoder.rb

@@ -26,7 +26,7 @@ module Cassandra
       end
 
       def encode_frame(request, stream_id=0, buffer=nil)
-        raise InvalidStreamIdError, 'The stream ID must be between 0 and 127' unless 0 <= stream_id && stream_id < 128
+        raise EncodingError, 'The stream ID must be between 0 and 127' unless 0 <= stream_id && stream_id < 128
         buffer ||= CqlByteBuffer.new
         flags = request.trace? ? 2 : 0
         body = request.write(@protocol_version, CqlByteBuffer.new)

data/lib/cassandra/protocol/requests/query_request.rb

@@ -39,11 +39,7 @@ module Cassandra
       end
 
       def write(protocol_version, buffer)
-        if protocol_version > 1
-          buffer.append_long_string(@cql)
-        else
-          buffer.append_long_string(serialized_cql)
-        end
+        buffer.append_long_string(@cql)
         buffer.append_consistency(@consistency)
         if protocol_version > 1
           flags  = 0
@@ -108,12 +104,6 @@ module Cassandra
 
       private
 
-      def serialized_cql
-        return @cql if @values.nil? || @values.empty?
-        i = -1
-        @cql.gsub('?') { Util.encode(@values[i += 1]) }
-      end
-
       def self.guess_type(value)
         type = TYPE_GUESSES[value.class]
         if type == :map

data/lib/cassandra/protocol/response.rb

@@ -24,7 +24,7 @@ module Cassandra
         if response_class
           response_class.decode(protocol_version, buffer, length, trace_id)
         else
-          raise UnsupportedOperationError, "The operation #{opcode} is not supported"
+          raise Errors::DecodingError, "Unsupported opcode #{opcode.inspect}"
         end
       end
 

data/lib/cassandra/protocol/responses/detailed_error_response.rb

@@ -37,7 +37,10 @@ module Cassandra
           details[:cl] = buffer.read_consistency
           details[:received] = buffer.read_int
           details[:blockfor] = buffer.read_int
-          details[:write_type] = buffer.read_string
+          write_type = buffer.read_string
+          write_type.downcase!
+
+          details[:write_type] = write_type.to_sym
         when 0x1200 # read_timeout
           details[:cl] = buffer.read_consistency
           details[:received] = buffer.read_int
@@ -52,6 +55,18 @@ module Cassandra
         new(code, message, details)
       end
 
+      def to_error(statement = nil)
+        case code
+        when 0x1000 then Errors::UnavailableError.new(@message, statement, @details[:cl], @details[:required], @details[:alive])
+        when 0x1100 then Errors::WriteTimeoutError.new(@message, statement, @details[:write_type], @details[:cl], @details[:blockfor], @details[:received])
+        when 0x1200 then Errors::ReadTimeoutError.new(@message, statement, @details[:data_present], @details[:cl], @details[:blockfor], @details[:received])
+        when 0x2400 then Errors::AlreadyExistsError.new(@message, statement, @details[:ks], @details[:table])
+        when 0x2500 then Errors::UnpreparedError.new(@message, statement, @details[:id])
+        else
+          super
+        end
+      end
+
       def to_s
         "#{super} #{@details}"
       end

data/lib/cassandra/protocol/responses/error_response.rb

@@ -42,6 +42,23 @@ module Cassandra
         %(ERROR 0x#{hex_code} "#@message")
       end
 
+      def to_error(statement = nil)
+        case @code
+        when 0x0000 then Errors::ServerError.new(@message)
+        when 0x000A then Errors::ProtocolError.new(@message)
+        when 0x0100 then Errors::AuthenticationError.new(@message)
+        when 0x1001 then Errors::OverloadedError.new(@message, statement)
+        when 0x1002 then Errors::IsBootstrappingError.new(@message, statement)
+        when 0x1003 then Errors::TruncateError.new(@message, statement)
+        when 0x2000 then Errors::SyntaxError.new(@message, statement)
+        when 0x2100 then Errors::UnauthorizedError.new(@message, statement)
+        when 0x2200 then Errors::InvalidError.new(@message, statement)
+        when 0x2300 then Errors::ConfigurationError.new(@message, statement)
+        else
+          Errors::ServerError.new(@message)
+        end
+      end
+
       private
 
       RESPONSE_TYPES[0x00] = self

data/lib/cassandra/protocol/responses/event_response.rb

@@ -22,7 +22,7 @@ module Cassandra
       def self.decode(protocol_version, buffer, length, trace_id=nil)
         type = buffer.read_string
         impl = EVENT_TYPES[type]
-        raise UnsupportedEventTypeError, %(Unsupported event type: "#{type}") unless impl
+        raise Errors::DecodingError, %(Unsupported event type: "#{type}") unless impl
         new_length = length - 4 - type.bytesize
         impl.decode(protocol_version, buffer, new_length, trace_id)
       end

data/lib/cassandra/protocol/responses/raw_rows_result_response.rb

@@ -31,7 +31,7 @@ module Cassandra
       end
 
       def rows
-        raise UnmaterializedRowsError, 'Not materialized!' unless @rows
+        raise Errors::DecodingError, 'Not materialized!' unless @rows
         @rows
       end
 

data/lib/cassandra/protocol/responses/result_response.rb

@@ -28,7 +28,7 @@ module Cassandra
       def self.decode(protocol_version, buffer, length, trace_id=nil)
         kind = buffer.read_int
         impl = RESULT_TYPES[kind]
-        raise UnsupportedResultKindError, %(Unsupported result kind: #{kind}) unless impl
+        raise Errors::DecodingError, %(Unsupported result kind: #{kind}) unless impl
         impl.decode(protocol_version, buffer, length - 4, trace_id)
       end
 

data/lib/cassandra/protocol/responses/rows_result_response.rb

@@ -87,7 +87,7 @@ module Cassandra
             sub_type = read_column_type(buffer)
             [:set, sub_type]
           else
-            raise UnsupportedColumnTypeError, %(Unsupported column type: #{id})
+            raise Errors::DecodingError, %(Unsupported column type: #{id})
           end
         end
         type

data/lib/cassandra/protocol/type_converter.rb

@@ -46,7 +46,7 @@ module Cassandra
         case type
         when Array
           unless value.nil? || value.is_a?(Enumerable)
-            raise InvalidValueError, 'Value for collection must be enumerable'
+            raise EncodingError, 'Value for collection must be enumerable'
           end
           case type.first
           when :list, :set
@@ -75,12 +75,12 @@ module Cassandra
               nil_to_bytes(buffer, size_bytes)
             end
           else
-            raise UnsupportedColumnTypeError, %(Unsupported column collection type: #{type.first})
+            raise EncodingError, %(Unsupported column collection type: #{type.first})
           end
         else
           converter = @to_bytes_converters[type]
           unless converter
-            raise UnsupportedColumnTypeError, %(Unsupported column type: #{type})
+            raise EncodingError, %(Unsupported column type: #{type})
           end
           converter.call(buffer, value, size_bytes)
         end
@@ -140,6 +140,7 @@ module Cassandra
           size = buffer.read_signed_int
           return nil if size & 0x80000000 == 0x80000000
         end
+        return nil if size.zero?
         size
       end
 

data/lib/cassandra/reconnection.rb

@@ -30,7 +30,7 @@ module Cassandra
 
     # A reconnection policy
     # @abstract Actual reconnection policies supplied as `:reconnection_policy`
-    #   option to {Cassandra.connect} don't need to inherit this class, only
+    #   option to {Cassandra.cluster} don't need to inherit this class, only
     #   implement its methods. This class exists for documentation purposes
     #   only.
     class Policy

data/lib/cassandra/result.rb

@@ -180,10 +180,9 @@ module Cassandra
       # Returns true when there are no more pages to load.
       #
       # This is only relevant when you have requested paging of the results with
-      # the `:page_size` option to {Cassandra::Client::Client#execute} or
-      # {Cassandra::Client::PreparedStatement#execute}.
+      # the `:page_size` option to {Cassandra::Session#execute}.
       #
-      # @see Cassandra::Client::Client#execute
+      # @see Cassandra::Session#execute
       def last_page?
         true
       end
@@ -191,10 +190,9 @@ module Cassandra
       # Returns the next page or nil when there is no next page.
       #
       # This is only relevant when you have requested paging of the results with
-      # the `:page_size` option to {Cassandra::Client::Client#execute} or
-      # {Cassandra::Client::PreparedStatement#execute}.
+      # the `:page_size` option to {Cassandra::Session#execute_async}.
       #
-      # @see Cassandra::Client::Client#execute
+      # @see Cassandra::Session#execute_async
       def next_page_async(options = nil)
         @futures.value(nil)
       end

data/lib/cassandra/retry.rb

@@ -19,7 +19,7 @@
 module Cassandra
   module Retry
     # @abstract Actual retry policies supplied as `:retry_policy` option to
-    #   {Cassandra.connect} don't need to inherit this class, only implement
+    #   {Cassandra.cluster} don't need to inherit this class, only implement
     #   its methods. This class exists for documentation purposes only.
     module Policy
       # Decides wether to retry a read and at what consistency level.
@@ -51,8 +51,7 @@ module Cassandra
       # @param statement [Cassandra::Statement] the original statement that timed out
       # @param consistency [Symbol] the original consistency level for the
       #   request, one of {Cassandra::CONSISTENCIES}
-      # @param type [Symbol] One of `:simple`, `:batch`, `:unlogged_batch`,
-      #   `:counter` or `:batch_log`
+      # @param type [Symbol] One of {Cassandra::WRITE_TYPES}
       # @param required [Integer] the number of acks required to achieve
       #   requested consistency level
       # @param received [Integer] the number of acks received by the time the
@@ -75,8 +74,7 @@ module Cassandra
       #   request, one of {Cassandra::CONSISTENCIES}
       # @param required [Integer] the number of replicas required to achieve
       #   requested consistency level
-      # @param alive [Integer] the number of replicas received by the time the
-      #   query timed out
+      # @param alive [Integer] the number of replicas available for the request
       # @param retries [Integer] the number of retries already performed
       # 
       # @return [Cassandra::Policies::Retry::Decision] a retry decision

data/lib/cassandra/session.rb

@@ -54,14 +54,20 @@ module Cassandra
     #   relevant for conditional updates and specifies a serial consistency to
     #   be used, one of {Cassandra::SERIAL_CONSISTENCIES}
     #
-    # @see Cassandra.connect for description of options that can be specified
-    #   on the cluster-level as well as default values chosen.
+    # @see Cassandra.cluster Options that can be specified on the cluster-level
+    #   and their default values.
     #
     # @note Last argument will be treated as `options` if it is a {Hash}.
     #   Therefore, make sure to pass empty `options` when executing a statement
     #   with the last parameter required to be a map datatype.
     #
+    # @note Positional arguments are only supported on Apache Cassandra 2.0 and
+    #   above.
+    #
     # @return [Cassandra::Future<Cassandra::Result>]
+    #
+    # @see Cassandra::Session#execute A list of errors this future can be
+    #   resolved with
     def execute_async(statement, *args)
       if args.last.is_a?(::Hash)
         options = @options.override(args.pop)
@@ -91,8 +97,11 @@ module Cassandra
     # @see Cassandra::Future#get
     #
     # @return [Cassandra::Result] query result
-    # @raise [Cassandra::Errors::NoHostsAvailable] if none of the hosts can be reached
-    # @raise [Cassandra::Errors::QueryError] if Cassandra returns an error response
+    # @raise [Cassandra::Errors::NoHostsAvailable] if all hosts fail
+    # @raise [Cassandra::Errors::ExecutionError] if Cassandra fails to execute
+    # @raise [Cassandra::Errors::ValidationError] if Cassandra fails to validate
+    # @raise [Cassandra::Errors::TimeoutError] if request has not completed
+    #   within the `:timeout` given
     def execute(*args)
       execute_async(*args).get
     end
@@ -131,7 +140,7 @@ module Cassandra
     #
     # @return [Cassandra::Statements::Prepared] prepared statement
     # @raise [Cassandra::Errors::NoHostsAvailable] if none of the hosts can be reached
-    # @raise [Cassandra::Errors::QueryError] if Cassandra returns an error response
+    # @raise [Cassandra::Errors::ExecutionError] if Cassandra returns an error response
     def prepare(*args)
       prepare_async(*args).get
     end

data/lib/cassandra/statements/prepared.rb

@@ -50,7 +50,11 @@ module Cassandra
       #   original cql passed to {Cassandra::Session#prepare}
       # @return [Cassandra::Statements::Bound] bound statement
       def bind(*args)
-        raise ::ArgumentError, "expecting exactly #{@params_metadata.size} bind parameters, #{args.size} given" if args.size != @params_metadata.size
+        Util.assert_equal(@params_metadata.size, args.size) { "expecting exactly #{@params_metadata.size} bind parameters, #{args.size} given" }
+
+        @params_metadata.each_with_index do |metadata, i|
+          Util.assert_type(metadata[3], args[i]) { "argument for #{metadata[2].inspect} must be #{metadata[3].inspect}, #{args[i]} given" }
+        end
 
         return Bound.new(@cql, @params_metadata, @result_metadata, args) if @params_metadata.empty?
 

data/lib/cassandra/table.rb

@@ -231,6 +231,11 @@ module Cassandra
       cql << ';'
     end
 
+    # @return [String] a CLI-friendly table representation
+    def inspect
+      "#<#{self.class.name}:0x#{self.object_id.to_s(16)} @keyspace=#{@keyspace} @name=#{@name}>"
+    end
+
     # @return [Boolean] whether this table is equal to the other
     def eql?(other)
       other.is_a?(Table) &&
@@ -247,7 +252,7 @@ module Cassandra
     # @private
     def create_partition_key(values)
       partition_key = @partition_key
-      return nil unless partition_key.size == values.size
+      return nil if partition_key.size > values.size
 
       if partition_key.one?
         column      = partition_key.first

data/lib/cassandra/time_uuid.rb

@@ -19,6 +19,7 @@
 module Cassandra
   # A variant of UUID which can extract its time component.
   #
+  # You can use {Cassandra::Uuid::Generator} to generate {Cassandra::TimeUuid}s
   class TimeUuid < Uuid
     include Comparable
 
@@ -29,18 +30,37 @@ module Cassandra
       t = time_bits - GREGORIAN_OFFSET
       seconds = t/10_000_000
       microseconds = (t - seconds * 10_000_000)/10.0
+
       Time.at(seconds, microseconds).utc
     end
 
+    # Returns the date component from this UUID as Date.
+    #
+    # This just sugar around {#to_time}
+    #
+    # @return [Date]
+    def to_date
+      to_time.to_date
+    end
+
+    # Compares this timeuuid with another timeuuid
+    #
+    # @param other [Cassandra::TimeUuid] another timeuuid to compare
+    # @see Comparable
+    #
+    # @return [nil] when other is not a {Cassandra::Uuid}
+    # @return [Integer] `-1` when less than `other`, `0` when equal to `other`
+    #   and `1` when greater than `other`
     def <=>(other)
       return nil unless other.kind_of?(Cassandra::Uuid)
       c = self.value <=> other.value
-      return c if c == 0
+      return c if c == 0 || !other.is_a?(Cassandra::TimeUuid)
       self.time_bits <=> other.time_bits
     end
 
     protected
 
+    # @private
     def time_bits
       n = (value >> 64)
       t = 0
@@ -54,88 +74,6 @@ module Cassandra
 
     # @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