hive-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From amareshw...@apache.org
Subject [05/23] hive git commit: HIVE-11487 : Adds getNumPartitionsByFilter api in metastore api
Date Mon, 21 Dec 2015 08:45:55 GMT
http://git-wip-us.apache.org/repos/asf/hive/blob/ccb30e3e/service/src/gen/thrift/gen-cpp/TCLIService_types.h
----------------------------------------------------------------------
diff --git a/service/src/gen/thrift/gen-cpp/TCLIService_types.h b/service/src/gen/thrift/gen-cpp/TCLIService_types.h
index b078c99..4536b41 100644
--- a/service/src/gen/thrift/gen-cpp/TCLIService_types.h
+++ b/service/src/gen/thrift/gen-cpp/TCLIService_types.h
@@ -1,5 +1,5 @@
 /**
- * Autogenerated by Thrift Compiler (0.9.3)
+ * Autogenerated by Thrift Compiler (0.9.2)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  *  @generated
@@ -338,6 +338,9 @@ typedef struct _TTypeQualifierValue__isset {
 class TTypeQualifierValue {
  public:
 
+  static const char* ascii_fingerprint; // = "A7801670116150C65ACA43E6F679BA79";
+  static const uint8_t binary_fingerprint[16]; // = {0xA7,0x80,0x16,0x70,0x11,0x61,0x50,0xC6,0x5A,0xCA,0x43,0xE6,0xF6,0x79,0xBA,0x79};
+
   TTypeQualifierValue(const TTypeQualifierValue&);
   TTypeQualifierValue& operator=(const TTypeQualifierValue&);
   TTypeQualifierValue() : i32Value(0), stringValue() {
@@ -374,21 +377,18 @@ class TTypeQualifierValue {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TTypeQualifierValue& obj);
 };
 
 void swap(TTypeQualifierValue &a, TTypeQualifierValue &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TTypeQualifierValue& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 
 class TTypeQualifiers {
  public:
 
+  static const char* ascii_fingerprint; // = "6C72981CFA989214285648FA8C196C47";
+  static const uint8_t binary_fingerprint[16]; // = {0x6C,0x72,0x98,0x1C,0xFA,0x98,0x92,0x14,0x28,0x56,0x48,0xFA,0x8C,0x19,0x6C,0x47};
+
   TTypeQualifiers(const TTypeQualifiers&);
   TTypeQualifiers& operator=(const TTypeQualifiers&);
   TTypeQualifiers() {
@@ -414,17 +414,11 @@ class TTypeQualifiers {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TTypeQualifiers& obj);
 };
 
 void swap(TTypeQualifiers &a, TTypeQualifiers &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TTypeQualifiers& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 typedef struct _TPrimitiveTypeEntry__isset {
   _TPrimitiveTypeEntry__isset() : typeQualifiers(false) {}
   bool typeQualifiers :1;
@@ -433,6 +427,9 @@ typedef struct _TPrimitiveTypeEntry__isset {
 class TPrimitiveTypeEntry {
  public:
 
+  static const char* ascii_fingerprint; // = "755674F6A5C8EB47868686AE386FBC1C";
+  static const uint8_t binary_fingerprint[16]; // = {0x75,0x56,0x74,0xF6,0xA5,0xC8,0xEB,0x47,0x86,0x86,0x86,0xAE,0x38,0x6F,0xBC,0x1C};
+
   TPrimitiveTypeEntry(const TPrimitiveTypeEntry&);
   TPrimitiveTypeEntry& operator=(const TPrimitiveTypeEntry&);
   TPrimitiveTypeEntry() : type((TTypeId::type)0) {
@@ -467,21 +464,18 @@ class TPrimitiveTypeEntry {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TPrimitiveTypeEntry& obj);
 };
 
 void swap(TPrimitiveTypeEntry &a, TPrimitiveTypeEntry &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TPrimitiveTypeEntry& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 
 class TArrayTypeEntry {
  public:
 
+  static const char* ascii_fingerprint; // = "E86CACEB22240450EDCBEFC3A83970E4";
+  static const uint8_t binary_fingerprint[16]; // = {0xE8,0x6C,0xAC,0xEB,0x22,0x24,0x04,0x50,0xED,0xCB,0xEF,0xC3,0xA8,0x39,0x70,0xE4};
+
   TArrayTypeEntry(const TArrayTypeEntry&);
   TArrayTypeEntry& operator=(const TArrayTypeEntry&);
   TArrayTypeEntry() : objectTypePtr(0) {
@@ -507,21 +501,18 @@ class TArrayTypeEntry {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TArrayTypeEntry& obj);
 };
 
 void swap(TArrayTypeEntry &a, TArrayTypeEntry &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TArrayTypeEntry& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 
 class TMapTypeEntry {
  public:
 
+  static const char* ascii_fingerprint; // = "989D1F1AE8D148D5E2119FFEC4BBBEE3";
+  static const uint8_t binary_fingerprint[16]; // = {0x98,0x9D,0x1F,0x1A,0xE8,0xD1,0x48,0xD5,0xE2,0x11,0x9F,0xFE,0xC4,0xBB,0xBE,0xE3};
+
   TMapTypeEntry(const TMapTypeEntry&);
   TMapTypeEntry& operator=(const TMapTypeEntry&);
   TMapTypeEntry() : keyTypePtr(0), valueTypePtr(0) {
@@ -552,21 +543,18 @@ class TMapTypeEntry {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TMapTypeEntry& obj);
 };
 
 void swap(TMapTypeEntry &a, TMapTypeEntry &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TMapTypeEntry& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 
 class TStructTypeEntry {
  public:
 
+  static const char* ascii_fingerprint; // = "91F548CA159B4AB4291F5741AC161402";
+  static const uint8_t binary_fingerprint[16]; // = {0x91,0xF5,0x48,0xCA,0x15,0x9B,0x4A,0xB4,0x29,0x1F,0x57,0x41,0xAC,0x16,0x14,0x02};
+
   TStructTypeEntry(const TStructTypeEntry&);
   TStructTypeEntry& operator=(const TStructTypeEntry&);
   TStructTypeEntry() {
@@ -592,21 +580,18 @@ class TStructTypeEntry {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TStructTypeEntry& obj);
 };
 
 void swap(TStructTypeEntry &a, TStructTypeEntry &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TStructTypeEntry& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 
 class TUnionTypeEntry {
  public:
 
+  static const char* ascii_fingerprint; // = "91F548CA159B4AB4291F5741AC161402";
+  static const uint8_t binary_fingerprint[16]; // = {0x91,0xF5,0x48,0xCA,0x15,0x9B,0x4A,0xB4,0x29,0x1F,0x57,0x41,0xAC,0x16,0x14,0x02};
+
   TUnionTypeEntry(const TUnionTypeEntry&);
   TUnionTypeEntry& operator=(const TUnionTypeEntry&);
   TUnionTypeEntry() {
@@ -632,21 +617,18 @@ class TUnionTypeEntry {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TUnionTypeEntry& obj);
 };
 
 void swap(TUnionTypeEntry &a, TUnionTypeEntry &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TUnionTypeEntry& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 
 class TUserDefinedTypeEntry {
  public:
 
+  static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
+  static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
+
   TUserDefinedTypeEntry(const TUserDefinedTypeEntry&);
   TUserDefinedTypeEntry& operator=(const TUserDefinedTypeEntry&);
   TUserDefinedTypeEntry() : typeClassName() {
@@ -672,17 +654,11 @@ class TUserDefinedTypeEntry {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TUserDefinedTypeEntry& obj);
 };
 
 void swap(TUserDefinedTypeEntry &a, TUserDefinedTypeEntry &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TUserDefinedTypeEntry& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 typedef struct _TTypeEntry__isset {
   _TTypeEntry__isset() : primitiveEntry(false), arrayEntry(false), mapEntry(false), structEntry(false), unionEntry(false), userDefinedTypeEntry(false) {}
   bool primitiveEntry :1;
@@ -696,6 +672,9 @@ typedef struct _TTypeEntry__isset {
 class TTypeEntry {
  public:
 
+  static const char* ascii_fingerprint; // = "2FE56D9097E325DAA7E933738C6D325F";
+  static const uint8_t binary_fingerprint[16]; // = {0x2F,0xE5,0x6D,0x90,0x97,0xE3,0x25,0xDA,0xA7,0xE9,0x33,0x73,0x8C,0x6D,0x32,0x5F};
+
   TTypeEntry(const TTypeEntry&);
   TTypeEntry& operator=(const TTypeEntry&);
   TTypeEntry() {
@@ -748,21 +727,18 @@ class TTypeEntry {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TTypeEntry& obj);
 };
 
 void swap(TTypeEntry &a, TTypeEntry &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TTypeEntry& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 
 class TTypeDesc {
  public:
 
+  static const char* ascii_fingerprint; // = "90B3C5A0B73419A84E85E0E48C452AA5";
+  static const uint8_t binary_fingerprint[16]; // = {0x90,0xB3,0xC5,0xA0,0xB7,0x34,0x19,0xA8,0x4E,0x85,0xE0,0xE4,0x8C,0x45,0x2A,0xA5};
+
   TTypeDesc(const TTypeDesc&);
   TTypeDesc& operator=(const TTypeDesc&);
   TTypeDesc() {
@@ -788,17 +764,11 @@ class TTypeDesc {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TTypeDesc& obj);
 };
 
 void swap(TTypeDesc &a, TTypeDesc &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TTypeDesc& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 typedef struct _TColumnDesc__isset {
   _TColumnDesc__isset() : comment(false) {}
   bool comment :1;
@@ -807,6 +777,9 @@ typedef struct _TColumnDesc__isset {
 class TColumnDesc {
  public:
 
+  static const char* ascii_fingerprint; // = "EABED9009D5FCABFCA65612069F2A849";
+  static const uint8_t binary_fingerprint[16]; // = {0xEA,0xBE,0xD9,0x00,0x9D,0x5F,0xCA,0xBF,0xCA,0x65,0x61,0x20,0x69,0xF2,0xA8,0x49};
+
   TColumnDesc(const TColumnDesc&);
   TColumnDesc& operator=(const TColumnDesc&);
   TColumnDesc() : columnName(), position(0), comment() {
@@ -851,21 +824,18 @@ class TColumnDesc {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TColumnDesc& obj);
 };
 
 void swap(TColumnDesc &a, TColumnDesc &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TColumnDesc& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 
 class TTableSchema {
  public:
 
+  static const char* ascii_fingerprint; // = "7A1811E49313E5977107FC667B20E39D";
+  static const uint8_t binary_fingerprint[16]; // = {0x7A,0x18,0x11,0xE4,0x93,0x13,0xE5,0x97,0x71,0x07,0xFC,0x66,0x7B,0x20,0xE3,0x9D};
+
   TTableSchema(const TTableSchema&);
   TTableSchema& operator=(const TTableSchema&);
   TTableSchema() {
@@ -891,17 +861,11 @@ class TTableSchema {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TTableSchema& obj);
 };
 
 void swap(TTableSchema &a, TTableSchema &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TTableSchema& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 typedef struct _TBoolValue__isset {
   _TBoolValue__isset() : value(false) {}
   bool value :1;
@@ -910,6 +874,9 @@ typedef struct _TBoolValue__isset {
 class TBoolValue {
  public:
 
+  static const char* ascii_fingerprint; // = "BF054652DEF86253C2BEE7D947F167DD";
+  static const uint8_t binary_fingerprint[16]; // = {0xBF,0x05,0x46,0x52,0xDE,0xF8,0x62,0x53,0xC2,0xBE,0xE7,0xD9,0x47,0xF1,0x67,0xDD};
+
   TBoolValue(const TBoolValue&);
   TBoolValue& operator=(const TBoolValue&);
   TBoolValue() : value(0) {
@@ -939,17 +906,11 @@ class TBoolValue {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TBoolValue& obj);
 };
 
 void swap(TBoolValue &a, TBoolValue &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TBoolValue& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 typedef struct _TByteValue__isset {
   _TByteValue__isset() : value(false) {}
   bool value :1;
@@ -958,6 +919,9 @@ typedef struct _TByteValue__isset {
 class TByteValue {
  public:
 
+  static const char* ascii_fingerprint; // = "9C15298ACB5D04AEA9B52D5DDE6F9208";
+  static const uint8_t binary_fingerprint[16]; // = {0x9C,0x15,0x29,0x8A,0xCB,0x5D,0x04,0xAE,0xA9,0xB5,0x2D,0x5D,0xDE,0x6F,0x92,0x08};
+
   TByteValue(const TByteValue&);
   TByteValue& operator=(const TByteValue&);
   TByteValue() : value(0) {
@@ -987,17 +951,11 @@ class TByteValue {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TByteValue& obj);
 };
 
 void swap(TByteValue &a, TByteValue &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TByteValue& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 typedef struct _TI16Value__isset {
   _TI16Value__isset() : value(false) {}
   bool value :1;
@@ -1006,6 +964,9 @@ typedef struct _TI16Value__isset {
 class TI16Value {
  public:
 
+  static const char* ascii_fingerprint; // = "5DAC9C51C7E1106BF936FC71860BE9D5";
+  static const uint8_t binary_fingerprint[16]; // = {0x5D,0xAC,0x9C,0x51,0xC7,0xE1,0x10,0x6B,0xF9,0x36,0xFC,0x71,0x86,0x0B,0xE9,0xD5};
+
   TI16Value(const TI16Value&);
   TI16Value& operator=(const TI16Value&);
   TI16Value() : value(0) {
@@ -1035,17 +996,11 @@ class TI16Value {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TI16Value& obj);
 };
 
 void swap(TI16Value &a, TI16Value &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TI16Value& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 typedef struct _TI32Value__isset {
   _TI32Value__isset() : value(false) {}
   bool value :1;
@@ -1054,6 +1009,9 @@ typedef struct _TI32Value__isset {
 class TI32Value {
  public:
 
+  static const char* ascii_fingerprint; // = "E7A96B151330359E84C0A3AC91BCBACD";
+  static const uint8_t binary_fingerprint[16]; // = {0xE7,0xA9,0x6B,0x15,0x13,0x30,0x35,0x9E,0x84,0xC0,0xA3,0xAC,0x91,0xBC,0xBA,0xCD};
+
   TI32Value(const TI32Value&);
   TI32Value& operator=(const TI32Value&);
   TI32Value() : value(0) {
@@ -1083,17 +1041,11 @@ class TI32Value {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TI32Value& obj);
 };
 
 void swap(TI32Value &a, TI32Value &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TI32Value& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 typedef struct _TI64Value__isset {
   _TI64Value__isset() : value(false) {}
   bool value :1;
@@ -1102,6 +1054,9 @@ typedef struct _TI64Value__isset {
 class TI64Value {
  public:
 
+  static const char* ascii_fingerprint; // = "148F3AAAC1D9859963D5E800D187BF26";
+  static const uint8_t binary_fingerprint[16]; // = {0x14,0x8F,0x3A,0xAA,0xC1,0xD9,0x85,0x99,0x63,0xD5,0xE8,0x00,0xD1,0x87,0xBF,0x26};
+
   TI64Value(const TI64Value&);
   TI64Value& operator=(const TI64Value&);
   TI64Value() : value(0) {
@@ -1131,17 +1086,11 @@ class TI64Value {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TI64Value& obj);
 };
 
 void swap(TI64Value &a, TI64Value &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TI64Value& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 typedef struct _TDoubleValue__isset {
   _TDoubleValue__isset() : value(false) {}
   bool value :1;
@@ -1150,6 +1099,9 @@ typedef struct _TDoubleValue__isset {
 class TDoubleValue {
  public:
 
+  static const char* ascii_fingerprint; // = "3586E570A474C4A8603B4FF74903B3A6";
+  static const uint8_t binary_fingerprint[16]; // = {0x35,0x86,0xE5,0x70,0xA4,0x74,0xC4,0xA8,0x60,0x3B,0x4F,0xF7,0x49,0x03,0xB3,0xA6};
+
   TDoubleValue(const TDoubleValue&);
   TDoubleValue& operator=(const TDoubleValue&);
   TDoubleValue() : value(0) {
@@ -1179,17 +1131,11 @@ class TDoubleValue {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TDoubleValue& obj);
 };
 
 void swap(TDoubleValue &a, TDoubleValue &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TDoubleValue& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 typedef struct _TStringValue__isset {
   _TStringValue__isset() : value(false) {}
   bool value :1;
@@ -1198,6 +1144,9 @@ typedef struct _TStringValue__isset {
 class TStringValue {
  public:
 
+  static const char* ascii_fingerprint; // = "66E694018C17E5B65A59AE8F55CCA3CD";
+  static const uint8_t binary_fingerprint[16]; // = {0x66,0xE6,0x94,0x01,0x8C,0x17,0xE5,0xB6,0x5A,0x59,0xAE,0x8F,0x55,0xCC,0xA3,0xCD};
+
   TStringValue(const TStringValue&);
   TStringValue& operator=(const TStringValue&);
   TStringValue() : value() {
@@ -1227,17 +1176,11 @@ class TStringValue {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TStringValue& obj);
 };
 
 void swap(TStringValue &a, TStringValue &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TStringValue& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 typedef struct _TColumnValue__isset {
   _TColumnValue__isset() : boolVal(false), byteVal(false), i16Val(false), i32Val(false), i64Val(false), doubleVal(false), stringVal(false) {}
   bool boolVal :1;
@@ -1252,6 +1195,9 @@ typedef struct _TColumnValue__isset {
 class TColumnValue {
  public:
 
+  static const char* ascii_fingerprint; // = "C2DDD988447EA7999A8285AA38AAE9AD";
+  static const uint8_t binary_fingerprint[16]; // = {0xC2,0xDD,0xD9,0x88,0x44,0x7E,0xA7,0x99,0x9A,0x82,0x85,0xAA,0x38,0xAA,0xE9,0xAD};
+
   TColumnValue(const TColumnValue&);
   TColumnValue& operator=(const TColumnValue&);
   TColumnValue() {
@@ -1309,21 +1255,18 @@ class TColumnValue {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TColumnValue& obj);
 };
 
 void swap(TColumnValue &a, TColumnValue &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TColumnValue& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 
 class TRow {
  public:
 
+  static const char* ascii_fingerprint; // = "E73FD1FCA0CA58A669FC3E02FB68D534";
+  static const uint8_t binary_fingerprint[16]; // = {0xE7,0x3F,0xD1,0xFC,0xA0,0xCA,0x58,0xA6,0x69,0xFC,0x3E,0x02,0xFB,0x68,0xD5,0x34};
+
   TRow(const TRow&);
   TRow& operator=(const TRow&);
   TRow() {
@@ -1349,21 +1292,18 @@ class TRow {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TRow& obj);
 };
 
 void swap(TRow &a, TRow &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TRow& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 
 class TBoolColumn {
  public:
 
+  static const char* ascii_fingerprint; // = "F9058324D96DB7F974D8ACDC01C54219";
+  static const uint8_t binary_fingerprint[16]; // = {0xF9,0x05,0x83,0x24,0xD9,0x6D,0xB7,0xF9,0x74,0xD8,0xAC,0xDC,0x01,0xC5,0x42,0x19};
+
   TBoolColumn(const TBoolColumn&);
   TBoolColumn& operator=(const TBoolColumn&);
   TBoolColumn() : nulls() {
@@ -1394,21 +1334,18 @@ class TBoolColumn {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TBoolColumn& obj);
 };
 
 void swap(TBoolColumn &a, TBoolColumn &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TBoolColumn& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 
 class TByteColumn {
  public:
 
+  static const char* ascii_fingerprint; // = "1CB300106BAA463A70BB2A2395900F48";
+  static const uint8_t binary_fingerprint[16]; // = {0x1C,0xB3,0x00,0x10,0x6B,0xAA,0x46,0x3A,0x70,0xBB,0x2A,0x23,0x95,0x90,0x0F,0x48};
+
   TByteColumn(const TByteColumn&);
   TByteColumn& operator=(const TByteColumn&);
   TByteColumn() : nulls() {
@@ -1439,21 +1376,18 @@ class TByteColumn {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TByteColumn& obj);
 };
 
 void swap(TByteColumn &a, TByteColumn &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TByteColumn& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 
 class TI16Column {
  public:
 
+  static const char* ascii_fingerprint; // = "6574CDB1F121C8DB47FB257A3F104BDB";
+  static const uint8_t binary_fingerprint[16]; // = {0x65,0x74,0xCD,0xB1,0xF1,0x21,0xC8,0xDB,0x47,0xFB,0x25,0x7A,0x3F,0x10,0x4B,0xDB};
+
   TI16Column(const TI16Column&);
   TI16Column& operator=(const TI16Column&);
   TI16Column() : nulls() {
@@ -1484,21 +1418,18 @@ class TI16Column {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TI16Column& obj);
 };
 
 void swap(TI16Column &a, TI16Column &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TI16Column& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 
 class TI32Column {
  public:
 
+  static const char* ascii_fingerprint; // = "CCCCE89C7E9DA10280F5663700677313";
+  static const uint8_t binary_fingerprint[16]; // = {0xCC,0xCC,0xE8,0x9C,0x7E,0x9D,0xA1,0x02,0x80,0xF5,0x66,0x37,0x00,0x67,0x73,0x13};
+
   TI32Column(const TI32Column&);
   TI32Column& operator=(const TI32Column&);
   TI32Column() : nulls() {
@@ -1529,21 +1460,18 @@ class TI32Column {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TI32Column& obj);
 };
 
 void swap(TI32Column &a, TI32Column &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TI32Column& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 
 class TI64Column {
  public:
 
+  static const char* ascii_fingerprint; // = "925353917FC0AF87976A2338011F5A31";
+  static const uint8_t binary_fingerprint[16]; // = {0x92,0x53,0x53,0x91,0x7F,0xC0,0xAF,0x87,0x97,0x6A,0x23,0x38,0x01,0x1F,0x5A,0x31};
+
   TI64Column(const TI64Column&);
   TI64Column& operator=(const TI64Column&);
   TI64Column() : nulls() {
@@ -1574,21 +1502,18 @@ class TI64Column {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TI64Column& obj);
 };
 
 void swap(TI64Column &a, TI64Column &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TI64Column& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 
 class TDoubleColumn {
  public:
 
+  static const char* ascii_fingerprint; // = "8FF1C050A8D7FD247AEB23CD71539C09";
+  static const uint8_t binary_fingerprint[16]; // = {0x8F,0xF1,0xC0,0x50,0xA8,0xD7,0xFD,0x24,0x7A,0xEB,0x23,0xCD,0x71,0x53,0x9C,0x09};
+
   TDoubleColumn(const TDoubleColumn&);
   TDoubleColumn& operator=(const TDoubleColumn&);
   TDoubleColumn() : nulls() {
@@ -1619,21 +1544,18 @@ class TDoubleColumn {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TDoubleColumn& obj);
 };
 
 void swap(TDoubleColumn &a, TDoubleColumn &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TDoubleColumn& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 
 class TStringColumn {
  public:
 
+  static const char* ascii_fingerprint; // = "BE556BF7091B2DABBA1863D5E458B15F";
+  static const uint8_t binary_fingerprint[16]; // = {0xBE,0x55,0x6B,0xF7,0x09,0x1B,0x2D,0xAB,0xBA,0x18,0x63,0xD5,0xE4,0x58,0xB1,0x5F};
+
   TStringColumn(const TStringColumn&);
   TStringColumn& operator=(const TStringColumn&);
   TStringColumn() : nulls() {
@@ -1664,21 +1586,18 @@ class TStringColumn {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TStringColumn& obj);
 };
 
 void swap(TStringColumn &a, TStringColumn &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TStringColumn& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 
 class TBinaryColumn {
  public:
 
+  static const char* ascii_fingerprint; // = "BE556BF7091B2DABBA1863D5E458B15F";
+  static const uint8_t binary_fingerprint[16]; // = {0xBE,0x55,0x6B,0xF7,0x09,0x1B,0x2D,0xAB,0xBA,0x18,0x63,0xD5,0xE4,0x58,0xB1,0x5F};
+
   TBinaryColumn(const TBinaryColumn&);
   TBinaryColumn& operator=(const TBinaryColumn&);
   TBinaryColumn() : nulls() {
@@ -1709,17 +1628,11 @@ class TBinaryColumn {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TBinaryColumn& obj);
 };
 
 void swap(TBinaryColumn &a, TBinaryColumn &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TBinaryColumn& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 typedef struct _TColumn__isset {
   _TColumn__isset() : boolVal(false), byteVal(false), i16Val(false), i32Val(false), i64Val(false), doubleVal(false), stringVal(false), binaryVal(false) {}
   bool boolVal :1;
@@ -1735,6 +1648,9 @@ typedef struct _TColumn__isset {
 class TColumn {
  public:
 
+  static const char* ascii_fingerprint; // = "E6ADD10B4CDDE61A19E8878CC7039A17";
+  static const uint8_t binary_fingerprint[16]; // = {0xE6,0xAD,0xD1,0x0B,0x4C,0xDD,0xE6,0x1A,0x19,0xE8,0x87,0x8C,0xC7,0x03,0x9A,0x17};
+
   TColumn(const TColumn&);
   TColumn& operator=(const TColumn&);
   TColumn() {
@@ -1797,17 +1713,11 @@ class TColumn {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TColumn& obj);
 };
 
 void swap(TColumn &a, TColumn &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TColumn& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 typedef struct _TRowSet__isset {
   _TRowSet__isset() : columns(false) {}
   bool columns :1;
@@ -1816,6 +1726,9 @@ typedef struct _TRowSet__isset {
 class TRowSet {
  public:
 
+  static const char* ascii_fingerprint; // = "46DA30A870489C7A58105AE0080DAEBF";
+  static const uint8_t binary_fingerprint[16]; // = {0x46,0xDA,0x30,0xA8,0x70,0x48,0x9C,0x7A,0x58,0x10,0x5A,0xE0,0x08,0x0D,0xAE,0xBF};
+
   TRowSet(const TRowSet&);
   TRowSet& operator=(const TRowSet&);
   TRowSet() : startRowOffset(0) {
@@ -1855,17 +1768,11 @@ class TRowSet {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TRowSet& obj);
 };
 
 void swap(TRowSet &a, TRowSet &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TRowSet& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 typedef struct _TStatus__isset {
   _TStatus__isset() : infoMessages(false), sqlState(false), errorCode(false), errorMessage(false) {}
   bool infoMessages :1;
@@ -1877,6 +1784,9 @@ typedef struct _TStatus__isset {
 class TStatus {
  public:
 
+  static const char* ascii_fingerprint; // = "D5DEF49634A59C615C1B3A6F7D0DADB5";
+  static const uint8_t binary_fingerprint[16]; // = {0xD5,0xDE,0xF4,0x96,0x34,0xA5,0x9C,0x61,0x5C,0x1B,0x3A,0x6F,0x7D,0x0D,0xAD,0xB5};
+
   TStatus(const TStatus&);
   TStatus& operator=(const TStatus&);
   TStatus() : statusCode((TStatusCode::type)0), sqlState(), errorCode(0), errorMessage() {
@@ -1932,21 +1842,18 @@ class TStatus {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TStatus& obj);
 };
 
 void swap(TStatus &a, TStatus &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TStatus& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 
 class THandleIdentifier {
  public:
 
+  static const char* ascii_fingerprint; // = "07A9615F837F7D0A952B595DD3020972";
+  static const uint8_t binary_fingerprint[16]; // = {0x07,0xA9,0x61,0x5F,0x83,0x7F,0x7D,0x0A,0x95,0x2B,0x59,0x5D,0xD3,0x02,0x09,0x72};
+
   THandleIdentifier(const THandleIdentifier&);
   THandleIdentifier& operator=(const THandleIdentifier&);
   THandleIdentifier() : guid(), secret() {
@@ -1977,21 +1884,18 @@ class THandleIdentifier {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const THandleIdentifier& obj);
 };
 
 void swap(THandleIdentifier &a, THandleIdentifier &b);
 
-inline std::ostream& operator<<(std::ostream& out, const THandleIdentifier& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 
 class TSessionHandle {
  public:
 
+  static const char* ascii_fingerprint; // = "A756D3DBE614FB13F70BF7F7B6EB3D73";
+  static const uint8_t binary_fingerprint[16]; // = {0xA7,0x56,0xD3,0xDB,0xE6,0x14,0xFB,0x13,0xF7,0x0B,0xF7,0xF7,0xB6,0xEB,0x3D,0x73};
+
   TSessionHandle(const TSessionHandle&);
   TSessionHandle& operator=(const TSessionHandle&);
   TSessionHandle() {
@@ -2017,17 +1921,11 @@ class TSessionHandle {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TSessionHandle& obj);
 };
 
 void swap(TSessionHandle &a, TSessionHandle &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TSessionHandle& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 typedef struct _TOperationHandle__isset {
   _TOperationHandle__isset() : modifiedRowCount(false) {}
   bool modifiedRowCount :1;
@@ -2036,6 +1934,9 @@ typedef struct _TOperationHandle__isset {
 class TOperationHandle {
  public:
 
+  static const char* ascii_fingerprint; // = "29FD80F4F96804A30FCC59C23D2E5349";
+  static const uint8_t binary_fingerprint[16]; // = {0x29,0xFD,0x80,0xF4,0xF9,0x68,0x04,0xA3,0x0F,0xCC,0x59,0xC2,0x3D,0x2E,0x53,0x49};
+
   TOperationHandle(const TOperationHandle&);
   TOperationHandle& operator=(const TOperationHandle&);
   TOperationHandle() : operationType((TOperationType::type)0), hasResultSet(0), modifiedRowCount(0) {
@@ -2080,17 +1981,11 @@ class TOperationHandle {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TOperationHandle& obj);
 };
 
 void swap(TOperationHandle &a, TOperationHandle &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TOperationHandle& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 typedef struct _TOpenSessionReq__isset {
   _TOpenSessionReq__isset() : username(false), password(false), configuration(false) {}
   bool username :1;
@@ -2101,6 +1996,9 @@ typedef struct _TOpenSessionReq__isset {
 class TOpenSessionReq {
  public:
 
+  static const char* ascii_fingerprint; // = "C8FD0F306A16C16BDA7B57F58BFAE5B2";
+  static const uint8_t binary_fingerprint[16]; // = {0xC8,0xFD,0x0F,0x30,0x6A,0x16,0xC1,0x6B,0xDA,0x7B,0x57,0xF5,0x8B,0xFA,0xE5,0xB2};
+
   TOpenSessionReq(const TOpenSessionReq&);
   TOpenSessionReq& operator=(const TOpenSessionReq&);
   TOpenSessionReq() : client_protocol((TProtocolVersion::type)7), username(), password() {
@@ -2151,17 +2049,11 @@ class TOpenSessionReq {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TOpenSessionReq& obj);
 };
 
 void swap(TOpenSessionReq &a, TOpenSessionReq &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TOpenSessionReq& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 typedef struct _TOpenSessionResp__isset {
   _TOpenSessionResp__isset() : sessionHandle(false), configuration(false) {}
   bool sessionHandle :1;
@@ -2171,6 +2063,9 @@ typedef struct _TOpenSessionResp__isset {
 class TOpenSessionResp {
  public:
 
+  static const char* ascii_fingerprint; // = "CFE7D7F4E9EC671F2518ED74FEE9F163";
+  static const uint8_t binary_fingerprint[16]; // = {0xCF,0xE7,0xD7,0xF4,0xE9,0xEC,0x67,0x1F,0x25,0x18,0xED,0x74,0xFE,0xE9,0xF1,0x63};
+
   TOpenSessionResp(const TOpenSessionResp&);
   TOpenSessionResp& operator=(const TOpenSessionResp&);
   TOpenSessionResp() : serverProtocolVersion((TProtocolVersion::type)7) {
@@ -2219,21 +2114,18 @@ class TOpenSessionResp {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TOpenSessionResp& obj);
 };
 
 void swap(TOpenSessionResp &a, TOpenSessionResp &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TOpenSessionResp& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 
 class TCloseSessionReq {
  public:
 
+  static const char* ascii_fingerprint; // = "82377107F8BD0526960537D5A112E6EF";
+  static const uint8_t binary_fingerprint[16]; // = {0x82,0x37,0x71,0x07,0xF8,0xBD,0x05,0x26,0x96,0x05,0x37,0xD5,0xA1,0x12,0xE6,0xEF};
+
   TCloseSessionReq(const TCloseSessionReq&);
   TCloseSessionReq& operator=(const TCloseSessionReq&);
   TCloseSessionReq() {
@@ -2259,21 +2151,18 @@ class TCloseSessionReq {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TCloseSessionReq& obj);
 };
 
 void swap(TCloseSessionReq &a, TCloseSessionReq &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TCloseSessionReq& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 
 class TCloseSessionResp {
  public:
 
+  static const char* ascii_fingerprint; // = "7142E89F09DC7C5F6FA916C7393F46C2";
+  static const uint8_t binary_fingerprint[16]; // = {0x71,0x42,0xE8,0x9F,0x09,0xDC,0x7C,0x5F,0x6F,0xA9,0x16,0xC7,0x39,0x3F,0x46,0xC2};
+
   TCloseSessionResp(const TCloseSessionResp&);
   TCloseSessionResp& operator=(const TCloseSessionResp&);
   TCloseSessionResp() {
@@ -2299,17 +2188,11 @@ class TCloseSessionResp {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TCloseSessionResp& obj);
 };
 
 void swap(TCloseSessionResp &a, TCloseSessionResp &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TCloseSessionResp& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 typedef struct _TGetInfoValue__isset {
   _TGetInfoValue__isset() : stringValue(false), smallIntValue(false), integerBitmask(false), integerFlag(false), binaryValue(false), lenValue(false) {}
   bool stringValue :1;
@@ -2323,6 +2206,9 @@ typedef struct _TGetInfoValue__isset {
 class TGetInfoValue {
  public:
 
+  static const char* ascii_fingerprint; // = "057FED11279FD7248CFE73EE82ED579E";
+  static const uint8_t binary_fingerprint[16]; // = {0x05,0x7F,0xED,0x11,0x27,0x9F,0xD7,0x24,0x8C,0xFE,0x73,0xEE,0x82,0xED,0x57,0x9E};
+
   TGetInfoValue(const TGetInfoValue&);
   TGetInfoValue& operator=(const TGetInfoValue&);
   TGetInfoValue() : stringValue(), smallIntValue(0), integerBitmask(0), integerFlag(0), binaryValue(0), lenValue(0) {
@@ -2375,21 +2261,18 @@ class TGetInfoValue {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TGetInfoValue& obj);
 };
 
 void swap(TGetInfoValue &a, TGetInfoValue &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TGetInfoValue& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 
 class TGetInfoReq {
  public:
 
+  static const char* ascii_fingerprint; // = "95675B1A0BADE5F7EDE323809DB679B2";
+  static const uint8_t binary_fingerprint[16]; // = {0x95,0x67,0x5B,0x1A,0x0B,0xAD,0xE5,0xF7,0xED,0xE3,0x23,0x80,0x9D,0xB6,0x79,0xB2};
+
   TGetInfoReq(const TGetInfoReq&);
   TGetInfoReq& operator=(const TGetInfoReq&);
   TGetInfoReq() : infoType((TGetInfoType::type)0) {
@@ -2420,21 +2303,18 @@ class TGetInfoReq {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TGetInfoReq& obj);
 };
 
 void swap(TGetInfoReq &a, TGetInfoReq &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TGetInfoReq& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 
 class TGetInfoResp {
  public:
 
+  static const char* ascii_fingerprint; // = "72AFA10A82728B51FDE91092012868DE";
+  static const uint8_t binary_fingerprint[16]; // = {0x72,0xAF,0xA1,0x0A,0x82,0x72,0x8B,0x51,0xFD,0xE9,0x10,0x92,0x01,0x28,0x68,0xDE};
+
   TGetInfoResp(const TGetInfoResp&);
   TGetInfoResp& operator=(const TGetInfoResp&);
   TGetInfoResp() {
@@ -2465,17 +2345,11 @@ class TGetInfoResp {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TGetInfoResp& obj);
 };
 
 void swap(TGetInfoResp &a, TGetInfoResp &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TGetInfoResp& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 typedef struct _TExecuteStatementReq__isset {
   _TExecuteStatementReq__isset() : confOverlay(false), runAsync(true) {}
   bool confOverlay :1;
@@ -2485,6 +2359,9 @@ typedef struct _TExecuteStatementReq__isset {
 class TExecuteStatementReq {
  public:
 
+  static const char* ascii_fingerprint; // = "FED75DB77E66D76EC1939A51FB0D96FA";
+  static const uint8_t binary_fingerprint[16]; // = {0xFE,0xD7,0x5D,0xB7,0x7E,0x66,0xD7,0x6E,0xC1,0x93,0x9A,0x51,0xFB,0x0D,0x96,0xFA};
+
   TExecuteStatementReq(const TExecuteStatementReq&);
   TExecuteStatementReq& operator=(const TExecuteStatementReq&);
   TExecuteStatementReq() : statement(), runAsync(false) {
@@ -2531,17 +2408,11 @@ class TExecuteStatementReq {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TExecuteStatementReq& obj);
 };
 
 void swap(TExecuteStatementReq &a, TExecuteStatementReq &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TExecuteStatementReq& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 typedef struct _TExecuteStatementResp__isset {
   _TExecuteStatementResp__isset() : operationHandle(false) {}
   bool operationHandle :1;
@@ -2550,6 +2421,9 @@ typedef struct _TExecuteStatementResp__isset {
 class TExecuteStatementResp {
  public:
 
+  static const char* ascii_fingerprint; // = "02A075A0FF88D3A172916D8F23C7B286";
+  static const uint8_t binary_fingerprint[16]; // = {0x02,0xA0,0x75,0xA0,0xFF,0x88,0xD3,0xA1,0x72,0x91,0x6D,0x8F,0x23,0xC7,0xB2,0x86};
+
   TExecuteStatementResp(const TExecuteStatementResp&);
   TExecuteStatementResp& operator=(const TExecuteStatementResp&);
   TExecuteStatementResp() {
@@ -2584,21 +2458,18 @@ class TExecuteStatementResp {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TExecuteStatementResp& obj);
 };
 
 void swap(TExecuteStatementResp &a, TExecuteStatementResp &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TExecuteStatementResp& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 
 class TGetTypeInfoReq {
  public:
 
+  static const char* ascii_fingerprint; // = "82377107F8BD0526960537D5A112E6EF";
+  static const uint8_t binary_fingerprint[16]; // = {0x82,0x37,0x71,0x07,0xF8,0xBD,0x05,0x26,0x96,0x05,0x37,0xD5,0xA1,0x12,0xE6,0xEF};
+
   TGetTypeInfoReq(const TGetTypeInfoReq&);
   TGetTypeInfoReq& operator=(const TGetTypeInfoReq&);
   TGetTypeInfoReq() {
@@ -2624,17 +2495,11 @@ class TGetTypeInfoReq {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TGetTypeInfoReq& obj);
 };
 
 void swap(TGetTypeInfoReq &a, TGetTypeInfoReq &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TGetTypeInfoReq& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 typedef struct _TGetTypeInfoResp__isset {
   _TGetTypeInfoResp__isset() : operationHandle(false) {}
   bool operationHandle :1;
@@ -2643,6 +2508,9 @@ typedef struct _TGetTypeInfoResp__isset {
 class TGetTypeInfoResp {
  public:
 
+  static const char* ascii_fingerprint; // = "02A075A0FF88D3A172916D8F23C7B286";
+  static const uint8_t binary_fingerprint[16]; // = {0x02,0xA0,0x75,0xA0,0xFF,0x88,0xD3,0xA1,0x72,0x91,0x6D,0x8F,0x23,0xC7,0xB2,0x86};
+
   TGetTypeInfoResp(const TGetTypeInfoResp&);
   TGetTypeInfoResp& operator=(const TGetTypeInfoResp&);
   TGetTypeInfoResp() {
@@ -2677,21 +2545,18 @@ class TGetTypeInfoResp {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TGetTypeInfoResp& obj);
 };
 
 void swap(TGetTypeInfoResp &a, TGetTypeInfoResp &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TGetTypeInfoResp& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 
 class TGetCatalogsReq {
  public:
 
+  static const char* ascii_fingerprint; // = "82377107F8BD0526960537D5A112E6EF";
+  static const uint8_t binary_fingerprint[16]; // = {0x82,0x37,0x71,0x07,0xF8,0xBD,0x05,0x26,0x96,0x05,0x37,0xD5,0xA1,0x12,0xE6,0xEF};
+
   TGetCatalogsReq(const TGetCatalogsReq&);
   TGetCatalogsReq& operator=(const TGetCatalogsReq&);
   TGetCatalogsReq() {
@@ -2717,17 +2582,11 @@ class TGetCatalogsReq {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TGetCatalogsReq& obj);
 };
 
 void swap(TGetCatalogsReq &a, TGetCatalogsReq &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TGetCatalogsReq& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 typedef struct _TGetCatalogsResp__isset {
   _TGetCatalogsResp__isset() : operationHandle(false) {}
   bool operationHandle :1;
@@ -2736,6 +2595,9 @@ typedef struct _TGetCatalogsResp__isset {
 class TGetCatalogsResp {
  public:
 
+  static const char* ascii_fingerprint; // = "02A075A0FF88D3A172916D8F23C7B286";
+  static const uint8_t binary_fingerprint[16]; // = {0x02,0xA0,0x75,0xA0,0xFF,0x88,0xD3,0xA1,0x72,0x91,0x6D,0x8F,0x23,0xC7,0xB2,0x86};
+
   TGetCatalogsResp(const TGetCatalogsResp&);
   TGetCatalogsResp& operator=(const TGetCatalogsResp&);
   TGetCatalogsResp() {
@@ -2770,17 +2632,11 @@ class TGetCatalogsResp {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TGetCatalogsResp& obj);
 };
 
 void swap(TGetCatalogsResp &a, TGetCatalogsResp &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TGetCatalogsResp& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 typedef struct _TGetSchemasReq__isset {
   _TGetSchemasReq__isset() : catalogName(false), schemaName(false) {}
   bool catalogName :1;
@@ -2790,6 +2646,9 @@ typedef struct _TGetSchemasReq__isset {
 class TGetSchemasReq {
  public:
 
+  static const char* ascii_fingerprint; // = "28A9D12DE8393DD3E73FC1E5AE6E113B";
+  static const uint8_t binary_fingerprint[16]; // = {0x28,0xA9,0xD1,0x2D,0xE8,0x39,0x3D,0xD3,0xE7,0x3F,0xC1,0xE5,0xAE,0x6E,0x11,0x3B};
+
   TGetSchemasReq(const TGetSchemasReq&);
   TGetSchemasReq& operator=(const TGetSchemasReq&);
   TGetSchemasReq() : catalogName(), schemaName() {
@@ -2831,17 +2690,11 @@ class TGetSchemasReq {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TGetSchemasReq& obj);
 };
 
 void swap(TGetSchemasReq &a, TGetSchemasReq &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TGetSchemasReq& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 typedef struct _TGetSchemasResp__isset {
   _TGetSchemasResp__isset() : operationHandle(false) {}
   bool operationHandle :1;
@@ -2850,6 +2703,9 @@ typedef struct _TGetSchemasResp__isset {
 class TGetSchemasResp {
  public:
 
+  static const char* ascii_fingerprint; // = "02A075A0FF88D3A172916D8F23C7B286";
+  static const uint8_t binary_fingerprint[16]; // = {0x02,0xA0,0x75,0xA0,0xFF,0x88,0xD3,0xA1,0x72,0x91,0x6D,0x8F,0x23,0xC7,0xB2,0x86};
+
   TGetSchemasResp(const TGetSchemasResp&);
   TGetSchemasResp& operator=(const TGetSchemasResp&);
   TGetSchemasResp() {
@@ -2884,17 +2740,11 @@ class TGetSchemasResp {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TGetSchemasResp& obj);
 };
 
 void swap(TGetSchemasResp &a, TGetSchemasResp &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TGetSchemasResp& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 typedef struct _TGetTablesReq__isset {
   _TGetTablesReq__isset() : catalogName(false), schemaName(false), tableName(false), tableTypes(false) {}
   bool catalogName :1;
@@ -2906,6 +2756,9 @@ typedef struct _TGetTablesReq__isset {
 class TGetTablesReq {
  public:
 
+  static const char* ascii_fingerprint; // = "C80DFEE06850052F5A445BE81ED763DB";
+  static const uint8_t binary_fingerprint[16]; // = {0xC8,0x0D,0xFE,0xE0,0x68,0x50,0x05,0x2F,0x5A,0x44,0x5B,0xE8,0x1E,0xD7,0x63,0xDB};
+
   TGetTablesReq(const TGetTablesReq&);
   TGetTablesReq& operator=(const TGetTablesReq&);
   TGetTablesReq() : catalogName(), schemaName(), tableName() {
@@ -2961,17 +2814,11 @@ class TGetTablesReq {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TGetTablesReq& obj);
 };
 
 void swap(TGetTablesReq &a, TGetTablesReq &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TGetTablesReq& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 typedef struct _TGetTablesResp__isset {
   _TGetTablesResp__isset() : operationHandle(false) {}
   bool operationHandle :1;
@@ -2980,6 +2827,9 @@ typedef struct _TGetTablesResp__isset {
 class TGetTablesResp {
  public:
 
+  static const char* ascii_fingerprint; // = "02A075A0FF88D3A172916D8F23C7B286";
+  static const uint8_t binary_fingerprint[16]; // = {0x02,0xA0,0x75,0xA0,0xFF,0x88,0xD3,0xA1,0x72,0x91,0x6D,0x8F,0x23,0xC7,0xB2,0x86};
+
   TGetTablesResp(const TGetTablesResp&);
   TGetTablesResp& operator=(const TGetTablesResp&);
   TGetTablesResp() {
@@ -3014,21 +2864,18 @@ class TGetTablesResp {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TGetTablesResp& obj);
 };
 
 void swap(TGetTablesResp &a, TGetTablesResp &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TGetTablesResp& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 
 class TGetTableTypesReq {
  public:
 
+  static const char* ascii_fingerprint; // = "82377107F8BD0526960537D5A112E6EF";
+  static const uint8_t binary_fingerprint[16]; // = {0x82,0x37,0x71,0x07,0xF8,0xBD,0x05,0x26,0x96,0x05,0x37,0xD5,0xA1,0x12,0xE6,0xEF};
+
   TGetTableTypesReq(const TGetTableTypesReq&);
   TGetTableTypesReq& operator=(const TGetTableTypesReq&);
   TGetTableTypesReq() {
@@ -3054,17 +2901,11 @@ class TGetTableTypesReq {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TGetTableTypesReq& obj);
 };
 
 void swap(TGetTableTypesReq &a, TGetTableTypesReq &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TGetTableTypesReq& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 typedef struct _TGetTableTypesResp__isset {
   _TGetTableTypesResp__isset() : operationHandle(false) {}
   bool operationHandle :1;
@@ -3073,6 +2914,9 @@ typedef struct _TGetTableTypesResp__isset {
 class TGetTableTypesResp {
  public:
 
+  static const char* ascii_fingerprint; // = "02A075A0FF88D3A172916D8F23C7B286";
+  static const uint8_t binary_fingerprint[16]; // = {0x02,0xA0,0x75,0xA0,0xFF,0x88,0xD3,0xA1,0x72,0x91,0x6D,0x8F,0x23,0xC7,0xB2,0x86};
+
   TGetTableTypesResp(const TGetTableTypesResp&);
   TGetTableTypesResp& operator=(const TGetTableTypesResp&);
   TGetTableTypesResp() {
@@ -3107,17 +2951,11 @@ class TGetTableTypesResp {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TGetTableTypesResp& obj);
 };
 
 void swap(TGetTableTypesResp &a, TGetTableTypesResp &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TGetTableTypesResp& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 typedef struct _TGetColumnsReq__isset {
   _TGetColumnsReq__isset() : catalogName(false), schemaName(false), tableName(false), columnName(false) {}
   bool catalogName :1;
@@ -3129,6 +2967,9 @@ typedef struct _TGetColumnsReq__isset {
 class TGetColumnsReq {
  public:
 
+  static const char* ascii_fingerprint; // = "72D0F28ED33A49B7306DF63EEE956C28";
+  static const uint8_t binary_fingerprint[16]; // = {0x72,0xD0,0xF2,0x8E,0xD3,0x3A,0x49,0xB7,0x30,0x6D,0xF6,0x3E,0xEE,0x95,0x6C,0x28};
+
   TGetColumnsReq(const TGetColumnsReq&);
   TGetColumnsReq& operator=(const TGetColumnsReq&);
   TGetColumnsReq() : catalogName(), schemaName(), tableName(), columnName() {
@@ -3184,17 +3025,11 @@ class TGetColumnsReq {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TGetColumnsReq& obj);
 };
 
 void swap(TGetColumnsReq &a, TGetColumnsReq &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TGetColumnsReq& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 typedef struct _TGetColumnsResp__isset {
   _TGetColumnsResp__isset() : operationHandle(false) {}
   bool operationHandle :1;
@@ -3203,6 +3038,9 @@ typedef struct _TGetColumnsResp__isset {
 class TGetColumnsResp {
  public:
 
+  static const char* ascii_fingerprint; // = "02A075A0FF88D3A172916D8F23C7B286";
+  static const uint8_t binary_fingerprint[16]; // = {0x02,0xA0,0x75,0xA0,0xFF,0x88,0xD3,0xA1,0x72,0x91,0x6D,0x8F,0x23,0xC7,0xB2,0x86};
+
   TGetColumnsResp(const TGetColumnsResp&);
   TGetColumnsResp& operator=(const TGetColumnsResp&);
   TGetColumnsResp() {
@@ -3237,17 +3075,11 @@ class TGetColumnsResp {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TGetColumnsResp& obj);
 };
 
 void swap(TGetColumnsResp &a, TGetColumnsResp &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TGetColumnsResp& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 typedef struct _TGetFunctionsReq__isset {
   _TGetFunctionsReq__isset() : catalogName(false), schemaName(false) {}
   bool catalogName :1;
@@ -3257,6 +3089,9 @@ typedef struct _TGetFunctionsReq__isset {
 class TGetFunctionsReq {
  public:
 
+  static const char* ascii_fingerprint; // = "0887E0916ADE4521BF6017B534493138";
+  static const uint8_t binary_fingerprint[16]; // = {0x08,0x87,0xE0,0x91,0x6A,0xDE,0x45,0x21,0xBF,0x60,0x17,0xB5,0x34,0x49,0x31,0x38};
+
   TGetFunctionsReq(const TGetFunctionsReq&);
   TGetFunctionsReq& operator=(const TGetFunctionsReq&);
   TGetFunctionsReq() : catalogName(), schemaName(), functionName() {
@@ -3303,17 +3138,11 @@ class TGetFunctionsReq {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TGetFunctionsReq& obj);
 };
 
 void swap(TGetFunctionsReq &a, TGetFunctionsReq &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TGetFunctionsReq& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 typedef struct _TGetFunctionsResp__isset {
   _TGetFunctionsResp__isset() : operationHandle(false) {}
   bool operationHandle :1;
@@ -3322,6 +3151,9 @@ typedef struct _TGetFunctionsResp__isset {
 class TGetFunctionsResp {
  public:
 
+  static const char* ascii_fingerprint; // = "02A075A0FF88D3A172916D8F23C7B286";
+  static const uint8_t binary_fingerprint[16]; // = {0x02,0xA0,0x75,0xA0,0xFF,0x88,0xD3,0xA1,0x72,0x91,0x6D,0x8F,0x23,0xC7,0xB2,0x86};
+
   TGetFunctionsResp(const TGetFunctionsResp&);
   TGetFunctionsResp& operator=(const TGetFunctionsResp&);
   TGetFunctionsResp() {
@@ -3356,21 +3188,18 @@ class TGetFunctionsResp {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TGetFunctionsResp& obj);
 };
 
 void swap(TGetFunctionsResp &a, TGetFunctionsResp &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TGetFunctionsResp& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 
 class TGetOperationStatusReq {
  public:
 
+  static const char* ascii_fingerprint; // = "414FA38522AE6B9CEC1438B56CA1DE5A";
+  static const uint8_t binary_fingerprint[16]; // = {0x41,0x4F,0xA3,0x85,0x22,0xAE,0x6B,0x9C,0xEC,0x14,0x38,0xB5,0x6C,0xA1,0xDE,0x5A};
+
   TGetOperationStatusReq(const TGetOperationStatusReq&);
   TGetOperationStatusReq& operator=(const TGetOperationStatusReq&);
   TGetOperationStatusReq() {
@@ -3396,17 +3225,11 @@ class TGetOperationStatusReq {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TGetOperationStatusReq& obj);
 };
 
 void swap(TGetOperationStatusReq &a, TGetOperationStatusReq &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TGetOperationStatusReq& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 typedef struct _TGetOperationStatusResp__isset {
   _TGetOperationStatusResp__isset() : operationState(false), sqlState(false), errorCode(false), errorMessage(false) {}
   bool operationState :1;
@@ -3418,6 +3241,9 @@ typedef struct _TGetOperationStatusResp__isset {
 class TGetOperationStatusResp {
  public:
 
+  static const char* ascii_fingerprint; // = "BD124DB87A5A2E7D11945BD1B17F013D";
+  static const uint8_t binary_fingerprint[16]; // = {0xBD,0x12,0x4D,0xB8,0x7A,0x5A,0x2E,0x7D,0x11,0x94,0x5B,0xD1,0xB1,0x7F,0x01,0x3D};
+
   TGetOperationStatusResp(const TGetOperationStatusResp&);
   TGetOperationStatusResp& operator=(const TGetOperationStatusResp&);
   TGetOperationStatusResp() : operationState((TOperationState::type)0), sqlState(), errorCode(0), errorMessage() {
@@ -3473,21 +3299,18 @@ class TGetOperationStatusResp {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TGetOperationStatusResp& obj);
 };
 
 void swap(TGetOperationStatusResp &a, TGetOperationStatusResp &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TGetOperationStatusResp& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 
 class TCancelOperationReq {
  public:
 
+  static const char* ascii_fingerprint; // = "414FA38522AE6B9CEC1438B56CA1DE5A";
+  static const uint8_t binary_fingerprint[16]; // = {0x41,0x4F,0xA3,0x85,0x22,0xAE,0x6B,0x9C,0xEC,0x14,0x38,0xB5,0x6C,0xA1,0xDE,0x5A};
+
   TCancelOperationReq(const TCancelOperationReq&);
   TCancelOperationReq& operator=(const TCancelOperationReq&);
   TCancelOperationReq() {
@@ -3513,21 +3336,18 @@ class TCancelOperationReq {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TCancelOperationReq& obj);
 };
 
 void swap(TCancelOperationReq &a, TCancelOperationReq &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TCancelOperationReq& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 
 class TCancelOperationResp {
  public:
 
+  static const char* ascii_fingerprint; // = "7142E89F09DC7C5F6FA916C7393F46C2";
+  static const uint8_t binary_fingerprint[16]; // = {0x71,0x42,0xE8,0x9F,0x09,0xDC,0x7C,0x5F,0x6F,0xA9,0x16,0xC7,0x39,0x3F,0x46,0xC2};
+
   TCancelOperationResp(const TCancelOperationResp&);
   TCancelOperationResp& operator=(const TCancelOperationResp&);
   TCancelOperationResp() {
@@ -3553,21 +3373,18 @@ class TCancelOperationResp {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TCancelOperationResp& obj);
 };
 
 void swap(TCancelOperationResp &a, TCancelOperationResp &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TCancelOperationResp& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 
 class TCloseOperationReq {
  public:
 
+  static const char* ascii_fingerprint; // = "414FA38522AE6B9CEC1438B56CA1DE5A";
+  static const uint8_t binary_fingerprint[16]; // = {0x41,0x4F,0xA3,0x85,0x22,0xAE,0x6B,0x9C,0xEC,0x14,0x38,0xB5,0x6C,0xA1,0xDE,0x5A};
+
   TCloseOperationReq(const TCloseOperationReq&);
   TCloseOperationReq& operator=(const TCloseOperationReq&);
   TCloseOperationReq() {
@@ -3593,21 +3410,18 @@ class TCloseOperationReq {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TCloseOperationReq& obj);
 };
 
 void swap(TCloseOperationReq &a, TCloseOperationReq &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TCloseOperationReq& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 
 class TCloseOperationResp {
  public:
 
+  static const char* ascii_fingerprint; // = "7142E89F09DC7C5F6FA916C7393F46C2";
+  static const uint8_t binary_fingerprint[16]; // = {0x71,0x42,0xE8,0x9F,0x09,0xDC,0x7C,0x5F,0x6F,0xA9,0x16,0xC7,0x39,0x3F,0x46,0xC2};
+
   TCloseOperationResp(const TCloseOperationResp&);
   TCloseOperationResp& operator=(const TCloseOperationResp&);
   TCloseOperationResp() {
@@ -3633,21 +3447,18 @@ class TCloseOperationResp {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TCloseOperationResp& obj);
 };
 
 void swap(TCloseOperationResp &a, TCloseOperationResp &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TCloseOperationResp& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 
 class TGetResultSetMetadataReq {
  public:
 
+  static const char* ascii_fingerprint; // = "414FA38522AE6B9CEC1438B56CA1DE5A";
+  static const uint8_t binary_fingerprint[16]; // = {0x41,0x4F,0xA3,0x85,0x22,0xAE,0x6B,0x9C,0xEC,0x14,0x38,0xB5,0x6C,0xA1,0xDE,0x5A};
+
   TGetResultSetMetadataReq(const TGetResultSetMetadataReq&);
   TGetResultSetMetadataReq& operator=(const TGetResultSetMetadataReq&);
   TGetResultSetMetadataReq() {
@@ -3673,17 +3484,11 @@ class TGetResultSetMetadataReq {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TGetResultSetMetadataReq& obj);
 };
 
 void swap(TGetResultSetMetadataReq &a, TGetResultSetMetadataReq &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TGetResultSetMetadataReq& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 typedef struct _TGetResultSetMetadataResp__isset {
   _TGetResultSetMetadataResp__isset() : schema(false) {}
   bool schema :1;
@@ -3692,6 +3497,9 @@ typedef struct _TGetResultSetMetadataResp__isset {
 class TGetResultSetMetadataResp {
  public:
 
+  static const char* ascii_fingerprint; // = "42CD49B7F49CC1B6D4E6F5FA2D7BE812";
+  static const uint8_t binary_fingerprint[16]; // = {0x42,0xCD,0x49,0xB7,0xF4,0x9C,0xC1,0xB6,0xD4,0xE6,0xF5,0xFA,0x2D,0x7B,0xE8,0x12};
+
   TGetResultSetMetadataResp(const TGetResultSetMetadataResp&);
   TGetResultSetMetadataResp& operator=(const TGetResultSetMetadataResp&);
   TGetResultSetMetadataResp() {
@@ -3726,17 +3534,11 @@ class TGetResultSetMetadataResp {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TGetResultSetMetadataResp& obj);
 };
 
 void swap(TGetResultSetMetadataResp &a, TGetResultSetMetadataResp &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TGetResultSetMetadataResp& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 typedef struct _TFetchResultsReq__isset {
   _TFetchResultsReq__isset() : fetchType(true) {}
   bool fetchType :1;
@@ -3745,6 +3547,9 @@ typedef struct _TFetchResultsReq__isset {
 class TFetchResultsReq {
  public:
 
+  static const char* ascii_fingerprint; // = "B4CB1E4F8F8F4D50183DD372AD11753A";
+  static const uint8_t binary_fingerprint[16]; // = {0xB4,0xCB,0x1E,0x4F,0x8F,0x8F,0x4D,0x50,0x18,0x3D,0xD3,0x72,0xAD,0x11,0x75,0x3A};
+
   TFetchResultsReq(const TFetchResultsReq&);
   TFetchResultsReq& operator=(const TFetchResultsReq&);
   TFetchResultsReq() : orientation((TFetchOrientation::type)0), maxRows(0), fetchType(0) {
@@ -3791,17 +3596,11 @@ class TFetchResultsReq {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TFetchResultsReq& obj);
 };
 
 void swap(TFetchResultsReq &a, TFetchResultsReq &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TFetchResultsReq& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 typedef struct _TFetchResultsResp__isset {
   _TFetchResultsResp__isset() : hasMoreRows(false), results(false) {}
   bool hasMoreRows :1;
@@ -3811,6 +3610,9 @@ typedef struct _TFetchResultsResp__isset {
 class TFetchResultsResp {
  public:
 
+  static const char* ascii_fingerprint; // = "FC43BC2D6F3B76D4DB0F34226A745C8E";
+  static const uint8_t binary_fingerprint[16]; // = {0xFC,0x43,0xBC,0x2D,0x6F,0x3B,0x76,0xD4,0xDB,0x0F,0x34,0x22,0x6A,0x74,0x5C,0x8E};
+
   TFetchResultsResp(const TFetchResultsResp&);
   TFetchResultsResp& operator=(const TFetchResultsResp&);
   TFetchResultsResp() : hasMoreRows(0) {
@@ -3852,21 +3654,18 @@ class TFetchResultsResp {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TFetchResultsResp& obj);
 };
 
 void swap(TFetchResultsResp &a, TFetchResultsResp &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TFetchResultsResp& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 
 class TGetDelegationTokenReq {
  public:
 
+  static const char* ascii_fingerprint; // = "07EA0311716A27924914E4354ED22D6C";
+  static const uint8_t binary_fingerprint[16]; // = {0x07,0xEA,0x03,0x11,0x71,0x6A,0x27,0x92,0x49,0x14,0xE4,0x35,0x4E,0xD2,0x2D,0x6C};
+
   TGetDelegationTokenReq(const TGetDelegationTokenReq&);
   TGetDelegationTokenReq& operator=(const TGetDelegationTokenReq&);
   TGetDelegationTokenReq() : owner(), renewer() {
@@ -3902,17 +3701,11 @@ class TGetDelegationTokenReq {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TGetDelegationTokenReq& obj);
 };
 
 void swap(TGetDelegationTokenReq &a, TGetDelegationTokenReq &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TGetDelegationTokenReq& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 typedef struct _TGetDelegationTokenResp__isset {
   _TGetDelegationTokenResp__isset() : delegationToken(false) {}
   bool delegationToken :1;
@@ -3921,6 +3714,9 @@ typedef struct _TGetDelegationTokenResp__isset {
 class TGetDelegationTokenResp {
  public:
 
+  static const char* ascii_fingerprint; // = "C0E132DC412CEA08D771EAC38CEA1DA6";
+  static const uint8_t binary_fingerprint[16]; // = {0xC0,0xE1,0x32,0xDC,0x41,0x2C,0xEA,0x08,0xD7,0x71,0xEA,0xC3,0x8C,0xEA,0x1D,0xA6};
+
   TGetDelegationTokenResp(const TGetDelegationTokenResp&);
   TGetDelegationTokenResp& operator=(const TGetDelegationTokenResp&);
   TGetDelegationTokenResp() : delegationToken() {
@@ -3955,21 +3751,18 @@ class TGetDelegationTokenResp {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TGetDelegationTokenResp& obj);
 };
 
 void swap(TGetDelegationTokenResp &a, TGetDelegationTokenResp &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TGetDelegationTokenResp& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 
 class TCancelDelegationTokenReq {
  public:
 
+  static const char* ascii_fingerprint; // = "1A3D66269336B7EC66998BFE1BECDE75";
+  static const uint8_t binary_fingerprint[16]; // = {0x1A,0x3D,0x66,0x26,0x93,0x36,0xB7,0xEC,0x66,0x99,0x8B,0xFE,0x1B,0xEC,0xDE,0x75};
+
   TCancelDelegationTokenReq(const TCancelDelegationTokenReq&);
   TCancelDelegationTokenReq& operator=(const TCancelDelegationTokenReq&);
   TCancelDelegationTokenReq() : delegationToken() {
@@ -4000,21 +3793,18 @@ class TCancelDelegationTokenReq {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TCancelDelegationTokenReq& obj);
 };
 
 void swap(TCancelDelegationTokenReq &a, TCancelDelegationTokenReq &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TCancelDelegationTokenReq& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 
 class TCancelDelegationTokenResp {
  public:
 
+  static const char* ascii_fingerprint; // = "7142E89F09DC7C5F6FA916C7393F46C2";
+  static const uint8_t binary_fingerprint[16]; // = {0x71,0x42,0xE8,0x9F,0x09,0xDC,0x7C,0x5F,0x6F,0xA9,0x16,0xC7,0x39,0x3F,0x46,0xC2};
+
   TCancelDelegationTokenResp(const TCancelDelegationTokenResp&);
   TCancelDelegationTokenResp& operator=(const TCancelDelegationTokenResp&);
   TCancelDelegationTokenResp() {
@@ -4040,21 +3830,18 @@ class TCancelDelegationTokenResp {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TCancelDelegationTokenResp& obj);
 };
 
 void swap(TCancelDelegationTokenResp &a, TCancelDelegationTokenResp &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TCancelDelegationTokenResp& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 
 class TRenewDelegationTokenReq {
  public:
 
+  static const char* ascii_fingerprint; // = "1A3D66269336B7EC66998BFE1BECDE75";
+  static const uint8_t binary_fingerprint[16]; // = {0x1A,0x3D,0x66,0x26,0x93,0x36,0xB7,0xEC,0x66,0x99,0x8B,0xFE,0x1B,0xEC,0xDE,0x75};
+
   TRenewDelegationTokenReq(const TRenewDelegationTokenReq&);
   TRenewDelegationTokenReq& operator=(const TRenewDelegationTokenReq&);
   TRenewDelegationTokenReq() : delegationToken() {
@@ -4085,21 +3872,18 @@ class TRenewDelegationTokenReq {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TRenewDelegationTokenReq& obj);
 };
 
 void swap(TRenewDelegationTokenReq &a, TRenewDelegationTokenReq &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TRenewDelegationTokenReq& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 
 class TRenewDelegationTokenResp {
  public:
 
+  static const char* ascii_fingerprint; // = "7142E89F09DC7C5F6FA916C7393F46C2";
+  static const uint8_t binary_fingerprint[16]; // = {0x71,0x42,0xE8,0x9F,0x09,0xDC,0x7C,0x5F,0x6F,0xA9,0x16,0xC7,0x39,0x3F,0x46,0xC2};
+
   TRenewDelegationTokenResp(const TRenewDelegationTokenResp&);
   TRenewDelegationTokenResp& operator=(const TRenewDelegationTokenResp&);
   TRenewDelegationTokenResp() {
@@ -4125,17 +3909,11 @@ class TRenewDelegationTokenResp {
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
-  virtual void printTo(std::ostream& out) const;
+  friend std::ostream& operator<<(std::ostream& out, const TRenewDelegationTokenResp& obj);
 };
 
 void swap(TRenewDelegationTokenResp &a, TRenewDelegationTokenResp &b);
 
-inline std::ostream& operator<<(std::ostream& out, const TRenewDelegationTokenResp& obj)
-{
-  obj.printTo(out);
-  return out;
-}
-
 }}}}} // namespace
 
 #endif


Mime
View raw message