cassandra-driver 2.1.7 → 3.0.0.beta.1

data/lib/cassandra/statements/simple.rb

@@ -37,6 +37,8 @@ module Cassandra
       #   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.
@@ -45,12 +47,11 @@ module Cassandra
       #   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)
+      def initialize(cql, params = nil, type_hints = nil, idempotent = false)
         Util.assert_instance_of(::String, cql) { "cql must be a string, #{cql.inspect} given" }
 
         params ||= EMPTY_LIST
 
-
         if params.is_a?(::Hash)
           params_names = []
           params = params.each_with_object([]) do |(name, value), params|
@@ -77,6 +78,7 @@ module Cassandra
         @params       = params
         @params_types = params.each_with_index.map {|value, index| (!type_hints.empty? && type_hints[index] && type_hints[index].is_a?(Type)) ? type_hints[index] : Util.guess_type(value)}
         @params_names = params_names
+        @idempotent   = idempotent
       end
 
       # @return [String] a CLI-friendly simple statement representation

data/lib/cassandra/table.rb

@@ -30,23 +30,29 @@ module Cassandra
                   :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
+      def initialize(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, min_index_interval, max_index_interval,
+                     compaction_strategy, compression_parameters, compact_storage)
+        @comment                     = comment
+        @read_repair_chance          = read_repair_chance
+        @local_read_repair_chance    = local_read_repair_chance
+        @gc_grace_seconds            = gc_grace_seconds
+        @caching                     = caching
+        @bloom_filter_fp_chance      = bloom_filter_fp_chance
+        @populate_io_cache_on_flush  = populate_io_cache_on_flush
+        @memtable_flush_period_in_ms = memtable_flush_period_in_ms
+        @default_time_to_live        = default_time_to_live
+        @speculative_retry           = speculative_retry
+        @index_interval              = index_interval
+        @replicate_on_write          = replicate_on_write
+        @min_index_interval          = min_index_interval
+        @max_index_interval          = max_index_interval
         @compaction_strategy         = compaction_strategy
         @compression_parameters      = compression_parameters
         @compact_storage             = compact_storage
-        @cassandra_version           = cassandra_version
       end
 
       def replicate_on_write?
@@ -65,19 +71,22 @@ module Cassandra
         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 << "bloom_filter_fp_chance = #{Util.encode_object(@bloom_filter_fp_chance)}" unless @bloom_filter_fp_chance.nil?
+        options << "caching = #{Util.encode_object(@caching)}" unless @caching.nil?
+        options << "comment = #{Util.encode_object(@comment)}" unless @comment.nil?
+        options << "compaction = #{@compaction_strategy.to_cql}" unless @compaction_strategy.nil?
+        options << "compression = #{Util.encode_object(@compression_parameters)}" unless @compression_parameters.nil?
+        options << "dclocal_read_repair_chance = #{Util.encode_object(@local_read_repair_chance)}" unless @local_read_repair_chance.nil?
+        options << "default_time_to_live = #{Util.encode_object(@default_time_to_live)}" unless @default_time_to_live.nil?
+        options << "gc_grace_seconds = #{Util.encode_object(@gc_grace_seconds)}" unless @gc_grace_seconds.nil?
+        options << "index_interval = #{Util.encode_object(@index_interval)}" unless @index_interval.nil?
+        options << "max_index_interval = #{Util.encode_object(@max_index_interval)}" unless @max_index_interval.nil?
+        options << "memtable_flush_period_in_ms = #{Util.encode_object(@memtable_flush_period_in_ms)}" unless @memtable_flush_period_in_ms.nil?
+        options << "min_index_interval = #{Util.encode_object(@min_index_interval)}" unless @min_index_interval.nil?
+        options << "populate_io_cache_on_flush = '#{@populate_io_cache_on_flush}'" unless @populate_io_cache_on_flush.nil?
+        options << "read_repair_chance = #{Util.encode_object(@read_repair_chance)}" unless @read_repair_chance.nil?
+        options << "replicate_on_write = '#{@replicate_on_write}'" unless @replicate_on_write.nil?
+        options << "speculative_retry = #{Util.encode_object(@speculative_retry)}" unless @speculative_retry.nil?
 
         options.join("\nAND ")
       end
@@ -98,13 +107,9 @@ module Cassandra
           @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
+          @compact_storage == other.compact_storage
       end
       alias :== :eql?
-
-      attr_reader :cassandra_version
-      protected :cassandra_version
     end
 
     # @private
@@ -137,9 +142,11 @@ module Cassandra
     attr_reader :name
     # @private
     attr_reader :options
+    # @private
+    attr_reader :partition_key
 
     # @private
-    def initialize(keyspace, name, partition_key, clustering_columns, columns, options, clustering_order, release_version)
+    def initialize(keyspace, name, partition_key, clustering_columns, columns, options, clustering_order)
       @keyspace           = keyspace
       @name               = name
       @partition_key      = partition_key
@@ -147,7 +154,6 @@ module Cassandra
       @columns            = columns
       @options            = options
       @clustering_order   = clustering_order
-      @release_version    = release_version
     end
 
     # @param name [String] column name
@@ -180,7 +186,12 @@ module Cassandra
 
     # @return [String] a cql representation of this table
     def to_cql
-      cql   = "CREATE TABLE #{Util.escape_name(@keyspace)}.#{Util.escape_name(@name)} (\n"
+      cql = "CREATE TABLE #{Util.escape_name(@keyspace)}.#{Util.escape_name(@name)} (\n"
+      primary_key = nil
+      if @partition_key.one? && @clustering_columns.empty?
+        primary_key = @partition_key.first.name
+      end
+
       first = true
       @columns.each do |(_, column)|
         if first
@@ -189,27 +200,31 @@ module Cassandra
           cql << ",\n" unless first
         end
         cql << "  #{column.name} #{type_to_cql(column.type, column.frozen?)}"
+        cql << ' PRIMARY KEY' if primary_key && column.name == primary_key
       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 << ', '
+
+      unless primary_key
+        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 << column.name
+          cql << ')'
+        end
+        @clustering_columns.each do |column|
+          cql << ", #{column.name}"
         end
         cql << ')'
       end
-      @clustering_columns.each do |column|
-        cql << ", #{column.name}"
-      end
-      cql << ')'
 
       cql << "\n)\nWITH "
 
@@ -232,12 +247,12 @@ module Cassandra
       cql << ';'
     end
 
-    # @return [String] a CLI-friendly table representation
+    # @private
     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
+    # @private
     def eql?(other)
       other.is_a?(Table) &&
         @keyspace == other.keyspace &&
@@ -250,53 +265,6 @@ module Cassandra
     end
     alias :== :eql?
 
-    # @private
-    def create_partition_key(values)
-      partition_key = @partition_key
-      return nil if 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
-
-        if @release_version > '2.1'
-          Protocol::Coder.write_value_v3(buffer, values[column_name], column.type)
-        else
-          Protocol::Coder.write_value_v1(buffer, values[column_name], column.type)
-        end
-
-        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
-
-          if @release_version > '2.1'
-            Protocol::Coder.write_value_v3(buf, values[column_name], column.type)
-          else
-            Protocol::Coder.write_value_v1(buf, values[column_name], column.type)
-          end
-
-          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
 
     # @private
@@ -319,11 +287,8 @@ module Cassandra
       end
     end
 
-    # @private
-    NULL_BYTE = "\x00".freeze
-
-    attr_reader :partition_key, :clustering_columns, :clustering_order
-    protected :partition_key, :clustering_columns, :clustering_order
+    attr_reader :clustering_columns, :clustering_order
+    protected :clustering_columns, :clustering_order
 
     protected
 

data/lib/cassandra/time.rb

@@ -0,0 +1,98 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2015 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
+      '%.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

data/lib/cassandra/time_uuid.rb

@@ -31,7 +31,7 @@ module Cassandra
       seconds = t/10_000_000
       microseconds = (t - seconds * 10_000_000)/10.0
 
-      Time.at(seconds, microseconds).utc
+      ::Time.at(seconds, microseconds).utc
     end
 
     # Returns the date component from this UUID as Date.

data/lib/cassandra/tuple.rb

@@ -112,13 +112,20 @@ module Cassandra
       "(#{@values.map(&:to_s).join(', ')})"
     end
 
+    # @private
     def inspect
       "#<Cassandra::Tuple:0x#{self.object_id.to_s(16)} #{to_s}>"
     end
 
+    # @private
     def eql?(other)
       other == @values
     end
     alias :== :eql?
+
+    # @private
+    def hash
+      @values.inject(17) {|h, v| 31 * h + v.hash}
+    end
   end
 end

data/lib/cassandra/types.rb

@@ -21,7 +21,10 @@ module Cassandra
   # @abstract This class exists for documentation purposes only
   class Type
     # @return [Symbol] shorthand type name
-    def kind
+    attr_reader :kind
+
+    def initialize(kind)
+      @kind = kind
     end
 
     # Coerces a given value to this type
@@ -48,12 +51,6 @@ module Cassandra
   module Types; extend self
     # @private
     class Simple < Type
-      attr_reader :kind
-
-      def initialize(kind)
-        @kind = kind
-      end
-
       def new(value)
         __send__(:"new_#{@kind}", value)
       end
@@ -67,6 +64,10 @@ module Cassandra
         @kind.to_s
       end
 
+      def hash
+        @hash ||= 31 * 17 + @kind.hash
+      end
+
       def eql?(other)
         other.is_a?(Simple) && @kind == other.kind
       end
@@ -86,96 +87,96 @@ module Cassandra
         String(value)
       end
 
-      def assert_text(valuee, message, &block)
-        Util.assert_instance_of(::String, valuee, message, &block)
+      def assert_text(value, message, &block)
+        Util.assert_instance_of(::String, value, message, &block)
       end
 
       def new_blob(value)
         String(value)
       end
 
-      def assert_blob(valuee, message, &block)
-        Util.assert_instance_of(::String, valuee, message, &block)
+      def assert_blob(value, message, &block)
+        Util.assert_instance_of(::String, value, message, &block)
       end
 
       def new_ascii(value)
         String(value)
       end
 
-      def assert_ascii(valuee, message, &block)
-        Util.assert_instance_of(::String, valuee, message, &block)
+      def assert_ascii(value, message, &block)
+        Util.assert_instance_of(::String, value, message, &block)
       end
 
       def new_bigint(value)
         Integer(value)
       end
 
-      def assert_bigint(valuee, message, &block)
-        Util.assert_instance_of(::Integer, valuee, message, &block)
+      def assert_bigint(value, message, &block)
+        Util.assert_instance_of(::Integer, value, message, &block)
       end
 
       def new_counter(value)
         Integer(value)
       end
 
-      def assert_counter(valuee, message, &block)
-        Util.assert_instance_of(::Integer, valuee, message, &block)
+      def assert_counter(value, message, &block)
+        Util.assert_instance_of(::Integer, value, message, &block)
       end
 
       def new_int(value)
         Integer(value)
       end
 
-      def assert_int(valuee, message, &block)
-        Util.assert_instance_of(::Integer, valuee, message, &block)
+      def assert_int(value, message, &block)
+        Util.assert_instance_of(::Integer, value, message, &block)
       end
 
       def new_varint(value)
         Integer(value)
       end
 
-      def assert_varint(valuee, message, &block)
-        Util.assert_instance_of(::Integer, valuee, message, &block)
+      def assert_varint(value, message, &block)
+        Util.assert_instance_of(::Integer, value, message, &block)
       end
 
       def new_boolean(value)
         !!value
       end
 
-      def assert_boolean(valuee, message, &block)
-        Util.assert_instance_of_one_of([::TrueClass, ::FalseClass], valuee, message, &block)
+      def assert_boolean(value, message, &block)
+        Util.assert_instance_of_one_of([::TrueClass, ::FalseClass], value, message, &block)
       end
 
       def new_decimal(value)
         ::BigDecimal.new(value)
       end
 
-      def assert_decimal(valuee, message, &block)
-        Util.assert_instance_of(::BigDecimal, valuee, message, &block)
+      def assert_decimal(value, message, &block)
+        Util.assert_instance_of(::BigDecimal, value, message, &block)
       end
 
       def new_double(value)
         Float(value)
       end
 
-      def assert_double(valuee, message, &block)
-        Util.assert_instance_of(::Float, valuee, message, &block)
+      def assert_double(value, message, &block)
+        Util.assert_instance_of(::Float, value, message, &block)
       end
 
       def new_float(value)
         Float(value)
       end
 
-      def assert_float(valuee, message, &block)
-        Util.assert_instance_of(::Float, valuee, message, &block)
+      def assert_float(value, message, &block)
+        Util.assert_instance_of(::Float, value, message, &block)
       end
 
       def new_inet(value)
         ::IPAddr.new(value)
       end
 
-      def assert_inet(valuee, message, &block)
-        Util.assert_instance_of(::IPAddr, valuee, message, &block)
+      def assert_inet(value, message, &block)
+        Util.assert_instance_of(::IPAddr, value, message, &block)
       end
 
       def new_timestamp(value)
@@ -188,122 +189,72 @@ module Cassandra
         end
       end
 
-      def assert_timestamp(valuee, message, &block)
-        Util.assert_instance_of(::Time, valuee, message, &block)
+      def assert_timestamp(value, message, &block)
+        Util.assert_instance_of(::Time, value, message, &block)
       end
 
-      def new_uuid(valuee, message, &block)
+      def new_uuid(value, message, &block)
         Cassandra::Uuid.new(value)
       end
 
-      def assert_uuid(valuee, message, &block)
-        Util.assert_instance_of(Cassandra::Uuid, valuee, message, &block)
+      def assert_uuid(value, message, &block)
+        Util.assert_instance_of(Cassandra::Uuid, value, message, &block)
       end
 
       def new_timeuuid(value)
         Cassandra::TimeUuid.new(value)
       end
 
-      def assert_timeuuid(valuee, message, &block)
-        Util.assert_instance_of(Cassandra::TimeUuid, valuee, message, &block)
+      def assert_timeuuid(value, message, &block)
+        Util.assert_instance_of(Cassandra::TimeUuid, value, message, &block)
       end
-    end
 
-    # @!parse
-    #   class Varchar < Type
-    #     # @return [Symbol] `:varchar`
-    #     # @see Cassandra::Type#kind
-    #     def kind
-    #     end
-    #
-    #     # Coerces the value to String
-    #     # @param value [Object] original value
-    #     # @return [String] value
-    #     # @see Cassandra::Type#new
-    #     def new(value)
-    #     end
-    #
-    #     # Asserts that a given value is a String
-    #     # @param value [Object] value to be validated
-    #     # @param message [String] error message to use when assertion
-    #     #   fails
-    #     # @yieldreturn [String] error message to use when assertion fails
-    #     # @raise [ArgumentError] if the value is not a String
-    #     # @return [void]
-    #     # @see Cassandra::Type#assert
-    #     def assert(value, message = nil, &block)
-    #     end
-    #
-    #     # @return [String] `"varchar"`
-    #     # @see Cassandra::Type#to_s
-    #     def to_s
-    #     end
-    #   end
-    const_set('Varchar', Simple.new(:varchar))
+      def new_date(value)
+        case value
+        when ::Date
+          value
+        else
+          return value.to_date if value.respond_to?(:to_date)
+          raise ::ArgumentError, "cannot convert #{value.inspect} to date"
+        end
+      end
 
-    # @!parse
-    #   class Text < Type
-    #     # @return [Symbol] `:text`
-    #     # @see Cassandra::Type#kind
-    #     def kind
-    #     end
-    #
-    #     # Coerces the value to String
-    #     # @param value [Object] original value
-    #     # @return [String] value
-    #     # @see Cassandra::Type#new
-    #     def new(value)
-    #     end
-    #
-    #     # Asserts that a given value is a String
-    #     # @param value [Object] value to be validated
-    #     # @param message [String] error message to use when assertion
-    #     #   fails
-    #     # @yieldreturn [String] error message to use when assertion fails
-    #     # @raise [ArgumentError] if the value is not a String
-    #     # @return [void]
-    #     # @see Cassandra::Type#assert
-    #     def assert(value, message = nil, &block)
-    #     end
-    #
-    #     # @return [String] `"text"`
-    #     # @see Cassandra::Type#to_s
-    #     def to_s
-    #     end
-    #   end
-    const_set('Text', Simple.new(:text))
+      def assert_date(value, message, &block)
+        Util.assert_instance_of(::Date, value, message, &block)
+      end
 
-    # @!parse
-    #   class Blob < Type
-    #     # @return [Symbol] `:blob`
-    #     # @see Cassandra::Type#kind
-    #     def kind
-    #     end
-    #
-    #     # Coerces the value to String
-    #     # @param value [Object] original value
-    #     # @return [String] value
-    #     # @see Cassandra::Type#new
-    #     def new(value)
-    #     end
-    #
-    #     # Asserts that a given value is a String
-    #     # @param value [Object] value to be validated
-    #     # @param message [String] error message to use when assertion
-    #     #   fails
-    #     # @yieldreturn [String] error message to use when assertion fails
-    #     # @raise [ArgumentError] if the value is not a String
-    #     # @return [void]
-    #     # @see Cassandra::Type#assert
-    #     def assert(value, message = nil, &block)
-    #     end
-    #
-    #     # @return [String] `"blob"`
-    #     # @see Cassandra::Type#to_s
-    #     def to_s
-    #     end
-    #   end
-    const_set('Blob', Simple.new(:blob))
+      def new_smallint(value)
+        Integer(value)
+      end
+
+      def assert_smallint(value, message, &block)
+        Util.assert_instance_of(::Integer, value, message, &block)
+        Util.assert(value <= 32767 && value >= -32768, message, &block)
+      end
+
+      def new_time(value)
+        case value
+        when ::Integer
+          Time.new(value)
+        else
+          return Time.new(value.to_nanoseconds) if value.respond_to?(:to_nanoseconds)
+          raise ::ArgumentError, "cannot convert #{value.inspect} to time"
+        end
+      end
+
+      def assert_time(value, message, &block)
+        Util.assert_instance_of(Cassandra::Time, value, message, &block)
+      end
+
+      def new_tinyint(value)
+        Integer(value)
+      end
+
+      def assert_tinyint(value, message, &block)
+        Util.assert_instance_of(::Integer, value, message, &block)
+        Util.assert(value <= 127 && value >= -128, message, &block)
+      end
+    end
 
     # @!parse
     #   class Ascii < Type
@@ -370,72 +321,72 @@ module Cassandra
     const_set('Bigint', Simple.new(:bigint))
 
     # @!parse
-    #   class Counter < Type
-    #     # @return [Symbol] `:counter`
+    #   class Blob < Type
+    #     # @return [Symbol] `:blob`
     #     # @see Cassandra::Type#kind
     #     def kind
     #     end
     #
-    #     # Coerces the value to Integer
+    #     # Coerces the value to String
     #     # @param value [Object] original value
-    #     # @return [Integer] value
+    #     # @return [String] value
     #     # @see Cassandra::Type#new
     #     def new(value)
     #     end
     #
-    #     # Asserts that a given value is an Integer
+    #     # Asserts that a given value is a String
     #     # @param value [Object] value to be validated
     #     # @param message [String] error message to use when assertion
     #     #   fails
     #     # @yieldreturn [String] error message to use when assertion fails
-    #     # @raise [ArgumentError] if the value is not an Integer
+    #     # @raise [ArgumentError] if the value is not a String
     #     # @return [void]
     #     # @see Cassandra::Type#assert
     #     def assert(value, message = nil, &block)
     #     end
     #
-    #     # @return [String] `"counter"`
+    #     # @return [String] `"blob"`
     #     # @see Cassandra::Type#to_s
     #     def to_s
     #     end
     #   end
-    const_set('Counter', Simple.new(:counter))
+    const_set('Blob', Simple.new(:blob))
 
     # @!parse
-    #   class Int < Type
-    #     # @return [Symbol] `:int`
+    #   class Boolean < Type
+    #     # @return [Symbol] `:boolean`
     #     # @see Cassandra::Type#kind
     #     def kind
     #     end
     #
-    #     # Coerces the value to Integer
+    #     # Coerces the value to `true` or `false`
     #     # @param value [Object] original value
-    #     # @return [Integer] value
+    #     # @return [Boolean] value
     #     # @see Cassandra::Type#new
     #     def new(value)
     #     end
     #
-    #     # Asserts that a given value is an Integer
+    #     # Asserts that a given value is a `true` or `false`
     #     # @param value [Object] value to be validated
     #     # @param message [String] error message to use when assertion
     #     #   fails
     #     # @yieldreturn [String] error message to use when assertion fails
-    #     # @raise [ArgumentError] if the value is not an Integer
+    #     # @raise [ArgumentError] if the value is not `true` or `false`
     #     # @return [void]
     #     # @see Cassandra::Type#assert
     #     def assert(value, message = nil, &block)
     #     end
     #
-    #     # @return [String] `"int"`
+    #     # @return [String] `"boolean"`
     #     # @see Cassandra::Type#to_s
     #     def to_s
     #     end
     #   end
-    const_set('Int', Simple.new(:int))
+    const_set('Boolean', Simple.new(:boolean))
 
     # @!parse
-    #   class Varint < Type
-    #     # @return [Symbol] `:varint`
+    #   class Counter < Type
+    #     # @return [Symbol] `:counter`
     #     # @see Cassandra::Type#kind
     #     def kind
     #     end
@@ -458,44 +409,44 @@ module Cassandra
     #     def assert(value, message = nil, &block)
     #     end
     #
-    #     # @return [String] `"varint"`
+    #     # @return [String] `"counter"`
     #     # @see Cassandra::Type#to_s
     #     def to_s
     #     end
     #   end
-    const_set('Varint', Simple.new(:varint))
+    const_set('Counter', Simple.new(:counter))
 
     # @!parse
-    #   class Boolean < Type
-    #     # @return [Symbol] `:boolean`
+    #   class Date < Type
+    #     # @return [Symbol] `:date`
     #     # @see Cassandra::Type#kind
     #     def kind
     #     end
     #
-    #     # Coerces the value to `true` or `false`
+    #     # Coerces the value to Date
     #     # @param value [Object] original value
-    #     # @return [Boolean] value
+    #     # @return [Date] value
     #     # @see Cassandra::Type#new
     #     def new(value)
     #     end
     #
-    #     # Asserts that a given value is a `true` or `false`
+    #     # Asserts that a given value is a Date
     #     # @param value [Object] value to be validated
     #     # @param message [String] error message to use when assertion
     #     #   fails
     #     # @yieldreturn [String] error message to use when assertion fails
-    #     # @raise [ArgumentError] if the value is not `true` or `false`
+    #     # @raise [ArgumentError] if the value is not a Date
     #     # @return [void]
     #     # @see Cassandra::Type#assert
     #     def assert(value, message = nil, &block)
     #     end
     #
-    #     # @return [String] `"boolean"`
+    #     # @return [String] `"date"`
     #     # @see Cassandra::Type#to_s
     #     def to_s
     #     end
     #   end
-    const_set('Boolean', Simple.new(:boolean))
+    const_set('Date', Simple.new(:date))
 
     # @!parse
     #   class Decimal < Type
@@ -626,100 +577,36 @@ module Cassandra
     const_set('Inet', Simple.new(:inet))
 
     # @!parse
-    #   class Timestamp < Type
-    #     # @return [Symbol] `:timestamp`
-    #     # @see Cassandra::Type#kind
-    #     def kind
-    #     end
-    #
-    #     # Coerces the value to Time
-    #     # @param value [Object] original value
-    #     # @return [Time] value
-    #     # @see Cassandra::Type#new
-    #     def new(value)
-    #     end
-    #
-    #     # Asserts that a given value is a Time
-    #     # @param value [Object] value to be validated
-    #     # @param message [String] error message to use when assertion
-    #     #   fails
-    #     # @yieldreturn [String] error message to use when assertion fails
-    #     # @raise [ArgumentError] if the value is not a Time
-    #     # @return [void]
-    #     # @see Cassandra::Type#assert
-    #     def assert(value, message = nil, &block)
-    #     end
-    #
-    #     # @return [String] `"timestamp"`
-    #     # @see Cassandra::Type#to_s
-    #     def to_s
-    #     end
-    #   end
-    const_set('Timestamp', Simple.new(:timestamp))
-
-    # @!parse
-    #   class Uuid < Type
-    #     # @return [Symbol] `:uuid`
-    #     # @see Cassandra::Type#kind
-    #     def kind
-    #     end
-    #
-    #     # Coerces the value to Cassandra::Uuid
-    #     # @param value [Object] original value
-    #     # @return [Cassandra::Uuid] value
-    #     # @see Cassandra::Type#new
-    #     def new(value)
-    #     end
-    #
-    #     # Asserts that a given value is a Cassandra::Uuid
-    #     # @param value [Object] value to be validated
-    #     # @param message [String] error message to use when assertion
-    #     #   fails
-    #     # @yieldreturn [String] error message to use when assertion fails
-    #     # @raise [ArgumentError] if the value is not a Cassandra::Uuid
-    #     # @return [void]
-    #     # @see Cassandra::Type#assert
-    #     def assert(value, message = nil, &block)
-    #     end
-    #
-    #     # @return [String] `"uuid"`
-    #     # @see Cassandra::Type#to_s
-    #     def to_s
-    #     end
-    #   end
-    const_set('Uuid', Simple.new(:uuid))
-
-    # @!parse
-    #   class Timeuuid < Type
-    #     # @return [Symbol] `:timeuuid`
+    #   class Int < Type
+    #     # @return [Symbol] `:int`
     #     # @see Cassandra::Type#kind
     #     def kind
     #     end
     #
-    #     # Coerces the value to Cassandra::Timeuuid
+    #     # Coerces the value to Integer
     #     # @param value [Object] original value
-    #     # @return [Cassandra::Timeuuid] value
+    #     # @return [Integer] value
     #     # @see Cassandra::Type#new
     #     def new(value)
     #     end
     #
-    #     # Asserts that a given value is a Cassandra::Timeuuid
+    #     # Asserts that a given value is an Integer
     #     # @param value [Object] value to be validated
     #     # @param message [String] error message to use when assertion
     #     #   fails
     #     # @yieldreturn [String] error message to use when assertion fails
-    #     # @raise [ArgumentError] if the value is not a Cassandra::Timeuuid
+    #     # @raise [ArgumentError] if the value is not an Integer
     #     # @return [void]
     #     # @see Cassandra::Type#assert
     #     def assert(value, message = nil, &block)
     #     end
     #
-    #     # @return [String] `"timeuuid"`
+    #     # @return [String] `"int"`
     #     # @see Cassandra::Type#to_s
     #     def to_s
     #     end
     #   end
-    const_set('Timeuuid', Simple.new(:timeuuid))
+    const_set('Int', Simple.new(:int))
 
     class List < Type
       # @private
@@ -727,15 +614,10 @@ module Cassandra
 
       # @private
       def initialize(value_type)
+        super(:list)
         @value_type = value_type
       end
 
-      # @return [Symbol] `:list`
-      # @see Cassandra::Type#kind
-      def kind
-        :list
-      end
-
       # Coerces the value to Array
       # @param value [Object] original value
       # @return [Array] value
@@ -770,6 +652,15 @@ module Cassandra
         "list<#{@value_type.to_s}>"
       end
 
+      def hash
+        @hash ||= begin
+          h = 17
+          h = 31 * h + @kind.hash
+          h = 31 * h + @value_type.hash
+          h
+        end
+      end
+
       def eql?(other)
         other.is_a?(List) && @value_type == other.value_type
       end
@@ -782,16 +673,11 @@ module Cassandra
 
       # @private
       def initialize(key_type, value_type)
+        super(:map)
         @key_type   = key_type
         @value_type = value_type
       end
 
-      # @return [Symbol] `:map`
-      # @see Cassandra::Type#kind
-      def kind
-        :map
-      end
-
       # Coerces the value to Hash
       # @param value [Object] original value
       # @return [Hash] value
@@ -841,6 +727,16 @@ module Cassandra
         "map<#{@key_type.to_s}, #{@value_type.to_s}>"
       end
 
+      def hash
+        @hash ||= begin
+          h = 17
+          h = 31 * h + @kind.hash
+          h = 31 * h + @key_type.hash
+          h = 31 * h + @value_type.hash
+          h
+        end
+      end
+
       def eql?(other)
         other.is_a?(Map) &&
           @key_type == other.key_type &&
@@ -855,15 +751,10 @@ module Cassandra
 
       # @private
       def initialize(value_type)
+        super(:set)
         @value_type = value_type
       end
 
-      # @return [Symbol] `:set`
-      # @see Cassandra::Type#kind
-      def kind
-        :set
-      end
-
       # Coerces the value to Set
       # @param value [Object] original value
       # @return [Set] value
@@ -925,27 +816,223 @@ module Cassandra
         "set<#{@value_type.to_s}>"
       end
 
+      def hash
+        @hash ||= begin
+          h = 17
+          h = 31 * h + @kind.hash
+          h = 31 * h + @value_type.hash
+          h
+        end
+      end
+
       def eql?(other)
         other.is_a?(Set) && @value_type == other.value_type
       end
       alias :== :eql?
     end
 
+    # @!parse
+    #   class Smallint < Type
+    #     # @return [Symbol] `:smallint`
+    #     # @see Cassandra::Type#kind
+    #     def kind
+    #     end
+    #
+    #     # Coerces the value to an Integer
+    #     # @param value [Object] original value
+    #     # @return [Integer] value
+    #     # @see Cassandra::Type#new
+    #     def new(value)
+    #     end
+    #
+    #     # Asserts that a given value is an Integer
+    #     # @param value [Object] value to be validated
+    #     # @param message [String] error message to use when assertion
+    #     #   fails
+    #     # @yieldreturn [String] error message to use when assertion fails
+    #     # @raise [ArgumentError] if the value is not an Integer
+    #     # @return [void]
+    #     # @see Cassandra::Type#assert
+    #     def assert(value, message = nil, &block)
+    #     end
+    #
+    #     # @return [String] `"smallint"`
+    #     # @see Cassandra::Type#to_s
+    #     def to_s
+    #     end
+    #   end
+    const_set('Smallint', Simple.new(:smallint))
+
+    # @!parse
+    #   class Text < Type
+    #     # @return [Symbol] `:text`
+    #     # @see Cassandra::Type#kind
+    #     def kind
+    #     end
+    #
+    #     # Coerces the value to String
+    #     # @param value [Object] original value
+    #     # @return [String] value
+    #     # @see Cassandra::Type#new
+    #     def new(value)
+    #     end
+    #
+    #     # Asserts that a given value is a String
+    #     # @param value [Object] value to be validated
+    #     # @param message [String] error message to use when assertion
+    #     #   fails
+    #     # @yieldreturn [String] error message to use when assertion fails
+    #     # @raise [ArgumentError] if the value is not a String
+    #     # @return [void]
+    #     # @see Cassandra::Type#assert
+    #     def assert(value, message = nil, &block)
+    #     end
+    #
+    #     # @return [String] `"text"`
+    #     # @see Cassandra::Type#to_s
+    #     def to_s
+    #     end
+    #   end
+    const_set('Text', Simple.new(:text))
+
+    # @!parse
+    #   class Time < Type
+    #     # @return [Symbol] `:time`
+    #     # @see Cassandra::Type#kind
+    #     def kind
+    #     end
+    #
+    #     # Coerces the value to Time
+    #     # @param value [Object] original value
+    #     # @return [Time] value
+    #     # @see Cassandra::Type#new
+    #     def new(value)
+    #     end
+    #
+    #     # Asserts that a given value is a Time
+    #     # @param value [Object] value to be validated
+    #     # @param message [String] error message to use when assertion
+    #     #   fails
+    #     # @yieldreturn [String] error message to use when assertion fails
+    #     # @raise [ArgumentError] if the value is not a String
+    #     # @return [void]
+    #     # @see Cassandra::Type#assert
+    #     def assert(value, message = nil, &block)
+    #     end
+    #
+    #     # @return [String] `"time"`
+    #     # @see Cassandra::Type#to_s
+    #     def to_s
+    #     end
+    #   end
+    const_set('Time', Simple.new(:time))
+
+    # @!parse
+    #   class Timestamp < Type
+    #     # @return [Symbol] `:timestamp`
+    #     # @see Cassandra::Type#kind
+    #     def kind
+    #     end
+    #
+    #     # Coerces the value to Time
+    #     # @param value [Object] original value
+    #     # @return [Time] value
+    #     # @see Cassandra::Type#new
+    #     def new(value)
+    #     end
+    #
+    #     # Asserts that a given value is a Time
+    #     # @param value [Object] value to be validated
+    #     # @param message [String] error message to use when assertion
+    #     #   fails
+    #     # @yieldreturn [String] error message to use when assertion fails
+    #     # @raise [ArgumentError] if the value is not a Time
+    #     # @return [void]
+    #     # @see Cassandra::Type#assert
+    #     def assert(value, message = nil, &block)
+    #     end
+    #
+    #     # @return [String] `"timestamp"`
+    #     # @see Cassandra::Type#to_s
+    #     def to_s
+    #     end
+    #   end
+    const_set('Timestamp', Simple.new(:timestamp))
+
+    # @!parse
+    #   class Timeuuid < Type
+    #     # @return [Symbol] `:timeuuid`
+    #     # @see Cassandra::Type#kind
+    #     def kind
+    #     end
+    #
+    #     # Coerces the value to Cassandra::Timeuuid
+    #     # @param value [Object] original value
+    #     # @return [Cassandra::Timeuuid] value
+    #     # @see Cassandra::Type#new
+    #     def new(value)
+    #     end
+    #
+    #     # Asserts that a given value is a Cassandra::Timeuuid
+    #     # @param value [Object] value to be validated
+    #     # @param message [String] error message to use when assertion
+    #     #   fails
+    #     # @yieldreturn [String] error message to use when assertion fails
+    #     # @raise [ArgumentError] if the value is not a Cassandra::Timeuuid
+    #     # @return [void]
+    #     # @see Cassandra::Type#assert
+    #     def assert(value, message = nil, &block)
+    #     end
+    #
+    #     # @return [String] `"timeuuid"`
+    #     # @see Cassandra::Type#to_s
+    #     def to_s
+    #     end
+    #   end
+    const_set('Timeuuid', Simple.new(:timeuuid))
+
+    # @!parse
+    #   class Tinyint < Type
+    #     # @return [Symbol] `:tinyint`
+    #     # @see Cassandra::Type#kind
+    #     def kind
+    #     end
+    #
+    #     # Coerces the value to Integer
+    #     # @param value [Object] original value
+    #     # @return [Integer] value
+    #     # @see Cassandra::Type#new
+    #     def new(value)
+    #     end
+    #
+    #     # Asserts that a given value is an Integer
+    #     # @param value [Object] value to be validated
+    #     # @param message [String] error message to use when assertion
+    #     #   fails
+    #     # @yieldreturn [String] error message to use when assertion fails
+    #     # @raise [ArgumentError] if the value is not an Integer
+    #     # @return [void]
+    #     # @see Cassandra::Type#assert
+    #     def assert(value, message = nil, &block)
+    #     end
+    #
+    #     # @return [String] `"tinyint"`
+    #     # @see Cassandra::Type#to_s
+    #     def to_s
+    #     end
+    #   end
+    const_set('Tinyint', Simple.new(:tinyint))
+
     class Tuple < Type
       # @private
       attr_reader :members
 
       # @private
       def initialize(*members)
+        super(:tuple)
         @members = members
       end
 
-      # @return [Symbol] `:tuple`
-      # @see Cassandra::Type#kind
-      def kind
-        :tuple
-      end
-
       # Coerces the value to Cassandra::Tuple
       # @param values [*Object] tuple values
       # @return [Cassandra::Tuple] value
@@ -984,12 +1071,85 @@ module Cassandra
         "tuple<#{@members.map(&:to_s).join(', ')}>"
       end
 
+      def hash
+        @hash ||= begin
+          h = 17
+          h = 31 * h + @kind.hash
+          h = 31 * h + @members.hash
+          h
+        end
+      end
+
       def eql?(other)
         other.is_a?(Tuple) && @members == other.members
       end
       alias :== :eql?
     end
 
+    # @!parse
+    #   class Uuid < Type
+    #     # @return [Symbol] `:uuid`
+    #     # @see Cassandra::Type#kind
+    #     def kind
+    #     end
+    #
+    #     # Coerces the value to Cassandra::Uuid
+    #     # @param value [Object] original value
+    #     # @return [Cassandra::Uuid] value
+    #     # @see Cassandra::Type#new
+    #     def new(value)
+    #     end
+    #
+    #     # Asserts that a given value is a Cassandra::Uuid
+    #     # @param value [Object] value to be validated
+    #     # @param message [String] error message to use when assertion
+    #     #   fails
+    #     # @yieldreturn [String] error message to use when assertion fails
+    #     # @raise [ArgumentError] if the value is not a Cassandra::Uuid
+    #     # @return [void]
+    #     # @see Cassandra::Type#assert
+    #     def assert(value, message = nil, &block)
+    #     end
+    #
+    #     # @return [String] `"uuid"`
+    #     # @see Cassandra::Type#to_s
+    #     def to_s
+    #     end
+    #   end
+    const_set('Uuid', Simple.new(:uuid))
+
+    # @!parse
+    #   class Varint < Type
+    #     # @return [Symbol] `:varint`
+    #     # @see Cassandra::Type#kind
+    #     def kind
+    #     end
+    #
+    #     # Coerces the value to Integer
+    #     # @param value [Object] original value
+    #     # @return [Integer] value
+    #     # @see Cassandra::Type#new
+    #     def new(value)
+    #     end
+    #
+    #     # Asserts that a given value is an Integer
+    #     # @param value [Object] value to be validated
+    #     # @param message [String] error message to use when assertion
+    #     #   fails
+    #     # @yieldreturn [String] error message to use when assertion fails
+    #     # @raise [ArgumentError] if the value is not an Integer
+    #     # @return [void]
+    #     # @see Cassandra::Type#assert
+    #     def assert(value, message = nil, &block)
+    #     end
+    #
+    #     # @return [String] `"varint"`
+    #     # @see Cassandra::Type#to_s
+    #     def to_s
+    #     end
+    #   end
+    const_set('Varint', Simple.new(:varint))
+
     class UserDefined < Type
       class Field
         # @return [String] name of this field
@@ -1009,6 +1169,15 @@ module Cassandra
           "#{@name} #{@type}"
         end
 
+        def hash
+          @hash ||= begin
+            h = 17
+            h = 31 * h + @name.hash
+            h = 31 * h + @type.hash
+            h
+          end
+        end
+
         def eql?(other)
           other.is_a?(Field) &&
             @name == other.name &&
@@ -1028,6 +1197,7 @@ module Cassandra
 
       # @private
       def initialize(keyspace, name, fields)
+        super(:udt)
         @keyspace  = keyspace
         @name      = name
         @fields    = fields
@@ -1062,12 +1232,6 @@ module Cassandra
         @fields.find {|f| f.name == name}
       end
 
-      # @return [Symbol] `:udt`
-      # @see Cassandra::Type#kind
-      def kind
-        :udt
-      end
-
       # Coerces the value to Cassandra::UDT
       # @param value [Object] original value
       # @return [Cassandra::UDT] value
@@ -1121,6 +1285,17 @@ module Cassandra
         "#{Util.escape_name(@keyspace)}.#{Util.escape_name(@name)} {#{@fields.join(', ')}}"
       end
 
+      def hash
+        @hash ||= begin
+          h = 17
+          h = 31 * h + @kind.hash
+          h = 31 * h + @keyspace.hash
+          h = 31 * h + @name.hash
+          h = 31 * h + @fields.hash
+          h
+        end
+      end
+
       def eql?(other)
         other.is_a?(UserDefined) &&
           @keyspace == other.keyspace &&
@@ -1171,14 +1346,10 @@ module Cassandra
       attr_reader :name
 
       def initialize(name)
+        super(:custom)
         @name = name
       end
 
-      # @return [Symbol] shorthand type name
-      def kind
-        :custom
-      end
-
       # Coerces a given value to this type
       #
       # @param value [*Object] value to be coerced
@@ -1202,15 +1373,24 @@ module Cassandra
         "'#{@name}'"
       end
 
+      def hash
+        @hash ||= begin
+          h = 17
+          h = 31 * h + @kind.hash
+          h = 31 * h + @name.hash
+          h
+        end
+      end
+
       def eql?(other)
         other.is_a?(Custom) && @name == other.name
       end
       alias :== :eql?
     end
 
-    # @return [Cassandra::Types::Varchar] varchar type
+    # @return [Cassandra::Types::Text] text type since varchar is an alias for text
     def varchar
-      Varchar
+      Text
     end
 
     # @return [Cassandra::Types::Text] text type
@@ -1288,8 +1468,28 @@ module Cassandra
       Timeuuid
     end
 
+    # @return [Cassandra::Types::Date] date type
+    def date
+      Date
+    end
+
+    # @return [Cassandra::Types::Time] time type
+    def time
+      Time
+    end
+
+    # @return [Cassandra::Types::Smallint] smallint type
+    def smallint
+      Smallint
+    end
+
+    # @return [Cassandra::Types::Tinyint] tinyint type
+    def tinyint
+      Tinyint
+    end
+
     # @param value_type [Cassandra::Type] the type of elements in this list
-    # @return [Cassandra::Types::Map] map type
+    # @return [Cassandra::Types::List] list type
     def list(value_type)
       Util.assert_instance_of(Cassandra::Type, value_type,
         "list type must be a Cassandra::Type, #{value_type.inspect} given"
@@ -1300,7 +1500,7 @@ module Cassandra
 
     # @param key_type [Cassandra::Type] the type of keys in this map
     # @param value_type [Cassandra::Type] the type of values in this map
-    # @return [Cassandra::Types::Varchar] varchar type
+    # @return [Cassandra::Types::Map] map type
     def map(key_type, value_type)
       Util.assert_instance_of(Cassandra::Type, key_type,
         "map key type must be a Cassandra::Type, #{key_type.inspect} given"
@@ -1312,7 +1512,7 @@ module Cassandra
       Map.new(key_type, value_type)
     end
 
-    # @param value_type [Cassandra::Type] the type of elements in this set
+    # @param value_type [Cassandra::Type] the type of values in this set
     # @return [Cassandra::Types::Set] set type
     def set(value_type)
       Util.assert_instance_of(Cassandra::Type, value_type,