hive-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nzh...@apache.org
Subject 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/ ...
Date Thu, 09 Dec 2010 18:31:09 GMT
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;
+    }
+  }
+}



Mime
View raw message