ashniku commented on PR #6412:
URL: https://github.com/apache/hive/pull/6412#issuecomment-4893119798
> I think the PR is overengineered on the client side. Once the server sends
the authoritative HYT00 message, the whole
HiveConnection.sessionQueryTimeoutSeconds machinery — the field/setter,
applySessionQueryTimeoutFromJdbcUrl(), getSessionQueryTimeoutSeconds(), and
resolveEffectiveTimeoutSecondsForMessage() — is redundant
>
> I removed all of it and let the fallback be just the per-statement
queryTimeout (which is all a pre-HYT00 server can meaningfully report). All
four of your timeout tests still pass
>
> ```
> Subject: [PATCH] patch
> ---
> Index:
itests/hive-unit/src/test/java/org/apache/hive/jdbc/TestJdbcDriver2.java
> IDEA additional info:
> Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
> <+>UTF-8
> ===================================================================
> diff --git
a/itests/hive-unit/src/test/java/org/apache/hive/jdbc/TestJdbcDriver2.java
b/itests/hive-unit/src/test/java/org/apache/hive/jdbc/TestJdbcDriver2.java
> ---
a/itests/hive-unit/src/test/java/org/apache/hive/jdbc/TestJdbcDriver2.java
(revision 93c40e17851b3c12beee9ef711705621b85ccf66)
> +++
b/itests/hive-unit/src/test/java/org/apache/hive/jdbc/TestJdbcDriver2.java
(date 1783328104714)
> @@ -2785,9 +2785,9 @@
> /**
> * Variant of {@link #testQueryTimeoutFromSetStatement}: the {@code
SET} is issued on a separate,
> * already-closed statement; the timed-out query runs on a brand-new
statement with no
> - * {@link Statement#setQueryTimeout(int)} call. The tracked session
timeout lives on the
> - * {@link HiveConnection}, so it persists across statement instances
and must still drive the
> - * {@link SQLTimeoutException} message correctly.
> + * {@link Statement#setQueryTimeout(int)} call. The timeout lives on
the HS2 session, so it
> + * persists across client statement instances and the server-supplied
{@link SQLTimeoutException}
> + * message must still reflect it correctly.
> */
> @Test
> public void testQueryTimeoutMessagePersistedAcrossStatements() throws
Exception {
> @@ -2801,7 +2801,7 @@
> stmt2.execute("set hive.query.timeout.seconds=1s");
> stmt2.close();
>
> - // Brand-new statement, no setQueryTimeout() call – relies solely on
the tracked session value
> + // Brand-new statement, no setQueryTimeout() call – relies solely on
the HS2 session timeout
> Statement stmt = con.createStatement();
> System.err.println("Executing query (expecting timeout): ");
> try {
> Index: jdbc/src/java/org/apache/hive/jdbc/HiveConnection.java
> IDEA additional info:
> Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
> <+>UTF-8
> ===================================================================
> diff --git a/jdbc/src/java/org/apache/hive/jdbc/HiveConnection.java
b/jdbc/src/java/org/apache/hive/jdbc/HiveConnection.java
> --- a/jdbc/src/java/org/apache/hive/jdbc/HiveConnection.java
(revision 93c40e17851b3c12beee9ef711705621b85ccf66)
> +++ b/jdbc/src/java/org/apache/hive/jdbc/HiveConnection.java (date
1783328248965)
> @@ -69,7 +69,6 @@
> import java.util.Optional;
> import java.util.Properties;
> import java.util.concurrent.Executor;
> -import java.util.concurrent.TimeUnit;
> import java.util.concurrent.locks.ReentrantLock;
> import java.util.stream.Stream;
>
> @@ -83,7 +82,6 @@
>
> import org.apache.commons.lang3.StringUtils;
> import org.apache.hadoop.hive.common.auth.HiveAuthUtils;
> -import org.apache.hadoop.hive.conf.HiveConf;
> import org.apache.hadoop.hive.conf.HiveConf.ConfVars;
> import com.google.common.annotations.VisibleForTesting;
> import com.google.common.base.Preconditions;
> @@ -165,13 +163,6 @@
> */
> public class HiveConnection implements java.sql.Connection {
> private static final Logger LOG =
LoggerFactory.getLogger(HiveConnection.class);
> -
> - /**
> - * Last effective {@code hive.query.timeout.seconds} in seconds, or
{@code -1} if not yet set.
> - * Seeded from the JDBC URL at connect time; a JDBC {@link
java.sql.Connection} may be shared
> - * across threads with concurrent {@link
org.apache.hive.jdbc.HiveStatement}s on one HS2 session.
> - */
> - private volatile long sessionQueryTimeoutSeconds = -1L;
> private String jdbcUriString;
> private String host;
> private int port;
> @@ -199,46 +190,6 @@
>
> public TCLIService.Iface getClient() { return client; }
>
> - /**
> - * Updates the tracked {@code hive.query.timeout.seconds} value (in
seconds) on this connection.
> - * Called at connect time from the JDBC URL hive-conf map, and may be
called again later if needed.
> - */
> - void setSessionQueryTimeoutSeconds(long seconds) {
> - sessionQueryTimeoutSeconds = seconds;
> - }
> -
> - /**
> - * If the JDBC URL supplied {@code hive.query.timeout.seconds} (via the
{@code ?hive_conf_list}
> - * segment), parses and stores the value so that {@link
#getSessionQueryTimeoutSeconds()} can
> - * return it for timeout error messages. This runs once at connect time
and does not affect the
> - * server-side configuration, which is applied separately in {@link
#openSession()}.
> - */
> - private void applySessionQueryTimeoutFromJdbcUrl() {
> - Map<String, String> hiveConfs = connParams.getHiveConfs();
> - if (hiveConfs == null || hiveConfs.isEmpty()) {
> - return;
> - }
> - String raw =
hiveConfs.get(ConfVars.HIVE_QUERY_TIMEOUT_SECONDS.varname);
> - if (StringUtils.isBlank(raw)) {
> - return;
> - }
> - try {
> - long sec = HiveConf.toTime(raw.trim(), TimeUnit.SECONDS,
TimeUnit.SECONDS);
> - if (sec > 0) {
> - setSessionQueryTimeoutSeconds(sec);
> - }
> - } catch (Exception e) {
> - LOG.debug("Could not parse {} from JDBC URL: {}",
ConfVars.HIVE_QUERY_TIMEOUT_SECONDS.varname, raw, e);
> - }
> - }
> -
> - /**
> - * @return the tracked {@code hive.query.timeout.seconds} in seconds,
or {@code -1} if not set
> - */
> - long getSessionQueryTimeoutSeconds() {
> - return sessionQueryTimeoutSeconds;
> - }
> -
> /**
> * Get all direct HiveServer2 URLs from a ZooKeeper based HiveServer2
URL
> * @param zookeeperBasedHS2Url
> @@ -381,7 +332,6 @@
> // hive_conf_list -> hiveConfMap
> // hive_var_list -> hiveVarMap
> sessConfMap = connParams.getSessionVars();
> - applySessionQueryTimeoutFromJdbcUrl();
> setupLoginTimeout();
> if (isKerberosAuthMode()) {
> // Ensure UserGroupInformation includes any authorized Kerberos
principals.
> Index: jdbc/src/java/org/apache/hive/jdbc/HiveStatement.java
> IDEA additional info:
> Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
> <+>UTF-8
> ===================================================================
> diff --git a/jdbc/src/java/org/apache/hive/jdbc/HiveStatement.java
b/jdbc/src/java/org/apache/hive/jdbc/HiveStatement.java
> --- a/jdbc/src/java/org/apache/hive/jdbc/HiveStatement.java
(revision 93c40e17851b3c12beee9ef711705621b85ccf66)
> +++ b/jdbc/src/java/org/apache/hive/jdbc/HiveStatement.java (date
1783328875508)
> @@ -399,43 +399,19 @@
> }
>
> /**
> - * Returns the timeout message for a {@code TIMEDOUT_STATE} response.
> - * Uses the server error message when the SQL state is {@code HYT00}
("timeout expired"),
> - * which indicates that the server set a precise message. Otherwise
falls back to a
> - * locally derived message from {@link #setQueryTimeout(int)} or the
URL-seeded
> - * {@code hive.query.timeout.seconds} value on the connection.
> + * Returns the timeout message for a {@code TIMEDOUT_STATE} response.
The server is authoritative:
> + * when the SQL state is {@code HYT00} ("timeout expired") it has set a
precise message that
> + * already reflects the effective {@code hive.query.timeout.seconds},
so it is used verbatim.
> + * Otherwise (e.g. an older server) falls back to the per-statement
{@link #setQueryTimeout(int)}.
> */
> private String sqlTimeoutMessageForTimedOutState(String serverMessage,
String sqlState) {
> if ("HYT00".equals(sqlState) &&
StringUtils.isNotBlank(serverMessage)) {
> return serverMessage;
> }
> - long effectiveSec = resolveEffectiveTimeoutSecondsForMessage();
> - if (effectiveSec > 0) {
> - return "Query timed out after " + effectiveSec + " seconds";
> - }
> - return "Query timed out";
> - }
> -
> - private long resolveEffectiveTimeoutSecondsForMessage() {
> if (queryTimeout > 0) {
> - return queryTimeout;
> - }
> - long tracked = connection.getSessionQueryTimeoutSeconds();
> - if (tracked > 0) {
> - return tracked;
> + return "Query timed out after " + queryTimeout + " seconds";
> }
> - return 0L;
> - }
> -
> - private SQLException
sqlExceptionForCanceledState(TGetOperationStatusResp statusResp) {
> - final String errMsg = statusResp.getErrorMessage();
> - final String fullErrMsg;
> - if (errMsg == null || errMsg.isEmpty()) {
> - fullErrMsg = QUERY_CANCELLED_MESSAGE;
> - } else {
> - fullErrMsg = QUERY_CANCELLED_MESSAGE + " " + errMsg;
> - }
> - return new SQLException(fullErrMsg, "01000"); // SQLSTATE 01000 =
warning
> + return "Query timed out";
> }
>
> /**
> @@ -457,7 +433,11 @@
> isLogBeingGenerated = false;
> break;
> case CANCELED_STATE:
> - throw sqlExceptionForCanceledState(statusResp);
> + // 01000 -> warning
> + final String errMsg = statusResp.getErrorMessage();
> + final String fullErrMsg =
> + (errMsg == null || errMsg.isEmpty()) ? QUERY_CANCELLED_MESSAGE
: QUERY_CANCELLED_MESSAGE + " " + errMsg;
> + throw new SQLException(fullErrMsg, "01000");
> case TIMEDOUT_STATE:
> throw new SQLTimeoutException(
> sqlTimeoutMessageForTimedOutState(statusResp.getErrorMessage(),
statusResp.getSqlState()));
> Index:
service/src/java/org/apache/hive/service/cli/operation/SQLOperation.java
> IDEA additional info:
> Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
> <+>UTF-8
> ===================================================================
> diff --git
a/service/src/java/org/apache/hive/service/cli/operation/SQLOperation.java
b/service/src/java/org/apache/hive/service/cli/operation/SQLOperation.java
> ---
a/service/src/java/org/apache/hive/service/cli/operation/SQLOperation.java
(revision 93c40e17851b3c12beee9ef711705621b85ccf66)
> +++
b/service/src/java/org/apache/hive/service/cli/operation/SQLOperation.java
(date 1783328402146)
> @@ -177,6 +177,12 @@
> timeoutExecutor = Executors.newSingleThreadScheduledExecutor();
> timeoutExecutor.schedule(() -> {
> try {
> + // The query may have already finished, failed, or been
cancelled before this task
> + // fires (the executor is only shut down when the operation
is closed). Skip in that
> + // case so we don't overwrite a real result/exception with a
spurious timeout message.
> + if (getState().isTerminal()) {
> + return null;
> + }
> final String queryId = queryState.getQueryId();
> log.info("Query timed out after: {} seconds. Cancelling the
execution now: {}", queryTimeout, queryId);
> setOperationException(new HiveSQLException(
> ```
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
