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_arguments (const SQLTypeInfo &arg_type, 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 81 of file ExtensionFunctionsBinding.cpp.

References ArrayBool, ArrayDouble, ArrayFloat, ArrayInt16, ArrayInt32, ArrayInt64, ArrayInt8, Bool, Double, Float, Int16, Int32, Int64, Int8, 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;
    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 Bool, ColumnBool, ColumnDouble, ColumnFloat, ColumnInt16, ColumnInt32, ColumnInt64, ColumnInt8, Double, Float, Int16, Int32, Int64, Int8, 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;
    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 58 of file ExtensionFunctionsBinding.cpp.

References Bool, ColumnListBool, ColumnListDouble, ColumnListFloat, ColumnListInt16, ColumnListInt32, ColumnListInt64, ColumnListInt8, Double, Float, Int16, Int32, Int64, Int8, 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;
    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 387 of file ExtensionFunctionsBinding.cpp.

References i.

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, int  sig_pos, const std::vector< ExtArgumentType > &  sig_types, int &  penalty_score  )

static

Definition at line 103 of file ExtensionFunctionsBinding.cpp.

References Bool, CHECK, Double, ext_arg_type_to_type_info(), Float, GeoLineString, 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_logical_size(), SQLTypeInfo::get_type(), SQLTypeInfo::get_type_name(), Int16, Int32, Int64, Int8, 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, kLINESTRING, kMULTIPOLYGON, kNULLT, kNUMERIC, kPOINT, kPOLYGON, kSMALLINT, kTEXT, kTINYINT, PBool, PDouble, PFloat, PInt16, PInt32, PInt64, PInt8, TextEncodingDict32, TextEncodingNone, to_string(), and ExtensionFunctionsWhitelist::toString().

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 stype = sig_types[sig_pos];
  switch (arg_type.get_type()) {
    case kBOOLEAN:
      if (stype == ExtArgumentType::Bool) {
        penalty_score += 1000;
        return 1;
      }
      break;
    case kTINYINT:
      switch (stype) {
        case ExtArgumentType::Int8:
          penalty_score += 1000;
          break;
        case ExtArgumentType::Int16:
          penalty_score += 2000;
          break;
        case ExtArgumentType::Int32:
          penalty_score += 4000;
          break;
        case ExtArgumentType::Int64:
          penalty_score += 8000;
          break;
        case ExtArgumentType::Double:
          penalty_score += 1008000;
          break;  // temporary: allow integers as double arguments
        default:
          return -1;
      }
      return 1;
    case kSMALLINT:
      switch (stype) {
        case ExtArgumentType::Int16:
          penalty_score += 1000;
          break;
        case ExtArgumentType::Int32:
          penalty_score += 2000;
          break;
        case ExtArgumentType::Int64:
          penalty_score += 4000;
          break;
        case ExtArgumentType::Double:
          penalty_score += 1004000;
          break;  // temporary: allow integers as double arguments
        default:
          return -1;
      }
      return 1;
    case kINT:
      switch (stype) {
        case ExtArgumentType::Int32:
          penalty_score += 1000;
          break;
        case ExtArgumentType::Int64:
          penalty_score += 2000;
          break;
        case ExtArgumentType::Double:
          penalty_score += 1002000;
          break;  // temporary: allow integers as double arguments
        default:
          return -1;
      }
      return 1;
    case kBIGINT:
      switch (stype) {
        case ExtArgumentType::Int64:
          penalty_score += 1000;
          break;
        case ExtArgumentType::Double:
          penalty_score += 1001000;
          break;  // temporary: allow integers as double arguments
        default:
          return -1;
      }
      return 1;
    case kFLOAT:
      switch (stype) {
        case ExtArgumentType::Float:
          penalty_score += 1000;
          break;
        case ExtArgumentType::Double:
          penalty_score += 2000;
          break;  // is it ok to use floats as double arguments?
        default:
          return -1;
      }
      return 1;
    case kDOUBLE:
      if (stype == ExtArgumentType::Double) {
        penalty_score += 1000;
        return 1;
      }
      break;

    case kPOINT:
    case kLINESTRING:
      if ((stype == ExtArgumentType::PInt8 || stype == ExtArgumentType::PInt16 ||
           stype == ExtArgumentType::PInt32 || stype == ExtArgumentType::PInt64 ||
           stype == ExtArgumentType::PFloat || stype == ExtArgumentType::PDouble) &&
          sig_pos < max_pos && sig_types[sig_pos + 1] == ExtArgumentType::Int64) {
        penalty_score += 1000;
        return 2;
      } else if (stype == ExtArgumentType::GeoPoint ||
                 stype == ExtArgumentType::GeoLineString) {
        penalty_score += 1000;
        return 1;
      }
      break;
    case kARRAY:
      if ((stype == ExtArgumentType::PInt8 || stype == ExtArgumentType::PInt16 ||
           stype == ExtArgumentType::PInt32 || stype == ExtArgumentType::PInt64 ||
           stype == ExtArgumentType::PFloat || stype == ExtArgumentType::PDouble ||
           stype == 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(stype)) {
        // array arguments must match exactly
        CHECK(arg_type.is_array());
        const auto stype_ti = ext_arg_type_to_type_info(get_array_arg_elem_type(stype));
        if (arg_type.get_elem_type() == kBOOLEAN && stype_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() == stype_ti.get_type()) {
          penalty_score += 1000;
          return 1;
        } else {
          return -1;
        }
      }
      break;
    case kPOLYGON:
      if (stype == 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 (stype == ExtArgumentType::GeoPolygon) {
        penalty_score += 1000;
        return 1;
      }

      break;

    case kMULTIPOLYGON:
      if (stype == 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 (stype == ExtArgumentType::GeoMultiPolygon) {
        penalty_score += 1000;
        return 1;
      }
      break;
    case kDECIMAL:
    case kNUMERIC:
      if (stype == ExtArgumentType::Double && arg_type.get_logical_size() == 8) {
        penalty_score += 1000;
        return 1;
      }
      if (stype == ExtArgumentType::Float && arg_type.get_logical_size() == 4) {
        penalty_score += 1000;
        return 1;
      }
      break;
    case kNULLT:  // NULL maps to a pointer and size argument
      if ((stype == ExtArgumentType::PInt8 || stype == ExtArgumentType::PInt16 ||
           stype == ExtArgumentType::PInt32 || stype == ExtArgumentType::PInt64 ||
           stype == ExtArgumentType::PFloat || stype == ExtArgumentType::PDouble ||
           stype == 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(stype)) {
        // column arguments must match exactly
        const auto stype_ti = ext_arg_type_to_type_info(get_column_arg_elem_type(stype));
        if (arg_type.get_elem_type() == kBOOLEAN && stype_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() == stype_ti.get_type()) {
          penalty_score += 1000;
          return 1;
        } else {
          return -1;
        }
      }
      break;
    case kCOLUMN_LIST:
      if (is_ext_arg_type_column_list(stype)) {
        // column_list arguments must match exactly
        const auto stype_ti =
            ext_arg_type_to_type_info(get_column_list_arg_elem_type(stype));
        if (arg_type.get_elem_type() == kBOOLEAN && stype_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() == stype_ti.get_type()) {
          penalty_score += 10000;
          return 1;
        } else {
          return -1;
        }
      }
      break;
    case kTEXT:
      switch (arg_type.get_compression()) {
        case kENCODING_NONE:
          if (stype == ExtArgumentType::TextEncodingNone) {
            penalty_score += 1000;
            return 1;
          }
          return -1;
        case kENCODING_DICT:
          if (stype == ExtArgumentType::TextEncodingDict32) {
            penalty_score += 1000;
            return 1;
          }
        default:;
          // todo: dict(8) and dict(16) encodings
      }
      /* Not implemented types:
         kCHAR
         kVARCHAR
         kTIME
         kTIMESTAMP
         kDATE
         kINTERVAL_DAY_TIME
         kINTERVAL_YEAR_MONTH
         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: