/**
 * Autogenerated by Thrift Compiler (0.14.1)
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 *  @generated
 */
#ifndef rpc_TYPES_H
#define rpc_TYPES_H

#include <iosfwd>

#include <thrift/Thrift.h>
#include <thrift/TApplicationException.h>
#include <thrift/TBase.h>
#include <thrift/protocol/TProtocol.h>
#include <thrift/transport/TTransport.h>

#include <functional>
#include <memory>




struct TSProtocolVersion {
  enum type {
    IOTDB_SERVICE_PROTOCOL_V1 = 0,
    IOTDB_SERVICE_PROTOCOL_V2 = 1,
    IOTDB_SERVICE_PROTOCOL_V3 = 2
  };
};

extern const std::map<int, const char*> _TSProtocolVersion_VALUES_TO_NAMES;

std::ostream& operator<<(std::ostream& out, const TSProtocolVersion::type& val);

std::string to_string(const TSProtocolVersion::type& val);

class EndPoint;

class TSStatus;

class TSQueryDataSet;

class TSQueryNonAlignDataSet;

class TSExecuteStatementResp;

class TSOpenSessionResp;

class TSOpenSessionReq;

class TSCloseSessionReq;

class TSExecuteStatementReq;

class TSExecuteBatchStatementReq;

class TSGetOperationStatusReq;

class TSCancelOperationReq;

class TSCloseOperationReq;

class TSFetchResultsReq;

class TSFetchResultsResp;

class TSFetchMetadataResp;

class TSFetchMetadataReq;

class TSGetTimeZoneResp;

class TSSetTimeZoneReq;

class TSInsertRecordReq;

class TSInsertStringRecordReq;

class TSInsertTabletReq;

class TSInsertTabletsReq;

class TSInsertRecordsReq;

class TSInsertRecordsOfOneDeviceReq;

class TSInsertStringRecordsReq;

class TSDeleteDataReq;

class TSCreateTimeseriesReq;

class TSRawDataQueryReq;

class TSCreateMultiTimeseriesReq;

class ServerProperties;

class TSSetSchemaTemplateReq;

class TSCreateSchemaTemplateReq;


class EndPoint : public virtual ::apache::thrift::TBase {
 public:

  EndPoint(const EndPoint&);
  EndPoint& operator=(const EndPoint&);
  EndPoint() : ip(), port(0) {
  }

  virtual ~EndPoint() noexcept;
  std::string ip;
  int32_t port;

  void __set_ip(const std::string& val);

  void __set_port(const int32_t val);

  bool operator == (const EndPoint & rhs) const
  {
    if (!(ip == rhs.ip))
      return false;
    if (!(port == rhs.port))
      return false;
    return true;
  }
  bool operator != (const EndPoint &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const EndPoint & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

  virtual void printTo(std::ostream& out) const;
};

void swap(EndPoint &a, EndPoint &b);

std::ostream& operator<<(std::ostream& out, const EndPoint& obj);

typedef struct _TSStatus__isset {
  _TSStatus__isset() : message(false), subStatus(false), redirectNode(false) {}
  bool message :1;
  bool subStatus :1;
  bool redirectNode :1;
} _TSStatus__isset;

class TSStatus : public virtual ::apache::thrift::TBase {
 public:

  TSStatus(const TSStatus&);
  TSStatus& operator=(const TSStatus&);
  TSStatus() : code(0), message() {
  }

  virtual ~TSStatus() noexcept;
  int32_t code;
  std::string message;
  std::vector<TSStatus>  subStatus;
  EndPoint redirectNode;

  _TSStatus__isset __isset;

  void __set_code(const int32_t val);

  void __set_message(const std::string& val);

  void __set_subStatus(const std::vector<TSStatus> & val);

  void __set_redirectNode(const EndPoint& val);

  bool operator == (const TSStatus & rhs) const
  {
    if (!(code == rhs.code))
      return false;
    if (__isset.message != rhs.__isset.message)
      return false;
    else if (__isset.message && !(message == rhs.message))
      return false;
    if (__isset.subStatus != rhs.__isset.subStatus)
      return false;
    else if (__isset.subStatus && !(subStatus == rhs.subStatus))
      return false;
    if (__isset.redirectNode != rhs.__isset.redirectNode)
      return false;
    else if (__isset.redirectNode && !(redirectNode == rhs.redirectNode))
      return false;
    return true;
  }
  bool operator != (const TSStatus &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TSStatus & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

  virtual void printTo(std::ostream& out) const;
};

void swap(TSStatus &a, TSStatus &b);

std::ostream& operator<<(std::ostream& out, const TSStatus& obj);


class TSQueryDataSet : public virtual ::apache::thrift::TBase {
 public:

  TSQueryDataSet(const TSQueryDataSet&);
  TSQueryDataSet& operator=(const TSQueryDataSet&);
  TSQueryDataSet() : time() {
  }

  virtual ~TSQueryDataSet() noexcept;
  std::string time;
  std::vector<std::string>  valueList;
  std::vector<std::string>  bitmapList;

  void __set_time(const std::string& val);

  void __set_valueList(const std::vector<std::string> & val);

  void __set_bitmapList(const std::vector<std::string> & val);

  bool operator == (const TSQueryDataSet & rhs) const
  {
    if (!(time == rhs.time))
      return false;
    if (!(valueList == rhs.valueList))
      return false;
    if (!(bitmapList == rhs.bitmapList))
      return false;
    return true;
  }
  bool operator != (const TSQueryDataSet &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TSQueryDataSet & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

  virtual void printTo(std::ostream& out) const;
};

void swap(TSQueryDataSet &a, TSQueryDataSet &b);

std::ostream& operator<<(std::ostream& out, const TSQueryDataSet& obj);


class TSQueryNonAlignDataSet : public virtual ::apache::thrift::TBase {
 public:

  TSQueryNonAlignDataSet(const TSQueryNonAlignDataSet&);
  TSQueryNonAlignDataSet& operator=(const TSQueryNonAlignDataSet&);
  TSQueryNonAlignDataSet() {
  }

  virtual ~TSQueryNonAlignDataSet() noexcept;
  std::vector<std::string>  timeList;
  std::vector<std::string>  valueList;

  void __set_timeList(const std::vector<std::string> & val);

  void __set_valueList(const std::vector<std::string> & val);

  bool operator == (const TSQueryNonAlignDataSet & rhs) const
  {
    if (!(timeList == rhs.timeList))
      return false;
    if (!(valueList == rhs.valueList))
      return false;
    return true;
  }
  bool operator != (const TSQueryNonAlignDataSet &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TSQueryNonAlignDataSet & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

  virtual void printTo(std::ostream& out) const;
};

void swap(TSQueryNonAlignDataSet &a, TSQueryNonAlignDataSet &b);

std::ostream& operator<<(std::ostream& out, const TSQueryNonAlignDataSet& obj);

typedef struct _TSExecuteStatementResp__isset {
  _TSExecuteStatementResp__isset() : queryId(false), columns(false), operationType(false), ignoreTimeStamp(false), dataTypeList(false), queryDataSet(false), nonAlignQueryDataSet(false), columnNameIndexMap(false) {}
  bool queryId :1;
  bool columns :1;
  bool operationType :1;
  bool ignoreTimeStamp :1;
  bool dataTypeList :1;
  bool queryDataSet :1;
  bool nonAlignQueryDataSet :1;
  bool columnNameIndexMap :1;
} _TSExecuteStatementResp__isset;

class TSExecuteStatementResp : public virtual ::apache::thrift::TBase {
 public:

  TSExecuteStatementResp(const TSExecuteStatementResp&);
  TSExecuteStatementResp& operator=(const TSExecuteStatementResp&);
  TSExecuteStatementResp() : queryId(0), operationType(), ignoreTimeStamp(0) {
  }

  virtual ~TSExecuteStatementResp() noexcept;
  TSStatus status;
  int64_t queryId;
  std::vector<std::string>  columns;
  std::string operationType;
  bool ignoreTimeStamp;
  std::vector<std::string>  dataTypeList;
  TSQueryDataSet queryDataSet;
  TSQueryNonAlignDataSet nonAlignQueryDataSet;
  std::map<std::string, int32_t>  columnNameIndexMap;

  _TSExecuteStatementResp__isset __isset;

  void __set_status(const TSStatus& val);

  void __set_queryId(const int64_t val);

  void __set_columns(const std::vector<std::string> & val);

  void __set_operationType(const std::string& val);

  void __set_ignoreTimeStamp(const bool val);

  void __set_dataTypeList(const std::vector<std::string> & val);

  void __set_queryDataSet(const TSQueryDataSet& val);

  void __set_nonAlignQueryDataSet(const TSQueryNonAlignDataSet& val);

  void __set_columnNameIndexMap(const std::map<std::string, int32_t> & val);

  bool operator == (const TSExecuteStatementResp & rhs) const
  {
    if (!(status == rhs.status))
      return false;
    if (__isset.queryId != rhs.__isset.queryId)
      return false;
    else if (__isset.queryId && !(queryId == rhs.queryId))
      return false;
    if (__isset.columns != rhs.__isset.columns)
      return false;
    else if (__isset.columns && !(columns == rhs.columns))
      return false;
    if (__isset.operationType != rhs.__isset.operationType)
      return false;
    else if (__isset.operationType && !(operationType == rhs.operationType))
      return false;
    if (__isset.ignoreTimeStamp != rhs.__isset.ignoreTimeStamp)
      return false;
    else if (__isset.ignoreTimeStamp && !(ignoreTimeStamp == rhs.ignoreTimeStamp))
      return false;
    if (__isset.dataTypeList != rhs.__isset.dataTypeList)
      return false;
    else if (__isset.dataTypeList && !(dataTypeList == rhs.dataTypeList))
      return false;
    if (__isset.queryDataSet != rhs.__isset.queryDataSet)
      return false;
    else if (__isset.queryDataSet && !(queryDataSet == rhs.queryDataSet))
      return false;
    if (__isset.nonAlignQueryDataSet != rhs.__isset.nonAlignQueryDataSet)
      return false;
    else if (__isset.nonAlignQueryDataSet && !(nonAlignQueryDataSet == rhs.nonAlignQueryDataSet))
      return false;
    if (__isset.columnNameIndexMap != rhs.__isset.columnNameIndexMap)
      return false;
    else if (__isset.columnNameIndexMap && !(columnNameIndexMap == rhs.columnNameIndexMap))
      return false;
    return true;
  }
  bool operator != (const TSExecuteStatementResp &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TSExecuteStatementResp & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

  virtual void printTo(std::ostream& out) const;
};

void swap(TSExecuteStatementResp &a, TSExecuteStatementResp &b);

std::ostream& operator<<(std::ostream& out, const TSExecuteStatementResp& obj);

typedef struct _TSOpenSessionResp__isset {
  _TSOpenSessionResp__isset() : sessionId(false), configuration(false) {}
  bool sessionId :1;
  bool configuration :1;
} _TSOpenSessionResp__isset;

class TSOpenSessionResp : public virtual ::apache::thrift::TBase {
 public:

  TSOpenSessionResp(const TSOpenSessionResp&);
  TSOpenSessionResp& operator=(const TSOpenSessionResp&);
  TSOpenSessionResp() : serverProtocolVersion((TSProtocolVersion::type)0), sessionId(0) {
    serverProtocolVersion = (TSProtocolVersion::type)0;

  }

  virtual ~TSOpenSessionResp() noexcept;
  TSStatus status;
  /**
   * 
   * @see TSProtocolVersion
   */
  TSProtocolVersion::type serverProtocolVersion;
  int64_t sessionId;
  std::map<std::string, std::string>  configuration;

  _TSOpenSessionResp__isset __isset;

  void __set_status(const TSStatus& val);

  void __set_serverProtocolVersion(const TSProtocolVersion::type val);

  void __set_sessionId(const int64_t val);

  void __set_configuration(const std::map<std::string, std::string> & val);

  bool operator == (const TSOpenSessionResp & rhs) const
  {
    if (!(status == rhs.status))
      return false;
    if (!(serverProtocolVersion == rhs.serverProtocolVersion))
      return false;
    if (__isset.sessionId != rhs.__isset.sessionId)
      return false;
    else if (__isset.sessionId && !(sessionId == rhs.sessionId))
      return false;
    if (__isset.configuration != rhs.__isset.configuration)
      return false;
    else if (__isset.configuration && !(configuration == rhs.configuration))
      return false;
    return true;
  }
  bool operator != (const TSOpenSessionResp &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TSOpenSessionResp & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

  virtual void printTo(std::ostream& out) const;
};

void swap(TSOpenSessionResp &a, TSOpenSessionResp &b);

std::ostream& operator<<(std::ostream& out, const TSOpenSessionResp& obj);

typedef struct _TSOpenSessionReq__isset {
  _TSOpenSessionReq__isset() : username(false), password(false), configuration(false) {}
  bool username :1;
  bool password :1;
  bool configuration :1;
} _TSOpenSessionReq__isset;

class TSOpenSessionReq : public virtual ::apache::thrift::TBase {
 public:

  TSOpenSessionReq(const TSOpenSessionReq&);
  TSOpenSessionReq& operator=(const TSOpenSessionReq&);
  TSOpenSessionReq() : client_protocol((TSProtocolVersion::type)2), zoneId(), username(), password() {
    client_protocol = (TSProtocolVersion::type)2;

  }

  virtual ~TSOpenSessionReq() noexcept;
  /**
   * 
   * @see TSProtocolVersion
   */
  TSProtocolVersion::type client_protocol;
  std::string zoneId;
  std::string username;
  std::string password;
  std::map<std::string, std::string>  configuration;

  _TSOpenSessionReq__isset __isset;

  void __set_client_protocol(const TSProtocolVersion::type val);

  void __set_zoneId(const std::string& val);

  void __set_username(const std::string& val);

  void __set_password(const std::string& val);

  void __set_configuration(const std::map<std::string, std::string> & val);

  bool operator == (const TSOpenSessionReq & rhs) const
  {
    if (!(client_protocol == rhs.client_protocol))
      return false;
    if (!(zoneId == rhs.zoneId))
      return false;
    if (__isset.username != rhs.__isset.username)
      return false;
    else if (__isset.username && !(username == rhs.username))
      return false;
    if (__isset.password != rhs.__isset.password)
      return false;
    else if (__isset.password && !(password == rhs.password))
      return false;
    if (__isset.configuration != rhs.__isset.configuration)
      return false;
    else if (__isset.configuration && !(configuration == rhs.configuration))
      return false;
    return true;
  }
  bool operator != (const TSOpenSessionReq &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TSOpenSessionReq & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

  virtual void printTo(std::ostream& out) const;
};

void swap(TSOpenSessionReq &a, TSOpenSessionReq &b);

std::ostream& operator<<(std::ostream& out, const TSOpenSessionReq& obj);


class TSCloseSessionReq : public virtual ::apache::thrift::TBase {
 public:

  TSCloseSessionReq(const TSCloseSessionReq&);
  TSCloseSessionReq& operator=(const TSCloseSessionReq&);
  TSCloseSessionReq() : sessionId(0) {
  }

  virtual ~TSCloseSessionReq() noexcept;
  int64_t sessionId;

  void __set_sessionId(const int64_t val);

  bool operator == (const TSCloseSessionReq & rhs) const
  {
    if (!(sessionId == rhs.sessionId))
      return false;
    return true;
  }
  bool operator != (const TSCloseSessionReq &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TSCloseSessionReq & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

  virtual void printTo(std::ostream& out) const;
};

void swap(TSCloseSessionReq &a, TSCloseSessionReq &b);

std::ostream& operator<<(std::ostream& out, const TSCloseSessionReq& obj);

typedef struct _TSExecuteStatementReq__isset {
  _TSExecuteStatementReq__isset() : fetchSize(false), timeout(false), enableRedirectQuery(false) {}
  bool fetchSize :1;
  bool timeout :1;
  bool enableRedirectQuery :1;
} _TSExecuteStatementReq__isset;

class TSExecuteStatementReq : public virtual ::apache::thrift::TBase {
 public:

  TSExecuteStatementReq(const TSExecuteStatementReq&);
  TSExecuteStatementReq& operator=(const TSExecuteStatementReq&);
  TSExecuteStatementReq() : sessionId(0), statement(), statementId(0), fetchSize(0), timeout(0), enableRedirectQuery(0) {
  }

  virtual ~TSExecuteStatementReq() noexcept;
  int64_t sessionId;
  std::string statement;
  int64_t statementId;
  int32_t fetchSize;
  int64_t timeout;
  bool enableRedirectQuery;

  _TSExecuteStatementReq__isset __isset;

  void __set_sessionId(const int64_t val);

  void __set_statement(const std::string& val);

  void __set_statementId(const int64_t val);

  void __set_fetchSize(const int32_t val);

  void __set_timeout(const int64_t val);

  void __set_enableRedirectQuery(const bool val);

  bool operator == (const TSExecuteStatementReq & rhs) const
  {
    if (!(sessionId == rhs.sessionId))
      return false;
    if (!(statement == rhs.statement))
      return false;
    if (!(statementId == rhs.statementId))
      return false;
    if (__isset.fetchSize != rhs.__isset.fetchSize)
      return false;
    else if (__isset.fetchSize && !(fetchSize == rhs.fetchSize))
      return false;
    if (__isset.timeout != rhs.__isset.timeout)
      return false;
    else if (__isset.timeout && !(timeout == rhs.timeout))
      return false;
    if (__isset.enableRedirectQuery != rhs.__isset.enableRedirectQuery)
      return false;
    else if (__isset.enableRedirectQuery && !(enableRedirectQuery == rhs.enableRedirectQuery))
      return false;
    return true;
  }
  bool operator != (const TSExecuteStatementReq &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TSExecuteStatementReq & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

  virtual void printTo(std::ostream& out) const;
};

void swap(TSExecuteStatementReq &a, TSExecuteStatementReq &b);

std::ostream& operator<<(std::ostream& out, const TSExecuteStatementReq& obj);


class TSExecuteBatchStatementReq : public virtual ::apache::thrift::TBase {
 public:

  TSExecuteBatchStatementReq(const TSExecuteBatchStatementReq&);
  TSExecuteBatchStatementReq& operator=(const TSExecuteBatchStatementReq&);
  TSExecuteBatchStatementReq() : sessionId(0) {
  }

  virtual ~TSExecuteBatchStatementReq() noexcept;
  int64_t sessionId;
  std::vector<std::string>  statements;

  void __set_sessionId(const int64_t val);

  void __set_statements(const std::vector<std::string> & val);

  bool operator == (const TSExecuteBatchStatementReq & rhs) const
  {
    if (!(sessionId == rhs.sessionId))
      return false;
    if (!(statements == rhs.statements))
      return false;
    return true;
  }
  bool operator != (const TSExecuteBatchStatementReq &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TSExecuteBatchStatementReq & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

  virtual void printTo(std::ostream& out) const;
};

void swap(TSExecuteBatchStatementReq &a, TSExecuteBatchStatementReq &b);

std::ostream& operator<<(std::ostream& out, const TSExecuteBatchStatementReq& obj);


class TSGetOperationStatusReq : public virtual ::apache::thrift::TBase {
 public:

  TSGetOperationStatusReq(const TSGetOperationStatusReq&);
  TSGetOperationStatusReq& operator=(const TSGetOperationStatusReq&);
  TSGetOperationStatusReq() : sessionId(0), queryId(0) {
  }

  virtual ~TSGetOperationStatusReq() noexcept;
  int64_t sessionId;
  int64_t queryId;

  void __set_sessionId(const int64_t val);

  void __set_queryId(const int64_t val);

  bool operator == (const TSGetOperationStatusReq & rhs) const
  {
    if (!(sessionId == rhs.sessionId))
      return false;
    if (!(queryId == rhs.queryId))
      return false;
    return true;
  }
  bool operator != (const TSGetOperationStatusReq &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TSGetOperationStatusReq & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

  virtual void printTo(std::ostream& out) const;
};

void swap(TSGetOperationStatusReq &a, TSGetOperationStatusReq &b);

std::ostream& operator<<(std::ostream& out, const TSGetOperationStatusReq& obj);


class TSCancelOperationReq : public virtual ::apache::thrift::TBase {
 public:

  TSCancelOperationReq(const TSCancelOperationReq&);
  TSCancelOperationReq& operator=(const TSCancelOperationReq&);
  TSCancelOperationReq() : sessionId(0), queryId(0) {
  }

  virtual ~TSCancelOperationReq() noexcept;
  int64_t sessionId;
  int64_t queryId;

  void __set_sessionId(const int64_t val);

  void __set_queryId(const int64_t val);

  bool operator == (const TSCancelOperationReq & rhs) const
  {
    if (!(sessionId == rhs.sessionId))
      return false;
    if (!(queryId == rhs.queryId))
      return false;
    return true;
  }
  bool operator != (const TSCancelOperationReq &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TSCancelOperationReq & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

  virtual void printTo(std::ostream& out) const;
};

void swap(TSCancelOperationReq &a, TSCancelOperationReq &b);

std::ostream& operator<<(std::ostream& out, const TSCancelOperationReq& obj);

typedef struct _TSCloseOperationReq__isset {
  _TSCloseOperationReq__isset() : queryId(false), statementId(false) {}
  bool queryId :1;
  bool statementId :1;
} _TSCloseOperationReq__isset;

class TSCloseOperationReq : public virtual ::apache::thrift::TBase {
 public:

  TSCloseOperationReq(const TSCloseOperationReq&);
  TSCloseOperationReq& operator=(const TSCloseOperationReq&);
  TSCloseOperationReq() : sessionId(0), queryId(0), statementId(0) {
  }

  virtual ~TSCloseOperationReq() noexcept;
  int64_t sessionId;
  int64_t queryId;
  int64_t statementId;

