Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* 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.hive.jdbc;
import org.apache.commons.lang3.StringUtils;
import org.apache.hadoop.hive.common.classification.InterfaceAudience.LimitedPrivate;
import org.apache.hadoop.hive.conf.HiveConf;
import org.apache.hive.jdbc.logs.InPlaceUpdateStream;
import org.apache.hive.service.cli.RowSet;
import org.apache.hive.service.cli.RowSetFactory;
import org.apache.hive.service.rpc.thrift.TCLIService;
import org.apache.hive.service.rpc.thrift.TCancelOperationReq;
import org.apache.hive.service.rpc.thrift.TCancelOperationResp;
import org.apache.hive.service.rpc.thrift.TCloseOperationReq;
import org.apache.hive.service.rpc.thrift.TCloseOperationResp;
import org.apache.hive.service.rpc.thrift.TExecuteStatementReq;
import org.apache.hive.service.rpc.thrift.TExecuteStatementResp;
import org.apache.hive.service.rpc.thrift.TFetchOrientation;
import org.apache.hive.service.rpc.thrift.TFetchResultsReq;
import org.apache.hive.service.rpc.thrift.TFetchResultsResp;
import org.apache.hive.service.rpc.thrift.TGetOperationStatusReq;
import org.apache.hive.service.rpc.thrift.TGetOperationStatusResp;
import org.apache.hive.service.rpc.thrift.TGetQueryIdReq;
import org.apache.hive.service.rpc.thrift.TOperationHandle;
import org.apache.hive.service.rpc.thrift.TSessionHandle;
import org.apache.thrift.TApplicationException;
import org.apache.thrift.TException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.sql.SQLTimeoutException;
import java.sql.SQLWarning;
import java.util.ArrayList;
import java.util.Base64;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import static org.apache.hadoop.hive.ql.ErrorMsg.CLIENT_POLLING_OPSTATUS_INTERRUPTED;
/**
* The object used for executing a static SQL statement and returning the
* results it produces.
*/
public class HiveStatement implements java.sql.Statement {
private static final Logger LOG = LoggerFactory.getLogger(HiveStatement.class);
public static final String QUERY_CANCELLED_MESSAGE = "Query was cancelled.";
private static final int DEFAULT_FETCH_SIZE =
HiveConf.ConfVars.HIVE_SERVER2_THRIFT_RESULTSET_DEFAULT_FETCH_SIZE.defaultIntVal;
private final HiveConnection connection;
private TCLIService.Iface client;
private Optional stmtHandle;
private final TSessionHandle sessHandle;
Map sessConf = new HashMap<>();
private int fetchSize;
private final int defaultFetchSize;
private final boolean isScrollableResultset;
private boolean isOperationComplete = false;
private boolean closeOnResultSetCompletion = false;
/**
* We need to keep a reference to the result set to support the following:
*
* statement.execute(String sql);
* statement.getResultSet();
* .
*/
private ResultSet resultSet = null;
/**
* Sets the limit for the maximum number of rows that any ResultSet object produced by this
* Statement can contain to the given number. If the limit is exceeded, the excess rows
* are silently dropped. The value must be >= 0, and 0 means there is not limit.
*/
private int maxRows = 0;
/**
* Add SQLWarnings to the warningChain if needed.
*/
private SQLWarning warningChain = null;
/**
* Keep state so we can fail certain calls made after close().
*/
private boolean isClosed = false;
/**
* Keep state so we can fail certain calls made after cancel().
*/
private boolean isCancelled = false;
/**
* Keep this state so we can know whether the query in this statement is closed.
*/
private boolean isQueryClosed = false;
/**
* Keep this state so we can know whether the query logs are being generated in HS2.
*/
private boolean isLogBeingGenerated = true;
private int queryTimeout = 0;
private Optional inPlaceUpdateStream;
public HiveStatement(HiveConnection connection, TCLIService.Iface client,
TSessionHandle sessHandle) {
this(connection, client, sessHandle, false, 0, DEFAULT_FETCH_SIZE);
}
public HiveStatement(HiveConnection connection, TCLIService.Iface client, TSessionHandle sessHandle,
boolean isScrollableResultset, int initFetchSize, int defaultFetchSize) {
this.connection = Objects.requireNonNull(connection);
this.client = Objects.requireNonNull(client);
this.sessHandle = Objects.requireNonNull(sessHandle);
if (initFetchSize < 0 || defaultFetchSize <= 0) {
throw new IllegalArgumentException();
}
this.isScrollableResultset = isScrollableResultset;
this.defaultFetchSize = defaultFetchSize;
this.fetchSize = (initFetchSize == 0) ? defaultFetchSize : initFetchSize;
this.inPlaceUpdateStream = Optional.empty();
this.stmtHandle = Optional.empty();
}
@Override
public void addBatch(String sql) throws SQLException {
throw new SQLFeatureNotSupportedException("Method not supported");
}
@Override
public void cancel() throws SQLException {
checkConnection("cancel");
if (isCancelled) {
return;
}
try {
if (stmtHandle.isPresent()) {
TCancelOperationReq cancelReq = new TCancelOperationReq(stmtHandle.get());
TCancelOperationResp cancelResp = client.CancelOperation(cancelReq);
Utils.verifySuccessWithInfo(cancelResp.getStatus());
}
} catch (SQLException e) {
throw e;
} catch (Exception e) {
throw new SQLException("Failed to cancel statement", "08S01", e);
}
isCancelled = true;
}
@Override
public void clearBatch() throws SQLException {
throw new SQLFeatureNotSupportedException("Method not supported");
}
@Override
public void clearWarnings() throws SQLException {
warningChain = null;
}
/**
* Closes the statement if there is one running. Do not change the the flags.
* @throws SQLException If there is an error closing the statement
*/
private void closeStatementIfNeeded() throws SQLException {
try {
if (stmtHandle.isPresent()) {
TCloseOperationReq closeReq = new TCloseOperationReq(stmtHandle.get());
TCloseOperationResp closeResp = client.CloseOperation(closeReq);
if (!checkInvalidOperationHandle(closeResp)) {
Utils.verifySuccessWithInfo(closeResp.getStatus());
}
}
} catch (SQLException e) {
throw e;
} catch (TApplicationException tae) {
String errorMsg = "Failed to close statement";
if (tae.getType() == TApplicationException.BAD_SEQUENCE_ID) {
errorMsg = "Failed to close statement. Mismatch thrift sequence id. A previous call to the Thrift library"
+ " failed and now position within the input stream is lost. Please enable verbose error logging and"
+ " check the status of previous calls.";
}
throw new SQLException(errorMsg, "08S01", tae);
} catch (Exception e) {
throw new SQLException("Failed to close statement", "08S01", e);
} finally {
stmtHandle = Optional.empty();
}
}
/**
* Invalid OperationHandle is a special case in HS2, which sometimes could be considered as safe to ignore.
* For instance: if the client retried due to HIVE-24786, and the retried operation happened to be the
* closeOperation, we don't care as the query might have already been removed from HS2's scope.
* @return true, if the response from server contains "Invalid OperationHandle"
*/
private boolean checkInvalidOperationHandle(TCloseOperationResp closeResp) {
List messages = closeResp.getStatus().getInfoMessages();
if (messages != null && messages.size() > 0) {
/*
* Here we need to handle 2 different cases, which can happen in CLIService.closeOperation, which actually does:
* sessionManager.getOperationManager().getOperation(opHandle).getParentSession().closeOperation(opHandle);
*/
String message = messages.get(0);
if (message.contains("Invalid OperationHandle")) {
/*
* This happens when the first request properly removes the operation handle, then second request arrives, calls
* sessionManager.getOperationManager().getOperation(opHandle), and it doesn't find the handle.
*/
LOG.warn("'Invalid OperationHandle' on server side (messages: " + messages + ")");
return true;
} else if (message.contains("Operation does not exist")) {
/*
* This is an extremely rare case, which represents a race condition when the first and second request
* arrives almost at the same time, both can get the OperationHandle instance
* from sessionManager's OperationManager, but the second fails, because it cannot get it again from the
* session's OperationManager, because it has been already removed in the meantime.
*/
LOG.warn("'Operation does not exist' on server side (messages: " + messages + ")");
return true;
}
}
return false;
}
void closeClientOperation() throws SQLException {
try {
closeStatementIfNeeded();
} finally {
isQueryClosed = true;
}
}
void closeOnResultSetCompletion() throws SQLException {
if (closeOnResultSetCompletion) {
resultSet = null;
close();
}
}
@Override
public void close() throws SQLException {
if (isClosed) {
return;
}
closeClientOperation();
client = null;
if (resultSet != null) {
if (!resultSet.isClosed()){
resultSet.close();
}
resultSet = null;
}
isClosed = true;
}
@Override
public void closeOnCompletion() throws SQLException {
closeOnResultSetCompletion = true;
}
@Override
public boolean execute(String sql) throws SQLException {
runAsyncOnServer(sql);
TGetOperationStatusResp status = waitForOperationToComplete();
// The query should be completed by now
if (!status.isHasResultSet() && stmtHandle.isPresent() && !stmtHandle.get().isHasResultSet()) {
return false;
}
resultSet = new HiveQueryResultSet.Builder(this).setClient(client)
.setStmtHandle(stmtHandle.get()).setMaxRows(maxRows).setFetchSize(fetchSize)
.setScrollable(isScrollableResultset)
.build();
return true;
}
/**
* Starts the query execution asynchronously on the server, and immediately returns to the client.
* The client subsequently blocks on ResultSet#next or Statement#getUpdateCount, depending on the
* query type. Users should call ResultSet.next or Statement#getUpdateCount (depending on whether
* query returns results) to ensure that query completes successfully. Calling another execute*
* method, or close before query completion would result in the async query getting killed if it
* is not already finished.
* Note: This method is an API for limited usage outside of Hive by applications like Apache Ambari,
* although it is not part of the interface java.sql.Statement.
*
* @param sql
* @return true if the first result is a ResultSet object; false if it is an update count or there
* are no results
* @throws SQLException
*/
public boolean executeAsync(String sql) throws SQLException {
runAsyncOnServer(sql);
TGetOperationStatusResp status = waitForResultSetStatus();
if (!status.isHasResultSet()) {
return false;
}
resultSet =
new HiveQueryResultSet.Builder(this).setClient(client)
.setStmtHandle(stmtHandle.get()).setMaxRows(maxRows)
.setFetchSize(fetchSize).setScrollable(isScrollableResultset)
.build();
return true;
}
private void runAsyncOnServer(String sql) throws SQLException {
checkConnection("execute");
reInitState();
TExecuteStatementReq execReq = new TExecuteStatementReq(sessHandle, sql);
/**
* Run asynchronously whenever possible
* Currently only a SQLOperation can be run asynchronously,
* in a background operation thread
* Compilation can run asynchronously or synchronously and execution run asynchronously
*/
execReq.setRunAsync(true);
execReq.setConfOverlay(sessConf);
execReq.setQueryTimeout(queryTimeout);
try {
LOG.debug("Submitting statement [{}]: {}", sessHandle, sql);
TExecuteStatementResp execResp = client.ExecuteStatement(execReq);
Utils.verifySuccessWithInfo(execResp.getStatus());
List infoMessages = execResp.getStatus().getInfoMessages();
if (infoMessages != null) {
for (String message : infoMessages) {
LOG.info(message);
}
}
stmtHandle = Optional.of(execResp.getOperationHandle());
LOG.debug("Running with statement handle: {}", stmtHandle.get());
} catch (SQLException eS) {
isLogBeingGenerated = false;
throw eS;
} catch (Exception ex) {
isLogBeingGenerated = false;
throw new SQLException("Failed to run async statement", "08S01", ex);
}
}
/**
* Poll the result set status by checking if isSetHasResultSet is set
* @return
* @throws SQLException
*/
private TGetOperationStatusResp waitForResultSetStatus() throws SQLException {
TGetOperationStatusReq statusReq = new TGetOperationStatusReq(stmtHandle.get());
TGetOperationStatusResp statusResp = null;
while (statusResp == null || !statusResp.isSetHasResultSet()) {
try {
statusResp = client.GetOperationStatus(statusReq);
} catch (TException e) {
isLogBeingGenerated = false;
throw new SQLException("Failed to wait for result set status", "08S01", e);
}
}
return statusResp;
}
TGetOperationStatusResp waitForOperationToComplete() throws SQLException {
TGetOperationStatusResp statusResp = null;
final TGetOperationStatusReq statusReq = new TGetOperationStatusReq(stmtHandle.get());
statusReq.setGetProgressUpdate(inPlaceUpdateStream.isPresent());
// Progress bar is completed if there is nothing to request
if (inPlaceUpdateStream.isPresent()) {
inPlaceUpdateStream.get().getEventNotifier().progressBarCompleted();
}
LOG.debug("Waiting on operation to complete: Polling operation status");
// Poll on the operation status, till the operation is complete
do {
try {
if (Thread.currentThread().isInterrupted()) {
throw new SQLException(CLIENT_POLLING_OPSTATUS_INTERRUPTED.getMsg(),
CLIENT_POLLING_OPSTATUS_INTERRUPTED.getSQLState());
}
/**
* For an async SQLOperation, GetOperationStatus will use the long polling approach It will
* essentially return after the HIVE_SERVER2_LONG_POLLING_TIMEOUT (a server config) expires
*/
statusResp = client.GetOperationStatus(statusReq);
LOG.debug("Status response: {}", statusResp);
if (!isOperationComplete && inPlaceUpdateStream.isPresent()) {
inPlaceUpdateStream.get().update(statusResp.getProgressUpdateResponse());
}
Utils.verifySuccessWithInfo(statusResp.getStatus());
if (statusResp.isSetOperationState()) {
switch (statusResp.getOperationState()) {
case CLOSED_STATE:
case FINISHED_STATE:
isOperationComplete = true;
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");
case TIMEDOUT_STATE:
throw new SQLTimeoutException("Query timed out after " + queryTimeout + " seconds");
case ERROR_STATE:
// Get the error details from the underlying exception
throw new SQLException(statusResp.getErrorMessage(), statusResp.getSqlState(),
statusResp.getErrorCode());
case UKNOWN_STATE:
throw new SQLException("Unknown query", "HY000");
case INITIALIZED_STATE:
case PENDING_STATE:
case RUNNING_STATE:
break;
}
}
} catch (SQLException e) {
isLogBeingGenerated = false;
throw e;
} catch (Exception e) {
isLogBeingGenerated = false;
throw new SQLException("Failed to wait for operation to complete", "08S01", e);
}
} while (!isOperationComplete);
// set progress bar to be completed when hive query execution has completed
if (inPlaceUpdateStream.isPresent()) {
inPlaceUpdateStream.get().getEventNotifier().progressBarCompleted();
}
return statusResp;
}
private void checkConnection(String action) throws SQLException {
if (isClosed) {
throw new SQLException("Cannot " + action + " after statement has been closed");
}
}
/**
* Close statement if needed, and reset the flags.
* @throws SQLException
*/
private void reInitState() throws SQLException {
try {
closeStatementIfNeeded();
} finally {
isCancelled = false;
isQueryClosed = false;
isLogBeingGenerated = true;
isOperationComplete = false;
}
}
@Override
public boolean execute(String sql, int autoGeneratedKeys) throws SQLException {
throw new SQLFeatureNotSupportedException("Method not supported");
}
@Override
public boolean execute(String sql, int[] columnIndexes) throws SQLException {
throw new SQLFeatureNotSupportedException("Method not supported");
}
@Override
public boolean execute(String sql, String[] columnNames) throws SQLException {
throw new SQLFeatureNotSupportedException("Method not supported");
}
@Override
public int[] executeBatch() throws SQLException {
throw new SQLFeatureNotSupportedException("Method not supported");
}
@Override
public ResultSet executeQuery(String sql) throws SQLException {
if (!execute(sql)) {
throw new SQLException("The query did not generate a result set");
}
return resultSet;
}
@Override
public int executeUpdate(String sql) throws SQLException {
execute(sql);
return getUpdateCount();
}
@Override
public int executeUpdate(String sql, int autoGeneratedKeys) throws SQLException {
throw new SQLFeatureNotSupportedException("Method not supported");
}
@Override
public int executeUpdate(String sql, int[] columnIndexes) throws SQLException {
throw new SQLFeatureNotSupportedException("Method not supported");
}
@Override
public int executeUpdate(String sql, String[] columnNames) throws SQLException {
throw new SQLFeatureNotSupportedException("Method not supported");
}
@Override
public Connection getConnection() throws SQLException {
checkConnection("getConnection");
return this.connection;
}
@Override
public int getFetchDirection() throws SQLException {
checkConnection("getFetchDirection");
return ResultSet.FETCH_FORWARD;
}
@Override
public int getFetchSize() throws SQLException {
checkConnection("getFetchSize");
return fetchSize;
}
@Override
public ResultSet getGeneratedKeys() throws SQLException {
throw new SQLFeatureNotSupportedException("Method not supported");
}
@Override
public int getMaxFieldSize() throws SQLException {
throw new SQLFeatureNotSupportedException("Method not supported");
}
@Override
public int getMaxRows() throws SQLException {
checkConnection("getMaxRows");
return maxRows;
}
@Override
public boolean getMoreResults() throws SQLException {
return false;
}
@Override
public boolean getMoreResults(int current) throws SQLException {
throw new SQLFeatureNotSupportedException("Method not supported");
}
@Override
public int getQueryTimeout() throws SQLException {
checkConnection("getQueryTimeout");
return this.queryTimeout;
}
@Override
public ResultSet getResultSet() throws SQLException {
checkConnection("getResultSet");
return resultSet;
}
@Override
public int getResultSetConcurrency() throws SQLException {
throw new SQLFeatureNotSupportedException("Method not supported");
}
@Override
public int getResultSetHoldability() throws SQLException {
throw new SQLFeatureNotSupportedException("Method not supported");
}
@Override
public int getResultSetType() throws SQLException {
checkConnection("getResultSetType");
return ResultSet.TYPE_FORWARD_ONLY;
}
@Override
public int getUpdateCount() throws SQLException {
checkConnection("getUpdateCount");
/**
* Poll on the operation status, till the operation is complete. We want to ensure that since a
* client might end up using executeAsync and then call this to check if the query run is
* finished.
*/
long numModifiedRows = -1L;
TGetOperationStatusResp resp = waitForOperationToComplete();
if (resp != null) {
numModifiedRows = resp.getNumModifiedRows();
}
if (numModifiedRows == -1L || numModifiedRows > Integer.MAX_VALUE) {
LOG.warn("Invalid number of updated rows: {}", numModifiedRows);
return -1;
}
return (int) numModifiedRows;
}
@Override
public SQLWarning getWarnings() throws SQLException {
checkConnection("getWarnings");
return warningChain;
}
@Override
public boolean isClosed() throws SQLException {
return isClosed;
}
public boolean isQueryClosed() throws SQLException {
return isQueryClosed;
}
@Override
public boolean isCloseOnCompletion() throws SQLException {
return closeOnResultSetCompletion;
}
@Override
public boolean isPoolable() throws SQLException {
return false;
}
@Override
public void setCursorName(String name) throws SQLException {
throw new SQLFeatureNotSupportedException("Method not supported");
}
@Override
public void setEscapeProcessing(boolean enable) throws SQLException {
if (enable) {
throw new SQLFeatureNotSupportedException("Method not supported");
}
}
@Override
public void setFetchDirection(int direction) throws SQLException {
checkConnection("setFetchDirection");
if (direction != ResultSet.FETCH_FORWARD) {
throw new SQLException("Not supported direction: " + direction);
}
}
@Override
public void setFetchSize(int rows) throws SQLException {
checkConnection("setFetchSize");
if (rows > 0) {
this.fetchSize = rows;
} else if (rows == 0) {
this.fetchSize = this.defaultFetchSize;
} else {
throw new SQLException("Fetch size must be greater or equal to 0");
}
}
@Override
public void setMaxFieldSize(int max) throws SQLException {
throw new SQLFeatureNotSupportedException("Method not supported");
}
@Override
public void setMaxRows(int max) throws SQLException {
checkConnection("setMaxRows");
if (max < 0) {
throw new SQLException("Maximum number of rows must be >= 0");
}
maxRows = max;
}
@Override
public void setPoolable(boolean poolable) throws SQLException {
throw new SQLFeatureNotSupportedException("Method not supported");
}
@Override
public void setQueryTimeout(int seconds) throws SQLException {
this.queryTimeout = seconds;
}
@Override
public boolean isWrapperFor(Class iface) throws SQLException {
return false;
}
@Override
public T unwrap(Class iface) throws SQLException {
throw new SQLException("Cannot unwrap to " + iface);
}
/**
* Check whether query execution might be producing more logs to be fetched.
* This method is a public API for usage outside of Hive, although it is not part of the
* interface java.sql.Statement.
* @return true if query execution might be producing more logs. It does not indicate if last
* log lines have been fetched by getQueryLog.
*/
public boolean hasMoreLogs() {
return isLogBeingGenerated;
}
/**
* Get the execution logs of the given SQL statement.
* This method is a public API for usage outside of Hive, although it is not part of the
* interface java.sql.Statement.
* This method gets the incremental logs during SQL execution, and uses fetchSize holden by
* HiveStatement object.
* @return a list of logs. It can be empty if there are no new logs to be retrieved at that time.
* @throws SQLException
* @throws ClosedOrCancelledStatementException if statement has been cancelled or closed
*/
public List getQueryLog() throws SQLException, ClosedOrCancelledStatementException {
return getQueryLog(true, fetchSize);
}
/**
* Get the execution logs of the given SQL statement.
* This method is a public API for usage outside of Hive, although it is not part of the
* interface java.sql.Statement.
* @param incremental indicate getting logs either incrementally or from the beginning,
* when it is true or false.
* @param fetchSize the number of lines to fetch
* @return a list of logs. It can be empty if there are no new logs to be retrieved at that time.
* @throws SQLException
* @throws ClosedOrCancelledStatementException if statement has been cancelled or closed
*/
public List getQueryLog(boolean incremental, int fetchSize)
throws SQLException, ClosedOrCancelledStatementException {
checkConnection("getQueryLog");
if (isCancelled) {
throw new ClosedOrCancelledStatementException("Method getQueryLog() failed. The " +
"statement has been closed or cancelled.");
}
TFetchResultsResp tFetchResultsResp = null;
try {
if (stmtHandle.isPresent()) {
TFetchResultsReq tFetchResultsReq = new TFetchResultsReq(stmtHandle.get(),
getFetchOrientation(incremental), fetchSize);
tFetchResultsReq.setFetchType((short)1);
tFetchResultsResp = client.FetchResults(tFetchResultsReq);
Utils.verifySuccessWithInfo(tFetchResultsResp.getStatus());
} else {
if (isQueryClosed) {
throw new ClosedOrCancelledStatementException("Method getQueryLog() failed. The " +
"statement has been closed or cancelled.");
} else {
return Collections.emptyList();
}
}
} catch (SQLException e) {
throw e;
} catch (Exception e) {
throw new SQLException("Error when getting query log", e);
}
final List logs = new ArrayList<>();
try {
final RowSet rowSet = RowSetFactory.create(tFetchResultsResp.getResults(), connection.getProtocol());
for (Object[] row : rowSet) {
logs.add(String.valueOf(row[0]));
}
} catch (TException e) {
throw new SQLException("Error building result set for query log", e);
}
return Collections.unmodifiableList(logs);
}
private TFetchOrientation getFetchOrientation(boolean incremental) {
return (incremental) ? TFetchOrientation.FETCH_NEXT : TFetchOrientation.FETCH_FIRST;
}
/**
* Returns the Yarn ATS GUID.
* This method is a public API for usage outside of Hive, although it is not part of the
* interface java.sql.Statement.
* @return Yarn ATS GUID or null if it hasn't been created yet.
*/
public String getYarnATSGuid() {
// Set on the server side.
// @see org.apache.hive.service.cli.operation.SQLOperation#prepare
return (stmtHandle.isPresent())
? Base64.getUrlEncoder().withoutPadding().encodeToString(stmtHandle.get().getOperationId().getGuid())
: null;
}
/**
* This is only used by the beeline client to set the stream on which in place
* progress updates are to be shown.
*/
public void setInPlaceUpdateStream(InPlaceUpdateStream stream) {
this.inPlaceUpdateStream = Optional.ofNullable(stream);
}
/**
* Returns the Query ID if it is running. This method is a public API for
* usage outside of Hive, although it is not part of the interface
* java.sql.Statement.
*
* @return Valid query ID if it is running else returns NULL.
* @throws SQLException If any internal failures.
*/
@LimitedPrivate(value={"Hive and closely related projects."})
public String getQueryId() throws SQLException {
// Storing it in temp variable as this method is not thread-safe and concurrent thread can
// close this handle and set it to null after checking for null.
TOperationHandle stmtHandleTmp = stmtHandle.orElse(null);
if (stmtHandleTmp == null) {
// If query is not running or already closed.
return null;
}
try {
final String queryId = client.GetQueryId(new TGetQueryIdReq(stmtHandleTmp)).getQueryId();
// queryId can be empty string if query was already closed. Need to return null in such case.
return StringUtils.isBlank(queryId) ? null : queryId;
} catch (TException e) {
throw new SQLException(e);
}
}
}
