Misiu/os advance may10

Analyzer/Analyzer.cpp

@@ -3107,24 +3107,27 @@ std::string OffsetInFragment::toString() const {
 }
 
 std::string WindowFrame::toString() const {
+  std::ostringstream oss;
   auto bound_str = bound_expr_ ? bound_expr_->toString() : "None";
-  return ::toString(bound_type_) + " " + bound_str;
+  oss << bound_type_ << " " << bound_str;
+  return oss.str();
 }
 
 std::string WindowFunction::toString() const {
-  std::string result = "WindowFunction(" + ::toString(kind_);
+  std::ostringstream oss;
+  oss << "WindowFunction(" << kind_;
   for (const auto& arg : args_) {
-    result += " " + arg->toString();
+    oss << " " << arg->toString();
   }
   if (hasFraming()) {
-    result += " Frame{";
+    oss << " Frame{";
     switch (frame_bound_type_) {
       case FrameBoundType::ROW: {
-        result += "ROW";
+        oss << "ROW";
         break;
       }
       case FrameBoundType::RANGE: {
-        result += "RANGE";
+        oss << "RANGE";
         break;
       }
       default: {
@@ -3133,17 +3136,17 @@ std::string WindowFunction::toString() const {
         break;
       }
     }
-    result += " BETWEEN : " + frame_start_bound_->toString();
-    result += " AND : " + frame_end_bound_->toString();
+    oss << " BETWEEN : " + frame_start_bound_->toString();
+    oss << " AND : " + frame_end_bound_->toString();
   } else {
     if (!order_keys_.empty()) {
-      result += " (RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)";
+      oss << " (RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)";
     } else {
-      result += " (RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)";
+      oss << " (RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)";
     }
   }
-  result += "} ";
-  return result + ") ";
+  oss << "} )";
+  return oss.str();
 }
 
 std::string ArrayExpr::toString() const {
@@ -3763,6 +3766,11 @@ std::shared_ptr<Analyzer::Expr> RegexpSubstrStringOper::deep_copy() const {
       std::dynamic_pointer_cast<Analyzer::StringOper>(StringOper::deep_copy()));
 }
 
+std::shared_ptr<Analyzer::Expr> RegexpCountStringOper::deep_copy() const {
+  return makeExpr<Analyzer::RegexpCountStringOper>(
+      std::dynamic_pointer_cast<Analyzer::StringOper>(StringOper::deep_copy()));
+}
+
 std::shared_ptr<Analyzer::Expr> JsonValueStringOper::deep_copy() const {
   return makeExpr<Analyzer::JsonValueStringOper>(
       std::dynamic_pointer_cast<Analyzer::StringOper>(StringOper::deep_copy()));
@@ -3778,6 +3786,16 @@ std::shared_ptr<Analyzer::Expr> Base64DecodeStringOper::deep_copy() const {
       std::dynamic_pointer_cast<Analyzer::StringOper>(StringOper::deep_copy()));
 }
 
+std::shared_ptr<Analyzer::Expr> UrlEncodeStringOper::deep_copy() const {
+  return makeExpr<Analyzer::UrlEncodeStringOper>(
+      std::dynamic_pointer_cast<Analyzer::StringOper>(StringOper::deep_copy()));
+}
+
+std::shared_ptr<Analyzer::Expr> UrlDecodeStringOper::deep_copy() const {
+  return makeExpr<Analyzer::UrlDecodeStringOper>(
+      std::dynamic_pointer_cast<Analyzer::StringOper>(StringOper::deep_copy()));
+}
+
 std::shared_ptr<Analyzer::Expr> TryStringCastOper::deep_copy() const {
   return makeExpr<Analyzer::TryStringCastOper>(
       std::dynamic_pointer_cast<Analyzer::StringOper>(StringOper::deep_copy()));
@@ -3798,6 +3816,11 @@ std::shared_ptr<Analyzer::Expr> LevenshteinDistanceStringOper::deep_copy() const
       std::dynamic_pointer_cast<Analyzer::StringOper>(StringOper::deep_copy()));
 }
 
+std::shared_ptr<Analyzer::Expr> HashStringOper::deep_copy() const {
+  return makeExpr<Analyzer::HashStringOper>(
+      std::dynamic_pointer_cast<Analyzer::StringOper>(StringOper::deep_copy()));
+}
+
 std::shared_ptr<Analyzer::Expr> FunctionOper::deep_copy() const {
   std::vector<std::shared_ptr<Analyzer::Expr>> args_copy;
   for (size_t i = 0; i < getArity(); ++i) {
@@ -4075,13 +4098,19 @@ std::shared_ptr<Analyzer::Constant> GeoConstant::makePhysicalConstant(
   std::vector<int> poly_rings;
 
   const bool validate_with_geos_if_available = false;
-  Geospatial::GeoTypesFactory::getGeoColumns(geo_->getWktString(),
-                                             ti,
-                                             coords,
-                                             bounds,
-                                             ring_sizes,
-                                             poly_rings,
-                                             validate_with_geos_if_available);
+  bool success =
+      Geospatial::GeoTypesFactory::getGeoColumns(geo_->getWktString(),
+                                                 ti,
+                                                 coords,
+                                                 bounds,
+                                                 ring_sizes,
+                                                 poly_rings,
+                                                 validate_with_geos_if_available);
+  if (!success) {
+    std::ostringstream oss;
+    oss << "Failed to create geometry from WKT string: " << geo_->getWktString();
+    throw std::runtime_error(oss.str());
+  }
 
   switch (index) {
     case 0:  // coords

Analyzer/Analyzer.h

@@ -2359,6 +2359,46 @@ class RegexpSubstrStringOper : public StringOper {
             "sub-match group index"};
   }
 };
+
+class RegexpCountStringOper : public StringOper {
+ public:
+  RegexpCountStringOper(const std::shared_ptr<Analyzer::Expr>& operand,
+                        const std::shared_ptr<Analyzer::Expr>& regex_pattern,
+                        const std::shared_ptr<Analyzer::Expr>& start_pos,
+                        const std::shared_ptr<Analyzer::Expr>& regex_params)
+      : StringOper(SqlStringOpKind::REGEXP_COUNT,
+                   SQLTypeInfo(kBIGINT),
+                   {operand, regex_pattern, start_pos, regex_params},
+                   getMinArgs(),
+                   getExpectedTypeFamilies(),
+                   getArgNames()) {}
+
+  RegexpCountStringOper(const std::vector<std::shared_ptr<Analyzer::Expr>>& operands)
+      : StringOper(SqlStringOpKind::REGEXP_COUNT,
+                   SQLTypeInfo(kBIGINT),
+                   operands,
+                   getMinArgs(),
+                   getExpectedTypeFamilies(),
+                   getArgNames()) {}
+
+  RegexpCountStringOper(const std::shared_ptr<Analyzer::StringOper>& string_oper)
+      : StringOper(string_oper) {}
+
+  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
+
+  size_t getMinArgs() const override { return 4UL; }
+
+  std::vector<OperandTypeFamily> getExpectedTypeFamilies() const override {
+    return {OperandTypeFamily::STRING_FAMILY,
+            OperandTypeFamily::STRING_FAMILY,
+            OperandTypeFamily::INT_FAMILY,
+            OperandTypeFamily::STRING_FAMILY};
+  }
+  std::vector<std::string> getArgNames() const override {
+    return {"operand", "regex pattern", "start position", "regex parameters"};
+  }
+};
+
 class JsonValueStringOper : public StringOper {
  public:
   JsonValueStringOper(const std::shared_ptr<Analyzer::Expr>& operand,
@@ -2449,6 +2489,66 @@ class Base64DecodeStringOper : public StringOper {
   std::vector<std::string> getArgNames() const override { return {"operand"}; }
 };
 
+class UrlEncodeStringOper : public StringOper {
+ public:
+  UrlEncodeStringOper(const std::shared_ptr<Analyzer::Expr>& operand)
+      : StringOper(SqlStringOpKind::URL_ENCODE,
+                   {operand},
+                   getMinArgs(),
+                   getExpectedTypeFamilies(),
+                   getArgNames()) {}
+
+  UrlEncodeStringOper(const std::vector<std::shared_ptr<Analyzer::Expr>>& operands)
+      : StringOper(SqlStringOpKind::URL_ENCODE,
+                   operands,
+                   getMinArgs(),
+                   getExpectedTypeFamilies(),
+                   getArgNames()) {}
+
+  UrlEncodeStringOper(const std::shared_ptr<Analyzer::StringOper>& string_oper)
+      : StringOper(string_oper) {}
+
+  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
+
+  size_t getMinArgs() const override { return 1u; }
+
+  std::vector<OperandTypeFamily> getExpectedTypeFamilies() const override {
+    return {OperandTypeFamily::STRING_FAMILY};
+  }
+
+  std::vector<std::string> getArgNames() const override { return {"operand"}; }
+};
+
+class UrlDecodeStringOper : public StringOper {
+ public:
+  UrlDecodeStringOper(const std::shared_ptr<Analyzer::Expr>& operand)
+      : StringOper(SqlStringOpKind::URL_DECODE,
+                   {operand},
+                   getMinArgs(),
+                   getExpectedTypeFamilies(),
+                   getArgNames()) {}
+
+  UrlDecodeStringOper(const std::vector<std::shared_ptr<Analyzer::Expr>>& operands)
+      : StringOper(SqlStringOpKind::URL_DECODE,
+                   operands,
+                   getMinArgs(),
+                   getExpectedTypeFamilies(),
+                   getArgNames()) {}
+
+  UrlDecodeStringOper(const std::shared_ptr<Analyzer::StringOper>& string_oper)
+      : StringOper(string_oper) {}
+
+  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
+
+  size_t getMinArgs() const override { return 1u; }
+
+  std::vector<OperandTypeFamily> getExpectedTypeFamilies() const override {
+    return {OperandTypeFamily::STRING_FAMILY};
+  }
+
+  std::vector<std::string> getArgNames() const override { return {"operand"}; }
+};
+
 class TryStringCastOper : public StringOper {
  public:
   TryStringCastOper(const SQLTypeInfo& ti, const std::shared_ptr<Analyzer::Expr>& operand)
@@ -2603,6 +2703,37 @@ class LevenshteinDistanceStringOper : public StringOper {
       const std::vector<std::shared_ptr<Analyzer::Expr>>& operands);
 };
 
+class HashStringOper : public StringOper {
+ public:
+  HashStringOper(const std::shared_ptr<Analyzer::Expr>& operand)
+      : StringOper(SqlStringOpKind::HASH,
+                   SQLTypeInfo(kBIGINT),
+                   {operand},
+                   getMinArgs(),
+                   getExpectedTypeFamilies(),
+                   getArgNames()) {}
+
+  HashStringOper(const std::vector<std::shared_ptr<Analyzer::Expr>>& operands)
+      : StringOper(SqlStringOpKind::HASH,
+                   SQLTypeInfo(kBIGINT),
+                   operands,
+                   getMinArgs(),
+                   getExpectedTypeFamilies(),
+                   getArgNames()) {}
+
+  HashStringOper(const std::shared_ptr<Analyzer::StringOper>& string_oper)
+      : StringOper(string_oper) {}
+
+  std::shared_ptr<Analyzer::Expr> deep_copy() const override;
+
+  size_t getMinArgs() const override { return 1UL; }
+
+  std::vector<OperandTypeFamily> getExpectedTypeFamilies() const override {
+    return {OperandTypeFamily::STRING_FAMILY};
+  }
+  std::vector<std::string> getArgNames() const override { return {"operand"}; }
+};
+
 class FunctionOper : public Expr {
  public:
   FunctionOper(const SQLTypeInfo& ti,

Benchmarks/conbench/report.css

@@ -0,0 +1,9 @@
+body { font-family: sans-serif }
+table { border-collapse: collapse }
+th { text-align: right; padding-right: 1em }
+td { font-family: monospace; text-align: right; padding-right: 1em }
+td.fixed { background-color: LightGreen }
+td.check { background-color: Khaki }
+td.warning { background-color: Yellow }
+td.error { background-color: Red }
+tr:nth-child(even) { background-color: LightCyan }

Benchmarks/conbench/report.py

@@ -213,17 +213,7 @@ def summary_body_rows():
 <html>
 <head>
   <title>Benchmarks for {branch} / {short_sha} on {host}</title>
-  <style>
-body {{ font-family: sans-serif }}
-table {{ border-collapse: collapse }}
-th {{ text-align: right; padding-right: 1em }}
-td {{ font-family: monospace; text-align: right; padding-right: 1em }}
-td.fixed {{ background-color: LightGreen }}
-td.check {{ background-color: Khaki }}
-td.warning {{ background-color: Yellow }}
-td.error {{ background-color: Red }}
-tr:nth-child(even) {{ background-color: LightCyan }}
-  </style>
+  <link rel="stylesheet" href="report.css">
 </head>
 <body>
 <h1>Benchmarks for {branch} / <a href="{commit_url}">{short_sha}</a> on {host}</h1>

CMakeLists.txt

@@ -89,12 +89,13 @@ add_definitions("-DMAPD_EDITION_${MAPD_EDITION}")
 string(TOLOWER "${MAPD_EDITION}" MAPD_EDITION_LOWER)
 
 # HeavyDB version number
-set(MAPD_VERSION_MAJOR "7")
-set(MAPD_VERSION_MINOR "1")
+set(MAPD_VERSION_MAJOR "8")
+set(MAPD_VERSION_MINOR "0")
 set(MAPD_VERSION_PATCH "0")
 set(MAPD_VERSION_EXTRA "dev")
 set(MAPD_VERSION_RAW "${MAPD_VERSION_MAJOR}.${MAPD_VERSION_MINOR}.${MAPD_VERSION_PATCH}${MAPD_VERSION_EXTRA}")
-set(MAPD_IMMERSE_URL "http://builds.mapd.com/frontend/mapd2-dashboard-v2-137-release-prod.zip")
+set(MAPD_IMMERSE_BUILD_ID "immerse-v2-latest-master-prod" CACHE STRING "Immerse Build ID")
+set(MAPD_IMMERSE_URL "http://builds.mapd.com/frontend/${MAPD_IMMERSE_BUILD_ID}.zip")
 string(TIMESTAMP MAPD_BUILD_DATE "%Y%m%d")
 
 if($ENV{BUILD_NUMBER})
@@ -134,6 +135,31 @@ macro(set_alternate_linker linker)
   endif()
 endmacro()
 
+macro(InstallVersionFile)
+  # `touch mapd_deps_version.txt` from build dir to silence warning.
+  find_file(MapdDepsVersion_FILE mapd_deps_version.txt PATH ${CMAKE_BINARY_DIR} NO_CACHE)
+
+  if(NOT MapdDepsVersion_FILE)
+    message(WARNING "Build could NOT find deps version file mapd_deps_version.txt")
+  else()
+    message(STATUS "Found deps version file ${MapdDepsVersion_FILE}")
+    file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/version)
+    set(HEAVY_DEPS_CUSTOM ${CMAKE_BINARY_DIR}/version/heavyai_deps_version.txt)
+    # cp mapd_version data to heavyai deps, removing un-tagged lines.
+    add_custom_command(OUTPUT ${HEAVY_DEPS_CUSTOM}
+      DEPENDS ${MapdDepsVersion_FILE}
+      COMMAND ${CMAKE_COMMAND} -E copy ${MapdDepsVersion_FILE} ${HEAVY_DEPS_CUSTOM}
+      # In the copied deps files leave the first line with the deps generated info
+      # and any other line starting with 'Public Release:', though remove the public release tag
+      VERBATIM
+      COMMAND "sed" "-i" "-n" "/^Public Release:/s/^Public Release://p" ${HEAVY_DEPS_CUSTOM})
+
+    add_custom_target(HeavyDepsVersionTarget DEPENDS ${HEAVY_DEPS_CUSTOM})
+    add_dependencies(heavydb HeavyDepsVersionTarget)
+    install(FILES ${HEAVY_DEPS_CUSTOM} DESTINATION "."  COMPONENT "doc")
+  endif()
+endmacro()
+
 set(USE_ALTERNATE_LINKER "" CACHE STRING "Use alternate linker. Leave empty for system default; alternatives are 'gold', 'lld', 'bfd', 'mold'")
 if(NOT "${USE_ALTERNATE_LINKER}" STREQUAL "")
   set_alternate_linker(${USE_ALTERNATE_LINKER})
@@ -192,9 +218,8 @@ endif()
 option(ENABLE_CUDA "Enable CUDA support" ON)
 if(ENABLE_CUDA)
   enable_language(CUDA)
-  find_package(CUDA REQUIRED)
-  include_directories(${CUDA_INCLUDE_DIRS})
-  list(APPEND CUDA_LIBRARIES ${CUDA_CUDA_LIBRARY})
+  include_directories(${CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES})
+  list(APPEND CUDA_LIBRARIES cuda)
   add_definitions("-DHAVE_CUDA")
 
 else()
@@ -918,10 +943,6 @@ target_link_libraries(mapd_thrift ${Thrift_LIBRARIES})
 
 if("${MAPD_EDITION_LOWER}" STREQUAL "ee")
   option(ENABLE_OMNIVERSE_CONNECTOR "Enable Omniverse Connector" ON)
-  if(ENABLE_OMNIVERSE_CONNECTOR)
-    include_directories(ThirdParty/poly2tri)
-    add_subdirectory(ThirdParty/poly2tri)
-  endif()
   include_directories(Catalog/ee)
   include_directories(Distributed/ee)
 else()
@@ -992,7 +1013,7 @@ if(ENABLE_RUNTIME_LIBS)
       find_package(Torch REQUIRED)
       if (DEFINED TORCH_CUDA_LIBRARIES)
         # Torch removes the CUDA Driver target from CUDA_LIBRARIES when doing its own CUDA CMake setup, so we have to re-add it
-        list(APPEND CUDA_LIBRARIES ${CUDA_CUDA_LIBRARY})
+        list(APPEND CUDA_LIBRARIES cuda)
         add_compile_definitions("HAVE_CUDA_TORCH")
       endif()
       add_compile_definitions("HAVE_TORCH_TFS")
@@ -1107,6 +1128,7 @@ endif()
 
 add_executable(heavydb HeavyDB.cpp ${CMAKE_BINARY_DIR}/MapDRelease.h)
 set_target_properties(heavydb PROPERTIES COMPILE_DEFINITIONS "${TIME_LIMITED_DEFINITIONS}")
+InstallVersionFile()
 
 add_custom_command(
     DEPENDS ${CMAKE_SOURCE_DIR}/heavy.thrift