cassandra-driver 2.0.1-java → 2.1.0-java

data/lib/cassandra/statements/void.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 #--
-# Copyright 2013-2014 DataStax, Inc.
+# 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.

data/lib/cassandra/table.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 #--
-# Copyright 2013-2014 DataStax, Inc.
+# 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.
@@ -139,7 +139,7 @@ module Cassandra
     attr_reader :options
 
     # @private
-    def initialize(keyspace, name, partition_key, clustering_columns, columns, options, clustering_order)
+    def initialize(keyspace, name, partition_key, clustering_columns, columns, options, clustering_order, release_version)
       @keyspace           = keyspace
       @name               = name
       @partition_key      = partition_key
@@ -147,6 +147,7 @@ module Cassandra
       @columns            = columns
       @options            = options
       @clustering_order   = clustering_order
+      @release_version    = release_version
     end
 
     # @param name [String] column name
@@ -187,7 +188,7 @@ module Cassandra
         else
           cql << ",\n" unless first
         end
-        cql << "  #{column.to_cql}"
+        cql << "  #{column.name} #{type_to_cql(column.type, column.frozen?)}"
       end
       cql << ",\n  PRIMARY KEY ("
       if @partition_key.one?
@@ -261,7 +262,12 @@ module Cassandra
 
         buffer = Protocol::CqlByteBuffer.new
 
-        Protocol::Coder.write_value_v1(buffer, values[column_name], column.type)
+        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
@@ -274,7 +280,12 @@ module Cassandra
           buf    ||= Protocol::CqlByteBuffer.new
           buffer ||= Protocol::CqlByteBuffer.new
 
-          Protocol::Coder.write_value_v1(buf, values[column_name], column.type)
+          if @protocol_version > 2
+            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
@@ -288,6 +299,26 @@ module Cassandra
 
     private
 
+    # @private
+    def type_to_cql(type, is_frozen)
+      case type.kind
+      when :tuple
+        "frozen <#{type}>"
+      when :udt
+        if @keyspace == type.keyspace
+          "frozen <#{Util.escape_name(type.name)}>"
+        else
+          "frozen <#{Util.escape_name(type.keyspace)}.#{Util.escape_name(type.name)}>"
+        end
+      else
+        if is_frozen
+          "frozen <#{type}>"
+        else
+          "#{type}"
+        end
+      end
+    end
+
     NULL_BYTE = "\x00".freeze
 
     attr_reader :partition_key, :clustering_columns, :clustering_order

data/lib/cassandra/time_uuid.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 #--
-# Copyright 2013-2014 DataStax, Inc.
+# 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.

data/lib/cassandra/tuple.rb

@@ -0,0 +1,124 @@
+# 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
+  class Tuple
+    # @private
+    class Strict < Tuple
+      attr_reader :types
+
+      def initialize(types, values)
+        @types  = types
+        @values = values
+      end
+
+      def each(&block)
+        @types.size.times do |i|
+          yield(@values[i])
+        end
+        self
+      end
+
+      def [](i)
+        @values[Integer(i)]
+      end
+
+      def fetch(i)
+        i = Integer(i)
+        raise ::IndexError, "index #{i} is outside of tuple, size: #{@types.size}" if i < 0 || i >= @types.size
+        @values[i]
+      end
+
+      def []=(i, value)
+        raise ::IndexError, "index #{i} is outside of tuple, size: #{@types.size}" if i < 0 || i >= @types.size
+        Util.assert_type(@types[i], value)
+        @values[i] = value
+      end
+
+      def size
+        @types.size
+      end
+
+      def inspect
+        "#<Cassandra::Tuple:0x#{self.object_id.to_s(16)} #{to_s}>"
+      end
+    end
+
+    include Enumerable
+
+    # Constructs a tuple with given values
+    def initialize(*values)
+      @values = values
+    end
+
+    # Iterates over all values of the tuple
+    # @yieldparam value [Object] current value
+    def each(&block)
+      @values.each(&block)
+      self
+    end
+
+    # @param i [Integer] numeric index of the value inside the tuple, must
+    #   be `0 < i < tuple.size`
+    # @return [Object] value of the tuple at position `i`
+    def [](i)
+      @values[Integer(i)]
+    end
+
+    # @param i [Integer] numeric index of the value inside the tuple, must
+    #   be `0 < i < tuple.size`
+    # @raise [IndexError] when index is outside of tuple bounds
+    # @return [Object] value of the tuple at position `i`
+    def fetch(i)
+      i = Integer(i)
+      raise ::IndexError, "index #{i} is outside of tuple, size: #{@values.size}" if i < 0 || i >= @values.size
+      @values[i]
+    end
+
+    # @param i [Integer] numeric index of the value inside the tuple, must
+    #   be `0 < i < tuple.size`
+    # @param value [Object] a value to assign at position `i`
+    # @raise [IndexError] when index is outside of tuple bounds
+    # @return [Object] value of the tuple at position `i`
+    def []=(i, value)
+      i = Integer(i)
+      raise ::IndexError, "index #{i} is outside of tuple, size: #{@values.size}" if i < 0 || i >= @values.size
+      @values[i] = value
+    end
+
+    # Returns tuple size
+    # @return [Integer] tuple size
+    def size
+      @values.size
+    end
+
+    # String representation of the tuple
+    def to_s
+      "(#{@values.map(&:to_s).join(', ')})"
+    end
+
+    def inspect
+      "#<Cassandra::Tuple:0x#{self.object_id.to_s(16)} #{to_s}>"
+    end
+
+    def eql?(other)
+      other == @values
+    end
+    alias :== :eql?
+  end
+end

data/lib/cassandra/types.rb

