Support for special characters in to_char functions

build.gradle.kts

@@ -18,13 +18,10 @@ import com.github.spotbugs.SpotBugsTask
 import com.github.vlsi.gradle.crlf.CrLfSpec
 import com.github.vlsi.gradle.crlf.LineEndings
 import com.github.vlsi.gradle.dsl.configureEach
-import com.github.vlsi.gradle.git.FindGitAttributes
-import com.github.vlsi.gradle.git.dsl.gitignore
 import com.github.vlsi.gradle.properties.dsl.lastEditYear
 import com.github.vlsi.gradle.properties.dsl.props
 import com.github.vlsi.gradle.release.RepositoryType
 import de.thetaphi.forbiddenapis.gradle.CheckForbiddenApis
-import de.thetaphi.forbiddenapis.gradle.CheckForbiddenApisExtension
 import java.net.URI
 import net.ltgt.gradle.errorprone.errorprone
 import org.apache.calcite.buildtools.buildext.dsl.ParenthesisBalancer
@@ -42,7 +39,7 @@ plugins {
     id("jacoco-report-aggregation")
     id("org.checkerframework") apply false
     id("com.github.autostyle")
-    id("org.nosphere.apache.rat")
+    // id("org.nosphere.apache.rat")
     id("com.github.spotbugs")
     id("de.thetaphi.forbiddenapis") apply false
     id("net.ltgt.errorprone") apply false
@@ -119,33 +116,38 @@ ide {
 // This task scans the project for gitignore / gitattributes, and that is reused for building
 // source/binary artifacts with the appropriate eol/executable file flags
 // It enables to automatically exclude patterns from .gitignore
-val gitProps by tasks.registering(FindGitAttributes::class) {
+// val gitProps by tasks.registering(FindGitAttributes::class) {
     // Scanning for .gitignore and .gitattributes files in a task avoids doing that
     // when distribution build is not required (e.g. code is just compiled)
-    root.set(rootDir)
-}
-
-val rat by tasks.getting(org.nosphere.apache.rat.RatTask::class) {
-    gitignore(gitProps)
-    verbose.set(true)
-    // Note: patterns are in non-standard syntax for RAT, so we use exclude(..) instead of excludeFile
-    exclude(rootDir.resolve(".ratignore").readLines())
-}
-
-tasks.validateBeforeBuildingReleaseArtifacts {
-    dependsOn(rat)
-}
+//    root.set(rootDir)
+// }
+
+// val rat by tasks.getting(org.nosphere.apache.rat.RatTask::class) {
+//    gitignore(gitProps)
+//    verbose.set(true)
+//    // Note: patterns are in non-standard syntax for RAT, so we use exclude(..) instead of excludeFile
+//    exclude(rootDir.resolve(".ratignore").readLines())
+// }
+//
+// tasks.validateBeforeBuildingReleaseArtifacts {
+//    dependsOn(rat)
+// }
 
 val String.v: String get() = rootProject.extra["$this.version"] as String
 
-val buildVersion = "calcite".v + releaseParams.snapshotSuffix
+val buildVersion = "calcite".v
 
 println("Building Apache Calcite $buildVersion")
 
 releaseArtifacts {
     fromProject(":release")
 }
 
+java {
+    sourceCompatibility = JavaVersion.VERSION_11
+    targetCompatibility = JavaVersion.VERSION_11
+}
+
 // Configures URLs to SVN and Nexus
 releaseParams {
     tlp.set("Calcite")
@@ -331,6 +333,14 @@ allprojects {
     repositories {
         // RAT and Autostyle dependencies
         mavenCentral()
+        maven {
+            url = uri("http://nexus2.datametica.com:8081/nexus/content/repositories/thirdparty/")
+            setAllowInsecureProtocol(true)
+            credentials {
+                username = "abbas.gadhia"
+                password = "abbas.gadhia"
+            }
+        }
     }
 
     val javaUsed = file("src/main/java").isDirectory
@@ -530,7 +540,7 @@ allprojects {
         }
         val sourceSets: SourceSetContainer by project
 
-        apply(plugin = "de.thetaphi.forbiddenapis")
+        // apply(plugin = "de.thetaphi.forbiddenapis")
         apply(plugin = "maven-publish")
 
         if (!skipJandex) {
@@ -675,19 +685,19 @@ allprojects {
             }
         }
 
-        configure<CheckForbiddenApisExtension> {
-            failOnUnsupportedJava = false
-            ignoreSignaturesOfMissingClasses = true
-            suppressAnnotations.add("org.immutables.value.Generated")
-            bundledSignatures.addAll(
-                listOf(
-                    "jdk-unsafe",
-                    "jdk-deprecated",
-                    "jdk-non-portable"
-                )
-            )
-            signaturesFiles = files("$rootDir/src/main/config/forbidden-apis/signatures.txt")
-        }
+//        configure<CheckForbiddenApisExtension> {
+//            failOnUnsupportedJava = false
+//            ignoreSignaturesOfMissingClasses = true
+//            suppressAnnotations.add("org.immutables.value.Generated")
+//            bundledSignatures.addAll(
+//                listOf(
+//                    "jdk-unsafe",
+//                    "jdk-deprecated",
+//                    "jdk-non-portable"
+//                )
+//            )
+//            signaturesFiles = files("$rootDir/src/main/config/forbidden-apis/signatures.txt")
+//        }
 
         if (enableErrorprone) {
             apply(plugin = "net.ltgt.errorprone")

core/build.gradle.kts

@@ -24,6 +24,7 @@ plugins {
     kotlin("jvm")
     id("com.github.vlsi.crlf")
     id("com.github.vlsi.ide")
+//    id("io.freefair.aspectj.post-compile-weaving") version "6.6.2"
     calcite.fmpp
     calcite.javacc
 }
@@ -75,6 +76,8 @@ dependencies {
     implementation("commons-io:commons-io")
     implementation("org.codehaus.janino:commons-compiler")
     implementation("org.codehaus.janino:janino")
+//    implementation("org.aspectj:aspectjrt:1.9.22")
+//    implementation("org.aspectj:aspectjweaver:1.9.22")
     annotationProcessor("org.immutables:value")
     compileOnly("org.immutables:value-annotations")
     compileOnly("com.google.code.findbugs:jsr305")

core/src/main/codegen/default_config.fmpp

@@ -328,6 +328,8 @@ parser: {
     "TIMESTAMPDIFF"
     "TIMESTAMP_DIFF"
     "TIMESTAMP_TRUNC"
+    "TIMESTAMPADD"
+    "TIMESTAMPDIFF"
     "TOP_LEVEL_COUNT"
     "TRANSACTION"
     "TRANSACTIONS_ACTIVE"

core/src/main/codegen/templates/Parser.jj

@@ -4155,7 +4155,6 @@ SqlCall PercentileFunctionCall() :
    )
 }
 
-
 /**
  * Parses an atomic row expression.
  */

core/src/main/java/org/apache/calcite/ExceptionLoggingAspect.java

@@ -0,0 +1,113 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * This class use by aspect implementation to segregate relNode and method call detail which
+ * captured during aspect execution.
+ */
+public class ExceptionLoggingAspect extends RuntimeException {
+
+  public static final String REL_NODE = "relNode";
+  public static final String METHOD_CALL_STACK = "methodCall";
+  public static final String SQL_EXPRESSION = "sqlExpression";
+  public static final String REL_EXPRESSION = "relExpression";
+  public static final String ROOT_METHOD_SIGNATURE = "rootMethodSignature";
+  public static final String ROOT_METHOD_ARGS = "rootMethodArgs";
+  public static final String FAILING_MODULE = "failingModule";
+  public static final String FAILURE_STAGE = "failureStage";
+  public static final String SOURCE_SCRIPT = "sourceScript";
+  public static final String EXCEPTION_MSG = "exceptionMsg";
+
+
+  public Map<String, List<String>> details;
+
+  public ExceptionLoggingAspect() {
+    details = new HashMap<>();
+    details.put(REL_NODE, new ArrayList<String>());
+    details.put(METHOD_CALL_STACK, new ArrayList<String>());
+    details.put(SQL_EXPRESSION, new ArrayList<String>());
+    details.put(REL_EXPRESSION, new ArrayList<String>());
+    details.put(ROOT_METHOD_SIGNATURE, new ArrayList<String>());
+    details.put(ROOT_METHOD_ARGS, new ArrayList<String>());
+    details.put(FAILING_MODULE, new ArrayList<String>());
+    details.put(FAILURE_STAGE, new ArrayList<String>());
+    details.put(SOURCE_SCRIPT, new ArrayList<String>());
+    details.put(EXCEPTION_MSG, new ArrayList<String>());
+  }
+
+  // Getting populated from calcite
+  public List<String> getRelNodeExceptionDetails() {
+    return details.get(REL_NODE);
+  }
+
+  // Getting populated from calcite as well as raven
+  public List<String> getMethodCallExceptionDetails() {
+    return details.get(METHOD_CALL_STACK);
+  }
+
+  // Getting populated from raven
+  public List<String> getSqlExpressions() {
+    return details.get(SQL_EXPRESSION);
+  }
+
+  // Getting populated from calcite as well as raven
+  public List<String> getRelExpressions() {
+    return details.get(REL_EXPRESSION);
+  }
+
+  // Getting populated from raven
+  public List<String> getRootMethodSignature() {
+    return details.get(ROOT_METHOD_SIGNATURE);
+  }
+
+  // Getting populated from raven
+  public List<String> getRootMethodArgs() {
+    return details.get(ROOT_METHOD_ARGS);
+  }
+
+  // Getting populated from raven
+  public List<String> getFailingModule() {
+    return details.get(FAILING_MODULE);
+  }
+
+  // Getting populated from raven
+  public List<String> getFailureStage() {
+    return details.get(FAILURE_STAGE);
+  }
+
+  // Getting populated from raven
+  public List<String> getSourceScript() {
+    return details.get(SOURCE_SCRIPT);
+  }
+
+  // Getting populated from raven
+  public List<String> getExceptionMsg() {
+    return details.get(EXCEPTION_MSG);
+  }
+
+  public void clear() {
+    details.forEach((key, value) -> value.clear());
+    details.clear();
+  }
+
+}

core/src/main/java/org/apache/calcite/LogCalciteException.java

@@ -0,0 +1,100 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+
+package org.apache.calcite;
+
+*/
+
+/**
+ * Define aspect for calcite. It will help to identify problematic code
+ * easily and quickly
+ *//*
+
+@Aspect
+public class LogCalciteException {
+
+  private static final String BASE_PACKAGE = "org.apache.calcite";
+  private static final String REL_PACKAGE = "org.apache.calcite.rel..*";
+  private static final String TOOL_PACKAGE = "org.apache.calcite.tool..*";
+  public static final String MESSAGE_PREFIX = "The issue occurred because of ";
+  public static final int METHOD_CALL_LIST_LIMIT = 5;
+
+  @AfterThrowing(pointcut =
+      "execution(* " + BASE_PACKAGE + "..*(..)) && (within(" + REL_PACKAGE + ") || "
+          + "within(" + TOOL_PACKAGE + "))", throwing = "ex")
+  public void logException(JoinPoint joinPoint, Exception ex) {
+    if (joinPoint.getTarget() != null) {
+      // Capture detail as part of suppressed exception and keep populating it
+      // to newly create or thrown exception instance
+      ExceptionLoggingAspect loggingException = ex.getSuppressed() != null && ex.getSuppressed().length > 0
+              ? (ExceptionLoggingAspect) ex.getSuppressed()[0] : new ExceptionLoggingAspect();
+      RelNode relNode = getRelNode(joinPoint);
+      // Check whether relNode not null and related to relnode details not populated.
+      if (relNode != null && loggingException.getRelNodeExceptionDetails().isEmpty()) {
+        loggingException.getRelNodeExceptionDetails().add(MESSAGE_PREFIX + relNode.explain());
+        populateSuppressedException(ex, loggingException);
+      } else {
+        // We populate relNode detail which is being passed as parameter while calling a method
+        // also captured details of other kind of parameter with certain threshold limit.
+        List<String> relExpressionList = loggingException.getRelExpressions();
+        boolean relExpressionListEmpty = relExpressionList.isEmpty();
+        String detail = MESSAGE_PREFIX + "method call " + joinPoint.getSignature().toString()
+                + " with args ";
+        for (Object arg : joinPoint.getArgs()) {
+          detail += arg.toString() + ",";
+          if (relExpressionListEmpty) {
+            populateRelExpressionList(relExpressionList, arg);
+            relExpressionListEmpty = relExpressionList.isEmpty();
+          }
+        }
+        if (loggingException.getMethodCallExceptionDetails().size() < METHOD_CALL_LIST_LIMIT) {
+          detail = detail.substring(0, detail.length() - 1) + "\n";
+          loggingException.getMethodCallExceptionDetails().add(MESSAGE_PREFIX + detail);
+        }
+        populateSuppressedException(ex, loggingException);
+      }
+    }
+  }
+
+  // If exception is thrown from RelBuilder, SingleRel or sub class of SingleRel
+  // then we try to get relnode at that time.
+  private RelNode getRelNode(JoinPoint joinPoint) {
+    if (joinPoint.getThis() instanceof RelBuilder
+            && ((RelBuilder) joinPoint.getThis()).size() > 0) {
+      return ((RelBuilder) joinPoint.getThis()).peek();
+    } else if (joinPoint.getThis() instanceof SingleRel
+            && ((SingleRel) joinPoint.getThis()).getInput() != null) {
+      return ((SingleRel) joinPoint.getThis()).getInput();
+    }
+    return null;
+  }
+
+  public static void populateSuppressedException(Exception ex, ExceptionLoggingAspect loggingException) {
+    if (ex.getSuppressed() == null || ex.getSuppressed().length == 0) {
+      ex.addSuppressed(loggingException);
+    }
+  }
+
+  private void populateRelExpressionList(List<String> expressionList, Object arg) {
+    if (arg instanceof AbstractRelNode) {
+      expressionList.add(arg.toString());
+    }
+  }
+}
+*/