anonymous_namespace{Datum.cpp} Namespace Reference

Functions
int64_t	convert_decimal_value_to_scale_internal (const int64_t decimal_value, int const dscale)
template<typename T >
T	minValue (unsigned const fieldsize)
template<typename T >
T	maxValue (unsigned const fieldsize)
std::string	toString (SQLTypeInfo const &ti, unsigned const fieldsize)
template<typename T , typename U = long double>
T	parseFloatAsInteger (std::string_view s, SQLTypeInfo const &ti)
bool	hasCommonSuffix (char const *const ptr, char const *const end)
template<typename T >
T	parseInteger (std::string_view s, SQLTypeInfo const &ti)
SQLTypes	get_type_for_datum (const SQLTypeInfo &ti)

Function Documentation

int64_t anonymous_namespace{Datum.cpp}::convert_decimal_value_to_scale_internal	(	const int64_t	decimal_value,
		int const	dscale
	)

Definition at line 79 of file Datum.cpp.

References sql_constants::kMaxRepresentableNumericPrecision.

Referenced by convert_decimal_value_to_scale(), and parse_numeric().

                                                                  {
  constexpr int max_scale = sql_constants::kMaxRepresentableNumericPrecision;  // 19
  constexpr auto pow10 = shared::powersOf<uint64_t, max_scale + 1>(10);
  if (dscale < 0) {
    if (dscale < -max_scale) {
      return 0;  // +/- 0.09223372036854775807 rounds to 0
    }
    uint64_t const u = std::abs(decimal_value);
    uint64_t const pow = pow10[-dscale];
    uint64_t div = u / pow;
    uint64_t rem = u % pow;
    div += pow / 2 <= rem;
    return decimal_value < 0 ? -div : div;
  } else if (dscale < max_scale) {
    int64_t retval;
#ifdef _WIN32
    return decimal_value * pow10[dscale];
#else
    if (!__builtin_mul_overflow(decimal_value, pow10[dscale], &retval)) {
      return retval;
    }
#endif
  }
  if (decimal_value == 0) {
    return 0;
  }
  throw std::runtime_error("Overflow in DECIMAL-to-DECIMAL conversion.");
}

Here is the caller graph for this function:

SQLTypes anonymous_namespace{Datum.cpp}::get_type_for_datum ( const SQLTypeInfo &  ti )

inline

Definition at line 272 of file Datum.cpp.

References decimal_to_int_type(), SQLTypeInfo::get_type(), SQLTypeInfo::is_decimal(), SQLTypeInfo::is_dict_encoded_string(), string_dict_to_int_type(), and run_benchmark_import::type.

                                                          {
  SQLTypes type;
  if (ti.is_decimal()) {
    type = decimal_to_int_type(ti);
  } else if (ti.is_dict_encoded_string()) {
    type = string_dict_to_int_type(ti);
  } else {
    type = ti.get_type();
  }
  return type;
}

Here is the call graph for this function:

bool anonymous_namespace{Datum.cpp}::hasCommonSuffix ( char const *const  ptr, char const *const  end  )

inline

Definition at line 224 of file Datum.cpp.

Referenced by parseInteger().

                                                                          {
  return *ptr == '.' && (ptr + 1 == end || (ptr[1] == '0' && ptr + 2 == end));
}

Here is the caller graph for this function:

template<typename T >

T anonymous_namespace{Datum.cpp}::maxValue

(

unsigned const

fieldsize

)

Definition at line 173 of file Datum.cpp.

                                     {
  return ~minValue<T>(fieldsize);
}

template<typename T >

T anonymous_namespace{Datum.cpp}::minValue

(

unsigned const

fieldsize

)

Definition at line 167 of file Datum.cpp.

References heavydb.dtypes::T.

                                     {
  static_assert(std::is_signed_v<T>);
  return T(-1) << (fieldsize - 1);
}

template<typename T , typename U = long double>

T anonymous_namespace{Datum.cpp}::parseFloatAsInteger	(	std::string_view	s,
		SQLTypeInfo const &	ti
	)

Definition at line 187 of file Datum.cpp.

References SQLTypeInfo::get_type_name(), and heavydb.dtypes::T.

                                                               {
  // Use stack memory if s is small enough before resorting to dynamic memory.
  constexpr size_t bufsize = 64;
  char c_str[bufsize];
  std::string str;
  char const* str_begin;
  char* str_end;
  if (s.size() < bufsize) {
    s.copy(c_str, s.size());
    c_str[s.size()] = '\0';
    str_begin = c_str;
  } else {
    str = s;
    str_begin = str.c_str();
  }
  U value = strtold(str_begin, &str_end);
  if (str_begin == str_end) {
    throw std::runtime_error("Unable to parse " + std::string(s) + " to " +
                             ti.get_type_name());
  } else if (str_begin + s.size() != str_end) {
    throw std::runtime_error(std::string("Unexpected character \"") + *str_end +
                             "\" encountered in " + ti.get_type_name() + " value " +
                             std::string(s));
  }
  value = std::round(value);
  if (!std::isfinite(value)) {
    throw std::runtime_error("Invalid conversion from \"" + std::string(s) + "\" to " +
                             ti.get_type_name());
  } else if (value < static_cast<U>(std::numeric_limits<T>::min()) ||
             static_cast<U>(std::numeric_limits<T>::max()) < value) {
    throw std::runtime_error("Integer " + std::string(s) + " is out of range for " +
                             ti.get_type_name());
  }
  return static_cast<T>(value);
}

Here is the call graph for this function:

template<typename T >

T anonymous_namespace{Datum.cpp}::parseInteger	(	std::string_view	s,
		SQLTypeInfo const &	ti
	)

Definition at line 229 of file Datum.cpp.

References SQLTypeInfo::get_comp_param(), SQLTypeInfo::get_compression(), SQLTypeInfo::get_notnull(), SQLTypeInfo::get_type_name(), hasCommonSuffix(), kENCODING_FIXED, heavydb.dtypes::T, and toString().

                                                        {
  T retval{0};
  char const* const end = s.data() + s.size();
  auto [ptr, error_code] = std::from_chars(s.data(), end, retval);
  if (ptr != end) {
    if (error_code != std::errc() || !hasCommonSuffix(ptr, end)) {
      retval = parseFloatAsInteger<T>(s, ti);
    }
  } else if (error_code != std::errc()) {
    if (error_code == std::errc::result_out_of_range) {
      throw std::runtime_error("Integer " + std::string(s) + " is out of range for " +
                               ti.get_type_name());
    }
    throw std::runtime_error("Invalid conversion from \"" + std::string(s) + "\" to " +
                             ti.get_type_name());
  }
  // Bounds checking based on SQLTypeInfo.
  unsigned const fieldsize =
      ti.get_compression() == kENCODING_FIXED ? ti.get_comp_param() : 8 * sizeof(T);
  if (fieldsize < 8 * sizeof(T)) {
    if (maxValue<T>(fieldsize) < retval) {
      throw std::runtime_error("Integer " + std::string(s) +
                               " exceeds maximum value for " + toString(ti, fieldsize));
    } else if (ti.get_notnull()) {
      if (retval < minValue<T>(fieldsize)) {
        throw std::runtime_error("Integer " + std::string(s) +
                                 " exceeds minimum value for " + toString(ti, fieldsize));
      }
    } else {
      if (retval <= minValue<T>(fieldsize)) {
        throw std::runtime_error("Integer " + std::string(s) +
                                 " exceeds minimum value for nullable " +
                                 toString(ti, fieldsize));
      }
    }
  } else if (!ti.get_notnull() && retval == std::numeric_limits<T>::min()) {
    throw std::runtime_error("Integer " + std::string(s) +
                             " exceeds minimum value for nullable " +
                             toString(ti, fieldsize));
  }
  return retval;
}

Here is the call graph for this function:

std::string anonymous_namespace{Datum.cpp}::toString	(	SQLTypeInfo const &	ti,
		unsigned const	fieldsize
	)

Definition at line 177 of file Datum.cpp.

References SQLTypeInfo::get_type_name(), and to_string().

                                                                    {
  return ti.get_type_name() + '(' + std::to_string(fieldsize) + ')';
}

Here is the call graph for this function: