You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by nz...@apache.org on 2010/12/09 19:31:09 UTC
svn commit: r1044070 [17/29] - in /hive/trunk: ./ eclipse-templates/ ivy/
lib/ metastore/ metastore/if/ metastore/src/gen-cpp/
metastore/src/gen-javabean/org/apache/hadoop/hive/metastore/api/
metastore/src/gen-php/ metastore/src/gen-py/hive_metastore/ ...
Modified: hive/trunk/odbc/Makefile
URL: http://svn.apache.org/viewvc/hive/trunk/odbc/Makefile?rev=1044070&r1=1044069&r2=1044070&view=diff
==============================================================================
--- hive/trunk/odbc/Makefile (original)
+++ hive/trunk/odbc/Makefile Thu Dec 9 18:30:58 2010
@@ -56,12 +56,13 @@ LINK = ln -sf
BUILD_DIR = $(HIVE_ROOT)/build
ODBC_BUILD_DIR = $(BUILD_DIR)/odbc
OBJ_SERVICE_BUILD_DIR = $(BUILD_DIR)/service/objs
-OBJ_FB303_BUILD_DIR = $(BUILD_DIR)/service/fb303/objs
+OBJ_QL_BUILD_DIR = $(BUILD_DIR)/ql/objs
OBJ_METASTORE_BUILD_DIR = $(BUILD_DIR)/metastore/objs
OBJ_ODBC_BUILD_DIR = $(ODBC_BUILD_DIR)/objs
LIB_ODBC_BUILD_DIR = $(ODBC_BUILD_DIR)/lib
TEST_ODBC_BUILD_DIR = $(ODBC_BUILD_DIR)/test
-THRIFT_INCLUDE_PATH = $(HIVE_ROOT)/service/include/thrift
+THRIFT_INCLUDE_PATH=$(THRIFT_HOME)/include/thrift
+FB303_INCLUDE_PATH=$(THRIFT_INCLUDE_PATH)/fb303
INSTALL_PATH = /usr/local
INSTALL_LIB_PATH = $(INSTALL_PATH)/lib
INSTALL_INCLUDE_PATH = $(INSTALL_PATH)/include
@@ -79,30 +80,31 @@ AR_NAME = lib$(LIB_NAME).a
AR_TARGET = $(LIB_ODBC_BUILD_DIR)/$(AR_NAME)
AR_INSTALL_TARGET = $(INSTALL_LIB_PATH)/$(AR_NAME)
-SERVICE_SRC_DIR = $(HIVE_ROOT)/service/src/gen-cpp
+SERVICE_SRC_DIR = $(HIVE_ROOT)/service/src/gen/thrift/gen-cpp
SERVICE_SOURCES = ThriftHive.cpp \
hive_service_constants.cpp \
hive_service_types.cpp
SERVICE_OBJS = $(addprefix $(OBJ_SERVICE_BUILD_DIR)/,$(patsubst %,%.o,$(basename $(SERVICE_SOURCES))))
-FB303_SRC_DIR = $(THRIFT_INCLUDE_PATH)/fb303
-FB303_SOURCES = FacebookService.cpp \
- fb303_constants.cpp \
- fb303_types.cpp
-FB303_OBJS = $(addprefix $(OBJ_FB303_BUILD_DIR)/,$(patsubst %,%.o,$(basename $(FB303_SOURCES))))
+QL_SRC_DIR = $(HIVE_ROOT)/ql/src/gen/thrift/gen-cpp
+QL_SOURCES = queryplan_types.cpp queryplan_constants.cpp
+QL_OBJS = $(addprefix $(OBJ_QL_BUILD_DIR)/,$(patsubst %,%.o,$(basename $(QL_SOURCES))))
-METASTORE_SRC_DIR = $(HIVE_ROOT)/metastore/src/gen-cpp
+
+METASTORE_SRC_DIR = $(HIVE_ROOT)/metastore/src/gen/thrift/gen-cpp
METASTORE_SOURCES = ThriftHiveMetastore.cpp \
hive_metastore_constants.cpp \
hive_metastore_types.cpp
METASTORE_OBJS = $(addprefix $(OBJ_METASTORE_BUILD_DIR)/,$(patsubst %,%.o,$(basename $(METASTORE_SOURCES))))
ODBC_SRC_DIR = $(BASE_DIR)/src/cpp
+
ODBC_SOURCES = hiveclient.cpp \
HiveResultSet.cpp \
HiveColumnDesc.cpp \
HiveRowSet.cpp \
hiveclienthelper.cpp
+
ODBC_OBJS = $(addprefix $(OBJ_ODBC_BUILD_DIR)/,$(patsubst %,%.o,$(basename $(ODBC_SOURCES))))
ODBC_TEST_SRC_DIR = $(BASE_DIR)/src/test
@@ -111,9 +113,10 @@ TEST_FLAGS = -DTEST_DATA_DIR=$(ODBC_TEST
HIVE_CLIENT_TEST = $(TEST_ODBC_BUILD_DIR)/HiveClientTestC
INCLUDE_PATHS = -I$(THRIFT_INCLUDE_PATH) \
+ -I$(FB303_INCLUDE_PATH) \
-I$(BOOST_INCLUDE_PATH) \
- -I$(FB303_SRC_DIR) \
-I$(SERVICE_SRC_DIR) \
+ -I$(QL_SRC_DIR) \
-I$(METASTORE_SRC_DIR) \
-I$(ODBC_SRC_DIR)
@@ -127,20 +130,25 @@ LIB_THRIFT_DIR = $(THRIFT_HOME)/lib
LIB_THRIFT_ADD = -L$(LIB_THRIFT_DIR) -lthrift
LIB_THRIFT_AR = $(LIB_THRIFT_DIR)/libthrift.a
+LIB_FB303_DIR = $(THRIFT_HOME)/lib
+LIB_FB303_ADD = -L$(LIB_FB303_DIR) -lfb303
+LIB_FB303_AR = $(LIB_FB303_DIR)/libfb303.a
+
all:: $(AR_TARGET) $(SO_TARGET) $(HIVE_CLIENT_TEST)
-$(AR_TARGET): $(FB303_OBJS) $(METASTORE_OBJS) $(SERVICE_OBJS) $(ODBC_OBJS)
+$(AR_TARGET): $(METASTORE_OBJS) $(SERVICE_OBJS) $(QL_OBJS) $(ODBC_OBJS)
if test -z '$(THRIFT_HOME)'; then echo 'THRIFT_HOME directory?'; exit 1; else exit 0; fi
mkdir -p $(LIB_ODBC_BUILD_DIR)
$(AR) $(ARXFLAGS) $(LIB_THRIFT_AR) #Extract thrift archive
+ $(AR) $(ARXFLAGS) $(LIB_FB303_AR) #Extract fb303 archive
$(AR) $(ARFLAGS) $@ $+ *.o #Include all object files into new archive
rm *.o #Remove extracted archive object files
-$(SO_TARGET): $(FB303_OBJS) $(METASTORE_OBJS) $(SERVICE_OBJS) $(ODBC_OBJS)
+$(SO_TARGET): $(METASTORE_OBJS) $(SERVICE_OBJS) $(QL_OBJS) $(ODBC_OBJS)
if test -z '$(THRIFT_HOME)'; then echo 'THRIFT_HOME directory?'; exit 1; else exit 0; fi
mkdir -p $(LIB_ODBC_BUILD_DIR)
- $(LD) $(ARCH_FLAGS) $(LDFLAGS) $+ $(LIB_THRIFT_ADD) -o $@ \
+ $(LD) $(ARCH_FLAGS) $(LDFLAGS) $+ $(LIB_THRIFT_ADD) $(LIB_FB303_ADD) -o $@ \
&& $(LINK) $(SO_NAME) $(SO_LINK_TARGET)
@@ -148,8 +156,8 @@ $(OBJ_SERVICE_BUILD_DIR)/%.o: $(SERVICE_
mkdir -p $(OBJ_SERVICE_BUILD_DIR)
$(CXX) $(CXXFLAGS) $(ARCH_FLAGS) $(INCLUDE_PATHS) -c $< -o $@
-$(OBJ_FB303_BUILD_DIR)/%.o: $(FB303_SRC_DIR)/%.cpp
- mkdir -p $(OBJ_FB303_BUILD_DIR)
+$(OBJ_QL_BUILD_DIR)/%.o: $(QL_SRC_DIR)/%.cpp
+ mkdir -p $(OBJ_QL_BUILD_DIR)
$(CXX) $(CXXFLAGS) $(ARCH_FLAGS) $(INCLUDE_PATHS) -c $< -o $@
$(OBJ_METASTORE_BUILD_DIR)/%.o: $(METASTORE_SRC_DIR)/%.cpp
@@ -162,7 +170,7 @@ $(OBJ_ODBC_BUILD_DIR)/%.o: $(ODBC_SRC_DI
$(HIVE_CLIENT_TEST): $(SO_TARGET) $(ODBC_TEST_SRC_DIR)/hiveclienttest.c
mkdir -p $(TEST_ODBC_BUILD_DIR)
- $(CC) $(CFLAGS) $(ARCH_FLAGS) $(TEST_FLAGS) $(INCLUDE_PATHS) $(ODBC_TEST_SRC_DIR)/hiveclienttest.c -L$(LIB_ODBC_BUILD_DIR) -L$(LIB_THRIFT_DIR) -l$(LIB_NAME) -lthrift -o $@
+ $(CC) $(CFLAGS) $(ARCH_FLAGS) $(TEST_FLAGS) $(INCLUDE_PATHS) $(ODBC_TEST_SRC_DIR)/hiveclienttest.c -L$(LIB_ODBC_BUILD_DIR) -L$(LIB_THRIFT_DIR) -l$(LIB_NAME) -lthrift $(LIB_FB303_ADD) -o $@
install: $(AR_TARGET) $(SO_TARGET)
@@ -179,7 +187,7 @@ uninstall:
rm -f $(HEADER_TARGETS)
clean:
- rm -rf $(ODBC_BUILD_DIR) $(OBJ_SERVICE_BUILD_DIR) $(OBJ_FB303_BUILD_DIR) $(OBJ_METASTORE_BUILD_DIR)
+ rm -rf $(ODBC_BUILD_DIR) $(OBJ_SERVICE_BUILD_DIR) $(OBJ_QL_BUILD_DIR) $(OBJ_METASTORE_BUILD_DIR)
test: $(AR_TARGET) $(SO_TARGET) $(HIVE_CLIENT_TEST)
- LD_LIBRARY_PATH=$(LIB_ODBC_BUILD_DIR):$(LIB_THRIFT_DIR):$(LD_LIBRARY_PATH) $(HIVE_CLIENT_TEST)
+ LD_LIBRARY_PATH=$(LIB_ODBC_BUILD_DIR):$(LIB_THRIFT_DIR):$(LIB_FB303_DIR):$(LD_LIBRARY_PATH) $(HIVE_CLIENT_TEST)
Modified: hive/trunk/odbc/build.xml
URL: http://svn.apache.org/viewvc/hive/trunk/odbc/build.xml?rev=1044070&r1=1044069&r2=1044070&view=diff
==============================================================================
--- hive/trunk/odbc/build.xml (original)
+++ hive/trunk/odbc/build.xml Thu Dec 9 18:30:58 2010
@@ -46,18 +46,6 @@
</condition>
</target>
- <target name="check-thrift-home">
- <condition property="thrift.home.defined">
- <and>
- <isset property="thrift.home"/>
- <not>
- <equals arg1="${thrift.home}" arg2="$${thrift.home}" trim="true"/>
- </not>
- </and>
- </condition>
- </target>
-
-
<target name="compile-cpp" depends="init,check-word-size">
<exec dir="." executable="${make.cmd}" failonerror="true">
<env key="WORD_SIZE" value="${word.size}"/>
Modified: hive/trunk/odbc/src/cpp/HiveRowSet.cpp
URL: http://svn.apache.org/viewvc/hive/trunk/odbc/src/cpp/HiveRowSet.cpp?rev=1044070&r1=1044069&r2=1044070&view=diff
==============================================================================
--- hive/trunk/odbc/src/cpp/HiveRowSet.cpp (original)
+++ hive/trunk/odbc/src/cpp/HiveRowSet.cpp Thu Dec 9 18:30:58 2010
@@ -17,6 +17,7 @@
*/
#include <assert.h>
+#include <string.h>
#include "HiveRowSet.h"
#include "hiveclienthelper.h"
Modified: hive/trunk/odbc/src/cpp/hiveclienthelper.cpp
URL: http://svn.apache.org/viewvc/hive/trunk/odbc/src/cpp/hiveclienthelper.cpp?rev=1044070&r1=1044069&r2=1044070&view=diff
==============================================================================
--- hive/trunk/odbc/src/cpp/hiveclienthelper.cpp (original)
+++ hive/trunk/odbc/src/cpp/hiveclienthelper.cpp Thu Dec 9 18:30:58 2010
@@ -18,6 +18,7 @@
#include <algorithm>
#include <assert.h>
+#include <string.h>
#include "hiveclienthelper.h"
#include "thriftserverconstants.h"
Modified: hive/trunk/ql/build.xml
URL: http://svn.apache.org/viewvc/hive/trunk/ql/build.xml?rev=1044070&r1=1044069&r2=1044070&view=diff
==============================================================================
--- hive/trunk/ql/build.xml (original)
+++ hive/trunk/ql/build.xml Thu Dec 9 18:30:58 2010
@@ -28,7 +28,6 @@
<property name="ql.test.query.clientpositive.dir" location="${ql.test.query.dir}/clientpositive"/>
<property name="ql.test.results.clientpositive.dir" location="${ql.test.results.dir}/clientpositive"/>
- <property name="thrift.args" value="--gen java:beans --gen php --gen py -I ${basedir}/include -I ${basedir}/.. -o ${basedir}/src"/>
<import file="../build-common.xml"/>
<property name="ql.test.clientpositive.exclude" value="${minimr.query.files}"/>
@@ -55,10 +54,11 @@
<path refid="classpath"/>
</path>
- <target name="thriftif">
- <echo>Executing thrift (which needs to be in your path) on if/queryplan.thrift</echo>
+ <target name="thriftif" depends="check-thrift-home">
+ <fail unless="thrift.home">You must set the 'thrift.home' property!</fail>
+ <echo>Executing ${thrift.home}/bin/thrift on ${ant.project.name}/if/queryplan.thrift</echo>
<exec executable="${thrift.home}/bin/thrift" failonerror="true" dir=".">
- <arg line="${thrift.args} if/queryplan.thrift " />
+ <arg line="${thrift.args} -I ${basedir}/include -I ${basedir}/.. -o ${basedir}/src/gen/thrift if/queryplan.thrift " />
</exec>
</target>
@@ -132,27 +132,27 @@
<uptodate property="grammarBuild.notRequired">
<srcfiles dir= "${src.dir}/org/apache/hadoop/hive/ql/parse" includes="**/*.g"/>
- <mapper type="merge" to="${build.dir.hive}/ql/gen-java/org/apache/hadoop/hive/ql/parse/HiveParser.java"/>
+ <mapper type="merge" to="${build.dir.hive}/ql/gen/antlr/gen-java/org/apache/hadoop/hive/ql/parse/HiveParser.java"/>
</uptodate>
<target name="build-grammar" unless="grammarBuild.notRequired">
<echo>Building Grammar ${src.dir}/org/apache/hadoop/hive/ql/parse/Hive.g ....</echo>
<java classname="org.antlr.Tool" classpathref="classpath" fork="true">
<arg value="-fo" />
- <arg value="${build.dir.hive}/ql/gen-java/org/apache/hadoop/hive/ql/parse" />
+ <arg value="${build.dir}/gen/antlr/gen-java/org/apache/hadoop/hive/ql/parse" />
<arg value="${src.dir}/org/apache/hadoop/hive/ql/parse/Hive.g" />
</java>
</target>
<target name="ql-init">
- <mkdir dir="${build.dir}/gen-java/org/apache/hadoop/hive/ql/parse"/>
+ <mkdir dir="${build.dir}/gen/antlr/gen-java/org/apache/hadoop/hive/ql/parse"/>
</target>
<target name="compile" depends="init, ql-init, build-grammar">
<echo message="Compiling: ${name}"/>
<javac
encoding="${build.encoding}"
- srcdir="${src.dir}:${basedir}/src/gen-javabean:${build.dir}/gen-java"
+ srcdir="${src.dir}:${basedir}/src/gen/thrift/gen-javabean:${build.dir}/gen/antlr/gen-java"
includes="**/*.java"
destdir="${build.classes}"
debug="${javac.debug}"
@@ -166,7 +166,7 @@
<target name="jar" depends="compile">
<echo message="Jar: ${name}"/>
- <unzip src="${hive.root}/lib/libthrift.jar" dest="${build.dir.hive}/thrift/classes">
+ <unzip src="${hive.root}/lib/thrift-${thrift.version}.jar" dest="${build.dir.hive}/thrift/classes">
<patternset>
<exclude name="META-INF"/>
<exclude name="META-INF/MANIFEST.MF"/>
Modified: hive/trunk/ql/if/queryplan.thrift
URL: http://svn.apache.org/viewvc/hive/trunk/ql/if/queryplan.thrift?rev=1044070&r1=1044069&r2=1044070&view=diff
==============================================================================
--- hive/trunk/ql/if/queryplan.thrift (original)
+++ hive/trunk/ql/if/queryplan.thrift Thu Dec 9 18:30:58 2010
@@ -1,5 +1,5 @@
namespace java org.apache.hadoop.hive.ql.plan.api
-namespace cpp Hive
+namespace cpp Apache.Hadoop.Hive
enum AdjacencyType { CONJUNCTIVE, DISJUNCTIVE }
struct Adjacency {
@@ -16,7 +16,27 @@ struct Graph {
}
#Represents a operator along with its counters
-enum OperatorType { JOIN, MAPJOIN, EXTRACT, FILTER, FORWARD, GROUPBY, LIMIT, SCRIPT, SELECT, TABLESCAN, FILESINK, REDUCESINK, UNION, UDTF, LATERALVIEWJOIN, LATERALVIEWFORWARD, HASHTABLESINK, HASHTABLEDUMMY }
+enum OperatorType {
+ JOIN,
+ MAPJOIN,
+ EXTRACT,
+ FILTER,
+ FORWARD,
+ GROUPBY,
+ LIMIT,
+ SCRIPT,
+ SELECT,
+ TABLESCAN,
+ FILESINK,
+ REDUCESINK,
+ UNION,
+ UDTF,
+ LATERALVIEWJOIN,
+ LATERALVIEWFORWARD,
+ HASHTABLESINK,
+ HASHTABLEDUMMY,
+}
+
struct Operator {
1: string operatorId,
2: OperatorType operatorType,
@@ -41,7 +61,18 @@ struct Task {
}
# Represents a Stage - unfortunately, it is represented as Task in ql/exec
-enum StageType { CONDITIONAL, COPY, DDL, MAPRED, EXPLAIN, FETCH, FUNC, MAPREDLOCAL, MOVE, STATS }
+enum StageType {
+ CONDITIONAL,
+ COPY,
+ DDL,
+ MAPRED,
+ EXPLAIN,
+ FETCH,
+ FUNC,
+ MAPREDLOCAL,
+ MOVE,
+ STATS,
+}
struct Stage {
1: string stageId,
Modified: hive/trunk/ql/ivy.xml
URL: http://svn.apache.org/viewvc/hive/trunk/ql/ivy.xml?rev=1044070&r1=1044069&r2=1044070&view=diff
==============================================================================
--- hive/trunk/ql/ivy.xml (original)
+++ hive/trunk/ql/ivy.xml Thu Dec 9 18:30:58 2010
@@ -3,6 +3,8 @@
<dependencies>
<dependency org="hadoop" name="core" rev="${hadoop.version.ant-internal}">
<artifact name="hadoop" type="source" ext="tar.gz"/>
- </dependency>
+ </dependency>
+ <dependency org="org.slf4j" name="slf4j-api" rev="${slf4j-api.version}"/>
+ <dependency org="org.slf4j" name="slf4j-log4j12" rev="${slf4j-log4j12.version}"/>
</dependencies>
</ivy-module>
Added: hive/trunk/ql/src/gen/thrift/gen-cpp/queryplan_constants.cpp
URL: http://svn.apache.org/viewvc/hive/trunk/ql/src/gen/thrift/gen-cpp/queryplan_constants.cpp?rev=1044070&view=auto
==============================================================================
--- hive/trunk/ql/src/gen/thrift/gen-cpp/queryplan_constants.cpp (added)
+++ hive/trunk/ql/src/gen/thrift/gen-cpp/queryplan_constants.cpp Thu Dec 9 18:30:58 2010
@@ -0,0 +1,16 @@
+/**
+ * Autogenerated by Thrift
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ */
+#include "queryplan_constants.h"
+
+namespace Apache { namespace Hadoop { namespace Hive {
+
+const queryplanConstants g_queryplan_constants;
+
+queryplanConstants::queryplanConstants() {
+}
+
+}}} // namespace
+
Added: hive/trunk/ql/src/gen/thrift/gen-cpp/queryplan_constants.h
URL: http://svn.apache.org/viewvc/hive/trunk/ql/src/gen/thrift/gen-cpp/queryplan_constants.h?rev=1044070&view=auto
==============================================================================
--- hive/trunk/ql/src/gen/thrift/gen-cpp/queryplan_constants.h (added)
+++ hive/trunk/ql/src/gen/thrift/gen-cpp/queryplan_constants.h Thu Dec 9 18:30:58 2010
@@ -0,0 +1,23 @@
+/**
+ * Autogenerated by Thrift
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ */
+#ifndef queryplan_CONSTANTS_H
+#define queryplan_CONSTANTS_H
+
+#include "queryplan_types.h"
+
+namespace Apache { namespace Hadoop { namespace Hive {
+
+class queryplanConstants {
+ public:
+ queryplanConstants();
+
+};
+
+extern const queryplanConstants g_queryplan_constants;
+
+}}} // namespace
+
+#endif
Added: hive/trunk/ql/src/gen/thrift/gen-cpp/queryplan_types.cpp
URL: http://svn.apache.org/viewvc/hive/trunk/ql/src/gen/thrift/gen-cpp/queryplan_types.cpp?rev=1044070&view=auto
==============================================================================
--- hive/trunk/ql/src/gen/thrift/gen-cpp/queryplan_types.cpp (added)
+++ hive/trunk/ql/src/gen/thrift/gen-cpp/queryplan_types.cpp Thu Dec 9 18:30:58 2010
@@ -0,0 +1,1075 @@
+/**
+ * Autogenerated by Thrift
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ */
+#include "queryplan_types.h"
+
+namespace Apache { namespace Hadoop { namespace Hive {
+
+const char* Adjacency::ascii_fingerprint = "BC4F8C394677A1003AA9F56ED26D8204";
+const uint8_t Adjacency::binary_fingerprint[16] = {0xBC,0x4F,0x8C,0x39,0x46,0x77,0xA1,0x00,0x3A,0xA9,0xF5,0x6E,0xD2,0x6D,0x82,0x04};
+
+uint32_t Adjacency::read(::apache::thrift::protocol::TProtocol* 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;
+
+
+ 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->node);
+ this->__isset.node = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->children.clear();
+ uint32_t _size0;
+ ::apache::thrift::protocol::TType _etype3;
+ iprot->readListBegin(_etype3, _size0);
+ this->children.resize(_size0);
+ uint32_t _i4;
+ for (_i4 = 0; _i4 < _size0; ++_i4)
+ {
+ xfer += iprot->readString(this->children[_i4]);
+ }
+ iprot->readListEnd();
+ }
+ this->__isset.children = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ int32_t ecast5;
+ xfer += iprot->readI32(ecast5);
+ this->adjacencyType = (AdjacencyType::type)ecast5;
+ this->__isset.adjacencyType = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Adjacency::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Adjacency");
+ xfer += oprot->writeFieldBegin("node", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->node);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("children", ::apache::thrift::protocol::T_LIST, 2);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, this->children.size());
+ std::vector<std::string> ::const_iterator _iter6;
+ for (_iter6 = this->children.begin(); _iter6 != this->children.end(); ++_iter6)
+ {
+ xfer += oprot->writeString((*_iter6));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("adjacencyType", ::apache::thrift::protocol::T_I32, 3);
+ xfer += oprot->writeI32((int32_t)this->adjacencyType);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+const char* Graph::ascii_fingerprint = "1F7FB604B3EF8F7AFB5DEAD15F2FC0B5";
+const uint8_t Graph::binary_fingerprint[16] = {0x1F,0x7F,0xB6,0x04,0xB3,0xEF,0x8F,0x7A,0xFB,0x5D,0xEA,0xD1,0x5F,0x2F,0xC0,0xB5};
+
+uint32_t Graph::read(::apache::thrift::protocol::TProtocol* 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;
+
+
+ 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_I32) {
+ int32_t ecast7;
+ xfer += iprot->readI32(ecast7);
+ this->nodeType = (NodeType::type)ecast7;
+ this->__isset.nodeType = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->roots.clear();
+ uint32_t _size8;
+ ::apache::thrift::protocol::TType _etype11;
+ iprot->readListBegin(_etype11, _size8);
+ this->roots.resize(_size8);
+ uint32_t _i12;
+ for (_i12 = 0; _i12 < _size8; ++_i12)
+ {
+ xfer += iprot->readString(this->roots[_i12]);
+ }
+ iprot->readListEnd();
+ }
+ this->__isset.roots = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->adjacencyList.clear();
+ uint32_t _size13;
+ ::apache::thrift::protocol::TType _etype16;
+ iprot->readListBegin(_etype16, _size13);
+ this->adjacencyList.resize(_size13);
+ uint32_t _i17;
+ for (_i17 = 0; _i17 < _size13; ++_i17)
+ {
+ xfer += this->adjacencyList[_i17].read(iprot);
+ }
+ iprot->readListEnd();
+ }
+ this->__isset.adjacencyList = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Graph::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Graph");
+ xfer += oprot->writeFieldBegin("nodeType", ::apache::thrift::protocol::T_I32, 1);
+ xfer += oprot->writeI32((int32_t)this->nodeType);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("roots", ::apache::thrift::protocol::T_LIST, 2);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, this->roots.size());
+ std::vector<std::string> ::const_iterator _iter18;
+ for (_iter18 = this->roots.begin(); _iter18 != this->roots.end(); ++_iter18)
+ {
+ xfer += oprot->writeString((*_iter18));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("adjacencyList", ::apache::thrift::protocol::T_LIST, 3);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, this->adjacencyList.size());
+ std::vector<Adjacency> ::const_iterator _iter19;
+ for (_iter19 = this->adjacencyList.begin(); _iter19 != this->adjacencyList.end(); ++_iter19)
+ {
+ xfer += (*_iter19).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+const char* Operator::ascii_fingerprint = "30917C758A752485AF223B697479DE6C";
+const uint8_t Operator::binary_fingerprint[16] = {0x30,0x91,0x7C,0x75,0x8A,0x75,0x24,0x85,0xAF,0x22,0x3B,0x69,0x74,0x79,0xDE,0x6C};
+
+uint32_t Operator::read(::apache::thrift::protocol::TProtocol* 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;
+
+
+ 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->operatorId);
+ this->__isset.operatorId = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ int32_t ecast20;
+ xfer += iprot->readI32(ecast20);
+ this->operatorType = (OperatorType::type)ecast20;
+ this->__isset.operatorType = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_MAP) {
+ {
+ this->operatorAttributes.clear();
+ uint32_t _size21;
+ ::apache::thrift::protocol::TType _ktype22;
+ ::apache::thrift::protocol::TType _vtype23;
+ iprot->readMapBegin(_ktype22, _vtype23, _size21);
+ uint32_t _i25;
+ for (_i25 = 0; _i25 < _size21; ++_i25)
+ {
+ std::string _key26;
+ xfer += iprot->readString(_key26);
+ std::string& _val27 = this->operatorAttributes[_key26];
+ xfer += iprot->readString(_val27);
+ }
+ iprot->readMapEnd();
+ }
+ this->__isset.operatorAttributes = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_MAP) {
+ {
+ this->operatorCounters.clear();
+ uint32_t _size28;
+ ::apache::thrift::protocol::TType _ktype29;
+ ::apache::thrift::protocol::TType _vtype30;
+ iprot->readMapBegin(_ktype29, _vtype30, _size28);
+ uint32_t _i32;
+ for (_i32 = 0; _i32 < _size28; ++_i32)
+ {
+ std::string _key33;
+ xfer += iprot->readString(_key33);
+ int64_t& _val34 = this->operatorCounters[_key33];
+ xfer += iprot->readI64(_val34);
+ }
+ iprot->readMapEnd();
+ }
+ this->__isset.operatorCounters = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->done);
+ this->__isset.done = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 6:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->started);
+ this->__isset.started = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Operator::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Operator");
+ xfer += oprot->writeFieldBegin("operatorId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->operatorId);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("operatorType", ::apache::thrift::protocol::T_I32, 2);
+ xfer += oprot->writeI32((int32_t)this->operatorType);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("operatorAttributes", ::apache::thrift::protocol::T_MAP, 3);
+ {
+ xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, this->operatorAttributes.size());
+ std::map<std::string, std::string> ::const_iterator _iter35;
+ for (_iter35 = this->operatorAttributes.begin(); _iter35 != this->operatorAttributes.end(); ++_iter35)
+ {
+ xfer += oprot->writeString(_iter35->first);
+ xfer += oprot->writeString(_iter35->second);
+ }
+ xfer += oprot->writeMapEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("operatorCounters", ::apache::thrift::protocol::T_MAP, 4);
+ {
+ xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_I64, this->operatorCounters.size());
+ std::map<std::string, int64_t> ::const_iterator _iter36;
+ for (_iter36 = this->operatorCounters.begin(); _iter36 != this->operatorCounters.end(); ++_iter36)
+ {
+ xfer += oprot->writeString(_iter36->first);
+ xfer += oprot->writeI64(_iter36->second);
+ }
+ xfer += oprot->writeMapEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("done", ::apache::thrift::protocol::T_BOOL, 5);
+ xfer += oprot->writeBool(this->done);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("started", ::apache::thrift::protocol::T_BOOL, 6);
+ xfer += oprot->writeBool(this->started);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+const char* Task::ascii_fingerprint = "AC741A136EFA51843AFC3A12F6A793D1";
+const uint8_t Task::binary_fingerprint[16] = {0xAC,0x74,0x1A,0x13,0x6E,0xFA,0x51,0x84,0x3A,0xFC,0x3A,0x12,0xF6,0xA7,0x93,0xD1};
+
+uint32_t Task::read(::apache::thrift::protocol::TProtocol* 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;
+
+
+ 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->taskId);
+ this->__isset.taskId = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ int32_t ecast37;
+ xfer += iprot->readI32(ecast37);
+ this->taskType = (TaskType::type)ecast37;
+ this->__isset.taskType = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_MAP) {
+ {
+ this->taskAttributes.clear();
+ uint32_t _size38;
+ ::apache::thrift::protocol::TType _ktype39;
+ ::apache::thrift::protocol::TType _vtype40;
+ iprot->readMapBegin(_ktype39, _vtype40, _size38);
+ uint32_t _i42;
+ for (_i42 = 0; _i42 < _size38; ++_i42)
+ {
+ std::string _key43;
+ xfer += iprot->readString(_key43);
+ std::string& _val44 = this->taskAttributes[_key43];
+ xfer += iprot->readString(_val44);
+ }
+ iprot->readMapEnd();
+ }
+ this->__isset.taskAttributes = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_MAP) {
+ {
+ this->taskCounters.clear();
+ uint32_t _size45;
+ ::apache::thrift::protocol::TType _ktype46;
+ ::apache::thrift::protocol::TType _vtype47;
+ iprot->readMapBegin(_ktype46, _vtype47, _size45);
+ uint32_t _i49;
+ for (_i49 = 0; _i49 < _size45; ++_i49)
+ {
+ std::string _key50;
+ xfer += iprot->readString(_key50);
+ int64_t& _val51 = this->taskCounters[_key50];
+ xfer += iprot->readI64(_val51);
+ }
+ iprot->readMapEnd();
+ }
+ this->__isset.taskCounters = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->operatorGraph.read(iprot);
+ this->__isset.operatorGraph = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 6:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->operatorList.clear();
+ uint32_t _size52;
+ ::apache::thrift::protocol::TType _etype55;
+ iprot->readListBegin(_etype55, _size52);
+ this->operatorList.resize(_size52);
+ uint32_t _i56;
+ for (_i56 = 0; _i56 < _size52; ++_i56)
+ {
+ xfer += this->operatorList[_i56].read(iprot);
+ }
+ iprot->readListEnd();
+ }
+ this->__isset.operatorList = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 7:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->done);
+ this->__isset.done = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 8:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->started);
+ this->__isset.started = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Task::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Task");
+ xfer += oprot->writeFieldBegin("taskId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->taskId);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("taskType", ::apache::thrift::protocol::T_I32, 2);
+ xfer += oprot->writeI32((int32_t)this->taskType);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("taskAttributes", ::apache::thrift::protocol::T_MAP, 3);
+ {
+ xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, this->taskAttributes.size());
+ std::map<std::string, std::string> ::const_iterator _iter57;
+ for (_iter57 = this->taskAttributes.begin(); _iter57 != this->taskAttributes.end(); ++_iter57)
+ {
+ xfer += oprot->writeString(_iter57->first);
+ xfer += oprot->writeString(_iter57->second);
+ }
+ xfer += oprot->writeMapEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("taskCounters", ::apache::thrift::protocol::T_MAP, 4);
+ {
+ xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_I64, this->taskCounters.size());
+ std::map<std::string, int64_t> ::const_iterator _iter58;
+ for (_iter58 = this->taskCounters.begin(); _iter58 != this->taskCounters.end(); ++_iter58)
+ {
+ xfer += oprot->writeString(_iter58->first);
+ xfer += oprot->writeI64(_iter58->second);
+ }
+ xfer += oprot->writeMapEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ if (this->__isset.operatorGraph) {
+ xfer += oprot->writeFieldBegin("operatorGraph", ::apache::thrift::protocol::T_STRUCT, 5);
+ xfer += this->operatorGraph.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.operatorList) {
+ xfer += oprot->writeFieldBegin("operatorList", ::apache::thrift::protocol::T_LIST, 6);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, this->operatorList.size());
+ std::vector<Operator> ::const_iterator _iter59;
+ for (_iter59 = this->operatorList.begin(); _iter59 != this->operatorList.end(); ++_iter59)
+ {
+ xfer += (*_iter59).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldBegin("done", ::apache::thrift::protocol::T_BOOL, 7);
+ xfer += oprot->writeBool(this->done);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("started", ::apache::thrift::protocol::T_BOOL, 8);
+ xfer += oprot->writeBool(this->started);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+const char* Stage::ascii_fingerprint = "86EA3C7B0690AFED21A3D479E2B32378";
+const uint8_t Stage::binary_fingerprint[16] = {0x86,0xEA,0x3C,0x7B,0x06,0x90,0xAF,0xED,0x21,0xA3,0xD4,0x79,0xE2,0xB3,0x23,0x78};
+
+uint32_t Stage::read(::apache::thrift::protocol::TProtocol* 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;
+
+
+ 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->stageId);
+ this->__isset.stageId = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ int32_t ecast60;
+ xfer += iprot->readI32(ecast60);
+ this->stageType = (StageType::type)ecast60;
+ this->__isset.stageType = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_MAP) {
+ {
+ this->stageAttributes.clear();
+ uint32_t _size61;
+ ::apache::thrift::protocol::TType _ktype62;
+ ::apache::thrift::protocol::TType _vtype63;
+ iprot->readMapBegin(_ktype62, _vtype63, _size61);
+ uint32_t _i65;
+ for (_i65 = 0; _i65 < _size61; ++_i65)
+ {
+ std::string _key66;
+ xfer += iprot->readString(_key66);
+ std::string& _val67 = this->stageAttributes[_key66];
+ xfer += iprot->readString(_val67);
+ }
+ iprot->readMapEnd();
+ }
+ this->__isset.stageAttributes = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_MAP) {
+ {
+ this->stageCounters.clear();
+ uint32_t _size68;
+ ::apache::thrift::protocol::TType _ktype69;
+ ::apache::thrift::protocol::TType _vtype70;
+ iprot->readMapBegin(_ktype69, _vtype70, _size68);
+ uint32_t _i72;
+ for (_i72 = 0; _i72 < _size68; ++_i72)
+ {
+ std::string _key73;
+ xfer += iprot->readString(_key73);
+ int64_t& _val74 = this->stageCounters[_key73];
+ xfer += iprot->readI64(_val74);
+ }
+ iprot->readMapEnd();
+ }
+ this->__isset.stageCounters = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->taskList.clear();
+ uint32_t _size75;
+ ::apache::thrift::protocol::TType _etype78;
+ iprot->readListBegin(_etype78, _size75);
+ this->taskList.resize(_size75);
+ uint32_t _i79;
+ for (_i79 = 0; _i79 < _size75; ++_i79)
+ {
+ xfer += this->taskList[_i79].read(iprot);
+ }
+ iprot->readListEnd();
+ }
+ this->__isset.taskList = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 6:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->done);
+ this->__isset.done = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 7:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->started);
+ this->__isset.started = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Stage::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Stage");
+ xfer += oprot->writeFieldBegin("stageId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->stageId);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("stageType", ::apache::thrift::protocol::T_I32, 2);
+ xfer += oprot->writeI32((int32_t)this->stageType);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("stageAttributes", ::apache::thrift::protocol::T_MAP, 3);
+ {
+ xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, this->stageAttributes.size());
+ std::map<std::string, std::string> ::const_iterator _iter80;
+ for (_iter80 = this->stageAttributes.begin(); _iter80 != this->stageAttributes.end(); ++_iter80)
+ {
+ xfer += oprot->writeString(_iter80->first);
+ xfer += oprot->writeString(_iter80->second);
+ }
+ xfer += oprot->writeMapEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("stageCounters", ::apache::thrift::protocol::T_MAP, 4);
+ {
+ xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_I64, this->stageCounters.size());
+ std::map<std::string, int64_t> ::const_iterator _iter81;
+ for (_iter81 = this->stageCounters.begin(); _iter81 != this->stageCounters.end(); ++_iter81)
+ {
+ xfer += oprot->writeString(_iter81->first);
+ xfer += oprot->writeI64(_iter81->second);
+ }
+ xfer += oprot->writeMapEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("taskList", ::apache::thrift::protocol::T_LIST, 5);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, this->taskList.size());
+ std::vector<Task> ::const_iterator _iter82;
+ for (_iter82 = this->taskList.begin(); _iter82 != this->taskList.end(); ++_iter82)
+ {
+ xfer += (*_iter82).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("done", ::apache::thrift::protocol::T_BOOL, 6);
+ xfer += oprot->writeBool(this->done);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("started", ::apache::thrift::protocol::T_BOOL, 7);
+ xfer += oprot->writeBool(this->started);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+const char* Query::ascii_fingerprint = "68300D63A5D40F2D17B9A9440FF626C1";
+const uint8_t Query::binary_fingerprint[16] = {0x68,0x30,0x0D,0x63,0xA5,0xD4,0x0F,0x2D,0x17,0xB9,0xA9,0x44,0x0F,0xF6,0x26,0xC1};
+
+uint32_t Query::read(::apache::thrift::protocol::TProtocol* 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;
+
+
+ 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);
+ this->__isset.queryId = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->queryType);
+ this->__isset.queryType = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_MAP) {
+ {
+ this->queryAttributes.clear();
+ uint32_t _size83;
+ ::apache::thrift::protocol::TType _ktype84;
+ ::apache::thrift::protocol::TType _vtype85;
+ iprot->readMapBegin(_ktype84, _vtype85, _size83);
+ uint32_t _i87;
+ for (_i87 = 0; _i87 < _size83; ++_i87)
+ {
+ std::string _key88;
+ xfer += iprot->readString(_key88);
+ std::string& _val89 = this->queryAttributes[_key88];
+ xfer += iprot->readString(_val89);
+ }
+ iprot->readMapEnd();
+ }
+ this->__isset.queryAttributes = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_MAP) {
+ {
+ this->queryCounters.clear();
+ uint32_t _size90;
+ ::apache::thrift::protocol::TType _ktype91;
+ ::apache::thrift::protocol::TType _vtype92;
+ iprot->readMapBegin(_ktype91, _vtype92, _size90);
+ uint32_t _i94;
+ for (_i94 = 0; _i94 < _size90; ++_i94)
+ {
+ std::string _key95;
+ xfer += iprot->readString(_key95);
+ int64_t& _val96 = this->queryCounters[_key95];
+ xfer += iprot->readI64(_val96);
+ }
+ iprot->readMapEnd();
+ }
+ this->__isset.queryCounters = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->stageGraph.read(iprot);
+ this->__isset.stageGraph = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 6:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->stageList.clear();
+ uint32_t _size97;
+ ::apache::thrift::protocol::TType _etype100;
+ iprot->readListBegin(_etype100, _size97);
+ this->stageList.resize(_size97);
+ uint32_t _i101;
+ for (_i101 = 0; _i101 < _size97; ++_i101)
+ {
+ xfer += this->stageList[_i101].read(iprot);
+ }
+ iprot->readListEnd();
+ }
+ this->__isset.stageList = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 7:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->done);
+ this->__isset.done = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 8:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->started);
+ this->__isset.started = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t Query::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("Query");
+ xfer += oprot->writeFieldBegin("queryId", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->queryId);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("queryType", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->queryType);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("queryAttributes", ::apache::thrift::protocol::T_MAP, 3);
+ {
+ xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, this->queryAttributes.size());
+ std::map<std::string, std::string> ::const_iterator _iter102;
+ for (_iter102 = this->queryAttributes.begin(); _iter102 != this->queryAttributes.end(); ++_iter102)
+ {
+ xfer += oprot->writeString(_iter102->first);
+ xfer += oprot->writeString(_iter102->second);
+ }
+ xfer += oprot->writeMapEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("queryCounters", ::apache::thrift::protocol::T_MAP, 4);
+ {
+ xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_I64, this->queryCounters.size());
+ std::map<std::string, int64_t> ::const_iterator _iter103;
+ for (_iter103 = this->queryCounters.begin(); _iter103 != this->queryCounters.end(); ++_iter103)
+ {
+ xfer += oprot->writeString(_iter103->first);
+ xfer += oprot->writeI64(_iter103->second);
+ }
+ xfer += oprot->writeMapEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("stageGraph", ::apache::thrift::protocol::T_STRUCT, 5);
+ xfer += this->stageGraph.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("stageList", ::apache::thrift::protocol::T_LIST, 6);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, this->stageList.size());
+ std::vector<Stage> ::const_iterator _iter104;
+ for (_iter104 = this->stageList.begin(); _iter104 != this->stageList.end(); ++_iter104)
+ {
+ xfer += (*_iter104).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("done", ::apache::thrift::protocol::T_BOOL, 7);
+ xfer += oprot->writeBool(this->done);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("started", ::apache::thrift::protocol::T_BOOL, 8);
+ xfer += oprot->writeBool(this->started);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+const char* QueryPlan::ascii_fingerprint = "3418D1B0C20C288C8406186700B772E3";
+const uint8_t QueryPlan::binary_fingerprint[16] = {0x34,0x18,0xD1,0xB0,0xC2,0x0C,0x28,0x8C,0x84,0x06,0x18,0x67,0x00,0xB7,0x72,0xE3};
+
+uint32_t QueryPlan::read(::apache::thrift::protocol::TProtocol* 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;
+
+
+ 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_LIST) {
+ {
+ this->queries.clear();
+ uint32_t _size105;
+ ::apache::thrift::protocol::TType _etype108;
+ iprot->readListBegin(_etype108, _size105);
+ this->queries.resize(_size105);
+ uint32_t _i109;
+ for (_i109 = 0; _i109 < _size105; ++_i109)
+ {
+ xfer += this->queries[_i109].read(iprot);
+ }
+ iprot->readListEnd();
+ }
+ this->__isset.queries = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->done);
+ this->__isset.done = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->started);
+ this->__isset.started = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t QueryPlan::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("QueryPlan");
+ xfer += oprot->writeFieldBegin("queries", ::apache::thrift::protocol::T_LIST, 1);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, this->queries.size());
+ std::vector<Query> ::const_iterator _iter110;
+ for (_iter110 = this->queries.begin(); _iter110 != this->queries.end(); ++_iter110)
+ {
+ xfer += (*_iter110).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("done", ::apache::thrift::protocol::T_BOOL, 2);
+ xfer += oprot->writeBool(this->done);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("started", ::apache::thrift::protocol::T_BOOL, 3);
+ xfer += oprot->writeBool(this->started);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+}}} // namespace
Added: hive/trunk/ql/src/gen/thrift/gen-cpp/queryplan_types.h
URL: http://svn.apache.org/viewvc/hive/trunk/ql/src/gen/thrift/gen-cpp/queryplan_types.h?rev=1044070&view=auto
==============================================================================
--- hive/trunk/ql/src/gen/thrift/gen-cpp/queryplan_types.h (added)
+++ hive/trunk/ql/src/gen/thrift/gen-cpp/queryplan_types.h Thu Dec 9 18:30:58 2010
@@ -0,0 +1,467 @@
+/**
+ * Autogenerated by Thrift
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ */
+#ifndef queryplan_TYPES_H
+#define queryplan_TYPES_H
+
+#include <Thrift.h>
+#include <TApplicationException.h>
+#include <protocol/TProtocol.h>
+#include <transport/TTransport.h>
+
+
+
+namespace Apache { namespace Hadoop { namespace Hive {
+
+struct AdjacencyType {
+ enum type {
+ CONJUNCTIVE = 0,
+ DISJUNCTIVE = 1
+ };
+};
+
+struct NodeType {
+ enum type {
+ OPERATOR = 0,
+ STAGE = 1
+ };
+};
+
+struct OperatorType {
+ enum type {
+ JOIN = 0,
+ MAPJOIN = 1,
+ EXTRACT = 2,
+ FILTER = 3,
+ FORWARD = 4,
+ GROUPBY = 5,
+ LIMIT = 6,
+ SCRIPT = 7,
+ SELECT = 8,
+ TABLESCAN = 9,
+ FILESINK = 10,
+ REDUCESINK = 11,
+ UNION = 12,
+ UDTF = 13,
+ LATERALVIEWJOIN = 14,
+ LATERALVIEWFORWARD = 15,
+ HASHTABLESINK = 16,
+ HASHTABLEDUMMY = 17
+ };
+};
+
+struct TaskType {
+ enum type {
+ MAP = 0,
+ REDUCE = 1,
+ OTHER = 2
+ };
+};
+
+struct StageType {
+ enum type {
+ CONDITIONAL = 0,
+ COPY = 1,
+ DDL = 2,
+ MAPRED = 3,
+ EXPLAIN = 4,
+ FETCH = 5,
+ FUNC = 6,
+ MAPREDLOCAL = 7,
+ MOVE = 8,
+ STATS = 9
+ };
+};
+
+typedef struct _Adjacency__isset {
+ _Adjacency__isset() : node(false), children(false), adjacencyType(false) {}
+ bool node;
+ bool children;
+ bool adjacencyType;
+} _Adjacency__isset;
+
+class Adjacency {
+ public:
+
+ static const char* ascii_fingerprint; // = "BC4F8C394677A1003AA9F56ED26D8204";
+ static const uint8_t binary_fingerprint[16]; // = {0xBC,0x4F,0x8C,0x39,0x46,0x77,0xA1,0x00,0x3A,0xA9,0xF5,0x6E,0xD2,0x6D,0x82,0x04};
+
+ Adjacency() : node("") {
+ }
+
+ virtual ~Adjacency() throw() {}
+
+ std::string node;
+ std::vector<std::string> children;
+ AdjacencyType::type adjacencyType;
+
+ _Adjacency__isset __isset;
+
+ bool operator == (const Adjacency & rhs) const
+ {
+ if (!(node == rhs.node))
+ return false;
+ if (!(children == rhs.children))
+ return false;
+ if (!(adjacencyType == rhs.adjacencyType))
+ return false;
+ return true;
+ }
+ bool operator != (const Adjacency &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Adjacency & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Graph__isset {
+ _Graph__isset() : nodeType(false), roots(false), adjacencyList(false) {}
+ bool nodeType;
+ bool roots;
+ bool adjacencyList;
+} _Graph__isset;
+
+class Graph {
+ public:
+
+ static const char* ascii_fingerprint; // = "1F7FB604B3EF8F7AFB5DEAD15F2FC0B5";
+ static const uint8_t binary_fingerprint[16]; // = {0x1F,0x7F,0xB6,0x04,0xB3,0xEF,0x8F,0x7A,0xFB,0x5D,0xEA,0xD1,0x5F,0x2F,0xC0,0xB5};
+
+ Graph() {
+ }
+
+ virtual ~Graph() throw() {}
+
+ NodeType::type nodeType;
+ std::vector<std::string> roots;
+ std::vector<Adjacency> adjacencyList;
+
+ _Graph__isset __isset;
+
+ bool operator == (const Graph & rhs) const
+ {
+ if (!(nodeType == rhs.nodeType))
+ return false;
+ if (!(roots == rhs.roots))
+ return false;
+ if (!(adjacencyList == rhs.adjacencyList))
+ return false;
+ return true;
+ }
+ bool operator != (const Graph &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Graph & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Operator__isset {
+ _Operator__isset() : operatorId(false), operatorType(false), operatorAttributes(false), operatorCounters(false), done(false), started(false) {}
+ bool operatorId;
+ bool operatorType;
+ bool operatorAttributes;
+ bool operatorCounters;
+ bool done;
+ bool started;
+} _Operator__isset;
+
+class Operator {
+ public:
+
+ static const char* ascii_fingerprint; // = "30917C758A752485AF223B697479DE6C";
+ static const uint8_t binary_fingerprint[16]; // = {0x30,0x91,0x7C,0x75,0x8A,0x75,0x24,0x85,0xAF,0x22,0x3B,0x69,0x74,0x79,0xDE,0x6C};
+
+ Operator() : operatorId(""), done(0), started(0) {
+ }
+
+ virtual ~Operator() throw() {}
+
+ std::string operatorId;
+ OperatorType::type operatorType;
+ std::map<std::string, std::string> operatorAttributes;
+ std::map<std::string, int64_t> operatorCounters;
+ bool done;
+ bool started;
+
+ _Operator__isset __isset;
+
+ bool operator == (const Operator & rhs) const
+ {
+ if (!(operatorId == rhs.operatorId))
+ return false;
+ if (!(operatorType == rhs.operatorType))
+ return false;
+ if (!(operatorAttributes == rhs.operatorAttributes))
+ return false;
+ if (!(operatorCounters == rhs.operatorCounters))
+ return false;
+ if (!(done == rhs.done))
+ return false;
+ if (!(started == rhs.started))
+ return false;
+ return true;
+ }
+ bool operator != (const Operator &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Operator & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Task__isset {
+ _Task__isset() : taskId(false), taskType(false), taskAttributes(false), taskCounters(false), operatorGraph(false), operatorList(false), done(false), started(false) {}
+ bool taskId;
+ bool taskType;
+ bool taskAttributes;
+ bool taskCounters;
+ bool operatorGraph;
+ bool operatorList;
+ bool done;
+ bool started;
+} _Task__isset;
+
+class Task {
+ public:
+
+ static const char* ascii_fingerprint; // = "AC741A136EFA51843AFC3A12F6A793D1";
+ static const uint8_t binary_fingerprint[16]; // = {0xAC,0x74,0x1A,0x13,0x6E,0xFA,0x51,0x84,0x3A,0xFC,0x3A,0x12,0xF6,0xA7,0x93,0xD1};
+
+ Task() : taskId(""), done(0), started(0) {
+ }
+
+ virtual ~Task() throw() {}
+
+ std::string taskId;
+ TaskType::type taskType;
+ std::map<std::string, std::string> taskAttributes;
+ std::map<std::string, int64_t> taskCounters;
+ Graph operatorGraph;
+ std::vector<Operator> operatorList;
+ bool done;
+ bool started;
+
+ _Task__isset __isset;
+
+ bool operator == (const Task & rhs) const
+ {
+ if (!(taskId == rhs.taskId))
+ return false;
+ if (!(taskType == rhs.taskType))
+ return false;
+ if (!(taskAttributes == rhs.taskAttributes))
+ return false;
+ if (!(taskCounters == rhs.taskCounters))
+ return false;
+ if (__isset.operatorGraph != rhs.__isset.operatorGraph)
+ return false;
+ else if (__isset.operatorGraph && !(operatorGraph == rhs.operatorGraph))
+ return false;
+ if (__isset.operatorList != rhs.__isset.operatorList)
+ return false;
+ else if (__isset.operatorList && !(operatorList == rhs.operatorList))
+ return false;
+ if (!(done == rhs.done))
+ return false;
+ if (!(started == rhs.started))
+ return false;
+ return true;
+ }
+ bool operator != (const Task &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Task & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Stage__isset {
+ _Stage__isset() : stageId(false), stageType(false), stageAttributes(false), stageCounters(false), taskList(false), done(false), started(false) {}
+ bool stageId;
+ bool stageType;
+ bool stageAttributes;
+ bool stageCounters;
+ bool taskList;
+ bool done;
+ bool started;
+} _Stage__isset;
+
+class Stage {
+ public:
+
+ static const char* ascii_fingerprint; // = "86EA3C7B0690AFED21A3D479E2B32378";
+ static const uint8_t binary_fingerprint[16]; // = {0x86,0xEA,0x3C,0x7B,0x06,0x90,0xAF,0xED,0x21,0xA3,0xD4,0x79,0xE2,0xB3,0x23,0x78};
+
+ Stage() : stageId(""), done(0), started(0) {
+ }
+
+ virtual ~Stage() throw() {}
+
+ std::string stageId;
+ StageType::type stageType;
+ std::map<std::string, std::string> stageAttributes;
+ std::map<std::string, int64_t> stageCounters;
+ std::vector<Task> taskList;
+ bool done;
+ bool started;
+
+ _Stage__isset __isset;
+
+ bool operator == (const Stage & rhs) const
+ {
+ if (!(stageId == rhs.stageId))
+ return false;
+ if (!(stageType == rhs.stageType))
+ return false;
+ if (!(stageAttributes == rhs.stageAttributes))
+ return false;
+ if (!(stageCounters == rhs.stageCounters))
+ return false;
+ if (!(taskList == rhs.taskList))
+ return false;
+ if (!(done == rhs.done))
+ return false;
+ if (!(started == rhs.started))
+ return false;
+ return true;
+ }
+ bool operator != (const Stage &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Stage & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Query__isset {
+ _Query__isset() : queryId(false), queryType(false), queryAttributes(false), queryCounters(false), stageGraph(false), stageList(false), done(false), started(false) {}
+ bool queryId;
+ bool queryType;
+ bool queryAttributes;
+ bool queryCounters;
+ bool stageGraph;
+ bool stageList;
+ bool done;
+ bool started;
+} _Query__isset;
+
+class Query {
+ public:
+
+ static const char* ascii_fingerprint; // = "68300D63A5D40F2D17B9A9440FF626C1";
+ static const uint8_t binary_fingerprint[16]; // = {0x68,0x30,0x0D,0x63,0xA5,0xD4,0x0F,0x2D,0x17,0xB9,0xA9,0x44,0x0F,0xF6,0x26,0xC1};
+
+ Query() : queryId(""), queryType(""), done(0), started(0) {
+ }
+
+ virtual ~Query() throw() {}
+
+ std::string queryId;
+ std::string queryType;
+ std::map<std::string, std::string> queryAttributes;
+ std::map<std::string, int64_t> queryCounters;
+ Graph stageGraph;
+ std::vector<Stage> stageList;
+ bool done;
+ bool started;
+
+ _Query__isset __isset;
+
+ bool operator == (const Query & rhs) const
+ {
+ if (!(queryId == rhs.queryId))
+ return false;
+ if (!(queryType == rhs.queryType))
+ return false;
+ if (!(queryAttributes == rhs.queryAttributes))
+ return false;
+ if (!(queryCounters == rhs.queryCounters))
+ return false;
+ if (!(stageGraph == rhs.stageGraph))
+ return false;
+ if (!(stageList == rhs.stageList))
+ return false;
+ if (!(done == rhs.done))
+ return false;
+ if (!(started == rhs.started))
+ return false;
+ return true;
+ }
+ bool operator != (const Query &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const Query & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _QueryPlan__isset {
+ _QueryPlan__isset() : queries(false), done(false), started(false) {}
+ bool queries;
+ bool done;
+ bool started;
+} _QueryPlan__isset;
+
+class QueryPlan {
+ public:
+
+ static const char* ascii_fingerprint; // = "3418D1B0C20C288C8406186700B772E3";
+ static const uint8_t binary_fingerprint[16]; // = {0x34,0x18,0xD1,0xB0,0xC2,0x0C,0x28,0x8C,0x84,0x06,0x18,0x67,0x00,0xB7,0x72,0xE3};
+
+ QueryPlan() : done(0), started(0) {
+ }
+
+ virtual ~QueryPlan() throw() {}
+
+ std::vector<Query> queries;
+ bool done;
+ bool started;
+
+ _QueryPlan__isset __isset;
+
+ bool operator == (const QueryPlan & rhs) const
+ {
+ if (!(queries == rhs.queries))
+ return false;
+ if (!(done == rhs.done))
+ return false;
+ if (!(started == rhs.started))
+ return false;
+ return true;
+ }
+ bool operator != (const QueryPlan &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const QueryPlan & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+}}} // namespace
+
+#endif
Added: hive/trunk/ql/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/ql/plan/api/Adjacency.java
URL: http://svn.apache.org/viewvc/hive/trunk/ql/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/ql/plan/api/Adjacency.java?rev=1044070&view=auto
==============================================================================
--- hive/trunk/ql/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/ql/plan/api/Adjacency.java (added)
+++ hive/trunk/ql/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/ql/plan/api/Adjacency.java Thu Dec 9 18:30:58 2010
@@ -0,0 +1,531 @@
+/**
+ * Autogenerated by Thrift
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ */
+package org.apache.hadoop.hive.ql.plan.api;
+
+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 org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.apache.thrift.*;
+import org.apache.thrift.async.*;
+import org.apache.thrift.meta_data.*;
+import org.apache.thrift.transport.*;
+import org.apache.thrift.protocol.*;
+
+public class Adjacency implements TBase<Adjacency, Adjacency._Fields>, java.io.Serializable, Cloneable {
+ private static final TStruct STRUCT_DESC = new TStruct("Adjacency");
+
+ private static final TField NODE_FIELD_DESC = new TField("node", TType.STRING, (short)1);
+ private static final TField CHILDREN_FIELD_DESC = new TField("children", TType.LIST, (short)2);
+ private static final TField ADJACENCY_TYPE_FIELD_DESC = new TField("adjacencyType", TType.I32, (short)3);
+
+ private String node;
+ private List<String> children;
+ private AdjacencyType adjacencyType;
+
+ /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+ public enum _Fields implements TFieldIdEnum {
+ NODE((short)1, "node"),
+ CHILDREN((short)2, "children"),
+ /**
+ *
+ * @see AdjacencyType
+ */
+ ADJACENCY_TYPE((short)3, "adjacencyType");
+
+ 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: // NODE
+ return NODE;
+ case 2: // CHILDREN
+ return CHILDREN;
+ case 3: // ADJACENCY_TYPE
+ return ADJACENCY_TYPE;
+ 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, FieldMetaData> metaDataMap;
+ static {
+ Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class);
+ tmpMap.put(_Fields.NODE, new FieldMetaData("node", TFieldRequirementType.DEFAULT,
+ new FieldValueMetaData(TType.STRING)));
+ tmpMap.put(_Fields.CHILDREN, new FieldMetaData("children", TFieldRequirementType.DEFAULT,
+ new ListMetaData(TType.LIST,
+ new FieldValueMetaData(TType.STRING))));
+ tmpMap.put(_Fields.ADJACENCY_TYPE, new FieldMetaData("adjacencyType", TFieldRequirementType.DEFAULT,
+ new EnumMetaData(TType.ENUM, AdjacencyType.class)));
+ metaDataMap = Collections.unmodifiableMap(tmpMap);
+ FieldMetaData.addStructMetaDataMap(Adjacency.class, metaDataMap);
+ }
+
+ public Adjacency() {
+ }
+
+ public Adjacency(
+ String node,
+ List<String> children,
+ AdjacencyType adjacencyType)
+ {
+ this();
+ this.node = node;
+ this.children = children;
+ this.adjacencyType = adjacencyType;
+ }
+
+ /**
+ * Performs a deep copy on <i>other</i>.
+ */
+ public Adjacency(Adjacency other) {
+ if (other.isSetNode()) {
+ this.node = other.node;
+ }
+ if (other.isSetChildren()) {
+ List<String> __this__children = new ArrayList<String>();
+ for (String other_element : other.children) {
+ __this__children.add(other_element);
+ }
+ this.children = __this__children;
+ }
+ if (other.isSetAdjacencyType()) {
+ this.adjacencyType = other.adjacencyType;
+ }
+ }
+
+ public Adjacency deepCopy() {
+ return new Adjacency(this);
+ }
+
+ @Override
+ public void clear() {
+ this.node = null;
+ this.children = null;
+ this.adjacencyType = null;
+ }
+
+ public String getNode() {
+ return this.node;
+ }
+
+ public void setNode(String node) {
+ this.node = node;
+ }
+
+ public void unsetNode() {
+ this.node = null;
+ }
+
+ /** Returns true if field node is set (has been asigned a value) and false otherwise */
+ public boolean isSetNode() {
+ return this.node != null;
+ }
+
+ public void setNodeIsSet(boolean value) {
+ if (!value) {
+ this.node = null;
+ }
+ }
+
+ public int getChildrenSize() {
+ return (this.children == null) ? 0 : this.children.size();
+ }
+
+ public java.util.Iterator<String> getChildrenIterator() {
+ return (this.children == null) ? null : this.children.iterator();
+ }
+
+ public void addToChildren(String elem) {
+ if (this.children == null) {
+ this.children = new ArrayList<String>();
+ }
+ this.children.add(elem);
+ }
+
+ public List<String> getChildren() {
+ return this.children;
+ }
+
+ public void setChildren(List<String> children) {
+ this.children = children;
+ }
+
+ public void unsetChildren() {
+ this.children = null;
+ }
+
+ /** Returns true if field children is set (has been asigned a value) and false otherwise */
+ public boolean isSetChildren() {
+ return this.children != null;
+ }
+
+ public void setChildrenIsSet(boolean value) {
+ if (!value) {
+ this.children = null;
+ }
+ }
+
+ /**
+ *
+ * @see AdjacencyType
+ */
+ public AdjacencyType getAdjacencyType() {
+ return this.adjacencyType;
+ }
+
+ /**
+ *
+ * @see AdjacencyType
+ */
+ public void setAdjacencyType(AdjacencyType adjacencyType) {
+ this.adjacencyType = adjacencyType;
+ }
+
+ public void unsetAdjacencyType() {
+ this.adjacencyType = null;
+ }
+
+ /** Returns true if field adjacencyType is set (has been asigned a value) and false otherwise */
+ public boolean isSetAdjacencyType() {
+ return this.adjacencyType != null;
+ }
+
+ public void setAdjacencyTypeIsSet(boolean value) {
+ if (!value) {
+ this.adjacencyType = null;
+ }
+ }
+
+ public void setFieldValue(_Fields field, Object value) {
+ switch (field) {
+ case NODE:
+ if (value == null) {
+ unsetNode();
+ } else {
+ setNode((String)value);
+ }
+ break;
+
+ case CHILDREN:
+ if (value == null) {
+ unsetChildren();
+ } else {
+ setChildren((List<String>)value);
+ }
+ break;
+
+ case ADJACENCY_TYPE:
+ if (value == null) {
+ unsetAdjacencyType();
+ } else {
+ setAdjacencyType((AdjacencyType)value);
+ }
+ break;
+
+ }
+ }
+
+ public Object getFieldValue(_Fields field) {
+ switch (field) {
+ case NODE:
+ return getNode();
+
+ case CHILDREN:
+ return getChildren();
+
+ case ADJACENCY_TYPE:
+ return getAdjacencyType();
+
+ }
+ throw new IllegalStateException();
+ }
+
+ /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
+ public boolean isSet(_Fields field) {
+ if (field == null) {
+ throw new IllegalArgumentException();
+ }
+
+ switch (field) {
+ case NODE:
+ return isSetNode();
+ case CHILDREN:
+ return isSetChildren();
+ case ADJACENCY_TYPE:
+ return isSetAdjacencyType();
+ }
+ throw new IllegalStateException();
+ }
+
+ @Override
+ public boolean equals(Object that) {
+ if (that == null)
+ return false;
+ if (that instanceof Adjacency)
+ return this.equals((Adjacency)that);
+ return false;
+ }
+
+ public boolean equals(Adjacency that) {
+ if (that == null)
+ return false;
+
+ boolean this_present_node = true && this.isSetNode();
+ boolean that_present_node = true && that.isSetNode();
+ if (this_present_node || that_present_node) {
+ if (!(this_present_node && that_present_node))
+ return false;
+ if (!this.node.equals(that.node))
+ return false;
+ }
+
+ boolean this_present_children = true && this.isSetChildren();
+ boolean that_present_children = true && that.isSetChildren();
+ if (this_present_children || that_present_children) {
+ if (!(this_present_children && that_present_children))
+ return false;
+ if (!this.children.equals(that.children))
+ return false;
+ }
+
+ boolean this_present_adjacencyType = true && this.isSetAdjacencyType();
+ boolean that_present_adjacencyType = true && that.isSetAdjacencyType();
+ if (this_present_adjacencyType || that_present_adjacencyType) {
+ if (!(this_present_adjacencyType && that_present_adjacencyType))
+ return false;
+ if (!this.adjacencyType.equals(that.adjacencyType))
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ return 0;
+ }
+
+ public int compareTo(Adjacency other) {
+ if (!getClass().equals(other.getClass())) {
+ return getClass().getName().compareTo(other.getClass().getName());
+ }
+
+ int lastComparison = 0;
+ Adjacency typedOther = (Adjacency)other;
+
+ lastComparison = Boolean.valueOf(isSetNode()).compareTo(typedOther.isSetNode());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetNode()) {
+ lastComparison = TBaseHelper.compareTo(this.node, typedOther.node);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = Boolean.valueOf(isSetChildren()).compareTo(typedOther.isSetChildren());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetChildren()) {
+ lastComparison = TBaseHelper.compareTo(this.children, typedOther.children);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ lastComparison = Boolean.valueOf(isSetAdjacencyType()).compareTo(typedOther.isSetAdjacencyType());
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ if (isSetAdjacencyType()) {
+ lastComparison = TBaseHelper.compareTo(this.adjacencyType, typedOther.adjacencyType);
+ if (lastComparison != 0) {
+ return lastComparison;
+ }
+ }
+ return 0;
+ }
+
+ public _Fields fieldForId(int fieldId) {
+ return _Fields.findByThriftId(fieldId);
+ }
+
+ public void read(TProtocol iprot) throws TException {
+ TField field;
+ iprot.readStructBegin();
+ while (true)
+ {
+ field = iprot.readFieldBegin();
+ if (field.type == TType.STOP) {
+ break;
+ }
+ switch (field.id) {
+ case 1: // NODE
+ if (field.type == TType.STRING) {
+ this.node = iprot.readString();
+ } else {
+ TProtocolUtil.skip(iprot, field.type);
+ }
+ break;
+ case 2: // CHILDREN
+ if (field.type == TType.LIST) {
+ {
+ TList _list0 = iprot.readListBegin();
+ this.children = new ArrayList<String>(_list0.size);
+ for (int _i1 = 0; _i1 < _list0.size; ++_i1)
+ {
+ String _elem2;
+ _elem2 = iprot.readString();
+ this.children.add(_elem2);
+ }
+ iprot.readListEnd();
+ }
+ } else {
+ TProtocolUtil.skip(iprot, field.type);
+ }
+ break;
+ case 3: // ADJACENCY_TYPE
+ if (field.type == TType.I32) {
+ this.adjacencyType = AdjacencyType.findByValue(iprot.readI32());
+ } else {
+ TProtocolUtil.skip(iprot, field.type);
+ }
+ break;
+ default:
+ TProtocolUtil.skip(iprot, field.type);
+ }
+ iprot.readFieldEnd();
+ }
+ iprot.readStructEnd();
+ validate();
+ }
+
+ public void write(TProtocol oprot) throws TException {
+ validate();
+
+ oprot.writeStructBegin(STRUCT_DESC);
+ if (this.node != null) {
+ oprot.writeFieldBegin(NODE_FIELD_DESC);
+ oprot.writeString(this.node);
+ oprot.writeFieldEnd();
+ }
+ if (this.children != null) {
+ oprot.writeFieldBegin(CHILDREN_FIELD_DESC);
+ {
+ oprot.writeListBegin(new TList(TType.STRING, this.children.size()));
+ for (String _iter3 : this.children)
+ {
+ oprot.writeString(_iter3);
+ }
+ oprot.writeListEnd();
+ }
+ oprot.writeFieldEnd();
+ }
+ if (this.adjacencyType != null) {
+ oprot.writeFieldBegin(ADJACENCY_TYPE_FIELD_DESC);
+ oprot.writeI32(this.adjacencyType.getValue());
+ oprot.writeFieldEnd();
+ }
+ oprot.writeFieldStop();
+ oprot.writeStructEnd();
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder("Adjacency(");
+ boolean first = true;
+
+ sb.append("node:");
+ if (this.node == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.node);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("children:");
+ if (this.children == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.children);
+ }
+ first = false;
+ if (!first) sb.append(", ");
+ sb.append("adjacencyType:");
+ if (this.adjacencyType == null) {
+ sb.append("null");
+ } else {
+ sb.append(this.adjacencyType);
+ }
+ first = false;
+ sb.append(")");
+ return sb.toString();
+ }
+
+ public void validate() throws TException {
+ // check for required fields
+ }
+
+}
+
Added: hive/trunk/ql/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/ql/plan/api/AdjacencyType.java
URL: http://svn.apache.org/viewvc/hive/trunk/ql/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/ql/plan/api/AdjacencyType.java?rev=1044070&view=auto
==============================================================================
--- hive/trunk/ql/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/ql/plan/api/AdjacencyType.java (added)
+++ hive/trunk/ql/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/ql/plan/api/AdjacencyType.java Thu Dec 9 18:30:58 2010
@@ -0,0 +1,44 @@
+/**
+ * Autogenerated by Thrift
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ */
+package org.apache.hadoop.hive.ql.plan.api;
+
+
+import java.util.Map;
+import java.util.HashMap;
+import org.apache.thrift.TEnum;
+
+public enum AdjacencyType implements TEnum {
+ CONJUNCTIVE(0),
+ DISJUNCTIVE(1);
+
+ private final int value;
+
+ private AdjacencyType(int value) {
+ this.value = value;
+ }
+
+ /**
+ * Get the integer value of this enum value, as defined in the Thrift IDL.
+ */
+ public int getValue() {
+ return value;
+ }
+
+ /**
+ * Find a the enum type by its integer value, as defined in the Thrift IDL.
+ * @return null if the value is not found.
+ */
+ public static AdjacencyType findByValue(int value) {
+ switch (value) {
+ case 0:
+ return CONJUNCTIVE;
+ case 1:
+ return DISJUNCTIVE;
+ default:
+ return null;
+ }
+ }
+}