class Cql::Protocol::TypeConverter

Public Class Methods

new() click to toggle source
# File lib/cql/protocol/type_converter.rb, line 10
def initialize
  @from_bytes_converters = from_bytes_converters
  @to_bytes_converters = to_bytes_converters
end

Public Instance Methods

from_bytes(buffer, type, size_bytes=4) click to toggle source
# File lib/cql/protocol/type_converter.rb, line 15
def from_bytes(buffer, type, size_bytes=4)
  return nil if buffer.empty?
  case type
  when Array
    return nil unless read_size(buffer, size_bytes)
    case type.first
    when :list
      bytes_to_list(buffer, @from_bytes_converters[type[1]])
    when :map
      bytes_to_map(buffer, @from_bytes_converters[type[1]], @from_bytes_converters[type[2]])
    when :set
      bytes_to_set(buffer, @from_bytes_converters[type[1]])
    end
  else
    @from_bytes_converters[type].call(buffer, size_bytes)
  end
end
to_bytes(buffer, type, value, size_bytes=4) click to toggle source
# File lib/cql/protocol/type_converter.rb, line 33
def to_bytes(buffer, type, value, size_bytes=4)
  case type
  when Array
    unless value.nil? || value.is_a?(Enumerable)
      raise InvalidValueError, 'Value for collection must be enumerable'
    end
    case type.first
    when :list, :set
      _, sub_type = type
      if value
        raw = CqlByteBuffer.new
        raw.append_short(value.size)
        value.each do |element|
          to_bytes(raw, sub_type, element, 2)
        end
        buffer.append_bytes(raw)
      else
        nil_to_bytes(buffer, size_bytes)
      end
    when :map
      _, key_type, value_type = type
      if value
        raw = CqlByteBuffer.new
        raw.append_short(value.size)
        value.each do |key, value|
          to_bytes(raw, key_type, key, 2)
          to_bytes(raw, value_type, value, 2)
        end
        buffer.append_bytes(raw)
      else
        nil_to_bytes(buffer, size_bytes)
      end
    else
      raise UnsupportedColumnTypeError, %(Unsupported column collection type: #{type.first})
    end
  else
    converter = @to_bytes_converters[type]
    unless converter
      raise UnsupportedColumnTypeError, %(Unsupported column type: #{type})
    end
    converter.call(buffer, value, size_bytes)
  end
rescue TypeError => e
  raise TypeError, %("#{value}" cannot be encoded as #{type.to_s.upcase}: #{e.message}), e.backtrace
end

Private Instance Methods

ascii_to_bytes(buffer, value, size_bytes) click to toggle source
# File lib/cql/protocol/type_converter.rb, line 237
def ascii_to_bytes(buffer, value, size_bytes)
  v = value && value.encode(::Encoding::ASCII)
  if size_bytes == 4
    buffer.append_bytes(v)
  else
    buffer.append_short_bytes(v)
  end
end
bigint_to_bytes(buffer, value, size_bytes) click to toggle source
# File lib/cql/protocol/type_converter.rb, line 246
def bigint_to_bytes(buffer, value, size_bytes)
  if value
    size_to_bytes(buffer, 8, size_bytes)
    buffer.append_long(value)
  else
    nil_to_bytes(buffer, size_bytes)
  end
end
blob_to_bytes(buffer, value, size_bytes) click to toggle source
# File lib/cql/protocol/type_converter.rb, line 255
def blob_to_bytes(buffer, value, size_bytes)
  v = value && value.encode(::Encoding::BINARY)
  if size_bytes == 4
    buffer.append_bytes(v)
  else
    buffer.append_short_bytes(v)
  end
end
boolean_to_bytes(buffer, value, size_bytes) click to toggle source
# File lib/cql/protocol/type_converter.rb, line 264
def boolean_to_bytes(buffer, value, size_bytes)
  if !value.nil?
    size_to_bytes(buffer, 1, size_bytes)
    buffer.append(value ? Constants::TRUE_BYTE : Constants::FALSE_BYTE)
  else
    nil_to_bytes(buffer, size_bytes)
  end
end
bytes_to_ascii(buffer, size_bytes) click to toggle source
# File lib/cql/protocol/type_converter.rb, line 134
def bytes_to_ascii(buffer, size_bytes)
  bytes = size_bytes == 4 ? buffer.read_bytes : buffer.read_short_bytes
  bytes ? bytes.force_encoding(::Encoding::ASCII) : nil
end
bytes_to_bigint(buffer, size_bytes) click to toggle source
# File lib/cql/protocol/type_converter.rb, line 139
def bytes_to_bigint(buffer, size_bytes)
  return nil unless read_size(buffer, size_bytes)
  buffer.read_long
end
bytes_to_blob(buffer, size_bytes) click to toggle source
# File lib/cql/protocol/type_converter.rb, line 144
def bytes_to_blob(buffer, size_bytes)
  bytes = size_bytes == 4 ? buffer.read_bytes : buffer.read_short_bytes
  bytes ? bytes : nil
end
bytes_to_boolean(buffer, size_bytes) click to toggle source
# File lib/cql/protocol/type_converter.rb, line 149
def bytes_to_boolean(buffer, size_bytes)
  return nil unless read_size(buffer, size_bytes)
  buffer.read(1) == Constants::TRUE_BYTE
end
bytes_to_decimal(buffer, size_bytes) click to toggle source
# File lib/cql/protocol/type_converter.rb, line 154
def bytes_to_decimal(buffer, size_bytes)
  size = read_size(buffer, size_bytes)
  return nil unless size
  buffer.read_decimal(size)
end
bytes_to_double(buffer, size_bytes) click to toggle source
# File lib/cql/protocol/type_converter.rb, line 160
def bytes_to_double(buffer, size_bytes)
  return nil unless read_size(buffer, size_bytes)
  buffer.read_double
end
bytes_to_float(buffer, size_bytes) click to toggle source
# File lib/cql/protocol/type_converter.rb, line 165
def bytes_to_float(buffer, size_bytes)
  return nil unless read_size(buffer, size_bytes)
  buffer.read_float
end
bytes_to_inet(buffer, size_bytes) click to toggle source
# File lib/cql/protocol/type_converter.rb, line 202
def bytes_to_inet(buffer, size_bytes)
  size = read_size(buffer, size_bytes)
  return nil unless size
  IPAddr.new_ntoh(buffer.read(size))
end
bytes_to_int(buffer, size_bytes) click to toggle source
# File lib/cql/protocol/type_converter.rb, line 170
def bytes_to_int(buffer, size_bytes)
  return nil unless read_size(buffer, size_bytes)
  buffer.read_signed_int
end
bytes_to_list(buffer, value_converter) click to toggle source
# File lib/cql/protocol/type_converter.rb, line 208
def bytes_to_list(buffer, value_converter)
  list = []
  size = buffer.read_short
  size.times do
    list << value_converter.call(buffer, 2)
  end
  list
end
bytes_to_map(buffer, key_converter, value_converter) click to toggle source
# File lib/cql/protocol/type_converter.rb, line 217
def bytes_to_map(buffer, key_converter, value_converter)
  map = {}
  size = buffer.read_short
  size.times do
    key = key_converter.call(buffer, 2)
    value = value_converter.call(buffer, 2)
    map[key] = value
  end
  map
end
bytes_to_set(buffer, value_converter) click to toggle source
# File lib/cql/protocol/type_converter.rb, line 228
def bytes_to_set(buffer, value_converter)
  set = Set.new
  size = buffer.read_short
  size.times do
    set << value_converter.call(buffer, 2)
  end
  set
end
bytes_to_timestamp(buffer, size_bytes) click to toggle source
# File lib/cql/protocol/type_converter.rb, line 175
def bytes_to_timestamp(buffer, size_bytes)
  return nil unless read_size(buffer, size_bytes)
  timestamp = buffer.read_long
  Time.at(timestamp/1000.0)
end
bytes_to_timeuuid(buffer, size_bytes) click to toggle source
# File lib/cql/protocol/type_converter.rb, line 197
def bytes_to_timeuuid(buffer, size_bytes)
  return nil unless read_size(buffer, size_bytes)
  buffer.read_uuid(TimeUuid)
end
bytes_to_uuid(buffer, size_bytes) click to toggle source
# File lib/cql/protocol/type_converter.rb, line 192
def bytes_to_uuid(buffer, size_bytes)
  return nil unless read_size(buffer, size_bytes)
  buffer.read_uuid
end
bytes_to_varchar(buffer, size_bytes) click to toggle source
# File lib/cql/protocol/type_converter.rb, line 181
def bytes_to_varchar(buffer, size_bytes)
  bytes = size_bytes == 4 ? buffer.read_bytes : buffer.read_short_bytes
  bytes ? bytes.force_encoding(::Encoding::UTF_8) : nil
end
bytes_to_varint(buffer, size_bytes) click to toggle source
# File lib/cql/protocol/type_converter.rb, line 186
def bytes_to_varint(buffer, size_bytes)
  size = read_size(buffer, size_bytes)
  return nil unless size
  buffer.read_varint(size)
end
decimal_to_bytes(buffer, value, size_bytes) click to toggle source
# File lib/cql/protocol/type_converter.rb, line 273
def decimal_to_bytes(buffer, value, size_bytes)
  raw = value && CqlByteBuffer.new.append_decimal(value)
  if size_bytes == 4
    buffer.append_bytes(raw)
  else
    buffer.append_short_bytes(raw)
  end
end
double_to_bytes(buffer, value, size_bytes) click to toggle source
# File lib/cql/protocol/type_converter.rb, line 282
def double_to_bytes(buffer, value, size_bytes)
  if value
    size_to_bytes(buffer, 8, size_bytes)
    buffer.append_double(value)
  else
    nil_to_bytes(buffer, size_bytes)
  end
end
float_to_bytes(buffer, value, size_bytes) click to toggle source
# File lib/cql/protocol/type_converter.rb, line 291
def float_to_bytes(buffer, value, size_bytes)
  if value
    size_to_bytes(buffer, 4, size_bytes)
    buffer.append_float(value)
  else
    nil_to_bytes(buffer, size_bytes)
  end
end
from_bytes_converters() click to toggle source
# File lib/cql/protocol/type_converter.rb, line 81
def from_bytes_converters
  {
    :ascii => method(:bytes_to_ascii),
    :bigint => method(:bytes_to_bigint),
    :blob => method(:bytes_to_blob),
    :boolean => method(:bytes_to_boolean),
    :counter => method(:bytes_to_bigint),
    :decimal => method(:bytes_to_decimal),
    :double => method(:bytes_to_double),
    :float => method(:bytes_to_float),
    :int => method(:bytes_to_int),
    :timestamp => method(:bytes_to_timestamp),
    :varchar => method(:bytes_to_varchar),
    :text => method(:bytes_to_varchar),
    :varint => method(:bytes_to_varint),
    :timeuuid => method(:bytes_to_timeuuid),
    :uuid => method(:bytes_to_uuid),
    :inet => method(:bytes_to_inet),
  }
end
inet_to_bytes(buffer, value, size_bytes) click to toggle source
# File lib/cql/protocol/type_converter.rb, line 300
def inet_to_bytes(buffer, value, size_bytes)
  if value
    size_to_bytes(buffer, value.ipv6? ? 16 : 4, size_bytes)
    buffer.append(value.hton)
  else
    nil_to_bytes(buffer, size_bytes)
  end
end
int_to_bytes(buffer, value, size_bytes) click to toggle source
# File lib/cql/protocol/type_converter.rb, line 309
def int_to_bytes(buffer, value, size_bytes)
  if value
    size_to_bytes(buffer, 4, size_bytes)
    buffer.append_int(value)
  else
    nil_to_bytes(buffer, size_bytes)
  end
end
nil_to_bytes(buffer, size_bytes) click to toggle source
# File lib/cql/protocol/type_converter.rb, line 363
def nil_to_bytes(buffer, size_bytes)
  if size_bytes == 4
    buffer.append_int(-1)
  else
    buffer.append_short(-1)
  end
end
read_size(buffer, size_bytes) click to toggle source
# File lib/cql/protocol/type_converter.rb, line 123
def read_size(buffer, size_bytes)
  if size_bytes == 2
    size = buffer.read_short
    return nil if size & 0x8000 == 0x8000
  else
    size = buffer.read_signed_int
    return nil if size & 0x80000000 == 0x80000000
  end
  size
end
size_to_bytes(buffer, size, size_bytes) click to toggle source
# File lib/cql/protocol/type_converter.rb, line 355
def size_to_bytes(buffer, size, size_bytes)
  if size_bytes == 4
    buffer.append_int(size)
  else
    buffer.append_short(size)
  end
end
timestamp_to_bytes(buffer, value, size_bytes) click to toggle source
# File lib/cql/protocol/type_converter.rb, line 327
def timestamp_to_bytes(buffer, value, size_bytes)
  if value
    ms = (value.to_f * 1000).to_i
    size_to_bytes(buffer, 8, size_bytes)
    buffer.append_long(ms)
  else
    nil_to_bytes(buffer, size_bytes)
  end
end
to_bytes_converters() click to toggle source
# File lib/cql/protocol/type_converter.rb, line 102
def to_bytes_converters
  {
    :ascii => method(:ascii_to_bytes),
    :bigint => method(:bigint_to_bytes),
    :blob => method(:blob_to_bytes),
    :boolean => method(:boolean_to_bytes),
    :counter => method(:bigint_to_bytes),
    :decimal => method(:decimal_to_bytes),
    :double => method(:double_to_bytes),
    :float => method(:float_to_bytes),
    :inet => method(:inet_to_bytes),
    :int => method(:int_to_bytes),
    :text => method(:varchar_to_bytes),
    :varchar => method(:varchar_to_bytes),
    :timestamp => method(:timestamp_to_bytes),
    :timeuuid => method(:uuid_to_bytes),
    :uuid => method(:uuid_to_bytes),
    :varint => method(:varint_to_bytes),
  }
end
uuid_to_bytes(buffer, value, size_bytes) click to toggle source
# File lib/cql/protocol/type_converter.rb, line 337
def uuid_to_bytes(buffer, value, size_bytes)
  if value
    size_to_bytes(buffer, 16, size_bytes)
    buffer.append_uuid(value)
  else
    nil_to_bytes(buffer, size_bytes)
  end
end
varchar_to_bytes(buffer, value, size_bytes) click to toggle source
# File lib/cql/protocol/type_converter.rb, line 318
def varchar_to_bytes(buffer, value, size_bytes)
  v = value && value.encode(::Encoding::UTF_8)
  if size_bytes == 4
    buffer.append_bytes(v)
  else
    buffer.append_short_bytes(v)
  end
end
varint_to_bytes(buffer, value, size_bytes) click to toggle source
# File lib/cql/protocol/type_converter.rb, line 346
def varint_to_bytes(buffer, value, size_bytes)
  raw = value && CqlByteBuffer.new.append_varint(value)
  if size_bytes == 4
    buffer.append_bytes(raw)
  else
    buffer.append_short_bytes(raw)
  end
end