anonymous_namespace{ExtensionFunctionsBinding.cpp} Namespace Reference

Functions
ExtArgumentType	get_column_arg_elem_type (const ExtArgumentType ext_arg_column_type)
ExtArgumentType	get_column_list_arg_elem_type (const ExtArgumentType ext_arg_column_list_type)
ExtArgumentType	get_array_arg_elem_type (const ExtArgumentType ext_arg_array_type)
static int	match_numeric_argument (const SQLTypeInfo &arg_type_info, const bool is_arg_literal, const ExtArgumentType &sig_ext_arg_type, int32_t &penalty_score)
static int	match_arguments (const SQLTypeInfo &arg_type, const bool is_arg_literal, int sig_pos, const std::vector< ExtArgumentType > &sig_types, int &penalty_score)
bool	is_valid_identifier (std::string str)

Function Documentation

ExtArgumentType anonymous_namespace{ExtensionFunctionsBinding.cpp}::get_array_arg_elem_type

(

const ExtArgumentType

ext_arg_array_type

)

Definition at line 147 of file ExtensionFunctionsBinding.cpp.

References ArrayBool, ArrayDouble, ArrayFloat, ArrayInt16, ArrayInt32, ArrayInt64, ArrayInt8, ArrayTextEncodingDict, ArrayTextEncodingNone, Bool, Double, Float, Int16, Int32, Int64, Int8, TextEncodingDict, TextEncodingNone, and UNREACHABLE.

Referenced by match_arguments().

                                                                                  {
  switch (ext_arg_array_type) {
    case ExtArgumentType::ArrayInt8:
      return ExtArgumentType::Int8;
    case ExtArgumentType::ArrayInt16:
      return ExtArgumentType::Int16;
    case ExtArgumentType::ArrayInt32:
      return ExtArgumentType::Int32;
    case ExtArgumentType::ArrayInt64:
      return ExtArgumentType::Int64;
    case ExtArgumentType::ArrayFloat:
      return ExtArgumentType::Float;
    case ExtArgumentType::ArrayDouble:
      return ExtArgumentType::Double;
    case ExtArgumentType::ArrayBool:
      return ExtArgumentType::Bool;
    case ExtArgumentType::ArrayTextEncodingDict:
      return ExtArgumentType::TextEncodingDict;
    case ExtArgumentType::ArrayTextEncodingNone:
      return ExtArgumentType::TextEncodingNone;
    default:
      UNREACHABLE();
  }
  return ExtArgumentType{};
}

Here is the caller graph for this function:

ExtArgumentType anonymous_namespace{ExtensionFunctionsBinding.cpp}::get_column_arg_elem_type

(

const ExtArgumentType

ext_arg_column_type

)

Definition at line 36 of file ExtensionFunctionsBinding.cpp.

References ArrayBool, ArrayDouble, ArrayFloat, ArrayInt16, ArrayInt32, ArrayInt64, ArrayInt8, ArrayTextEncodingDict, Bool, ColumnArrayBool, ColumnArrayDouble, ColumnArrayFloat, ColumnArrayInt16, ColumnArrayInt32, ColumnArrayInt64, ColumnArrayInt8, ColumnArrayTextEncodingDict, ColumnBool, ColumnDouble, ColumnFloat, ColumnGeoLineString, ColumnGeoMultiLineString, ColumnGeoMultiPoint, ColumnGeoMultiPolygon, ColumnGeoPoint, ColumnGeoPolygon, ColumnInt16, ColumnInt32, ColumnInt64, ColumnInt8, ColumnTextEncodingDict, ColumnTextEncodingNone, ColumnTimestamp, Double, Float, GeoLineString, GeoMultiLineString, GeoMultiPoint, GeoMultiPolygon, GeoPoint, GeoPolygon, Int16, Int32, Int64, Int8, TextEncodingDict, TextEncodingNone, Timestamp, and UNREACHABLE.

Referenced by match_arguments().

                                                                                    {
  switch (ext_arg_column_type) {
    case ExtArgumentType::ColumnInt8:
      return ExtArgumentType::Int8;
    case ExtArgumentType::ColumnInt16:
      return ExtArgumentType::Int16;
    case ExtArgumentType::ColumnInt32:
      return ExtArgumentType::Int32;
    case ExtArgumentType::ColumnInt64:
      return ExtArgumentType::Int64;
    case ExtArgumentType::ColumnFloat:
      return ExtArgumentType::Float;
    case ExtArgumentType::ColumnDouble:
      return ExtArgumentType::Double;
    case ExtArgumentType::ColumnBool:
      return ExtArgumentType::Bool;
    case ExtArgumentType::ColumnTextEncodingDict:
      return ExtArgumentType::TextEncodingDict;
    case ExtArgumentType::ColumnTimestamp:
      return ExtArgumentType::Timestamp;
    case ExtArgumentType::ColumnArrayInt8:
      return ExtArgumentType::ArrayInt8;
    case ExtArgumentType::ColumnArrayInt16:
      return ExtArgumentType::ArrayInt16;
    case ExtArgumentType::ColumnArrayInt32:
      return ExtArgumentType::ArrayInt32;
    case ExtArgumentType::ColumnArrayInt64:
      return ExtArgumentType::ArrayInt64;
    case ExtArgumentType::ColumnArrayFloat:
      return ExtArgumentType::ArrayFloat;
    case ExtArgumentType::ColumnArrayDouble:
      return ExtArgumentType::ArrayDouble;
    case ExtArgumentType::ColumnArrayBool:
      return ExtArgumentType::ArrayBool;
    case ExtArgumentType::ColumnArrayTextEncodingDict:
      return ExtArgumentType::ArrayTextEncodingDict;
    case ExtArgumentType::ColumnGeoPoint:
      return ExtArgumentType::GeoPoint;
    case ExtArgumentType::ColumnGeoLineString:
      return ExtArgumentType::GeoLineString;
    case ExtArgumentType::ColumnGeoPolygon:
      return ExtArgumentType::GeoPolygon;
    case ExtArgumentType::ColumnGeoMultiPoint:
      return ExtArgumentType::GeoMultiPoint;
    case ExtArgumentType::ColumnGeoMultiLineString:
      return ExtArgumentType::GeoMultiLineString;
    case ExtArgumentType::ColumnGeoMultiPolygon:
      return ExtArgumentType::GeoMultiPolygon;
    case ExtArgumentType::ColumnTextEncodingNone:
      return ExtArgumentType::TextEncodingNone;
    default:
      UNREACHABLE();
  }
  return ExtArgumentType{};
}

Here is the caller graph for this function:

ExtArgumentType anonymous_namespace{ExtensionFunctionsBinding.cpp}::get_column_list_arg_elem_type

(

const ExtArgumentType

ext_arg_column_list_type

)

Definition at line 92 of file ExtensionFunctionsBinding.cpp.

References ArrayBool, ArrayDouble, ArrayFloat, ArrayInt16, ArrayInt32, ArrayInt64, ArrayInt8, ArrayTextEncodingDict, Bool, ColumnListArrayBool, ColumnListArrayDouble, ColumnListArrayFloat, ColumnListArrayInt16, ColumnListArrayInt32, ColumnListArrayInt64, ColumnListArrayInt8, ColumnListArrayTextEncodingDict, ColumnListBool, ColumnListDouble, ColumnListFloat, ColumnListGeoLineString, ColumnListGeoMultiLineString, ColumnListGeoMultiPoint, ColumnListGeoMultiPolygon, ColumnListGeoPoint, ColumnListGeoPolygon, ColumnListInt16, ColumnListInt32, ColumnListInt64, ColumnListInt8, ColumnListTextEncodingDict, ColumnListTextEncodingNone, Double, Float, GeoLineString, GeoMultiLineString, GeoMultiPoint, GeoMultiPolygon, GeoPoint, GeoPolygon, Int16, Int32, Int64, Int8, TextEncodingDict, TextEncodingNone, and UNREACHABLE.

Referenced by match_arguments().

                                                    {
  switch (ext_arg_column_list_type) {
    case ExtArgumentType::ColumnListInt8:
      return ExtArgumentType::Int8;
    case ExtArgumentType::ColumnListInt16:
      return ExtArgumentType::Int16;
    case ExtArgumentType::ColumnListInt32:
      return ExtArgumentType::Int32;
    case ExtArgumentType::ColumnListInt64:
      return ExtArgumentType::Int64;
    case ExtArgumentType::ColumnListFloat:
      return ExtArgumentType::Float;
    case ExtArgumentType::ColumnListDouble:
      return ExtArgumentType::Double;
    case ExtArgumentType::ColumnListBool:
      return ExtArgumentType::Bool;
    case ExtArgumentType::ColumnListTextEncodingDict:
      return ExtArgumentType::TextEncodingDict;
    case ExtArgumentType::ColumnListArrayInt8:
      return ExtArgumentType::ArrayInt8;
    case ExtArgumentType::ColumnListArrayInt16:
      return ExtArgumentType::ArrayInt16;
    case ExtArgumentType::ColumnListArrayInt32:
      return ExtArgumentType::ArrayInt32;
    case ExtArgumentType::ColumnListArrayInt64:
      return ExtArgumentType::ArrayInt64;
    case ExtArgumentType::ColumnListArrayFloat:
      return ExtArgumentType::ArrayFloat;
    case ExtArgumentType::ColumnListArrayDouble:
      return ExtArgumentType::ArrayDouble;
    case ExtArgumentType::ColumnListArrayBool:
      return ExtArgumentType::ArrayBool;
    case ExtArgumentType::ColumnListArrayTextEncodingDict:
      return ExtArgumentType::ArrayTextEncodingDict;
    case ExtArgumentType::ColumnListGeoPoint:
      return ExtArgumentType::GeoPoint;
    case ExtArgumentType::ColumnListGeoLineString:
      return ExtArgumentType::GeoLineString;
    case ExtArgumentType::ColumnListGeoPolygon:
      return ExtArgumentType::GeoPolygon;
    case ExtArgumentType::ColumnListGeoMultiPoint:
      return ExtArgumentType::GeoMultiPoint;
    case ExtArgumentType::ColumnListGeoMultiLineString:
      return ExtArgumentType::GeoMultiLineString;
    case ExtArgumentType::ColumnListGeoMultiPolygon:
      return ExtArgumentType::GeoMultiPolygon;
    case ExtArgumentType::ColumnListTextEncodingNone:
      return ExtArgumentType::TextEncodingNone;
    default:
      UNREACHABLE();
  }
  return ExtArgumentType{};
}

Here is the caller graph for this function:

bool anonymous_namespace{ExtensionFunctionsBinding.cpp}::is_valid_identifier

(

std::string

str

)

Definition at line 527 of file ExtensionFunctionsBinding.cpp.

Referenced by bind_function().

                                        {
  if (!str.size()) {
    return false;
  }

  if (!(std::isalpha(str[0]) || str[0] == '_')) {
    return false;
  }

  for (size_t i = 1; i < str.size(); i++) {
    if (!(std::isalnum(str[i]) || str[i] == '_')) {
      return false;
    }
  }

  return true;
}

Here is the caller graph for this function:

static int anonymous_namespace{ExtensionFunctionsBinding.cpp}::match_arguments ( const SQLTypeInfo &  arg_type, const bool  is_arg_literal, int  sig_pos, const std::vector< ExtArgumentType > &  sig_types, int &  penalty_score  )

static

Definition at line 265 of file ExtensionFunctionsBinding.cpp.

References CHECK, DayTimeInterval, ext_arg_type_to_type_info(), GeoLineString, GeoMultiLineString, GeoMultiPoint, GeoMultiPolygon, GeoPoint, GeoPolygon, get_array_arg_elem_type(), get_column_arg_elem_type(), get_column_list_arg_elem_type(), SQLTypeInfo::get_compression(), SQLTypeInfo::get_elem_type(), SQLTypeInfo::get_type(), SQLTypeInfo::get_type_name(), Int64, SQLTypeInfo::is_array(), is_ext_arg_type_array(), is_ext_arg_type_column(), is_ext_arg_type_column_list(), kARRAY, kBIGINT, kBOOLEAN, kCOLUMN, kCOLUMN_LIST, kDECIMAL, kDOUBLE, kENCODING_DICT, kENCODING_NONE, kFLOAT, kINT, kINTERVAL_DAY_TIME, kINTERVAL_YEAR_MONTH, kLINESTRING, kMULTILINESTRING, kMULTIPOINT, kMULTIPOLYGON, kNULLT, kNUMERIC, kPOINT, kPOLYGON, kSMALLINT, kTEXT, kTIMESTAMP, kTINYINT, kVARCHAR, match_numeric_argument(), PBool, PDouble, PFloat, PInt16, PInt32, PInt64, PInt8, TextEncodingDict, TextEncodingNone, Timestamp, to_string(), ExtensionFunctionsWhitelist::toString(), UNREACHABLE, and YearMonthTimeInterval.

Referenced by bind_function().

                                               {
  /*
    Returns non-negative integer `offset` if `arg_type` and
    `sig_types[sig_pos:sig_pos + offset]` match.

    The `offset` value can be interpreted as the number of extension
    function arguments that is consumed by the given `arg_type`. For
    instance, for scalar types the offset is always 1, for array
    types the offset is 2: one argument for array pointer value and
    one argument for the array size value, etc.

    Returns -1 when the types of an argument and the corresponding
    extension function argument(s) mismatch, or when downcasting would
    be effective.

    In case of non-negative `offset` result, the function updates
    penalty_score argument as follows:

      add 1000 if arg_type is non-scalar, otherwise:
      add 1000 * sizeof(sig_type) / sizeof(arg_type)
      add 1000000 if type kinds differ (integer vs double, for instance)

   */
  int max_pos = sig_types.size() - 1;
  if (sig_pos > max_pos) {
    return -1;
  }
  auto sig_type = sig_types[sig_pos];
  switch (arg_type.get_type()) {
    case kBOOLEAN:
    case kTINYINT:
    case kSMALLINT:
    case kINT:
    case kBIGINT:
    case kFLOAT:
    case kDOUBLE:
    case kDECIMAL:
    case kNUMERIC:
      return match_numeric_argument(arg_type, is_arg_literal, sig_type, penalty_score);
    case kPOINT:
    case kMULTIPOINT:
    case kLINESTRING:
      if ((sig_type == ExtArgumentType::PInt8 || sig_type == ExtArgumentType::PInt16 ||
           sig_type == ExtArgumentType::PInt32 || sig_type == ExtArgumentType::PInt64 ||
           sig_type == ExtArgumentType::PFloat || sig_type == ExtArgumentType::PDouble) &&
          sig_pos < max_pos && sig_types[sig_pos + 1] == ExtArgumentType::Int64) {
        penalty_score += 1000;
        return 2;
      } else if ((sig_type == ExtArgumentType::GeoPoint &&
                  arg_type.get_type() == kPOINT) ||
                 (sig_type == ExtArgumentType::GeoMultiPoint &&
                  arg_type.get_type() == kMULTIPOINT) ||
                 (sig_type == ExtArgumentType::GeoLineString &&
                  arg_type.get_type() == kLINESTRING)) {
        penalty_score += 1000;
        return 1;
      }
      return -1;
    case kMULTILINESTRING:
      if (sig_type == ExtArgumentType::PInt8 && sig_pos + 3 < max_pos &&
          sig_types[sig_pos + 1] == ExtArgumentType::Int64 &&
          sig_types[sig_pos + 2] == ExtArgumentType::PInt8 &&
          sig_types[sig_pos + 3] == ExtArgumentType::Int64) {
        penalty_score += 1000;
        return 4;
      } else if (sig_type == ExtArgumentType::GeoMultiLineString) {
        penalty_score += 1000;
        return 1;
      }
      break;
    case kARRAY:
      if ((sig_type == ExtArgumentType::PInt8 || sig_type == ExtArgumentType::PInt16 ||
           sig_type == ExtArgumentType::PInt32 || sig_type == ExtArgumentType::PInt64 ||
           sig_type == ExtArgumentType::PFloat || sig_type == ExtArgumentType::PDouble ||
           sig_type == ExtArgumentType::PBool) &&
          sig_pos < max_pos && sig_types[sig_pos + 1] == ExtArgumentType::Int64) {
        penalty_score += 1000;
        return 2;
      } else if (is_ext_arg_type_array(sig_type)) {
        // array arguments must match exactly
        CHECK(arg_type.is_array());
        const auto sig_type_ti =
            ext_arg_type_to_type_info(get_array_arg_elem_type(sig_type));
        if (arg_type.get_elem_type().get_type() == kBOOLEAN &&
            sig_type_ti.get_type() == kTINYINT) {
          /* Boolean array has the same low-level structure as Int8 array. */
          penalty_score += 1000;
          return 1;
        } else if (arg_type.get_elem_type().get_type() == sig_type_ti.get_type()) {
          penalty_score += 1000;
          return 1;
        } else {
          return -1;
        }
      }
      break;
    case kPOLYGON:
      if (sig_type == ExtArgumentType::PInt8 && sig_pos + 3 < max_pos &&
          sig_types[sig_pos + 1] == ExtArgumentType::Int64 &&
          sig_types[sig_pos + 2] == ExtArgumentType::PInt32 &&
          sig_types[sig_pos + 3] == ExtArgumentType::Int64) {
        penalty_score += 1000;
        return 4;
      } else if (sig_type == ExtArgumentType::GeoPolygon) {
        penalty_score += 1000;
        return 1;
      }
      break;
    case kMULTIPOLYGON:
      if (sig_type == ExtArgumentType::PInt8 && sig_pos + 5 < max_pos &&
          sig_types[sig_pos + 1] == ExtArgumentType::Int64 &&
          sig_types[sig_pos + 2] == ExtArgumentType::PInt32 &&
          sig_types[sig_pos + 3] == ExtArgumentType::Int64 &&
          sig_types[sig_pos + 4] == ExtArgumentType::PInt32 &&
          sig_types[sig_pos + 5] == ExtArgumentType::Int64) {
        penalty_score += 1000;
        return 6;
      } else if (sig_type == ExtArgumentType::GeoMultiPolygon) {
        penalty_score += 1000;
        return 1;
      }
      break;
    case kNULLT:  // NULL maps to a pointer and size argument
      if ((sig_type == ExtArgumentType::PInt8 || sig_type == ExtArgumentType::PInt16 ||
           sig_type == ExtArgumentType::PInt32 || sig_type == ExtArgumentType::PInt64 ||
           sig_type == ExtArgumentType::PFloat || sig_type == ExtArgumentType::PDouble ||
           sig_type == ExtArgumentType::PBool) &&
          sig_pos < max_pos && sig_types[sig_pos + 1] == ExtArgumentType::Int64) {
        penalty_score += 1000;
        return 2;
      }
      break;
    case kCOLUMN:
      if (is_ext_arg_type_column(sig_type)) {
        // column arguments must match exactly
        const auto sig_type_ti =
            ext_arg_type_to_type_info(get_column_arg_elem_type(sig_type));
        if (arg_type.get_elem_type().get_type() == kARRAY &&
            sig_type_ti.get_type() == kARRAY) {
          if (arg_type.get_elem_type().get_elem_type().get_type() ==
              sig_type_ti.get_elem_type().get_type()) {
            penalty_score += 1000;
            return 1;
          } else {
            return -1;
          }
        } else if (arg_type.get_elem_type().get_type() == kBOOLEAN &&
                   sig_type_ti.get_type() == kTINYINT) {
          /* Boolean column has the same low-level structure as Int8 column. */
          penalty_score += 1000;
          return 1;
        } else if (arg_type.get_elem_type().get_type() == sig_type_ti.get_type()) {
          penalty_score += 1000;
          return 1;
        } else {
          return -1;
        }
      }
      break;
    case kCOLUMN_LIST:
      if (is_ext_arg_type_column_list(sig_type)) {
        // column_list arguments must match exactly
        const auto sig_type_ti =
            ext_arg_type_to_type_info(get_column_list_arg_elem_type(sig_type));
        if (arg_type.get_elem_type().get_type() == kARRAY &&
            sig_type_ti.get_type() == kARRAY) {
          if (arg_type.get_elem_type().get_elem_type().get_type() ==
              sig_type_ti.get_elem_type().get_type()) {
            penalty_score += 1000;
            return 1;
          } else {
            return -1;
          }
        } else if (arg_type.get_elem_type().get_type() == kBOOLEAN &&
                   sig_type_ti.get_type() == kTINYINT) {
          /* Boolean column_list has the same low-level structure as Int8 column_list. */
          penalty_score += 10000;
          return 1;
        } else if (arg_type.get_elem_type().get_type() == sig_type_ti.get_type()) {
          penalty_score += 10000;
          return 1;
        } else {
          return -1;
        }
      }
      break;
    case kVARCHAR:
      if (sig_type != ExtArgumentType::TextEncodingNone) {
        return -1;
      }
      switch (arg_type.get_compression()) {
        case kENCODING_NONE:
          penalty_score += 1000;
          return 1;
        case kENCODING_DICT:
          return -1;
          // Todo (todd): Evaluate when and where we can tranlate to dictionary-encoded
        default:
          UNREACHABLE();
      }
    case kTEXT:
      switch (arg_type.get_compression()) {
        case kENCODING_NONE:
          if (sig_type == ExtArgumentType::TextEncodingNone) {
            penalty_score += 1000;
            return 1;
          }
          return -1;
        case kENCODING_DICT:
          if (sig_type == ExtArgumentType::TextEncodingDict) {
            penalty_score += 1000;
            return 1;
          }
          return -1;
        default:
          UNREACHABLE();
      }
    case kTIMESTAMP:
      if (sig_type == ExtArgumentType::Timestamp) {
        penalty_score += 1000;
        return 1;
      }
      break;
    case kINTERVAL_DAY_TIME:
      if (sig_type == ExtArgumentType::DayTimeInterval) {
        penalty_score += 1000;
        return 1;
      }
      break;

    case kINTERVAL_YEAR_MONTH:
      if (sig_type == ExtArgumentType::YearMonthTimeInterval) {
        penalty_score += 1000;
        return 1;
      }
      break;

      /* Not implemented types:
         kCHAR
         kTIME
         kDATE
         kGEOMETRY
         kGEOGRAPHY
         kEVAL_CONTEXT_TYPE
         kVOID
         kCURSOR
      */
    default:
      throw std::runtime_error(std::string(__FILE__) + "#" + std::to_string(__LINE__) +
                               ": support for " + arg_type.get_type_name() +
                               "(type=" + std::to_string(arg_type.get_type()) + ")" +
                               +" not implemented: \n  pos=" + std::to_string(sig_pos) +
                               " max_pos=" + std::to_string(max_pos) + "\n  sig_types=(" +
                               ExtensionFunctionsWhitelist::toString(sig_types) + ")");
  }
  return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int anonymous_namespace{ExtensionFunctionsBinding.cpp}::match_numeric_argument ( const SQLTypeInfo &  arg_type_info, const bool  is_arg_literal, const ExtArgumentType &  sig_ext_arg_type, int32_t &  penalty_score  )

static

Definition at line 173 of file ExtensionFunctionsBinding.cpp.

References CHECK, CHECK_GE, CHECK_GT, CHECK_LE, ext_arg_type_to_type_info(), SQLTypeInfo::get_numeric_scalar_scale(), SQLTypeInfo::get_type(), SQLTypeInfo::is_numeric_scalar_auto_castable(), kBIGINT, kBOOLEAN, kDECIMAL, kDOUBLE, kFLOAT, kINT, kNUMERIC, kSMALLINT, and kTINYINT.

Referenced by match_arguments().

                                                          {
  const auto arg_type = arg_type_info.get_type();
  CHECK(arg_type == kBOOLEAN || arg_type == kTINYINT || arg_type == kSMALLINT ||
        arg_type == kINT || arg_type == kBIGINT || arg_type == kFLOAT ||
        arg_type == kDOUBLE || arg_type == kDECIMAL || arg_type == kNUMERIC);
  // Todo (todd): Add support for timestamp, date, and time types
  const auto sig_type_info = ext_arg_type_to_type_info(sig_ext_arg_type);
  const auto sig_type = sig_type_info.get_type();

  // If we can't legally auto-cast to sig_type, abort
  if (!arg_type_info.is_numeric_scalar_auto_castable(sig_type_info)) {
    return -1;
  }

  // We now compare a measure of the scale of the sig_type with the
  // arg_type, which provides a basis for scoring the match between
  // the two.  Note that get_numeric_scalar_scale for the most part
  // returns the logical byte width of the type, with a few caveats
  // for decimals and timestamps described in more depth in comments
  // in the function itself.  Also even though for example float and
  // int types return 4 (as in 4 bytes), and double and bigint types
  // return 8, a fp32 type cannot express every 32-bit integer (even
  // if it can cover a larger absolute range), and an fp64 type
  // likewise cannot express every 64-bit integer.  With the aim to
  // minimize the precision loss from casting (always precise) integer
  // value to (imprecise) floating point value, in the case of integer
  // inputs, we'll penalize wider floating point argument types least
  // by a specific scale transformation (see the implementation
  // below). For instance, casting tinyint to fp64 is prefered over
  // casting it to fp32 to minimize precision loss.
  const bool is_integer_to_fp_cast = (arg_type == kTINYINT || arg_type == kSMALLINT ||
                                      arg_type == kINT || arg_type == kBIGINT) &&
                                     (sig_type == kFLOAT || sig_type == kDOUBLE);

  const auto arg_type_relative_scale = arg_type_info.get_numeric_scalar_scale();
  CHECK_GE(arg_type_relative_scale, 1);
  CHECK_LE(arg_type_relative_scale, 8);
  auto sig_type_relative_scale = sig_type_info.get_numeric_scalar_scale();
  CHECK_GE(sig_type_relative_scale, 1);
  CHECK_LE(sig_type_relative_scale, 8);

  if (is_integer_to_fp_cast) {
    // transform fp scale: 4 becomes 16, 8 remains 8
    sig_type_relative_scale = (3 - (sig_type_relative_scale >> 2)) << 3;
  }

  // We do not allow auto-casting to types with less scale/precision
  // within the same type family.
  CHECK_GE(sig_type_relative_scale, arg_type_relative_scale);

  // Calculate the ratio of the sig_type by the arg_type, per the above check will be >= 1
  const auto sig_type_scale_gain_ratio =
      sig_type_relative_scale / arg_type_relative_scale;
  CHECK_GE(sig_type_scale_gain_ratio, 1);

  // Following the old bespoke scoring logic this function replaces, we heavily penalize
  // any casts that move ints to floats/doubles for the precision-loss reasons above
  // Arguably all integers in the tinyint and smallint can be fully specified with both
  // float and double types, but we treat them the same as int and bigint types here.
  const int32_t type_family_cast_penalty_score = is_integer_to_fp_cast ? 1001000 : 1000;

  int32_t scale_cast_penalty_score;

  // The following logic is new. Basically there are strong reasons to
  // prefer the promotion of constant literals to the most precise type possible, as
  // rather than the type being inherent in the data - that is a column or columns where
  // a user specified a type (and with any expressions on those columns following our
  // standard sql casting logic), literal types are given to us by Calcite and do not
  // necessarily convey any semantic intent (i.e. 10 will be an int, but 10.0 a decimal)
  // Hence it is better to promote these types to the most precise sig_type available,
  // while at the same time keeping column expressions as close as possible to the input
  // types (mainly for performance, we have many float versions of various functions
  // to allow for greater performance when the underlying data is not of double precision,
  // and hence there is little benefit of the extra cost of computing double precision
  // operators on this data)
  if (is_arg_literal) {
    scale_cast_penalty_score =
        (8000 / arg_type_relative_scale) - (1000 * sig_type_scale_gain_ratio);
  } else {
    scale_cast_penalty_score = (1000 * sig_type_scale_gain_ratio);
  }

  const auto cast_penalty_score =
      type_family_cast_penalty_score + scale_cast_penalty_score;
  CHECK_GT(cast_penalty_score, 0);
  penalty_score += cast_penalty_score;
  return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function: