Analyzer::anonymous_namespace{Analyzer.cpp} Namespace Reference

Functions
template<typename T >
T	floatFromDecimal (int64_t const dec, unsigned const scale)
template<typename FLOAT_TYPE , typename INT_TYPE >
constexpr FLOAT_TYPE	maxRound ()
template<typename TO , typename FROM >
TO	safeNarrow (FROM const from)
template<typename T >
T	roundDecimal (int64_t n, unsigned scale)
template<typename TO , typename FROM >
TO	safeRound (FROM const from)
template<typename T >
int64_t	safeScale (T from, unsigned const scale)
bool	is_null_value (const SQLTypeInfo &ti, const Datum &constval)
template<class T >
bool	expr_is (const std::shared_ptr< Analyzer::Expr > &expr)
bool	is_expr_nullable (const Analyzer::Expr *expr)
bool	is_in_values_nullable (const std::shared_ptr< Analyzer::Expr > &a, const std::list< std::shared_ptr< Analyzer::Expr >> &l)
SQLTypes	get_ti_from_geo (const Geospatial::GeoBase *geo)

Function Documentation

template<class T >

bool Analyzer::anonymous_namespace{Analyzer.cpp}::expr_is

(

const std::shared_ptr< Analyzer::Expr > &

expr

)

Definition at line 1453 of file Analyzer.cpp.

References omnisci.dtypes::T.

                                                      {
  return std::dynamic_pointer_cast<T>(expr) != nullptr;
}

template<typename T >

T Analyzer::anonymous_namespace{Analyzer.cpp}::floatFromDecimal	(	int64_t const	dec,
		unsigned const	scale
	)

Definition at line 737 of file Analyzer.cpp.

References shared::power10(), and omnisci.dtypes::T.

                                                            {
  static_assert(std::is_floating_point_v<T>);
  return static_cast<T>(dec) / shared::power10(scale);
}

Here is the call graph for this function:

SQLTypes Analyzer::anonymous_namespace{Analyzer.cpp}::get_ti_from_geo

(

const Geospatial::GeoBase *

geo

)

Definition at line 3458 of file Analyzer.cpp.

References CHECK, Geospatial::GeoBase::getType(), Geospatial::GeoBase::kLINESTRING, kLINESTRING, Geospatial::GeoBase::kMULTIPOLYGON, kMULTIPOLYGON, kNULLT, Geospatial::GeoBase::kPOINT, kPOINT, Geospatial::GeoBase::kPOLYGON, kPOLYGON, and UNREACHABLE.

