You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by th...@apache.org on 2017/09/26 21:04:32 UTC
[2/3] hive git commit: HIVE-17483 : HS2 kill command to kill queries
using query id (Teddy Choi, reviewed by Thejas Nair )
http://git-wip-us.apache.org/repos/asf/hive/blob/2d698b67/service-rpc/src/gen/thrift/gen-cpp/TCLIService_types.cpp
----------------------------------------------------------------------
diff --git a/service-rpc/src/gen/thrift/gen-cpp/TCLIService_types.cpp b/service-rpc/src/gen/thrift/gen-cpp/TCLIService_types.cpp
index ec3f066..d8c01b6 100644
--- a/service-rpc/src/gen/thrift/gen-cpp/TCLIService_types.cpp
+++ b/service-rpc/src/gen/thrift/gen-cpp/TCLIService_types.cpp
@@ -10312,4 +10312,176 @@ void TProgressUpdateResp::printTo(std::ostream& out) const {
out << ")";
}
+
+TGetQueryIdReq::~TGetQueryIdReq() throw() {
+}
+
+
+void TGetQueryIdReq::__set_operationHandle(const TOperationHandle& val) {
+ this->operationHandle = val;
+}
+
+uint32_t TGetQueryIdReq::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_operationHandle = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->operationHandle.read(iprot);
+ isset_operationHandle = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_operationHandle)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t TGetQueryIdReq::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("TGetQueryIdReq");
+
+ xfer += oprot->writeFieldBegin("operationHandle", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->operationHandle.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TGetQueryIdReq &a, TGetQueryIdReq &b) {
+ using ::std::swap;
+ swap(a.operationHandle, b.operationHandle);
+}
+
+TGetQueryIdReq::TGetQueryIdReq(const TGetQueryIdReq& other323) {
+ operationHandle = other323.operationHandle;
+}
+TGetQueryIdReq& TGetQueryIdReq::operator=(const TGetQueryIdReq& other324) {
+ operationHandle = other324.operationHandle;
+ return *this;
+}
+void TGetQueryIdReq::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "TGetQueryIdReq(";
+ out << "operationHandle=" << to_string(operationHandle);
+ out << ")";
+}
+
+
+TGetQueryIdResp::~TGetQueryIdResp() throw() {
+}
+
+
+void TGetQueryIdResp::__set_queryId(const std::string& val) {
+ this->queryId = val;
+}
+
+uint32_t TGetQueryIdResp::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_queryId = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->queryId);
+ isset_queryId = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_queryId)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t TGetQueryIdResp::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("TGetQueryIdResp");
+
+ xfer += oprot->writeFieldBegin("queryId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->queryId);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TGetQueryIdResp &a, TGetQueryIdResp &b) {
+ using ::std::swap;
+ swap(a.queryId, b.queryId);
+}
+
+TGetQueryIdResp::TGetQueryIdResp(const TGetQueryIdResp& other325) {
+ queryId = other325.queryId;
+}
+TGetQueryIdResp& TGetQueryIdResp::operator=(const TGetQueryIdResp& other326) {
+ queryId = other326.queryId;
+ return *this;
+}
+void TGetQueryIdResp::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "TGetQueryIdResp(";
+ out << "queryId=" << to_string(queryId);
+ out << ")";
+}
+
}}}}} // namespace
http://git-wip-us.apache.org/repos/asf/hive/blob/2d698b67/service-rpc/src/gen/thrift/gen-cpp/TCLIService_types.h
----------------------------------------------------------------------
diff --git a/service-rpc/src/gen/thrift/gen-cpp/TCLIService_types.h b/service-rpc/src/gen/thrift/gen-cpp/TCLIService_types.h
index cb62db0..30a771d 100644
--- a/service-rpc/src/gen/thrift/gen-cpp/TCLIService_types.h
+++ b/service-rpc/src/gen/thrift/gen-cpp/TCLIService_types.h
@@ -354,6 +354,10 @@ class TRenewDelegationTokenResp;
class TProgressUpdateResp;
+class TGetQueryIdReq;
+
+class TGetQueryIdResp;
+
typedef struct _TTypeQualifierValue__isset {
_TTypeQualifierValue__isset() : i32Value(false), stringValue(false) {}
bool i32Value :1;
@@ -4571,6 +4575,86 @@ inline std::ostream& operator<<(std::ostream& out, const TProgressUpdateResp& ob
return out;
}
+
+class TGetQueryIdReq {
+ public:
+
+ TGetQueryIdReq(const TGetQueryIdReq&);
+ TGetQueryIdReq& operator=(const TGetQueryIdReq&);
+ TGetQueryIdReq() {
+ }
+
+ virtual ~TGetQueryIdReq() throw();
+ TOperationHandle operationHandle;
+
+ void __set_operationHandle(const TOperationHandle& val);
+
+ bool operator == (const TGetQueryIdReq & rhs) const
+ {
+ if (!(operationHandle == rhs.operationHandle))
+ return false;
+ return true;
+ }
+ bool operator != (const TGetQueryIdReq &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const TGetQueryIdReq & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+ virtual void printTo(std::ostream& out) const;
+};
+
+void swap(TGetQueryIdReq &a, TGetQueryIdReq &b);
+
+inline std::ostream& operator<<(std::ostream& out, const TGetQueryIdReq& obj)
+{
+ obj.printTo(out);
+ return out;
+}
+
+
+class TGetQueryIdResp {
+ public:
+
+ TGetQueryIdResp(const TGetQueryIdResp&);
+ TGetQueryIdResp& operator=(const TGetQueryIdResp&);
+ TGetQueryIdResp() : queryId() {
+ }
+
+ virtual ~TGetQueryIdResp() throw();
+ std::string queryId;
+
+ void __set_queryId(const std::string& val);
+
+ bool operator == (const TGetQueryIdResp & rhs) const
+ {
+ if (!(queryId == rhs.queryId))
+ return false;
+ return true;
+ }
+ bool operator != (const TGetQueryIdResp &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const TGetQueryIdResp & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+ virtual void printTo(std::ostream& out) const;
+};
+
+void swap(TGetQueryIdResp &a, TGetQueryIdResp &b);
+
+inline std::ostream& operator<<(std::ostream& out, const TGetQueryIdResp& obj)
+{
+ obj.printTo(out);
+ return out;
+}
+
}}}}} // namespace
#endif
http://git-wip-us.apache.org/repos/asf/hive/blob/2d698b67/service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TCLIService.java
----------------------------------------------------------------------
diff --git a/service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TCLIService.java b/service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TCLIService.java
index 6dba051..2f44a4f 100644
--- a/service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TCLIService.java
+++ b/service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TCLIService.java
@@ -81,6 +81,8 @@ public class TCLIService {
public TRenewDelegationTokenResp RenewDelegationToken(TRenewDelegationTokenReq req) throws org.apache.thrift.TException;
+ public TGetQueryIdResp GetQueryId(TGetQueryIdReq req) throws org.apache.thrift.TException;
+
}
public interface AsyncIface {
@@ -127,6 +129,8 @@ public class TCLIService {
public void RenewDelegationToken(TRenewDelegationTokenReq req, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException;
+ public void GetQueryId(TGetQueryIdReq req, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException;
+
}
public static class Client extends org.apache.thrift.TServiceClient implements Iface {
@@ -632,6 +636,29 @@ public class TCLIService {
throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "RenewDelegationToken failed: unknown result");
}
+ public TGetQueryIdResp GetQueryId(TGetQueryIdReq req) throws org.apache.thrift.TException
+ {
+ send_GetQueryId(req);
+ return recv_GetQueryId();
+ }
+
+ public void send_GetQueryId(TGetQueryIdReq req) throws org.apache.thrift.TException
+ {
+ GetQueryId_args args = new GetQueryId_args();
+ args.setReq(req);
+ sendBase("GetQueryId", args);
+ }
+
+ public TGetQueryIdResp recv_GetQueryId() throws org.apache.thrift.TException
+ {
+ GetQueryId_result result = new GetQueryId_result();
+ receiveBase(result, "GetQueryId");
+ if (result.isSetSuccess()) {
+ return result.success;
+ }
+ throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "GetQueryId failed: unknown result");
+ }
+
}
public static class AsyncClient extends org.apache.thrift.async.TAsyncClient implements AsyncIface {
public static class Factory implements org.apache.thrift.async.TAsyncClientFactory<AsyncClient> {
@@ -1322,6 +1349,38 @@ public class TCLIService {
}
}
+ public void GetQueryId(TGetQueryIdReq req, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException {
+ checkReady();
+ GetQueryId_call method_call = new GetQueryId_call(req, resultHandler, this, ___protocolFactory, ___transport);
+ this.___currentMethod = method_call;
+ ___manager.call(method_call);
+ }
+
+ public static class GetQueryId_call extends org.apache.thrift.async.TAsyncMethodCall {
+ private TGetQueryIdReq req;
+ public GetQueryId_call(TGetQueryIdReq req, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+ super(client, protocolFactory, transport, resultHandler, false);
+ this.req = req;
+ }
+
+ public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+ prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("GetQueryId", org.apache.thrift.protocol.TMessageType.CALL, 0));
+ GetQueryId_args args = new GetQueryId_args();
+ args.setReq(req);
+ args.write(prot);
+ prot.writeMessageEnd();
+ }
+
+ public TGetQueryIdResp getResult() throws org.apache.thrift.TException {
+ if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+ throw new IllegalStateException("Method call not finished!");
+ }
+ org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+ org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+ return (new Client(prot)).recv_GetQueryId();
+ }
+ }
+
}
public static class Processor<I extends Iface> extends org.apache.thrift.TBaseProcessor<I> implements org.apache.thrift.TProcessor {
@@ -1356,6 +1415,7 @@ public class TCLIService {
processMap.put("GetDelegationToken", new GetDelegationToken());
processMap.put("CancelDelegationToken", new CancelDelegationToken());
processMap.put("RenewDelegationToken", new RenewDelegationToken());
+ processMap.put("GetQueryId", new GetQueryId());
return processMap;
}
@@ -1779,6 +1839,26 @@ public class TCLIService {
}
}
+ public static class GetQueryId<I extends Iface> extends org.apache.thrift.ProcessFunction<I, GetQueryId_args> {
+ public GetQueryId() {
+ super("GetQueryId");
+ }
+
+ public GetQueryId_args getEmptyArgsInstance() {
+ return new GetQueryId_args();
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public GetQueryId_result getResult(I iface, GetQueryId_args args) throws org.apache.thrift.TException {
+ GetQueryId_result result = new GetQueryId_result();
+ result.success = iface.GetQueryId(args.req);
+ return result;
+ }
+ }
+
}
public static class AsyncProcessor<I extends AsyncIface> extends org.apache.thrift.TBaseAsyncProcessor<I> {
@@ -1813,6 +1893,7 @@ public class TCLIService {
processMap.put("GetDelegationToken", new GetDelegationToken());
processMap.put("CancelDelegationToken", new CancelDelegationToken());
processMap.put("RenewDelegationToken", new RenewDelegationToken());
+ processMap.put("GetQueryId", new GetQueryId());
return processMap;
}
@@ -2887,6 +2968,57 @@ public class TCLIService {
}
}
+ public static class GetQueryId<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, GetQueryId_args, TGetQueryIdResp> {
+ public GetQueryId() {
+ super("GetQueryId");
+ }
+
+ public GetQueryId_args getEmptyArgsInstance() {
+ return new GetQueryId_args();
+ }
+
+ public AsyncMethodCallback<TGetQueryIdResp> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
+ final org.apache.thrift.AsyncProcessFunction fcall = this;
+ return new AsyncMethodCallback<TGetQueryIdResp>() {
+ public void onComplete(TGetQueryIdResp o) {
+ GetQueryId_result result = new GetQueryId_result();
+ result.success = o;
+ try {
+ fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
+ return;
+ } catch (Exception e) {
+ LOGGER.error("Exception writing to internal frame buffer", e);
+ }
+ fb.close();
+ }
+ public void onError(Exception e) {
+ byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
+ org.apache.thrift.TBase msg;
+ GetQueryId_result result = new GetQueryId_result();
+ {
+ msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
+ msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
+ }
+ try {
+ fcall.sendResponse(fb,msg,msgType,seqid);
+ return;
+ } catch (Exception ex) {
+ LOGGER.error("Exception writing to internal frame buffer", ex);
+ }
+ fb.close();
+ }
+ };
+ }
+
+ protected boolean isOneway() {
+ return false;
+ }
+
+ public void start(I iface, GetQueryId_args args, org.apache.thrift.async.AsyncMethodCallback<TGetQueryIdResp> resultHandler) throws TException {
+ iface.GetQueryId(args.req,resultHandler);
+ }
+ }
+
}
public static class OpenSession_args implements org.apache.thrift.TBase<OpenSession_args, OpenSession_args._Fields>, java.io.Serializable, Cloneable, Comparable<OpenSession_args> {
@@ -18135,4 +18267,730 @@ public class TCLIService {
}
+ public static class GetQueryId_args implements org.apache.thrift.TBase<GetQueryId_args, GetQueryId_args._Fields>, java.io.Serializable, Cloneable, Comparable<GetQueryId_args> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("GetQueryId_args");
+
+ private static final org.apache.thrift.protocol.TField REQ_FIELD_DESC = new org.apache.thrift.protocol.TField("req", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+
+ private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
+ static {
+ schemes.put(StandardScheme.class, new GetQueryId_argsStandardSchemeFactory());
+ schemes.put(TupleScheme.class, new GetQueryId_argsTupleSchemeFactory());
+ }
+
+ private TGetQueryIdReq req; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ REQ((short)1, "req");
+
+ private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+
+ static {
+ for (_Fields field : EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // REQ
+ return REQ;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ public static _Fields findByName(String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final String _fieldName;
+
+ _Fields(short thriftId, String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.REQ, new org.apache.thrift.meta_data.FieldMetaData("req", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TGetQueryIdReq.class)));
+ metaDataMap = Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(GetQueryId_args.class, metaDataMap);
+ }
+
+ public GetQueryId_args() {
+ }
+
+ public GetQueryId_args(
+ TGetQueryIdReq req)
+ {
+ this();
+ this.req = req;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public GetQueryId_args(GetQueryId_args other) {
+ if (other.isSetReq()) {
+ this.req = new TGetQueryIdReq(other.req);
+ }
+ }
+
+ public GetQueryId_args deepCopy() {
+ return new GetQueryId_args(this);
+ }
+
+ @Override
+ public void clear() {
+ this.req = null;
+ }
+
+ public TGetQueryIdReq getReq() {
+ return this.req;
+ }
+
+ public void setReq(TGetQueryIdReq req) {
+ this.req = req;
+ }
+
+ public void unsetReq() {
+ this.req = null;
+ }
+
+ /** Returns true if field req is set (has been assigned a value) and false otherwise */
+ public boolean isSetReq() {
+ return this.req != null;
+ }
+
+ public void setReqIsSet(boolean value) {
+ if (!value) {
+ this.req = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, Object value) {
+ switch (field) {
+ case REQ:
+ if (value == null) {
+ unsetReq();
+ } else {
+ setReq((TGetQueryIdReq)value);
+ }
+ break;
+
+ }
+ }
+
+ public Object getFieldValue(_Fields field) {
+ switch (field) {
+ case REQ:
+ return getReq();
+
+ }
+ throw new IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new IllegalArgumentException();
+ }
+
+ switch (field) {
+ case REQ:
+ return isSetReq();
+ }
+ throw new IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(Object that) {
+ if (that == null)
+ return false;
+ if (that instanceof GetQueryId_args)
+ return this.equals((GetQueryId_args)that);
+ return false;
+ }
+
+ public boolean equals(GetQueryId_args that) {
+ if (that == null)
+ return false;
+
+ boolean this_present_req = true && this.isSetReq();
+ boolean that_present_req = true && that.isSetReq();
+ if (this_present_req || that_present_req) {
+ if (!(this_present_req && that_present_req))
+ return false;
+ if (!this.req.equals(that.req))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ List<Object> list = new ArrayList<Object>();
+
+ boolean present_req = true && (isSetReq());
+ list.add(present_req);
+ if (present_req)
+ list.add(req);
+
+ return list.hashCode();
+ }
+
+ @Override
+ public int compareTo(GetQueryId_args other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = Boolean.valueOf(isSetReq()).compareTo(other.isSetReq());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetReq()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.req, other.req);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder("GetQueryId_args(");
+ boolean first = true;
+
+ sb.append("req:");
+ if (this.req == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.req);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ if (req != null) {
+ req.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class GetQueryId_argsStandardSchemeFactory implements SchemeFactory {
+ public GetQueryId_argsStandardScheme getScheme() {
+ return new GetQueryId_argsStandardScheme();
+ }
+ }
+
+ private static class GetQueryId_argsStandardScheme extends StandardScheme<GetQueryId_args> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, GetQueryId_args struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // REQ
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.req = new TGetQueryIdReq();
+ struct.req.read(iprot);
+ struct.setReqIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, GetQueryId_args struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.req != null) {
+ oprot.writeFieldBegin(REQ_FIELD_DESC);
+ struct.req.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class GetQueryId_argsTupleSchemeFactory implements SchemeFactory {
+ public GetQueryId_argsTupleScheme getScheme() {
+ return new GetQueryId_argsTupleScheme();
+ }
+ }
+
+ private static class GetQueryId_argsTupleScheme extends TupleScheme<GetQueryId_args> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, GetQueryId_args struct) throws org.apache.thrift.TException {
+ TTupleProtocol oprot = (TTupleProtocol) prot;
+ BitSet optionals = new BitSet();
+ if (struct.isSetReq()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetReq()) {
+ struct.req.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, GetQueryId_args struct) throws org.apache.thrift.TException {
+ TTupleProtocol iprot = (TTupleProtocol) prot;
+ BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.req = new TGetQueryIdReq();
+ struct.req.read(iprot);
+ struct.setReqIsSet(true);
+ }
+ }
+ }
+
+ }
+
+ public static class GetQueryId_result implements org.apache.thrift.TBase<GetQueryId_result, GetQueryId_result._Fields>, java.io.Serializable, Cloneable, Comparable<GetQueryId_result> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("GetQueryId_result");
+
+ private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0);
+
+ private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
+ static {
+ schemes.put(StandardScheme.class, new GetQueryId_resultStandardSchemeFactory());
+ schemes.put(TupleScheme.class, new GetQueryId_resultTupleSchemeFactory());
+ }
+
+ private TGetQueryIdResp success; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ SUCCESS((short)0, "success");
+
+ private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+
+ static {
+ for (_Fields field : EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 0: // SUCCESS
+ return SUCCESS;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ public static _Fields findByName(String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final String _fieldName;
+
+ _Fields(short thriftId, String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TGetQueryIdResp.class)));
+ metaDataMap = Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(GetQueryId_result.class, metaDataMap);
+ }
+
+ public GetQueryId_result() {
+ }
+
+ public GetQueryId_result(
+ TGetQueryIdResp success)
+ {
+ this();
+ this.success = success;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public GetQueryId_result(GetQueryId_result other) {
+ if (other.isSetSuccess()) {
+ this.success = new TGetQueryIdResp(other.success);
+ }
+ }
+
+ public GetQueryId_result deepCopy() {
+ return new GetQueryId_result(this);
+ }
+
+ @Override
+ public void clear() {
+ this.success = null;
+ }
+
+ public TGetQueryIdResp getSuccess() {
+ return this.success;
+ }
+
+ public void setSuccess(TGetQueryIdResp success) {
+ this.success = success;
+ }
+
+ public void unsetSuccess() {
+ this.success = null;
+ }
+
+ /** Returns true if field success is set (has been assigned a value) and false otherwise */
+ public boolean isSetSuccess() {
+ return this.success != null;
+ }
+
+ public void setSuccessIsSet(boolean value) {
+ if (!value) {
+ this.success = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, Object value) {
+ switch (field) {
+ case SUCCESS:
+ if (value == null) {
+ unsetSuccess();
+ } else {
+ setSuccess((TGetQueryIdResp)value);
+ }
+ break;
+
+ }
+ }
+
+ public Object getFieldValue(_Fields field) {
+ switch (field) {
+ case SUCCESS:
+ return getSuccess();
+
+ }
+ throw new IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new IllegalArgumentException();
+ }
+
+ switch (field) {
+ case SUCCESS:
+ return isSetSuccess();
+ }
+ throw new IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(Object that) {
+ if (that == null)
+ return false;
+ if (that instanceof GetQueryId_result)
+ return this.equals((GetQueryId_result)that);
+ return false;
+ }
+
+ public boolean equals(GetQueryId_result that) {
+ if (that == null)
+ return false;
+
+ boolean this_present_success = true && this.isSetSuccess();
+ boolean that_present_success = true && that.isSetSuccess();
+ if (this_present_success || that_present_success) {
+ if (!(this_present_success && that_present_success))
+ return false;
+ if (!this.success.equals(that.success))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ List<Object> list = new ArrayList<Object>();
+
+ boolean present_success = true && (isSetSuccess());
+ list.add(present_success);
+ if (present_success)
+ list.add(success);
+
+ return list.hashCode();
+ }
+
+ @Override
+ public int compareTo(GetQueryId_result other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(other.isSetSuccess());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetSuccess()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder("GetQueryId_result(");
+ boolean first = true;
+
+ sb.append("success:");
+ if (this.success == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.success);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ // check for sub-struct validity
+ if (success != null) {
+ success.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class GetQueryId_resultStandardSchemeFactory implements SchemeFactory {
+ public GetQueryId_resultStandardScheme getScheme() {
+ return new GetQueryId_resultStandardScheme();
+ }
+ }
+
+ private static class GetQueryId_resultStandardScheme extends StandardScheme<GetQueryId_result> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, GetQueryId_result struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 0: // SUCCESS
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.success = new TGetQueryIdResp();
+ struct.success.read(iprot);
+ struct.setSuccessIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, GetQueryId_result struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.success != null) {
+ oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+ struct.success.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class GetQueryId_resultTupleSchemeFactory implements SchemeFactory {
+ public GetQueryId_resultTupleScheme getScheme() {
+ return new GetQueryId_resultTupleScheme();
+ }
+ }
+
+ private static class GetQueryId_resultTupleScheme extends TupleScheme<GetQueryId_result> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, GetQueryId_result struct) throws org.apache.thrift.TException {
+ TTupleProtocol oprot = (TTupleProtocol) prot;
+ BitSet optionals = new BitSet();
+ if (struct.isSetSuccess()) {
+ optionals.set(0);
+ }
+ oprot.writeBitSet(optionals, 1);
+ if (struct.isSetSuccess()) {
+ struct.success.write(oprot);
+ }
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, GetQueryId_result struct) throws org.apache.thrift.TException {
+ TTupleProtocol iprot = (TTupleProtocol) prot;
+ BitSet incoming = iprot.readBitSet(1);
+ if (incoming.get(0)) {
+ struct.success = new TGetQueryIdResp();
+ struct.success.read(iprot);
+ struct.setSuccessIsSet(true);
+ }
+ }
+ }
+
+ }
+
}
http://git-wip-us.apache.org/repos/asf/hive/blob/2d698b67/service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TGetQueryIdReq.java
----------------------------------------------------------------------
diff --git a/service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TGetQueryIdReq.java b/service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TGetQueryIdReq.java
new file mode 100644
index 0000000..bc904f1
--- /dev/null
+++ b/service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TGetQueryIdReq.java
@@ -0,0 +1,394 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.3)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hive.service.rpc.thrift;
+
+import org.apache.thrift.scheme.IScheme;
+import org.apache.thrift.scheme.SchemeFactory;
+import org.apache.thrift.scheme.StandardScheme;
+
+import org.apache.thrift.scheme.TupleScheme;
+import org.apache.thrift.protocol.TTupleProtocol;
+import org.apache.thrift.protocol.TProtocolException;
+import org.apache.thrift.EncodingUtils;
+import org.apache.thrift.TException;
+import org.apache.thrift.async.AsyncMethodCallback;
+import org.apache.thrift.server.AbstractNonblockingServer.*;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.EnumMap;
+import java.util.Set;
+import java.util.HashSet;
+import java.util.EnumSet;
+import java.util.Collections;
+import java.util.BitSet;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import javax.annotation.Generated;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"})
+@Generated(value = "Autogenerated by Thrift Compiler (0.9.3)")
+public class TGetQueryIdReq implements org.apache.thrift.TBase<TGetQueryIdReq, TGetQueryIdReq._Fields>, java.io.Serializable, Cloneable, Comparable<TGetQueryIdReq> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TGetQueryIdReq");
+
+ private static final org.apache.thrift.protocol.TField OPERATION_HANDLE_FIELD_DESC = new org.apache.thrift.protocol.TField("operationHandle", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+
+ private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
+ static {
+ schemes.put(StandardScheme.class, new TGetQueryIdReqStandardSchemeFactory());
+ schemes.put(TupleScheme.class, new TGetQueryIdReqTupleSchemeFactory());
+ }
+
+ private TOperationHandle operationHandle; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ OPERATION_HANDLE((short)1, "operationHandle");
+
+ private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+
+ static {
+ for (_Fields field : EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // OPERATION_HANDLE
+ return OPERATION_HANDLE;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ public static _Fields findByName(String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final String _fieldName;
+
+ _Fields(short thriftId, String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.OPERATION_HANDLE, new org.apache.thrift.meta_data.FieldMetaData("operationHandle", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TOperationHandle.class)));
+ metaDataMap = Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TGetQueryIdReq.class, metaDataMap);
+ }
+
+ public TGetQueryIdReq() {
+ }
+
+ public TGetQueryIdReq(
+ TOperationHandle operationHandle)
+ {
+ this();
+ this.operationHandle = operationHandle;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public TGetQueryIdReq(TGetQueryIdReq other) {
+ if (other.isSetOperationHandle()) {
+ this.operationHandle = new TOperationHandle(other.operationHandle);
+ }
+ }
+
+ public TGetQueryIdReq deepCopy() {
+ return new TGetQueryIdReq(this);
+ }
+
+ @Override
+ public void clear() {
+ this.operationHandle = null;
+ }
+
+ public TOperationHandle getOperationHandle() {
+ return this.operationHandle;
+ }
+
+ public void setOperationHandle(TOperationHandle operationHandle) {
+ this.operationHandle = operationHandle;
+ }
+
+ public void unsetOperationHandle() {
+ this.operationHandle = null;
+ }
+
+ /** Returns true if field operationHandle is set (has been assigned a value) and false otherwise */
+ public boolean isSetOperationHandle() {
+ return this.operationHandle != null;
+ }
+
+ public void setOperationHandleIsSet(boolean value) {
+ if (!value) {
+ this.operationHandle = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, Object value) {
+ switch (field) {
+ case OPERATION_HANDLE:
+ if (value == null) {
+ unsetOperationHandle();
+ } else {
+ setOperationHandle((TOperationHandle)value);
+ }
+ break;
+
+ }
+ }
+
+ public Object getFieldValue(_Fields field) {
+ switch (field) {
+ case OPERATION_HANDLE:
+ return getOperationHandle();
+
+ }
+ throw new IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new IllegalArgumentException();
+ }
+
+ switch (field) {
+ case OPERATION_HANDLE:
+ return isSetOperationHandle();
+ }
+ throw new IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(Object that) {
+ if (that == null)
+ return false;
+ if (that instanceof TGetQueryIdReq)
+ return this.equals((TGetQueryIdReq)that);
+ return false;
+ }
+
+ public boolean equals(TGetQueryIdReq that) {
+ if (that == null)
+ return false;
+
+ boolean this_present_operationHandle = true && this.isSetOperationHandle();
+ boolean that_present_operationHandle = true && that.isSetOperationHandle();
+ if (this_present_operationHandle || that_present_operationHandle) {
+ if (!(this_present_operationHandle && that_present_operationHandle))
+ return false;
+ if (!this.operationHandle.equals(that.operationHandle))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ List<Object> list = new ArrayList<Object>();
+
+ boolean present_operationHandle = true && (isSetOperationHandle());
+ list.add(present_operationHandle);
+ if (present_operationHandle)
+ list.add(operationHandle);
+
+ return list.hashCode();
+ }
+
+ @Override
+ public int compareTo(TGetQueryIdReq other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = Boolean.valueOf(isSetOperationHandle()).compareTo(other.isSetOperationHandle());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetOperationHandle()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.operationHandle, other.operationHandle);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder("TGetQueryIdReq(");
+ boolean first = true;
+
+ sb.append("operationHandle:");
+ if (this.operationHandle == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.operationHandle);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (!isSetOperationHandle()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'operationHandle' is unset! Struct:" + toString());
+ }
+
+ // check for sub-struct validity
+ if (operationHandle != null) {
+ operationHandle.validate();
+ }
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class TGetQueryIdReqStandardSchemeFactory implements SchemeFactory {
+ public TGetQueryIdReqStandardScheme getScheme() {
+ return new TGetQueryIdReqStandardScheme();
+ }
+ }
+
+ private static class TGetQueryIdReqStandardScheme extends StandardScheme<TGetQueryIdReq> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TGetQueryIdReq struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // OPERATION_HANDLE
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+ struct.operationHandle = new TOperationHandle();
+ struct.operationHandle.read(iprot);
+ struct.setOperationHandleIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TGetQueryIdReq struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.operationHandle != null) {
+ oprot.writeFieldBegin(OPERATION_HANDLE_FIELD_DESC);
+ struct.operationHandle.write(oprot);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TGetQueryIdReqTupleSchemeFactory implements SchemeFactory {
+ public TGetQueryIdReqTupleScheme getScheme() {
+ return new TGetQueryIdReqTupleScheme();
+ }
+ }
+
+ private static class TGetQueryIdReqTupleScheme extends TupleScheme<TGetQueryIdReq> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TGetQueryIdReq struct) throws org.apache.thrift.TException {
+ TTupleProtocol oprot = (TTupleProtocol) prot;
+ struct.operationHandle.write(oprot);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TGetQueryIdReq struct) throws org.apache.thrift.TException {
+ TTupleProtocol iprot = (TTupleProtocol) prot;
+ struct.operationHandle = new TOperationHandle();
+ struct.operationHandle.read(iprot);
+ struct.setOperationHandleIsSet(true);
+ }
+ }
+
+}
+
http://git-wip-us.apache.org/repos/asf/hive/blob/2d698b67/service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TGetQueryIdResp.java
----------------------------------------------------------------------
diff --git a/service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TGetQueryIdResp.java b/service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TGetQueryIdResp.java
new file mode 100644
index 0000000..91aa1e9
--- /dev/null
+++ b/service-rpc/src/gen/thrift/gen-javabean/org/apache/hive/service/rpc/thrift/TGetQueryIdResp.java
@@ -0,0 +1,389 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.3)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+package org.apache.hive.service.rpc.thrift;
+
+import org.apache.thrift.scheme.IScheme;
+import org.apache.thrift.scheme.SchemeFactory;
+import org.apache.thrift.scheme.StandardScheme;
+
+import org.apache.thrift.scheme.TupleScheme;
+import org.apache.thrift.protocol.TTupleProtocol;
+import org.apache.thrift.protocol.TProtocolException;
+import org.apache.thrift.EncodingUtils;
+import org.apache.thrift.TException;
+import org.apache.thrift.async.AsyncMethodCallback;
+import org.apache.thrift.server.AbstractNonblockingServer.*;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.EnumMap;
+import java.util.Set;
+import java.util.HashSet;
+import java.util.EnumSet;
+import java.util.Collections;
+import java.util.BitSet;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import javax.annotation.Generated;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"})
+@Generated(value = "Autogenerated by Thrift Compiler (0.9.3)")
+public class TGetQueryIdResp implements org.apache.thrift.TBase<TGetQueryIdResp, TGetQueryIdResp._Fields>, java.io.Serializable, Cloneable, Comparable<TGetQueryIdResp> {
+ private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TGetQueryIdResp");
+
+ private static final org.apache.thrift.protocol.TField QUERY_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("queryId", org.apache.thrift.protocol.TType.STRING, (short)1);
+
+ private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
+ static {
+ schemes.put(StandardScheme.class, new TGetQueryIdRespStandardSchemeFactory());
+ schemes.put(TupleScheme.class, new TGetQueryIdRespTupleSchemeFactory());
+ }
+
+ private String queryId; // required
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+ QUERY_ID((short)1, "queryId");
+
+ private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+
+ static {
+ for (_Fields field : EnumSet.allOf(_Fields.class)) {
+ byName.put(field.getFieldName(), field);
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, or null if its not found.
+ */
+ public static _Fields findByThriftId(int fieldId) {
+ switch(fieldId) {
+ case 1: // QUERY_ID
+ return QUERY_ID;
+ default:
+ return null;
+ }
+ }
+
+ /**
+ * Find the _Fields constant that matches fieldId, throwing an exception
+ * if it is not found.
+ */
+ public static _Fields findByThriftIdOrThrow(int fieldId) {
+ _Fields fields = findByThriftId(fieldId);
+ if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+ return fields;
+ }
+
+ /**
+ * Find the _Fields constant that matches name, or null if its not found.
+ */
+ public static _Fields findByName(String name) {
+ return byName.get(name);
+ }
+
+ private final short _thriftId;
+ private final String _fieldName;
+
+ _Fields(short thriftId, String fieldName) {
+ _thriftId = thriftId;
+ _fieldName = fieldName;
+ }
+
+ public short getThriftFieldId() {
+ return _thriftId;
+ }
+
+ public String getFieldName() {
+ return _fieldName;
+ }
+ }
+
+ // isset id assignments
+ public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+ static {
+ Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.QUERY_ID, new org.apache.thrift.meta_data.FieldMetaData("queryId", org.apache.thrift.TFieldRequirementType.REQUIRED,
+ new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+ metaDataMap = Collections.unmodifiableMap(tmpMap);
+ org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TGetQueryIdResp.class, metaDataMap);
+ }
+
+ public TGetQueryIdResp() {
+ }
+
+ public TGetQueryIdResp(
+ String queryId)
+ {
+ this();
+ this.queryId = queryId;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public TGetQueryIdResp(TGetQueryIdResp other) {
+ if (other.isSetQueryId()) {
+ this.queryId = other.queryId;
+ }
+ }
+
+ public TGetQueryIdResp deepCopy() {
+ return new TGetQueryIdResp(this);
+ }
+
+ @Override
+ public void clear() {
+ this.queryId = null;
+ }
+
+ public String getQueryId() {
+ return this.queryId;
+ }
+
+ public void setQueryId(String queryId) {
+ this.queryId = queryId;
+ }
+
+ public void unsetQueryId() {
+ this.queryId = null;
+ }
+
+ /** Returns true if field queryId is set (has been assigned a value) and false otherwise */
+ public boolean isSetQueryId() {
+ return this.queryId != null;
+ }
+
+ public void setQueryIdIsSet(boolean value) {
+ if (!value) {
+ this.queryId = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, Object value) {
+ switch (field) {
+ case QUERY_ID:
+ if (value == null) {
+ unsetQueryId();
+ } else {
+ setQueryId((String)value);
+ }
+ break;
+
+ }
+ }
+
+ public Object getFieldValue(_Fields field) {
+ switch (field) {
+ case QUERY_ID:
+ return getQueryId();
+
+ }
+ throw new IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new IllegalArgumentException();
+ }
+
+ switch (field) {
+ case QUERY_ID:
+ return isSetQueryId();
+ }
+ throw new IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(Object that) {
+ if (that == null)
+ return false;
+ if (that instanceof TGetQueryIdResp)
+ return this.equals((TGetQueryIdResp)that);
+ return false;
+ }
+
+ public boolean equals(TGetQueryIdResp that) {
+ if (that == null)
+ return false;
+
+ boolean this_present_queryId = true && this.isSetQueryId();
+ boolean that_present_queryId = true && that.isSetQueryId();
+ if (this_present_queryId || that_present_queryId) {
+ if (!(this_present_queryId && that_present_queryId))
+ return false;
+ if (!this.queryId.equals(that.queryId))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ List<Object> list = new ArrayList<Object>();
+
+ boolean present_queryId = true && (isSetQueryId());
+ list.add(present_queryId);
+ if (present_queryId)
+ list.add(queryId);
+
+ return list.hashCode();
+ }
+
+ @Override
+ public int compareTo(TGetQueryIdResp other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+
+ lastComparison = Boolean.valueOf(isSetQueryId()).compareTo(other.isSetQueryId());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetQueryId()) {
+ lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.queryId, other.queryId);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+ schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+ schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder("TGetQueryIdResp(");
+ boolean first = true;
+
+ sb.append("queryId:");
+ if (this.queryId == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.queryId);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws org.apache.thrift.TException {
+ // check for required fields
+ if (!isSetQueryId()) {
+ throw new org.apache.thrift.protocol.TProtocolException("Required field 'queryId' is unset! Struct:" + toString());
+ }
+
+ // check for sub-struct validity
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ try {
+ write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
+ try {
+ read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+ } catch (org.apache.thrift.TException te) {
+ throw new java.io.IOException(te);
+ }
+ }
+
+ private static class TGetQueryIdRespStandardSchemeFactory implements SchemeFactory {
+ public TGetQueryIdRespStandardScheme getScheme() {
+ return new TGetQueryIdRespStandardScheme();
+ }
+ }
+
+ private static class TGetQueryIdRespStandardScheme extends StandardScheme<TGetQueryIdResp> {
+
+ public void read(org.apache.thrift.protocol.TProtocol iprot, TGetQueryIdResp struct) throws org.apache.thrift.TException {
+ org.apache.thrift.protocol.TField schemeField;
+ iprot.readStructBegin();
+ while (true)
+ {
+ schemeField = iprot.readFieldBegin();
+ if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
+ break;
+ }
+ switch (schemeField.id) {
+ case 1: // QUERY_ID
+ if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+ struct.queryId = iprot.readString();
+ struct.setQueryIdIsSet(true);
+ } else {
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ break;
+ default:
+ org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+ struct.validate();
+ }
+
+ public void write(org.apache.thrift.protocol.TProtocol oprot, TGetQueryIdResp struct) throws org.apache.thrift.TException {
+ struct.validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (struct.queryId != null) {
+ oprot.writeFieldBegin(QUERY_ID_FIELD_DESC);
+ oprot.writeString(struct.queryId);
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ }
+
+ private static class TGetQueryIdRespTupleSchemeFactory implements SchemeFactory {
+ public TGetQueryIdRespTupleScheme getScheme() {
+ return new TGetQueryIdRespTupleScheme();
+ }
+ }
+
+ private static class TGetQueryIdRespTupleScheme extends TupleScheme<TGetQueryIdResp> {
+
+ @Override
+ public void write(org.apache.thrift.protocol.TProtocol prot, TGetQueryIdResp struct) throws org.apache.thrift.TException {
+ TTupleProtocol oprot = (TTupleProtocol) prot;
+ oprot.writeString(struct.queryId);
+ }
+
+ @Override
+ public void read(org.apache.thrift.protocol.TProtocol prot, TGetQueryIdResp struct) throws org.apache.thrift.TException {
+ TTupleProtocol iprot = (TTupleProtocol) prot;
+ struct.queryId = iprot.readString();
+ struct.setQueryIdIsSet(true);
+ }
+ }
+
+}
+
http://git-wip-us.apache.org/repos/asf/hive/blob/2d698b67/service-rpc/src/gen/thrift/gen-php/TCLIService.php
----------------------------------------------------------------------
diff --git a/service-rpc/src/gen/thrift/gen-php/TCLIService.php b/service-rpc/src/gen/thrift/gen-php/TCLIService.php
index d283145..c76b24c 100644
--- a/service-rpc/src/gen/thrift/gen-php/TCLIService.php
+++ b/service-rpc/src/gen/thrift/gen-php/TCLIService.php
@@ -121,6 +121,11 @@ interface TCLIServiceIf {
* @return \TRenewDelegationTokenResp
*/
public function RenewDelegationToken(\TRenewDelegationTokenReq $req);
+ /**
+ * @param \TGetQueryIdReq $req
+ * @return \TGetQueryIdResp
+ */
+ public function GetQueryId(\TGetQueryIdReq $req);
}
class TCLIServiceClient implements \TCLIServiceIf {
@@ -1205,6 +1210,57 @@ class TCLIServiceClient implements \TCLIServiceIf {
throw new \Exception("RenewDelegationToken failed: unknown result");
}
+ public function GetQueryId(\TGetQueryIdReq $req)
+ {
+ $this->send_GetQueryId($req);
+ return $this->recv_GetQueryId();
+ }
+
+ public function send_GetQueryId(\TGetQueryIdReq $req)
+ {
+ $args = new \TCLIService_GetQueryId_args();
+ $args->req = $req;
+ $bin_accel = ($this->output_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_write_binary');
+ if ($bin_accel)
+ {
+ thrift_protocol_write_binary($this->output_, 'GetQueryId', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
+ }
+ else
+ {
+ $this->output_->writeMessageBegin('GetQueryId', TMessageType::CALL, $this->seqid_);
+ $args->write($this->output_);
+ $this->output_->writeMessageEnd();
+ $this->output_->getTransport()->flush();
+ }
+ }
+
+ public function recv_GetQueryId()
+ {
+ $bin_accel = ($this->input_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_read_binary');
+ if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\TCLIService_GetQueryId_result', $this->input_->isStrictRead());
+ else
+ {
+ $rseqid = 0;
+ $fname = null;
+ $mtype = 0;
+
+ $this->input_->readMessageBegin($fname, $mtype, $rseqid);
+ if ($mtype == TMessageType::EXCEPTION) {
+ $x = new TApplicationException();
+ $x->read($this->input_);
+ $this->input_->readMessageEnd();
+ throw $x;
+ }
+ $result = new \TCLIService_GetQueryId_result();
+ $result->read($this->input_);
+ $this->input_->readMessageEnd();
+ }
+ if ($result->success !== null) {
+ return $result->success;
+ }
+ throw new \Exception("GetQueryId failed: unknown result");
+ }
+
}
// HELPER FUNCTIONS AND STRUCTURES
@@ -4569,4 +4625,164 @@ class TCLIService_RenewDelegationToken_result {
}
+class TCLIService_GetQueryId_args {
+ static $_TSPEC;
+
+ /**
+ * @var \TGetQueryIdReq
+ */
+ public $req = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'req',
+ 'type' => TType::STRUCT,
+ 'class' => '\TGetQueryIdReq',
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['req'])) {
+ $this->req = $vals['req'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'TCLIService_GetQueryId_args';
+ }
+
+ public function read($input)
+ {
+ $xfer = 0;
+ $fname = null;
+ $ftype = 0;
+ $fid = 0;
+ $xfer += $input->readStructBegin($fname);
+ while (true)
+ {
+ $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+ if ($ftype == TType::STOP) {
+ break;
+ }
+ switch ($fid)
+ {
+ case 1:
+ if ($ftype == TType::STRUCT) {
+ $this->req = new \TGetQueryIdReq();
+ $xfer += $this->req->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ default:
+ $xfer += $input->skip($ftype);
+ break;
+ }
+ $xfer += $input->readFieldEnd();
+ }
+ $xfer += $input->readStructEnd();
+ return $xfer;
+ }
+
+ public function write($output) {
+ $xfer = 0;
+ $xfer += $output->writeStructBegin('TCLIService_GetQueryId_args');
+ if ($this->req !== null) {
+ if (!is_object($this->req)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
+ $xfer += $this->req->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class TCLIService_GetQueryId_result {
+ static $_TSPEC;
+
+ /**
+ * @var \TGetQueryIdResp
+ */
+ public $success = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 0 => array(
+ 'var' => 'success',
+ 'type' => TType::STRUCT,
+ 'class' => '\TGetQueryIdResp',
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['success'])) {
+ $this->success = $vals['success'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'TCLIService_GetQueryId_result';
+ }
+
+ public function read($input)
+ {
+ $xfer = 0;
+ $fname = null;
+ $ftype = 0;
+ $fid = 0;
+ $xfer += $input->readStructBegin($fname);
+ while (true)
+ {
+ $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+ if ($ftype == TType::STOP) {
+ break;
+ }
+ switch ($fid)
+ {
+ case 0:
+ if ($ftype == TType::STRUCT) {
+ $this->success = new \TGetQueryIdResp();
+ $xfer += $this->success->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ default:
+ $xfer += $input->skip($ftype);
+ break;
+ }
+ $xfer += $input->readFieldEnd();
+ }
+ $xfer += $input->readStructEnd();
+ return $xfer;
+ }
+
+ public function write($output) {
+ $xfer = 0;
+ $xfer += $output->writeStructBegin('TCLIService_GetQueryId_result');
+ if ($this->success !== null) {
+ if (!is_object($this->success)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
+ $xfer += $this->success->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
http://git-wip-us.apache.org/repos/asf/hive/blob/2d698b67/service-rpc/src/gen/thrift/gen-php/Types.php
----------------------------------------------------------------------
diff --git a/service-rpc/src/gen/thrift/gen-php/Types.php b/service-rpc/src/gen/thrift/gen-php/Types.php
index f34a0cf..da2b811 100644
--- a/service-rpc/src/gen/thrift/gen-php/Types.php
+++ b/service-rpc/src/gen/thrift/gen-php/Types.php
@@ -10029,6 +10029,161 @@ class TProgressUpdateResp {
}
+class TGetQueryIdReq {
+ static $_TSPEC;
+
+ /**
+ * @var \TOperationHandle
+ */
+ public $operationHandle = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'operationHandle',
+ 'type' => TType::STRUCT,
+ 'class' => '\TOperationHandle',
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['operationHandle'])) {
+ $this->operationHandle = $vals['operationHandle'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'TGetQueryIdReq';
+ }
+
+ public function read($input)
+ {
+ $xfer = 0;
+ $fname = null;
+ $ftype = 0;
+ $fid = 0;
+ $xfer += $input->readStructBegin($fname);
+ while (true)
+ {
+ $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+ if ($ftype == TType::STOP) {
+ break;
+ }
+ switch ($fid)
+ {
+ case 1:
+ if ($ftype == TType::STRUCT) {
+ $this->operationHandle = new \TOperationHandle();
+ $xfer += $this->operationHandle->read($input);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ default:
+ $xfer += $input->skip($ftype);
+ break;
+ }
+ $xfer += $input->readFieldEnd();
+ }
+ $xfer += $input->readStructEnd();
+ return $xfer;
+ }
+
+ public function write($output) {
+ $xfer = 0;
+ $xfer += $output->writeStructBegin('TGetQueryIdReq');
+ if ($this->operationHandle !== null) {
+ if (!is_object($this->operationHandle)) {
+ throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
+ }
+ $xfer += $output->writeFieldBegin('operationHandle', TType::STRUCT, 1);
+ $xfer += $this->operationHandle->write($output);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
+class TGetQueryIdResp {
+ static $_TSPEC;
+
+ /**
+ * @var string
+ */
+ public $queryId = null;
+
+ public function __construct($vals=null) {
+ if (!isset(self::$_TSPEC)) {
+ self::$_TSPEC = array(
+ 1 => array(
+ 'var' => 'queryId',
+ 'type' => TType::STRING,
+ ),
+ );
+ }
+ if (is_array($vals)) {
+ if (isset($vals['queryId'])) {
+ $this->queryId = $vals['queryId'];
+ }
+ }
+ }
+
+ public function getName() {
+ return 'TGetQueryIdResp';
+ }
+
+ public function read($input)
+ {
+ $xfer = 0;
+ $fname = null;
+ $ftype = 0;
+ $fid = 0;
+ $xfer += $input->readStructBegin($fname);
+ while (true)
+ {
+ $xfer += $input->readFieldBegin($fname, $ftype, $fid);
+ if ($ftype == TType::STOP) {
+ break;
+ }
+ switch ($fid)
+ {
+ case 1:
+ if ($ftype == TType::STRING) {
+ $xfer += $input->readString($this->queryId);
+ } else {
+ $xfer += $input->skip($ftype);
+ }
+ break;
+ default:
+ $xfer += $input->skip($ftype);
+ break;
+ }
+ $xfer += $input->readFieldEnd();
+ }
+ $xfer += $input->readStructEnd();
+ return $xfer;
+ }
+
+ public function write($output) {
+ $xfer = 0;
+ $xfer += $output->writeStructBegin('TGetQueryIdResp');
+ if ($this->queryId !== null) {
+ $xfer += $output->writeFieldBegin('queryId', TType::STRING, 1);
+ $xfer += $output->writeString($this->queryId);
+ $xfer += $output->writeFieldEnd();
+ }
+ $xfer += $output->writeFieldStop();
+ $xfer += $output->writeStructEnd();
+ return $xfer;
+ }
+
+}
+
final class Constant extends \Thrift\Type\TConstant {
static protected $PRIMITIVE_TYPES;
static protected $COMPLEX_TYPES;
http://git-wip-us.apache.org/repos/asf/hive/blob/2d698b67/service-rpc/src/gen/thrift/gen-py/TCLIService/TCLIService-remote
----------------------------------------------------------------------
diff --git a/service-rpc/src/gen/thrift/gen-py/TCLIService/TCLIService-remote b/service-rpc/src/gen/thrift/gen-py/TCLIService/TCLIService-remote
index 62b87a3..915ee13 100755
--- a/service-rpc/src/gen/thrift/gen-py/TCLIService/TCLIService-remote
+++ b/service-rpc/src/gen/thrift/gen-py/TCLIService/TCLIService-remote
@@ -45,6 +45,7 @@ if len(sys.argv) <= 1 or sys.argv[1] == '--help':
print(' TGetDelegationTokenResp GetDelegationToken(TGetDelegationTokenReq req)')
print(' TCancelDelegationTokenResp CancelDelegationToken(TCancelDelegationTokenReq req)')
print(' TRenewDelegationTokenResp RenewDelegationToken(TRenewDelegationTokenReq req)')
+ print(' TGetQueryIdResp GetQueryId(TGetQueryIdReq req)')
print('')
sys.exit(0)
@@ -227,6 +228,12 @@ elif cmd == 'RenewDelegationToken':
sys.exit(1)
pp.pprint(client.RenewDelegationToken(eval(args[0]),))
+elif cmd == 'GetQueryId':
+ if len(args) != 1:
+ print('GetQueryId requires 1 args')
+ sys.exit(1)
+ pp.pprint(client.GetQueryId(eval(args[0]),))
+
else:
print('Unrecognized method %s' % cmd)
sys.exit(1)
http://git-wip-us.apache.org/repos/asf/hive/blob/2d698b67/service-rpc/src/gen/thrift/gen-py/TCLIService/TCLIService.py
----------------------------------------------------------------------
diff --git a/service-rpc/src/gen/thrift/gen-py/TCLIService/TCLIService.py b/service-rpc/src/gen/thrift/gen-py/TCLIService/TCLIService.py
index 35f2ae4..6054b7f 100644
--- a/service-rpc/src/gen/thrift/gen-py/TCLIService/TCLIService.py
+++ b/service-rpc/src/gen/thrift/gen-py/TCLIService/TCLIService.py
@@ -166,6 +166,13 @@ class Iface:
"""
pass
+ def GetQueryId(self, req):
+ """
+ Parameters:
+ - req
+ """
+ pass
+
class Client(Iface):
def __init__(self, iprot, oprot=None):
@@ -825,6 +832,37 @@ class Client(Iface):
return result.success
raise TApplicationException(TApplicationException.MISSING_RESULT, "RenewDelegationToken failed: unknown result")
+ def GetQueryId(self, req):
+ """
+ Parameters:
+ - req
+ """
+ self.send_GetQueryId(req)
+ return self.recv_GetQueryId()
+
+ def send_GetQueryId(self, req):
+ self._oprot.writeMessageBegin('GetQueryId', TMessageType.CALL, self._seqid)
+ args = GetQueryId_args()
+ args.req = req
+ args.write(self._oprot)
+ self._oprot.writeMessageEnd()
+ self._oprot.trans.flush()
+
+ def recv_GetQueryId(self):
+ iprot = self._iprot
+ (fname, mtype, rseqid) = iprot.readMessageBegin()
+ if mtype == TMessageType.EXCEPTION:
+ x = TApplicationException()
+ x.read(iprot)
+ iprot.readMessageEnd()
+ raise x
+ result = GetQueryId_result()
+ result.read(iprot)
+ iprot.readMessageEnd()
+ if result.success is not None:
+ return result.success
+ raise TApplicationException(TApplicationException.MISSING_RESULT, "GetQueryId failed: unknown result")
+
class Processor(Iface, TProcessor):
def __init__(self, handler):
@@ -851,6 +889,7 @@ class Processor(Iface, TProcessor):
self._processMap["GetDelegationToken"] = Processor.process_GetDelegationToken
self._processMap["CancelDelegationToken"] = Processor.process_CancelDelegationToken
self._processMap["RenewDelegationToken"] = Processor.process_RenewDelegationToken
+ self._processMap["GetQueryId"] = Processor.process_GetQueryId
def process(self, iprot, oprot):
(name, type, seqid) = iprot.readMessageBegin()
@@ -1266,6 +1305,25 @@ class Processor(Iface, TProcessor):
oprot.writeMessageEnd()
oprot.trans.flush()
+ def process_GetQueryId(self, seqid, iprot, oprot):
+ args = GetQueryId_args()
+ args.read(iprot)
+ iprot.readMessageEnd()
+ result = GetQueryId_result()
+ try:
+ result.success = self._handler.GetQueryId(args.req)
+ msg_type = TMessageType.REPLY
+ except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
+ raise
+ except Exception as ex:
+ msg_type = TMessageType.EXCEPTION
+ logging.exception(ex)
+ result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
+ oprot.writeMessageBegin("GetQueryId", msg_type, seqid)
+ result.write(oprot)
+ oprot.writeMessageEnd()
+ oprot.trans.flush()
+
# HELPER FUNCTIONS AND STRUCTURES
@@ -4019,3 +4077,134 @@ class RenewDelegationToken_result:
def __ne__(self, other):
return not (self == other)
+
+class GetQueryId_args:
+ """
+ Attributes:
+ - req
+ """
+
+ thrift_spec = (
+ None, # 0
+ (1, TType.STRUCT, 'req', (TGetQueryIdReq, TGetQueryIdReq.thrift_spec), None, ), # 1
+ )
+
+ def __init__(self, req=None,):
+ self.req = req
+
+ def read(self, iprot):
+ if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+ fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+ return
+ iprot.readStructBegin()
+ while True:
+ (fname, ftype, fid) = iprot.readFieldBegin()
+ if ftype == TType.STOP:
+ break
+ if fid == 1:
+ if ftype == TType.STRUCT:
+ self.req = TGetQueryIdReq()
+ self.req.read(iprot)
+ else:
+ iprot.skip(ftype)
+ else:
+ iprot.skip(ftype)
+ iprot.readFieldEnd()
+ iprot.readStructEnd()
+
+ def write(self, oprot):
+ if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+ oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+ return
+ oprot.writeStructBegin('GetQueryId_args')
+ if self.req is not None:
+ oprot.writeFieldBegin('req', TType.STRUCT, 1)
+ self.req.write(oprot)
+ oprot.writeFieldEnd()
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ return
+
+
+ def __hash__(self):
+ value = 17
+ value = (value * 31) ^ hash(self.req)
+ return value
+
+ def __repr__(self):
+ L = ['%s=%r' % (key, value)
+ for key, value in self.__dict__.iteritems()]
+ return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+ def __eq__(self, other):
+ return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+ def __ne__(self, other):
+ return not (self == other)
+
+class GetQueryId_result:
+ """
+ Attributes:
+ - success
+ """
+
+ thrift_spec = (
+ (0, TType.STRUCT, 'success', (TGetQueryIdResp, TGetQueryIdResp.thrift_spec), None, ), # 0
+ )
+
+ def __init__(self, success=None,):
+ self.success = success
+
+ def read(self, iprot):
+ if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+ fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+ return
+ iprot.readStructBegin()
+ while True:
+ (fname, ftype, fid) = iprot.readFieldBegin()
+ if ftype == TType.STOP:
+ break
+ if fid == 0:
+ if ftype == TType.STRUCT:
+ self.success = TGetQueryIdResp()
+ self.success.read(iprot)
+ else:
+ iprot.skip(ftype)
+ else:
+ iprot.skip(ftype)
+ iprot.readFieldEnd()
+ iprot.readStructEnd()
+
+ def write(self, oprot):
+ if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+ oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+ return
+ oprot.writeStructBegin('GetQueryId_result')
+ if self.success is not None:
+ oprot.writeFieldBegin('success', TType.STRUCT, 0)
+ self.success.write(oprot)
+ oprot.writeFieldEnd()
+ oprot.writeFieldStop()
+ oprot.writeStructEnd()
+
+ def validate(self):
+ return
+
+
+ def __hash__(self):
+ value = 17
+ value = (value * 31) ^ hash(self.success)
+ return value
+
+ def __repr__(self):
+ L = ['%s=%r' % (key, value)
+ for key, value in self.__dict__.iteritems()]
+ return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+ def __eq__(self, other):
+ return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+ def __ne__(self, other):
+ return not (self == other)