  _TSCloseOperationReq__isset __isset;

  void __set_sessionId(const int64_t val);

  void __set_queryId(const int64_t val);

  void __set_statementId(const int64_t val);

  bool operator == (const TSCloseOperationReq & rhs) const
  {
    if (!(sessionId == rhs.sessionId))
      return false;
    if (__isset.queryId != rhs.__isset.queryId)
      return false;
    else if (__isset.queryId && !(queryId == rhs.queryId))
      return false;
    if (__isset.statementId != rhs.__isset.statementId)
      return false;
    else if (__isset.statementId && !(statementId == rhs.statementId))
      return false;
    return true;
  }
  bool operator != (const TSCloseOperationReq &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TSCloseOperationReq & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

  virtual void printTo(std::ostream& out) const;
};

void swap(TSCloseOperationReq &a, TSCloseOperationReq &b);

std::ostream& operator<<(std::ostream& out, const TSCloseOperationReq& obj);

typedef struct _TSFetchResultsReq__isset {
  _TSFetchResultsReq__isset() : timeout(false) {}
  bool timeout :1;
} _TSFetchResultsReq__isset;

class TSFetchResultsReq : public virtual ::apache::thrift::TBase {
 public:

  TSFetchResultsReq(const TSFetchResultsReq&);
  TSFetchResultsReq& operator=(const TSFetchResultsReq&);
  TSFetchResultsReq() : sessionId(0), statement(), fetchSize(0), queryId(0), isAlign(0), timeout(0) {
  }

  virtual ~TSFetchResultsReq() noexcept;
  int64_t sessionId;
  std::string statement;
  int32_t fetchSize;
  int64_t queryId;
  bool isAlign;
  int64_t timeout;

  _TSFetchResultsReq__isset __isset;

  void __set_sessionId(const int64_t val);

  void __set_statement(const std::string& val);

  void __set_fetchSize(const int32_t val);

  void __set_queryId(const int64_t val);

  void __set_isAlign(const bool val);

  void __set_timeout(const int64_t val);

  bool operator == (const TSFetchResultsReq & rhs) const
  {
    if (!(sessionId == rhs.sessionId))
      return false;
    if (!(statement == rhs.statement))
      return false;
    if (!(fetchSize == rhs.fetchSize))
      return false;
    if (!(queryId == rhs.queryId))
      return false;
    if (!(isAlign == rhs.isAlign))
      return false;
    if (__isset.timeout != rhs.__isset.timeout)
      return false;
    else if (__isset.timeout && !(timeout == rhs.timeout))
      return false;
    return true;
  }
  bool operator != (const TSFetchResultsReq &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TSFetchResultsReq & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

  virtual void printTo(std::ostream& out) const;
};

void swap(TSFetchResultsReq &a, TSFetchResultsReq &b);

std::ostream& operator<<(std::ostream& out, const TSFetchResultsReq& obj);

typedef struct _TSFetchResultsResp__isset {
  _TSFetchResultsResp__isset() : queryDataSet(false), nonAlignQueryDataSet(false) {}
  bool queryDataSet :1;
  bool nonAlignQueryDataSet :1;
} _TSFetchResultsResp__isset;

class TSFetchResultsResp : public virtual ::apache::thrift::TBase {
 public:

  TSFetchResultsResp(const TSFetchResultsResp&);
  TSFetchResultsResp& operator=(const TSFetchResultsResp&);
  TSFetchResultsResp() : hasResultSet(0), isAlign(0) {
  }

  virtual ~TSFetchResultsResp() noexcept;
  TSStatus status;
  bool hasResultSet;
  bool isAlign;
  TSQueryDataSet queryDataSet;
  TSQueryNonAlignDataSet nonAlignQueryDataSet;

  _TSFetchResultsResp__isset __isset;

  void __set_status(const TSStatus& val);

  void __set_hasResultSet(const bool val);

  void __set_isAlign(const bool val);

  void __set_queryDataSet(const TSQueryDataSet& val);

  void __set_nonAlignQueryDataSet(const TSQueryNonAlignDataSet& val);

  bool operator == (const TSFetchResultsResp & rhs) const
  {
    if (!(status == rhs.status))
      return false;
    if (!(hasResultSet == rhs.hasResultSet))
      return false;
    if (!(isAlign == rhs.isAlign))
      return false;
    if (__isset.queryDataSet != rhs.__isset.queryDataSet)
      return false;
    else if (__isset.queryDataSet && !(queryDataSet == rhs.queryDataSet))
      return false;
    if (__isset.nonAlignQueryDataSet != rhs.__isset.nonAlignQueryDataSet)
      return false;
    else if (__isset.nonAlignQueryDataSet && !(nonAlignQueryDataSet == rhs.nonAlignQueryDataSet))
      return false;
    return true;
  }
  bool operator != (const TSFetchResultsResp &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TSFetchResultsResp & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

  virtual void printTo(std::ostream& out) const;
};

void swap(TSFetchResultsResp &a, TSFetchResultsResp &b);

std::ostream& operator<<(std::ostream& out, const TSFetchResultsResp& obj);

typedef struct _TSFetchMetadataResp__isset {
  _TSFetchMetadataResp__isset() : metadataInJson(false), columnsList(false), dataType(false) {}
  bool metadataInJson :1;
  bool columnsList :1;
  bool dataType :1;
} _TSFetchMetadataResp__isset;

class TSFetchMetadataResp : public virtual ::apache::thrift::TBase {
 public:

  TSFetchMetadataResp(const TSFetchMetadataResp&);
  TSFetchMetadataResp& operator=(const TSFetchMetadataResp&);
  TSFetchMetadataResp() : metadataInJson(), dataType() {
  }

  virtual ~TSFetchMetadataResp() noexcept;
  TSStatus status;
  std::string metadataInJson;
  std::vector<std::string>  columnsList;
  std::string dataType;

  _TSFetchMetadataResp__isset __isset;

  void __set_status(const TSStatus& val);

  void __set_metadataInJson(const std::string& val);

  void __set_columnsList(const std::vector<std::string> & val);

  void __set_dataType(const std::string& val);

  bool operator == (const TSFetchMetadataResp & rhs) const
  {
    if (!(status == rhs.status))
      return false;
    if (__isset.metadataInJson != rhs.__isset.metadataInJson)
      return false;
    else if (__isset.metadataInJson && !(metadataInJson == rhs.metadataInJson))
      return false;
    if (__isset.columnsList != rhs.__isset.columnsList)
      return false;
    else if (__isset.columnsList && !(columnsList == rhs.columnsList))
      return false;
    if (__isset.dataType != rhs.__isset.dataType)
      return false;
    else if (__isset.dataType && !(dataType == rhs.dataType))
      return false;
    return true;
  }
  bool operator != (const TSFetchMetadataResp &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TSFetchMetadataResp & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

  virtual void printTo(std::ostream& out) const;
};

void swap(TSFetchMetadataResp &a, TSFetchMetadataResp &b);

std::ostream& operator<<(std::ostream& out, const TSFetchMetadataResp& obj);

typedef struct _TSFetchMetadataReq__isset {
  _TSFetchMetadataReq__isset() : columnPath(false) {}
  bool columnPath :1;
} _TSFetchMetadataReq__isset;

class TSFetchMetadataReq : public virtual ::apache::thrift::TBase {
 public:

  TSFetchMetadataReq(const TSFetchMetadataReq&);
  TSFetchMetadataReq& operator=(const TSFetchMetadataReq&);
  TSFetchMetadataReq() : sessionId(0), type(), columnPath() {
  }

  virtual ~TSFetchMetadataReq() noexcept;
  int64_t sessionId;
  std::string type;
  std::string columnPath;

  _TSFetchMetadataReq__isset __isset;

  void __set_sessionId(const int64_t val);

  void __set_type(const std::string& val);

  void __set_columnPath(const std::string& val);

  bool operator == (const TSFetchMetadataReq & rhs) const
  {
    if (!(sessionId == rhs.sessionId))
      return false;
    if (!(type == rhs.type))
      return false;
    if (__isset.columnPath != rhs.__isset.columnPath)
      return false;
    else if (__isset.columnPath && !(columnPath == rhs.columnPath))
      return false;
    return true;
  }
  bool operator != (const TSFetchMetadataReq &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TSFetchMetadataReq & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

  virtual void printTo(std::ostream& out) const;
};

void swap(TSFetchMetadataReq &a, TSFetchMetadataReq &b);

std::ostream& operator<<(std::ostream& out, const TSFetchMetadataReq& obj);


class TSGetTimeZoneResp : public virtual ::apache::thrift::TBase {
 public:

  TSGetTimeZoneResp(const TSGetTimeZoneResp&);
  TSGetTimeZoneResp& operator=(const TSGetTimeZoneResp&);
  TSGetTimeZoneResp() : timeZone() {
  }

  virtual ~TSGetTimeZoneResp() noexcept;
  TSStatus status;
  std::string timeZone;

  void __set_status(const TSStatus& val);

  void __set_timeZone(const std::string& val);

  bool operator == (const TSGetTimeZoneResp & rhs) const
  {
    if (!(status == rhs.status))
      return false;
    if (!(timeZone == rhs.timeZone))
      return false;
    return true;
  }
  bool operator != (const TSGetTimeZoneResp &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TSGetTimeZoneResp & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

  virtual void printTo(std::ostream& out) const;
};

void swap(TSGetTimeZoneResp &a, TSGetTimeZoneResp &b);

std::ostream& operator<<(std::ostream& out, const TSGetTimeZoneResp& obj);


class TSSetTimeZoneReq : public virtual ::apache::thrift::TBase {
 public:

  TSSetTimeZoneReq(const TSSetTimeZoneReq&);
  TSSetTimeZoneReq& operator=(const TSSetTimeZoneReq&);
  TSSetTimeZoneReq() : sessionId(0), timeZone() {
  }

  virtual ~TSSetTimeZoneReq() noexcept;
  int64_t sessionId;
  std::string timeZone;

  void __set_sessionId(const int64_t val);

  void __set_timeZone(const std::string& val);

  bool operator == (const TSSetTimeZoneReq & rhs) const
  {
    if (!(sessionId == rhs.sessionId))
      return false;
    if (!(timeZone == rhs.timeZone))
      return false;
    return true;
  }
  bool operator != (const TSSetTimeZoneReq &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TSSetTimeZoneReq & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

  virtual void printTo(std::ostream& out) const;
};

void swap(TSSetTimeZoneReq &a, TSSetTimeZoneReq &b);

std::ostream& operator<<(std::ostream& out, const TSSetTimeZoneReq& obj);


class TSInsertRecordReq : public virtual ::apache::thrift::TBase {
 public:

  TSInsertRecordReq(const TSInsertRecordReq&);
  TSInsertRecordReq& operator=(const TSInsertRecordReq&);
  TSInsertRecordReq() : sessionId(0), deviceId(), values(), timestamp(0) {
  }

  virtual ~TSInsertRecordReq() noexcept;
  int64_t sessionId;
  std::string deviceId;
  std::vector<std::string>  measurements;
  std::string values;
  int64_t timestamp;

  void __set_sessionId(const int64_t val);

  void __set_deviceId(const std::string& val);

  void __set_measurements(const std::vector<std::string> & val);

  void __set_values(const std::string& val);

  void __set_timestamp(const int64_t val);

  bool operator == (const TSInsertRecordReq & rhs) const
  {
    if (!(sessionId == rhs.sessionId))
      return false;
    if (!(deviceId == rhs.deviceId))
      return false;
    if (!(measurements == rhs.measurements))
      return false;
    if (!(values == rhs.values))
      return false;
    if (!(timestamp == rhs.timestamp))
      return false;
    return true;
  }
  bool operator != (const TSInsertRecordReq &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TSInsertRecordReq & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

  virtual void printTo(std::ostream& out) const;
};

void swap(TSInsertRecordReq &a, TSInsertRecordReq &b);

std::ostream& operator<<(std::ostream& out, const TSInsertRecordReq& obj);


class TSInsertStringRecordReq : public virtual ::apache::thrift::TBase {
 public:

  TSInsertStringRecordReq(const TSInsertStringRecordReq&);
  TSInsertStringRecordReq& operator=(const TSInsertStringRecordReq&);
  TSInsertStringRecordReq() : sessionId(0), deviceId(), timestamp(0) {
  }

  virtual ~TSInsertStringRecordReq() noexcept;
  int64_t sessionId;
  std::string deviceId;
  std::vector<std::string>  measurements;
  std::vector<std::string>  values;
  int64_t timestamp;

  void __set_sessionId(const int64_t val);

  void __set_deviceId(const std::string& val);

  void __set_measurements(const std::vector<std::string> & val);

  void __set_values(const std::vector<std::string> & val);

  void __set_timestamp(const int64_t val);

  bool operator == (const TSInsertStringRecordReq & rhs) const
  {
    if (!(sessionId == rhs.sessionId))
      return false;
    if (!(deviceId == rhs.deviceId))
      return false;
    if (!(measurements == rhs.measurements))
      return false;
    if (!(values == rhs.values))
      return false;
    if (!(timestamp == rhs.timestamp))
      return false;
    return true;
  }
  bool operator != (const TSInsertStringRecordReq &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TSInsertStringRecordReq & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

  virtual void printTo(std::ostream& out) const;
};

void swap(TSInsertStringRecordReq &a, TSInsertStringRecordReq &b);

std::ostream& operator<<(std::ostream& out, const TSInsertStringRecordReq& obj);


class TSInsertTabletReq : public virtual ::apache::thrift::TBase {
 public:

  TSInsertTabletReq(const TSInsertTabletReq&);
  TSInsertTabletReq& operator=(const TSInsertTabletReq&);
  TSInsertTabletReq() : sessionId(0), deviceId(), values(), timestamps(), size(0) {
  }

  virtual ~TSInsertTabletReq() noexcept;
  int64_t sessionId;
  std::string deviceId;
  std::vector<std::string>  measurements;
  std::string values;
  std::string timestamps;
  std::vector<int32_t>  types;
  int32_t size;

  void __set_sessionId(const int64_t val);

  void __set_deviceId(const std::string& val);

  void __set_measurements(const std::vector<std::string> & val);

  void __set_values(const std::string& val);

  void __set_timestamps(const std::string& val);

  void __set_types(const std::vector<int32_t> & val);

  void __set_size(const int32_t val);

  bool operator == (const TSInsertTabletReq & rhs) const
  {
    if (!(sessionId == rhs.sessionId))
      return false;
    if (!(deviceId == rhs.deviceId))
      return false;
    if (!(measurements == rhs.measurements))
      return false;
    if (!(values == rhs.values))
      return false;
    if (!(timestamps == rhs.timestamps))
      return false;
    if (!(types == rhs.types))
      return false;
    if (!(size == rhs.size))
      return false;
    return true;
  }
  bool operator != (const TSInsertTabletReq &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TSInsertTabletReq & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

  virtual void printTo(std::ostream& out) const;
};

void swap(TSInsertTabletReq &a, TSInsertTabletReq &b);

std::ostream& operator<<(std::ostream& out, const TSInsertTabletReq& obj);


class TSInsertTabletsReq : public virtual ::apache::thrift::TBase {
 public:

  TSInsertTabletsReq(const TSInsertTabletsReq&);
  TSInsertTabletsReq& operator=(const TSInsertTabletsReq&);
  TSInsertTabletsReq() : sessionId(0) {
  }

  virtual ~TSInsertTabletsReq() noexcept;
  int64_t sessionId;
  std::vector<std::string>  deviceIds;
  std::vector<std::vector<std::string> >  measurementsList;
  std::vector<std::string>  valuesList;
  std::vector<std::string>  timestampsList;
  std::vector<std::vector<int32_t> >  typesList;
  std::vector<int32_t>  sizeList;

  void __set_sessionId(const int64_t val);

  void __set_deviceIds(const std::vector<std::string> & val);

  void __set_measurementsList(const std::vector<std::vector<std::string> > & val);

  void __set_valuesList(const std::vector<std::string> & val);

  void __set_timestampsList(const std::vector<std::string> & val);

  void __set_typesList(const std::vector<std::vector<int32_t> > & val);

  void __set_sizeList(const std::vector<int32_t> & val);

  bool operator == (const TSInsertTabletsReq & rhs) const
  {
    if (!(sessionId == rhs.sessionId))
      return false;
    if (!(deviceIds == rhs.deviceIds))
      return false;
    if (!(measurementsList == rhs.measurementsList))
      return false;
    if (!(valuesList == rhs.valuesList))
      return false;
    if (!(timestampsList == rhs.timestampsList))
      return false;
    if (!(typesList == rhs.typesList))
      return false;
    if (!(sizeList == rhs.sizeList))
      return false;
    return true;
  }
  bool operator != (const TSInsertTabletsReq &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TSInsertTabletsReq & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

  virtual void printTo(std::ostream& out) const;
};

void swap(TSInsertTabletsReq &a, TSInsertTabletsReq &b);

std::ostream& operator<<(std::ostream& out, const TSInsertTabletsReq& obj);


class TSInsertRecordsReq : public virtual ::apache::thrift::TBase {
 public:

  TSInsertRecordsReq(const TSInsertRecordsReq&);
  TSInsertRecordsReq& operator=(const TSInsertRecordsReq&);
  TSInsertRecordsReq() : sessionId(0) {
  }

  virtual ~TSInsertRecordsReq() noexcept;
  int64_t sessionId;
  std::vector<std::string>  deviceIds;
  std::vector<std::vector<std::string> >  measurementsList;
  std::vector<std::string>  valuesList;
  std::vector<int64_t>  timestamps;

  void __set_sessionId(const int64_t val);

  void __set_deviceIds(const std::vector<std::string> & val);

  void __set_measurementsList(const std::vector<std::vector<std::string> > & val);

  void __set_valuesList(const std::vector<std::string> & val);

  void __set_timestamps(const std::vector<int64_t> & val);

  bool operator == (const TSInsertRecordsReq & rhs) const
  {
    if (!(sessionId == rhs.sessionId))
      return false;
    if (!(deviceIds == rhs.deviceIds))
      return false;
    if (!(measurementsList == rhs.measurementsList))
      return false;
    if (!(valuesList == rhs.valuesList))
      return false;
    if (!(timestamps == rhs.timestamps))
      return false;
    return true;
  }
  bool operator != (const TSInsertRecordsReq &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TSInsertRecordsReq & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

  virtual void printTo(std::ostream& out) const;
};

void swap(TSInsertRecordsReq &a, TSInsertRecordsReq &b);

std::ostream& operator<<(std::ostream& out, const TSInsertRecordsReq& obj);


class TSInsertRecordsOfOneDeviceReq : public virtual ::apache::thrift::TBase {
 public:

  TSInsertRecordsOfOneDeviceReq(const TSInsertRecordsOfOneDeviceReq&);
  TSInsertRecordsOfOneDeviceReq& operator=(const TSInsertRecordsOfOneDeviceReq&);
  TSInsertRecordsOfOneDeviceReq() : sessionId(0), deviceId() {
  }

  virtual ~TSInsertRecordsOfOneDeviceReq() noexcept;
  int64_t sessionId;
  std::string deviceId;
  std::vector<std::vector<std::string> >  measurementsList;
  std::vector<std::string>  valuesList;
  std::vector<int64_t>  timestamps;

  void __set_sessionId(const int64_t val);

  void __set_deviceId(const std::string& val);

  void __set_measurementsList(const std::vector<std::vector<std::string> > & val);

  void __set_valuesList(const std::vector<std::string> & val);

  void __set_timestamps(const std::vector<int64_t> & val);

  bool operator == (const TSInsertRecordsOfOneDeviceReq & rhs) const
  {
    if (!(sessionId == rhs.sessionId))
      return false;
    if (!(deviceId == rhs.deviceId))
      return false;
    if (!(measurementsList == rhs.measurementsList))
      return false;
    if (!(valuesList == rhs.valuesList))
      return false;
    if (!(timestamps == rhs.timestamps))
      return false;
    return true;
  }
  bool operator != (const TSInsertRecordsOfOneDeviceReq &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TSInsertRecordsOfOneDeviceReq & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

  virtual void printTo(std::ostream& out) const;
};

void swap(TSInsertRecordsOfOneDeviceReq &a, TSInsertRecordsOfOneDeviceReq &b);

std::ostream& operator<<(std::ostream& out, const TSInsertRecordsOfOneDeviceReq& obj);


class TSInsertStringRecordsReq : public virtual ::apache::thrift::TBase {
 public:

  TSInsertStringRecordsReq(const TSInsertStringRecordsReq&);
  TSInsertStringRecordsReq& operator=(const TSInsertStringRecordsReq&);
  TSInsertStringRecordsReq() : sessionId(0) {
  }

  virtual ~TSInsertStringRecordsReq() noexcept;
  int64_t sessionId;
  std::vector<std::string>  deviceIds;
  std::vector<std::vector<std::string> >  measurementsList;
  std::vector<std::vector<std::string> >  valuesList;
  std::vector<int64_t>  timestamps;

  void __set_sessionId(const int64_t val);

  void __set_deviceIds(const std::vector<std::string> & val);

  void __set_measurementsList(const std::vector<std::vector<std::string> > & val);

  void __set_valuesList(const std::vector<std::vector<std::string> > & val);

  void __set_timestamps(const std::vector<int64_t> & val);

  bool operator == (const TSInsertStringRecordsReq & rhs) const
  {
    if (!(sessionId == rhs.sessionId))
      return false;
    if (!(deviceIds == rhs.deviceIds))
      return false;
    if (!(measurementsList == rhs.measurementsList))
      return false;
    if (!(valuesList == rhs.valuesList))
      return false;
    if (!(timestamps == rhs.timestamps))
      return false;
    return true;
  }
  bool operator != (const TSInsertStringRecordsReq &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TSInsertStringRecordsReq & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

  virtual void printTo(std::ostream& out) const;
};

void swap(TSInsertStringRecordsReq &a, TSInsertStringRecordsReq &b);

std::ostream& operator<<(std::ostream& out, const TSInsertStringRecordsReq& obj);


class TSDeleteDataReq : public virtual ::apache::thrift::TBase {
 public:

  TSDeleteDataReq(const TSDeleteDataReq&);
  TSDeleteDataReq& operator=(const TSDeleteDataReq&);
  TSDeleteDataReq() : sessionId(0), startTime(0), endTime(0) {
  }

  virtual ~TSDeleteDataReq() noexcept;
  int64_t sessionId;
  std::vector<std::string>  paths;
  int64_t startTime;
  int64_t endTime;

  void __set_sessionId(const int64_t val);

  void __set_paths(const std::vector<std::string> & val);

  void __set_startTime(const int64_t val);

  void __set_endTime(const int64_t val);

  bool operator == (const TSDeleteDataReq & rhs) const
  {
    if (!(sessionId == rhs.sessionId))
      return false;
    if (!(paths == rhs.paths))
      return false;
    if (!(startTime == rhs.startTime))
      return false;
    if (!(endTime == rhs.endTime))
      return false;
    return true;
  }
  bool operator != (const TSDeleteDataReq &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TSDeleteDataReq & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

  virtual void printTo(std::ostream& out) const;
};

void swap(TSDeleteDataReq &a, TSDeleteDataReq &b);

std::ostream& operator<<(std::ostream& out, const TSDeleteDataReq& obj);

typedef struct _TSCreateTimeseriesReq__isset {
  _TSCreateTimeseriesReq__isset() : props(false), tags(false), attributes(false), measurementAlias(false) {}
  bool props :1;
  bool tags :1;
  bool attributes :1;
  bool measurementAlias :1;
} _TSCreateTimeseriesReq__isset;

class TSCreateTimeseriesReq : public virtual ::apache::thrift::TBase {
 public:

  TSCreateTimeseriesReq(const TSCreateTimeseriesReq&);
  TSCreateTimeseriesReq& operator=(const TSCreateTimeseriesReq&);
  TSCreateTimeseriesReq() : sessionId(0), path(), dataType(0), encoding(0), compressor(0), measurementAlias() {
  }

  virtual ~TSCreateTimeseriesReq() noexcept;
  int64_t sessionId;
  std::string path;
  int32_t dataType;
  int32_t encoding;
  int32_t compressor;
  std::map<std::string, std::string>  props;
  std::map<std::string, std::string>  tags;
  std::map<std::string, std::string>  attributes;
  std::string measurementAlias;

  _TSCreateTimeseriesReq__isset __isset;

  void __set_sessionId(const int64_t val);

  void __set_path(const std::string& val);

  void __set_dataType(const int32_t val);

  void __set_encoding(const int32_t val);

  void __set_compressor(const int32_t val);

  void __set_props(const std::map<std::string, std::string> & val);

  void __set_tags(const std::map<std::string, std::string> & val);

  void __set_attributes(const std::map<std::string, std::string> & val);

  void __set_measurementAlias(const std::string& val);

  bool operator == (const TSCreateTimeseriesReq & rhs) const
  {
    if (!(sessionId == rhs.sessionId))
      return false;
    if (!(path == rhs.path))
      return false;
    if (!(dataType == rhs.dataType))
      return false;
    if (!(encoding == rhs.encoding))
      return false;
    if (!(compressor == rhs.compressor))
      return false;
    if (__isset.props != rhs.__isset.props)
      return false;
    else if (__isset.props && !(props == rhs.props))
      return false;
    if (__isset.tags != rhs.__isset.tags)
      return false;
    else if (__isset.tags && !(tags == rhs.tags))
      return false;
    if (__isset.attributes != rhs.__isset.attributes)
      return false;
    else if (__isset.attributes && !(attributes == rhs.attributes))
      return false;
    if (__isset.measurementAlias != rhs.__isset.measurementAlias)
      return false;
    else if (__isset.measurementAlias && !(measurementAlias == rhs.measurementAlias))
      return false;
    return true;
  }
  bool operator != (const TSCreateTimeseriesReq &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TSCreateTimeseriesReq & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

  virtual void printTo(std::ostream& out) const;
};

void swap(TSCreateTimeseriesReq &a, TSCreateTimeseriesReq &b);

std::ostream& operator<<(std::ostream& out, const TSCreateTimeseriesReq& obj);

typedef struct _TSRawDataQueryReq__isset {
  _TSRawDataQueryReq__isset() : fetchSize(false), enableRedirectQuery(false) {}
  bool fetchSize :1;
  bool enableRedirectQuery :1;
} _TSRawDataQueryReq__isset;

class TSRawDataQueryReq : public virtual ::apache::thrift::TBase {
 public:

  TSRawDataQueryReq(const TSRawDataQueryReq&);
  TSRawDataQueryReq& operator=(const TSRawDataQueryReq&);
  TSRawDataQueryReq() : sessionId(0), fetchSize(0), startTime(0), endTime(0), statementId(0), enableRedirectQuery(0) {
  }

  virtual ~TSRawDataQueryReq() noexcept;
  int64_t sessionId;
  std::vector<std::string>  paths;
  int32_t fetchSize;
  int64_t startTime;
  int64_t endTime;
  int64_t statementId;
  bool enableRedirectQuery;

  _TSRawDataQueryReq__isset __isset;

  void __set_sessionId(const int64_t val);

  void __set_paths(const std::vector<std::string> & val);

  void __set_fetchSize(const int32_t val);

  void __set_startTime(const int64_t val);

  void __set_endTime(const int64_t val);

  void __set_statementId(const int64_t val);

  void __set_enableRedirectQuery(const bool val);

  bool operator == (const TSRawDataQueryReq & rhs) const
  {
    if (!(sessionId == rhs.sessionId))
      return false;
    if (!(paths == rhs.paths))
      return false;
    if (__isset.fetchSize != rhs.__isset.fetchSize)
      return false;
    else if (__isset.fetchSize && !(fetchSize == rhs.fetchSize))
      return false;
    if (!(startTime == rhs.startTime))
      return false;
    if (!(endTime == rhs.endTime))
      return false;
    if (!(statementId == rhs.statementId))
      return false;
    if (__isset.enableRedirectQuery != rhs.__isset.enableRedirectQuery)
      return false;
    else if (__isset.enableRedirectQuery && !(enableRedirectQuery == rhs.enableRedirectQuery))
      return false;
    return true;
  }
  bool operator != (const TSRawDataQueryReq &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TSRawDataQueryReq & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

  virtual void printTo(std::ostream& out) const;
};

void swap(TSRawDataQueryReq &a, TSRawDataQueryReq &b);

std::ostream& operator<<(std::ostream& out, const TSRawDataQueryReq& obj);

typedef struct _TSCreateMultiTimeseriesReq__isset {
  _TSCreateMultiTimeseriesReq__isset() : propsList(false), tagsList(false), attributesList(false), measurementAliasList(false) {}
  bool propsList :1;
  bool tagsList :1;
  bool attributesList :1;
  bool measurementAliasList :1;
} _TSCreateMultiTimeseriesReq__isset;

class TSCreateMultiTimeseriesReq : public virtual ::apache::thrift::TBase {
 public:

  TSCreateMultiTimeseriesReq(const TSCreateMultiTimeseriesReq&);
  TSCreateMultiTimeseriesReq& operator=(const TSCreateMultiTimeseriesReq&);
  TSCreateMultiTimeseriesReq() : sessionId(0) {
  }

  virtual ~TSCreateMultiTimeseriesReq() noexcept;
  int64_t sessionId;
  std::vector<std::string>  paths;
  std::vector<int32_t>  dataTypes;
  std::vector<int32_t>  encodings;
  std::vector<int32_t>  compressors;
  std::vector<std::map<std::string, std::string> >  propsList;
  std::vector<std::map<std::string, std::string> >  tagsList;
  std::vector<std::map<std::string, std::string> >  attributesList;
  std::vector<std::string>  measurementAliasList;

  _TSCreateMultiTimeseriesReq__isset __isset;

  void __set_sessionId(const int64_t val);

  void __set_paths(const std::vector<std::string> & val);

  void __set_dataTypes(const std::vector<int32_t> & val);

  void __set_encodings(const std::vector<int32_t> & val);

  void __set_compressors(const std::vector<int32_t> & val);

  void __set_propsList(const std::vector<std::map<std::string, std::string> > & val);

  void __set_tagsList(const std::vector<std::map<std::string, std::string> > & val);

  void __set_attributesList(const std::vector<std::map<std::string, std::string> > & val);

  void __set_measurementAliasList(const std::vector<std::string> & val);

  bool operator == (const TSCreateMultiTimeseriesReq & rhs) const
  {
    if (!(sessionId == rhs.sessionId))
      return false;
    if (!(paths == rhs.paths))
      return false;
    if (!(dataTypes == rhs.dataTypes))
      return false;
    if (!(encodings == rhs.encodings))
      return false;
    if (!(compressors == rhs.compressors))
      return false;
    if (__isset.propsList != rhs.__isset.propsList)
      return false;
    else if (__isset.propsList && !(propsList == rhs.propsList))
      return false;
    if (__isset.tagsList != rhs.__isset.tagsList)
      return false;
    else if (__isset.tagsList && !(tagsList == rhs.tagsList))
      return false;
    if (__isset.attributesList != rhs.__isset.attributesList)
      return false;
    else if (__isset.attributesList && !(attributesList == rhs.attributesList))
      return false;
    if (__isset.measurementAliasList != rhs.__isset.measurementAliasList)
      return false;
    else if (__isset.measurementAliasList && !(measurementAliasList == rhs.measurementAliasList))
      return false;
    return true;
  }
  bool operator != (const TSCreateMultiTimeseriesReq &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TSCreateMultiTimeseriesReq & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

  virtual void printTo(std::ostream& out) const;
};

void swap(TSCreateMultiTimeseriesReq &a, TSCreateMultiTimeseriesReq &b);

std::ostream& operator<<(std::ostream& out, const TSCreateMultiTimeseriesReq& obj);


class ServerProperties : public virtual ::apache::thrift::TBase {
 public:

  ServerProperties(const ServerProperties&);
  ServerProperties& operator=(const ServerProperties&);
  ServerProperties() : version(), timestampPrecision() {
  }

  virtual ~ServerProperties() noexcept;
  std::string version;
  std::vector<std::string>  supportedTimeAggregationOperations;
  std::string timestampPrecision;

  void __set_version(const std::string& val);

  void __set_supportedTimeAggregationOperations(const std::vector<std::string> & val);

  void __set_timestampPrecision(const std::string& val);

  bool operator == (const ServerProperties & rhs) const
  {
    if (!(version == rhs.version))
      return false;
    if (!(supportedTimeAggregationOperations == rhs.supportedTimeAggregationOperations))
      return false;
    if (!(timestampPrecision == rhs.timestampPrecision))
      return false;
    return true;
  }
  bool operator != (const ServerProperties &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ServerProperties & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

  virtual void printTo(std::ostream& out) const;
};

void swap(ServerProperties &a, ServerProperties &b);

std::ostream& operator<<(std::ostream& out, const ServerProperties& obj);


class TSSetSchemaTemplateReq : public virtual ::apache::thrift::TBase {
 public:

  TSSetSchemaTemplateReq(const TSSetSchemaTemplateReq&);
  TSSetSchemaTemplateReq& operator=(const TSSetSchemaTemplateReq&);
  TSSetSchemaTemplateReq() : sessionId(0), templateName(), prefixPath() {
  }

  virtual ~TSSetSchemaTemplateReq() noexcept;
  int64_t sessionId;
  std::string templateName;
  std::string prefixPath;

  void __set_sessionId(const int64_t val);

  void __set_templateName(const std::string& val);

  void __set_prefixPath(const std::string& val);

  bool operator == (const TSSetSchemaTemplateReq & rhs) const
  {
    if (!(sessionId == rhs.sessionId))
      return false;
    if (!(templateName == rhs.templateName))
      return false;
    if (!(prefixPath == rhs.prefixPath))
      return false;
    return true;
  }
  bool operator != (const TSSetSchemaTemplateReq &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TSSetSchemaTemplateReq & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

  virtual void printTo(std::ostream& out) const;
};

void swap(TSSetSchemaTemplateReq &a, TSSetSchemaTemplateReq &b);

std::ostream& operator<<(std::ostream& out, const TSSetSchemaTemplateReq& obj);


class TSCreateSchemaTemplateReq : public virtual ::apache::thrift::TBase {
 public:

  TSCreateSchemaTemplateReq(const TSCreateSchemaTemplateReq&);
  TSCreateSchemaTemplateReq& operator=(const TSCreateSchemaTemplateReq&);
  TSCreateSchemaTemplateReq() : sessionId(0), name() {
  }

  virtual ~TSCreateSchemaTemplateReq() noexcept;
  int64_t sessionId;
  std::string name;
  std::vector<std::string>  schemaNames;
  std::vector<std::vector<std::string> >  measurements;
  std::vector<std::vector<int32_t> >  dataTypes;
  std::vector<std::vector<int32_t> >  encodings;
  std::vector<int32_t>  compressors;

  void __set_sessionId(const int64_t val);

  void __set_name(const std::string& val);

  void __set_schemaNames(const std::vector<std::string> & val);

  void __set_measurements(const std::vector<std::vector<std::string> > & val);

  void __set_dataTypes(const std::vector<std::vector<int32_t> > & val);

  void __set_encodings(const std::vector<std::vector<int32_t> > & val);

  void __set_compressors(const std::vector<int32_t> & val);

  bool operator == (const TSCreateSchemaTemplateReq & rhs) const
  {
    if (!(sessionId == rhs.sessionId))
      return false;
    if (!(name == rhs.name))
      return false;
    if (!(schemaNames == rhs.schemaNames))
      return false;
    if (!(measurements == rhs.measurements))
      return false;
    if (!(dataTypes == rhs.dataTypes))
      return false;
    if (!(encodings == rhs.encodings))
      return false;
    if (!(compressors == rhs.compressors))
      return false;
    return true;
  }
  bool operator != (const TSCreateSchemaTemplateReq &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TSCreateSchemaTemplateReq & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

  virtual void printTo(std::ostream& out) const;
};

void swap(TSCreateSchemaTemplateReq &a, TSCreateSchemaTemplateReq &b);

std::ostream& operator<<(std::ostream& out, const TSCreateSchemaTemplateReq& obj);



#endif
