class DuckDB::Appender

def append(value)
  case value
  when NilClass
    append_null
  when Float
    append_double(value)
  when Integer
    case value
    when RANGE_INT16
      append_int16(value)
    when RANGE_INT32
      append_int32(value)
    when RANGE_INT64
      append_int64(value)
    else
      append_hugeint(value)
    end
  when String
    blob?(value) ? append_blob(value) : append_varchar(value)
  when TrueClass, FalseClass
    append_bool(value)
  when Time
    append_timestamp(value)
  when Date
    append_date(value)
  when DuckDB::Interval
    append_interval(value)
  else
    raise(DuckDB::Error, "not supported type #{value} (#{value.class})")
  end
end

def append_blob(value)
  return self if _append_blob(value)
  raise_appender_error('failed to append_blob')
end

def append_bool(value)
  return self if _append_bool(value)
  raise_appender_error('failed to append_bool')
end

def append_date(value)
  date = _parse_date(value)
  return self if _append_date(date.year, date.month, date.day)
  raise_appender_error('failed to append_date')
end

def append_default
  return self if _append_default
  raise_appender_error('failed to append_default')
end

def append_double(value)
  return self if _append_double(value)
  raise_appender_error('failed to append_double')
end

def append_float(value)
  return self if _append_float(value)
  raise_appender_error('failed to append_float')
end

def append_hugeint(value)
  lower, upper = integer_to_hugeint(value)
  return self if _append_hugeint(lower, upper)
  raise_appender_error('failed to append_hugeint')
end

def append_int16(value)
  return self if _append_int16(value)
  raise_appender_error('failed to append_int16')
end

def append_int32(value)
  return self if _append_int32(value)
  raise_appender_error('failed to append_int32')
end

def append_int64(value)
  return self if _append_int64(value)
  raise_appender_error('failed to append_int64')
end

def append_int8(value)
  return self if _append_int8(value)
  raise_appender_error('failed to append_int8')
end

def append_interval(value)
  value = Interval.to_interval(value)
  return self if _append_interval(value.interval_months, value.interval_days, value.interval_micros)
  raise_appender_error('failed to append_interval')
end

def append_null
  return self if _append_null
  raise_appender_error('failed to append_null')
end

def append_row(*args)
  args.each do |arg|
    append(arg)
  end
  end_row
end

def append_time(value)
  time = _parse_time(value)
  return self if _append_time(time.hour, time.min, time.sec, time.usec)
  raise_appender_error('failed to append_time')
end

def append_timestamp(value)
  time = to_time(value)
  return self if _append_timestamp(time.year, time.month, time.day, time.hour, time.min, time.sec, time.nsec / 1000)
  raise_appender_error('failed to append_timestamp')
end

def append_uhugeint(value)
  lower, upper = integer_to_hugeint(value)
  return self if _append_uhugeint(lower, upper)
  raise_appender_error('failed to append_uhugeint')
end

def append_uint16(value)
  return self if _append_uint16(value)
  raise_appender_error('failed to append_uint16')
end

def append_uint32(value)
  return self if _append_uint32(value)
  raise_appender_error('failed to append_uint32')
end

def append_uint64(value)
  return self if _append_uint64(value)
  raise_appender_error('failed to append_uint64')
end

def append_uint8(value)
  return self if _append_uint8(value)
  raise_appender_error('failed to append_uint8')
end

def append_varchar(value)
  return self if _append_varchar(value)
  raise_appender_error('failed to append_varchar')
end

def append_varchar_length(value, length)
  return self if _append_varchar_length(value, length)
  raise_appender_error('failed to append_varchar_length')
end

def begin_row
  self
end

def blob?(value) # :nodoc:
  value.instance_of?(DuckDB::Blob) || value.encoding == Encoding::BINARY
end

def close
  return self if _close
  raise_appender_error('failed to close')
end

def end_row
  return self if _end_row
  raise_appender_error('failed to end_row')
end

def flush
  return self if _flush
  raise_appender_error('failed to flush')
end

def raise_appender_error(default_message) # :nodoc:
  message = error_message
  raise DuckDB::Error, message || default_message
end

def to_time(value) # :nodoc:
  case value
  when Date
    value.to_time
  else
    _parse_time(value)
  end
end