All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.apache.iotdb.mpp.rpc.thrift.TQueryStatistics Maven / Gradle / Ivy

The newest version!
/**
 * Autogenerated by Thrift Compiler (0.14.1)
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 *  @generated
 */
package org.apache.iotdb.mpp.rpc.thrift;

@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.14.1)", date = "2024-09-12")
public class TQueryStatistics implements org.apache.thrift.TBase, java.io.Serializable, Cloneable, Comparable {
  private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TQueryStatistics");

  private static final org.apache.thrift.protocol.TField LOAD_TIME_SERIES_METADATA_DISK_SEQ_COUNT_FIELD_DESC = new org.apache.thrift.protocol.TField("loadTimeSeriesMetadataDiskSeqCount", org.apache.thrift.protocol.TType.I64, (short)1);
  private static final org.apache.thrift.protocol.TField LOAD_TIME_SERIES_METADATA_DISK_UN_SEQ_COUNT_FIELD_DESC = new org.apache.thrift.protocol.TField("loadTimeSeriesMetadataDiskUnSeqCount", org.apache.thrift.protocol.TType.I64, (short)2);
  private static final org.apache.thrift.protocol.TField LOAD_TIME_SERIES_METADATA_MEM_SEQ_COUNT_FIELD_DESC = new org.apache.thrift.protocol.TField("loadTimeSeriesMetadataMemSeqCount", org.apache.thrift.protocol.TType.I64, (short)3);
  private static final org.apache.thrift.protocol.TField LOAD_TIME_SERIES_METADATA_MEM_UN_SEQ_COUNT_FIELD_DESC = new org.apache.thrift.protocol.TField("loadTimeSeriesMetadataMemUnSeqCount", org.apache.thrift.protocol.TType.I64, (short)4);
  private static final org.apache.thrift.protocol.TField LOAD_TIME_SERIES_METADATA_ALIGNED_DISK_SEQ_COUNT_FIELD_DESC = new org.apache.thrift.protocol.TField("loadTimeSeriesMetadataAlignedDiskSeqCount", org.apache.thrift.protocol.TType.I64, (short)5);
  private static final org.apache.thrift.protocol.TField LOAD_TIME_SERIES_METADATA_ALIGNED_DISK_UN_SEQ_COUNT_FIELD_DESC = new org.apache.thrift.protocol.TField("loadTimeSeriesMetadataAlignedDiskUnSeqCount", org.apache.thrift.protocol.TType.I64, (short)6);
  private static final org.apache.thrift.protocol.TField LOAD_TIME_SERIES_METADATA_ALIGNED_MEM_SEQ_COUNT_FIELD_DESC = new org.apache.thrift.protocol.TField("loadTimeSeriesMetadataAlignedMemSeqCount", org.apache.thrift.protocol.TType.I64, (short)7);
  private static final org.apache.thrift.protocol.TField LOAD_TIME_SERIES_METADATA_ALIGNED_MEM_UN_SEQ_COUNT_FIELD_DESC = new org.apache.thrift.protocol.TField("loadTimeSeriesMetadataAlignedMemUnSeqCount", org.apache.thrift.protocol.TType.I64, (short)8);
  private static final org.apache.thrift.protocol.TField LOAD_TIME_SERIES_METADATA_DISK_SEQ_TIME_FIELD_DESC = new org.apache.thrift.protocol.TField("loadTimeSeriesMetadataDiskSeqTime", org.apache.thrift.protocol.TType.I64, (short)9);
  private static final org.apache.thrift.protocol.TField LOAD_TIME_SERIES_METADATA_DISK_UN_SEQ_TIME_FIELD_DESC = new org.apache.thrift.protocol.TField("loadTimeSeriesMetadataDiskUnSeqTime", org.apache.thrift.protocol.TType.I64, (short)10);
  private static final org.apache.thrift.protocol.TField LOAD_TIME_SERIES_METADATA_MEM_SEQ_TIME_FIELD_DESC = new org.apache.thrift.protocol.TField("loadTimeSeriesMetadataMemSeqTime", org.apache.thrift.protocol.TType.I64, (short)11);
  private static final org.apache.thrift.protocol.TField LOAD_TIME_SERIES_METADATA_MEM_UN_SEQ_TIME_FIELD_DESC = new org.apache.thrift.protocol.TField("loadTimeSeriesMetadataMemUnSeqTime", org.apache.thrift.protocol.TType.I64, (short)12);
  private static final org.apache.thrift.protocol.TField LOAD_TIME_SERIES_METADATA_ALIGNED_DISK_SEQ_TIME_FIELD_DESC = new org.apache.thrift.protocol.TField("loadTimeSeriesMetadataAlignedDiskSeqTime", org.apache.thrift.protocol.TType.I64, (short)13);
  private static final org.apache.thrift.protocol.TField LOAD_TIME_SERIES_METADATA_ALIGNED_DISK_UN_SEQ_TIME_FIELD_DESC = new org.apache.thrift.protocol.TField("loadTimeSeriesMetadataAlignedDiskUnSeqTime", org.apache.thrift.protocol.TType.I64, (short)14);
  private static final org.apache.thrift.protocol.TField LOAD_TIME_SERIES_METADATA_ALIGNED_MEM_SEQ_TIME_FIELD_DESC = new org.apache.thrift.protocol.TField("loadTimeSeriesMetadataAlignedMemSeqTime", org.apache.thrift.protocol.TType.I64, (short)15);
  private static final org.apache.thrift.protocol.TField LOAD_TIME_SERIES_METADATA_ALIGNED_MEM_UN_SEQ_TIME_FIELD_DESC = new org.apache.thrift.protocol.TField("loadTimeSeriesMetadataAlignedMemUnSeqTime", org.apache.thrift.protocol.TType.I64, (short)16);
  private static final org.apache.thrift.protocol.TField CONSTRUCT_NON_ALIGNED_CHUNK_READERS_DISK_COUNT_FIELD_DESC = new org.apache.thrift.protocol.TField("constructNonAlignedChunkReadersDiskCount", org.apache.thrift.protocol.TType.I64, (short)17);
  private static final org.apache.thrift.protocol.TField CONSTRUCT_NON_ALIGNED_CHUNK_READERS_MEM_COUNT_FIELD_DESC = new org.apache.thrift.protocol.TField("constructNonAlignedChunkReadersMemCount", org.apache.thrift.protocol.TType.I64, (short)18);
  private static final org.apache.thrift.protocol.TField CONSTRUCT_ALIGNED_CHUNK_READERS_DISK_COUNT_FIELD_DESC = new org.apache.thrift.protocol.TField("constructAlignedChunkReadersDiskCount", org.apache.thrift.protocol.TType.I64, (short)19);
  private static final org.apache.thrift.protocol.TField CONSTRUCT_ALIGNED_CHUNK_READERS_MEM_COUNT_FIELD_DESC = new org.apache.thrift.protocol.TField("constructAlignedChunkReadersMemCount", org.apache.thrift.protocol.TType.I64, (short)20);
  private static final org.apache.thrift.protocol.TField CONSTRUCT_NON_ALIGNED_CHUNK_READERS_DISK_TIME_FIELD_DESC = new org.apache.thrift.protocol.TField("constructNonAlignedChunkReadersDiskTime", org.apache.thrift.protocol.TType.I64, (short)21);
  private static final org.apache.thrift.protocol.TField CONSTRUCT_NON_ALIGNED_CHUNK_READERS_MEM_TIME_FIELD_DESC = new org.apache.thrift.protocol.TField("constructNonAlignedChunkReadersMemTime", org.apache.thrift.protocol.TType.I64, (short)22);
  private static final org.apache.thrift.protocol.TField CONSTRUCT_ALIGNED_CHUNK_READERS_DISK_TIME_FIELD_DESC = new org.apache.thrift.protocol.TField("constructAlignedChunkReadersDiskTime", org.apache.thrift.protocol.TType.I64, (short)23);
  private static final org.apache.thrift.protocol.TField CONSTRUCT_ALIGNED_CHUNK_READERS_MEM_TIME_FIELD_DESC = new org.apache.thrift.protocol.TField("constructAlignedChunkReadersMemTime", org.apache.thrift.protocol.TType.I64, (short)24);
  private static final org.apache.thrift.protocol.TField PAGE_READERS_DECODE_ALIGNED_DISK_COUNT_FIELD_DESC = new org.apache.thrift.protocol.TField("pageReadersDecodeAlignedDiskCount", org.apache.thrift.protocol.TType.I64, (short)25);
  private static final org.apache.thrift.protocol.TField PAGE_READERS_DECODE_ALIGNED_DISK_TIME_FIELD_DESC = new org.apache.thrift.protocol.TField("pageReadersDecodeAlignedDiskTime", org.apache.thrift.protocol.TType.I64, (short)26);
  private static final org.apache.thrift.protocol.TField PAGE_READERS_DECODE_ALIGNED_MEM_COUNT_FIELD_DESC = new org.apache.thrift.protocol.TField("pageReadersDecodeAlignedMemCount", org.apache.thrift.protocol.TType.I64, (short)27);
  private static final org.apache.thrift.protocol.TField PAGE_READERS_DECODE_ALIGNED_MEM_TIME_FIELD_DESC = new org.apache.thrift.protocol.TField("pageReadersDecodeAlignedMemTime", org.apache.thrift.protocol.TType.I64, (short)28);
  private static final org.apache.thrift.protocol.TField PAGE_READERS_DECODE_NON_ALIGNED_DISK_COUNT_FIELD_DESC = new org.apache.thrift.protocol.TField("pageReadersDecodeNonAlignedDiskCount", org.apache.thrift.protocol.TType.I64, (short)29);
  private static final org.apache.thrift.protocol.TField PAGE_READERS_DECODE_NON_ALIGNED_DISK_TIME_FIELD_DESC = new org.apache.thrift.protocol.TField("pageReadersDecodeNonAlignedDiskTime", org.apache.thrift.protocol.TType.I64, (short)30);
  private static final org.apache.thrift.protocol.TField PAGE_READERS_DECODE_NON_ALIGNED_MEM_COUNT_FIELD_DESC = new org.apache.thrift.protocol.TField("pageReadersDecodeNonAlignedMemCount", org.apache.thrift.protocol.TType.I64, (short)31);
  private static final org.apache.thrift.protocol.TField PAGE_READERS_DECODE_NON_ALIGNED_MEM_TIME_FIELD_DESC = new org.apache.thrift.protocol.TField("pageReadersDecodeNonAlignedMemTime", org.apache.thrift.protocol.TType.I64, (short)32);
  private static final org.apache.thrift.protocol.TField PAGE_READER_MAX_USED_MEMORY_SIZE_FIELD_DESC = new org.apache.thrift.protocol.TField("pageReaderMaxUsedMemorySize", org.apache.thrift.protocol.TType.I64, (short)33);
  private static final org.apache.thrift.protocol.TField ALIGNED_TIME_SERIES_METADATA_MODIFICATION_COUNT_FIELD_DESC = new org.apache.thrift.protocol.TField("alignedTimeSeriesMetadataModificationCount", org.apache.thrift.protocol.TType.I64, (short)34);
  private static final org.apache.thrift.protocol.TField ALIGNED_TIME_SERIES_METADATA_MODIFICATION_TIME_FIELD_DESC = new org.apache.thrift.protocol.TField("alignedTimeSeriesMetadataModificationTime", org.apache.thrift.protocol.TType.I64, (short)35);
  private static final org.apache.thrift.protocol.TField NON_ALIGNED_TIME_SERIES_METADATA_MODIFICATION_COUNT_FIELD_DESC = new org.apache.thrift.protocol.TField("nonAlignedTimeSeriesMetadataModificationCount", org.apache.thrift.protocol.TType.I64, (short)36);
  private static final org.apache.thrift.protocol.TField NON_ALIGNED_TIME_SERIES_METADATA_MODIFICATION_TIME_FIELD_DESC = new org.apache.thrift.protocol.TField("nonAlignedTimeSeriesMetadataModificationTime", org.apache.thrift.protocol.TType.I64, (short)37);

  private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TQueryStatisticsStandardSchemeFactory();
  private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TQueryStatisticsTupleSchemeFactory();

  public long loadTimeSeriesMetadataDiskSeqCount; // required
  public long loadTimeSeriesMetadataDiskUnSeqCount; // required
  public long loadTimeSeriesMetadataMemSeqCount; // required
  public long loadTimeSeriesMetadataMemUnSeqCount; // required
  public long loadTimeSeriesMetadataAlignedDiskSeqCount; // required
  public long loadTimeSeriesMetadataAlignedDiskUnSeqCount; // required
  public long loadTimeSeriesMetadataAlignedMemSeqCount; // required
  public long loadTimeSeriesMetadataAlignedMemUnSeqCount; // required
  public long loadTimeSeriesMetadataDiskSeqTime; // required
  public long loadTimeSeriesMetadataDiskUnSeqTime; // required
  public long loadTimeSeriesMetadataMemSeqTime; // required
  public long loadTimeSeriesMetadataMemUnSeqTime; // required
  public long loadTimeSeriesMetadataAlignedDiskSeqTime; // required
  public long loadTimeSeriesMetadataAlignedDiskUnSeqTime; // required
  public long loadTimeSeriesMetadataAlignedMemSeqTime; // required
  public long loadTimeSeriesMetadataAlignedMemUnSeqTime; // required
  public long constructNonAlignedChunkReadersDiskCount; // required
  public long constructNonAlignedChunkReadersMemCount; // required
  public long constructAlignedChunkReadersDiskCount; // required
  public long constructAlignedChunkReadersMemCount; // required
  public long constructNonAlignedChunkReadersDiskTime; // required
  public long constructNonAlignedChunkReadersMemTime; // required
  public long constructAlignedChunkReadersDiskTime; // required
  public long constructAlignedChunkReadersMemTime; // required
  public long pageReadersDecodeAlignedDiskCount; // required
  public long pageReadersDecodeAlignedDiskTime; // required
  public long pageReadersDecodeAlignedMemCount; // required
  public long pageReadersDecodeAlignedMemTime; // required
  public long pageReadersDecodeNonAlignedDiskCount; // required
  public long pageReadersDecodeNonAlignedDiskTime; // required
  public long pageReadersDecodeNonAlignedMemCount; // required
  public long pageReadersDecodeNonAlignedMemTime; // required
  public long pageReaderMaxUsedMemorySize; // required
  public long alignedTimeSeriesMetadataModificationCount; // required
  public long alignedTimeSeriesMetadataModificationTime; // required
  public long nonAlignedTimeSeriesMetadataModificationCount; // required
  public long nonAlignedTimeSeriesMetadataModificationTime; // required

  /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
  public enum _Fields implements org.apache.thrift.TFieldIdEnum {
    LOAD_TIME_SERIES_METADATA_DISK_SEQ_COUNT((short)1, "loadTimeSeriesMetadataDiskSeqCount"),
    LOAD_TIME_SERIES_METADATA_DISK_UN_SEQ_COUNT((short)2, "loadTimeSeriesMetadataDiskUnSeqCount"),
    LOAD_TIME_SERIES_METADATA_MEM_SEQ_COUNT((short)3, "loadTimeSeriesMetadataMemSeqCount"),
    LOAD_TIME_SERIES_METADATA_MEM_UN_SEQ_COUNT((short)4, "loadTimeSeriesMetadataMemUnSeqCount"),
    LOAD_TIME_SERIES_METADATA_ALIGNED_DISK_SEQ_COUNT((short)5, "loadTimeSeriesMetadataAlignedDiskSeqCount"),
    LOAD_TIME_SERIES_METADATA_ALIGNED_DISK_UN_SEQ_COUNT((short)6, "loadTimeSeriesMetadataAlignedDiskUnSeqCount"),
    LOAD_TIME_SERIES_METADATA_ALIGNED_MEM_SEQ_COUNT((short)7, "loadTimeSeriesMetadataAlignedMemSeqCount"),
    LOAD_TIME_SERIES_METADATA_ALIGNED_MEM_UN_SEQ_COUNT((short)8, "loadTimeSeriesMetadataAlignedMemUnSeqCount"),
    LOAD_TIME_SERIES_METADATA_DISK_SEQ_TIME((short)9, "loadTimeSeriesMetadataDiskSeqTime"),
    LOAD_TIME_SERIES_METADATA_DISK_UN_SEQ_TIME((short)10, "loadTimeSeriesMetadataDiskUnSeqTime"),
    LOAD_TIME_SERIES_METADATA_MEM_SEQ_TIME((short)11, "loadTimeSeriesMetadataMemSeqTime"),
    LOAD_TIME_SERIES_METADATA_MEM_UN_SEQ_TIME((short)12, "loadTimeSeriesMetadataMemUnSeqTime"),
    LOAD_TIME_SERIES_METADATA_ALIGNED_DISK_SEQ_TIME((short)13, "loadTimeSeriesMetadataAlignedDiskSeqTime"),
    LOAD_TIME_SERIES_METADATA_ALIGNED_DISK_UN_SEQ_TIME((short)14, "loadTimeSeriesMetadataAlignedDiskUnSeqTime"),
    LOAD_TIME_SERIES_METADATA_ALIGNED_MEM_SEQ_TIME((short)15, "loadTimeSeriesMetadataAlignedMemSeqTime"),
    LOAD_TIME_SERIES_METADATA_ALIGNED_MEM_UN_SEQ_TIME((short)16, "loadTimeSeriesMetadataAlignedMemUnSeqTime"),
    CONSTRUCT_NON_ALIGNED_CHUNK_READERS_DISK_COUNT((short)17, "constructNonAlignedChunkReadersDiskCount"),
    CONSTRUCT_NON_ALIGNED_CHUNK_READERS_MEM_COUNT((short)18, "constructNonAlignedChunkReadersMemCount"),
    CONSTRUCT_ALIGNED_CHUNK_READERS_DISK_COUNT((short)19, "constructAlignedChunkReadersDiskCount"),
    CONSTRUCT_ALIGNED_CHUNK_READERS_MEM_COUNT((short)20, "constructAlignedChunkReadersMemCount"),
    CONSTRUCT_NON_ALIGNED_CHUNK_READERS_DISK_TIME((short)21, "constructNonAlignedChunkReadersDiskTime"),
    CONSTRUCT_NON_ALIGNED_CHUNK_READERS_MEM_TIME((short)22, "constructNonAlignedChunkReadersMemTime"),
    CONSTRUCT_ALIGNED_CHUNK_READERS_DISK_TIME((short)23, "constructAlignedChunkReadersDiskTime"),
    CONSTRUCT_ALIGNED_CHUNK_READERS_MEM_TIME((short)24, "constructAlignedChunkReadersMemTime"),
    PAGE_READERS_DECODE_ALIGNED_DISK_COUNT((short)25, "pageReadersDecodeAlignedDiskCount"),
    PAGE_READERS_DECODE_ALIGNED_DISK_TIME((short)26, "pageReadersDecodeAlignedDiskTime"),
    PAGE_READERS_DECODE_ALIGNED_MEM_COUNT((short)27, "pageReadersDecodeAlignedMemCount"),
    PAGE_READERS_DECODE_ALIGNED_MEM_TIME((short)28, "pageReadersDecodeAlignedMemTime"),
    PAGE_READERS_DECODE_NON_ALIGNED_DISK_COUNT((short)29, "pageReadersDecodeNonAlignedDiskCount"),
    PAGE_READERS_DECODE_NON_ALIGNED_DISK_TIME((short)30, "pageReadersDecodeNonAlignedDiskTime"),
    PAGE_READERS_DECODE_NON_ALIGNED_MEM_COUNT((short)31, "pageReadersDecodeNonAlignedMemCount"),
    PAGE_READERS_DECODE_NON_ALIGNED_MEM_TIME((short)32, "pageReadersDecodeNonAlignedMemTime"),
    PAGE_READER_MAX_USED_MEMORY_SIZE((short)33, "pageReaderMaxUsedMemorySize"),
    ALIGNED_TIME_SERIES_METADATA_MODIFICATION_COUNT((short)34, "alignedTimeSeriesMetadataModificationCount"),
    ALIGNED_TIME_SERIES_METADATA_MODIFICATION_TIME((short)35, "alignedTimeSeriesMetadataModificationTime"),
    NON_ALIGNED_TIME_SERIES_METADATA_MODIFICATION_COUNT((short)36, "nonAlignedTimeSeriesMetadataModificationCount"),
    NON_ALIGNED_TIME_SERIES_METADATA_MODIFICATION_TIME((short)37, "nonAlignedTimeSeriesMetadataModificationTime");

    private static final java.util.Map byName = new java.util.HashMap();

    static {
      for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
        byName.put(field.getFieldName(), field);
      }
    }

    /**
     * Find the _Fields constant that matches fieldId, or null if its not found.
     */
    @org.apache.thrift.annotation.Nullable
    public static _Fields findByThriftId(int fieldId) {
      switch(fieldId) {
        case 1: // LOAD_TIME_SERIES_METADATA_DISK_SEQ_COUNT
          return LOAD_TIME_SERIES_METADATA_DISK_SEQ_COUNT;
        case 2: // LOAD_TIME_SERIES_METADATA_DISK_UN_SEQ_COUNT
          return LOAD_TIME_SERIES_METADATA_DISK_UN_SEQ_COUNT;
        case 3: // LOAD_TIME_SERIES_METADATA_MEM_SEQ_COUNT
          return LOAD_TIME_SERIES_METADATA_MEM_SEQ_COUNT;
        case 4: // LOAD_TIME_SERIES_METADATA_MEM_UN_SEQ_COUNT
          return LOAD_TIME_SERIES_METADATA_MEM_UN_SEQ_COUNT;
        case 5: // LOAD_TIME_SERIES_METADATA_ALIGNED_DISK_SEQ_COUNT
          return LOAD_TIME_SERIES_METADATA_ALIGNED_DISK_SEQ_COUNT;
        case 6: // LOAD_TIME_SERIES_METADATA_ALIGNED_DISK_UN_SEQ_COUNT
          return LOAD_TIME_SERIES_METADATA_ALIGNED_DISK_UN_SEQ_COUNT;
        case 7: // LOAD_TIME_SERIES_METADATA_ALIGNED_MEM_SEQ_COUNT
          return LOAD_TIME_SERIES_METADATA_ALIGNED_MEM_SEQ_COUNT;
        case 8: // LOAD_TIME_SERIES_METADATA_ALIGNED_MEM_UN_SEQ_COUNT
          return LOAD_TIME_SERIES_METADATA_ALIGNED_MEM_UN_SEQ_COUNT;
        case 9: // LOAD_TIME_SERIES_METADATA_DISK_SEQ_TIME
          return LOAD_TIME_SERIES_METADATA_DISK_SEQ_TIME;
        case 10: // LOAD_TIME_SERIES_METADATA_DISK_UN_SEQ_TIME
          return LOAD_TIME_SERIES_METADATA_DISK_UN_SEQ_TIME;
        case 11: // LOAD_TIME_SERIES_METADATA_MEM_SEQ_TIME
          return LOAD_TIME_SERIES_METADATA_MEM_SEQ_TIME;
        case 12: // LOAD_TIME_SERIES_METADATA_MEM_UN_SEQ_TIME
          return LOAD_TIME_SERIES_METADATA_MEM_UN_SEQ_TIME;
        case 13: // LOAD_TIME_SERIES_METADATA_ALIGNED_DISK_SEQ_TIME
          return LOAD_TIME_SERIES_METADATA_ALIGNED_DISK_SEQ_TIME;
        case 14: // LOAD_TIME_SERIES_METADATA_ALIGNED_DISK_UN_SEQ_TIME
          return LOAD_TIME_SERIES_METADATA_ALIGNED_DISK_UN_SEQ_TIME;
        case 15: // LOAD_TIME_SERIES_METADATA_ALIGNED_MEM_SEQ_TIME
          return LOAD_TIME_SERIES_METADATA_ALIGNED_MEM_SEQ_TIME;
        case 16: // LOAD_TIME_SERIES_METADATA_ALIGNED_MEM_UN_SEQ_TIME
          return LOAD_TIME_SERIES_METADATA_ALIGNED_MEM_UN_SEQ_TIME;
        case 17: // CONSTRUCT_NON_ALIGNED_CHUNK_READERS_DISK_COUNT
          return CONSTRUCT_NON_ALIGNED_CHUNK_READERS_DISK_COUNT;
        case 18: // CONSTRUCT_NON_ALIGNED_CHUNK_READERS_MEM_COUNT
          return CONSTRUCT_NON_ALIGNED_CHUNK_READERS_MEM_COUNT;
        case 19: // CONSTRUCT_ALIGNED_CHUNK_READERS_DISK_COUNT
          return CONSTRUCT_ALIGNED_CHUNK_READERS_DISK_COUNT;
        case 20: // CONSTRUCT_ALIGNED_CHUNK_READERS_MEM_COUNT
          return CONSTRUCT_ALIGNED_CHUNK_READERS_MEM_COUNT;
        case 21: // CONSTRUCT_NON_ALIGNED_CHUNK_READERS_DISK_TIME
          return CONSTRUCT_NON_ALIGNED_CHUNK_READERS_DISK_TIME;
        case 22: // CONSTRUCT_NON_ALIGNED_CHUNK_READERS_MEM_TIME
          return CONSTRUCT_NON_ALIGNED_CHUNK_READERS_MEM_TIME;
        case 23: // CONSTRUCT_ALIGNED_CHUNK_READERS_DISK_TIME
          return CONSTRUCT_ALIGNED_CHUNK_READERS_DISK_TIME;
        case 24: // CONSTRUCT_ALIGNED_CHUNK_READERS_MEM_TIME
          return CONSTRUCT_ALIGNED_CHUNK_READERS_MEM_TIME;
        case 25: // PAGE_READERS_DECODE_ALIGNED_DISK_COUNT
          return PAGE_READERS_DECODE_ALIGNED_DISK_COUNT;
        case 26: // PAGE_READERS_DECODE_ALIGNED_DISK_TIME
          return PAGE_READERS_DECODE_ALIGNED_DISK_TIME;
        case 27: // PAGE_READERS_DECODE_ALIGNED_MEM_COUNT
          return PAGE_READERS_DECODE_ALIGNED_MEM_COUNT;
        case 28: // PAGE_READERS_DECODE_ALIGNED_MEM_TIME
          return PAGE_READERS_DECODE_ALIGNED_MEM_TIME;
        case 29: // PAGE_READERS_DECODE_NON_ALIGNED_DISK_COUNT
          return PAGE_READERS_DECODE_NON_ALIGNED_DISK_COUNT;
        case 30: // PAGE_READERS_DECODE_NON_ALIGNED_DISK_TIME
          return PAGE_READERS_DECODE_NON_ALIGNED_DISK_TIME;
        case 31: // PAGE_READERS_DECODE_NON_ALIGNED_MEM_COUNT
          return PAGE_READERS_DECODE_NON_ALIGNED_MEM_COUNT;
        case 32: // PAGE_READERS_DECODE_NON_ALIGNED_MEM_TIME
          return PAGE_READERS_DECODE_NON_ALIGNED_MEM_TIME;
        case 33: // PAGE_READER_MAX_USED_MEMORY_SIZE
          return PAGE_READER_MAX_USED_MEMORY_SIZE;
        case 34: // ALIGNED_TIME_SERIES_METADATA_MODIFICATION_COUNT
          return ALIGNED_TIME_SERIES_METADATA_MODIFICATION_COUNT;
        case 35: // ALIGNED_TIME_SERIES_METADATA_MODIFICATION_TIME
          return ALIGNED_TIME_SERIES_METADATA_MODIFICATION_TIME;
        case 36: // NON_ALIGNED_TIME_SERIES_METADATA_MODIFICATION_COUNT
          return NON_ALIGNED_TIME_SERIES_METADATA_MODIFICATION_COUNT;
        case 37: // NON_ALIGNED_TIME_SERIES_METADATA_MODIFICATION_TIME
          return NON_ALIGNED_TIME_SERIES_METADATA_MODIFICATION_TIME;
        default:
          return null;
      }
    }

    /**
     * Find the _Fields constant that matches fieldId, throwing an exception
     * if it is not found.
     */
    public static _Fields findByThriftIdOrThrow(int fieldId) {
      _Fields fields = findByThriftId(fieldId);
      if (fields == null) throw new java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
      return fields;
    }

    /**
     * Find the _Fields constant that matches name, or null if its not found.
     */
    @org.apache.thrift.annotation.Nullable
    public static _Fields findByName(java.lang.String name) {
      return byName.get(name);
    }

    private final short _thriftId;
    private final java.lang.String _fieldName;

    _Fields(short thriftId, java.lang.String fieldName) {
      _thriftId = thriftId;
      _fieldName = fieldName;
    }

    public short getThriftFieldId() {
      return _thriftId;
    }

    public java.lang.String getFieldName() {
      return _fieldName;
    }
  }

  // isset id assignments
  private static final int __LOADTIMESERIESMETADATADISKSEQCOUNT_ISSET_ID = 0;
  private static final int __LOADTIMESERIESMETADATADISKUNSEQCOUNT_ISSET_ID = 1;
  private static final int __LOADTIMESERIESMETADATAMEMSEQCOUNT_ISSET_ID = 2;
  private static final int __LOADTIMESERIESMETADATAMEMUNSEQCOUNT_ISSET_ID = 3;
  private static final int __LOADTIMESERIESMETADATAALIGNEDDISKSEQCOUNT_ISSET_ID = 4;
  private static final int __LOADTIMESERIESMETADATAALIGNEDDISKUNSEQCOUNT_ISSET_ID = 5;
  private static final int __LOADTIMESERIESMETADATAALIGNEDMEMSEQCOUNT_ISSET_ID = 6;
  private static final int __LOADTIMESERIESMETADATAALIGNEDMEMUNSEQCOUNT_ISSET_ID = 7;
  private static final int __LOADTIMESERIESMETADATADISKSEQTIME_ISSET_ID = 8;
  private static final int __LOADTIMESERIESMETADATADISKUNSEQTIME_ISSET_ID = 9;
  private static final int __LOADTIMESERIESMETADATAMEMSEQTIME_ISSET_ID = 10;
  private static final int __LOADTIMESERIESMETADATAMEMUNSEQTIME_ISSET_ID = 11;
  private static final int __LOADTIMESERIESMETADATAALIGNEDDISKSEQTIME_ISSET_ID = 12;
  private static final int __LOADTIMESERIESMETADATAALIGNEDDISKUNSEQTIME_ISSET_ID = 13;
  private static final int __LOADTIMESERIESMETADATAALIGNEDMEMSEQTIME_ISSET_ID = 14;
  private static final int __LOADTIMESERIESMETADATAALIGNEDMEMUNSEQTIME_ISSET_ID = 15;
  private static final int __CONSTRUCTNONALIGNEDCHUNKREADERSDISKCOUNT_ISSET_ID = 16;
  private static final int __CONSTRUCTNONALIGNEDCHUNKREADERSMEMCOUNT_ISSET_ID = 17;
  private static final int __CONSTRUCTALIGNEDCHUNKREADERSDISKCOUNT_ISSET_ID = 18;
  private static final int __CONSTRUCTALIGNEDCHUNKREADERSMEMCOUNT_ISSET_ID = 19;
  private static final int __CONSTRUCTNONALIGNEDCHUNKREADERSDISKTIME_ISSET_ID = 20;
  private static final int __CONSTRUCTNONALIGNEDCHUNKREADERSMEMTIME_ISSET_ID = 21;
  private static final int __CONSTRUCTALIGNEDCHUNKREADERSDISKTIME_ISSET_ID = 22;
  private static final int __CONSTRUCTALIGNEDCHUNKREADERSMEMTIME_ISSET_ID = 23;
  private static final int __PAGEREADERSDECODEALIGNEDDISKCOUNT_ISSET_ID = 24;
  private static final int __PAGEREADERSDECODEALIGNEDDISKTIME_ISSET_ID = 25;
  private static final int __PAGEREADERSDECODEALIGNEDMEMCOUNT_ISSET_ID = 26;
  private static final int __PAGEREADERSDECODEALIGNEDMEMTIME_ISSET_ID = 27;
  private static final int __PAGEREADERSDECODENONALIGNEDDISKCOUNT_ISSET_ID = 28;
  private static final int __PAGEREADERSDECODENONALIGNEDDISKTIME_ISSET_ID = 29;
  private static final int __PAGEREADERSDECODENONALIGNEDMEMCOUNT_ISSET_ID = 30;
  private static final int __PAGEREADERSDECODENONALIGNEDMEMTIME_ISSET_ID = 31;
  private static final int __PAGEREADERMAXUSEDMEMORYSIZE_ISSET_ID = 32;
  private static final int __ALIGNEDTIMESERIESMETADATAMODIFICATIONCOUNT_ISSET_ID = 33;
  private static final int __ALIGNEDTIMESERIESMETADATAMODIFICATIONTIME_ISSET_ID = 34;
  private static final int __NONALIGNEDTIMESERIESMETADATAMODIFICATIONCOUNT_ISSET_ID = 35;
  private static final int __NONALIGNEDTIMESERIESMETADATAMODIFICATIONTIME_ISSET_ID = 36;
  private long __isset_bitfield = 0;
  public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
  static {
    java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
    tmpMap.put(_Fields.LOAD_TIME_SERIES_METADATA_DISK_SEQ_COUNT, new org.apache.thrift.meta_data.FieldMetaData("loadTimeSeriesMetadataDiskSeqCount", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
    tmpMap.put(_Fields.LOAD_TIME_SERIES_METADATA_DISK_UN_SEQ_COUNT, new org.apache.thrift.meta_data.FieldMetaData("loadTimeSeriesMetadataDiskUnSeqCount", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
    tmpMap.put(_Fields.LOAD_TIME_SERIES_METADATA_MEM_SEQ_COUNT, new org.apache.thrift.meta_data.FieldMetaData("loadTimeSeriesMetadataMemSeqCount", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
    tmpMap.put(_Fields.LOAD_TIME_SERIES_METADATA_MEM_UN_SEQ_COUNT, new org.apache.thrift.meta_data.FieldMetaData("loadTimeSeriesMetadataMemUnSeqCount", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
    tmpMap.put(_Fields.LOAD_TIME_SERIES_METADATA_ALIGNED_DISK_SEQ_COUNT, new org.apache.thrift.meta_data.FieldMetaData("loadTimeSeriesMetadataAlignedDiskSeqCount", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
    tmpMap.put(_Fields.LOAD_TIME_SERIES_METADATA_ALIGNED_DISK_UN_SEQ_COUNT, new org.apache.thrift.meta_data.FieldMetaData("loadTimeSeriesMetadataAlignedDiskUnSeqCount", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
    tmpMap.put(_Fields.LOAD_TIME_SERIES_METADATA_ALIGNED_MEM_SEQ_COUNT, new org.apache.thrift.meta_data.FieldMetaData("loadTimeSeriesMetadataAlignedMemSeqCount", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
    tmpMap.put(_Fields.LOAD_TIME_SERIES_METADATA_ALIGNED_MEM_UN_SEQ_COUNT, new org.apache.thrift.meta_data.FieldMetaData("loadTimeSeriesMetadataAlignedMemUnSeqCount", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
    tmpMap.put(_Fields.LOAD_TIME_SERIES_METADATA_DISK_SEQ_TIME, new org.apache.thrift.meta_data.FieldMetaData("loadTimeSeriesMetadataDiskSeqTime", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
    tmpMap.put(_Fields.LOAD_TIME_SERIES_METADATA_DISK_UN_SEQ_TIME, new org.apache.thrift.meta_data.FieldMetaData("loadTimeSeriesMetadataDiskUnSeqTime", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
    tmpMap.put(_Fields.LOAD_TIME_SERIES_METADATA_MEM_SEQ_TIME, new org.apache.thrift.meta_data.FieldMetaData("loadTimeSeriesMetadataMemSeqTime", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
    tmpMap.put(_Fields.LOAD_TIME_SERIES_METADATA_MEM_UN_SEQ_TIME, new org.apache.thrift.meta_data.FieldMetaData("loadTimeSeriesMetadataMemUnSeqTime", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
    tmpMap.put(_Fields.LOAD_TIME_SERIES_METADATA_ALIGNED_DISK_SEQ_TIME, new org.apache.thrift.meta_data.FieldMetaData("loadTimeSeriesMetadataAlignedDiskSeqTime", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
    tmpMap.put(_Fields.LOAD_TIME_SERIES_METADATA_ALIGNED_DISK_UN_SEQ_TIME, new org.apache.thrift.meta_data.FieldMetaData("loadTimeSeriesMetadataAlignedDiskUnSeqTime", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
    tmpMap.put(_Fields.LOAD_TIME_SERIES_METADATA_ALIGNED_MEM_SEQ_TIME, new org.apache.thrift.meta_data.FieldMetaData("loadTimeSeriesMetadataAlignedMemSeqTime", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
    tmpMap.put(_Fields.LOAD_TIME_SERIES_METADATA_ALIGNED_MEM_UN_SEQ_TIME, new org.apache.thrift.meta_data.FieldMetaData("loadTimeSeriesMetadataAlignedMemUnSeqTime", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
    tmpMap.put(_Fields.CONSTRUCT_NON_ALIGNED_CHUNK_READERS_DISK_COUNT, new org.apache.thrift.meta_data.FieldMetaData("constructNonAlignedChunkReadersDiskCount", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
    tmpMap.put(_Fields.CONSTRUCT_NON_ALIGNED_CHUNK_READERS_MEM_COUNT, new org.apache.thrift.meta_data.FieldMetaData("constructNonAlignedChunkReadersMemCount", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
    tmpMap.put(_Fields.CONSTRUCT_ALIGNED_CHUNK_READERS_DISK_COUNT, new org.apache.thrift.meta_data.FieldMetaData("constructAlignedChunkReadersDiskCount", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
    tmpMap.put(_Fields.CONSTRUCT_ALIGNED_CHUNK_READERS_MEM_COUNT, new org.apache.thrift.meta_data.FieldMetaData("constructAlignedChunkReadersMemCount", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
    tmpMap.put(_Fields.CONSTRUCT_NON_ALIGNED_CHUNK_READERS_DISK_TIME, new org.apache.thrift.meta_data.FieldMetaData("constructNonAlignedChunkReadersDiskTime", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
    tmpMap.put(_Fields.CONSTRUCT_NON_ALIGNED_CHUNK_READERS_MEM_TIME, new org.apache.thrift.meta_data.FieldMetaData("constructNonAlignedChunkReadersMemTime", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
    tmpMap.put(_Fields.CONSTRUCT_ALIGNED_CHUNK_READERS_DISK_TIME, new org.apache.thrift.meta_data.FieldMetaData("constructAlignedChunkReadersDiskTime", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
    tmpMap.put(_Fields.CONSTRUCT_ALIGNED_CHUNK_READERS_MEM_TIME, new org.apache.thrift.meta_data.FieldMetaData("constructAlignedChunkReadersMemTime", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
    tmpMap.put(_Fields.PAGE_READERS_DECODE_ALIGNED_DISK_COUNT, new org.apache.thrift.meta_data.FieldMetaData("pageReadersDecodeAlignedDiskCount", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
    tmpMap.put(_Fields.PAGE_READERS_DECODE_ALIGNED_DISK_TIME, new org.apache.thrift.meta_data.FieldMetaData("pageReadersDecodeAlignedDiskTime", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
    tmpMap.put(_Fields.PAGE_READERS_DECODE_ALIGNED_MEM_COUNT, new org.apache.thrift.meta_data.FieldMetaData("pageReadersDecodeAlignedMemCount", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
    tmpMap.put(_Fields.PAGE_READERS_DECODE_ALIGNED_MEM_TIME, new org.apache.thrift.meta_data.FieldMetaData("pageReadersDecodeAlignedMemTime", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
    tmpMap.put(_Fields.PAGE_READERS_DECODE_NON_ALIGNED_DISK_COUNT, new org.apache.thrift.meta_data.FieldMetaData("pageReadersDecodeNonAlignedDiskCount", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
    tmpMap.put(_Fields.PAGE_READERS_DECODE_NON_ALIGNED_DISK_TIME, new org.apache.thrift.meta_data.FieldMetaData("pageReadersDecodeNonAlignedDiskTime", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
    tmpMap.put(_Fields.PAGE_READERS_DECODE_NON_ALIGNED_MEM_COUNT, new org.apache.thrift.meta_data.FieldMetaData("pageReadersDecodeNonAlignedMemCount", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
    tmpMap.put(_Fields.PAGE_READERS_DECODE_NON_ALIGNED_MEM_TIME, new org.apache.thrift.meta_data.FieldMetaData("pageReadersDecodeNonAlignedMemTime", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
    tmpMap.put(_Fields.PAGE_READER_MAX_USED_MEMORY_SIZE, new org.apache.thrift.meta_data.FieldMetaData("pageReaderMaxUsedMemorySize", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
    tmpMap.put(_Fields.ALIGNED_TIME_SERIES_METADATA_MODIFICATION_COUNT, new org.apache.thrift.meta_data.FieldMetaData("alignedTimeSeriesMetadataModificationCount", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
    tmpMap.put(_Fields.ALIGNED_TIME_SERIES_METADATA_MODIFICATION_TIME, new org.apache.thrift.meta_data.FieldMetaData("alignedTimeSeriesMetadataModificationTime", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
    tmpMap.put(_Fields.NON_ALIGNED_TIME_SERIES_METADATA_MODIFICATION_COUNT, new org.apache.thrift.meta_data.FieldMetaData("nonAlignedTimeSeriesMetadataModificationCount", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
    tmpMap.put(_Fields.NON_ALIGNED_TIME_SERIES_METADATA_MODIFICATION_TIME, new org.apache.thrift.meta_data.FieldMetaData("nonAlignedTimeSeriesMetadataModificationTime", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
    metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
    org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TQueryStatistics.class, metaDataMap);
  }

  public TQueryStatistics() {
  }

  public TQueryStatistics(
    long loadTimeSeriesMetadataDiskSeqCount,
    long loadTimeSeriesMetadataDiskUnSeqCount,
    long loadTimeSeriesMetadataMemSeqCount,
    long loadTimeSeriesMetadataMemUnSeqCount,
    long loadTimeSeriesMetadataAlignedDiskSeqCount,
    long loadTimeSeriesMetadataAlignedDiskUnSeqCount,
    long loadTimeSeriesMetadataAlignedMemSeqCount,
    long loadTimeSeriesMetadataAlignedMemUnSeqCount,
    long loadTimeSeriesMetadataDiskSeqTime,
    long loadTimeSeriesMetadataDiskUnSeqTime,
    long loadTimeSeriesMetadataMemSeqTime,
    long loadTimeSeriesMetadataMemUnSeqTime,
    long loadTimeSeriesMetadataAlignedDiskSeqTime,
    long loadTimeSeriesMetadataAlignedDiskUnSeqTime,
    long loadTimeSeriesMetadataAlignedMemSeqTime,
    long loadTimeSeriesMetadataAlignedMemUnSeqTime,
    long constructNonAlignedChunkReadersDiskCount,
    long constructNonAlignedChunkReadersMemCount,
    long constructAlignedChunkReadersDiskCount,
    long constructAlignedChunkReadersMemCount,
    long constructNonAlignedChunkReadersDiskTime,
    long constructNonAlignedChunkReadersMemTime,
    long constructAlignedChunkReadersDiskTime,
    long constructAlignedChunkReadersMemTime,
    long pageReadersDecodeAlignedDiskCount,
    long pageReadersDecodeAlignedDiskTime,
    long pageReadersDecodeAlignedMemCount,
    long pageReadersDecodeAlignedMemTime,
    long pageReadersDecodeNonAlignedDiskCount,
    long pageReadersDecodeNonAlignedDiskTime,
    long pageReadersDecodeNonAlignedMemCount,
    long pageReadersDecodeNonAlignedMemTime,
    long pageReaderMaxUsedMemorySize,
    long alignedTimeSeriesMetadataModificationCount,
    long alignedTimeSeriesMetadataModificationTime,
    long nonAlignedTimeSeriesMetadataModificationCount,
    long nonAlignedTimeSeriesMetadataModificationTime)
  {
    this();
    this.loadTimeSeriesMetadataDiskSeqCount = loadTimeSeriesMetadataDiskSeqCount;
    setLoadTimeSeriesMetadataDiskSeqCountIsSet(true);
    this.loadTimeSeriesMetadataDiskUnSeqCount = loadTimeSeriesMetadataDiskUnSeqCount;
    setLoadTimeSeriesMetadataDiskUnSeqCountIsSet(true);
    this.loadTimeSeriesMetadataMemSeqCount = loadTimeSeriesMetadataMemSeqCount;
    setLoadTimeSeriesMetadataMemSeqCountIsSet(true);
    this.loadTimeSeriesMetadataMemUnSeqCount = loadTimeSeriesMetadataMemUnSeqCount;
    setLoadTimeSeriesMetadataMemUnSeqCountIsSet(true);
    this.loadTimeSeriesMetadataAlignedDiskSeqCount = loadTimeSeriesMetadataAlignedDiskSeqCount;
    setLoadTimeSeriesMetadataAlignedDiskSeqCountIsSet(true);
    this.loadTimeSeriesMetadataAlignedDiskUnSeqCount = loadTimeSeriesMetadataAlignedDiskUnSeqCount;
    setLoadTimeSeriesMetadataAlignedDiskUnSeqCountIsSet(true);
    this.loadTimeSeriesMetadataAlignedMemSeqCount = loadTimeSeriesMetadataAlignedMemSeqCount;
    setLoadTimeSeriesMetadataAlignedMemSeqCountIsSet(true);
    this.loadTimeSeriesMetadataAlignedMemUnSeqCount = loadTimeSeriesMetadataAlignedMemUnSeqCount;
    setLoadTimeSeriesMetadataAlignedMemUnSeqCountIsSet(true);
    this.loadTimeSeriesMetadataDiskSeqTime = loadTimeSeriesMetadataDiskSeqTime;
    setLoadTimeSeriesMetadataDiskSeqTimeIsSet(true);
    this.loadTimeSeriesMetadataDiskUnSeqTime = loadTimeSeriesMetadataDiskUnSeqTime;
    setLoadTimeSeriesMetadataDiskUnSeqTimeIsSet(true);
    this.loadTimeSeriesMetadataMemSeqTime = loadTimeSeriesMetadataMemSeqTime;
    setLoadTimeSeriesMetadataMemSeqTimeIsSet(true);
    this.loadTimeSeriesMetadataMemUnSeqTime = loadTimeSeriesMetadataMemUnSeqTime;
    setLoadTimeSeriesMetadataMemUnSeqTimeIsSet(true);
    this.loadTimeSeriesMetadataAlignedDiskSeqTime = loadTimeSeriesMetadataAlignedDiskSeqTime;
    setLoadTimeSeriesMetadataAlignedDiskSeqTimeIsSet(true);
    this.loadTimeSeriesMetadataAlignedDiskUnSeqTime = loadTimeSeriesMetadataAlignedDiskUnSeqTime;
    setLoadTimeSeriesMetadataAlignedDiskUnSeqTimeIsSet(true);
    this.loadTimeSeriesMetadataAlignedMemSeqTime = loadTimeSeriesMetadataAlignedMemSeqTime;
    setLoadTimeSeriesMetadataAlignedMemSeqTimeIsSet(true);
    this.loadTimeSeriesMetadataAlignedMemUnSeqTime = loadTimeSeriesMetadataAlignedMemUnSeqTime;
    setLoadTimeSeriesMetadataAlignedMemUnSeqTimeIsSet(true);
    this.constructNonAlignedChunkReadersDiskCount = constructNonAlignedChunkReadersDiskCount;
    setConstructNonAlignedChunkReadersDiskCountIsSet(true);
    this.constructNonAlignedChunkReadersMemCount = constructNonAlignedChunkReadersMemCount;
    setConstructNonAlignedChunkReadersMemCountIsSet(true);
    this.constructAlignedChunkReadersDiskCount = constructAlignedChunkReadersDiskCount;
    setConstructAlignedChunkReadersDiskCountIsSet(true);
    this.constructAlignedChunkReadersMemCount = constructAlignedChunkReadersMemCount;
    setConstructAlignedChunkReadersMemCountIsSet(true);
    this.constructNonAlignedChunkReadersDiskTime = constructNonAlignedChunkReadersDiskTime;
    setConstructNonAlignedChunkReadersDiskTimeIsSet(true);
    this.constructNonAlignedChunkReadersMemTime = constructNonAlignedChunkReadersMemTime;
    setConstructNonAlignedChunkReadersMemTimeIsSet(true);
    this.constructAlignedChunkReadersDiskTime = constructAlignedChunkReadersDiskTime;
    setConstructAlignedChunkReadersDiskTimeIsSet(true);
    this.constructAlignedChunkReadersMemTime = constructAlignedChunkReadersMemTime;
    setConstructAlignedChunkReadersMemTimeIsSet(true);
    this.pageReadersDecodeAlignedDiskCount = pageReadersDecodeAlignedDiskCount;
    setPageReadersDecodeAlignedDiskCountIsSet(true);
    this.pageReadersDecodeAlignedDiskTime = pageReadersDecodeAlignedDiskTime;
    setPageReadersDecodeAlignedDiskTimeIsSet(true);
    this.pageReadersDecodeAlignedMemCount = pageReadersDecodeAlignedMemCount;
    setPageReadersDecodeAlignedMemCountIsSet(true);
    this.pageReadersDecodeAlignedMemTime = pageReadersDecodeAlignedMemTime;
    setPageReadersDecodeAlignedMemTimeIsSet(true);
    this.pageReadersDecodeNonAlignedDiskCount = pageReadersDecodeNonAlignedDiskCount;
    setPageReadersDecodeNonAlignedDiskCountIsSet(true);
    this.pageReadersDecodeNonAlignedDiskTime = pageReadersDecodeNonAlignedDiskTime;
    setPageReadersDecodeNonAlignedDiskTimeIsSet(true);
    this.pageReadersDecodeNonAlignedMemCount = pageReadersDecodeNonAlignedMemCount;
    setPageReadersDecodeNonAlignedMemCountIsSet(true);
    this.pageReadersDecodeNonAlignedMemTime = pageReadersDecodeNonAlignedMemTime;
    setPageReadersDecodeNonAlignedMemTimeIsSet(true);
    this.pageReaderMaxUsedMemorySize = pageReaderMaxUsedMemorySize;
    setPageReaderMaxUsedMemorySizeIsSet(true);
    this.alignedTimeSeriesMetadataModificationCount = alignedTimeSeriesMetadataModificationCount;
    setAlignedTimeSeriesMetadataModificationCountIsSet(true);
    this.alignedTimeSeriesMetadataModificationTime = alignedTimeSeriesMetadataModificationTime;
    setAlignedTimeSeriesMetadataModificationTimeIsSet(true);
    this.nonAlignedTimeSeriesMetadataModificationCount = nonAlignedTimeSeriesMetadataModificationCount;
    setNonAlignedTimeSeriesMetadataModificationCountIsSet(true);
    this.nonAlignedTimeSeriesMetadataModificationTime = nonAlignedTimeSeriesMetadataModificationTime;
    setNonAlignedTimeSeriesMetadataModificationTimeIsSet(true);
  }

  /**
   * Performs a deep copy on other.
   */
  public TQueryStatistics(TQueryStatistics other) {
    __isset_bitfield = other.__isset_bitfield;
    this.loadTimeSeriesMetadataDiskSeqCount = other.loadTimeSeriesMetadataDiskSeqCount;
    this.loadTimeSeriesMetadataDiskUnSeqCount = other.loadTimeSeriesMetadataDiskUnSeqCount;
    this.loadTimeSeriesMetadataMemSeqCount = other.loadTimeSeriesMetadataMemSeqCount;
    this.loadTimeSeriesMetadataMemUnSeqCount = other.loadTimeSeriesMetadataMemUnSeqCount;
    this.loadTimeSeriesMetadataAlignedDiskSeqCount = other.loadTimeSeriesMetadataAlignedDiskSeqCount;
    this.loadTimeSeriesMetadataAlignedDiskUnSeqCount = other.loadTimeSeriesMetadataAlignedDiskUnSeqCount;
    this.loadTimeSeriesMetadataAlignedMemSeqCount = other.loadTimeSeriesMetadataAlignedMemSeqCount;
    this.loadTimeSeriesMetadataAlignedMemUnSeqCount = other.loadTimeSeriesMetadataAlignedMemUnSeqCount;
    this.loadTimeSeriesMetadataDiskSeqTime = other.loadTimeSeriesMetadataDiskSeqTime;
    this.loadTimeSeriesMetadataDiskUnSeqTime = other.loadTimeSeriesMetadataDiskUnSeqTime;
    this.loadTimeSeriesMetadataMemSeqTime = other.loadTimeSeriesMetadataMemSeqTime;
    this.loadTimeSeriesMetadataMemUnSeqTime = other.loadTimeSeriesMetadataMemUnSeqTime;
    this.loadTimeSeriesMetadataAlignedDiskSeqTime = other.loadTimeSeriesMetadataAlignedDiskSeqTime;
    this.loadTimeSeriesMetadataAlignedDiskUnSeqTime = other.loadTimeSeriesMetadataAlignedDiskUnSeqTime;
    this.loadTimeSeriesMetadataAlignedMemSeqTime = other.loadTimeSeriesMetadataAlignedMemSeqTime;
    this.loadTimeSeriesMetadataAlignedMemUnSeqTime = other.loadTimeSeriesMetadataAlignedMemUnSeqTime;
    this.constructNonAlignedChunkReadersDiskCount = other.constructNonAlignedChunkReadersDiskCount;
    this.constructNonAlignedChunkReadersMemCount = other.constructNonAlignedChunkReadersMemCount;
    this.constructAlignedChunkReadersDiskCount = other.constructAlignedChunkReadersDiskCount;
    this.constructAlignedChunkReadersMemCount = other.constructAlignedChunkReadersMemCount;
    this.constructNonAlignedChunkReadersDiskTime = other.constructNonAlignedChunkReadersDiskTime;
    this.constructNonAlignedChunkReadersMemTime = other.constructNonAlignedChunkReadersMemTime;
    this.constructAlignedChunkReadersDiskTime = other.constructAlignedChunkReadersDiskTime;
    this.constructAlignedChunkReadersMemTime = other.constructAlignedChunkReadersMemTime;
    this.pageReadersDecodeAlignedDiskCount = other.pageReadersDecodeAlignedDiskCount;
    this.pageReadersDecodeAlignedDiskTime = other.pageReadersDecodeAlignedDiskTime;
    this.pageReadersDecodeAlignedMemCount = other.pageReadersDecodeAlignedMemCount;
    this.pageReadersDecodeAlignedMemTime = other.pageReadersDecodeAlignedMemTime;
    this.pageReadersDecodeNonAlignedDiskCount = other.pageReadersDecodeNonAlignedDiskCount;
    this.pageReadersDecodeNonAlignedDiskTime = other.pageReadersDecodeNonAlignedDiskTime;
    this.pageReadersDecodeNonAlignedMemCount = other.pageReadersDecodeNonAlignedMemCount;
    this.pageReadersDecodeNonAlignedMemTime = other.pageReadersDecodeNonAlignedMemTime;
    this.pageReaderMaxUsedMemorySize = other.pageReaderMaxUsedMemorySize;
    this.alignedTimeSeriesMetadataModificationCount = other.alignedTimeSeriesMetadataModificationCount;
    this.alignedTimeSeriesMetadataModificationTime = other.alignedTimeSeriesMetadataModificationTime;
    this.nonAlignedTimeSeriesMetadataModificationCount = other.nonAlignedTimeSeriesMetadataModificationCount;
    this.nonAlignedTimeSeriesMetadataModificationTime = other.nonAlignedTimeSeriesMetadataModificationTime;
  }

  public TQueryStatistics deepCopy() {
    return new TQueryStatistics(this);
  }

  @Override
  public void clear() {
    setLoadTimeSeriesMetadataDiskSeqCountIsSet(false);
    this.loadTimeSeriesMetadataDiskSeqCount = 0;
    setLoadTimeSeriesMetadataDiskUnSeqCountIsSet(false);
    this.loadTimeSeriesMetadataDiskUnSeqCount = 0;
    setLoadTimeSeriesMetadataMemSeqCountIsSet(false);
    this.loadTimeSeriesMetadataMemSeqCount = 0;
    setLoadTimeSeriesMetadataMemUnSeqCountIsSet(false);
    this.loadTimeSeriesMetadataMemUnSeqCount = 0;
    setLoadTimeSeriesMetadataAlignedDiskSeqCountIsSet(false);
    this.loadTimeSeriesMetadataAlignedDiskSeqCount = 0;
    setLoadTimeSeriesMetadataAlignedDiskUnSeqCountIsSet(false);
    this.loadTimeSeriesMetadataAlignedDiskUnSeqCount = 0;
    setLoadTimeSeriesMetadataAlignedMemSeqCountIsSet(false);
    this.loadTimeSeriesMetadataAlignedMemSeqCount = 0;
    setLoadTimeSeriesMetadataAlignedMemUnSeqCountIsSet(false);
    this.loadTimeSeriesMetadataAlignedMemUnSeqCount = 0;
    setLoadTimeSeriesMetadataDiskSeqTimeIsSet(false);
    this.loadTimeSeriesMetadataDiskSeqTime = 0;
    setLoadTimeSeriesMetadataDiskUnSeqTimeIsSet(false);
    this.loadTimeSeriesMetadataDiskUnSeqTime = 0;
    setLoadTimeSeriesMetadataMemSeqTimeIsSet(false);
    this.loadTimeSeriesMetadataMemSeqTime = 0;
    setLoadTimeSeriesMetadataMemUnSeqTimeIsSet(false);
    this.loadTimeSeriesMetadataMemUnSeqTime = 0;
    setLoadTimeSeriesMetadataAlignedDiskSeqTimeIsSet(false);
    this.loadTimeSeriesMetadataAlignedDiskSeqTime = 0;
    setLoadTimeSeriesMetadataAlignedDiskUnSeqTimeIsSet(false);
    this.loadTimeSeriesMetadataAlignedDiskUnSeqTime = 0;
    setLoadTimeSeriesMetadataAlignedMemSeqTimeIsSet(false);
    this.loadTimeSeriesMetadataAlignedMemSeqTime = 0;
    setLoadTimeSeriesMetadataAlignedMemUnSeqTimeIsSet(false);
    this.loadTimeSeriesMetadataAlignedMemUnSeqTime = 0;
    setConstructNonAlignedChunkReadersDiskCountIsSet(false);
    this.constructNonAlignedChunkReadersDiskCount = 0;
    setConstructNonAlignedChunkReadersMemCountIsSet(false);
    this.constructNonAlignedChunkReadersMemCount = 0;
    setConstructAlignedChunkReadersDiskCountIsSet(false);
    this.constructAlignedChunkReadersDiskCount = 0;
    setConstructAlignedChunkReadersMemCountIsSet(false);
    this.constructAlignedChunkReadersMemCount = 0;
    setConstructNonAlignedChunkReadersDiskTimeIsSet(false);
    this.constructNonAlignedChunkReadersDiskTime = 0;
    setConstructNonAlignedChunkReadersMemTimeIsSet(false);
    this.constructNonAlignedChunkReadersMemTime = 0;
    setConstructAlignedChunkReadersDiskTimeIsSet(false);
    this.constructAlignedChunkReadersDiskTime = 0;
    setConstructAlignedChunkReadersMemTimeIsSet(false);
    this.constructAlignedChunkReadersMemTime = 0;
    setPageReadersDecodeAlignedDiskCountIsSet(false);
    this.pageReadersDecodeAlignedDiskCount = 0;
    setPageReadersDecodeAlignedDiskTimeIsSet(false);
    this.pageReadersDecodeAlignedDiskTime = 0;
    setPageReadersDecodeAlignedMemCountIsSet(false);
    this.pageReadersDecodeAlignedMemCount = 0;
    setPageReadersDecodeAlignedMemTimeIsSet(false);
    this.pageReadersDecodeAlignedMemTime = 0;
    setPageReadersDecodeNonAlignedDiskCountIsSet(false);
    this.pageReadersDecodeNonAlignedDiskCount = 0;
    setPageReadersDecodeNonAlignedDiskTimeIsSet(false);
    this.pageReadersDecodeNonAlignedDiskTime = 0;
    setPageReadersDecodeNonAlignedMemCountIsSet(false);
    this.pageReadersDecodeNonAlignedMemCount = 0;
    setPageReadersDecodeNonAlignedMemTimeIsSet(false);
    this.pageReadersDecodeNonAlignedMemTime = 0;
    setPageReaderMaxUsedMemorySizeIsSet(false);
    this.pageReaderMaxUsedMemorySize = 0;
    setAlignedTimeSeriesMetadataModificationCountIsSet(false);
    this.alignedTimeSeriesMetadataModificationCount = 0;
    setAlignedTimeSeriesMetadataModificationTimeIsSet(false);
    this.alignedTimeSeriesMetadataModificationTime = 0;
    setNonAlignedTimeSeriesMetadataModificationCountIsSet(false);
    this.nonAlignedTimeSeriesMetadataModificationCount = 0;
    setNonAlignedTimeSeriesMetadataModificationTimeIsSet(false);
    this.nonAlignedTimeSeriesMetadataModificationTime = 0;
  }

  public long getLoadTimeSeriesMetadataDiskSeqCount() {
    return this.loadTimeSeriesMetadataDiskSeqCount;
  }

  public TQueryStatistics setLoadTimeSeriesMetadataDiskSeqCount(long loadTimeSeriesMetadataDiskSeqCount) {
    this.loadTimeSeriesMetadataDiskSeqCount = loadTimeSeriesMetadataDiskSeqCount;
    setLoadTimeSeriesMetadataDiskSeqCountIsSet(true);
    return this;
  }

  public void unsetLoadTimeSeriesMetadataDiskSeqCount() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __LOADTIMESERIESMETADATADISKSEQCOUNT_ISSET_ID);
  }

  /** Returns true if field loadTimeSeriesMetadataDiskSeqCount is set (has been assigned a value) and false otherwise */
  public boolean isSetLoadTimeSeriesMetadataDiskSeqCount() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __LOADTIMESERIESMETADATADISKSEQCOUNT_ISSET_ID);
  }

  public void setLoadTimeSeriesMetadataDiskSeqCountIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __LOADTIMESERIESMETADATADISKSEQCOUNT_ISSET_ID, value);
  }

  public long getLoadTimeSeriesMetadataDiskUnSeqCount() {
    return this.loadTimeSeriesMetadataDiskUnSeqCount;
  }

  public TQueryStatistics setLoadTimeSeriesMetadataDiskUnSeqCount(long loadTimeSeriesMetadataDiskUnSeqCount) {
    this.loadTimeSeriesMetadataDiskUnSeqCount = loadTimeSeriesMetadataDiskUnSeqCount;
    setLoadTimeSeriesMetadataDiskUnSeqCountIsSet(true);
    return this;
  }

  public void unsetLoadTimeSeriesMetadataDiskUnSeqCount() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __LOADTIMESERIESMETADATADISKUNSEQCOUNT_ISSET_ID);
  }

  /** Returns true if field loadTimeSeriesMetadataDiskUnSeqCount is set (has been assigned a value) and false otherwise */
  public boolean isSetLoadTimeSeriesMetadataDiskUnSeqCount() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __LOADTIMESERIESMETADATADISKUNSEQCOUNT_ISSET_ID);
  }

  public void setLoadTimeSeriesMetadataDiskUnSeqCountIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __LOADTIMESERIESMETADATADISKUNSEQCOUNT_ISSET_ID, value);
  }

  public long getLoadTimeSeriesMetadataMemSeqCount() {
    return this.loadTimeSeriesMetadataMemSeqCount;
  }

  public TQueryStatistics setLoadTimeSeriesMetadataMemSeqCount(long loadTimeSeriesMetadataMemSeqCount) {
    this.loadTimeSeriesMetadataMemSeqCount = loadTimeSeriesMetadataMemSeqCount;
    setLoadTimeSeriesMetadataMemSeqCountIsSet(true);
    return this;
  }

  public void unsetLoadTimeSeriesMetadataMemSeqCount() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __LOADTIMESERIESMETADATAMEMSEQCOUNT_ISSET_ID);
  }

  /** Returns true if field loadTimeSeriesMetadataMemSeqCount is set (has been assigned a value) and false otherwise */
  public boolean isSetLoadTimeSeriesMetadataMemSeqCount() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __LOADTIMESERIESMETADATAMEMSEQCOUNT_ISSET_ID);
  }

  public void setLoadTimeSeriesMetadataMemSeqCountIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __LOADTIMESERIESMETADATAMEMSEQCOUNT_ISSET_ID, value);
  }

  public long getLoadTimeSeriesMetadataMemUnSeqCount() {
    return this.loadTimeSeriesMetadataMemUnSeqCount;
  }

  public TQueryStatistics setLoadTimeSeriesMetadataMemUnSeqCount(long loadTimeSeriesMetadataMemUnSeqCount) {
    this.loadTimeSeriesMetadataMemUnSeqCount = loadTimeSeriesMetadataMemUnSeqCount;
    setLoadTimeSeriesMetadataMemUnSeqCountIsSet(true);
    return this;
  }

  public void unsetLoadTimeSeriesMetadataMemUnSeqCount() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __LOADTIMESERIESMETADATAMEMUNSEQCOUNT_ISSET_ID);
  }

  /** Returns true if field loadTimeSeriesMetadataMemUnSeqCount is set (has been assigned a value) and false otherwise */
  public boolean isSetLoadTimeSeriesMetadataMemUnSeqCount() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __LOADTIMESERIESMETADATAMEMUNSEQCOUNT_ISSET_ID);
  }

  public void setLoadTimeSeriesMetadataMemUnSeqCountIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __LOADTIMESERIESMETADATAMEMUNSEQCOUNT_ISSET_ID, value);
  }

  public long getLoadTimeSeriesMetadataAlignedDiskSeqCount() {
    return this.loadTimeSeriesMetadataAlignedDiskSeqCount;
  }

  public TQueryStatistics setLoadTimeSeriesMetadataAlignedDiskSeqCount(long loadTimeSeriesMetadataAlignedDiskSeqCount) {
    this.loadTimeSeriesMetadataAlignedDiskSeqCount = loadTimeSeriesMetadataAlignedDiskSeqCount;
    setLoadTimeSeriesMetadataAlignedDiskSeqCountIsSet(true);
    return this;
  }

  public void unsetLoadTimeSeriesMetadataAlignedDiskSeqCount() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __LOADTIMESERIESMETADATAALIGNEDDISKSEQCOUNT_ISSET_ID);
  }

  /** Returns true if field loadTimeSeriesMetadataAlignedDiskSeqCount is set (has been assigned a value) and false otherwise */
  public boolean isSetLoadTimeSeriesMetadataAlignedDiskSeqCount() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __LOADTIMESERIESMETADATAALIGNEDDISKSEQCOUNT_ISSET_ID);
  }

  public void setLoadTimeSeriesMetadataAlignedDiskSeqCountIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __LOADTIMESERIESMETADATAALIGNEDDISKSEQCOUNT_ISSET_ID, value);
  }

  public long getLoadTimeSeriesMetadataAlignedDiskUnSeqCount() {
    return this.loadTimeSeriesMetadataAlignedDiskUnSeqCount;
  }

  public TQueryStatistics setLoadTimeSeriesMetadataAlignedDiskUnSeqCount(long loadTimeSeriesMetadataAlignedDiskUnSeqCount) {
    this.loadTimeSeriesMetadataAlignedDiskUnSeqCount = loadTimeSeriesMetadataAlignedDiskUnSeqCount;
    setLoadTimeSeriesMetadataAlignedDiskUnSeqCountIsSet(true);
    return this;
  }

  public void unsetLoadTimeSeriesMetadataAlignedDiskUnSeqCount() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __LOADTIMESERIESMETADATAALIGNEDDISKUNSEQCOUNT_ISSET_ID);
  }

  /** Returns true if field loadTimeSeriesMetadataAlignedDiskUnSeqCount is set (has been assigned a value) and false otherwise */
  public boolean isSetLoadTimeSeriesMetadataAlignedDiskUnSeqCount() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __LOADTIMESERIESMETADATAALIGNEDDISKUNSEQCOUNT_ISSET_ID);
  }

  public void setLoadTimeSeriesMetadataAlignedDiskUnSeqCountIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __LOADTIMESERIESMETADATAALIGNEDDISKUNSEQCOUNT_ISSET_ID, value);
  }

  public long getLoadTimeSeriesMetadataAlignedMemSeqCount() {
    return this.loadTimeSeriesMetadataAlignedMemSeqCount;
  }

  public TQueryStatistics setLoadTimeSeriesMetadataAlignedMemSeqCount(long loadTimeSeriesMetadataAlignedMemSeqCount) {
    this.loadTimeSeriesMetadataAlignedMemSeqCount = loadTimeSeriesMetadataAlignedMemSeqCount;
    setLoadTimeSeriesMetadataAlignedMemSeqCountIsSet(true);
    return this;
  }

  public void unsetLoadTimeSeriesMetadataAlignedMemSeqCount() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __LOADTIMESERIESMETADATAALIGNEDMEMSEQCOUNT_ISSET_ID);
  }

  /** Returns true if field loadTimeSeriesMetadataAlignedMemSeqCount is set (has been assigned a value) and false otherwise */
  public boolean isSetLoadTimeSeriesMetadataAlignedMemSeqCount() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __LOADTIMESERIESMETADATAALIGNEDMEMSEQCOUNT_ISSET_ID);
  }

  public void setLoadTimeSeriesMetadataAlignedMemSeqCountIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __LOADTIMESERIESMETADATAALIGNEDMEMSEQCOUNT_ISSET_ID, value);
  }

  public long getLoadTimeSeriesMetadataAlignedMemUnSeqCount() {
    return this.loadTimeSeriesMetadataAlignedMemUnSeqCount;
  }

  public TQueryStatistics setLoadTimeSeriesMetadataAlignedMemUnSeqCount(long loadTimeSeriesMetadataAlignedMemUnSeqCount) {
    this.loadTimeSeriesMetadataAlignedMemUnSeqCount = loadTimeSeriesMetadataAlignedMemUnSeqCount;
    setLoadTimeSeriesMetadataAlignedMemUnSeqCountIsSet(true);
    return this;
  }

  public void unsetLoadTimeSeriesMetadataAlignedMemUnSeqCount() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __LOADTIMESERIESMETADATAALIGNEDMEMUNSEQCOUNT_ISSET_ID);
  }

  /** Returns true if field loadTimeSeriesMetadataAlignedMemUnSeqCount is set (has been assigned a value) and false otherwise */
  public boolean isSetLoadTimeSeriesMetadataAlignedMemUnSeqCount() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __LOADTIMESERIESMETADATAALIGNEDMEMUNSEQCOUNT_ISSET_ID);
  }

  public void setLoadTimeSeriesMetadataAlignedMemUnSeqCountIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __LOADTIMESERIESMETADATAALIGNEDMEMUNSEQCOUNT_ISSET_ID, value);
  }

  public long getLoadTimeSeriesMetadataDiskSeqTime() {
    return this.loadTimeSeriesMetadataDiskSeqTime;
  }

  public TQueryStatistics setLoadTimeSeriesMetadataDiskSeqTime(long loadTimeSeriesMetadataDiskSeqTime) {
    this.loadTimeSeriesMetadataDiskSeqTime = loadTimeSeriesMetadataDiskSeqTime;
    setLoadTimeSeriesMetadataDiskSeqTimeIsSet(true);
    return this;
  }

  public void unsetLoadTimeSeriesMetadataDiskSeqTime() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __LOADTIMESERIESMETADATADISKSEQTIME_ISSET_ID);
  }

  /** Returns true if field loadTimeSeriesMetadataDiskSeqTime is set (has been assigned a value) and false otherwise */
  public boolean isSetLoadTimeSeriesMetadataDiskSeqTime() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __LOADTIMESERIESMETADATADISKSEQTIME_ISSET_ID);
  }

  public void setLoadTimeSeriesMetadataDiskSeqTimeIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __LOADTIMESERIESMETADATADISKSEQTIME_ISSET_ID, value);
  }

  public long getLoadTimeSeriesMetadataDiskUnSeqTime() {
    return this.loadTimeSeriesMetadataDiskUnSeqTime;
  }

  public TQueryStatistics setLoadTimeSeriesMetadataDiskUnSeqTime(long loadTimeSeriesMetadataDiskUnSeqTime) {
    this.loadTimeSeriesMetadataDiskUnSeqTime = loadTimeSeriesMetadataDiskUnSeqTime;
    setLoadTimeSeriesMetadataDiskUnSeqTimeIsSet(true);
    return this;
  }

  public void unsetLoadTimeSeriesMetadataDiskUnSeqTime() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __LOADTIMESERIESMETADATADISKUNSEQTIME_ISSET_ID);
  }

  /** Returns true if field loadTimeSeriesMetadataDiskUnSeqTime is set (has been assigned a value) and false otherwise */
  public boolean isSetLoadTimeSeriesMetadataDiskUnSeqTime() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __LOADTIMESERIESMETADATADISKUNSEQTIME_ISSET_ID);
  }

  public void setLoadTimeSeriesMetadataDiskUnSeqTimeIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __LOADTIMESERIESMETADATADISKUNSEQTIME_ISSET_ID, value);
  }

  public long getLoadTimeSeriesMetadataMemSeqTime() {
    return this.loadTimeSeriesMetadataMemSeqTime;
  }

  public TQueryStatistics setLoadTimeSeriesMetadataMemSeqTime(long loadTimeSeriesMetadataMemSeqTime) {
    this.loadTimeSeriesMetadataMemSeqTime = loadTimeSeriesMetadataMemSeqTime;
    setLoadTimeSeriesMetadataMemSeqTimeIsSet(true);
    return this;
  }

  public void unsetLoadTimeSeriesMetadataMemSeqTime() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __LOADTIMESERIESMETADATAMEMSEQTIME_ISSET_ID);
  }

  /** Returns true if field loadTimeSeriesMetadataMemSeqTime is set (has been assigned a value) and false otherwise */
  public boolean isSetLoadTimeSeriesMetadataMemSeqTime() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __LOADTIMESERIESMETADATAMEMSEQTIME_ISSET_ID);
  }

  public void setLoadTimeSeriesMetadataMemSeqTimeIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __LOADTIMESERIESMETADATAMEMSEQTIME_ISSET_ID, value);
  }

  public long getLoadTimeSeriesMetadataMemUnSeqTime() {
    return this.loadTimeSeriesMetadataMemUnSeqTime;
  }

  public TQueryStatistics setLoadTimeSeriesMetadataMemUnSeqTime(long loadTimeSeriesMetadataMemUnSeqTime) {
    this.loadTimeSeriesMetadataMemUnSeqTime = loadTimeSeriesMetadataMemUnSeqTime;
    setLoadTimeSeriesMetadataMemUnSeqTimeIsSet(true);
    return this;
  }

  public void unsetLoadTimeSeriesMetadataMemUnSeqTime() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __LOADTIMESERIESMETADATAMEMUNSEQTIME_ISSET_ID);
  }

  /** Returns true if field loadTimeSeriesMetadataMemUnSeqTime is set (has been assigned a value) and false otherwise */
  public boolean isSetLoadTimeSeriesMetadataMemUnSeqTime() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __LOADTIMESERIESMETADATAMEMUNSEQTIME_ISSET_ID);
  }

  public void setLoadTimeSeriesMetadataMemUnSeqTimeIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __LOADTIMESERIESMETADATAMEMUNSEQTIME_ISSET_ID, value);
  }

  public long getLoadTimeSeriesMetadataAlignedDiskSeqTime() {
    return this.loadTimeSeriesMetadataAlignedDiskSeqTime;
  }

  public TQueryStatistics setLoadTimeSeriesMetadataAlignedDiskSeqTime(long loadTimeSeriesMetadataAlignedDiskSeqTime) {
    this.loadTimeSeriesMetadataAlignedDiskSeqTime = loadTimeSeriesMetadataAlignedDiskSeqTime;
    setLoadTimeSeriesMetadataAlignedDiskSeqTimeIsSet(true);
    return this;
  }

  public void unsetLoadTimeSeriesMetadataAlignedDiskSeqTime() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __LOADTIMESERIESMETADATAALIGNEDDISKSEQTIME_ISSET_ID);
  }

  /** Returns true if field loadTimeSeriesMetadataAlignedDiskSeqTime is set (has been assigned a value) and false otherwise */
  public boolean isSetLoadTimeSeriesMetadataAlignedDiskSeqTime() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __LOADTIMESERIESMETADATAALIGNEDDISKSEQTIME_ISSET_ID);
  }

  public void setLoadTimeSeriesMetadataAlignedDiskSeqTimeIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __LOADTIMESERIESMETADATAALIGNEDDISKSEQTIME_ISSET_ID, value);
  }

  public long getLoadTimeSeriesMetadataAlignedDiskUnSeqTime() {
    return this.loadTimeSeriesMetadataAlignedDiskUnSeqTime;
  }

  public TQueryStatistics setLoadTimeSeriesMetadataAlignedDiskUnSeqTime(long loadTimeSeriesMetadataAlignedDiskUnSeqTime) {
    this.loadTimeSeriesMetadataAlignedDiskUnSeqTime = loadTimeSeriesMetadataAlignedDiskUnSeqTime;
    setLoadTimeSeriesMetadataAlignedDiskUnSeqTimeIsSet(true);
    return this;
  }

  public void unsetLoadTimeSeriesMetadataAlignedDiskUnSeqTime() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __LOADTIMESERIESMETADATAALIGNEDDISKUNSEQTIME_ISSET_ID);
  }

  /** Returns true if field loadTimeSeriesMetadataAlignedDiskUnSeqTime is set (has been assigned a value) and false otherwise */
  public boolean isSetLoadTimeSeriesMetadataAlignedDiskUnSeqTime() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __LOADTIMESERIESMETADATAALIGNEDDISKUNSEQTIME_ISSET_ID);
  }

  public void setLoadTimeSeriesMetadataAlignedDiskUnSeqTimeIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __LOADTIMESERIESMETADATAALIGNEDDISKUNSEQTIME_ISSET_ID, value);
  }

  public long getLoadTimeSeriesMetadataAlignedMemSeqTime() {
    return this.loadTimeSeriesMetadataAlignedMemSeqTime;
  }

  public TQueryStatistics setLoadTimeSeriesMetadataAlignedMemSeqTime(long loadTimeSeriesMetadataAlignedMemSeqTime) {
    this.loadTimeSeriesMetadataAlignedMemSeqTime = loadTimeSeriesMetadataAlignedMemSeqTime;
    setLoadTimeSeriesMetadataAlignedMemSeqTimeIsSet(true);
    return this;
  }

  public void unsetLoadTimeSeriesMetadataAlignedMemSeqTime() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __LOADTIMESERIESMETADATAALIGNEDMEMSEQTIME_ISSET_ID);
  }

  /** Returns true if field loadTimeSeriesMetadataAlignedMemSeqTime is set (has been assigned a value) and false otherwise */
  public boolean isSetLoadTimeSeriesMetadataAlignedMemSeqTime() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __LOADTIMESERIESMETADATAALIGNEDMEMSEQTIME_ISSET_ID);
  }

  public void setLoadTimeSeriesMetadataAlignedMemSeqTimeIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __LOADTIMESERIESMETADATAALIGNEDMEMSEQTIME_ISSET_ID, value);
  }

  public long getLoadTimeSeriesMetadataAlignedMemUnSeqTime() {
    return this.loadTimeSeriesMetadataAlignedMemUnSeqTime;
  }

  public TQueryStatistics setLoadTimeSeriesMetadataAlignedMemUnSeqTime(long loadTimeSeriesMetadataAlignedMemUnSeqTime) {
    this.loadTimeSeriesMetadataAlignedMemUnSeqTime = loadTimeSeriesMetadataAlignedMemUnSeqTime;
    setLoadTimeSeriesMetadataAlignedMemUnSeqTimeIsSet(true);
    return this;
  }

  public void unsetLoadTimeSeriesMetadataAlignedMemUnSeqTime() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __LOADTIMESERIESMETADATAALIGNEDMEMUNSEQTIME_ISSET_ID);
  }

  /** Returns true if field loadTimeSeriesMetadataAlignedMemUnSeqTime is set (has been assigned a value) and false otherwise */
  public boolean isSetLoadTimeSeriesMetadataAlignedMemUnSeqTime() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __LOADTIMESERIESMETADATAALIGNEDMEMUNSEQTIME_ISSET_ID);
  }

  public void setLoadTimeSeriesMetadataAlignedMemUnSeqTimeIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __LOADTIMESERIESMETADATAALIGNEDMEMUNSEQTIME_ISSET_ID, value);
  }

  public long getConstructNonAlignedChunkReadersDiskCount() {
    return this.constructNonAlignedChunkReadersDiskCount;
  }

  public TQueryStatistics setConstructNonAlignedChunkReadersDiskCount(long constructNonAlignedChunkReadersDiskCount) {
    this.constructNonAlignedChunkReadersDiskCount = constructNonAlignedChunkReadersDiskCount;
    setConstructNonAlignedChunkReadersDiskCountIsSet(true);
    return this;
  }

  public void unsetConstructNonAlignedChunkReadersDiskCount() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __CONSTRUCTNONALIGNEDCHUNKREADERSDISKCOUNT_ISSET_ID);
  }

  /** Returns true if field constructNonAlignedChunkReadersDiskCount is set (has been assigned a value) and false otherwise */
  public boolean isSetConstructNonAlignedChunkReadersDiskCount() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __CONSTRUCTNONALIGNEDCHUNKREADERSDISKCOUNT_ISSET_ID);
  }

  public void setConstructNonAlignedChunkReadersDiskCountIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __CONSTRUCTNONALIGNEDCHUNKREADERSDISKCOUNT_ISSET_ID, value);
  }

  public long getConstructNonAlignedChunkReadersMemCount() {
    return this.constructNonAlignedChunkReadersMemCount;
  }

  public TQueryStatistics setConstructNonAlignedChunkReadersMemCount(long constructNonAlignedChunkReadersMemCount) {
    this.constructNonAlignedChunkReadersMemCount = constructNonAlignedChunkReadersMemCount;
    setConstructNonAlignedChunkReadersMemCountIsSet(true);
    return this;
  }

  public void unsetConstructNonAlignedChunkReadersMemCount() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __CONSTRUCTNONALIGNEDCHUNKREADERSMEMCOUNT_ISSET_ID);
  }

  /** Returns true if field constructNonAlignedChunkReadersMemCount is set (has been assigned a value) and false otherwise */
  public boolean isSetConstructNonAlignedChunkReadersMemCount() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __CONSTRUCTNONALIGNEDCHUNKREADERSMEMCOUNT_ISSET_ID);
  }

  public void setConstructNonAlignedChunkReadersMemCountIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __CONSTRUCTNONALIGNEDCHUNKREADERSMEMCOUNT_ISSET_ID, value);
  }

  public long getConstructAlignedChunkReadersDiskCount() {
    return this.constructAlignedChunkReadersDiskCount;
  }

  public TQueryStatistics setConstructAlignedChunkReadersDiskCount(long constructAlignedChunkReadersDiskCount) {
    this.constructAlignedChunkReadersDiskCount = constructAlignedChunkReadersDiskCount;
    setConstructAlignedChunkReadersDiskCountIsSet(true);
    return this;
  }

  public void unsetConstructAlignedChunkReadersDiskCount() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __CONSTRUCTALIGNEDCHUNKREADERSDISKCOUNT_ISSET_ID);
  }

  /** Returns true if field constructAlignedChunkReadersDiskCount is set (has been assigned a value) and false otherwise */
  public boolean isSetConstructAlignedChunkReadersDiskCount() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __CONSTRUCTALIGNEDCHUNKREADERSDISKCOUNT_ISSET_ID);
  }

  public void setConstructAlignedChunkReadersDiskCountIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __CONSTRUCTALIGNEDCHUNKREADERSDISKCOUNT_ISSET_ID, value);
  }

  public long getConstructAlignedChunkReadersMemCount() {
    return this.constructAlignedChunkReadersMemCount;
  }

  public TQueryStatistics setConstructAlignedChunkReadersMemCount(long constructAlignedChunkReadersMemCount) {
    this.constructAlignedChunkReadersMemCount = constructAlignedChunkReadersMemCount;
    setConstructAlignedChunkReadersMemCountIsSet(true);
    return this;
  }

  public void unsetConstructAlignedChunkReadersMemCount() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __CONSTRUCTALIGNEDCHUNKREADERSMEMCOUNT_ISSET_ID);
  }

  /** Returns true if field constructAlignedChunkReadersMemCount is set (has been assigned a value) and false otherwise */
  public boolean isSetConstructAlignedChunkReadersMemCount() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __CONSTRUCTALIGNEDCHUNKREADERSMEMCOUNT_ISSET_ID);
  }

  public void setConstructAlignedChunkReadersMemCountIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __CONSTRUCTALIGNEDCHUNKREADERSMEMCOUNT_ISSET_ID, value);
  }

  public long getConstructNonAlignedChunkReadersDiskTime() {
    return this.constructNonAlignedChunkReadersDiskTime;
  }

  public TQueryStatistics setConstructNonAlignedChunkReadersDiskTime(long constructNonAlignedChunkReadersDiskTime) {
    this.constructNonAlignedChunkReadersDiskTime = constructNonAlignedChunkReadersDiskTime;
    setConstructNonAlignedChunkReadersDiskTimeIsSet(true);
    return this;
  }

  public void unsetConstructNonAlignedChunkReadersDiskTime() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __CONSTRUCTNONALIGNEDCHUNKREADERSDISKTIME_ISSET_ID);
  }

  /** Returns true if field constructNonAlignedChunkReadersDiskTime is set (has been assigned a value) and false otherwise */
  public boolean isSetConstructNonAlignedChunkReadersDiskTime() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __CONSTRUCTNONALIGNEDCHUNKREADERSDISKTIME_ISSET_ID);
  }

  public void setConstructNonAlignedChunkReadersDiskTimeIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __CONSTRUCTNONALIGNEDCHUNKREADERSDISKTIME_ISSET_ID, value);
  }

  public long getConstructNonAlignedChunkReadersMemTime() {
    return this.constructNonAlignedChunkReadersMemTime;
  }

  public TQueryStatistics setConstructNonAlignedChunkReadersMemTime(long constructNonAlignedChunkReadersMemTime) {
    this.constructNonAlignedChunkReadersMemTime = constructNonAlignedChunkReadersMemTime;
    setConstructNonAlignedChunkReadersMemTimeIsSet(true);
    return this;
  }

  public void unsetConstructNonAlignedChunkReadersMemTime() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __CONSTRUCTNONALIGNEDCHUNKREADERSMEMTIME_ISSET_ID);
  }

  /** Returns true if field constructNonAlignedChunkReadersMemTime is set (has been assigned a value) and false otherwise */
  public boolean isSetConstructNonAlignedChunkReadersMemTime() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __CONSTRUCTNONALIGNEDCHUNKREADERSMEMTIME_ISSET_ID);
  }

  public void setConstructNonAlignedChunkReadersMemTimeIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __CONSTRUCTNONALIGNEDCHUNKREADERSMEMTIME_ISSET_ID, value);
  }

  public long getConstructAlignedChunkReadersDiskTime() {
    return this.constructAlignedChunkReadersDiskTime;
  }

  public TQueryStatistics setConstructAlignedChunkReadersDiskTime(long constructAlignedChunkReadersDiskTime) {
    this.constructAlignedChunkReadersDiskTime = constructAlignedChunkReadersDiskTime;
    setConstructAlignedChunkReadersDiskTimeIsSet(true);
    return this;
  }

  public void unsetConstructAlignedChunkReadersDiskTime() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __CONSTRUCTALIGNEDCHUNKREADERSDISKTIME_ISSET_ID);
  }

  /** Returns true if field constructAlignedChunkReadersDiskTime is set (has been assigned a value) and false otherwise */
  public boolean isSetConstructAlignedChunkReadersDiskTime() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __CONSTRUCTALIGNEDCHUNKREADERSDISKTIME_ISSET_ID);
  }

  public void setConstructAlignedChunkReadersDiskTimeIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __CONSTRUCTALIGNEDCHUNKREADERSDISKTIME_ISSET_ID, value);
  }

  public long getConstructAlignedChunkReadersMemTime() {
    return this.constructAlignedChunkReadersMemTime;
  }

  public TQueryStatistics setConstructAlignedChunkReadersMemTime(long constructAlignedChunkReadersMemTime) {
    this.constructAlignedChunkReadersMemTime = constructAlignedChunkReadersMemTime;
    setConstructAlignedChunkReadersMemTimeIsSet(true);
    return this;
  }

  public void unsetConstructAlignedChunkReadersMemTime() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __CONSTRUCTALIGNEDCHUNKREADERSMEMTIME_ISSET_ID);
  }

  /** Returns true if field constructAlignedChunkReadersMemTime is set (has been assigned a value) and false otherwise */
  public boolean isSetConstructAlignedChunkReadersMemTime() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __CONSTRUCTALIGNEDCHUNKREADERSMEMTIME_ISSET_ID);
  }

  public void setConstructAlignedChunkReadersMemTimeIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __CONSTRUCTALIGNEDCHUNKREADERSMEMTIME_ISSET_ID, value);
  }

  public long getPageReadersDecodeAlignedDiskCount() {
    return this.pageReadersDecodeAlignedDiskCount;
  }

  public TQueryStatistics setPageReadersDecodeAlignedDiskCount(long pageReadersDecodeAlignedDiskCount) {
    this.pageReadersDecodeAlignedDiskCount = pageReadersDecodeAlignedDiskCount;
    setPageReadersDecodeAlignedDiskCountIsSet(true);
    return this;
  }

  public void unsetPageReadersDecodeAlignedDiskCount() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __PAGEREADERSDECODEALIGNEDDISKCOUNT_ISSET_ID);
  }

  /** Returns true if field pageReadersDecodeAlignedDiskCount is set (has been assigned a value) and false otherwise */
  public boolean isSetPageReadersDecodeAlignedDiskCount() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __PAGEREADERSDECODEALIGNEDDISKCOUNT_ISSET_ID);
  }

  public void setPageReadersDecodeAlignedDiskCountIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __PAGEREADERSDECODEALIGNEDDISKCOUNT_ISSET_ID, value);
  }

  public long getPageReadersDecodeAlignedDiskTime() {
    return this.pageReadersDecodeAlignedDiskTime;
  }

  public TQueryStatistics setPageReadersDecodeAlignedDiskTime(long pageReadersDecodeAlignedDiskTime) {
    this.pageReadersDecodeAlignedDiskTime = pageReadersDecodeAlignedDiskTime;
    setPageReadersDecodeAlignedDiskTimeIsSet(true);
    return this;
  }

  public void unsetPageReadersDecodeAlignedDiskTime() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __PAGEREADERSDECODEALIGNEDDISKTIME_ISSET_ID);
  }

  /** Returns true if field pageReadersDecodeAlignedDiskTime is set (has been assigned a value) and false otherwise */
  public boolean isSetPageReadersDecodeAlignedDiskTime() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __PAGEREADERSDECODEALIGNEDDISKTIME_ISSET_ID);
  }

  public void setPageReadersDecodeAlignedDiskTimeIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __PAGEREADERSDECODEALIGNEDDISKTIME_ISSET_ID, value);
  }

  public long getPageReadersDecodeAlignedMemCount() {
    return this.pageReadersDecodeAlignedMemCount;
  }

  public TQueryStatistics setPageReadersDecodeAlignedMemCount(long pageReadersDecodeAlignedMemCount) {
    this.pageReadersDecodeAlignedMemCount = pageReadersDecodeAlignedMemCount;
    setPageReadersDecodeAlignedMemCountIsSet(true);
    return this;
  }

  public void unsetPageReadersDecodeAlignedMemCount() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __PAGEREADERSDECODEALIGNEDMEMCOUNT_ISSET_ID);
  }

  /** Returns true if field pageReadersDecodeAlignedMemCount is set (has been assigned a value) and false otherwise */
  public boolean isSetPageReadersDecodeAlignedMemCount() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __PAGEREADERSDECODEALIGNEDMEMCOUNT_ISSET_ID);
  }

  public void setPageReadersDecodeAlignedMemCountIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __PAGEREADERSDECODEALIGNEDMEMCOUNT_ISSET_ID, value);
  }

  public long getPageReadersDecodeAlignedMemTime() {
    return this.pageReadersDecodeAlignedMemTime;
  }

  public TQueryStatistics setPageReadersDecodeAlignedMemTime(long pageReadersDecodeAlignedMemTime) {
    this.pageReadersDecodeAlignedMemTime = pageReadersDecodeAlignedMemTime;
    setPageReadersDecodeAlignedMemTimeIsSet(true);
    return this;
  }

  public void unsetPageReadersDecodeAlignedMemTime() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __PAGEREADERSDECODEALIGNEDMEMTIME_ISSET_ID);
  }

  /** Returns true if field pageReadersDecodeAlignedMemTime is set (has been assigned a value) and false otherwise */
  public boolean isSetPageReadersDecodeAlignedMemTime() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __PAGEREADERSDECODEALIGNEDMEMTIME_ISSET_ID);
  }

  public void setPageReadersDecodeAlignedMemTimeIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __PAGEREADERSDECODEALIGNEDMEMTIME_ISSET_ID, value);
  }

  public long getPageReadersDecodeNonAlignedDiskCount() {
    return this.pageReadersDecodeNonAlignedDiskCount;
  }

  public TQueryStatistics setPageReadersDecodeNonAlignedDiskCount(long pageReadersDecodeNonAlignedDiskCount) {
    this.pageReadersDecodeNonAlignedDiskCount = pageReadersDecodeNonAlignedDiskCount;
    setPageReadersDecodeNonAlignedDiskCountIsSet(true);
    return this;
  }

  public void unsetPageReadersDecodeNonAlignedDiskCount() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __PAGEREADERSDECODENONALIGNEDDISKCOUNT_ISSET_ID);
  }

  /** Returns true if field pageReadersDecodeNonAlignedDiskCount is set (has been assigned a value) and false otherwise */
  public boolean isSetPageReadersDecodeNonAlignedDiskCount() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __PAGEREADERSDECODENONALIGNEDDISKCOUNT_ISSET_ID);
  }

  public void setPageReadersDecodeNonAlignedDiskCountIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __PAGEREADERSDECODENONALIGNEDDISKCOUNT_ISSET_ID, value);
  }

  public long getPageReadersDecodeNonAlignedDiskTime() {
    return this.pageReadersDecodeNonAlignedDiskTime;
  }

  public TQueryStatistics setPageReadersDecodeNonAlignedDiskTime(long pageReadersDecodeNonAlignedDiskTime) {
    this.pageReadersDecodeNonAlignedDiskTime = pageReadersDecodeNonAlignedDiskTime;
    setPageReadersDecodeNonAlignedDiskTimeIsSet(true);
    return this;
  }

  public void unsetPageReadersDecodeNonAlignedDiskTime() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __PAGEREADERSDECODENONALIGNEDDISKTIME_ISSET_ID);
  }

  /** Returns true if field pageReadersDecodeNonAlignedDiskTime is set (has been assigned a value) and false otherwise */
  public boolean isSetPageReadersDecodeNonAlignedDiskTime() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __PAGEREADERSDECODENONALIGNEDDISKTIME_ISSET_ID);
  }

  public void setPageReadersDecodeNonAlignedDiskTimeIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __PAGEREADERSDECODENONALIGNEDDISKTIME_ISSET_ID, value);
  }

  public long getPageReadersDecodeNonAlignedMemCount() {
    return this.pageReadersDecodeNonAlignedMemCount;
  }

  public TQueryStatistics setPageReadersDecodeNonAlignedMemCount(long pageReadersDecodeNonAlignedMemCount) {
    this.pageReadersDecodeNonAlignedMemCount = pageReadersDecodeNonAlignedMemCount;
    setPageReadersDecodeNonAlignedMemCountIsSet(true);
    return this;
  }

  public void unsetPageReadersDecodeNonAlignedMemCount() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __PAGEREADERSDECODENONALIGNEDMEMCOUNT_ISSET_ID);
  }

  /** Returns true if field pageReadersDecodeNonAlignedMemCount is set (has been assigned a value) and false otherwise */
  public boolean isSetPageReadersDecodeNonAlignedMemCount() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __PAGEREADERSDECODENONALIGNEDMEMCOUNT_ISSET_ID);
  }

  public void setPageReadersDecodeNonAlignedMemCountIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __PAGEREADERSDECODENONALIGNEDMEMCOUNT_ISSET_ID, value);
  }

  public long getPageReadersDecodeNonAlignedMemTime() {
    return this.pageReadersDecodeNonAlignedMemTime;
  }

  public TQueryStatistics setPageReadersDecodeNonAlignedMemTime(long pageReadersDecodeNonAlignedMemTime) {
    this.pageReadersDecodeNonAlignedMemTime = pageReadersDecodeNonAlignedMemTime;
    setPageReadersDecodeNonAlignedMemTimeIsSet(true);
    return this;
  }

  public void unsetPageReadersDecodeNonAlignedMemTime() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __PAGEREADERSDECODENONALIGNEDMEMTIME_ISSET_ID);
  }

  /** Returns true if field pageReadersDecodeNonAlignedMemTime is set (has been assigned a value) and false otherwise */
  public boolean isSetPageReadersDecodeNonAlignedMemTime() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __PAGEREADERSDECODENONALIGNEDMEMTIME_ISSET_ID);
  }

  public void setPageReadersDecodeNonAlignedMemTimeIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __PAGEREADERSDECODENONALIGNEDMEMTIME_ISSET_ID, value);
  }

  public long getPageReaderMaxUsedMemorySize() {
    return this.pageReaderMaxUsedMemorySize;
  }

  public TQueryStatistics setPageReaderMaxUsedMemorySize(long pageReaderMaxUsedMemorySize) {
    this.pageReaderMaxUsedMemorySize = pageReaderMaxUsedMemorySize;
    setPageReaderMaxUsedMemorySizeIsSet(true);
    return this;
  }

  public void unsetPageReaderMaxUsedMemorySize() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __PAGEREADERMAXUSEDMEMORYSIZE_ISSET_ID);
  }

  /** Returns true if field pageReaderMaxUsedMemorySize is set (has been assigned a value) and false otherwise */
  public boolean isSetPageReaderMaxUsedMemorySize() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __PAGEREADERMAXUSEDMEMORYSIZE_ISSET_ID);
  }

  public void setPageReaderMaxUsedMemorySizeIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __PAGEREADERMAXUSEDMEMORYSIZE_ISSET_ID, value);
  }

  public long getAlignedTimeSeriesMetadataModificationCount() {
    return this.alignedTimeSeriesMetadataModificationCount;
  }

  public TQueryStatistics setAlignedTimeSeriesMetadataModificationCount(long alignedTimeSeriesMetadataModificationCount) {
    this.alignedTimeSeriesMetadataModificationCount = alignedTimeSeriesMetadataModificationCount;
    setAlignedTimeSeriesMetadataModificationCountIsSet(true);
    return this;
  }

  public void unsetAlignedTimeSeriesMetadataModificationCount() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __ALIGNEDTIMESERIESMETADATAMODIFICATIONCOUNT_ISSET_ID);
  }

  /** Returns true if field alignedTimeSeriesMetadataModificationCount is set (has been assigned a value) and false otherwise */
  public boolean isSetAlignedTimeSeriesMetadataModificationCount() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __ALIGNEDTIMESERIESMETADATAMODIFICATIONCOUNT_ISSET_ID);
  }

  public void setAlignedTimeSeriesMetadataModificationCountIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __ALIGNEDTIMESERIESMETADATAMODIFICATIONCOUNT_ISSET_ID, value);
  }

  public long getAlignedTimeSeriesMetadataModificationTime() {
    return this.alignedTimeSeriesMetadataModificationTime;
  }

  public TQueryStatistics setAlignedTimeSeriesMetadataModificationTime(long alignedTimeSeriesMetadataModificationTime) {
    this.alignedTimeSeriesMetadataModificationTime = alignedTimeSeriesMetadataModificationTime;
    setAlignedTimeSeriesMetadataModificationTimeIsSet(true);
    return this;
  }

  public void unsetAlignedTimeSeriesMetadataModificationTime() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __ALIGNEDTIMESERIESMETADATAMODIFICATIONTIME_ISSET_ID);
  }

  /** Returns true if field alignedTimeSeriesMetadataModificationTime is set (has been assigned a value) and false otherwise */
  public boolean isSetAlignedTimeSeriesMetadataModificationTime() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __ALIGNEDTIMESERIESMETADATAMODIFICATIONTIME_ISSET_ID);
  }

  public void setAlignedTimeSeriesMetadataModificationTimeIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __ALIGNEDTIMESERIESMETADATAMODIFICATIONTIME_ISSET_ID, value);
  }

  public long getNonAlignedTimeSeriesMetadataModificationCount() {
    return this.nonAlignedTimeSeriesMetadataModificationCount;
  }

  public TQueryStatistics setNonAlignedTimeSeriesMetadataModificationCount(long nonAlignedTimeSeriesMetadataModificationCount) {
    this.nonAlignedTimeSeriesMetadataModificationCount = nonAlignedTimeSeriesMetadataModificationCount;
    setNonAlignedTimeSeriesMetadataModificationCountIsSet(true);
    return this;
  }

  public void unsetNonAlignedTimeSeriesMetadataModificationCount() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __NONALIGNEDTIMESERIESMETADATAMODIFICATIONCOUNT_ISSET_ID);
  }

  /** Returns true if field nonAlignedTimeSeriesMetadataModificationCount is set (has been assigned a value) and false otherwise */
  public boolean isSetNonAlignedTimeSeriesMetadataModificationCount() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __NONALIGNEDTIMESERIESMETADATAMODIFICATIONCOUNT_ISSET_ID);
  }

  public void setNonAlignedTimeSeriesMetadataModificationCountIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __NONALIGNEDTIMESERIESMETADATAMODIFICATIONCOUNT_ISSET_ID, value);
  }

  public long getNonAlignedTimeSeriesMetadataModificationTime() {
    return this.nonAlignedTimeSeriesMetadataModificationTime;
  }

  public TQueryStatistics setNonAlignedTimeSeriesMetadataModificationTime(long nonAlignedTimeSeriesMetadataModificationTime) {
    this.nonAlignedTimeSeriesMetadataModificationTime = nonAlignedTimeSeriesMetadataModificationTime;
    setNonAlignedTimeSeriesMetadataModificationTimeIsSet(true);
    return this;
  }

  public void unsetNonAlignedTimeSeriesMetadataModificationTime() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __NONALIGNEDTIMESERIESMETADATAMODIFICATIONTIME_ISSET_ID);
  }

  /** Returns true if field nonAlignedTimeSeriesMetadataModificationTime is set (has been assigned a value) and false otherwise */
  public boolean isSetNonAlignedTimeSeriesMetadataModificationTime() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __NONALIGNEDTIMESERIESMETADATAMODIFICATIONTIME_ISSET_ID);
  }

  public void setNonAlignedTimeSeriesMetadataModificationTimeIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __NONALIGNEDTIMESERIESMETADATAMODIFICATIONTIME_ISSET_ID, value);
  }

  public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
    switch (field) {
    case LOAD_TIME_SERIES_METADATA_DISK_SEQ_COUNT:
      if (value == null) {
        unsetLoadTimeSeriesMetadataDiskSeqCount();
      } else {
        setLoadTimeSeriesMetadataDiskSeqCount((java.lang.Long)value);
      }
      break;

    case LOAD_TIME_SERIES_METADATA_DISK_UN_SEQ_COUNT:
      if (value == null) {
        unsetLoadTimeSeriesMetadataDiskUnSeqCount();
      } else {
        setLoadTimeSeriesMetadataDiskUnSeqCount((java.lang.Long)value);
      }
      break;

    case LOAD_TIME_SERIES_METADATA_MEM_SEQ_COUNT:
      if (value == null) {
        unsetLoadTimeSeriesMetadataMemSeqCount();
      } else {
        setLoadTimeSeriesMetadataMemSeqCount((java.lang.Long)value);
      }
      break;

    case LOAD_TIME_SERIES_METADATA_MEM_UN_SEQ_COUNT:
      if (value == null) {
        unsetLoadTimeSeriesMetadataMemUnSeqCount();
      } else {
        setLoadTimeSeriesMetadataMemUnSeqCount((java.lang.Long)value);
      }
      break;

    case LOAD_TIME_SERIES_METADATA_ALIGNED_DISK_SEQ_COUNT:
      if (value == null) {
        unsetLoadTimeSeriesMetadataAlignedDiskSeqCount();
      } else {
        setLoadTimeSeriesMetadataAlignedDiskSeqCount((java.lang.Long)value);
      }
      break;

    case LOAD_TIME_SERIES_METADATA_ALIGNED_DISK_UN_SEQ_COUNT:
      if (value == null) {
        unsetLoadTimeSeriesMetadataAlignedDiskUnSeqCount();
      } else {
        setLoadTimeSeriesMetadataAlignedDiskUnSeqCount((java.lang.Long)value);
      }
      break;

    case LOAD_TIME_SERIES_METADATA_ALIGNED_MEM_SEQ_COUNT:
      if (value == null) {
        unsetLoadTimeSeriesMetadataAlignedMemSeqCount();
      } else {
        setLoadTimeSeriesMetadataAlignedMemSeqCount((java.lang.Long)value);
      }
      break;

    case LOAD_TIME_SERIES_METADATA_ALIGNED_MEM_UN_SEQ_COUNT:
      if (value == null) {
        unsetLoadTimeSeriesMetadataAlignedMemUnSeqCount();
      } else {
        setLoadTimeSeriesMetadataAlignedMemUnSeqCount((java.lang.Long)value);
      }
      break;

    case LOAD_TIME_SERIES_METADATA_DISK_SEQ_TIME:
      if (value == null) {
        unsetLoadTimeSeriesMetadataDiskSeqTime();
      } else {
        setLoadTimeSeriesMetadataDiskSeqTime((java.lang.Long)value);
      }
      break;

    case LOAD_TIME_SERIES_METADATA_DISK_UN_SEQ_TIME:
      if (value == null) {
        unsetLoadTimeSeriesMetadataDiskUnSeqTime();
      } else {
        setLoadTimeSeriesMetadataDiskUnSeqTime((java.lang.Long)value);
      }
      break;

    case LOAD_TIME_SERIES_METADATA_MEM_SEQ_TIME:
      if (value == null) {
        unsetLoadTimeSeriesMetadataMemSeqTime();
      } else {
        setLoadTimeSeriesMetadataMemSeqTime((java.lang.Long)value);
      }
      break;

    case LOAD_TIME_SERIES_METADATA_MEM_UN_SEQ_TIME:
      if (value == null) {
        unsetLoadTimeSeriesMetadataMemUnSeqTime();
      } else {
        setLoadTimeSeriesMetadataMemUnSeqTime((java.lang.Long)value);
      }
      break;

    case LOAD_TIME_SERIES_METADATA_ALIGNED_DISK_SEQ_TIME:
      if (value == null) {
        unsetLoadTimeSeriesMetadataAlignedDiskSeqTime();
      } else {
        setLoadTimeSeriesMetadataAlignedDiskSeqTime((java.lang.Long)value);
      }
      break;

    case LOAD_TIME_SERIES_METADATA_ALIGNED_DISK_UN_SEQ_TIME:
      if (value == null) {
        unsetLoadTimeSeriesMetadataAlignedDiskUnSeqTime();
      } else {
        setLoadTimeSeriesMetadataAlignedDiskUnSeqTime((java.lang.Long)value);
      }
      break;

    case LOAD_TIME_SERIES_METADATA_ALIGNED_MEM_SEQ_TIME:
      if (value == null) {
        unsetLoadTimeSeriesMetadataAlignedMemSeqTime();
      } else {
        setLoadTimeSeriesMetadataAlignedMemSeqTime((java.lang.Long)value);
      }
      break;

    case LOAD_TIME_SERIES_METADATA_ALIGNED_MEM_UN_SEQ_TIME:
      if (value == null) {
        unsetLoadTimeSeriesMetadataAlignedMemUnSeqTime();
      } else {
        setLoadTimeSeriesMetadataAlignedMemUnSeqTime((java.lang.Long)value);
      }
      break;

    case CONSTRUCT_NON_ALIGNED_CHUNK_READERS_DISK_COUNT:
      if (value == null) {
        unsetConstructNonAlignedChunkReadersDiskCount();
      } else {
        setConstructNonAlignedChunkReadersDiskCount((java.lang.Long)value);
      }
      break;

    case CONSTRUCT_NON_ALIGNED_CHUNK_READERS_MEM_COUNT:
      if (value == null) {
        unsetConstructNonAlignedChunkReadersMemCount();
      } else {
        setConstructNonAlignedChunkReadersMemCount((java.lang.Long)value);
      }
      break;

    case CONSTRUCT_ALIGNED_CHUNK_READERS_DISK_COUNT:
      if (value == null) {
        unsetConstructAlignedChunkReadersDiskCount();
      } else {
        setConstructAlignedChunkReadersDiskCount((java.lang.Long)value);
      }
      break;

    case CONSTRUCT_ALIGNED_CHUNK_READERS_MEM_COUNT:
      if (value == null) {
        unsetConstructAlignedChunkReadersMemCount();
      } else {
        setConstructAlignedChunkReadersMemCount((java.lang.Long)value);
      }
      break;

    case CONSTRUCT_NON_ALIGNED_CHUNK_READERS_DISK_TIME:
      if (value == null) {
        unsetConstructNonAlignedChunkReadersDiskTime();
      } else {
        setConstructNonAlignedChunkReadersDiskTime((java.lang.Long)value);
      }
      break;

    case CONSTRUCT_NON_ALIGNED_CHUNK_READERS_MEM_TIME:
      if (value == null) {
        unsetConstructNonAlignedChunkReadersMemTime();
      } else {
        setConstructNonAlignedChunkReadersMemTime((java.lang.Long)value);
      }
      break;

    case CONSTRUCT_ALIGNED_CHUNK_READERS_DISK_TIME:
      if (value == null) {
        unsetConstructAlignedChunkReadersDiskTime();
      } else {
        setConstructAlignedChunkReadersDiskTime((java.lang.Long)value);
      }
      break;

    case CONSTRUCT_ALIGNED_CHUNK_READERS_MEM_TIME:
      if (value == null) {
        unsetConstructAlignedChunkReadersMemTime();
      } else {
        setConstructAlignedChunkReadersMemTime((java.lang.Long)value);
      }
      break;

    case PAGE_READERS_DECODE_ALIGNED_DISK_COUNT:
      if (value == null) {
        unsetPageReadersDecodeAlignedDiskCount();
      } else {
        setPageReadersDecodeAlignedDiskCount((java.lang.Long)value);
      }
      break;

    case PAGE_READERS_DECODE_ALIGNED_DISK_TIME:
      if (value == null) {
        unsetPageReadersDecodeAlignedDiskTime();
      } else {
        setPageReadersDecodeAlignedDiskTime((java.lang.Long)value);
      }
      break;

    case PAGE_READERS_DECODE_ALIGNED_MEM_COUNT:
      if (value == null) {
        unsetPageReadersDecodeAlignedMemCount();
      } else {
        setPageReadersDecodeAlignedMemCount((java.lang.Long)value);
      }
      break;

    case PAGE_READERS_DECODE_ALIGNED_MEM_TIME:
      if (value == null) {
        unsetPageReadersDecodeAlignedMemTime();
      } else {
        setPageReadersDecodeAlignedMemTime((java.lang.Long)value);
      }
      break;

    case PAGE_READERS_DECODE_NON_ALIGNED_DISK_COUNT:
      if (value == null) {
        unsetPageReadersDecodeNonAlignedDiskCount();
      } else {
        setPageReadersDecodeNonAlignedDiskCount((java.lang.Long)value);
      }
      break;

    case PAGE_READERS_DECODE_NON_ALIGNED_DISK_TIME:
      if (value == null) {
        unsetPageReadersDecodeNonAlignedDiskTime();
      } else {
        setPageReadersDecodeNonAlignedDiskTime((java.lang.Long)value);
      }
      break;

    case PAGE_READERS_DECODE_NON_ALIGNED_MEM_COUNT:
      if (value == null) {
        unsetPageReadersDecodeNonAlignedMemCount();
      } else {
        setPageReadersDecodeNonAlignedMemCount((java.lang.Long)value);
      }
      break;

    case PAGE_READERS_DECODE_NON_ALIGNED_MEM_TIME:
      if (value == null) {
        unsetPageReadersDecodeNonAlignedMemTime();
      } else {
        setPageReadersDecodeNonAlignedMemTime((java.lang.Long)value);
      }
      break;

    case PAGE_READER_MAX_USED_MEMORY_SIZE:
      if (value == null) {
        unsetPageReaderMaxUsedMemorySize();
      } else {
        setPageReaderMaxUsedMemorySize((java.lang.Long)value);
      }
      break;

    case ALIGNED_TIME_SERIES_METADATA_MODIFICATION_COUNT:
      if (value == null) {
        unsetAlignedTimeSeriesMetadataModificationCount();
      } else {
        setAlignedTimeSeriesMetadataModificationCount((java.lang.Long)value);
      }
      break;

    case ALIGNED_TIME_SERIES_METADATA_MODIFICATION_TIME:
      if (value == null) {
        unsetAlignedTimeSeriesMetadataModificationTime();
      } else {
        setAlignedTimeSeriesMetadataModificationTime((java.lang.Long)value);
      }
      break;

    case NON_ALIGNED_TIME_SERIES_METADATA_MODIFICATION_COUNT:
      if (value == null) {
        unsetNonAlignedTimeSeriesMetadataModificationCount();
      } else {
        setNonAlignedTimeSeriesMetadataModificationCount((java.lang.Long)value);
      }
      break;

    case NON_ALIGNED_TIME_SERIES_METADATA_MODIFICATION_TIME:
      if (value == null) {
        unsetNonAlignedTimeSeriesMetadataModificationTime();
      } else {
        setNonAlignedTimeSeriesMetadataModificationTime((java.lang.Long)value);
      }
      break;

    }
  }

  @org.apache.thrift.annotation.Nullable
  public java.lang.Object getFieldValue(_Fields field) {
    switch (field) {
    case LOAD_TIME_SERIES_METADATA_DISK_SEQ_COUNT:
      return getLoadTimeSeriesMetadataDiskSeqCount();

    case LOAD_TIME_SERIES_METADATA_DISK_UN_SEQ_COUNT:
      return getLoadTimeSeriesMetadataDiskUnSeqCount();

    case LOAD_TIME_SERIES_METADATA_MEM_SEQ_COUNT:
      return getLoadTimeSeriesMetadataMemSeqCount();

    case LOAD_TIME_SERIES_METADATA_MEM_UN_SEQ_COUNT:
      return getLoadTimeSeriesMetadataMemUnSeqCount();

    case LOAD_TIME_SERIES_METADATA_ALIGNED_DISK_SEQ_COUNT:
      return getLoadTimeSeriesMetadataAlignedDiskSeqCount();

    case LOAD_TIME_SERIES_METADATA_ALIGNED_DISK_UN_SEQ_COUNT:
      return getLoadTimeSeriesMetadataAlignedDiskUnSeqCount();

    case LOAD_TIME_SERIES_METADATA_ALIGNED_MEM_SEQ_COUNT:
      return getLoadTimeSeriesMetadataAlignedMemSeqCount();

    case LOAD_TIME_SERIES_METADATA_ALIGNED_MEM_UN_SEQ_COUNT:
      return getLoadTimeSeriesMetadataAlignedMemUnSeqCount();

    case LOAD_TIME_SERIES_METADATA_DISK_SEQ_TIME:
      return getLoadTimeSeriesMetadataDiskSeqTime();

    case LOAD_TIME_SERIES_METADATA_DISK_UN_SEQ_TIME:
      return getLoadTimeSeriesMetadataDiskUnSeqTime();

    case LOAD_TIME_SERIES_METADATA_MEM_SEQ_TIME:
      return getLoadTimeSeriesMetadataMemSeqTime();

    case LOAD_TIME_SERIES_METADATA_MEM_UN_SEQ_TIME:
      return getLoadTimeSeriesMetadataMemUnSeqTime();

    case LOAD_TIME_SERIES_METADATA_ALIGNED_DISK_SEQ_TIME:
      return getLoadTimeSeriesMetadataAlignedDiskSeqTime();

    case LOAD_TIME_SERIES_METADATA_ALIGNED_DISK_UN_SEQ_TIME:
      return getLoadTimeSeriesMetadataAlignedDiskUnSeqTime();

    case LOAD_TIME_SERIES_METADATA_ALIGNED_MEM_SEQ_TIME:
      return getLoadTimeSeriesMetadataAlignedMemSeqTime();

    case LOAD_TIME_SERIES_METADATA_ALIGNED_MEM_UN_SEQ_TIME:
      return getLoadTimeSeriesMetadataAlignedMemUnSeqTime();

    case CONSTRUCT_NON_ALIGNED_CHUNK_READERS_DISK_COUNT:
      return getConstructNonAlignedChunkReadersDiskCount();

    case CONSTRUCT_NON_ALIGNED_CHUNK_READERS_MEM_COUNT:
      return getConstructNonAlignedChunkReadersMemCount();

    case CONSTRUCT_ALIGNED_CHUNK_READERS_DISK_COUNT:
      return getConstructAlignedChunkReadersDiskCount();

    case CONSTRUCT_ALIGNED_CHUNK_READERS_MEM_COUNT:
      return getConstructAlignedChunkReadersMemCount();

    case CONSTRUCT_NON_ALIGNED_CHUNK_READERS_DISK_TIME:
      return getConstructNonAlignedChunkReadersDiskTime();

    case CONSTRUCT_NON_ALIGNED_CHUNK_READERS_MEM_TIME:
      return getConstructNonAlignedChunkReadersMemTime();

    case CONSTRUCT_ALIGNED_CHUNK_READERS_DISK_TIME:
      return getConstructAlignedChunkReadersDiskTime();

    case CONSTRUCT_ALIGNED_CHUNK_READERS_MEM_TIME:
      return getConstructAlignedChunkReadersMemTime();

    case PAGE_READERS_DECODE_ALIGNED_DISK_COUNT:
      return getPageReadersDecodeAlignedDiskCount();

    case PAGE_READERS_DECODE_ALIGNED_DISK_TIME:
      return getPageReadersDecodeAlignedDiskTime();

    case PAGE_READERS_DECODE_ALIGNED_MEM_COUNT:
      return getPageReadersDecodeAlignedMemCount();

    case PAGE_READERS_DECODE_ALIGNED_MEM_TIME:
      return getPageReadersDecodeAlignedMemTime();

    case PAGE_READERS_DECODE_NON_ALIGNED_DISK_COUNT:
      return getPageReadersDecodeNonAlignedDiskCount();

    case PAGE_READERS_DECODE_NON_ALIGNED_DISK_TIME:
      return getPageReadersDecodeNonAlignedDiskTime();

    case PAGE_READERS_DECODE_NON_ALIGNED_MEM_COUNT:
      return getPageReadersDecodeNonAlignedMemCount();

    case PAGE_READERS_DECODE_NON_ALIGNED_MEM_TIME:
      return getPageReadersDecodeNonAlignedMemTime();

    case PAGE_READER_MAX_USED_MEMORY_SIZE:
      return getPageReaderMaxUsedMemorySize();

    case ALIGNED_TIME_SERIES_METADATA_MODIFICATION_COUNT:
      return getAlignedTimeSeriesMetadataModificationCount();

    case ALIGNED_TIME_SERIES_METADATA_MODIFICATION_TIME:
      return getAlignedTimeSeriesMetadataModificationTime();

    case NON_ALIGNED_TIME_SERIES_METADATA_MODIFICATION_COUNT:
      return getNonAlignedTimeSeriesMetadataModificationCount();

    case NON_ALIGNED_TIME_SERIES_METADATA_MODIFICATION_TIME:
      return getNonAlignedTimeSeriesMetadataModificationTime();

    }
    throw new java.lang.IllegalStateException();
  }

  /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
  public boolean isSet(_Fields field) {
    if (field == null) {
      throw new java.lang.IllegalArgumentException();
    }

    switch (field) {
    case LOAD_TIME_SERIES_METADATA_DISK_SEQ_COUNT:
      return isSetLoadTimeSeriesMetadataDiskSeqCount();
    case LOAD_TIME_SERIES_METADATA_DISK_UN_SEQ_COUNT:
      return isSetLoadTimeSeriesMetadataDiskUnSeqCount();
    case LOAD_TIME_SERIES_METADATA_MEM_SEQ_COUNT:
      return isSetLoadTimeSeriesMetadataMemSeqCount();
    case LOAD_TIME_SERIES_METADATA_MEM_UN_SEQ_COUNT:
      return isSetLoadTimeSeriesMetadataMemUnSeqCount();
    case LOAD_TIME_SERIES_METADATA_ALIGNED_DISK_SEQ_COUNT:
      return isSetLoadTimeSeriesMetadataAlignedDiskSeqCount();
    case LOAD_TIME_SERIES_METADATA_ALIGNED_DISK_UN_SEQ_COUNT:
      return isSetLoadTimeSeriesMetadataAlignedDiskUnSeqCount();
    case LOAD_TIME_SERIES_METADATA_ALIGNED_MEM_SEQ_COUNT:
      return isSetLoadTimeSeriesMetadataAlignedMemSeqCount();
    case LOAD_TIME_SERIES_METADATA_ALIGNED_MEM_UN_SEQ_COUNT:
      return isSetLoadTimeSeriesMetadataAlignedMemUnSeqCount();
    case LOAD_TIME_SERIES_METADATA_DISK_SEQ_TIME:
      return isSetLoadTimeSeriesMetadataDiskSeqTime();
    case LOAD_TIME_SERIES_METADATA_DISK_UN_SEQ_TIME:
      return isSetLoadTimeSeriesMetadataDiskUnSeqTime();
    case LOAD_TIME_SERIES_METADATA_MEM_SEQ_TIME:
      return isSetLoadTimeSeriesMetadataMemSeqTime();
    case LOAD_TIME_SERIES_METADATA_MEM_UN_SEQ_TIME:
      return isSetLoadTimeSeriesMetadataMemUnSeqTime();
    case LOAD_TIME_SERIES_METADATA_ALIGNED_DISK_SEQ_TIME:
      return isSetLoadTimeSeriesMetadataAlignedDiskSeqTime();
    case LOAD_TIME_SERIES_METADATA_ALIGNED_DISK_UN_SEQ_TIME:
      return isSetLoadTimeSeriesMetadataAlignedDiskUnSeqTime();
    case LOAD_TIME_SERIES_METADATA_ALIGNED_MEM_SEQ_TIME:
      return isSetLoadTimeSeriesMetadataAlignedMemSeqTime();
    case LOAD_TIME_SERIES_METADATA_ALIGNED_MEM_UN_SEQ_TIME:
      return isSetLoadTimeSeriesMetadataAlignedMemUnSeqTime();
    case CONSTRUCT_NON_ALIGNED_CHUNK_READERS_DISK_COUNT:
      return isSetConstructNonAlignedChunkReadersDiskCount();
    case CONSTRUCT_NON_ALIGNED_CHUNK_READERS_MEM_COUNT:
      return isSetConstructNonAlignedChunkReadersMemCount();
    case CONSTRUCT_ALIGNED_CHUNK_READERS_DISK_COUNT:
      return isSetConstructAlignedChunkReadersDiskCount();
    case CONSTRUCT_ALIGNED_CHUNK_READERS_MEM_COUNT:
      return isSetConstructAlignedChunkReadersMemCount();
    case CONSTRUCT_NON_ALIGNED_CHUNK_READERS_DISK_TIME:
      return isSetConstructNonAlignedChunkReadersDiskTime();
    case CONSTRUCT_NON_ALIGNED_CHUNK_READERS_MEM_TIME:
      return isSetConstructNonAlignedChunkReadersMemTime();
    case CONSTRUCT_ALIGNED_CHUNK_READERS_DISK_TIME:
      return isSetConstructAlignedChunkReadersDiskTime();
    case CONSTRUCT_ALIGNED_CHUNK_READERS_MEM_TIME:
      return isSetConstructAlignedChunkReadersMemTime();
    case PAGE_READERS_DECODE_ALIGNED_DISK_COUNT:
      return isSetPageReadersDecodeAlignedDiskCount();
    case PAGE_READERS_DECODE_ALIGNED_DISK_TIME:
      return isSetPageReadersDecodeAlignedDiskTime();
    case PAGE_READERS_DECODE_ALIGNED_MEM_COUNT:
      return isSetPageReadersDecodeAlignedMemCount();
    case PAGE_READERS_DECODE_ALIGNED_MEM_TIME:
      return isSetPageReadersDecodeAlignedMemTime();
    case PAGE_READERS_DECODE_NON_ALIGNED_DISK_COUNT:
      return isSetPageReadersDecodeNonAlignedDiskCount();
    case PAGE_READERS_DECODE_NON_ALIGNED_DISK_TIME:
      return isSetPageReadersDecodeNonAlignedDiskTime();
    case PAGE_READERS_DECODE_NON_ALIGNED_MEM_COUNT:
      return isSetPageReadersDecodeNonAlignedMemCount();
    case PAGE_READERS_DECODE_NON_ALIGNED_MEM_TIME:
      return isSetPageReadersDecodeNonAlignedMemTime();
    case PAGE_READER_MAX_USED_MEMORY_SIZE:
      return isSetPageReaderMaxUsedMemorySize();
    case ALIGNED_TIME_SERIES_METADATA_MODIFICATION_COUNT:
      return isSetAlignedTimeSeriesMetadataModificationCount();
    case ALIGNED_TIME_SERIES_METADATA_MODIFICATION_TIME:
      return isSetAlignedTimeSeriesMetadataModificationTime();
    case NON_ALIGNED_TIME_SERIES_METADATA_MODIFICATION_COUNT:
      return isSetNonAlignedTimeSeriesMetadataModificationCount();
    case NON_ALIGNED_TIME_SERIES_METADATA_MODIFICATION_TIME:
      return isSetNonAlignedTimeSeriesMetadataModificationTime();
    }
    throw new java.lang.IllegalStateException();
  }

  @Override
  public boolean equals(java.lang.Object that) {
    if (that instanceof TQueryStatistics)
      return this.equals((TQueryStatistics)that);
    return false;
  }

  public boolean equals(TQueryStatistics that) {
    if (that == null)
      return false;
    if (this == that)
      return true;

    boolean this_present_loadTimeSeriesMetadataDiskSeqCount = true;
    boolean that_present_loadTimeSeriesMetadataDiskSeqCount = true;
    if (this_present_loadTimeSeriesMetadataDiskSeqCount || that_present_loadTimeSeriesMetadataDiskSeqCount) {
      if (!(this_present_loadTimeSeriesMetadataDiskSeqCount && that_present_loadTimeSeriesMetadataDiskSeqCount))
        return false;
      if (this.loadTimeSeriesMetadataDiskSeqCount != that.loadTimeSeriesMetadataDiskSeqCount)
        return false;
    }

    boolean this_present_loadTimeSeriesMetadataDiskUnSeqCount = true;
    boolean that_present_loadTimeSeriesMetadataDiskUnSeqCount = true;
    if (this_present_loadTimeSeriesMetadataDiskUnSeqCount || that_present_loadTimeSeriesMetadataDiskUnSeqCount) {
      if (!(this_present_loadTimeSeriesMetadataDiskUnSeqCount && that_present_loadTimeSeriesMetadataDiskUnSeqCount))
        return false;
      if (this.loadTimeSeriesMetadataDiskUnSeqCount != that.loadTimeSeriesMetadataDiskUnSeqCount)
        return false;
    }

    boolean this_present_loadTimeSeriesMetadataMemSeqCount = true;
    boolean that_present_loadTimeSeriesMetadataMemSeqCount = true;
    if (this_present_loadTimeSeriesMetadataMemSeqCount || that_present_loadTimeSeriesMetadataMemSeqCount) {
      if (!(this_present_loadTimeSeriesMetadataMemSeqCount && that_present_loadTimeSeriesMetadataMemSeqCount))
        return false;
      if (this.loadTimeSeriesMetadataMemSeqCount != that.loadTimeSeriesMetadataMemSeqCount)
        return false;
    }

    boolean this_present_loadTimeSeriesMetadataMemUnSeqCount = true;
    boolean that_present_loadTimeSeriesMetadataMemUnSeqCount = true;
    if (this_present_loadTimeSeriesMetadataMemUnSeqCount || that_present_loadTimeSeriesMetadataMemUnSeqCount) {
      if (!(this_present_loadTimeSeriesMetadataMemUnSeqCount && that_present_loadTimeSeriesMetadataMemUnSeqCount))
        return false;
      if (this.loadTimeSeriesMetadataMemUnSeqCount != that.loadTimeSeriesMetadataMemUnSeqCount)
        return false;
    }

    boolean this_present_loadTimeSeriesMetadataAlignedDiskSeqCount = true;
    boolean that_present_loadTimeSeriesMetadataAlignedDiskSeqCount = true;
    if (this_present_loadTimeSeriesMetadataAlignedDiskSeqCount || that_present_loadTimeSeriesMetadataAlignedDiskSeqCount) {
      if (!(this_present_loadTimeSeriesMetadataAlignedDiskSeqCount && that_present_loadTimeSeriesMetadataAlignedDiskSeqCount))
        return false;
      if (this.loadTimeSeriesMetadataAlignedDiskSeqCount != that.loadTimeSeriesMetadataAlignedDiskSeqCount)
        return false;
    }

    boolean this_present_loadTimeSeriesMetadataAlignedDiskUnSeqCount = true;
    boolean that_present_loadTimeSeriesMetadataAlignedDiskUnSeqCount = true;
    if (this_present_loadTimeSeriesMetadataAlignedDiskUnSeqCount || that_present_loadTimeSeriesMetadataAlignedDiskUnSeqCount) {
      if (!(this_present_loadTimeSeriesMetadataAlignedDiskUnSeqCount && that_present_loadTimeSeriesMetadataAlignedDiskUnSeqCount))
        return false;
      if (this.loadTimeSeriesMetadataAlignedDiskUnSeqCount != that.loadTimeSeriesMetadataAlignedDiskUnSeqCount)
        return false;
    }

    boolean this_present_loadTimeSeriesMetadataAlignedMemSeqCount = true;
    boolean that_present_loadTimeSeriesMetadataAlignedMemSeqCount = true;
    if (this_present_loadTimeSeriesMetadataAlignedMemSeqCount || that_present_loadTimeSeriesMetadataAlignedMemSeqCount) {
      if (!(this_present_loadTimeSeriesMetadataAlignedMemSeqCount && that_present_loadTimeSeriesMetadataAlignedMemSeqCount))
        return false;
      if (this.loadTimeSeriesMetadataAlignedMemSeqCount != that.loadTimeSeriesMetadataAlignedMemSeqCount)
        return false;
    }

    boolean this_present_loadTimeSeriesMetadataAlignedMemUnSeqCount = true;
    boolean that_present_loadTimeSeriesMetadataAlignedMemUnSeqCount = true;
    if (this_present_loadTimeSeriesMetadataAlignedMemUnSeqCount || that_present_loadTimeSeriesMetadataAlignedMemUnSeqCount) {
      if (!(this_present_loadTimeSeriesMetadataAlignedMemUnSeqCount && that_present_loadTimeSeriesMetadataAlignedMemUnSeqCount))
        return false;
      if (this.loadTimeSeriesMetadataAlignedMemUnSeqCount != that.loadTimeSeriesMetadataAlignedMemUnSeqCount)
        return false;
    }

    boolean this_present_loadTimeSeriesMetadataDiskSeqTime = true;
    boolean that_present_loadTimeSeriesMetadataDiskSeqTime = true;
    if (this_present_loadTimeSeriesMetadataDiskSeqTime || that_present_loadTimeSeriesMetadataDiskSeqTime) {
      if (!(this_present_loadTimeSeriesMetadataDiskSeqTime && that_present_loadTimeSeriesMetadataDiskSeqTime))
        return false;
      if (this.loadTimeSeriesMetadataDiskSeqTime != that.loadTimeSeriesMetadataDiskSeqTime)
        return false;
    }

    boolean this_present_loadTimeSeriesMetadataDiskUnSeqTime = true;
    boolean that_present_loadTimeSeriesMetadataDiskUnSeqTime = true;
    if (this_present_loadTimeSeriesMetadataDiskUnSeqTime || that_present_loadTimeSeriesMetadataDiskUnSeqTime) {
      if (!(this_present_loadTimeSeriesMetadataDiskUnSeqTime && that_present_loadTimeSeriesMetadataDiskUnSeqTime))
        return false;
      if (this.loadTimeSeriesMetadataDiskUnSeqTime != that.loadTimeSeriesMetadataDiskUnSeqTime)
        return false;
    }

    boolean this_present_loadTimeSeriesMetadataMemSeqTime = true;
    boolean that_present_loadTimeSeriesMetadataMemSeqTime = true;
    if (this_present_loadTimeSeriesMetadataMemSeqTime || that_present_loadTimeSeriesMetadataMemSeqTime) {
      if (!(this_present_loadTimeSeriesMetadataMemSeqTime && that_present_loadTimeSeriesMetadataMemSeqTime))
        return false;
      if (this.loadTimeSeriesMetadataMemSeqTime != that.loadTimeSeriesMetadataMemSeqTime)
        return false;
    }

    boolean this_present_loadTimeSeriesMetadataMemUnSeqTime = true;
    boolean that_present_loadTimeSeriesMetadataMemUnSeqTime = true;
    if (this_present_loadTimeSeriesMetadataMemUnSeqTime || that_present_loadTimeSeriesMetadataMemUnSeqTime) {
      if (!(this_present_loadTimeSeriesMetadataMemUnSeqTime && that_present_loadTimeSeriesMetadataMemUnSeqTime))
        return false;
      if (this.loadTimeSeriesMetadataMemUnSeqTime != that.loadTimeSeriesMetadataMemUnSeqTime)
        return false;
    }

    boolean this_present_loadTimeSeriesMetadataAlignedDiskSeqTime = true;
    boolean that_present_loadTimeSeriesMetadataAlignedDiskSeqTime = true;
    if (this_present_loadTimeSeriesMetadataAlignedDiskSeqTime || that_present_loadTimeSeriesMetadataAlignedDiskSeqTime) {
      if (!(this_present_loadTimeSeriesMetadataAlignedDiskSeqTime && that_present_loadTimeSeriesMetadataAlignedDiskSeqTime))
        return false;
      if (this.loadTimeSeriesMetadataAlignedDiskSeqTime != that.loadTimeSeriesMetadataAlignedDiskSeqTime)
        return false;
    }

    boolean this_present_loadTimeSeriesMetadataAlignedDiskUnSeqTime = true;
    boolean that_present_loadTimeSeriesMetadataAlignedDiskUnSeqTime = true;
    if (this_present_loadTimeSeriesMetadataAlignedDiskUnSeqTime || that_present_loadTimeSeriesMetadataAlignedDiskUnSeqTime) {
      if (!(this_present_loadTimeSeriesMetadataAlignedDiskUnSeqTime && that_present_loadTimeSeriesMetadataAlignedDiskUnSeqTime))
        return false;
      if (this.loadTimeSeriesMetadataAlignedDiskUnSeqTime != that.loadTimeSeriesMetadataAlignedDiskUnSeqTime)
        return false;
    }

    boolean this_present_loadTimeSeriesMetadataAlignedMemSeqTime = true;
    boolean that_present_loadTimeSeriesMetadataAlignedMemSeqTime = true;
    if (this_present_loadTimeSeriesMetadataAlignedMemSeqTime || that_present_loadTimeSeriesMetadataAlignedMemSeqTime) {
      if (!(this_present_loadTimeSeriesMetadataAlignedMemSeqTime && that_present_loadTimeSeriesMetadataAlignedMemSeqTime))
        return false;
      if (this.loadTimeSeriesMetadataAlignedMemSeqTime != that.loadTimeSeriesMetadataAlignedMemSeqTime)
        return false;
    }

    boolean this_present_loadTimeSeriesMetadataAlignedMemUnSeqTime = true;
    boolean that_present_loadTimeSeriesMetadataAlignedMemUnSeqTime = true;
    if (this_present_loadTimeSeriesMetadataAlignedMemUnSeqTime || that_present_loadTimeSeriesMetadataAlignedMemUnSeqTime) {
      if (!(this_present_loadTimeSeriesMetadataAlignedMemUnSeqTime && that_present_loadTimeSeriesMetadataAlignedMemUnSeqTime))
        return false;
      if (this.loadTimeSeriesMetadataAlignedMemUnSeqTime != that.loadTimeSeriesMetadataAlignedMemUnSeqTime)
        return false;
    }

    boolean this_present_constructNonAlignedChunkReadersDiskCount = true;
    boolean that_present_constructNonAlignedChunkReadersDiskCount = true;
    if (this_present_constructNonAlignedChunkReadersDiskCount || that_present_constructNonAlignedChunkReadersDiskCount) {
      if (!(this_present_constructNonAlignedChunkReadersDiskCount && that_present_constructNonAlignedChunkReadersDiskCount))
        return false;
      if (this.constructNonAlignedChunkReadersDiskCount != that.constructNonAlignedChunkReadersDiskCount)
        return false;
    }

    boolean this_present_constructNonAlignedChunkReadersMemCount = true;
    boolean that_present_constructNonAlignedChunkReadersMemCount = true;
    if (this_present_constructNonAlignedChunkReadersMemCount || that_present_constructNonAlignedChunkReadersMemCount) {
      if (!(this_present_constructNonAlignedChunkReadersMemCount && that_present_constructNonAlignedChunkReadersMemCount))
        return false;
      if (this.constructNonAlignedChunkReadersMemCount != that.constructNonAlignedChunkReadersMemCount)
        return false;
    }

    boolean this_present_constructAlignedChunkReadersDiskCount = true;
    boolean that_present_constructAlignedChunkReadersDiskCount = true;
    if (this_present_constructAlignedChunkReadersDiskCount || that_present_constructAlignedChunkReadersDiskCount) {
      if (!(this_present_constructAlignedChunkReadersDiskCount && that_present_constructAlignedChunkReadersDiskCount))
        return false;
      if (this.constructAlignedChunkReadersDiskCount != that.constructAlignedChunkReadersDiskCount)
        return false;
    }

    boolean this_present_constructAlignedChunkReadersMemCount = true;
    boolean that_present_constructAlignedChunkReadersMemCount = true;
    if (this_present_constructAlignedChunkReadersMemCount || that_present_constructAlignedChunkReadersMemCount) {
      if (!(this_present_constructAlignedChunkReadersMemCount && that_present_constructAlignedChunkReadersMemCount))
        return false;
      if (this.constructAlignedChunkReadersMemCount != that.constructAlignedChunkReadersMemCount)
        return false;
    }

    boolean this_present_constructNonAlignedChunkReadersDiskTime = true;
    boolean that_present_constructNonAlignedChunkReadersDiskTime = true;
    if (this_present_constructNonAlignedChunkReadersDiskTime || that_present_constructNonAlignedChunkReadersDiskTime) {
      if (!(this_present_constructNonAlignedChunkReadersDiskTime && that_present_constructNonAlignedChunkReadersDiskTime))
        return false;
      if (this.constructNonAlignedChunkReadersDiskTime != that.constructNonAlignedChunkReadersDiskTime)
        return false;
    }

    boolean this_present_constructNonAlignedChunkReadersMemTime = true;
    boolean that_present_constructNonAlignedChunkReadersMemTime = true;
    if (this_present_constructNonAlignedChunkReadersMemTime || that_present_constructNonAlignedChunkReadersMemTime) {
      if (!(this_present_constructNonAlignedChunkReadersMemTime && that_present_constructNonAlignedChunkReadersMemTime))
        return false;
      if (this.constructNonAlignedChunkReadersMemTime != that.constructNonAlignedChunkReadersMemTime)
        return false;
    }

    boolean this_present_constructAlignedChunkReadersDiskTime = true;
    boolean that_present_constructAlignedChunkReadersDiskTime = true;
    if (this_present_constructAlignedChunkReadersDiskTime || that_present_constructAlignedChunkReadersDiskTime) {
      if (!(this_present_constructAlignedChunkReadersDiskTime && that_present_constructAlignedChunkReadersDiskTime))
        return false;
      if (this.constructAlignedChunkReadersDiskTime != that.constructAlignedChunkReadersDiskTime)
        return false;
    }

    boolean this_present_constructAlignedChunkReadersMemTime = true;
    boolean that_present_constructAlignedChunkReadersMemTime = true;
    if (this_present_constructAlignedChunkReadersMemTime || that_present_constructAlignedChunkReadersMemTime) {
      if (!(this_present_constructAlignedChunkReadersMemTime && that_present_constructAlignedChunkReadersMemTime))
        return false;
      if (this.constructAlignedChunkReadersMemTime != that.constructAlignedChunkReadersMemTime)
        return false;
    }

    boolean this_present_pageReadersDecodeAlignedDiskCount = true;
    boolean that_present_pageReadersDecodeAlignedDiskCount = true;
    if (this_present_pageReadersDecodeAlignedDiskCount || that_present_pageReadersDecodeAlignedDiskCount) {
      if (!(this_present_pageReadersDecodeAlignedDiskCount && that_present_pageReadersDecodeAlignedDiskCount))
        return false;
      if (this.pageReadersDecodeAlignedDiskCount != that.pageReadersDecodeAlignedDiskCount)
        return false;
    }

    boolean this_present_pageReadersDecodeAlignedDiskTime = true;
    boolean that_present_pageReadersDecodeAlignedDiskTime = true;
    if (this_present_pageReadersDecodeAlignedDiskTime || that_present_pageReadersDecodeAlignedDiskTime) {
      if (!(this_present_pageReadersDecodeAlignedDiskTime && that_present_pageReadersDecodeAlignedDiskTime))
        return false;
      if (this.pageReadersDecodeAlignedDiskTime != that.pageReadersDecodeAlignedDiskTime)
        return false;
    }

    boolean this_present_pageReadersDecodeAlignedMemCount = true;
    boolean that_present_pageReadersDecodeAlignedMemCount = true;
    if (this_present_pageReadersDecodeAlignedMemCount || that_present_pageReadersDecodeAlignedMemCount) {
      if (!(this_present_pageReadersDecodeAlignedMemCount && that_present_pageReadersDecodeAlignedMemCount))
        return false;
      if (this.pageReadersDecodeAlignedMemCount != that.pageReadersDecodeAlignedMemCount)
        return false;
    }

    boolean this_present_pageReadersDecodeAlignedMemTime = true;
    boolean that_present_pageReadersDecodeAlignedMemTime = true;
    if (this_present_pageReadersDecodeAlignedMemTime || that_present_pageReadersDecodeAlignedMemTime) {
      if (!(this_present_pageReadersDecodeAlignedMemTime && that_present_pageReadersDecodeAlignedMemTime))
        return false;
      if (this.pageReadersDecodeAlignedMemTime != that.pageReadersDecodeAlignedMemTime)
        return false;
    }

    boolean this_present_pageReadersDecodeNonAlignedDiskCount = true;
    boolean that_present_pageReadersDecodeNonAlignedDiskCount = true;
    if (this_present_pageReadersDecodeNonAlignedDiskCount || that_present_pageReadersDecodeNonAlignedDiskCount) {
      if (!(this_present_pageReadersDecodeNonAlignedDiskCount && that_present_pageReadersDecodeNonAlignedDiskCount))
        return false;
      if (this.pageReadersDecodeNonAlignedDiskCount != that.pageReadersDecodeNonAlignedDiskCount)
        return false;
    }

    boolean this_present_pageReadersDecodeNonAlignedDiskTime = true;
    boolean that_present_pageReadersDecodeNonAlignedDiskTime = true;
    if (this_present_pageReadersDecodeNonAlignedDiskTime || that_present_pageReadersDecodeNonAlignedDiskTime) {
      if (!(this_present_pageReadersDecodeNonAlignedDiskTime && that_present_pageReadersDecodeNonAlignedDiskTime))
        return false;
      if (this.pageReadersDecodeNonAlignedDiskTime != that.pageReadersDecodeNonAlignedDiskTime)
        return false;
    }

    boolean this_present_pageReadersDecodeNonAlignedMemCount = true;
    boolean that_present_pageReadersDecodeNonAlignedMemCount = true;
    if (this_present_pageReadersDecodeNonAlignedMemCount || that_present_pageReadersDecodeNonAlignedMemCount) {
      if (!(this_present_pageReadersDecodeNonAlignedMemCount && that_present_pageReadersDecodeNonAlignedMemCount))
        return false;
      if (this.pageReadersDecodeNonAlignedMemCount != that.pageReadersDecodeNonAlignedMemCount)
        return false;
    }

    boolean this_present_pageReadersDecodeNonAlignedMemTime = true;
    boolean that_present_pageReadersDecodeNonAlignedMemTime = true;
    if (this_present_pageReadersDecodeNonAlignedMemTime || that_present_pageReadersDecodeNonAlignedMemTime) {
      if (!(this_present_pageReadersDecodeNonAlignedMemTime && that_present_pageReadersDecodeNonAlignedMemTime))
        return false;
      if (this.pageReadersDecodeNonAlignedMemTime != that.pageReadersDecodeNonAlignedMemTime)
        return false;
    }

    boolean this_present_pageReaderMaxUsedMemorySize = true;
    boolean that_present_pageReaderMaxUsedMemorySize = true;
    if (this_present_pageReaderMaxUsedMemorySize || that_present_pageReaderMaxUsedMemorySize) {
      if (!(this_present_pageReaderMaxUsedMemorySize && that_present_pageReaderMaxUsedMemorySize))
        return false;
      if (this.pageReaderMaxUsedMemorySize != that.pageReaderMaxUsedMemorySize)
        return false;
    }

    boolean this_present_alignedTimeSeriesMetadataModificationCount = true;
    boolean that_present_alignedTimeSeriesMetadataModificationCount = true;
    if (this_present_alignedTimeSeriesMetadataModificationCount || that_present_alignedTimeSeriesMetadataModificationCount) {
      if (!(this_present_alignedTimeSeriesMetadataModificationCount && that_present_alignedTimeSeriesMetadataModificationCount))
        return false;
      if (this.alignedTimeSeriesMetadataModificationCount != that.alignedTimeSeriesMetadataModificationCount)
        return false;
    }

    boolean this_present_alignedTimeSeriesMetadataModificationTime = true;
    boolean that_present_alignedTimeSeriesMetadataModificationTime = true;
    if (this_present_alignedTimeSeriesMetadataModificationTime || that_present_alignedTimeSeriesMetadataModificationTime) {
      if (!(this_present_alignedTimeSeriesMetadataModificationTime && that_present_alignedTimeSeriesMetadataModificationTime))
        return false;
      if (this.alignedTimeSeriesMetadataModificationTime != that.alignedTimeSeriesMetadataModificationTime)
        return false;
    }

    boolean this_present_nonAlignedTimeSeriesMetadataModificationCount = true;
    boolean that_present_nonAlignedTimeSeriesMetadataModificationCount = true;
    if (this_present_nonAlignedTimeSeriesMetadataModificationCount || that_present_nonAlignedTimeSeriesMetadataModificationCount) {
      if (!(this_present_nonAlignedTimeSeriesMetadataModificationCount && that_present_nonAlignedTimeSeriesMetadataModificationCount))
        return false;
      if (this.nonAlignedTimeSeriesMetadataModificationCount != that.nonAlignedTimeSeriesMetadataModificationCount)
        return false;
    }

    boolean this_present_nonAlignedTimeSeriesMetadataModificationTime = true;
    boolean that_present_nonAlignedTimeSeriesMetadataModificationTime = true;
    if (this_present_nonAlignedTimeSeriesMetadataModificationTime || that_present_nonAlignedTimeSeriesMetadataModificationTime) {
      if (!(this_present_nonAlignedTimeSeriesMetadataModificationTime && that_present_nonAlignedTimeSeriesMetadataModificationTime))
        return false;
      if (this.nonAlignedTimeSeriesMetadataModificationTime != that.nonAlignedTimeSeriesMetadataModificationTime)
        return false;
    }

    return true;
  }

  @Override
  public int hashCode() {
    int hashCode = 1;

    hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(loadTimeSeriesMetadataDiskSeqCount);

    hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(loadTimeSeriesMetadataDiskUnSeqCount);

    hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(loadTimeSeriesMetadataMemSeqCount);

    hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(loadTimeSeriesMetadataMemUnSeqCount);

    hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(loadTimeSeriesMetadataAlignedDiskSeqCount);

    hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(loadTimeSeriesMetadataAlignedDiskUnSeqCount);

    hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(loadTimeSeriesMetadataAlignedMemSeqCount);

    hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(loadTimeSeriesMetadataAlignedMemUnSeqCount);

    hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(loadTimeSeriesMetadataDiskSeqTime);

    hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(loadTimeSeriesMetadataDiskUnSeqTime);

    hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(loadTimeSeriesMetadataMemSeqTime);

    hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(loadTimeSeriesMetadataMemUnSeqTime);

    hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(loadTimeSeriesMetadataAlignedDiskSeqTime);

    hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(loadTimeSeriesMetadataAlignedDiskUnSeqTime);

    hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(loadTimeSeriesMetadataAlignedMemSeqTime);

    hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(loadTimeSeriesMetadataAlignedMemUnSeqTime);

    hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(constructNonAlignedChunkReadersDiskCount);

    hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(constructNonAlignedChunkReadersMemCount);

    hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(constructAlignedChunkReadersDiskCount);

    hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(constructAlignedChunkReadersMemCount);

    hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(constructNonAlignedChunkReadersDiskTime);

    hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(constructNonAlignedChunkReadersMemTime);

    hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(constructAlignedChunkReadersDiskTime);

    hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(constructAlignedChunkReadersMemTime);

    hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(pageReadersDecodeAlignedDiskCount);

    hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(pageReadersDecodeAlignedDiskTime);

    hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(pageReadersDecodeAlignedMemCount);

    hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(pageReadersDecodeAlignedMemTime);

    hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(pageReadersDecodeNonAlignedDiskCount);

    hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(pageReadersDecodeNonAlignedDiskTime);

    hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(pageReadersDecodeNonAlignedMemCount);

    hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(pageReadersDecodeNonAlignedMemTime);

    hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(pageReaderMaxUsedMemorySize);

    hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(alignedTimeSeriesMetadataModificationCount);

    hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(alignedTimeSeriesMetadataModificationTime);

    hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(nonAlignedTimeSeriesMetadataModificationCount);

    hashCode = hashCode * 8191 + org.apache.thrift.TBaseHelper.hashCode(nonAlignedTimeSeriesMetadataModificationTime);

    return hashCode;
  }

  @Override
  public int compareTo(TQueryStatistics other) {
    if (!getClass().equals(other.getClass())) {
      return getClass().getName().compareTo(other.getClass().getName());
    }

    int lastComparison = 0;

    lastComparison = java.lang.Boolean.compare(isSetLoadTimeSeriesMetadataDiskSeqCount(), other.isSetLoadTimeSeriesMetadataDiskSeqCount());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetLoadTimeSeriesMetadataDiskSeqCount()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.loadTimeSeriesMetadataDiskSeqCount, other.loadTimeSeriesMetadataDiskSeqCount);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.compare(isSetLoadTimeSeriesMetadataDiskUnSeqCount(), other.isSetLoadTimeSeriesMetadataDiskUnSeqCount());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetLoadTimeSeriesMetadataDiskUnSeqCount()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.loadTimeSeriesMetadataDiskUnSeqCount, other.loadTimeSeriesMetadataDiskUnSeqCount);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.compare(isSetLoadTimeSeriesMetadataMemSeqCount(), other.isSetLoadTimeSeriesMetadataMemSeqCount());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetLoadTimeSeriesMetadataMemSeqCount()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.loadTimeSeriesMetadataMemSeqCount, other.loadTimeSeriesMetadataMemSeqCount);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.compare(isSetLoadTimeSeriesMetadataMemUnSeqCount(), other.isSetLoadTimeSeriesMetadataMemUnSeqCount());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetLoadTimeSeriesMetadataMemUnSeqCount()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.loadTimeSeriesMetadataMemUnSeqCount, other.loadTimeSeriesMetadataMemUnSeqCount);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.compare(isSetLoadTimeSeriesMetadataAlignedDiskSeqCount(), other.isSetLoadTimeSeriesMetadataAlignedDiskSeqCount());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetLoadTimeSeriesMetadataAlignedDiskSeqCount()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.loadTimeSeriesMetadataAlignedDiskSeqCount, other.loadTimeSeriesMetadataAlignedDiskSeqCount);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.compare(isSetLoadTimeSeriesMetadataAlignedDiskUnSeqCount(), other.isSetLoadTimeSeriesMetadataAlignedDiskUnSeqCount());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetLoadTimeSeriesMetadataAlignedDiskUnSeqCount()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.loadTimeSeriesMetadataAlignedDiskUnSeqCount, other.loadTimeSeriesMetadataAlignedDiskUnSeqCount);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.compare(isSetLoadTimeSeriesMetadataAlignedMemSeqCount(), other.isSetLoadTimeSeriesMetadataAlignedMemSeqCount());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetLoadTimeSeriesMetadataAlignedMemSeqCount()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.loadTimeSeriesMetadataAlignedMemSeqCount, other.loadTimeSeriesMetadataAlignedMemSeqCount);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.compare(isSetLoadTimeSeriesMetadataAlignedMemUnSeqCount(), other.isSetLoadTimeSeriesMetadataAlignedMemUnSeqCount());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetLoadTimeSeriesMetadataAlignedMemUnSeqCount()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.loadTimeSeriesMetadataAlignedMemUnSeqCount, other.loadTimeSeriesMetadataAlignedMemUnSeqCount);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.compare(isSetLoadTimeSeriesMetadataDiskSeqTime(), other.isSetLoadTimeSeriesMetadataDiskSeqTime());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetLoadTimeSeriesMetadataDiskSeqTime()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.loadTimeSeriesMetadataDiskSeqTime, other.loadTimeSeriesMetadataDiskSeqTime);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.compare(isSetLoadTimeSeriesMetadataDiskUnSeqTime(), other.isSetLoadTimeSeriesMetadataDiskUnSeqTime());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetLoadTimeSeriesMetadataDiskUnSeqTime()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.loadTimeSeriesMetadataDiskUnSeqTime, other.loadTimeSeriesMetadataDiskUnSeqTime);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.compare(isSetLoadTimeSeriesMetadataMemSeqTime(), other.isSetLoadTimeSeriesMetadataMemSeqTime());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetLoadTimeSeriesMetadataMemSeqTime()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.loadTimeSeriesMetadataMemSeqTime, other.loadTimeSeriesMetadataMemSeqTime);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.compare(isSetLoadTimeSeriesMetadataMemUnSeqTime(), other.isSetLoadTimeSeriesMetadataMemUnSeqTime());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetLoadTimeSeriesMetadataMemUnSeqTime()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.loadTimeSeriesMetadataMemUnSeqTime, other.loadTimeSeriesMetadataMemUnSeqTime);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.compare(isSetLoadTimeSeriesMetadataAlignedDiskSeqTime(), other.isSetLoadTimeSeriesMetadataAlignedDiskSeqTime());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetLoadTimeSeriesMetadataAlignedDiskSeqTime()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.loadTimeSeriesMetadataAlignedDiskSeqTime, other.loadTimeSeriesMetadataAlignedDiskSeqTime);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.compare(isSetLoadTimeSeriesMetadataAlignedDiskUnSeqTime(), other.isSetLoadTimeSeriesMetadataAlignedDiskUnSeqTime());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetLoadTimeSeriesMetadataAlignedDiskUnSeqTime()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.loadTimeSeriesMetadataAlignedDiskUnSeqTime, other.loadTimeSeriesMetadataAlignedDiskUnSeqTime);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.compare(isSetLoadTimeSeriesMetadataAlignedMemSeqTime(), other.isSetLoadTimeSeriesMetadataAlignedMemSeqTime());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetLoadTimeSeriesMetadataAlignedMemSeqTime()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.loadTimeSeriesMetadataAlignedMemSeqTime, other.loadTimeSeriesMetadataAlignedMemSeqTime);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.compare(isSetLoadTimeSeriesMetadataAlignedMemUnSeqTime(), other.isSetLoadTimeSeriesMetadataAlignedMemUnSeqTime());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetLoadTimeSeriesMetadataAlignedMemUnSeqTime()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.loadTimeSeriesMetadataAlignedMemUnSeqTime, other.loadTimeSeriesMetadataAlignedMemUnSeqTime);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.compare(isSetConstructNonAlignedChunkReadersDiskCount(), other.isSetConstructNonAlignedChunkReadersDiskCount());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetConstructNonAlignedChunkReadersDiskCount()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.constructNonAlignedChunkReadersDiskCount, other.constructNonAlignedChunkReadersDiskCount);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.compare(isSetConstructNonAlignedChunkReadersMemCount(), other.isSetConstructNonAlignedChunkReadersMemCount());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetConstructNonAlignedChunkReadersMemCount()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.constructNonAlignedChunkReadersMemCount, other.constructNonAlignedChunkReadersMemCount);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.compare(isSetConstructAlignedChunkReadersDiskCount(), other.isSetConstructAlignedChunkReadersDiskCount());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetConstructAlignedChunkReadersDiskCount()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.constructAlignedChunkReadersDiskCount, other.constructAlignedChunkReadersDiskCount);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.compare(isSetConstructAlignedChunkReadersMemCount(), other.isSetConstructAlignedChunkReadersMemCount());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetConstructAlignedChunkReadersMemCount()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.constructAlignedChunkReadersMemCount, other.constructAlignedChunkReadersMemCount);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.compare(isSetConstructNonAlignedChunkReadersDiskTime(), other.isSetConstructNonAlignedChunkReadersDiskTime());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetConstructNonAlignedChunkReadersDiskTime()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.constructNonAlignedChunkReadersDiskTime, other.constructNonAlignedChunkReadersDiskTime);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.compare(isSetConstructNonAlignedChunkReadersMemTime(), other.isSetConstructNonAlignedChunkReadersMemTime());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetConstructNonAlignedChunkReadersMemTime()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.constructNonAlignedChunkReadersMemTime, other.constructNonAlignedChunkReadersMemTime);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.compare(isSetConstructAlignedChunkReadersDiskTime(), other.isSetConstructAlignedChunkReadersDiskTime());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetConstructAlignedChunkReadersDiskTime()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.constructAlignedChunkReadersDiskTime, other.constructAlignedChunkReadersDiskTime);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.compare(isSetConstructAlignedChunkReadersMemTime(), other.isSetConstructAlignedChunkReadersMemTime());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetConstructAlignedChunkReadersMemTime()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.constructAlignedChunkReadersMemTime, other.constructAlignedChunkReadersMemTime);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.compare(isSetPageReadersDecodeAlignedDiskCount(), other.isSetPageReadersDecodeAlignedDiskCount());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetPageReadersDecodeAlignedDiskCount()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pageReadersDecodeAlignedDiskCount, other.pageReadersDecodeAlignedDiskCount);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.compare(isSetPageReadersDecodeAlignedDiskTime(), other.isSetPageReadersDecodeAlignedDiskTime());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetPageReadersDecodeAlignedDiskTime()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pageReadersDecodeAlignedDiskTime, other.pageReadersDecodeAlignedDiskTime);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.compare(isSetPageReadersDecodeAlignedMemCount(), other.isSetPageReadersDecodeAlignedMemCount());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetPageReadersDecodeAlignedMemCount()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pageReadersDecodeAlignedMemCount, other.pageReadersDecodeAlignedMemCount);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.compare(isSetPageReadersDecodeAlignedMemTime(), other.isSetPageReadersDecodeAlignedMemTime());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetPageReadersDecodeAlignedMemTime()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pageReadersDecodeAlignedMemTime, other.pageReadersDecodeAlignedMemTime);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.compare(isSetPageReadersDecodeNonAlignedDiskCount(), other.isSetPageReadersDecodeNonAlignedDiskCount());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetPageReadersDecodeNonAlignedDiskCount()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pageReadersDecodeNonAlignedDiskCount, other.pageReadersDecodeNonAlignedDiskCount);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.compare(isSetPageReadersDecodeNonAlignedDiskTime(), other.isSetPageReadersDecodeNonAlignedDiskTime());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetPageReadersDecodeNonAlignedDiskTime()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pageReadersDecodeNonAlignedDiskTime, other.pageReadersDecodeNonAlignedDiskTime);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.compare(isSetPageReadersDecodeNonAlignedMemCount(), other.isSetPageReadersDecodeNonAlignedMemCount());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetPageReadersDecodeNonAlignedMemCount()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pageReadersDecodeNonAlignedMemCount, other.pageReadersDecodeNonAlignedMemCount);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.compare(isSetPageReadersDecodeNonAlignedMemTime(), other.isSetPageReadersDecodeNonAlignedMemTime());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetPageReadersDecodeNonAlignedMemTime()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pageReadersDecodeNonAlignedMemTime, other.pageReadersDecodeNonAlignedMemTime);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.compare(isSetPageReaderMaxUsedMemorySize(), other.isSetPageReaderMaxUsedMemorySize());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetPageReaderMaxUsedMemorySize()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pageReaderMaxUsedMemorySize, other.pageReaderMaxUsedMemorySize);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.compare(isSetAlignedTimeSeriesMetadataModificationCount(), other.isSetAlignedTimeSeriesMetadataModificationCount());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetAlignedTimeSeriesMetadataModificationCount()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.alignedTimeSeriesMetadataModificationCount, other.alignedTimeSeriesMetadataModificationCount);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.compare(isSetAlignedTimeSeriesMetadataModificationTime(), other.isSetAlignedTimeSeriesMetadataModificationTime());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetAlignedTimeSeriesMetadataModificationTime()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.alignedTimeSeriesMetadataModificationTime, other.alignedTimeSeriesMetadataModificationTime);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.compare(isSetNonAlignedTimeSeriesMetadataModificationCount(), other.isSetNonAlignedTimeSeriesMetadataModificationCount());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetNonAlignedTimeSeriesMetadataModificationCount()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.nonAlignedTimeSeriesMetadataModificationCount, other.nonAlignedTimeSeriesMetadataModificationCount);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.compare(isSetNonAlignedTimeSeriesMetadataModificationTime(), other.isSetNonAlignedTimeSeriesMetadataModificationTime());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetNonAlignedTimeSeriesMetadataModificationTime()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.nonAlignedTimeSeriesMetadataModificationTime, other.nonAlignedTimeSeriesMetadataModificationTime);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    return 0;
  }

  @org.apache.thrift.annotation.Nullable
  public _Fields fieldForId(int fieldId) {
    return _Fields.findByThriftId(fieldId);
  }

  public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
    scheme(iprot).read(iprot, this);
  }

  public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
    scheme(oprot).write(oprot, this);
  }

  @Override
  public java.lang.String toString() {
    java.lang.StringBuilder sb = new java.lang.StringBuilder("TQueryStatistics(");
    boolean first = true;

    sb.append("loadTimeSeriesMetadataDiskSeqCount:");
    sb.append(this.loadTimeSeriesMetadataDiskSeqCount);
    first = false;
    if (!first) sb.append(", ");
    sb.append("loadTimeSeriesMetadataDiskUnSeqCount:");
    sb.append(this.loadTimeSeriesMetadataDiskUnSeqCount);
    first = false;
    if (!first) sb.append(", ");
    sb.append("loadTimeSeriesMetadataMemSeqCount:");
    sb.append(this.loadTimeSeriesMetadataMemSeqCount);
    first = false;
    if (!first) sb.append(", ");
    sb.append("loadTimeSeriesMetadataMemUnSeqCount:");
    sb.append(this.loadTimeSeriesMetadataMemUnSeqCount);
    first = false;
    if (!first) sb.append(", ");
    sb.append("loadTimeSeriesMetadataAlignedDiskSeqCount:");
    sb.append(this.loadTimeSeriesMetadataAlignedDiskSeqCount);
    first = false;
    if (!first) sb.append(", ");
    sb.append("loadTimeSeriesMetadataAlignedDiskUnSeqCount:");
    sb.append(this.loadTimeSeriesMetadataAlignedDiskUnSeqCount);
    first = false;
    if (!first) sb.append(", ");
    sb.append("loadTimeSeriesMetadataAlignedMemSeqCount:");
    sb.append(this.loadTimeSeriesMetadataAlignedMemSeqCount);
    first = false;
    if (!first) sb.append(", ");
    sb.append("loadTimeSeriesMetadataAlignedMemUnSeqCount:");
    sb.append(this.loadTimeSeriesMetadataAlignedMemUnSeqCount);
    first = false;
    if (!first) sb.append(", ");
    sb.append("loadTimeSeriesMetadataDiskSeqTime:");
    sb.append(this.loadTimeSeriesMetadataDiskSeqTime);
    first = false;
    if (!first) sb.append(", ");
    sb.append("loadTimeSeriesMetadataDiskUnSeqTime:");
    sb.append(this.loadTimeSeriesMetadataDiskUnSeqTime);
    first = false;
    if (!first) sb.append(", ");
    sb.append("loadTimeSeriesMetadataMemSeqTime:");
    sb.append(this.loadTimeSeriesMetadataMemSeqTime);
    first = false;
    if (!first) sb.append(", ");
    sb.append("loadTimeSeriesMetadataMemUnSeqTime:");
    sb.append(this.loadTimeSeriesMetadataMemUnSeqTime);
    first = false;
    if (!first) sb.append(", ");
    sb.append("loadTimeSeriesMetadataAlignedDiskSeqTime:");
    sb.append(this.loadTimeSeriesMetadataAlignedDiskSeqTime);
    first = false;
    if (!first) sb.append(", ");
    sb.append("loadTimeSeriesMetadataAlignedDiskUnSeqTime:");
    sb.append(this.loadTimeSeriesMetadataAlignedDiskUnSeqTime);
    first = false;
    if (!first) sb.append(", ");
    sb.append("loadTimeSeriesMetadataAlignedMemSeqTime:");
    sb.append(this.loadTimeSeriesMetadataAlignedMemSeqTime);
    first = false;
    if (!first) sb.append(", ");
    sb.append("loadTimeSeriesMetadataAlignedMemUnSeqTime:");
    sb.append(this.loadTimeSeriesMetadataAlignedMemUnSeqTime);
    first = false;
    if (!first) sb.append(", ");
    sb.append("constructNonAlignedChunkReadersDiskCount:");
    sb.append(this.constructNonAlignedChunkReadersDiskCount);
    first = false;
    if (!first) sb.append(", ");
    sb.append("constructNonAlignedChunkReadersMemCount:");
    sb.append(this.constructNonAlignedChunkReadersMemCount);
    first = false;
    if (!first) sb.append(", ");
    sb.append("constructAlignedChunkReadersDiskCount:");
    sb.append(this.constructAlignedChunkReadersDiskCount);
    first = false;
    if (!first) sb.append(", ");
    sb.append("constructAlignedChunkReadersMemCount:");
    sb.append(this.constructAlignedChunkReadersMemCount);
    first = false;
    if (!first) sb.append(", ");
    sb.append("constructNonAlignedChunkReadersDiskTime:");
    sb.append(this.constructNonAlignedChunkReadersDiskTime);
    first = false;
    if (!first) sb.append(", ");
    sb.append("constructNonAlignedChunkReadersMemTime:");
    sb.append(this.constructNonAlignedChunkReadersMemTime);
    first = false;
    if (!first) sb.append(", ");
    sb.append("constructAlignedChunkReadersDiskTime:");
    sb.append(this.constructAlignedChunkReadersDiskTime);
    first = false;
    if (!first) sb.append(", ");
    sb.append("constructAlignedChunkReadersMemTime:");
    sb.append(this.constructAlignedChunkReadersMemTime);
    first = false;
    if (!first) sb.append(", ");
    sb.append("pageReadersDecodeAlignedDiskCount:");
    sb.append(this.pageReadersDecodeAlignedDiskCount);
    first = false;
    if (!first) sb.append(", ");
    sb.append("pageReadersDecodeAlignedDiskTime:");
    sb.append(this.pageReadersDecodeAlignedDiskTime);
    first = false;
    if (!first) sb.append(", ");
    sb.append("pageReadersDecodeAlignedMemCount:");
    sb.append(this.pageReadersDecodeAlignedMemCount);
    first = false;
    if (!first) sb.append(", ");
    sb.append("pageReadersDecodeAlignedMemTime:");
    sb.append(this.pageReadersDecodeAlignedMemTime);
    first = false;
    if (!first) sb.append(", ");
    sb.append("pageReadersDecodeNonAlignedDiskCount:");
    sb.append(this.pageReadersDecodeNonAlignedDiskCount);
    first = false;
    if (!first) sb.append(", ");
    sb.append("pageReadersDecodeNonAlignedDiskTime:");
    sb.append(this.pageReadersDecodeNonAlignedDiskTime);
    first = false;
    if (!first) sb.append(", ");
    sb.append("pageReadersDecodeNonAlignedMemCount:");
    sb.append(this.pageReadersDecodeNonAlignedMemCount);
    first = false;
    if (!first) sb.append(", ");
    sb.append("pageReadersDecodeNonAlignedMemTime:");
    sb.append(this.pageReadersDecodeNonAlignedMemTime);
    first = false;
    if (!first) sb.append(", ");
    sb.append("pageReaderMaxUsedMemorySize:");
    sb.append(this.pageReaderMaxUsedMemorySize);
    first = false;
    if (!first) sb.append(", ");
    sb.append("alignedTimeSeriesMetadataModificationCount:");
    sb.append(this.alignedTimeSeriesMetadataModificationCount);
    first = false;
    if (!first) sb.append(", ");
    sb.append("alignedTimeSeriesMetadataModificationTime:");
    sb.append(this.alignedTimeSeriesMetadataModificationTime);
    first = false;
    if (!first) sb.append(", ");
    sb.append("nonAlignedTimeSeriesMetadataModificationCount:");
    sb.append(this.nonAlignedTimeSeriesMetadataModificationCount);
    first = false;
    if (!first) sb.append(", ");
    sb.append("nonAlignedTimeSeriesMetadataModificationTime:");
    sb.append(this.nonAlignedTimeSeriesMetadataModificationTime);
    first = false;
    sb.append(")");
    return sb.toString();
  }

  public void validate() throws org.apache.thrift.TException {
    // check for required fields
    // check for sub-struct validity
  }

  private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
    try {
      write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
    } catch (org.apache.thrift.TException te) {
      throw new java.io.IOException(te);
    }
  }

  private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException {
    try {
      // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
      __isset_bitfield = 0;
      read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
    } catch (org.apache.thrift.TException te) {
      throw new java.io.IOException(te);
    }
  }

  private static class TQueryStatisticsStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
    public TQueryStatisticsStandardScheme getScheme() {
      return new TQueryStatisticsStandardScheme();
    }
  }

  private static class TQueryStatisticsStandardScheme extends org.apache.thrift.scheme.StandardScheme {

    public void read(org.apache.thrift.protocol.TProtocol iprot, TQueryStatistics struct) throws org.apache.thrift.TException {
      org.apache.thrift.protocol.TField schemeField;
      iprot.readStructBegin();
      while (true)
      {
        schemeField = iprot.readFieldBegin();
        if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
          break;
        }
        switch (schemeField.id) {
          case 1: // LOAD_TIME_SERIES_METADATA_DISK_SEQ_COUNT
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.loadTimeSeriesMetadataDiskSeqCount = iprot.readI64();
              struct.setLoadTimeSeriesMetadataDiskSeqCountIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 2: // LOAD_TIME_SERIES_METADATA_DISK_UN_SEQ_COUNT
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.loadTimeSeriesMetadataDiskUnSeqCount = iprot.readI64();
              struct.setLoadTimeSeriesMetadataDiskUnSeqCountIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 3: // LOAD_TIME_SERIES_METADATA_MEM_SEQ_COUNT
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.loadTimeSeriesMetadataMemSeqCount = iprot.readI64();
              struct.setLoadTimeSeriesMetadataMemSeqCountIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 4: // LOAD_TIME_SERIES_METADATA_MEM_UN_SEQ_COUNT
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.loadTimeSeriesMetadataMemUnSeqCount = iprot.readI64();
              struct.setLoadTimeSeriesMetadataMemUnSeqCountIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 5: // LOAD_TIME_SERIES_METADATA_ALIGNED_DISK_SEQ_COUNT
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.loadTimeSeriesMetadataAlignedDiskSeqCount = iprot.readI64();
              struct.setLoadTimeSeriesMetadataAlignedDiskSeqCountIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 6: // LOAD_TIME_SERIES_METADATA_ALIGNED_DISK_UN_SEQ_COUNT
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.loadTimeSeriesMetadataAlignedDiskUnSeqCount = iprot.readI64();
              struct.setLoadTimeSeriesMetadataAlignedDiskUnSeqCountIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 7: // LOAD_TIME_SERIES_METADATA_ALIGNED_MEM_SEQ_COUNT
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.loadTimeSeriesMetadataAlignedMemSeqCount = iprot.readI64();
              struct.setLoadTimeSeriesMetadataAlignedMemSeqCountIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 8: // LOAD_TIME_SERIES_METADATA_ALIGNED_MEM_UN_SEQ_COUNT
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.loadTimeSeriesMetadataAlignedMemUnSeqCount = iprot.readI64();
              struct.setLoadTimeSeriesMetadataAlignedMemUnSeqCountIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 9: // LOAD_TIME_SERIES_METADATA_DISK_SEQ_TIME
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.loadTimeSeriesMetadataDiskSeqTime = iprot.readI64();
              struct.setLoadTimeSeriesMetadataDiskSeqTimeIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 10: // LOAD_TIME_SERIES_METADATA_DISK_UN_SEQ_TIME
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.loadTimeSeriesMetadataDiskUnSeqTime = iprot.readI64();
              struct.setLoadTimeSeriesMetadataDiskUnSeqTimeIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 11: // LOAD_TIME_SERIES_METADATA_MEM_SEQ_TIME
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.loadTimeSeriesMetadataMemSeqTime = iprot.readI64();
              struct.setLoadTimeSeriesMetadataMemSeqTimeIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 12: // LOAD_TIME_SERIES_METADATA_MEM_UN_SEQ_TIME
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.loadTimeSeriesMetadataMemUnSeqTime = iprot.readI64();
              struct.setLoadTimeSeriesMetadataMemUnSeqTimeIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 13: // LOAD_TIME_SERIES_METADATA_ALIGNED_DISK_SEQ_TIME
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.loadTimeSeriesMetadataAlignedDiskSeqTime = iprot.readI64();
              struct.setLoadTimeSeriesMetadataAlignedDiskSeqTimeIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 14: // LOAD_TIME_SERIES_METADATA_ALIGNED_DISK_UN_SEQ_TIME
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.loadTimeSeriesMetadataAlignedDiskUnSeqTime = iprot.readI64();
              struct.setLoadTimeSeriesMetadataAlignedDiskUnSeqTimeIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 15: // LOAD_TIME_SERIES_METADATA_ALIGNED_MEM_SEQ_TIME
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.loadTimeSeriesMetadataAlignedMemSeqTime = iprot.readI64();
              struct.setLoadTimeSeriesMetadataAlignedMemSeqTimeIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 16: // LOAD_TIME_SERIES_METADATA_ALIGNED_MEM_UN_SEQ_TIME
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.loadTimeSeriesMetadataAlignedMemUnSeqTime = iprot.readI64();
              struct.setLoadTimeSeriesMetadataAlignedMemUnSeqTimeIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 17: // CONSTRUCT_NON_ALIGNED_CHUNK_READERS_DISK_COUNT
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.constructNonAlignedChunkReadersDiskCount = iprot.readI64();
              struct.setConstructNonAlignedChunkReadersDiskCountIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 18: // CONSTRUCT_NON_ALIGNED_CHUNK_READERS_MEM_COUNT
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.constructNonAlignedChunkReadersMemCount = iprot.readI64();
              struct.setConstructNonAlignedChunkReadersMemCountIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 19: // CONSTRUCT_ALIGNED_CHUNK_READERS_DISK_COUNT
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.constructAlignedChunkReadersDiskCount = iprot.readI64();
              struct.setConstructAlignedChunkReadersDiskCountIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 20: // CONSTRUCT_ALIGNED_CHUNK_READERS_MEM_COUNT
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.constructAlignedChunkReadersMemCount = iprot.readI64();
              struct.setConstructAlignedChunkReadersMemCountIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 21: // CONSTRUCT_NON_ALIGNED_CHUNK_READERS_DISK_TIME
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.constructNonAlignedChunkReadersDiskTime = iprot.readI64();
              struct.setConstructNonAlignedChunkReadersDiskTimeIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 22: // CONSTRUCT_NON_ALIGNED_CHUNK_READERS_MEM_TIME
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.constructNonAlignedChunkReadersMemTime = iprot.readI64();
              struct.setConstructNonAlignedChunkReadersMemTimeIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 23: // CONSTRUCT_ALIGNED_CHUNK_READERS_DISK_TIME
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.constructAlignedChunkReadersDiskTime = iprot.readI64();
              struct.setConstructAlignedChunkReadersDiskTimeIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 24: // CONSTRUCT_ALIGNED_CHUNK_READERS_MEM_TIME
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.constructAlignedChunkReadersMemTime = iprot.readI64();
              struct.setConstructAlignedChunkReadersMemTimeIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 25: // PAGE_READERS_DECODE_ALIGNED_DISK_COUNT
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.pageReadersDecodeAlignedDiskCount = iprot.readI64();
              struct.setPageReadersDecodeAlignedDiskCountIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 26: // PAGE_READERS_DECODE_ALIGNED_DISK_TIME
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.pageReadersDecodeAlignedDiskTime = iprot.readI64();
              struct.setPageReadersDecodeAlignedDiskTimeIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 27: // PAGE_READERS_DECODE_ALIGNED_MEM_COUNT
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.pageReadersDecodeAlignedMemCount = iprot.readI64();
              struct.setPageReadersDecodeAlignedMemCountIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 28: // PAGE_READERS_DECODE_ALIGNED_MEM_TIME
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.pageReadersDecodeAlignedMemTime = iprot.readI64();
              struct.setPageReadersDecodeAlignedMemTimeIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 29: // PAGE_READERS_DECODE_NON_ALIGNED_DISK_COUNT
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.pageReadersDecodeNonAlignedDiskCount = iprot.readI64();
              struct.setPageReadersDecodeNonAlignedDiskCountIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 30: // PAGE_READERS_DECODE_NON_ALIGNED_DISK_TIME
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.pageReadersDecodeNonAlignedDiskTime = iprot.readI64();
              struct.setPageReadersDecodeNonAlignedDiskTimeIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 31: // PAGE_READERS_DECODE_NON_ALIGNED_MEM_COUNT
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.pageReadersDecodeNonAlignedMemCount = iprot.readI64();
              struct.setPageReadersDecodeNonAlignedMemCountIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 32: // PAGE_READERS_DECODE_NON_ALIGNED_MEM_TIME
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.pageReadersDecodeNonAlignedMemTime = iprot.readI64();
              struct.setPageReadersDecodeNonAlignedMemTimeIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 33: // PAGE_READER_MAX_USED_MEMORY_SIZE
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.pageReaderMaxUsedMemorySize = iprot.readI64();
              struct.setPageReaderMaxUsedMemorySizeIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 34: // ALIGNED_TIME_SERIES_METADATA_MODIFICATION_COUNT
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.alignedTimeSeriesMetadataModificationCount = iprot.readI64();
              struct.setAlignedTimeSeriesMetadataModificationCountIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 35: // ALIGNED_TIME_SERIES_METADATA_MODIFICATION_TIME
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.alignedTimeSeriesMetadataModificationTime = iprot.readI64();
              struct.setAlignedTimeSeriesMetadataModificationTimeIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 36: // NON_ALIGNED_TIME_SERIES_METADATA_MODIFICATION_COUNT
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.nonAlignedTimeSeriesMetadataModificationCount = iprot.readI64();
              struct.setNonAlignedTimeSeriesMetadataModificationCountIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 37: // NON_ALIGNED_TIME_SERIES_METADATA_MODIFICATION_TIME
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.nonAlignedTimeSeriesMetadataModificationTime = iprot.readI64();
              struct.setNonAlignedTimeSeriesMetadataModificationTimeIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          default:
            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
        }
        iprot.readFieldEnd();
      }
      iprot.readStructEnd();

      // check for required fields of primitive type, which can't be checked in the validate method
      struct.validate();
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot, TQueryStatistics struct) throws org.apache.thrift.TException {
      struct.validate();

      oprot.writeStructBegin(STRUCT_DESC);
      oprot.writeFieldBegin(LOAD_TIME_SERIES_METADATA_DISK_SEQ_COUNT_FIELD_DESC);
      oprot.writeI64(struct.loadTimeSeriesMetadataDiskSeqCount);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(LOAD_TIME_SERIES_METADATA_DISK_UN_SEQ_COUNT_FIELD_DESC);
      oprot.writeI64(struct.loadTimeSeriesMetadataDiskUnSeqCount);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(LOAD_TIME_SERIES_METADATA_MEM_SEQ_COUNT_FIELD_DESC);
      oprot.writeI64(struct.loadTimeSeriesMetadataMemSeqCount);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(LOAD_TIME_SERIES_METADATA_MEM_UN_SEQ_COUNT_FIELD_DESC);
      oprot.writeI64(struct.loadTimeSeriesMetadataMemUnSeqCount);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(LOAD_TIME_SERIES_METADATA_ALIGNED_DISK_SEQ_COUNT_FIELD_DESC);
      oprot.writeI64(struct.loadTimeSeriesMetadataAlignedDiskSeqCount);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(LOAD_TIME_SERIES_METADATA_ALIGNED_DISK_UN_SEQ_COUNT_FIELD_DESC);
      oprot.writeI64(struct.loadTimeSeriesMetadataAlignedDiskUnSeqCount);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(LOAD_TIME_SERIES_METADATA_ALIGNED_MEM_SEQ_COUNT_FIELD_DESC);
      oprot.writeI64(struct.loadTimeSeriesMetadataAlignedMemSeqCount);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(LOAD_TIME_SERIES_METADATA_ALIGNED_MEM_UN_SEQ_COUNT_FIELD_DESC);
      oprot.writeI64(struct.loadTimeSeriesMetadataAlignedMemUnSeqCount);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(LOAD_TIME_SERIES_METADATA_DISK_SEQ_TIME_FIELD_DESC);
      oprot.writeI64(struct.loadTimeSeriesMetadataDiskSeqTime);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(LOAD_TIME_SERIES_METADATA_DISK_UN_SEQ_TIME_FIELD_DESC);
      oprot.writeI64(struct.loadTimeSeriesMetadataDiskUnSeqTime);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(LOAD_TIME_SERIES_METADATA_MEM_SEQ_TIME_FIELD_DESC);
      oprot.writeI64(struct.loadTimeSeriesMetadataMemSeqTime);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(LOAD_TIME_SERIES_METADATA_MEM_UN_SEQ_TIME_FIELD_DESC);
      oprot.writeI64(struct.loadTimeSeriesMetadataMemUnSeqTime);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(LOAD_TIME_SERIES_METADATA_ALIGNED_DISK_SEQ_TIME_FIELD_DESC);
      oprot.writeI64(struct.loadTimeSeriesMetadataAlignedDiskSeqTime);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(LOAD_TIME_SERIES_METADATA_ALIGNED_DISK_UN_SEQ_TIME_FIELD_DESC);
      oprot.writeI64(struct.loadTimeSeriesMetadataAlignedDiskUnSeqTime);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(LOAD_TIME_SERIES_METADATA_ALIGNED_MEM_SEQ_TIME_FIELD_DESC);
      oprot.writeI64(struct.loadTimeSeriesMetadataAlignedMemSeqTime);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(LOAD_TIME_SERIES_METADATA_ALIGNED_MEM_UN_SEQ_TIME_FIELD_DESC);
      oprot.writeI64(struct.loadTimeSeriesMetadataAlignedMemUnSeqTime);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(CONSTRUCT_NON_ALIGNED_CHUNK_READERS_DISK_COUNT_FIELD_DESC);
      oprot.writeI64(struct.constructNonAlignedChunkReadersDiskCount);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(CONSTRUCT_NON_ALIGNED_CHUNK_READERS_MEM_COUNT_FIELD_DESC);
      oprot.writeI64(struct.constructNonAlignedChunkReadersMemCount);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(CONSTRUCT_ALIGNED_CHUNK_READERS_DISK_COUNT_FIELD_DESC);
      oprot.writeI64(struct.constructAlignedChunkReadersDiskCount);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(CONSTRUCT_ALIGNED_CHUNK_READERS_MEM_COUNT_FIELD_DESC);
      oprot.writeI64(struct.constructAlignedChunkReadersMemCount);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(CONSTRUCT_NON_ALIGNED_CHUNK_READERS_DISK_TIME_FIELD_DESC);
      oprot.writeI64(struct.constructNonAlignedChunkReadersDiskTime);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(CONSTRUCT_NON_ALIGNED_CHUNK_READERS_MEM_TIME_FIELD_DESC);
      oprot.writeI64(struct.constructNonAlignedChunkReadersMemTime);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(CONSTRUCT_ALIGNED_CHUNK_READERS_DISK_TIME_FIELD_DESC);
      oprot.writeI64(struct.constructAlignedChunkReadersDiskTime);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(CONSTRUCT_ALIGNED_CHUNK_READERS_MEM_TIME_FIELD_DESC);
      oprot.writeI64(struct.constructAlignedChunkReadersMemTime);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(PAGE_READERS_DECODE_ALIGNED_DISK_COUNT_FIELD_DESC);
      oprot.writeI64(struct.pageReadersDecodeAlignedDiskCount);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(PAGE_READERS_DECODE_ALIGNED_DISK_TIME_FIELD_DESC);
      oprot.writeI64(struct.pageReadersDecodeAlignedDiskTime);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(PAGE_READERS_DECODE_ALIGNED_MEM_COUNT_FIELD_DESC);
      oprot.writeI64(struct.pageReadersDecodeAlignedMemCount);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(PAGE_READERS_DECODE_ALIGNED_MEM_TIME_FIELD_DESC);
      oprot.writeI64(struct.pageReadersDecodeAlignedMemTime);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(PAGE_READERS_DECODE_NON_ALIGNED_DISK_COUNT_FIELD_DESC);
      oprot.writeI64(struct.pageReadersDecodeNonAlignedDiskCount);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(PAGE_READERS_DECODE_NON_ALIGNED_DISK_TIME_FIELD_DESC);
      oprot.writeI64(struct.pageReadersDecodeNonAlignedDiskTime);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(PAGE_READERS_DECODE_NON_ALIGNED_MEM_COUNT_FIELD_DESC);
      oprot.writeI64(struct.pageReadersDecodeNonAlignedMemCount);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(PAGE_READERS_DECODE_NON_ALIGNED_MEM_TIME_FIELD_DESC);
      oprot.writeI64(struct.pageReadersDecodeNonAlignedMemTime);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(PAGE_READER_MAX_USED_MEMORY_SIZE_FIELD_DESC);
      oprot.writeI64(struct.pageReaderMaxUsedMemorySize);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(ALIGNED_TIME_SERIES_METADATA_MODIFICATION_COUNT_FIELD_DESC);
      oprot.writeI64(struct.alignedTimeSeriesMetadataModificationCount);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(ALIGNED_TIME_SERIES_METADATA_MODIFICATION_TIME_FIELD_DESC);
      oprot.writeI64(struct.alignedTimeSeriesMetadataModificationTime);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(NON_ALIGNED_TIME_SERIES_METADATA_MODIFICATION_COUNT_FIELD_DESC);
      oprot.writeI64(struct.nonAlignedTimeSeriesMetadataModificationCount);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(NON_ALIGNED_TIME_SERIES_METADATA_MODIFICATION_TIME_FIELD_DESC);
      oprot.writeI64(struct.nonAlignedTimeSeriesMetadataModificationTime);
      oprot.writeFieldEnd();
      oprot.writeFieldStop();
      oprot.writeStructEnd();
    }

  }

  private static class TQueryStatisticsTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
    public TQueryStatisticsTupleScheme getScheme() {
      return new TQueryStatisticsTupleScheme();
    }
  }

  private static class TQueryStatisticsTupleScheme extends org.apache.thrift.scheme.TupleScheme {

    @Override
    public void write(org.apache.thrift.protocol.TProtocol prot, TQueryStatistics struct) throws org.apache.thrift.TException {
      org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
      java.util.BitSet optionals = new java.util.BitSet();
      if (struct.isSetLoadTimeSeriesMetadataDiskSeqCount()) {
        optionals.set(0);
      }
      if (struct.isSetLoadTimeSeriesMetadataDiskUnSeqCount()) {
        optionals.set(1);
      }
      if (struct.isSetLoadTimeSeriesMetadataMemSeqCount()) {
        optionals.set(2);
      }
      if (struct.isSetLoadTimeSeriesMetadataMemUnSeqCount()) {
        optionals.set(3);
      }
      if (struct.isSetLoadTimeSeriesMetadataAlignedDiskSeqCount()) {
        optionals.set(4);
      }
      if (struct.isSetLoadTimeSeriesMetadataAlignedDiskUnSeqCount()) {
        optionals.set(5);
      }
      if (struct.isSetLoadTimeSeriesMetadataAlignedMemSeqCount()) {
        optionals.set(6);
      }
      if (struct.isSetLoadTimeSeriesMetadataAlignedMemUnSeqCount()) {
        optionals.set(7);
      }
      if (struct.isSetLoadTimeSeriesMetadataDiskSeqTime()) {
        optionals.set(8);
      }
      if (struct.isSetLoadTimeSeriesMetadataDiskUnSeqTime()) {
        optionals.set(9);
      }
      if (struct.isSetLoadTimeSeriesMetadataMemSeqTime()) {
        optionals.set(10);
      }
      if (struct.isSetLoadTimeSeriesMetadataMemUnSeqTime()) {
        optionals.set(11);
      }
      if (struct.isSetLoadTimeSeriesMetadataAlignedDiskSeqTime()) {
        optionals.set(12);
      }
      if (struct.isSetLoadTimeSeriesMetadataAlignedDiskUnSeqTime()) {
        optionals.set(13);
      }
      if (struct.isSetLoadTimeSeriesMetadataAlignedMemSeqTime()) {
        optionals.set(14);
      }
      if (struct.isSetLoadTimeSeriesMetadataAlignedMemUnSeqTime()) {
        optionals.set(15);
      }
      if (struct.isSetConstructNonAlignedChunkReadersDiskCount()) {
        optionals.set(16);
      }
      if (struct.isSetConstructNonAlignedChunkReadersMemCount()) {
        optionals.set(17);
      }
      if (struct.isSetConstructAlignedChunkReadersDiskCount()) {
        optionals.set(18);
      }
      if (struct.isSetConstructAlignedChunkReadersMemCount()) {
        optionals.set(19);
      }
      if (struct.isSetConstructNonAlignedChunkReadersDiskTime()) {
        optionals.set(20);
      }
      if (struct.isSetConstructNonAlignedChunkReadersMemTime()) {
        optionals.set(21);
      }
      if (struct.isSetConstructAlignedChunkReadersDiskTime()) {
        optionals.set(22);
      }
      if (struct.isSetConstructAlignedChunkReadersMemTime()) {
        optionals.set(23);
      }
      if (struct.isSetPageReadersDecodeAlignedDiskCount()) {
        optionals.set(24);
      }
      if (struct.isSetPageReadersDecodeAlignedDiskTime()) {
        optionals.set(25);
      }
      if (struct.isSetPageReadersDecodeAlignedMemCount()) {
        optionals.set(26);
      }
      if (struct.isSetPageReadersDecodeAlignedMemTime()) {
        optionals.set(27);
      }
      if (struct.isSetPageReadersDecodeNonAlignedDiskCount()) {
        optionals.set(28);
      }
      if (struct.isSetPageReadersDecodeNonAlignedDiskTime()) {
        optionals.set(29);
      }
      if (struct.isSetPageReadersDecodeNonAlignedMemCount()) {
        optionals.set(30);
      }
      if (struct.isSetPageReadersDecodeNonAlignedMemTime()) {
        optionals.set(31);
      }
      if (struct.isSetPageReaderMaxUsedMemorySize()) {
        optionals.set(32);
      }
      if (struct.isSetAlignedTimeSeriesMetadataModificationCount()) {
        optionals.set(33);
      }
      if (struct.isSetAlignedTimeSeriesMetadataModificationTime()) {
        optionals.set(34);
      }
      if (struct.isSetNonAlignedTimeSeriesMetadataModificationCount()) {
        optionals.set(35);
      }
      if (struct.isSetNonAlignedTimeSeriesMetadataModificationTime()) {
        optionals.set(36);
      }
      oprot.writeBitSet(optionals, 37);
      if (struct.isSetLoadTimeSeriesMetadataDiskSeqCount()) {
        oprot.writeI64(struct.loadTimeSeriesMetadataDiskSeqCount);
      }
      if (struct.isSetLoadTimeSeriesMetadataDiskUnSeqCount()) {
        oprot.writeI64(struct.loadTimeSeriesMetadataDiskUnSeqCount);
      }
      if (struct.isSetLoadTimeSeriesMetadataMemSeqCount()) {
        oprot.writeI64(struct.loadTimeSeriesMetadataMemSeqCount);
      }
      if (struct.isSetLoadTimeSeriesMetadataMemUnSeqCount()) {
        oprot.writeI64(struct.loadTimeSeriesMetadataMemUnSeqCount);
      }
      if (struct.isSetLoadTimeSeriesMetadataAlignedDiskSeqCount()) {
        oprot.writeI64(struct.loadTimeSeriesMetadataAlignedDiskSeqCount);
      }
      if (struct.isSetLoadTimeSeriesMetadataAlignedDiskUnSeqCount()) {
        oprot.writeI64(struct.loadTimeSeriesMetadataAlignedDiskUnSeqCount);
      }
      if (struct.isSetLoadTimeSeriesMetadataAlignedMemSeqCount()) {
        oprot.writeI64(struct.loadTimeSeriesMetadataAlignedMemSeqCount);
      }
      if (struct.isSetLoadTimeSeriesMetadataAlignedMemUnSeqCount()) {
        oprot.writeI64(struct.loadTimeSeriesMetadataAlignedMemUnSeqCount);
      }
      if (struct.isSetLoadTimeSeriesMetadataDiskSeqTime()) {
        oprot.writeI64(struct.loadTimeSeriesMetadataDiskSeqTime);
      }
      if (struct.isSetLoadTimeSeriesMetadataDiskUnSeqTime()) {
        oprot.writeI64(struct.loadTimeSeriesMetadataDiskUnSeqTime);
      }
      if (struct.isSetLoadTimeSeriesMetadataMemSeqTime()) {
        oprot.writeI64(struct.loadTimeSeriesMetadataMemSeqTime);
      }
      if (struct.isSetLoadTimeSeriesMetadataMemUnSeqTime()) {
        oprot.writeI64(struct.loadTimeSeriesMetadataMemUnSeqTime);
      }
      if (struct.isSetLoadTimeSeriesMetadataAlignedDiskSeqTime()) {
        oprot.writeI64(struct.loadTimeSeriesMetadataAlignedDiskSeqTime);
      }
      if (struct.isSetLoadTimeSeriesMetadataAlignedDiskUnSeqTime()) {
        oprot.writeI64(struct.loadTimeSeriesMetadataAlignedDiskUnSeqTime);
      }
      if (struct.isSetLoadTimeSeriesMetadataAlignedMemSeqTime()) {
        oprot.writeI64(struct.loadTimeSeriesMetadataAlignedMemSeqTime);
      }
      if (struct.isSetLoadTimeSeriesMetadataAlignedMemUnSeqTime()) {
        oprot.writeI64(struct.loadTimeSeriesMetadataAlignedMemUnSeqTime);
      }
      if (struct.isSetConstructNonAlignedChunkReadersDiskCount()) {
        oprot.writeI64(struct.constructNonAlignedChunkReadersDiskCount);
      }
      if (struct.isSetConstructNonAlignedChunkReadersMemCount()) {
        oprot.writeI64(struct.constructNonAlignedChunkReadersMemCount);
      }
      if (struct.isSetConstructAlignedChunkReadersDiskCount()) {
        oprot.writeI64(struct.constructAlignedChunkReadersDiskCount);
      }
      if (struct.isSetConstructAlignedChunkReadersMemCount()) {
        oprot.writeI64(struct.constructAlignedChunkReadersMemCount);
      }
      if (struct.isSetConstructNonAlignedChunkReadersDiskTime()) {
        oprot.writeI64(struct.constructNonAlignedChunkReadersDiskTime);
      }
      if (struct.isSetConstructNonAlignedChunkReadersMemTime()) {
        oprot.writeI64(struct.constructNonAlignedChunkReadersMemTime);
      }
      if (struct.isSetConstructAlignedChunkReadersDiskTime()) {
        oprot.writeI64(struct.constructAlignedChunkReadersDiskTime);
      }
      if (struct.isSetConstructAlignedChunkReadersMemTime()) {
        oprot.writeI64(struct.constructAlignedChunkReadersMemTime);
      }
      if (struct.isSetPageReadersDecodeAlignedDiskCount()) {
        oprot.writeI64(struct.pageReadersDecodeAlignedDiskCount);
      }
      if (struct.isSetPageReadersDecodeAlignedDiskTime()) {
        oprot.writeI64(struct.pageReadersDecodeAlignedDiskTime);
      }
      if (struct.isSetPageReadersDecodeAlignedMemCount()) {
        oprot.writeI64(struct.pageReadersDecodeAlignedMemCount);
      }
      if (struct.isSetPageReadersDecodeAlignedMemTime()) {
        oprot.writeI64(struct.pageReadersDecodeAlignedMemTime);
      }
      if (struct.isSetPageReadersDecodeNonAlignedDiskCount()) {
        oprot.writeI64(struct.pageReadersDecodeNonAlignedDiskCount);
      }
      if (struct.isSetPageReadersDecodeNonAlignedDiskTime()) {
        oprot.writeI64(struct.pageReadersDecodeNonAlignedDiskTime);
      }
      if (struct.isSetPageReadersDecodeNonAlignedMemCount()) {
        oprot.writeI64(struct.pageReadersDecodeNonAlignedMemCount);
      }
      if (struct.isSetPageReadersDecodeNonAlignedMemTime()) {
        oprot.writeI64(struct.pageReadersDecodeNonAlignedMemTime);
      }
      if (struct.isSetPageReaderMaxUsedMemorySize()) {
        oprot.writeI64(struct.pageReaderMaxUsedMemorySize);
      }
      if (struct.isSetAlignedTimeSeriesMetadataModificationCount()) {
        oprot.writeI64(struct.alignedTimeSeriesMetadataModificationCount);
      }
      if (struct.isSetAlignedTimeSeriesMetadataModificationTime()) {
        oprot.writeI64(struct.alignedTimeSeriesMetadataModificationTime);
      }
      if (struct.isSetNonAlignedTimeSeriesMetadataModificationCount()) {
        oprot.writeI64(struct.nonAlignedTimeSeriesMetadataModificationCount);
      }
      if (struct.isSetNonAlignedTimeSeriesMetadataModificationTime()) {
        oprot.writeI64(struct.nonAlignedTimeSeriesMetadataModificationTime);
      }
    }

    @Override
    public void read(org.apache.thrift.protocol.TProtocol prot, TQueryStatistics struct) throws org.apache.thrift.TException {
      org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
      java.util.BitSet incoming = iprot.readBitSet(37);
      if (incoming.get(0)) {
        struct.loadTimeSeriesMetadataDiskSeqCount = iprot.readI64();
        struct.setLoadTimeSeriesMetadataDiskSeqCountIsSet(true);
      }
      if (incoming.get(1)) {
        struct.loadTimeSeriesMetadataDiskUnSeqCount = iprot.readI64();
        struct.setLoadTimeSeriesMetadataDiskUnSeqCountIsSet(true);
      }
      if (incoming.get(2)) {
        struct.loadTimeSeriesMetadataMemSeqCount = iprot.readI64();
        struct.setLoadTimeSeriesMetadataMemSeqCountIsSet(true);
      }
      if (incoming.get(3)) {
        struct.loadTimeSeriesMetadataMemUnSeqCount = iprot.readI64();
        struct.setLoadTimeSeriesMetadataMemUnSeqCountIsSet(true);
      }
      if (incoming.get(4)) {
        struct.loadTimeSeriesMetadataAlignedDiskSeqCount = iprot.readI64();
        struct.setLoadTimeSeriesMetadataAlignedDiskSeqCountIsSet(true);
      }
      if (incoming.get(5)) {
        struct.loadTimeSeriesMetadataAlignedDiskUnSeqCount = iprot.readI64();
        struct.setLoadTimeSeriesMetadataAlignedDiskUnSeqCountIsSet(true);
      }
      if (incoming.get(6)) {
        struct.loadTimeSeriesMetadataAlignedMemSeqCount = iprot.readI64();
        struct.setLoadTimeSeriesMetadataAlignedMemSeqCountIsSet(true);
      }
      if (incoming.get(7)) {
        struct.loadTimeSeriesMetadataAlignedMemUnSeqCount = iprot.readI64();
        struct.setLoadTimeSeriesMetadataAlignedMemUnSeqCountIsSet(true);
      }
      if (incoming.get(8)) {
        struct.loadTimeSeriesMetadataDiskSeqTime = iprot.readI64();
        struct.setLoadTimeSeriesMetadataDiskSeqTimeIsSet(true);
      }
      if (incoming.get(9)) {
        struct.loadTimeSeriesMetadataDiskUnSeqTime = iprot.readI64();
        struct.setLoadTimeSeriesMetadataDiskUnSeqTimeIsSet(true);
      }
      if (incoming.get(10)) {
        struct.loadTimeSeriesMetadataMemSeqTime = iprot.readI64();
        struct.setLoadTimeSeriesMetadataMemSeqTimeIsSet(true);
      }
      if (incoming.get(11)) {
        struct.loadTimeSeriesMetadataMemUnSeqTime = iprot.readI64();
        struct.setLoadTimeSeriesMetadataMemUnSeqTimeIsSet(true);
      }
      if (incoming.get(12)) {
        struct.loadTimeSeriesMetadataAlignedDiskSeqTime = iprot.readI64();
        struct.setLoadTimeSeriesMetadataAlignedDiskSeqTimeIsSet(true);
      }
      if (incoming.get(13)) {
        struct.loadTimeSeriesMetadataAlignedDiskUnSeqTime = iprot.readI64();
        struct.setLoadTimeSeriesMetadataAlignedDiskUnSeqTimeIsSet(true);
      }
      if (incoming.get(14)) {
        struct.loadTimeSeriesMetadataAlignedMemSeqTime = iprot.readI64();
        struct.setLoadTimeSeriesMetadataAlignedMemSeqTimeIsSet(true);
      }
      if (incoming.get(15)) {
        struct.loadTimeSeriesMetadataAlignedMemUnSeqTime = iprot.readI64();
        struct.setLoadTimeSeriesMetadataAlignedMemUnSeqTimeIsSet(true);
      }
      if (incoming.get(16)) {
        struct.constructNonAlignedChunkReadersDiskCount = iprot.readI64();
        struct.setConstructNonAlignedChunkReadersDiskCountIsSet(true);
      }
      if (incoming.get(17)) {
        struct.constructNonAlignedChunkReadersMemCount = iprot.readI64();
        struct.setConstructNonAlignedChunkReadersMemCountIsSet(true);
      }
      if (incoming.get(18)) {
        struct.constructAlignedChunkReadersDiskCount = iprot.readI64();
        struct.setConstructAlignedChunkReadersDiskCountIsSet(true);
      }
      if (incoming.get(19)) {
        struct.constructAlignedChunkReadersMemCount = iprot.readI64();
        struct.setConstructAlignedChunkReadersMemCountIsSet(true);
      }
      if (incoming.get(20)) {
        struct.constructNonAlignedChunkReadersDiskTime = iprot.readI64();
        struct.setConstructNonAlignedChunkReadersDiskTimeIsSet(true);
      }
      if (incoming.get(21)) {
        struct.constructNonAlignedChunkReadersMemTime = iprot.readI64();
        struct.setConstructNonAlignedChunkReadersMemTimeIsSet(true);
      }
      if (incoming.get(22)) {
        struct.constructAlignedChunkReadersDiskTime = iprot.readI64();
        struct.setConstructAlignedChunkReadersDiskTimeIsSet(true);
      }
      if (incoming.get(23)) {
        struct.constructAlignedChunkReadersMemTime = iprot.readI64();
        struct.setConstructAlignedChunkReadersMemTimeIsSet(true);
      }
      if (incoming.get(24)) {
        struct.pageReadersDecodeAlignedDiskCount = iprot.readI64();
        struct.setPageReadersDecodeAlignedDiskCountIsSet(true);
      }
      if (incoming.get(25)) {
        struct.pageReadersDecodeAlignedDiskTime = iprot.readI64();
        struct.setPageReadersDecodeAlignedDiskTimeIsSet(true);
      }
      if (incoming.get(26)) {
        struct.pageReadersDecodeAlignedMemCount = iprot.readI64();
        struct.setPageReadersDecodeAlignedMemCountIsSet(true);
      }
      if (incoming.get(27)) {
        struct.pageReadersDecodeAlignedMemTime = iprot.readI64();
        struct.setPageReadersDecodeAlignedMemTimeIsSet(true);
      }
      if (incoming.get(28)) {
        struct.pageReadersDecodeNonAlignedDiskCount = iprot.readI64();
        struct.setPageReadersDecodeNonAlignedDiskCountIsSet(true);
      }
      if (incoming.get(29)) {
        struct.pageReadersDecodeNonAlignedDiskTime = iprot.readI64();
        struct.setPageReadersDecodeNonAlignedDiskTimeIsSet(true);
      }
      if (incoming.get(30)) {
        struct.pageReadersDecodeNonAlignedMemCount = iprot.readI64();
        struct.setPageReadersDecodeNonAlignedMemCountIsSet(true);
      }
      if (incoming.get(31)) {
        struct.pageReadersDecodeNonAlignedMemTime = iprot.readI64();
        struct.setPageReadersDecodeNonAlignedMemTimeIsSet(true);
      }
      if (incoming.get(32)) {
        struct.pageReaderMaxUsedMemorySize = iprot.readI64();
        struct.setPageReaderMaxUsedMemorySizeIsSet(true);
      }
      if (incoming.get(33)) {
        struct.alignedTimeSeriesMetadataModificationCount = iprot.readI64();
        struct.setAlignedTimeSeriesMetadataModificationCountIsSet(true);
      }
      if (incoming.get(34)) {
        struct.alignedTimeSeriesMetadataModificationTime = iprot.readI64();
        struct.setAlignedTimeSeriesMetadataModificationTimeIsSet(true);
      }
      if (incoming.get(35)) {
        struct.nonAlignedTimeSeriesMetadataModificationCount = iprot.readI64();
        struct.setNonAlignedTimeSeriesMetadataModificationCountIsSet(true);
      }
      if (incoming.get(36)) {
        struct.nonAlignedTimeSeriesMetadataModificationTime = iprot.readI64();
        struct.setNonAlignedTimeSeriesMetadataModificationTimeIsSet(true);
      }
    }
  }

  private static  S scheme(org.apache.thrift.protocol.TProtocol proto) {
    return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
  }
}





© 2015 - 2024 Weber Informatics LLC | Privacy Policy