Referenced by Analyzer::GeoConstant::GeoConstant(), and RelAlgTranslator::translateGeoFunctionArg().

                                                       {
  CHECK(geo);
  switch (geo->getType()) {
    case Geospatial::GeoBase::GeoType::kPOINT: {
      return kPOINT;
    }
    case Geospatial::GeoBase::GeoType::kLINESTRING: {
      return kLINESTRING;
    }
    case Geospatial::GeoBase::GeoType::kPOLYGON: {
      return kPOLYGON;
    }
    case Geospatial::GeoBase::GeoType::kMULTIPOLYGON: {
      return kMULTIPOLYGON;
    }
    default:
      UNREACHABLE();
      return kNULLT;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Analyzer::anonymous_namespace{Analyzer.cpp}::is_expr_nullable

(

const Analyzer::Expr *

expr

)

Definition at line 1570 of file Analyzer.cpp.

References Analyzer::Constant::get_is_null(), SQLTypeInfo::get_notnull(), and Analyzer::Expr::get_type_info().

Referenced by is_in_values_nullable().

                                                {
  const auto const_expr = dynamic_cast<const Analyzer::Constant*>(expr);
  if (const_expr) {
    return const_expr->get_is_null();
  }
  const auto& expr_ti = expr->get_type_info();
  return !expr_ti.get_notnull();
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Analyzer::anonymous_namespace{Analyzer.cpp}::is_in_values_nullable	(	const std::shared_ptr< Analyzer::Expr > &	a,
		const std::list< std::shared_ptr< Analyzer::Expr >> &	l
	)

Definition at line 1579 of file Analyzer.cpp.

References is_expr_nullable().

                                                                          {
  if (is_expr_nullable(a.get())) {
    return true;
  }
  for (const auto& v : l) {
    if (is_expr_nullable(v.get())) {
      return true;
    }
  }
  return false;
}

Here is the call graph for this function:

bool Analyzer::anonymous_namespace{Analyzer.cpp}::is_null_value ( const SQLTypeInfo &  ti, const Datum &  constval  )

inline

Definition at line 1150 of file Analyzer.cpp.

References Datum::arrayval, Datum::bigintval, Datum::doubleval, Datum::floatval, SQLTypeInfo::get_type(), Datum::intval, kARRAY, kBIGINT, kBOOLEAN, kCHAR, kDATE, kDECIMAL, kDOUBLE, kFLOAT, kINT, kLINESTRING, kMULTIPOLYGON, kNULLT, kNUMERIC, kPOINT, kPOLYGON, kSMALLINT, kTEXT, kTIME, kTIMESTAMP, kTINYINT, kVARCHAR, NULL_BIGINT, NULL_BOOLEAN, NULL_DOUBLE, NULL_FLOAT, NULL_INT, NULL_SMALLINT, NULL_TINYINT, Datum::smallintval, Datum::stringval, Datum::tinyintval, and UNREACHABLE.

Referenced by Analyzer::Constant::do_cast().

                                                                        {
  switch (ti.get_type()) {
    case kBOOLEAN:
      return constval.tinyintval == NULL_BOOLEAN;
    case kTINYINT:
      return constval.tinyintval == NULL_TINYINT;
    case kINT:
      return constval.intval == NULL_INT;
    case kSMALLINT:
      return constval.smallintval == NULL_SMALLINT;
    case kBIGINT:
    case kNUMERIC:
    case kDECIMAL:
      return constval.bigintval == NULL_BIGINT;
    case kTIME:
    case kTIMESTAMP:
    case kDATE:
      return constval.bigintval == NULL_BIGINT;
    case kVARCHAR:
    case kCHAR:
    case kTEXT:
      return constval.stringval == nullptr;
    case kPOINT:
    case kLINESTRING:
    case kPOLYGON:
    case kMULTIPOLYGON:
      return constval.stringval == nullptr;
    case kFLOAT:
      return constval.floatval == NULL_FLOAT;
    case kDOUBLE:
      return constval.doubleval == NULL_DOUBLE;
    case kNULLT:
      return constval.bigintval == 0;
    case kARRAY:
      return constval.arrayval == nullptr;
    default:
      UNREACHABLE();
  }
  UNREACHABLE();
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename FLOAT_TYPE , typename INT_TYPE >

constexpr FLOAT_TYPE Analyzer::anonymous_namespace{Analyzer.cpp}::maxRound

(

)

Definition at line 749 of file Analyzer.cpp.

                                {
  static_assert(std::is_integral_v<INT_TYPE> && std::is_floating_point_v<FLOAT_TYPE>);
  constexpr int dd =
      std::numeric_limits<INT_TYPE>::digits - std::numeric_limits<FLOAT_TYPE>::digits;
  if constexpr (0 < dd) {  // NOLINT
    return static_cast<FLOAT_TYPE>(std::numeric_limits<INT_TYPE>::max() - (1ll << dd));
  } else {
    return static_cast<FLOAT_TYPE>(std::numeric_limits<INT_TYPE>::max());
  }
}

template<typename T >

T Analyzer::anonymous_namespace{Analyzer.cpp}::roundDecimal	(	int64_t	n,
		unsigned	scale
	)

Definition at line 772 of file Analyzer.cpp.

References anonymous_namespace{Utm.h}::n, and omnisci.dtypes::T.

                                          {
  static_assert(std::is_integral_v<T>);
  constexpr size_t max_scale = std::numeric_limits<uint64_t>::digits10;  // 19
  constexpr auto pow10 = shared::powersOf<uint64_t, max_scale + 1>(10);
  if (scale == 0) {
    if constexpr (sizeof(T) < sizeof(int64_t)) {  // NOLINT
      return safeNarrow<T>(n);
    } else {
      return n;
    }
  } else if (max_scale < scale) {
    return 0;  // 0.09223372036854775807 rounds to 0
  }
  uint64_t const u = std::abs(n);
  uint64_t const pow = pow10[scale];
  uint64_t div = u / pow;
  uint64_t rem = u % pow;
  div += pow / 2 <= rem;
  if constexpr (sizeof(T) < sizeof(int64_t)) {  // NOLINT
    return safeNarrow<T>(static_cast<int64_t>(n < 0 ? -div : div));
  } else {
    return n < 0 ? -div : div;
  }
}

template<typename TO , typename FROM >

TO Analyzer::anonymous_namespace{Analyzer.cpp}::safeNarrow

(

FROM const

from

)

Definition at line 761 of file Analyzer.cpp.

References FROM, and TO.

                               {
  static_assert(std::is_integral_v<TO> && std::is_integral_v<FROM>);
  static_assert(sizeof(TO) < sizeof(FROM));
  if (from < static_cast<FROM>(std::numeric_limits<TO>::min()) ||
      static_cast<FROM>(std::numeric_limits<TO>::max()) < from) {
    throw std::runtime_error("Overflow or underflow");
  }
  return static_cast<TO>(from);
}

template<typename TO , typename FROM >

TO Analyzer::anonymous_namespace{Analyzer.cpp}::safeRound

(

FROM const

from

)

Definition at line 798 of file Analyzer.cpp.

References FROM, anonymous_namespace{Utm.h}::n, and TO.

                              {
  static_assert(std::is_integral_v<TO> && std::is_floating_point_v<FROM>);
  constexpr FROM max_float = maxRound<FROM, TO>();
  FROM const n = std::round(from);
  if (n < static_cast<FROM>(std::numeric_limits<TO>::min()) || max_float < n) {
    throw std::runtime_error("Overflow or underflow");
  }
  return static_cast<TO>(n);
}

template<typename T >

int64_t Analyzer::anonymous_namespace{Analyzer.cpp}::safeScale	(	T	from,
		unsigned const	scale
	)

Definition at line 810 of file Analyzer.cpp.

Referenced by Analyzer::Constant::cast_number().

                                                {
  static_assert(std::is_arithmetic_v<T>);
  constexpr size_t max_scale = std::numeric_limits<int64_t>::digits10;  // 18
  constexpr auto pow10 = shared::powersOf<int64_t, max_scale + 1>(10);
  if constexpr (std::is_integral_v<T>) {  // NOLINT
    int64_t retval;
    if (scale < pow10.size()) {
#ifdef __linux__
      if (!__builtin_mul_overflow(from, pow10[scale], &retval)) {
        return retval;
      }
      // Not over flow safe.
#else
      return from * pow10[scale];
#endif
    }
  } else if constexpr (std::is_floating_point_v<T>) {
    if (scale < pow10.size()) {
      return safeRound<int64_t>(from * pow10[scale]);
    }
  }
  if (from == 0) {
    return 0;
  }
  throw std::runtime_error("Overflow or underflow");
}

Here is the caller graph for this function: