ddl_utils::anonymous_namespace{DdlUtils.cpp} Namespace Reference

Functions
void	validate_literal (const std::string &val, SQLTypeInfo column_type, const std::string &column_name)

Function Documentation

void ddl_utils::anonymous_namespace{DdlUtils.cpp}::validate_literal	(	const std::string &	val,
		SQLTypeInfo	column_type,
		const std::string &	column_name
	)

Definition at line 523 of file DdlUtils.cpp.

References CHECK, convert_decimal_value_to_scale(), Geospatial::GeoTypesFactory::createGeoType(), SQLTypeInfo::get_elem_type(), SQLTypeInfo::get_size(), SQLTypeInfo::get_type(), kARRAY, kBIGINT, kBOOLEAN, kCHAR, kDATE, kDECIMAL, kDOUBLE, kFLOAT, kINT, Geospatial::GeoBase::kLINESTRING, kLINESTRING, Geospatial::GeoBase::kMULTILINESTRING, kMULTILINESTRING, Geospatial::GeoBase::kMULTIPOINT, kMULTIPOINT, Geospatial::GeoBase::kMULTIPOLYGON, kMULTIPOLYGON, kNUMERIC, Geospatial::GeoBase::kPOINT, kPOINT, Geospatial::GeoBase::kPOLYGON, kPOLYGON, kSMALLINT, kTEXT, kTIME, kTIMESTAMP, kTINYINT, kVARCHAR, StringDictionary::MAX_STRLEN, split(), StringToDatum(), to_string(), to_upper(), DecimalOverflowValidator::validate(), and DateDaysOverflowValidator::validate().

Referenced by ddl_utils::validate_and_set_default_value().

                                                    {
  if (to_upper(val) == "NULL") {
    return;
  }
  switch (column_type.get_type()) {
    case kBOOLEAN:
    case kTINYINT:
    case kSMALLINT:
    case kINT:
    case kBIGINT:
    case kFLOAT:
    case kDOUBLE:
    case kTIME:
    case kTIMESTAMP:
      StringToDatum(val, column_type);
      break;
    case kDATE: {
      auto d = StringToDatum(val, column_type);
      DateDaysOverflowValidator validator(column_type);
      validator.validate(d.bigintval);
      break;
    }
    case kDECIMAL:
    case kNUMERIC: {
      SQLTypeInfo ti(kNUMERIC, 0, 0, false);
      auto d = StringToDatum(val, ti);
      auto converted_val = convert_decimal_value_to_scale(d.bigintval, ti, column_type);
      DecimalOverflowValidator validator(column_type);
      validator.validate(converted_val);
      break;
    }
    case kTEXT:
    case kVARCHAR:
    case kCHAR:
      if (val.length() > StringDictionary::MAX_STRLEN) {
        throw std::runtime_error("String too long for column " + column_name + " was " +
                                 std::to_string(val.length()) + " max is " +
                                 std::to_string(StringDictionary::MAX_STRLEN));
      }
      break;
    case kARRAY: {
      if (val.front() != '{' || val.back() != '}') {
        throw std::runtime_error(column_name +
                                 ": arrays should start and end with curly braces");
      }
      std::vector<std::string> elements = split(val.substr(1, val.length() - 2), ", ");
      if (column_type.get_size() > 0) {
        auto sti = column_type.get_elem_type();
        size_t expected_size = column_type.get_size() / sti.get_size();
        size_t actual_size = elements.size();
        if (actual_size != expected_size) {
          throw std::runtime_error("Fixed length array column " + column_name +
                                   " expects " + std::to_string(expected_size) +
                                   " values, received " + std::to_string(actual_size));
        }
      }
      SQLTypeInfo element_ti = column_type.get_elem_type();
      for (const auto& element : elements) {
        if (to_upper(element) != "NULL") {
          validate_literal(element, element_ti, column_name);
        }
      }
      break;
    }
    case kPOINT:
    case kMULTIPOINT:
    case kLINESTRING:
    case kMULTILINESTRING:
    case kPOLYGON:
    case kMULTIPOLYGON:
      if (val.empty()) {
        return;
      }
      try {
        auto geo = Geospatial::GeoTypesFactory::createGeoType(val);
        if (!geo) {
          throw std::runtime_error("Unexpected geo literal '" + val + "' for column " +
                                   column_name);
        }
        if (!geo->transform(column_type)) {
          throw std::runtime_error("Cannot transform SRID for literal '" + val +
                                   "' for column " + column_name);
        } else {
          auto sql_type = column_type.get_type();
          auto geo_type = geo->getType();
          if ((geo_type == Geospatial::GeoBase::GeoType::kPOINT && sql_type != kPOINT) ||
              (geo_type == Geospatial::GeoBase::GeoType::kMULTIPOINT &&
               sql_type != kMULTIPOINT) ||
              (geo_type == Geospatial::GeoBase::GeoType::kLINESTRING &&
               sql_type != kLINESTRING) ||
              (geo_type == Geospatial::GeoBase::GeoType::kMULTILINESTRING &&
               sql_type != kMULTILINESTRING) ||
              (geo_type == Geospatial::GeoBase::GeoType::kPOLYGON &&
               sql_type != kPOLYGON) ||
              (geo_type == Geospatial::GeoBase::GeoType::kMULTIPOLYGON &&
               sql_type != kMULTIPOLYGON)) {
            throw std::runtime_error("Geo literal '" + val +
                                     "' doesn't match the type "
                                     "of column column " +
                                     column_name);
          }
        }
      } catch (Geospatial::GeoTypesError& e) {
        throw std::runtime_error("Unexpected geo literal '" + val + "' for column " +
                                 column_name + ": " + e.what());
      }
      break;
    default:
      CHECK(false) << "validate_literal() does not support type "
                   << column_type.get_type();
  }
}

Here is the call graph for this function:

Here is the caller graph for this function: