Skip to content

HIVE-28265: Fix JDBC timeout message for hive.query.timeout.seconds #6412

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
ashniku wants to merge 5 commits into
base: master
Choose a base branch
from
Open

HIVE-28265: Fix JDBC timeout message for hive.query.timeout.seconds #6412

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
5 commits
Select commit Hold shift + click to select a range
eec11d2
HIVE-28265: Fix JDBC timeout message for hive.query.timeout.seconds
ashniku Apr 6, 2026
ab425d3
HIVE-28265: Refactor HiveStatement timeout handling; reset session ti…
ashniku Apr 6, 2026
c5399f3
HIVE-28265: Tighten query timeout message assertions in TestJdbcDriver2
ashniku Apr 7, 2026
eaae132
HIVE-28265: Address JDBC PR review (assertEquals, setter names, docs)
ashniku Apr 7, 2026
aeb5a7c
HIVE-28265: Strip Query ID suffix from JDBC SQLTimeoutException message
ashniku Apr 7, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
67 changes: 66 additions & 1 deletion itests/hive-unit/src/test/java/org/apache/hive/jdbc/TestJdbcDriver2.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -42,6 +42,7 @@
import org.apache.hive.service.cli.operation.ClassicTableTypeMapping.ClassicTableTypes;
import org.apache.hive.service.cli.operation.HiveTableTypeMapping;
import org.apache.hive.service.cli.operation.TableTypeMappingFactory.TableTypeMappings;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Rule;
Expand Down Expand Up @@ -128,9 +129,35 @@ public class TestJdbcDriver2 {
private static Connection con;
private static final float floatCompareDelta = 0.0001f;

/**
* Exact {@link SQLTimeoutException#getMessage()} for a 1s limit from HS2 / client; see
* {@code SQLOperation} and {@code HiveStatement#sqlTimeoutMessageForTimedOutState} (no query id
* or timestamp is appended to this text).
*/
private static final String QUERY_TIMED_OUT_AFTER_1_SECONDS = "Query timed out after 1 seconds";

@Rule public ExpectedException thrown = ExpectedException.none();
@Rule public final TestName testName = new TestName();

/**
* {@code SET hive.query.timeout.seconds} applies to the whole HS2 session. Tests such as
* {@link #testQueryTimeoutMessageUsesHiveConf()} must not leave a short limit on the shared
* {@link #con}, or unrelated tests will see {@link SQLTimeoutException}.
*/
@After
public void resetHiveSessionQueryTimeout() {
try {
if (con == null || con.isClosed()) {
return;
}
try (Statement st = con.createStatement()) {
st.execute("set hive.query.timeout.seconds=0s");
}
} catch (SQLException e) {
LOG.warn("Could not reset hive.query.timeout.seconds after {}", testName.getMethodName(), e);
}
}

private static Connection getConnection(String prefix, String postfix) throws SQLException {
Connection con1;
String connString = "jdbc:hive2:///" + prefix + "?" + conf.getOverlayOptionsAsQueryString()
Expand Down Expand Up @@ -2661,7 +2688,11 @@ public void testQueryTimeout() throws Exception {
+ " t2 on t1.under_col = t2.under_col");
fail("Expecting SQLTimeoutException");
} catch (SQLTimeoutException e) {
assertNotNull(e);
assertEquals(
"JDBC query timeout (1s) should match HS2/HiveStatement text, e.g. "
+ QUERY_TIMED_OUT_AFTER_1_SECONDS,
QUERY_TIMED_OUT_AFTER_1_SECONDS,
e.getMessage());
System.err.println(e.toString());
} catch (SQLException e) {
fail("Expecting SQLTimeoutException, but got SQLException: " + e);
Expand All @@ -2680,6 +2711,40 @@ public void testQueryTimeout() throws Exception {
stmt.close();
}

/**
* When only {@code hive.query.timeout.seconds} applies (no {@link Statement#setQueryTimeout(int)}),
* the client must still report the real limit in {@link SQLTimeoutException#getMessage()} (before
* HIVE-28265 some paths wrongly showed "after 0 seconds"). Expected full message:
* {@link #QUERY_TIMED_OUT_AFTER_1_SECONDS} — same string as HS2 uses, with no query id or host
* suffix.
*/
@Test
public void testQueryTimeoutMessageUsesHiveConf() throws Exception {
String udfName = SleepMsUDF.class.getName();
Statement stmt1 = con.createStatement();
stmt1.execute("create temporary function sleepMsUDF as '" + udfName + "'");
stmt1.close();

Statement stmt = con.createStatement();
stmt.execute("set hive.query.timeout.seconds=1s");

try {
stmt.executeQuery("select sleepMsUDF(t1.under_col, 5) as u0, t1.under_col as u1, "
+ "t2.under_col as u2 from " + tableName + " t1 join " + tableName
+ " t2 on t1.under_col = t2.under_col");
fail("Expecting SQLTimeoutException");
} catch (SQLTimeoutException e) {
assertEquals(
"Session query timeout (1s) should match HS2/HiveStatement text, e.g. "
+ QUERY_TIMED_OUT_AFTER_1_SECONDS,
QUERY_TIMED_OUT_AFTER_1_SECONDS,
e.getMessage());
} catch (SQLException e) {
fail("Expecting SQLTimeoutException, but got SQLException: " + e);
}
stmt.close();
}

/**
* Test the non-null value of the Yarn ATS GUID.
* We spawn 2 threads - one running the query and
Expand Down
28 changes: 28 additions & 0 deletions jdbc/src/java/org/apache/hive/jdbc/HiveConnection.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -155,6 +155,7 @@
import org.apache.thrift.transport.TTransportException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.concurrent.atomic.AtomicLong;
import java.util.function.Supplier;

/**
Expand All @@ -163,6 +164,18 @@
*/
public class HiveConnection implements java.sql.Connection {
private static final Logger LOG = LoggerFactory.getLogger(HiveConnection.class);

/**
* Sentinel: no {@code SET hive.query.timeout.seconds} has been observed on this connection yet.
*/
static final long SESSION_QUERY_TIMEOUT_NOT_TRACKED = -1L;
/**
* Last effective {@code hive.query.timeout.seconds} from a client {@code SET} (seconds), or
* {@link #SESSION_QUERY_TIMEOUT_NOT_TRACKED}. A JDBC {@code Connection} may be shared across threads
* with concurrent {@link org.apache.hive.jdbc.HiveStatement}s on one HS2 session; this field uses an
* {@link AtomicLong} so updates remain well-defined (last SET wins).
*/
private final AtomicLong sessionQueryTimeoutSeconds = new AtomicLong(SESSION_QUERY_TIMEOUT_NOT_TRACKED);
Copy link
Copy Markdown
Contributor

@InvisibleProgrammer InvisibleProgrammer Apr 7, 2026

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Thinking out loud: I wonder if a connection can have concurrency issue: I mean, you can have multiple individual connections to Hive, but inside a connection itself, can we have multiple hive statements in parallel?
I have no such use case in my mind, but let me ping Ayush about this question.

@ayushtkn , what do you think?

Copy link
Copy Markdown
Member

@ayushtkn ayushtkn Apr 7, 2026

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

a single JDBC Connection can be shared across multiple threads, and it is entirely possible to have multiple HiveStatement objects executing concurrently on the same connection (which maps to a single session on the HS2 side).

via Beeline or so maybe not but In Hive Server 2 (HS2), a single JDBC Connection corresponds to a single HS2 Session. You can absolutely execute multiple queries concurrently within the same session by spawning multiple threads on the client side, each using a different HiveStatement created from that single HiveConnection.

Copy link
Copy Markdown
Contributor

@InvisibleProgrammer InvisibleProgrammer Apr 7, 2026

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Thx

private String jdbcUriString;
private String host;
private int port;
Expand Down Expand Up @@ -190,6 +203,21 @@ public class HiveConnection implements java.sql.Connection {

public TCLIService.Iface getClient() { return client; }

/**
* Sets the effective {@code hive.query.timeout.seconds} (in seconds) after a successful
* {@code SET hive.query.timeout.seconds=...} on this connection. Used for JDBC timeout messages.
*/
void setSessionQueryTimeoutSeconds(long seconds) {
sessionQueryTimeoutSeconds.set(seconds);
}

/**
* @return seconds from the last client-tracked SET, or {@link #SESSION_QUERY_TIMEOUT_NOT_TRACKED} if none
*/
long getSessionQueryTimeoutSeconds() {
return sessionQueryTimeoutSeconds.get();
}

/**
* Get all direct HiveServer2 URLs from a ZooKeeper based HiveServer2 URL
* @param zookeeperBasedHS2Url
Expand Down
96 changes: 90 additions & 6 deletions jdbc/src/java/org/apache/hive/jdbc/HiveStatement.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -19,8 +19,10 @@
package org.apache.hive.jdbc;

import org.apache.commons.lang3.StringUtils;
import org.apache.hadoop.hive.conf.HiveConf;
import org.apache.hadoop.hive.common.classification.InterfaceAudience.LimitedPrivate;
import org.apache.hive.jdbc.logs.InPlaceUpdateStream;
import org.apache.hive.service.cli.HiveSQLException;
import org.apache.hive.service.cli.RowSet;
import org.apache.hive.service.cli.RowSetFactory;
import org.apache.hive.service.rpc.thrift.TCLIService;
Expand Down Expand Up @@ -57,6 +59,9 @@
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.concurrent.TimeUnit;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import static org.apache.hadoop.hive.ql.ErrorMsg.CLIENT_POLLING_OPSTATUS_INTERRUPTED;

Expand All @@ -70,6 +75,10 @@ public class HiveStatement implements java.sql.Statement {

public static final String QUERY_CANCELLED_MESSAGE = "Query was cancelled.";

/** Last assignment wins if multiple appear (e.g. multi-line script). Uses find(), not full-string match. */
private static final Pattern SET_HIVE_QUERY_TIMEOUT_SECONDS = Pattern.compile(
"(?i)set\\s+hive\\.query\\.timeout\\.seconds\\s*=\\s*([^;\\n]+)");

private final HiveConnection connection;
private TCLIService.Iface client;
private Optional<TOperationHandle> stmtHandle;
Expand Down Expand Up @@ -298,6 +307,7 @@ public void closeOnCompletion() throws SQLException {
public boolean execute(String sql) throws SQLException {
runAsyncOnServer(sql);
TGetOperationStatusResp status = waitForOperationToComplete();
trackSessionQueryTimeoutIfSet(sql);

// The query should be completed by now
if (!status.isHasResultSet() && stmtHandle.isPresent() && !stmtHandle.get().isHasResultSet()) {
Expand Down Expand Up @@ -398,6 +408,84 @@ private TGetOperationStatusResp waitForResultSetStatus() throws SQLException {
return statusResp;
}

/**
* When {@code SET hive.query.timeout.seconds=...} succeeds, remember the effective value on the
* connection so {@code TIMEDOUT_STATE} can report it if the server omits {@code errorMessage}
* (HIVE-28265).
*/
private void trackSessionQueryTimeoutIfSet(String sql) {
if (sql == null) {
return;
}
Matcher m = SET_HIVE_QUERY_TIMEOUT_SECONDS.matcher(sql);
Long lastSec = null;
while (m.find()) {
Copy link
Copy Markdown
Contributor

@InvisibleProgrammer InvisibleProgrammer Apr 7, 2026

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I found this PR interesting.

Unfortunately, I have no time to finish this review as I go for a long vacation.

But this part made me suspicious as I'm pretty sure we usually don't read Hive this way.
So, I read the Jira ticket itself: https://issues.apache.org/jira/browse/HIVE-28265

My fault, I should start with this one.
Actually, the ticket says the feature itself is already working but we get a wrong error message.

Just thinking out loud:

As I see HiveStatement doesn't contain any reference to Hive Configuration. Creating a hiveConf object is not a top of my mind but I affraid with this way you ignore the actual HiveConf loaded in the Hive Server session. I'm sad that I have no time to debug it out but for me, it looks suspicious.
I bet Hive already has it's method to read the SET ... commands out. As you can see, we have no such (or similar) parsing logic to read the Hive settings but still, if you run a set command, you can easily read the value from HiveConf. It would worth doing a debug session and figuring out how Hive exactly handles session level configurations.
Based on that I would say maybe there is a place where HiveStatement.setQueryTimeout should be called but it is not.

Anyway, good luck with the PR. If you have still have open questions at the end of the next week, I would be happy to help and learn this part of the code.

Copy link
Copy Markdown
Contributor Author

@ashniku ashniku Apr 7, 2026

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

thank you @InvisibleProgrammer This was reproducable.

Could you please let me know any setting or runtime configs, if you feel can fix the issue?

Could you also please let me know, how to refactor? As I am new to the community

I'm sad that I have no time to debug it out but for me, it looks suspicious.

try {
HiveConf conf = new HiveConf();
conf.set(HiveConf.ConfVars.HIVE_QUERY_TIMEOUT_SECONDS.varname, m.group(1).trim());
long sec = HiveConf.getTimeVar(conf, HiveConf.ConfVars.HIVE_QUERY_TIMEOUT_SECONDS, TimeUnit.SECONDS);
lastSec = sec;
} catch (Exception e) {
LOG.debug("Could not parse session query timeout fragment: {}", m.group(0), e);
}
}
if (lastSec != null) {
connection.setSessionQueryTimeoutSeconds(lastSec);
}
}

/**
* HIVE-28265: Prefer server error text unless it is empty or the known-broken "0 seconds" case;
* otherwise derive seconds from JDBC {@link #setQueryTimeout(int)} or last session SET.
*/
private String sqlTimeoutMessageForTimedOutState(String serverMessage) {
if (!needsLocalTimeoutMessageForTimedOut(serverMessage)) {
return stripTrailingQueryIdSuffix(serverMessage);
}
long effectiveSec = resolveEffectiveTimeoutSecondsForMessage();
if (effectiveSec > 0) {
return "Query timed out after " + effectiveSec + " seconds";
}
return "Query timed out";
}

/**
* HS2 wraps many errors via {@link HiveSQLException#getMessage()}, which appends
* {@code ; Query ID: ...}. Strip that trailer so JDBC timeout text stays stable and matches the
* base HS2 wording (HIVE-28265).
*/
private static String stripTrailingQueryIdSuffix(String msg) {
if (msg == null) {
return null;
}
String marker = "; " + HiveSQLException.QUERY_ID + ": ";
int idx = msg.indexOf(marker);
return idx >= 0 ? msg.substring(0, idx) : msg;
}

private boolean needsLocalTimeoutMessageForTimedOut(String timeoutMsg) {
return StringUtils.isBlank(timeoutMsg)
|| StringUtils.containsIgnoreCase(timeoutMsg, "after 0 seconds");
}

private long resolveEffectiveTimeoutSecondsForMessage() {
if (queryTimeout > 0) {
return queryTimeout;
}
long tracked = connection.getSessionQueryTimeoutSeconds();
if (tracked > 0) {
return tracked;
}
return 0L;
}

private SQLException sqlExceptionForCanceledState(TGetOperationStatusResp statusResp) {
final String errMsg = statusResp.getErrorMessage();
final String fullErrMsg =
(errMsg == null || errMsg.isEmpty()) ? QUERY_CANCELLED_MESSAGE : QUERY_CANCELLED_MESSAGE + " " + errMsg;
return new SQLException(fullErrMsg, "01000");
}

TGetOperationStatusResp waitForOperationToComplete() throws SQLException {
TGetOperationStatusResp statusResp = null;

Expand Down Expand Up @@ -436,13 +524,9 @@ TGetOperationStatusResp waitForOperationToComplete() throws SQLException {
isLogBeingGenerated = false;
break;
case CANCELED_STATE:
// 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");
throw sqlExceptionForCanceledState(statusResp);
case TIMEDOUT_STATE:
throw new SQLTimeoutException("Query timed out after " + queryTimeout + " seconds");
throw new SQLTimeoutException(sqlTimeoutMessageForTimedOutState(statusResp.getErrorMessage()));
case ERROR_STATE:
// Get the error details from the underlying exception
throw new SQLException(statusResp.getErrorMessage(), statusResp.getSqlState(),
Expand Down
13 changes: 11 additions & 2 deletions service/src/java/org/apache/hive/service/cli/operation/SQLOperation.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -179,6 +179,11 @@ private void prepare(QueryState queryState) throws HiveSQLException {
try {
final String queryId = queryState.getQueryId();
log.info("Query timed out after: {} seconds. Cancelling the execution now: {}", queryTimeout, queryId);
setOperationException(new HiveSQLException(
"Query timed out after " + queryTimeout + " seconds",
"HYT00",
Copy link
Copy Markdown
Contributor

@InvisibleProgrammer InvisibleProgrammer Apr 7, 2026

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Could you please share some reference to this error code? The closest thing that I have found is a login timeout for SQL Server: https://learn.microsoft.com/en-us/answers/questions/1348638/sql-state-hyt00-sql-error-code-0-login-timeout-exp

Copy link
Copy Markdown
Contributor Author

@ashniku ashniku Apr 7, 2026

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

HYT00 is not a SQL Server–only code. It comes from the ODBC SQLSTATE list. In ODBC 3.x, HYT00 means “Timeout expired” (generic timeout, not specifically “login timeout”). SQL Server’s docs often show up in web search because they map ODBC states, but the same state is used for query / statement timeouts and other “timeout expired” situations when products follow ODBC-style SQLSTATEs.

References:

==> Microsoft’s ODBC appendix lists ODBC error / SQLSTATE codes; HYT00 is documented there in the “Timeout expired” family (see Appendix A: ODBC Error Codes — search the page for HYT00).
==> Broader context: HY = CLI/driver advisory category; T00 = timeout expired in that ODBC mapping (ODBC 2.x S1T00 was aligned to HYT00 in ODBC 3.x per SQLSTATE Mappings).
So Hive reusing HYT00 for query timeout is consistent with “timeout expired” in ODBC/JDBC-style SQLSTATE usage, not an odd SQL Server login-only choice. The Learn article they found is one example of HYT00, not the definition of the code.

0,
queryId));
SQLOperation.this.cancel(OperationState.TIMEDOUT);
} catch (HiveSQLException e) {
log.error("Error cancelling the query after timeout: {} seconds", queryTimeout, e);
Expand Down Expand Up @@ -334,7 +339,9 @@ public Object run() throws HiveSQLException {
runQuery();
} catch (HiveSQLException e) {
// TODO: why do we invent our own error path op top of the one from Future.get?
setOperationException(e);
if (getState() != OperationState.TIMEDOUT) {
setOperationException(e);
}
log.error("Error running hive query", e);
} finally {
if (!embedded) {
Expand All @@ -353,7 +360,9 @@ public Object run() throws HiveSQLException {
try {
currentUGI.doAs(doAsAction);
} catch (Exception e) {
setOperationException(new HiveSQLException(e));
if (getState() != OperationState.TIMEDOUT) {
setOperationException(new HiveSQLException(e));
}
log.error("Error running hive query as user : {}", currentUGI.getShortUserName(), e);
} finally {
/**
Expand Down
Loading