@@ -0,0 +1,1406 @@
+# 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
+  # Base class for all cassandra types.
+  # @abstract This class exists for documentation purposes only
+  class Type
+    # @return [Symbol] shorthand type name
+    def kind
+    end
+
+    # Coerces a given value to this type
+    #
+    # @param values [*Object] value to be coerced
+    # @return [Object] a value of this type
+    def new(*values)
+    end
+
+    # Asserts that a given value is of this type
+    # @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 invalid
+    # @return [void]
+    def assert(value, message = nil, &block)
+    end
+
+    # @return [String] a cassandra representation of this type
+    def to_s
+    end
+  end
+
+  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
+
+      def assert(value, message = nil, &block)
+        __send__(:"assert_#{@kind}", value, message, &block)
+        nil
+      end
+
+      def to_s
+        @kind.to_s
+      end
+
+      def eql?(other)
+        other.is_a?(Simple) && @kind == other.kind
+      end
+      alias :== :eql?
+
+      private
+
+      def new_varchar(value)
+       String(value)
+      end
+
+      def assert_varchar(value, message, &block)
+        Util.assert_instance_of(::String, value, message, &block)
+      end
+
+      def new_text(value)
+        String(value)
+      end
+
+      def assert_text(valuee, message, &block)
+        Util.assert_instance_of(::String, valuee, message, &block)
+      end
+
+      def new_blob(value)
+        String(value)
+      end
+
+      def assert_blob(valuee, message, &block)
+        Util.assert_instance_of(::String, valuee, message, &block)
+      end
+
+      def new_ascii(value)
+        String(value)
+      end
+
+      def assert_ascii(valuee, message, &block)
+        Util.assert_instance_of(::String, valuee, message, &block)
+      end
+
+      def new_bigint(value)
+        Integer(value)
+      end
+
+      def assert_bigint(valuee, message, &block)
+        Util.assert_instance_of(::Integer, valuee, message, &block)
+      end
+
+      def new_counter(value)
+        Integer(value)
+      end
+
+      def assert_counter(valuee, message, &block)
+        Util.assert_instance_of(::Integer, valuee, message, &block)
+      end
+
+      def new_int(value)
+        Integer(value)
+      end
+
+      def assert_int(valuee, message, &block)
+        Util.assert_instance_of(::Integer, valuee, message, &block)
+      end
+
+      def new_varint(value)
+        Integer(value)
+      end
+
+      def assert_varint(valuee, message, &block)
+        Util.assert_instance_of(::Integer, valuee, 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)
+      end
+
+      def new_decimal(value)
+        ::BigDecimal.new(value)
+      end
+
+      def assert_decimal(valuee, message, &block)
+        Util.assert_instance_of(::BigDecimal, valuee, message, &block)
+      end
+
+      def new_double(value)
+        Float(value)
+      end
+
+      def assert_double(valuee, message, &block)
+        Util.assert_instance_of(::Float, valuee, message, &block)
+      end
+
+      def new_float(value)
+        Float(value)
+      end
+
+      def assert_float(valuee, message, &block)
+        Util.assert_instance_of(::Float, valuee, 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)
+      end
+
+      def new_timestamp(value)
+        case value
+        when ::Time
+          value
+        else
+          return value.to_time if value.respond_to?(:to_time)
+          raise ::ArgumentError, "cannot convert #{value.inspect} to timestamp"
+        end
+      end
+
+      def assert_timestamp(valuee, message, &block)
+        Util.assert_instance_of(::Time, valuee, message, &block)
+      end
+
+      def new_uuid(valuee, message, &block)
+        Cassandra::Uuid.new(value)
+      end
+
+      def assert_uuid(valuee, message, &block)
+        Util.assert_instance_of(Cassandra::Uuid, valuee, 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)
+      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))
+
+    # @!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 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))
+
+    # @!parse
+    #   class Ascii < Type
+    #     # @return [Symbol] `:ascii`
+    #     # @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] `"ascii"`
+    #     # @see Cassandra::Type#to_s
+    #     def to_s
+    #     end
+    #   end
+    const_set('Ascii', Simple.new(:ascii))
+
+    # @!parse
+    #   class Bigint < Type
+    #     # @return [Symbol] `:bigint`
+    #     # @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] `"bigint"`
+    #     # @see Cassandra::Type#to_s
+    #     def to_s
+    #     end
+    #   end
+    const_set('Bigint', Simple.new(:bigint))
+
+    # @!parse
+    #   class Counter < Type
+    #     # @return [Symbol] `:counter`
+    #     # @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] `"counter"`
+    #     # @see Cassandra::Type#to_s
+    #     def to_s
+    #     end
+    #   end
+    const_set('Counter', Simple.new(:counter))
+
+    # @!parse
+    #   class Int < Type
+    #     # @return [Symbol] `:int`
+    #     # @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] `"int"`
+    #     # @see Cassandra::Type#to_s
+    #     def to_s
+    #     end
+    #   end
+    const_set('Int', Simple.new(:int))
+
+    # @!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))
+
+    # @!parse
+    #   class Boolean < Type
+    #     # @return [Symbol] `:boolean`
+    #     # @see Cassandra::Type#kind
+    #     def kind
+    #     end
+    #
+    #     # Coerces the value to `true` or `false`
+    #     # @param value [Object] original value
+    #     # @return [Boolean] value
+    #     # @see Cassandra::Type#new
+    #     def new(value)
+    #     end
+    #
+    #     # 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 `true` or `false`
+    #     # @return [void]
+    #     # @see Cassandra::Type#assert
+    #     def assert(value, message = nil, &block)
+    #     end
+    #
+    #     # @return [String] `"boolean"`
+    #     # @see Cassandra::Type#to_s
+    #     def to_s
+    #     end
+    #   end
+    const_set('Boolean', Simple.new(:boolean))
+
+    # @!parse
+    #   class Decimal < Type
+    #     # @return [Symbol] `:decimal`
+    #     # @see Cassandra::Type#kind
+    #     def kind
+    #     end
+    #
+    #     # Coerces the value to BigDecimal
+    #     # @param value [Object] original value
+    #     # @return [BigDecimal] value
+    #     # @see Cassandra::Type#new
+    #     def new(value)
+    #     end
+    #
+    #     # Asserts that a given value is a BigDecimal
+    #     # @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 BigDecimal
+    #     # @return [void]
+    #     # @see Cassandra::Type#assert
+    #     def assert(value, message = nil, &block)
+    #     end
+    #
+    #     # @return [String] `"decimal"`
+    #     # @see Cassandra::Type#to_s
+    #     def to_s
+    #     end
+    #   end
+    const_set('Decimal', Simple.new(:decimal))
+
+    # @!parse
+    #   class Double < Type
+    #     # @return [Symbol] `:double`
+    #     # @see Cassandra::Type#kind
+    #     def kind
+    #     end
+    #
+    #     # Coerces the value to Float
+    #     # @param value [Object] original value
+    #     # @return [Float] value
+    #     # @see Cassandra::Type#new
+    #     def new(value)
+    #     end
+    #
+    #     # Asserts that a given value is a Float
+    #     # @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 Float
+    #     # @return [void]
+    #     # @see Cassandra::Type#assert
+    #     def assert(value, message = nil, &block)
+    #     end
+    #
+    #     # @return [String] `"double"`
+    #     # @see Cassandra::Type#to_s
+    #     def to_s
+    #     end
+    #   end
+    const_set('Double', Simple.new(:double))
+
+    # @!parse
+    #   class Float < Type
+    #     # @return [Symbol] `:float`
+    #     # @see Cassandra::Type#kind
+    #     def kind
+    #     end
+    #
+    #     # Coerces the value to Float
+    #     # @param value [Object] original value
+    #     # @return [Float] value
+    #     # @see Cassandra::Type#new
+    #     def new(value)
+    #     end
+    #
+    #     # Asserts that a given value is a Float
+    #     # @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 Float
+    #     # @return [void]
+    #     # @see Cassandra::Type#assert
+    #     def assert(value, message = nil, &block)
+    #     end
+    #
+    #     # @return [String] `"float"`
+    #     # @see Cassandra::Type#to_s
+    #     def to_s
+    #     end
+    #   end
+    const_set('Float', Simple.new(:float))
+
+    # @!parse
+    #   class Inet < Type
+    #     # @return [Symbol] `:inet`
+    #     # @see Cassandra::Type#kind
+    #     def kind
+    #     end
+    #
+    #     # Coerces the value to IPAddr
+    #     # @param value [Object] original value
+    #     # @return [IPAddr] value
+    #     # @see Cassandra::Type#new
+    #     def new(value)
+    #     end
+    #
+    #     # Asserts that a given value is an IPAddr
+    #     # @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 IPAddr
+    #     # @return [void]
+    #     # @see Cassandra::Type#assert
+    #     def assert(value, message = nil, &block)
+    #     end
+    #
+    #     # @return [String] `"inet"`
+    #     # @see Cassandra::Type#to_s
+    #     def to_s
+    #     end
+    #   end
+    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`
+    #     # @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))
+
+    class List < Type
+      # @private
+      attr_reader :value_type
+
+      # @private
+      def initialize(value_type)
+        @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
+      # @see Cassandra::Type#new
+      def new(*value)
+        value = Array(value.first) if value.one?
+
+        value.each do |v|
+          Util.assert_type(@value_type, v)
+        end
+        value
+      end
+
+      # Asserts that a given value is an Array
+      # @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 Array
+      # @return [void]
+      # @see Cassandra::Type#assert
+      def assert(value, message = nil, &block)
+        Util.assert_instance_of(::Array, value, message, &block)
+        value.each do |v|
+          Util.assert_type(@value_type, v, message, &block)
+        end
+        nil
+      end
+
+      # @return [String] `"list<type>"`
+      # @see Cassandra::Type#to_s
+      def to_s
+        "list<#{@value_type.to_s}>"
+      end
+
+      def eql?(other)
+        other.is_a?(List) && @value_type == other.value_type
+      end
+      alias :== :eql?
+    end
+
+    class Map < Type
+      # @private
+      attr_reader :key_type, :value_type
+
+      # @private
+      def initialize(key_type, value_type)
+        @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
+      # @see Cassandra::Type#new
+      def new(*value)
+        value = value.first if value.one?
+
+        case value
+        when ::Hash
+          value.each do |k, v|
+            Util.assert_type(@key_type, k)
+            Util.assert_type(@value_type, v)
+          end
+          value
+        when ::Array
+          result = ::Hash.new
+          value.each_slice(2) do |(k, v)|
+            Util.assert_type(@key_type, k)
+            Util.assert_type(@value_type, v)
+            result[k] = v
+          end
+          result
+        else
+          raise ::ArgumentError, "cannot convert #{value.inspect} to #{to_s}"
+        end
+      end
+
+      # Asserts that a given value is a Hash
+      # @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 Hash
+      # @return [void]
+      # @see Cassandra::Type#assert
+      def assert(value, message = nil, &block)
+        Util.assert_instance_of(::Hash, value, message, &block)
+        value.each do |k, v|
+          Util.assert_type(@key_type, k, message, &block)
+          Util.assert_type(@value_type, v, message, &block)
+        end
+        nil
+      end
+
+      # @return [String] `"map<type, type>"`
+      # @see Cassandra::Type#to_s
+      def to_s
+        "map<#{@key_type.to_s}, #{@value_type.to_s}>"
+      end
+
+      def eql?(other)
+        other.is_a?(Map) &&
+          @key_type == other.key_type &&
+          @value_type == other.value_type
+      end
+      alias :== :eql?
+    end
+
+    class Set < Type
+      # @private
+      attr_reader :value_type
+
+      # @private
+      def initialize(value_type)
+        @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
+      # @see Cassandra::Type#new
+      # @example Creating a set using splat arguments
+      #   include Cassandra::Types
+      #
+      #   set(varchar).new('Jane', 'Alice', 'Loren') => #<Set: {"Jane", "Alice", "Loren"}>
+      #
+      # @example Coercing an existing set
+      #   include Cassandra::Types
+      #
+      #   set(varchar).new(Set['Jane', 'Alice', 'Loren']) => #<Set: {"Jane", "Alice", "Loren"}>
+      #
+      # @example Coercing an array
+      #   include Cassandra::Types
+      #
+      #   set(varchar).new(['Jane', 'Alice', 'Loren']) => #<Set: {"Jane", "Alice", "Loren"}>
+      def new(*value)
+        value = value.first if value.one?
+
+        case value
+        when ::Array
+          result = ::Set.new
+          value.each do |v|
+            Util.assert_type(@value_type, v)
+            result << v
+          end
+          result
+        when ::Set
+          value.each do |v|
+            Util.assert_type(@value_type, v)
+          end
+          value
+        else
+          Util.assert_type(@value_type, value)
+          ::Set[value]
+        end
+      end
+
+      # Asserts that a given value is an Set
+      # @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 Set
+      # @return [void]
+      # @see Cassandra::Type#assert
+      def assert(value, message = nil, &block)
+        Util.assert_instance_of(::Set, value, message, &block)
+        value.each do |v|
+          Util.assert_type(@value_type, v, message, &block)
+        end
+        nil
+      end
+
+      # @return [String] `"set<type>"`
+      # @see Cassandra::Type#to_s
+      def to_s
+        "set<#{@value_type.to_s}>"
+      end
+
+      def eql?(other)
+        other.is_a?(Set) && @value_type == other.value_type
+      end
+      alias :== :eql?
+    end
+
+    class Tuple < Type
+      # @private
+      attr_reader :members
+
+      # @private
+      def initialize(*members)
+        @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
+      # @see Cassandra::Type#new
+      # @example Creating a tuple
+      #   include Cassandra::Types
+      #
+      #   tuple(varchar, varchar, int).new('Jane', 'Smith', 38) # => (Jane, Smith, 38)
+      def new(*values)
+        Util.assert(values.size <= @members.size) { "too many values: #{values.size} out of max #{@members.size}" }
+        values.each_with_index do |v, i|
+          Util.assert_type(@members[i], v)
+        end
+        Cassandra::Tuple::Strict.new(@members, values)
+      end
+
+      # Asserts that a given value is an Cassandra::Tuple
+      # @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 Cassandra::Tuple
+      # @return [void]
+      # @see Cassandra::Type#assert
+      def assert(value, message = nil, &block)
+        Util.assert_instance_of(Cassandra::Tuple, value, message, &block)
+        Util.assert(value.size <= @members.size, message, &block)
+        @members.each_with_index do |type, i|
+          Util.assert_type(type, value[i], message, &block)
+        end
+        nil
+      end
+
+      # @return [String] `"tuple<type, type, type...>"`
+      # @see Cassandra::Type#to_s
+      def to_s
+        "tuple<#{@members.map(&:to_s).join(', ')}>"
+      end
+
+      def eql?(other)
+        other.is_a?(Tuple) && @members == other.members
+      end
+      alias :== :eql?
+    end
+
+    class UserDefined < Type
+      class Field
+        # @return [String] name of this field
+        attr_reader :name
+        # @return [Cassandra::Type] type of this field
+        attr_reader :type
+
+        # @private
+        def initialize(name, type)
+          @name = name
+          @type = type
+        end
+
+        # String representation of the field
+        # @return [String] String representation of the field
+        def to_s
+          "#{@name} #{@type}"
+        end
+
+        def eql?(other)
+          other.is_a?(Field) &&
+            @name == other.name &&
+            @type == other.type
+        end
+        alias :== :eql?
+      end
+
+      # @return [String] keyspace where this type is defined
+      attr_reader :keyspace
+
+      # @return [String] name of this type
+      attr_reader :name
+
+      # @private
+      attr_reader :fields
+
+      # @private
+      def initialize(keyspace, name, fields)
+        @keyspace  = keyspace
+        @name      = name
+        @fields    = fields
+      end
+
+      # @param name [String] field name
+      # @return [Boolean] whether this type has a given field
+      def has_field?(name)
+        @fields.any? {|f| f.name == name}
+      end
+
+      # Yield or enumerate each field defined in this type
+      # @overload each_field
+      #   @yieldparam field [Cassandra::UserDefined::Field] field
+      #   @return [Cassandra::Types::UserDefined] self
+      # @overload each_field
+      #   @return [Array<Array<String, Cassandra::Type>>] a list of fields
+      def each_field(&block)
+        if block_given?
+          @fields.each(&block)
+          self
+        else
+          @fields.dup
+        end
+      end
+      alias :fields :each_field
+
+      # @param name [String] field name
+      # @return [Cassandra::UserDefined::Field, nil] a field with this name or
+      #   nil
+      def field(name)
+        @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
+      # @see Cassandra::Type#new
+      def new(*value)
+        value = value.first if value.one?
+        value = Array(value) unless value.is_a?(::Hash)
+
+        Util.assert(value.size <= @fields.size) { "too many values: #{value.size} out of #{@fields.size}" }
+
+        case value
+        when ::Array
+          result = ::Hash.new
+          value.each_with_index do |v, i|
+            f = @fields[i]
+            Util.assert_type(f.type, v)
+            result[f.name] = v
+          end
+        when ::Hash
+          result = ::Hash.new
+          @fields.each do |f|
+            n = f.name
+            v = value[n]
+            Util.assert_type(f.type, v)
+            result[n] = v
+          end
+        end
+
+        Cassandra::UDT::Strict.new(@keyspace, @name, @fields, result)
+      end
+
+      # Asserts that a given value is an Cassandra::UDT
+      # @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 Cassandra::UDT
+      # @return [void]
+      # @see Cassandra::Type#assert
+      def assert(value, message = nil, &block)
+        Util.assert_instance_of(Cassandra::UDT, value, message, &block)
+        Util.assert(value.size <= @fields.size, message, &block)
+        @fields.each do |field|
+          Util.assert_type(field.type, value[field.name], message, &block)
+        end
+        nil
+      end
+
+      # @return [String] `"keyspace.name"`
+      # @see Cassandra::Type#to_s
+      def to_s
+        "#{Util.escape_name(@keyspace)}.#{Util.escape_name(@name)} {#{@fields.join(', ')}}"
+      end
+
+      def eql?(other)
+        other.is_a?(UserDefined) &&
+          @keyspace == other.keyspace &&
+          @name == other.name &&
+          @fields == other.fields
+      end
+      alias :== :eql?
+
+      # Output this type in CQL
+      def to_cql
+        cql   = "CREATE TYPE #{Util.escape_name(@keyspace)}.#{Util.escape_name(@name)} (\n"
+        first = true
+
+        @fields.each do |field|
+          if first
+            first = false
+          else
+            cql << ",\n" unless first
+          end
+          cql << "  #{field.name} #{type_to_cql(field.type)}"
+        end
+
+        cql << "\n);"
+
+        cql
+      end
+
+      private
+
+      # @private
+      def type_to_cql(type)
+        case type.kind
+        when :tuple
+          "frozen <#{type}>"
+        when :udt
+          if @keyspace == type.keyspace
+            "frozen <#{Util.escape_name(type.name)}>"
+          else
+            "frozen <#{Util.escape_name(type.keyspace)}.#{Util.escape_name(type.name)}>"
+          end
+        else
+          "#{type}"
+        end
+      end
+    end
+
+    class Custom < Type
+      attr_reader :name
+
+      def initialize(name)
+        @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
+      # @return [Object] a value of this type
+      def new(*value)
+        raise ::NotImplementedError, "unable to create a value for custom type: #{@name.inspect}"
+      end
+
+      # Asserts that a given value is of this type
+      # @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 invalid
+      # @return [void]
+      def assert(value, message = nil, &block)
+        raise ::NotImplementedError, "unable to assert a value for custom type: #{@name.inspect}"
+      end
+
+      # @return [String] a cassandra representation of this type
+      def to_s
+        "custom: #{@name}"
+      end
+    end
+
+    # @return [Cassandra::Types::Varchar] varchar type
+    def varchar
+      Varchar
+    end
+
+    # @return [Cassandra::Types::Text] text type
+    def text
+      Text
+    end
+
+    # @return [Cassandra::Types::Blob] blob type
+    def blob
+      Blob
+    end
+
+    # @return [Cassandra::Types::Ascii] ascii type
+    def ascii
+      Ascii
+    end
+
+    # @return [Cassandra::Types::Bigint] bigint type
+    def bigint
+      Bigint
+    end
+
+    # @return [Cassandra::Types::Counter] counter type
+    def counter
+      Counter
+    end
+
+    # @return [Cassandra::Types::Int] int type
+    def int
+      Int
+    end
+
+    # @return [Cassandra::Types::Varint] varint type
+    def varint
+      Varint
+    end
+
+    # @return [Cassandra::Types::Boolean] boolean type
+    def boolean
+      Boolean
+    end
+
+    # @return [Cassandra::Types::Decimal] decimal type
+    def decimal
+      Decimal
+    end
+
+    # @return [Cassandra::Types::Double] double type
+    def double
+      Double
+    end
+
+    # @return [Cassandra::Types::Float] float type
+    def float
+      Float
+    end
+
+    # @return [Cassandra::Types::Inet] inet type
+    def inet
+      Inet
+    end
+
+    # @return [Cassandra::Types::Timestamp] timestamp type
+    def timestamp
+      Timestamp
+    end
+
+    # @return [Cassandra::Types::Uuid] uuid type
+    def uuid
+      Uuid
+    end
+
+    # @return [Cassandra::Types::Timeuuid] timeuuid type
+    def timeuuid
+      Timeuuid
+    end
+
+    # @param value_type [Cassandra::Type] the type of elements in this list
+    # @return [Cassandra::Types::Map] map type
+    def list(value_type)
+      Util.assert_instance_of(Cassandra::Type, value_type,
+        "list type must be a Cassandra::Type, #{value_type.inspect} given"
+      )
+
+      List.new(value_type)
+    end
+
+    # @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
+    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"
+      )
+      Util.assert_instance_of(Cassandra::Type, value_type,
+        "map value type must be a Cassandra::Type, #{value_type.inspect} given"
+      )
+
+      Map.new(key_type, value_type)
+    end
+
+    # @param value_type [Cassandra::Type] the type of elements in this set
+    # @return [Cassandra::Types::Set] set type
+    def set(value_type)
+      Util.assert_instance_of(Cassandra::Type, value_type,
+        "set type must be a Cassandra::Type, #{value_type.inspect} given"
+      )
+
+      Set.new(value_type)
+    end
+
+    # @param members [*Cassandra::Type] types of members of this tuple
+    # @return [Cassandra::Types::Tuple] tuple type
+    def tuple(*members)
+      Util.assert_not_empty(members, "tuple must contain at least one member")
+      members.each do |member|
+        Util.assert_instance_of(Cassandra::Type, member,
+          "each tuple member must be a Cassandra::Type, " \
+          "#{member.inspect} given"
+        )
+      end
+
+      Tuple.new(*members)
+    end
+
+    # Creates a User Defined Type instance
+    # @example Various ways of defining the same UDT
+    #   include Cassandra::Types
+    #
+    #   udt('simplex', 'address', {'street' => varchar, 'city' => varchar, 'state' => varchar, 'zip' => varchar}) #=> simplex.address
+    #
+    #   udt('simplex', 'address', [['street', varchar], ['city', varchar], ['state', varchar], ['zip', varchar]]) #=> simplex.address
+    #
+    #   udt('simplex', 'address', ['street', varchar], ['city', varchar], ['state', varchar], ['zip', varchar]) #=> simplex.address
+    #
+    #   udt('simplex', 'address', 'street', varchar, 'city', varchar, 'state', varchar, 'zip', varchar) #=> simplex.address
+    # @param keyspace [String] name of the keyspace that this UDT is defined in
+    # @param name     [String] name of this UDT
+    # @param fields   [Hash<String, Cassandra::Type>,
+    #                  Array<Array<String, Cassandra::Type>>,
+    #                  *(String, Cassandra::Type),
+    #                  *Array<String, Cassandra::Type>] UDT field types
+    # @return [Cassandra::Types::UserDefined] user defined type
+    def udt(keyspace, name, *fields)
+      keyspace = String(keyspace)
+      name     = String(name)
+      fields   = Array(fields.first) if fields.one?
+
+      Util.assert_not_empty(fields,
+        "user-defined type must contain at least one field"
+      )
+
+      if fields.first.is_a?(::Array)
+        fields = fields.map do |pair|
+          Util.assert(pair.size == 2,
+            "fields of a user-defined type must be an Array of name and " \
+            "value pairs, #{pair.inspect} given"
+          )
+          Util.assert_instance_of(::String, pair[0],
+            "each field name for a user-defined type must be a String, " \
+            "#{pair[0].inspect} given"
+          )
+          Util.assert_instance_of(Cassandra::Type, pair[1],
+            "each field type for a user-defined type must be a " \
+            "Cassandra::Type, #{pair[1].inspect} given"
+          )
+
+          UserDefined::Field.new(*pair)
+        end
+      else
+        Util.assert((fields.size % 2) == 0,
+          "fields of a user-defined type must be an Array of alternating " \
+          "names and values pairs, #{fields.inspect} given"
+        )
+        fields = fields.each_slice(2).map do |field_name, field_type|
+          Util.assert_instance_of(::String, field_name,
+            "each field name for a user-defined type must be a String, " \
+            "#{field_name.inspect} given"
+          )
+          Util.assert_instance_of(Cassandra::Type, field_type,
+            "each field type for a user-defined type must be a " \
+            "Cassandra::Type, #{field_type.inspect} given"
+          )
+
+          UserDefined::Field.new(field_name, field_type)
+        end
+      end
+
+      UserDefined.new(keyspace, name, fields)
+    end
+
+    # @param name [String] name of the custom type
+    # @return [Cassandra::Types::Custom] custom type
+    def custom(name)
+      Custom.new(name)
+    end
+  end
+end