content: // Generated by the protocol buffer compiler.  DO NOT EDIT!
  // source: lot/lot.proto
  
  package apsara.odps.lot;
  
  public final class Lot {
    private Lot() {}
    public static void registerAllExtensions(
        com.google.protobuf.ExtensionRegistry registry) {
    }
    public interface LogicalOperatorOrBuilder
        extends com.google.protobuf.MessageOrBuilder {
      
      // optional .apsara.odps.lot.Apply Apply = 1;
      boolean hasApply();
      ApplyProtos.Apply getApply();
      ApplyProtos.ApplyOrBuilder getApplyOrBuilder();
      
      // optional .apsara.odps.lot.DistributeBy DistributeBy = 2;
      boolean hasDistributeBy();
      DistributeByProtos.DistributeBy getDistributeBy();
      DistributeByProtos.DistributeByOrBuilder getDistributeByOrBuilder();
      
      // optional .apsara.odps.lot.Filter Filter = 3;
      boolean hasFilter();
      FilterProtos.Filter getFilter();
      FilterProtos.FilterOrBuilder getFilterOrBuilder();
      
      // optional .apsara.odps.lot.Aggregate Aggregate = 4;
      boolean hasAggregate();
      AggregateProtos.Aggregate getAggregate();
      AggregateProtos.AggregateOrBuilder getAggregateOrBuilder();
      
      // optional .apsara.odps.lot.Join Join = 5;
      boolean hasJoin();
      JoinProtos.Join getJoin();
      JoinProtos.JoinOrBuilder getJoinOrBuilder();
      
      // optional .apsara.odps.lot.Select Select = 6;
      boolean hasSelect();
      SelectProtos.Select getSelect();
      SelectProtos.SelectOrBuilder getSelectOrBuilder();
      
      // optional .apsara.odps.lot.SortBy SortBy = 7;
      boolean hasSortBy();
      SortByProtos.SortBy getSortBy();
      SortByProtos.SortByOrBuilder getSortByOrBuilder();
      
      // optional .apsara.odps.lot.DataSource DataSource = 8;
      boolean hasDataSource();
      DataSourceProtos.DataSource getDataSource();
      DataSourceProtos.DataSourceOrBuilder getDataSourceOrBuilder();
      
      // optional .apsara.odps.lot.DataSink DataSink = 9;
      boolean hasDataSink();
      DataSinkProtos.DataSink getDataSink();
      DataSinkProtos.DataSinkOrBuilder getDataSinkOrBuilder();
      
      // optional .apsara.odps.lot.Limit Limit = 10;
      boolean hasLimit();
      LimitProtos.Limit getLimit();
      LimitProtos.LimitOrBuilder getLimitOrBuilder();
      
      // optional .apsara.odps.lot.UnionAll UnionAll = 11;
      boolean hasUnionAll();
      UnionAllProtos.UnionAll getUnionAll();
      UnionAllProtos.UnionAllOrBuilder getUnionAllOrBuilder();
      
      // optional .apsara.odps.lot.Window Window = 12;
      boolean hasWindow();
      WindowProtos.Window getWindow();
      WindowProtos.WindowOrBuilder getWindowOrBuilder();
      
      // optional .apsara.odps.lot.Transform Transform = 13;
      boolean hasTransform();
      TransformProtos.Transform getTransform();
      TransformProtos.TransformOrBuilder getTransformOrBuilder();
    }
    public static final class LogicalOperator extends
        com.google.protobuf.GeneratedMessage
        implements LogicalOperatorOrBuilder {
      // Use LogicalOperator.newBuilder() to construct.
      private LogicalOperator(Builder builder) {
        super(builder);
      }
      private LogicalOperator(boolean noInit) {}
      
      private static final LogicalOperator defaultInstance;
      public static LogicalOperator getDefaultInstance() {
        return defaultInstance;
      }
      
      public LogicalOperator getDefaultInstanceForType() {
        return defaultInstance;
      }
      
      public static final com.google.protobuf.Descriptors.Descriptor
          getDescriptor() {
        return Lot.internal_static_apsara_odps_lot_LogicalOperator_descriptor;
      }
      
      protected FieldAccessorTable
          internalGetFieldAccessorTable() {
        return Lot.internal_static_apsara_odps_lot_LogicalOperator_fieldAccessorTable;
      }
      
      private int bitField0_;
      // optional .apsara.odps.lot.Apply Apply = 1;
      public static final int APPLY_FIELD_NUMBER = 1;
      private ApplyProtos.Apply apply_;
      public boolean hasApply() {
        return ((bitField0_ & 0x00000001) == 0x00000001);
      }
      public ApplyProtos.Apply getApply() {
        return apply_;
      }
      public ApplyProtos.ApplyOrBuilder getApplyOrBuilder() {
        return apply_;
      }
      
      // optional .apsara.odps.lot.DistributeBy DistributeBy = 2;
      public static final int DISTRIBUTEBY_FIELD_NUMBER = 2;
      private DistributeByProtos.DistributeBy distributeBy_;
      public boolean hasDistributeBy() {
        return ((bitField0_ & 0x00000002) == 0x00000002);
      }
      public DistributeByProtos.DistributeBy getDistributeBy() {
        return distributeBy_;
      }
      public DistributeByProtos.DistributeByOrBuilder getDistributeByOrBuilder() {
        return distributeBy_;
      }
      
      // optional .apsara.odps.lot.Filter Filter = 3;
      public static final int FILTER_FIELD_NUMBER = 3;
      private FilterProtos.Filter filter_;
      public boolean hasFilter() {
        return ((bitField0_ & 0x00000004) == 0x00000004);
      }
      public FilterProtos.Filter getFilter() {
        return filter_;
      }
      public FilterProtos.FilterOrBuilder getFilterOrBuilder() {
        return filter_;
      }
      
      // optional .apsara.odps.lot.Aggregate Aggregate = 4;
      public static final int AGGREGATE_FIELD_NUMBER = 4;
      private AggregateProtos.Aggregate aggregate_;
      public boolean hasAggregate() {
        return ((bitField0_ & 0x00000008) == 0x00000008);
      }
      public AggregateProtos.Aggregate getAggregate() {
        return aggregate_;
      }
      public AggregateProtos.AggregateOrBuilder getAggregateOrBuilder() {
        return aggregate_;
      }
      
      // optional .apsara.odps.lot.Join Join = 5;
      public static final int JOIN_FIELD_NUMBER = 5;
      private JoinProtos.Join join_;
      public boolean hasJoin() {
        return ((bitField0_ & 0x00000010) == 0x00000010);
      }
      public JoinProtos.Join getJoin() {
        return join_;
      }
      public JoinProtos.JoinOrBuilder getJoinOrBuilder() {
        return join_;
      }
      
      // optional .apsara.odps.lot.Select Select = 6;
      public static final int SELECT_FIELD_NUMBER = 6;
      private SelectProtos.Select select_;
      public boolean hasSelect() {
        return ((bitField0_ & 0x00000020) == 0x00000020);
      }
      public SelectProtos.Select getSelect() {
        return select_;
      }
      public SelectProtos.SelectOrBuilder getSelectOrBuilder() {
        return select_;
      }
      
      // optional .apsara.odps.lot.SortBy SortBy = 7;
      public static final int SORTBY_FIELD_NUMBER = 7;
      private SortByProtos.SortBy sortBy_;
      public boolean hasSortBy() {
        return ((bitField0_ & 0x00000040) == 0x00000040);
      }
      public SortByProtos.SortBy getSortBy() {
        return sortBy_;
      }
      public SortByProtos.SortByOrBuilder getSortByOrBuilder() {
        return sortBy_;
      }
      
      // optional .apsara.odps.lot.DataSource DataSource = 8;
      public static final int DATASOURCE_FIELD_NUMBER = 8;
      private DataSourceProtos.DataSource dataSource_;
      public boolean hasDataSource() {
        return ((bitField0_ & 0x00000080) == 0x00000080);
      }
      public DataSourceProtos.DataSource getDataSource() {
        return dataSource_;
      }
      public DataSourceProtos.DataSourceOrBuilder getDataSourceOrBuilder() {
        return dataSource_;
      }
      
      // optional .apsara.odps.lot.DataSink DataSink = 9;
      public static final int DATASINK_FIELD_NUMBER = 9;
      private DataSinkProtos.DataSink dataSink_;
      public boolean hasDataSink() {
        return ((bitField0_ & 0x00000100) == 0x00000100);
      }
      public DataSinkProtos.DataSink getDataSink() {
        return dataSink_;
      }
      public DataSinkProtos.DataSinkOrBuilder getDataSinkOrBuilder() {
        return dataSink_;
      }
      
      // optional .apsara.odps.lot.Limit Limit = 10;
      public static final int LIMIT_FIELD_NUMBER = 10;
      private LimitProtos.Limit limit_;
      public boolean hasLimit() {
        return ((bitField0_ & 0x00000200) == 0x00000200);
      }
      public LimitProtos.Limit getLimit() {
        return limit_;
      }
      public LimitProtos.LimitOrBuilder getLimitOrBuilder() {
        return limit_;
      }
      
      // optional .apsara.odps.lot.UnionAll UnionAll = 11;
      public static final int UNIONALL_FIELD_NUMBER = 11;
      private UnionAllProtos.UnionAll unionAll_;
      public boolean hasUnionAll() {
        return ((bitField0_ & 0x00000400) == 0x00000400);
      }
      public UnionAllProtos.UnionAll getUnionAll() {
        return unionAll_;
      }
      public UnionAllProtos.UnionAllOrBuilder getUnionAllOrBuilder() {
        return unionAll_;
      }
      
      // optional .apsara.odps.lot.Window Window = 12;
      public static final int WINDOW_FIELD_NUMBER = 12;
      private WindowProtos.Window window_;
      public boolean hasWindow() {
        return ((bitField0_ & 0x00000800) == 0x00000800);
      }
      public WindowProtos.Window getWindow() {
        return window_;
      }
      public WindowProtos.WindowOrBuilder getWindowOrBuilder() {
        return window_;
      }
      
      // optional .apsara.odps.lot.Transform Transform = 13;
      public static final int TRANSFORM_FIELD_NUMBER = 13;
      private TransformProtos.Transform transform_;
      public boolean hasTransform() {
        return ((bitField0_ & 0x00001000) == 0x00001000);
      }
      public TransformProtos.Transform getTransform() {
        return transform_;
      }
      public TransformProtos.TransformOrBuilder getTransformOrBuilder() {
        return transform_;
      }
      
      private void initFields() {
        apply_ = ApplyProtos.Apply.getDefaultInstance();
        distributeBy_ = DistributeByProtos.DistributeBy.getDefaultInstance();
        filter_ = FilterProtos.Filter.getDefaultInstance();
        aggregate_ = AggregateProtos.Aggregate.getDefaultInstance();
        join_ = JoinProtos.Join.getDefaultInstance();
        select_ = SelectProtos.Select.getDefaultInstance();
        sortBy_ = SortByProtos.SortBy.getDefaultInstance();
        dataSource_ = DataSourceProtos.DataSource.getDefaultInstance();
        dataSink_ = DataSinkProtos.DataSink.getDefaultInstance();
        limit_ = LimitProtos.Limit.getDefaultInstance();
        unionAll_ = UnionAllProtos.UnionAll.getDefaultInstance();
        window_ = WindowProtos.Window.getDefaultInstance();
        transform_ = TransformProtos.Transform.getDefaultInstance();
      }
      private byte memoizedIsInitialized = -1;
      public final boolean isInitialized() {
        byte isInitialized = memoizedIsInitialized;
        if (isInitialized != -1) return isInitialized == 1;
        
        if (hasApply()) {
          if (!getApply().isInitialized()) {
            memoizedIsInitialized = 0;
            return false;
          }
        }
        if (hasDistributeBy()) {
          if (!getDistributeBy().isInitialized()) {
            memoizedIsInitialized = 0;
            return false;
          }
        }
        if (hasFilter()) {
          if (!getFilter().isInitialized()) {
            memoizedIsInitialized = 0;
            return false;
          }
        }
        if (hasAggregate()) {
          if (!getAggregate().isInitialized()) {
            memoizedIsInitialized = 0;
            return false;
          }
        }
        if (hasJoin()) {
          if (!getJoin().isInitialized()) {
            memoizedIsInitialized = 0;
            return false;
          }
        }
        if (hasSelect()) {
          if (!getSelect().isInitialized()) {
            memoizedIsInitialized = 0;
            return false;
          }
        }
        if (hasSortBy()) {
          if (!getSortBy().isInitialized()) {
            memoizedIsInitialized = 0;
            return false;
          }
        }
        if (hasDataSource()) {
          if (!getDataSource().isInitialized()) {
            memoizedIsInitialized = 0;
            return false;
          }
        }
        if (hasDataSink()) {
          if (!getDataSink().isInitialized()) {
            memoizedIsInitialized = 0;
            return false;
          }
        }
        if (hasLimit()) {
          if (!getLimit().isInitialized()) {
            memoizedIsInitialized = 0;
            return false;
          }
        }
        if (hasUnionAll()) {
          if (!getUnionAll().isInitialized()) {
            memoizedIsInitialized = 0;
            return false;
          }
        }
        if (hasWindow()) {
          if (!getWindow().isInitialized()) {
            memoizedIsInitialized = 0;
            return false;
          }
        }
        if (hasTransform()) {
          if (!getTransform().isInitialized()) {
            memoizedIsInitialized = 0;
            return false;
          }
        }
        memoizedIsInitialized = 1;
        return true;
      }
      
      public void writeTo(com.google.protobuf.CodedOutputStream output)
                          throws java.io.IOException {
        getSerializedSize();
        if (((bitField0_ & 0x00000001) == 0x00000001)) {
          output.writeMessage(1, apply_);
        }
        if (((bitField0_ & 0x00000002) == 0x00000002)) {
          output.writeMessage(2, distributeBy_);
        }
        if (((bitField0_ & 0x00000004) == 0x00000004)) {
          output.writeMessage(3, filter_);
        }
        if (((bitField0_ & 0x00000008) == 0x00000008)) {
          output.writeMessage(4, aggregate_);
        }
        if (((bitField0_ & 0x00000010) == 0x00000010)) {
          output.writeMessage(5, join_);
        }
        if (((bitField0_ & 0x00000020) == 0x00000020)) {
          output.writeMessage(6, select_);
        }
        if (((bitField0_ & 0x00000040) == 0x00000040)) {
          output.writeMessage(7, sortBy_);
        }
        if (((bitField0_ & 0x00000080) == 0x00000080)) {
          output.writeMessage(8, dataSource_);
        }
        if (((bitField0_ & 0x00000100) == 0x00000100)) {
          output.writeMessage(9, dataSink_);
        }
        if (((bitField0_ & 0x00000200) == 0x00000200)) {
          output.writeMessage(10, limit_);
        }
        if (((bitField0_ & 0x00000400) == 0x00000400)) {
          output.writeMessage(11, unionAll_);
        }
        if (((bitField0_ & 0x00000800) == 0x00000800)) {
          output.writeMessage(12, window_);
        }
        if (((bitField0_ & 0x00001000) == 0x00001000)) {
          output.writeMessage(13, transform_);
        }
        getUnknownFields().writeTo(output);
      }
      
      private int memoizedSerializedSize = -1;
      public int getSerializedSize() {
        int size = memoizedSerializedSize;
        if (size != -1) return size;
      
        size = 0;
        if (((bitField0_ & 0x00000001) == 0x00000001)) {
          size += com.google.protobuf.CodedOutputStream
            .computeMessageSize(1, apply_);
        }
        if (((bitField0_ & 0x00000002) == 0x00000002)) {
          size += com.google.protobuf.CodedOutputStream
            .computeMessageSize(2, distributeBy_);
        }
        if (((bitField0_ & 0x00000004) == 0x00000004)) {
          size += com.google.protobuf.CodedOutputStream
            .computeMessageSize(3, filter_);
        }
        if (((bitField0_ & 0x00000008) == 0x00000008)) {
          size += com.google.protobuf.CodedOutputStream
            .computeMessageSize(4, aggregate_);
        }
        if (((bitField0_ & 0x00000010) == 0x00000010)) {
          size += com.google.protobuf.CodedOutputStream
            .computeMessageSize(5, join_);
        }
        if (((bitField0_ & 0x00000020) == 0x00000020)) {
          size += com.google.protobuf.CodedOutputStream
            .computeMessageSize(6, select_);
        }
        if (((bitField0_ & 0x00000040) == 0x00000040)) {
          size += com.google.protobuf.CodedOutputStream
            .computeMessageSize(7, sortBy_);
        }
        if (((bitField0_ & 0x00000080) == 0x00000080)) {
          size += com.google.protobuf.CodedOutputStream
            .computeMessageSize(8, dataSource_);
        }
        if (((bitField0_ & 0x00000100) == 0x00000100)) {
          size += com.google.protobuf.CodedOutputStream
            .computeMessageSize(9, dataSink_);
        }
        if (((bitField0_ & 0x00000200) == 0x00000200)) {
          size += com.google.protobuf.CodedOutputStream
            .computeMessageSize(10, limit_);
        }
        if (((bitField0_ & 0x00000400) == 0x00000400)) {
          size += com.google.protobuf.CodedOutputStream
            .computeMessageSize(11, unionAll_);
        }
        if (((bitField0_ & 0x00000800) == 0x00000800)) {
          size += com.google.protobuf.CodedOutputStream
            .computeMessageSize(12, window_);
        }
        if (((bitField0_ & 0x00001000) == 0x00001000)) {
          size += com.google.protobuf.CodedOutputStream
            .computeMessageSize(13, transform_);
        }
        size += getUnknownFields().getSerializedSize();
        memoizedSerializedSize = size;
        return size;
      }
      
      private static final long serialVersionUID = 0L;
      @Override
      protected Object writeReplace()
          throws java.io.ObjectStreamException {
        return super.writeReplace();
      }
      
      public static LogicalOperator parseFrom(
          com.google.protobuf.ByteString data)
          throws com.google.protobuf.InvalidProtocolBufferException {
        return newBuilder().mergeFrom(data).buildParsed();
      }
      public static LogicalOperator parseFrom(
          com.google.protobuf.ByteString data,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws com.google.protobuf.InvalidProtocolBufferException {
        return newBuilder().mergeFrom(data, extensionRegistry)
                 .buildParsed();
      }
      public static LogicalOperator parseFrom(byte[] data)
          throws com.google.protobuf.InvalidProtocolBufferException {
        return newBuilder().mergeFrom(data).buildParsed();
      }
      public static LogicalOperator parseFrom(
          byte[] data,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws com.google.protobuf.InvalidProtocolBufferException {
        return newBuilder().mergeFrom(data, extensionRegistry)
                 .buildParsed();
      }
      public static LogicalOperator parseFrom(java.io.InputStream input)
          throws java.io.IOException {
        return newBuilder().mergeFrom(input).buildParsed();
      }
      public static LogicalOperator parseFrom(
          java.io.InputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws java.io.IOException {
        return newBuilder().mergeFrom(input, extensionRegistry)
                 .buildParsed();
      }
      public static LogicalOperator parseDelimitedFrom(java.io.InputStream input)
          throws java.io.IOException {
        Builder builder = newBuilder();
        if (builder.mergeDelimitedFrom(input)) {
          return builder.buildParsed();
        } else {
          return null;
        }
      }
      public static LogicalOperator parseDelimitedFrom(
          java.io.InputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws java.io.IOException {
        Builder builder = newBuilder();
        if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
          return builder.buildParsed();
        } else {
          return null;
        }
      }
      public static LogicalOperator parseFrom(
          com.google.protobuf.CodedInputStream input)
          throws java.io.IOException {
        return newBuilder().mergeFrom(input).buildParsed();
      }
      public static LogicalOperator parseFrom(
          com.google.protobuf.CodedInputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws java.io.IOException {
        return newBuilder().mergeFrom(input, extensionRegistry)
                 .buildParsed();
      }
      
      public static Builder newBuilder() { return Builder.create(); }
      public Builder newBuilderForType() { return newBuilder(); }
      public static Builder newBuilder(LogicalOperator prototype) {
        return newBuilder().mergeFrom(prototype);
      }
      public Builder toBuilder() { return newBuilder(this); }
      
      @Override
      protected Builder newBuilderForType(
          BuilderParent parent) {
        Builder builder = new Builder(parent);
        return builder;
      }
      public static final class Builder extends
          com.google.protobuf.GeneratedMessage.Builder<Builder>
         implements LogicalOperatorOrBuilder {
        public static final com.google.protobuf.Descriptors.Descriptor
            getDescriptor() {
          return Lot.internal_static_apsara_odps_lot_LogicalOperator_descriptor;
        }
        
        protected FieldAccessorTable
            internalGetFieldAccessorTable() {
          return Lot.internal_static_apsara_odps_lot_LogicalOperator_fieldAccessorTable;
        }
        
        // Construct using apsara.odps.lot.Lot.LogicalOperator.newBuilder()
        private Builder() {
          maybeForceBuilderInitialization();
        }
        
        private Builder(BuilderParent parent) {
          super(parent);
          maybeForceBuilderInitialization();
        }
        private void maybeForceBuilderInitialization() {
          if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
            getApplyFieldBuilder();
            getDistributeByFieldBuilder();
            getFilterFieldBuilder();
            getAggregateFieldBuilder();
            getJoinFieldBuilder();
            getSelectFieldBuilder();
            getSortByFieldBuilder();
            getDataSourceFieldBuilder();
            getDataSinkFieldBuilder();
            getLimitFieldBuilder();
            getUnionAllFieldBuilder();
            getWindowFieldBuilder();
            getTransformFieldBuilder();
          }
        }
        private static Builder create() {
          return new Builder();
        }
        
        public Builder clear() {
          super.clear();
          if (applyBuilder_ == null) {
            apply_ = ApplyProtos.Apply.getDefaultInstance();
          } else {
            applyBuilder_.clear();
          }
          bitField0_ = (bitField0_ & ~0x00000001);
          if (distributeByBuilder_ == null) {
            distributeBy_ = DistributeByProtos.DistributeBy.getDefaultInstance();
          } else {
            distributeByBuilder_.clear();
          }
          bitField0_ = (bitField0_ & ~0x00000002);
          if (filterBuilder_ == null) {
            filter_ = FilterProtos.Filter.getDefaultInstance();
          } else {
            filterBuilder_.clear();
          }
          bitField0_ = (bitField0_ & ~0x00000004);
          if (aggregateBuilder_ == null) {
            aggregate_ = AggregateProtos.Aggregate.getDefaultInstance();
          } else {
            aggregateBuilder_.clear();
          }
          bitField0_ = (bitField0_ & ~0x00000008);
          if (joinBuilder_ == null) {
            join_ = JoinProtos.Join.getDefaultInstance();
          } else {
            joinBuilder_.clear();
          }
          bitField0_ = (bitField0_ & ~0x00000010);
          if (selectBuilder_ == null) {
            select_ = SelectProtos.Select.getDefaultInstance();
          } else {
            selectBuilder_.clear();
          }
          bitField0_ = (bitField0_ & ~0x00000020);
          if (sortByBuilder_ == null) {
            sortBy_ = SortByProtos.SortBy.getDefaultInstance();
          } else {
            sortByBuilder_.clear();
          }
          bitField0_ = (bitField0_ & ~0x00000040);
          if (dataSourceBuilder_ == null) {
            dataSource_ = DataSourceProtos.DataSource.getDefaultInstance();
          } else {
            dataSourceBuilder_.clear();
          }
          bitField0_ = (bitField0_ & ~0x00000080);
          if (dataSinkBuilder_ == null) {
            dataSink_ = DataSinkProtos.DataSink.getDefaultInstance();
          } else {
            dataSinkBuilder_.clear();
          }
          bitField0_ = (bitField0_ & ~0x00000100);
          if (limitBuilder_ == null) {
            limit_ = LimitProtos.Limit.getDefaultInstance();
          } else {
            limitBuilder_.clear();
          }
          bitField0_ = (bitField0_ & ~0x00000200);
          if (unionAllBuilder_ == null) {
            unionAll_ = UnionAllProtos.UnionAll.getDefaultInstance();
          } else {
            unionAllBuilder_.clear();
          }
          bitField0_ = (bitField0_ & ~0x00000400);
          if (windowBuilder_ == null) {
            window_ = WindowProtos.Window.getDefaultInstance();
          } else {
            windowBuilder_.clear();
          }
          bitField0_ = (bitField0_ & ~0x00000800);
          if (transformBuilder_ == null) {
            transform_ = TransformProtos.Transform.getDefaultInstance();
          } else {
            transformBuilder_.clear();
          }
          bitField0_ = (bitField0_ & ~0x00001000);
          return this;
        }
        
        public Builder clone() {
          return create().mergeFrom(buildPartial());
        }
        
        public com.google.protobuf.Descriptors.Descriptor
            getDescriptorForType() {
          return LogicalOperator.getDescriptor();
        }
        
        public LogicalOperator getDefaultInstanceForType() {
          return LogicalOperator.getDefaultInstance();
        }
        
        public LogicalOperator build() {
          LogicalOperator result = buildPartial();
          if (!result.isInitialized()) {
            throw newUninitializedMessageException(result);
          }
          return result;
        }
        
        private LogicalOperator buildParsed()
            throws com.google.protobuf.InvalidProtocolBufferException {
          LogicalOperator result = buildPartial();
          if (!result.isInitialized()) {
            throw newUninitializedMessageException(
              result).asInvalidProtocolBufferException();
          }
          return result;
        }
        
        public LogicalOperator buildPartial() {
          LogicalOperator result = new LogicalOperator(this);
          int from_bitField0_ = bitField0_;
          int to_bitField0_ = 0;
          if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
            to_bitField0_ |= 0x00000001;
          }
          if (applyBuilder_ == null) {
            result.apply_ = apply_;
          } else {
            result.apply_ = applyBuilder_.build();
          }
          if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
            to_bitField0_ |= 0x00000002;
          }
          if (distributeByBuilder_ == null) {
            result.distributeBy_ = distributeBy_;
          } else {
            result.distributeBy_ = distributeByBuilder_.build();
          }
          if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
            to_bitField0_ |= 0x00000004;
          }
          if (filterBuilder_ == null) {
            result.filter_ = filter_;
          } else {
            result.filter_ = filterBuilder_.build();
          }
          if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
            to_bitField0_ |= 0x00000008;
          }
          if (aggregateBuilder_ == null) {
            result.aggregate_ = aggregate_;
          } else {
            result.aggregate_ = aggregateBuilder_.build();
          }
          if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
            to_bitField0_ |= 0x00000010;
          }
          if (joinBuilder_ == null) {
            result.join_ = join_;
          } else {
            result.join_ = joinBuilder_.build();
          }
          if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
            to_bitField0_ |= 0x00000020;
          }
          if (selectBuilder_ == null) {
            result.select_ = select_;
          } else {
            result.select_ = selectBuilder_.build();
          }
          if (((from_bitField0_ & 0x00000040) == 0x00000040)) {
            to_bitField0_ |= 0x00000040;
          }
          if (sortByBuilder_ == null) {
            result.sortBy_ = sortBy_;
          } else {
            result.sortBy_ = sortByBuilder_.build();
          }
          if (((from_bitField0_ & 0x00000080) == 0x00000080)) {
            to_bitField0_ |= 0x00000080;
          }
          if (dataSourceBuilder_ == null) {
            result.dataSource_ = dataSource_;
          } else {
            result.dataSource_ = dataSourceBuilder_.build();
          }
          if (((from_bitField0_ & 0x00000100) == 0x00000100)) {
            to_bitField0_ |= 0x00000100;
          }
          if (dataSinkBuilder_ == null) {
            result.dataSink_ = dataSink_;
          } else {
            result.dataSink_ = dataSinkBuilder_.build();
          }
          if (((from_bitField0_ & 0x00000200) == 0x00000200)) {
            to_bitField0_ |= 0x00000200;
          }
          if (limitBuilder_ == null) {
            result.limit_ = limit_;
          } else {
            result.limit_ = limitBuilder_.build();
          }
          if (((from_bitField0_ & 0x00000400) == 0x00000400)) {
            to_bitField0_ |= 0x00000400;
          }
          if (unionAllBuilder_ == null) {
            result.unionAll_ = unionAll_;
          } else {
            result.unionAll_ = unionAllBuilder_.build();
          }
          if (((from_bitField0_ & 0x00000800) == 0x00000800)) {
            to_bitField0_ |= 0x00000800;
          }
          if (windowBuilder_ == null) {
            result.window_ = window_;
          } else {
            result.window_ = windowBuilder_.build();
          }
          if (((from_bitField0_ & 0x00001000) == 0x00001000)) {
            to_bitField0_ |= 0x00001000;
          }
          if (transformBuilder_ == null) {
            result.transform_ = transform_;
          } else {
            result.transform_ = transformBuilder_.build();
          }
          result.bitField0_ = to_bitField0_;
          onBuilt();
          return result;
        }
        
        public Builder mergeFrom(com.google.protobuf.Message other) {
          if (other instanceof LogicalOperator) {
            return mergeFrom((LogicalOperator)other);
          } else {
            super.mergeFrom(other);
            return this;
          }
        }
        
        public Builder mergeFrom(LogicalOperator other) {
          if (other == LogicalOperator.getDefaultInstance()) return this;
          if (other.hasApply()) {
            mergeApply(other.getApply());
          }
          if (other.hasDistributeBy()) {
            mergeDistributeBy(other.getDistributeBy());
          }
          if (other.hasFilter()) {
            mergeFilter(other.getFilter());
          }
          if (other.hasAggregate()) {
            mergeAggregate(other.getAggregate());
          }
          if (other.hasJoin()) {
            mergeJoin(other.getJoin());
          }
          if (other.hasSelect()) {
            mergeSelect(other.getSelect());
          }
          if (other.hasSortBy()) {
            mergeSortBy(other.getSortBy());
          }
          if (other.hasDataSource()) {
            mergeDataSource(other.getDataSource());
          }
          if (other.hasDataSink()) {
            mergeDataSink(other.getDataSink());
          }
          if (other.hasLimit()) {
            mergeLimit(other.getLimit());
          }
          if (other.hasUnionAll()) {
            mergeUnionAll(other.getUnionAll());
          }
          if (other.hasWindow()) {
            mergeWindow(other.getWindow());
          }
          if (other.hasTransform()) {
            mergeTransform(other.getTransform());
          }
          this.mergeUnknownFields(other.getUnknownFields());
          return this;
        }
        
        public final boolean isInitialized() {
          if (hasApply()) {
            if (!getApply().isInitialized()) {
              
              return false;
            }
          }
          if (hasDistributeBy()) {
            if (!getDistributeBy().isInitialized()) {
              
              return false;
            }
          }
          if (hasFilter()) {
            if (!getFilter().isInitialized()) {
              
              return false;
            }
          }
          if (hasAggregate()) {
            if (!getAggregate().isInitialized()) {
              
              return false;
            }
          }
          if (hasJoin()) {
            if (!getJoin().isInitialized()) {
              
              return false;
            }
          }
          if (hasSelect()) {
            if (!getSelect().isInitialized()) {
              
              return false;
            }
          }
          if (hasSortBy()) {
            if (!getSortBy().isInitialized()) {
              
              return false;
            }
          }
          if (hasDataSource()) {
            if (!getDataSource().isInitialized()) {
              
              return false;
            }
          }
          if (hasDataSink()) {
            if (!getDataSink().isInitialized()) {
              
              return false;
            }
          }
          if (hasLimit()) {
            if (!getLimit().isInitialized()) {
              
              return false;
            }
          }
          if (hasUnionAll()) {
            if (!getUnionAll().isInitialized()) {
              
              return false;
            }
          }
          if (hasWindow()) {
            if (!getWindow().isInitialized()) {
              
              return false;
            }
          }
          if (hasTransform()) {
            if (!getTransform().isInitialized()) {
              
              return false;
            }
          }
          return true;
        }
        
        public Builder mergeFrom(
            com.google.protobuf.CodedInputStream input,
            com.google.protobuf.ExtensionRegistryLite extensionRegistry)
            throws java.io.IOException {
          com.google.protobuf.UnknownFieldSet.Builder unknownFields =
            com.google.protobuf.UnknownFieldSet.newBuilder(
              this.getUnknownFields());
          while (true) {
            int tag = input.readTag();
            switch (tag) {
              case 0:
                this.setUnknownFields(unknownFields.build());
                onChanged();
                return this;
              default: {
                if (!parseUnknownField(input, unknownFields,
                                       extensionRegistry, tag)) {
                  this.setUnknownFields(unknownFields.build());
                  onChanged();
                  return this;
                }
                break;
              }
              case 10: {
                ApplyProtos.Apply.Builder subBuilder = ApplyProtos.Apply.newBuilder();
                if (hasApply()) {
                  subBuilder.mergeFrom(getApply());
                }
                input.readMessage(subBuilder, extensionRegistry);
                setApply(subBuilder.buildPartial());
                break;
              }
              case 18: {
                DistributeByProtos.DistributeBy.Builder subBuilder = DistributeByProtos.DistributeBy.newBuilder();
                if (hasDistributeBy()) {
                  subBuilder.mergeFrom(getDistributeBy());
                }
                input.readMessage(subBuilder, extensionRegistry);
                setDistributeBy(subBuilder.buildPartial());
                break;
              }
              case 26: {
                FilterProtos.Filter.Builder subBuilder = FilterProtos.Filter.newBuilder();
                if (hasFilter()) {
                  subBuilder.mergeFrom(getFilter());
                }
                input.readMessage(subBuilder, extensionRegistry);
                setFilter(subBuilder.buildPartial());
                break;
              }
              case 34: {
                AggregateProtos.Aggregate.Builder subBuilder = AggregateProtos.Aggregate.newBuilder();
                if (hasAggregate()) {
                  subBuilder.mergeFrom(getAggregate());
                }
                input.readMessage(subBuilder, extensionRegistry);
                setAggregate(subBuilder.buildPartial());
                break;
              }
              case 42: {
                JoinProtos.Join.Builder subBuilder = JoinProtos.Join.newBuilder();
                if (hasJoin()) {
                  subBuilder.mergeFrom(getJoin());
                }
                input.readMessage(subBuilder, extensionRegistry);
                setJoin(subBuilder.buildPartial());
                break;
              }
              case 50: {
                SelectProtos.Select.Builder subBuilder = SelectProtos.Select.newBuilder();
                if (hasSelect()) {
                  subBuilder.mergeFrom(getSelect());
                }
                input.readMessage(subBuilder, extensionRegistry);
                setSelect(subBuilder.buildPartial());
                break;
              }
              case 58: {
                SortByProtos.SortBy.Builder subBuilder = SortByProtos.SortBy.newBuilder();
                if (hasSortBy()) {
                  subBuilder.mergeFrom(getSortBy());
                }
                input.readMessage(subBuilder, extensionRegistry);
                setSortBy(subBuilder.buildPartial());
                break;
              }
              case 66: {
                DataSourceProtos.DataSource.Builder subBuilder = DataSourceProtos.DataSource.newBuilder();
                if (hasDataSource()) {
                  subBuilder.mergeFrom(getDataSource());
                }
                input.readMessage(subBuilder, extensionRegistry);
                setDataSource(subBuilder.buildPartial());
                break;
              }
              case 74: {
                DataSinkProtos.DataSink.Builder subBuilder = DataSinkProtos.DataSink.newBuilder();
                if (hasDataSink()) {
                  subBuilder.mergeFrom(getDataSink());
                }
                input.readMessage(subBuilder, extensionRegistry);
                setDataSink(subBuilder.buildPartial());
                break;
              }
              case 82: {
                LimitProtos.Limit.Builder subBuilder = LimitProtos.Limit.newBuilder();
                if (hasLimit()) {
                  subBuilder.mergeFrom(getLimit());
                }
                input.readMessage(subBuilder, extensionRegistry);
                setLimit(subBuilder.buildPartial());
                break;
              }
              case 90: {
                UnionAllProtos.UnionAll.Builder subBuilder = UnionAllProtos.UnionAll.newBuilder();
                if (hasUnionAll()) {
                  subBuilder.mergeFrom(getUnionAll());
                }
                input.readMessage(subBuilder, extensionRegistry);
                setUnionAll(subBuilder.buildPartial());
                break;
              }
              case 98: {
                WindowProtos.Window.Builder subBuilder = WindowProtos.Window.newBuilder();
                if (hasWindow()) {
                  subBuilder.mergeFrom(getWindow());
                }
                input.readMessage(subBuilder, extensionRegistry);
                setWindow(subBuilder.buildPartial());
                break;
              }
              case 106: {
                TransformProtos.Transform.Builder subBuilder = TransformProtos.Transform.newBuilder();
                if (hasTransform()) {
                  subBuilder.mergeFrom(getTransform());
                }
                input.readMessage(subBuilder, extensionRegistry);
                setTransform(subBuilder.buildPartial());
                break;
              }
            }
          }
        }
        
        private int bitField0_;
        
        // optional .apsara.odps.lot.Apply Apply = 1;
        private ApplyProtos.Apply apply_ = ApplyProtos.Apply.getDefaultInstance();
        private com.google.protobuf.SingleFieldBuilder<
            ApplyProtos.Apply, ApplyProtos.Apply.Builder, ApplyProtos.ApplyOrBuilder> applyBuilder_;
        public boolean hasApply() {
          return ((bitField0_ & 0x00000001) == 0x00000001);
        }
        public ApplyProtos.Apply getApply() {
          if (applyBuilder_ == null) {
            return apply_;
          } else {
            return applyBuilder_.getMessage();
          }
        }
        public Builder setApply(ApplyProtos.Apply value) {
          if (applyBuilder_ == null) {
            if (value == null) {
              throw new NullPointerException();
            }
            apply_ = value;
            onChanged();
          } else {
            applyBuilder_.setMessage(value);
          }
          bitField0_ |= 0x00000001;
          return this;
        }
        public Builder setApply(
            ApplyProtos.Apply.Builder builderForValue) {
          if (applyBuilder_ == null) {
            apply_ = builderForValue.build();
            onChanged();
          } else {
            applyBuilder_.setMessage(builderForValue.build());
          }
          bitField0_ |= 0x00000001;
          return this;
        }
        public Builder mergeApply(ApplyProtos.Apply value) {
          if (applyBuilder_ == null) {
            if (((bitField0_ & 0x00000001) == 0x00000001) &&
                apply_ != ApplyProtos.Apply.getDefaultInstance()) {
              apply_ =
                ApplyProtos.Apply.newBuilder(apply_).mergeFrom(value).buildPartial();
            } else {
              apply_ = value;
            }
            onChanged();
          } else {
            applyBuilder_.mergeFrom(value);
          }
          bitField0_ |= 0x00000001;
          return this;
        }
        public Builder clearApply() {
          if (applyBuilder_ == null) {
            apply_ = ApplyProtos.Apply.getDefaultInstance();
            onChanged();
          } else {
            applyBuilder_.clear();
          }
          bitField0_ = (bitField0_ & ~0x00000001);
          return this;
        }
        public ApplyProtos.Apply.Builder getApplyBuilder() {
          bitField0_ |= 0x00000001;
          onChanged();
          return getApplyFieldBuilder().getBuilder();
        }
        public ApplyProtos.ApplyOrBuilder getApplyOrBuilder() {
          if (applyBuilder_ != null) {
            return applyBuilder_.getMessageOrBuilder();
          } else {
            return apply_;
          }
        }
        private com.google.protobuf.SingleFieldBuilder<
            ApplyProtos.Apply, ApplyProtos.Apply.Builder, ApplyProtos.ApplyOrBuilder>
            getApplyFieldBuilder() {
          if (applyBuilder_ == null) {
            applyBuilder_ = new com.google.protobuf.SingleFieldBuilder<
                ApplyProtos.Apply, ApplyProtos.Apply.Builder, ApplyProtos.ApplyOrBuilder>(
                    apply_,
                    getParentForChildren(),
                    isClean());
            apply_ = null;
          }
          return applyBuilder_;
        }
        
        // optional .apsara.odps.lot.DistributeBy DistributeBy = 2;
        private DistributeByProtos.DistributeBy distributeBy_ = DistributeByProtos.DistributeBy.getDefaultInstance();
        private com.google.protobuf.SingleFieldBuilder<
            DistributeByProtos.DistributeBy, DistributeByProtos.DistributeBy.Builder, DistributeByProtos.DistributeByOrBuilder> distributeByBuilder_;
        public boolean hasDistributeBy() {
          return ((bitField0_ & 0x00000002) == 0x00000002);
        }
        public DistributeByProtos.DistributeBy getDistributeBy() {
          if (distributeByBuilder_ == null) {
            return distributeBy_;
          } else {
            return distributeByBuilder_.getMessage();
          }
        }
        public Builder setDistributeBy(DistributeByProtos.DistributeBy value) {
          if (distributeByBuilder_ == null) {
            if (value == null) {
              throw new NullPointerException();
            }
            distributeBy_ = value;
            onChanged();
          } else {
            distributeByBuilder_.setMessage(value);
          }
          bitField0_ |= 0x00000002;
          return this;
        }
        public Builder setDistributeBy(
            DistributeByProtos.DistributeBy.Builder builderForValue) {
          if (distributeByBuilder_ == null) {
            distributeBy_ = builderForValue.build();
            onChanged();
          } else {
            distributeByBuilder_.setMessage(builderForValue.build());
          }
          bitField0_ |= 0x00000002;
          return this;
        }
        public Builder mergeDistributeBy(DistributeByProtos.DistributeBy value) {
          if (distributeByBuilder_ == null) {
            if (((bitField0_ & 0x00000002) == 0x00000002) &&
                distributeBy_ != DistributeByProtos.DistributeBy.getDefaultInstance()) {
              distributeBy_ =
                DistributeByProtos.DistributeBy.newBuilder(distributeBy_).mergeFrom(value).buildPartial();
            } else {
              distributeBy_ = value;
            }
            onChanged();
          } else {
            distributeByBuilder_.mergeFrom(value);
          }
          bitField0_ |= 0x00000002;
          return this;
        }
        public Builder clearDistributeBy() {
          if (distributeByBuilder_ == null) {
            distributeBy_ = DistributeByProtos.DistributeBy.getDefaultInstance();
            onChanged();
          } else {
            distributeByBuilder_.clear();
          }
          bitField0_ = (bitField0_ & ~0x00000002);
          return this;
        }
        public DistributeByProtos.DistributeBy.Builder getDistributeByBuilder() {
          bitField0_ |= 0x00000002;
          onChanged();
          return getDistributeByFieldBuilder().getBuilder();
        }
        public DistributeByProtos.DistributeByOrBuilder getDistributeByOrBuilder() {
          if (distributeByBuilder_ != null) {
            return distributeByBuilder_.getMessageOrBuilder();
          } else {
            return distributeBy_;
          }
        }
        private com.google.protobuf.SingleFieldBuilder<
            DistributeByProtos.DistributeBy, DistributeByProtos.DistributeBy.Builder, DistributeByProtos.DistributeByOrBuilder>
            getDistributeByFieldBuilder() {
          if (distributeByBuilder_ == null) {
            distributeByBuilder_ = new com.google.protobuf.SingleFieldBuilder<
                DistributeByProtos.DistributeBy, DistributeByProtos.DistributeBy.Builder, DistributeByProtos.DistributeByOrBuilder>(
                    distributeBy_,
                    getParentForChildren(),
                    isClean());
            distributeBy_ = null;
          }
          return distributeByBuilder_;
        }
        
        // optional .apsara.odps.lot.Filter Filter = 3;
        private FilterProtos.Filter filter_ = FilterProtos.Filter.getDefaultInstance();
        private com.google.protobuf.SingleFieldBuilder<
            FilterProtos.Filter, FilterProtos.Filter.Builder, FilterProtos.FilterOrBuilder> filterBuilder_;
        public boolean hasFilter() {
          return ((bitField0_ & 0x00000004) == 0x00000004);
        }
        public FilterProtos.Filter getFilter() {
          if (filterBuilder_ == null) {
            return filter_;
          } else {
            return filterBuilder_.getMessage();
          }
        }
        public Builder setFilter(FilterProtos.Filter value) {
          if (filterBuilder_ == null) {
            if (value == null) {
              throw new NullPointerException();
            }
            filter_ = value;
            onChanged();
          } else {
            filterBuilder_.setMessage(value);
          }
          bitField0_ |= 0x00000004;
          return this;
        }
        public Builder setFilter(
            FilterProtos.Filter.Builder builderForValue) {
          if (filterBuilder_ == null) {
            filter_ = builderForValue.build();
            onChanged();
          } else {
            filterBuilder_.setMessage(builderForValue.build());
          }
          bitField0_ |= 0x00000004;
          return this;
        }
        public Builder mergeFilter(FilterProtos.Filter value) {
          if (filterBuilder_ == null) {
            if (((bitField0_ & 0x00000004) == 0x00000004) &&
                filter_ != FilterProtos.Filter.getDefaultInstance()) {
              filter_ =
                FilterProtos.Filter.newBuilder(filter_).mergeFrom(value).buildPartial();
            } else {
              filter_ = value;
            }
            onChanged();
          } else {
            filterBuilder_.mergeFrom(value);
          }
          bitField0_ |= 0x00000004;
          return this;
        }
        public Builder clearFilter() {
          if (filterBuilder_ == null) {
            filter_ = FilterProtos.Filter.getDefaultInstance();
            onChanged();
          } else {
            filterBuilder_.clear();
          }
          bitField0_ = (bitField0_ & ~0x00000004);
          return this;
        }
        public FilterProtos.Filter.Builder getFilterBuilder() {
          bitField0_ |= 0x00000004;
          onChanged();
          return getFilterFieldBuilder().getBuilder();
        }
        public FilterProtos.FilterOrBuilder getFilterOrBuilder() {
          if (filterBuilder_ != null) {
            return filterBuilder_.getMessageOrBuilder();
          } else {
            return filter_;
          }
        }
        private com.google.protobuf.SingleFieldBuilder<
            FilterProtos.Filter, FilterProtos.Filter.Builder, FilterProtos.FilterOrBuilder>
            getFilterFieldBuilder() {
          if (filterBuilder_ == null) {
            filterBuilder_ = new com.google.protobuf.SingleFieldBuilder<
                FilterProtos.Filter, FilterProtos.Filter.Builder, FilterProtos.FilterOrBuilder>(
                    filter_,
                    getParentForChildren(),
                    isClean());
            filter_ = null;
          }
          return filterBuilder_;
        }
        
        // optional .apsara.odps.lot.Aggregate Aggregate = 4;
        private AggregateProtos.Aggregate aggregate_ = AggregateProtos.Aggregate.getDefaultInstance();
        private com.google.protobuf.SingleFieldBuilder<
            AggregateProtos.Aggregate, AggregateProtos.Aggregate.Builder, AggregateProtos.AggregateOrBuilder> aggregateBuilder_;
        public boolean hasAggregate() {
          return ((bitField0_ & 0x00000008) == 0x00000008);
        }
        public AggregateProtos.Aggregate getAggregate() {
          if (aggregateBuilder_ == null) {
            return aggregate_;
          } else {
            return aggregateBuilder_.getMessage();
          }
        }
        public Builder setAggregate(AggregateProtos.Aggregate value) {
          if (aggregateBuilder_ == null) {
            if (value == null) {
              throw new NullPointerException();
            }
            aggregate_ = value;
            onChanged();
          } else {
            aggregateBuilder_.setMessage(value);
          }
          bitField0_ |= 0x00000008;
          return this;
        }
        public Builder setAggregate(
            AggregateProtos.Aggregate.Builder builderForValue) {
          if (aggregateBuilder_ == null) {
            aggregate_ = builderForValue.build();
            onChanged();
          } else {
            aggregateBuilder_.setMessage(builderForValue.build());
          }
          bitField0_ |= 0x00000008;
          return this;
        }
        public Builder mergeAggregate(AggregateProtos.Aggregate value) {
          if (aggregateBuilder_ == null) {
            if (((bitField0_ & 0x00000008) == 0x00000008) &&
                aggregate_ != AggregateProtos.Aggregate.getDefaultInstance()) {
              aggregate_ =
                AggregateProtos.Aggregate.newBuilder(aggregate_).mergeFrom(value).buildPartial();
            } else {
              aggregate_ = value;
            }
            onChanged();
          } else {
            aggregateBuilder_.mergeFrom(value);
          }
          bitField0_ |= 0x00000008;
          return this;
        }
        public Builder clearAggregate() {
          if (aggregateBuilder_ == null) {
            aggregate_ = AggregateProtos.Aggregate.getDefaultInstance();
            onChanged();
          } else {
            aggregateBuilder_.clear();
          }
          bitField0_ = (bitField0_ & ~0x00000008);
          return this;
        }
        public AggregateProtos.Aggregate.Builder getAggregateBuilder() {
          bitField0_ |= 0x00000008;
          onChanged();
          return getAggregateFieldBuilder().getBuilder();
        }
        public AggregateProtos.AggregateOrBuilder getAggregateOrBuilder() {
          if (aggregateBuilder_ != null) {
            return aggregateBuilder_.getMessageOrBuilder();
          } else {
            return aggregate_;
          }
        }
        private com.google.protobuf.SingleFieldBuilder<
            AggregateProtos.Aggregate, AggregateProtos.Aggregate.Builder, AggregateProtos.AggregateOrBuilder>
            getAggregateFieldBuilder() {
          if (aggregateBuilder_ == null) {
            aggregateBuilder_ = new com.google.protobuf.SingleFieldBuilder<
                AggregateProtos.Aggregate, AggregateProtos.Aggregate.Builder, AggregateProtos.AggregateOrBuilder>(
                    aggregate_,
                    getParentForChildren(),
                    isClean());
            aggregate_ = null;
          }
          return aggregateBuilder_;
        }
        
        // optional .apsara.odps.lot.Join Join = 5;
        private JoinProtos.Join join_ = JoinProtos.Join.getDefaultInstance();
        private com.google.protobuf.SingleFieldBuilder<
            JoinProtos.Join, JoinProtos.Join.Builder, JoinProtos.JoinOrBuilder> joinBuilder_;
        public boolean hasJoin() {
          return ((bitField0_ & 0x00000010) == 0x00000010);
        }
        public JoinProtos.Join getJoin() {
          if (joinBuilder_ == null) {
            return join_;
          } else {
            return joinBuilder_.getMessage();
          }
        }
        public Builder setJoin(JoinProtos.Join value) {
          if (joinBuilder_ == null) {
            if (value == null) {
              throw new NullPointerException();
            }
            join_ = value;
            onChanged();
          } else {
            joinBuilder_.setMessage(value);
          }
          bitField0_ |= 0x00000010;
          return this;
        }
        public Builder setJoin(
            JoinProtos.Join.Builder builderForValue) {
          if (joinBuilder_ == null) {
            join_ = builderForValue.build();
            onChanged();
          } else {
            joinBuilder_.setMessage(builderForValue.build());
          }
          bitField0_ |= 0x00000010;
          return this;
        }
        public Builder mergeJoin(JoinProtos.Join value) {
          if (joinBuilder_ == null) {
            if (((bitField0_ & 0x00000010) == 0x00000010) &&
                join_ != JoinProtos.Join.getDefaultInstance()) {
              join_ =
                JoinProtos.Join.newBuilder(join_).mergeFrom(value).buildPartial();
            } else {
              join_ = value;
            }
            onChanged();
          } else {
            joinBuilder_.mergeFrom(value);
          }
          bitField0_ |= 0x00000010;
          return this;
        }
        public Builder clearJoin() {
          if (joinBuilder_ == null) {
            join_ = JoinProtos.Join.getDefaultInstance();
            onChanged();
          } else {
            joinBuilder_.clear();
          }
          bitField0_ = (bitField0_ & ~0x00000010);
          return this;
        }
        public JoinProtos.Join.Builder getJoinBuilder() {
          bitField0_ |= 0x00000010;
          onChanged();
          return getJoinFieldBuilder().getBuilder();
        }
        public JoinProtos.JoinOrBuilder getJoinOrBuilder() {
          if (joinBuilder_ != null) {
            return joinBuilder_.getMessageOrBuilder();
          } else {
            return join_;
          }
        }
        private com.google.protobuf.SingleFieldBuilder<
            JoinProtos.Join, JoinProtos.Join.Builder, JoinProtos.JoinOrBuilder>
            getJoinFieldBuilder() {
          if (joinBuilder_ == null) {
            joinBuilder_ = new com.google.protobuf.SingleFieldBuilder<
                JoinProtos.Join, JoinProtos.Join.Builder, JoinProtos.JoinOrBuilder>(
                    join_,
                    getParentForChildren(),
                    isClean());
            join_ = null;
          }
          return joinBuilder_;
        }
        
        // optional .apsara.odps.lot.Select Select = 6;
        private SelectProtos.Select select_ = SelectProtos.Select.getDefaultInstance();
        private com.google.protobuf.SingleFieldBuilder<
            SelectProtos.Select, SelectProtos.Select.Builder, SelectProtos.SelectOrBuilder> selectBuilder_;
        public boolean hasSelect() {
          return ((bitField0_ & 0x00000020) == 0x00000020);
        }
        public SelectProtos.Select getSelect() {
          if (selectBuilder_ == null) {
            return select_;
          } else {
            return selectBuilder_.getMessage();
          }
        }
        public Builder setSelect(SelectProtos.Select value) {
          if (selectBuilder_ == null) {
            if (value == null) {
              throw new NullPointerException();
            }
            select_ = value;
            onChanged();
          } else {
            selectBuilder_.setMessage(value);
          }
          bitField0_ |= 0x00000020;
          return this;
        }
        public Builder setSelect(
            SelectProtos.Select.Builder builderForValue) {
          if (selectBuilder_ == null) {
            select_ = builderForValue.build();
            onChanged();
          } else {
            selectBuilder_.setMessage(builderForValue.build());
          }
          bitField0_ |= 0x00000020;
          return this;
        }
        public Builder mergeSelect(SelectProtos.Select value) {
          if (selectBuilder_ == null) {
            if (((bitField0_ & 0x00000020) == 0x00000020) &&
                select_ != SelectProtos.Select.getDefaultInstance()) {
              select_ =
                SelectProtos.Select.newBuilder(select_).mergeFrom(value).buildPartial();
            } else {
              select_ = value;
            }
            onChanged();
          } else {
            selectBuilder_.mergeFrom(value);
          }
          bitField0_ |= 0x00000020;
          return this;
        }
        public Builder clearSelect() {
          if (selectBuilder_ == null) {
            select_ = SelectProtos.Select.getDefaultInstance();
            onChanged();
          } else {
            selectBuilder_.clear();
          }
          bitField0_ = (bitField0_ & ~0x00000020);
          return this;
        }
        public SelectProtos.Select.Builder getSelectBuilder() {
          bitField0_ |= 0x00000020;
          onChanged();
          return getSelectFieldBuilder().getBuilder();
        }
        public SelectProtos.SelectOrBuilder getSelectOrBuilder() {
          if (selectBuilder_ != null) {
            return selectBuilder_.getMessageOrBuilder();
          } else {
            return select_;
          }
        }
        private com.google.protobuf.SingleFieldBuilder<
            SelectProtos.Select, SelectProtos.Select.Builder, SelectProtos.SelectOrBuilder>
            getSelectFieldBuilder() {
          if (selectBuilder_ == null) {
            selectBuilder_ = new com.google.protobuf.SingleFieldBuilder<
                SelectProtos.Select, SelectProtos.Select.Builder, SelectProtos.SelectOrBuilder>(
                    select_,
                    getParentForChildren(),
                    isClean());
            select_ = null;
          }
          return selectBuilder_;
        }
        
        // optional .apsara.odps.lot.SortBy SortBy = 7;
        private SortByProtos.SortBy sortBy_ = SortByProtos.SortBy.getDefaultInstance();
        private com.google.protobuf.SingleFieldBuilder<
            SortByProtos.SortBy, SortByProtos.SortBy.Builder, SortByProtos.SortByOrBuilder> sortByBuilder_;
        public boolean hasSortBy() {
          return ((bitField0_ & 0x00000040) == 0x00000040);
        }
        public SortByProtos.SortBy getSortBy() {
          if (sortByBuilder_ == null) {
            return sortBy_;
          } else {
            return sortByBuilder_.getMessage();
          }
        }
        public Builder setSortBy(SortByProtos.SortBy value) {
          if (sortByBuilder_ == null) {
            if (value == null) {
              throw new NullPointerException();
            }
            sortBy_ = value;
            onChanged();
          } else {
            sortByBuilder_.setMessage(value);
          }
          bitField0_ |= 0x00000040;
          return this;
        }
        public Builder setSortBy(
            SortByProtos.SortBy.Builder builderForValue) {
          if (sortByBuilder_ == null) {
            sortBy_ = builderForValue.build();
            onChanged();
          } else {
            sortByBuilder_.setMessage(builderForValue.build());
          }
          bitField0_ |= 0x00000040;
          return this;
        }
        public Builder mergeSortBy(SortByProtos.SortBy value) {
          if (sortByBuilder_ == null) {
            if (((bitField0_ & 0x00000040) == 0x00000040) &&
                sortBy_ != SortByProtos.SortBy.getDefaultInstance()) {
              sortBy_ =
                SortByProtos.SortBy.newBuilder(sortBy_).mergeFrom(value).buildPartial();
            } else {
              sortBy_ = value;
            }
            onChanged();
          } else {
            sortByBuilder_.mergeFrom(value);
          }
          bitField0_ |= 0x00000040;
          return this;
        }
        public Builder clearSortBy() {
          if (sortByBuilder_ == null) {
            sortBy_ = SortByProtos.SortBy.getDefaultInstance();
            onChanged();
          } else {
            sortByBuilder_.clear();
          }
          bitField0_ = (bitField0_ & ~0x00000040);
          return this;
        }
        public SortByProtos.SortBy.Builder getSortByBuilder() {
          bitField0_ |= 0x00000040;
          onChanged();
          return getSortByFieldBuilder().getBuilder();
        }
        public SortByProtos.SortByOrBuilder getSortByOrBuilder() {
          if (sortByBuilder_ != null) {
            return sortByBuilder_.getMessageOrBuilder();
          } else {
            return sortBy_;
          }
        }
        private com.google.protobuf.SingleFieldBuilder<
            SortByProtos.SortBy, SortByProtos.SortBy.Builder, SortByProtos.SortByOrBuilder>
            getSortByFieldBuilder() {
          if (sortByBuilder_ == null) {
            sortByBuilder_ = new com.google.protobuf.SingleFieldBuilder<
                SortByProtos.SortBy, SortByProtos.SortBy.Builder, SortByProtos.SortByOrBuilder>(
                    sortBy_,
                    getParentForChildren(),
                    isClean());
            sortBy_ = null;
          }
          return sortByBuilder_;
        }
        
        // optional .apsara.odps.lot.DataSource DataSource = 8;
        private DataSourceProtos.DataSource dataSource_ = DataSourceProtos.DataSource.getDefaultInstance();
        private com.google.protobuf.SingleFieldBuilder<
            DataSourceProtos.DataSource, DataSourceProtos.DataSource.Builder, DataSourceProtos.DataSourceOrBuilder> dataSourceBuilder_;
        public boolean hasDataSource() {
          return ((bitField0_ & 0x00000080) == 0x00000080);
        }
        public DataSourceProtos.DataSource getDataSource() {
          if (dataSourceBuilder_ == null) {
            return dataSource_;
          } else {
            return dataSourceBuilder_.getMessage();
          }
        }
        public Builder setDataSource(DataSourceProtos.DataSource value) {
          if (dataSourceBuilder_ == null) {
            if (value == null) {
              throw new NullPointerException();
            }
            dataSource_ = value;
            onChanged();
          } else {
            dataSourceBuilder_.setMessage(value);
          }
          bitField0_ |= 0x00000080;
          return this;
        }
        public Builder setDataSource(
            DataSourceProtos.DataSource.Builder builderForValue) {
          if (dataSourceBuilder_ == null) {
            dataSource_ = builderForValue.build();
            onChanged();
          } else {
            dataSourceBuilder_.setMessage(builderForValue.build());
          }
          bitField0_ |= 0x00000080;
          return this;
        }
        public Builder mergeDataSource(DataSourceProtos.DataSource value) {
          if (dataSourceBuilder_ == null) {
            if (((bitField0_ & 0x00000080) == 0x00000080) &&
                dataSource_ != DataSourceProtos.DataSource.getDefaultInstance()) {
              dataSource_ =
                DataSourceProtos.DataSource.newBuilder(dataSource_).mergeFrom(value).buildPartial();
            } else {
              dataSource_ = value;
            }
            onChanged();
          } else {
            dataSourceBuilder_.mergeFrom(value);
          }
          bitField0_ |= 0x00000080;
          return this;
        }
        public Builder clearDataSource() {
          if (dataSourceBuilder_ == null) {
            dataSource_ = DataSourceProtos.DataSource.getDefaultInstance();
            onChanged();
          } else {
            dataSourceBuilder_.clear();
          }
          bitField0_ = (bitField0_ & ~0x00000080);
          return this;
        }
        public DataSourceProtos.DataSource.Builder getDataSourceBuilder() {
          bitField0_ |= 0x00000080;
          onChanged();
          return getDataSourceFieldBuilder().getBuilder();
        }
        public DataSourceProtos.DataSourceOrBuilder getDataSourceOrBuilder() {
          if (dataSourceBuilder_ != null) {
            return dataSourceBuilder_.getMessageOrBuilder();
          } else {
            return dataSource_;
          }
        }
        private com.google.protobuf.SingleFieldBuilder<
            DataSourceProtos.DataSource, DataSourceProtos.DataSource.Builder, DataSourceProtos.DataSourceOrBuilder>
            getDataSourceFieldBuilder() {
          if (dataSourceBuilder_ == null) {
            dataSourceBuilder_ = new com.google.protobuf.SingleFieldBuilder<
                DataSourceProtos.DataSource, DataSourceProtos.DataSource.Builder, DataSourceProtos.DataSourceOrBuilder>(
                    dataSource_,
                    getParentForChildren(),
                    isClean());
            dataSource_ = null;
          }
          return dataSourceBuilder_;
        }
        
        // optional .apsara.odps.lot.DataSink DataSink = 9;
        private DataSinkProtos.DataSink dataSink_ = DataSinkProtos.DataSink.getDefaultInstance();
        private com.google.protobuf.SingleFieldBuilder<
            DataSinkProtos.DataSink, DataSinkProtos.DataSink.Builder, DataSinkProtos.DataSinkOrBuilder> dataSinkBuilder_;
        public boolean hasDataSink() {
          return ((bitField0_ & 0x00000100) == 0x00000100);
        }
        public DataSinkProtos.DataSink getDataSink() {
          if (dataSinkBuilder_ == null) {
            return dataSink_;
          } else {
            return dataSinkBuilder_.getMessage();
          }
        }
        public Builder setDataSink(DataSinkProtos.DataSink value) {
          if (dataSinkBuilder_ == null) {
            if (value == null) {
              throw new NullPointerException();
            }
            dataSink_ = value;
            onChanged();
          } else {
            dataSinkBuilder_.setMessage(value);
          }
          bitField0_ |= 0x00000100;
          return this;
        }
        public Builder setDataSink(
            DataSinkProtos.DataSink.Builder builderForValue) {
          if (dataSinkBuilder_ == null) {
            dataSink_ = builderForValue.build();
            onChanged();
          } else {
            dataSinkBuilder_.setMessage(builderForValue.build());
          }
          bitField0_ |= 0x00000100;
          return this;
        }
        public Builder mergeDataSink(DataSinkProtos.DataSink value) {
          if (dataSinkBuilder_ == null) {
            if (((bitField0_ & 0x00000100) == 0x00000100) &&
                dataSink_ != DataSinkProtos.DataSink.getDefaultInstance()) {
              dataSink_ =
                DataSinkProtos.DataSink.newBuilder(dataSink_).mergeFrom(value).buildPartial();
            } else {
              dataSink_ = value;
            }
            onChanged();
          } else {
            dataSinkBuilder_.mergeFrom(value);
          }
          bitField0_ |= 0x00000100;
          return this;
        }
        public Builder clearDataSink() {
          if (dataSinkBuilder_ == null) {
            dataSink_ = DataSinkProtos.DataSink.getDefaultInstance();
            onChanged();
          } else {
            dataSinkBuilder_.clear();
          }
          bitField0_ = (bitField0_ & ~0x00000100);
          return this;
        }
        public DataSinkProtos.DataSink.Builder getDataSinkBuilder() {
          bitField0_ |= 0x00000100;
          onChanged();
          return getDataSinkFieldBuilder().getBuilder();
        }
        public DataSinkProtos.DataSinkOrBuilder getDataSinkOrBuilder() {
          if (dataSinkBuilder_ != null) {
            return dataSinkBuilder_.getMessageOrBuilder();
          } else {
            return dataSink_;
          }
        }
        private com.google.protobuf.SingleFieldBuilder<
            DataSinkProtos.DataSink, DataSinkProtos.DataSink.Builder, DataSinkProtos.DataSinkOrBuilder>
            getDataSinkFieldBuilder() {
          if (dataSinkBuilder_ == null) {
            dataSinkBuilder_ = new com.google.protobuf.SingleFieldBuilder<
                DataSinkProtos.DataSink, DataSinkProtos.DataSink.Builder, DataSinkProtos.DataSinkOrBuilder>(
                    dataSink_,
                    getParentForChildren(),
                    isClean());
            dataSink_ = null;
          }
          return dataSinkBuilder_;
        }
        
        // optional .apsara.odps.lot.Limit Limit = 10;
        private LimitProtos.Limit limit_ = LimitProtos.Limit.getDefaultInstance();
        private com.google.protobuf.SingleFieldBuilder<
            LimitProtos.Limit, LimitProtos.Limit.Builder, LimitProtos.LimitOrBuilder> limitBuilder_;
        public boolean hasLimit() {
          return ((bitField0_ & 0x00000200) == 0x00000200);
        }
        public LimitProtos.Limit getLimit() {
          if (limitBuilder_ == null) {
            return limit_;
          } else {
            return limitBuilder_.getMessage();
          }
        }
        public Builder setLimit(LimitProtos.Limit value) {
          if (limitBuilder_ == null) {
            if (value == null) {
              throw new NullPointerException();
            }
            limit_ = value;
            onChanged();
          } else {
            limitBuilder_.setMessage(value);
          }
          bitField0_ |= 0x00000200;
          return this;
        }
        public Builder setLimit(
            LimitProtos.Limit.Builder builderForValue) {
          if (limitBuilder_ == null) {
            limit_ = builderForValue.build();
            onChanged();
          } else {
            limitBuilder_.setMessage(builderForValue.build());
          }
          bitField0_ |= 0x00000200;
          return this;
        }
        public Builder mergeLimit(LimitProtos.Limit value) {
          if (limitBuilder_ == null) {
            if (((bitField0_ & 0x00000200) == 0x00000200) &&
                limit_ != LimitProtos.Limit.getDefaultInstance()) {
              limit_ =
                LimitProtos.Limit.newBuilder(limit_).mergeFrom(value).buildPartial();
            } else {
              limit_ = value;
            }
            onChanged();
          } else {
            limitBuilder_.mergeFrom(value);
          }
          bitField0_ |= 0x00000200;
          return this;
        }
        public Builder clearLimit() {
          if (limitBuilder_ == null) {
            limit_ = LimitProtos.Limit.getDefaultInstance();
            onChanged();
          } else {
            limitBuilder_.clear();
          }
          bitField0_ = (bitField0_ & ~0x00000200);
          return this;
        }
        public LimitProtos.Limit.Builder getLimitBuilder() {
          bitField0_ |= 0x00000200;
          onChanged();
          return getLimitFieldBuilder().getBuilder();
        }
        public LimitProtos.LimitOrBuilder getLimitOrBuilder() {
          if (limitBuilder_ != null) {
            return limitBuilder_.getMessageOrBuilder();
          } else {
            return limit_;
          }
        }
        private com.google.protobuf.SingleFieldBuilder<
            LimitProtos.Limit, LimitProtos.Limit.Builder, LimitProtos.LimitOrBuilder>
            getLimitFieldBuilder() {
          if (limitBuilder_ == null) {
            limitBuilder_ = new com.google.protobuf.SingleFieldBuilder<
                LimitProtos.Limit, LimitProtos.Limit.Builder, LimitProtos.LimitOrBuilder>(
                    limit_,
                    getParentForChildren(),
                    isClean());
            limit_ = null;
          }
          return limitBuilder_;
        }
        
        // optional .apsara.odps.lot.UnionAll UnionAll = 11;
        private UnionAllProtos.UnionAll unionAll_ = UnionAllProtos.UnionAll.getDefaultInstance();
        private com.google.protobuf.SingleFieldBuilder<
            UnionAllProtos.UnionAll, UnionAllProtos.UnionAll.Builder, UnionAllProtos.UnionAllOrBuilder> unionAllBuilder_;
        public boolean hasUnionAll() {
          return ((bitField0_ & 0x00000400) == 0x00000400);
        }
        public UnionAllProtos.UnionAll getUnionAll() {
          if (unionAllBuilder_ == null) {
            return unionAll_;
          } else {
            return unionAllBuilder_.getMessage();
          }
        }
        public Builder setUnionAll(UnionAllProtos.UnionAll value) {
          if (unionAllBuilder_ == null) {
            if (value == null) {
              throw new NullPointerException();
            }
            unionAll_ = value;
            onChanged();
          } else {
            unionAllBuilder_.setMessage(value);
          }
          bitField0_ |= 0x00000400;
          return this;
        }
        public Builder setUnionAll(
            UnionAllProtos.UnionAll.Builder builderForValue) {
          if (unionAllBuilder_ == null) {
            unionAll_ = builderForValue.build();
            onChanged();
          } else {
            unionAllBuilder_.setMessage(builderForValue.build());
          }
          bitField0_ |= 0x00000400;
          return this;
        }
        public Builder mergeUnionAll(UnionAllProtos.UnionAll value) {
          if (unionAllBuilder_ == null) {
            if (((bitField0_ & 0x00000400) == 0x00000400) &&
                unionAll_ != UnionAllProtos.UnionAll.getDefaultInstance()) {
              unionAll_ =
                UnionAllProtos.UnionAll.newBuilder(unionAll_).mergeFrom(value).buildPartial();
            } else {
              unionAll_ = value;
            }
            onChanged();
          } else {
            unionAllBuilder_.mergeFrom(value);
          }
          bitField0_ |= 0x00000400;
          return this;
        }
        public Builder clearUnionAll() {
          if (unionAllBuilder_ == null) {
            unionAll_ = UnionAllProtos.UnionAll.getDefaultInstance();
            onChanged();
          } else {
            unionAllBuilder_.clear();
          }
          bitField0_ = (bitField0_ & ~0x00000400);
          return this;
        }
        public UnionAllProtos.UnionAll.Builder getUnionAllBuilder() {
          bitField0_ |= 0x00000400;
          onChanged();
          return getUnionAllFieldBuilder().getBuilder();
        }
        public UnionAllProtos.UnionAllOrBuilder getUnionAllOrBuilder() {
          if (unionAllBuilder_ != null) {
            return unionAllBuilder_.getMessageOrBuilder();
          } else {
            return unionAll_;
          }
        }
        private com.google.protobuf.SingleFieldBuilder<
            UnionAllProtos.UnionAll, UnionAllProtos.UnionAll.Builder, UnionAllProtos.UnionAllOrBuilder>
            getUnionAllFieldBuilder() {
          if (unionAllBuilder_ == null) {
            unionAllBuilder_ = new com.google.protobuf.SingleFieldBuilder<
                UnionAllProtos.UnionAll, UnionAllProtos.UnionAll.Builder, UnionAllProtos.UnionAllOrBuilder>(
                    unionAll_,
                    getParentForChildren(),
                    isClean());
            unionAll_ = null;
          }
          return unionAllBuilder_;
        }
        
        // optional .apsara.odps.lot.Window Window = 12;
        private WindowProtos.Window window_ = WindowProtos.Window.getDefaultInstance();
        private com.google.protobuf.SingleFieldBuilder<
            WindowProtos.Window, WindowProtos.Window.Builder, WindowProtos.WindowOrBuilder> windowBuilder_;
        public boolean hasWindow() {
          return ((bitField0_ & 0x00000800) == 0x00000800);
        }
        public WindowProtos.Window getWindow() {
          if (windowBuilder_ == null) {
            return window_;
          } else {
            return windowBuilder_.getMessage();
          }
        }
        public Builder setWindow(WindowProtos.Window value) {
          if (windowBuilder_ == null) {
            if (value == null) {
              throw new NullPointerException();
            }
            window_ = value;
            onChanged();
          } else {
            windowBuilder_.setMessage(value);
          }
          bitField0_ |= 0x00000800;
          return this;
        }
        public Builder setWindow(
            WindowProtos.Window.Builder builderForValue) {
          if (windowBuilder_ == null) {
            window_ = builderForValue.build();
            onChanged();
          } else {
            windowBuilder_.setMessage(builderForValue.build());
          }
          bitField0_ |= 0x00000800;
          return this;
        }
        public Builder mergeWindow(WindowProtos.Window value) {
          if (windowBuilder_ == null) {
            if (((bitField0_ & 0x00000800) == 0x00000800) &&
                window_ != WindowProtos.Window.getDefaultInstance()) {
              window_ =
                WindowProtos.Window.newBuilder(window_).mergeFrom(value).buildPartial();
            } else {
              window_ = value;
            }
            onChanged();
          } else {
            windowBuilder_.mergeFrom(value);
          }
          bitField0_ |= 0x00000800;
          return this;
        }
        public Builder clearWindow() {
          if (windowBuilder_ == null) {
            window_ = WindowProtos.Window.getDefaultInstance();
            onChanged();
          } else {
            windowBuilder_.clear();
          }
          bitField0_ = (bitField0_ & ~0x00000800);
          return this;
        }
        public WindowProtos.Window.Builder getWindowBuilder() {
          bitField0_ |= 0x00000800;
          onChanged();
          return getWindowFieldBuilder().getBuilder();
        }
        public WindowProtos.WindowOrBuilder getWindowOrBuilder() {
          if (windowBuilder_ != null) {
            return windowBuilder_.getMessageOrBuilder();
          } else {
            return window_;
          }
        }
        private com.google.protobuf.SingleFieldBuilder<
            WindowProtos.Window, WindowProtos.Window.Builder, WindowProtos.WindowOrBuilder>
            getWindowFieldBuilder() {
          if (windowBuilder_ == null) {
            windowBuilder_ = new com.google.protobuf.SingleFieldBuilder<
                WindowProtos.Window, WindowProtos.Window.Builder, WindowProtos.WindowOrBuilder>(
                    window_,
                    getParentForChildren(),
                    isClean());
            window_ = null;
          }
          return windowBuilder_;
        }
        
        // optional .apsara.odps.lot.Transform Transform = 13;
        private TransformProtos.Transform transform_ = TransformProtos.Transform.getDefaultInstance();
        private com.google.protobuf.SingleFieldBuilder<
            TransformProtos.Transform, TransformProtos.Transform.Builder, TransformProtos.TransformOrBuilder> transformBuilder_;
        public boolean hasTransform() {
          return ((bitField0_ & 0x00001000) == 0x00001000);
        }
        public TransformProtos.Transform getTransform() {
          if (transformBuilder_ == null) {
            return transform_;
          } else {
            return transformBuilder_.getMessage();
          }
        }
        public Builder setTransform(TransformProtos.Transform value) {
          if (transformBuilder_ == null) {
            if (value == null) {
              throw new NullPointerException();
            }
            transform_ = value;
            onChanged();
          } else {
            transformBuilder_.setMessage(value);
          }
          bitField0_ |= 0x00001000;
          return this;
        }
        public Builder setTransform(
            TransformProtos.Transform.Builder builderForValue) {
          if (transformBuilder_ == null) {
            transform_ = builderForValue.build();
            onChanged();
          } else {
            transformBuilder_.setMessage(builderForValue.build());
          }
          bitField0_ |= 0x00001000;
          return this;
        }
        public Builder mergeTransform(TransformProtos.Transform value) {
          if (transformBuilder_ == null) {
            if (((bitField0_ & 0x00001000) == 0x00001000) &&
                transform_ != TransformProtos.Transform.getDefaultInstance()) {
              transform_ =
                TransformProtos.Transform.newBuilder(transform_).mergeFrom(value).buildPartial();
            } else {
              transform_ = value;
            }
            onChanged();
          } else {
            transformBuilder_.mergeFrom(value);
          }
          bitField0_ |= 0x00001000;
          return this;
        }
        public Builder clearTransform() {
          if (transformBuilder_ == null) {
            transform_ = TransformProtos.Transform.getDefaultInstance();
            onChanged();
          } else {
            transformBuilder_.clear();
          }
          bitField0_ = (bitField0_ & ~0x00001000);
          return this;
        }
        public TransformProtos.Transform.Builder getTransformBuilder() {
          bitField0_ |= 0x00001000;
          onChanged();
          return getTransformFieldBuilder().getBuilder();
        }
        public TransformProtos.TransformOrBuilder getTransformOrBuilder() {
          if (transformBuilder_ != null) {
            return transformBuilder_.getMessageOrBuilder();
          } else {
            return transform_;
          }
        }
        private com.google.protobuf.SingleFieldBuilder<
            TransformProtos.Transform, TransformProtos.Transform.Builder, TransformProtos.TransformOrBuilder>
            getTransformFieldBuilder() {
          if (transformBuilder_ == null) {
            transformBuilder_ = new com.google.protobuf.SingleFieldBuilder<
                TransformProtos.Transform, TransformProtos.Transform.Builder, TransformProtos.TransformOrBuilder>(
                    transform_,
                    getParentForChildren(),
                    isClean());
            transform_ = null;
          }
          return transformBuilder_;
        }
        
        // @@protoc_insertion_point(builder_scope:apsara.odps.lot.LogicalOperator)
      }
      
      static {
        defaultInstance = new LogicalOperator(true);
        defaultInstance.initFields();
      }
      
      // @@protoc_insertion_point(class_scope:apsara.odps.lot.LogicalOperator)
    }
    
    public interface LogicalOperatorTreeOrBuilder
        extends com.google.protobuf.MessageOrBuilder {
      
      // repeated .apsara.odps.lot.LogicalOperator Operators = 1;
      java.util.List<LogicalOperator>
          getOperatorsList();
      LogicalOperator getOperators(int index);
      int getOperatorsCount();
      java.util.List<? extends LogicalOperatorOrBuilder>
          getOperatorsOrBuilderList();
      LogicalOperatorOrBuilder getOperatorsOrBuilder(
          int index);
    }
    public static final class LogicalOperatorTree extends
        com.google.protobuf.GeneratedMessage
        implements LogicalOperatorTreeOrBuilder {
      // Use LogicalOperatorTree.newBuilder() to construct.
      private LogicalOperatorTree(Builder builder) {
        super(builder);
      }
      private LogicalOperatorTree(boolean noInit) {}
      
      private static final LogicalOperatorTree defaultInstance;
      public static LogicalOperatorTree getDefaultInstance() {
        return defaultInstance;
      }
      
      public LogicalOperatorTree getDefaultInstanceForType() {
        return defaultInstance;
      }
      
      public static final com.google.protobuf.Descriptors.Descriptor
          getDescriptor() {
        return Lot.internal_static_apsara_odps_lot_LogicalOperatorTree_descriptor;
      }
      
      protected FieldAccessorTable
          internalGetFieldAccessorTable() {
        return Lot.internal_static_apsara_odps_lot_LogicalOperatorTree_fieldAccessorTable;
      }
      
      // repeated .apsara.odps.lot.LogicalOperator Operators = 1;
      public static final int OPERATORS_FIELD_NUMBER = 1;
      private java.util.List<LogicalOperator> operators_;
      public java.util.List<LogicalOperator> getOperatorsList() {
        return operators_;
      }
      public java.util.List<? extends LogicalOperatorOrBuilder>
          getOperatorsOrBuilderList() {
        return operators_;
      }
      public int getOperatorsCount() {
        return operators_.size();
      }
      public LogicalOperator getOperators(int index) {
        return operators_.get(index);
      }
      public LogicalOperatorOrBuilder getOperatorsOrBuilder(
          int index) {
        return operators_.get(index);
      }
      
      private void initFields() {
        operators_ = java.util.Collections.emptyList();
      }
      private byte memoizedIsInitialized = -1;
      public final boolean isInitialized() {
        byte isInitialized = memoizedIsInitialized;
        if (isInitialized != -1) return isInitialized == 1;
        
        for (int i = 0; i < getOperatorsCount(); i++) {
          if (!getOperators(i).isInitialized()) {
            memoizedIsInitialized = 0;
            return false;
          }
        }
        memoizedIsInitialized = 1;
        return true;
      }
      
      public void writeTo(com.google.protobuf.CodedOutputStream output)
                          throws java.io.IOException {
        getSerializedSize();
        for (int i = 0; i < operators_.size(); i++) {
          output.writeMessage(1, operators_.get(i));
        }
        getUnknownFields().writeTo(output);
      }
      
      private int memoizedSerializedSize = -1;
      public int getSerializedSize() {
        int size = memoizedSerializedSize;
        if (size != -1) return size;
      
        size = 0;
        for (int i = 0; i < operators_.size(); i++) {
          size += com.google.protobuf.CodedOutputStream
            .computeMessageSize(1, operators_.get(i));
        }
        size += getUnknownFields().getSerializedSize();
        memoizedSerializedSize = size;
        return size;
      }
      
      private static final long serialVersionUID = 0L;
      @Override
      protected Object writeReplace()
          throws java.io.ObjectStreamException {
        return super.writeReplace();
      }
      
      public static LogicalOperatorTree parseFrom(
          com.google.protobuf.ByteString data)
          throws com.google.protobuf.InvalidProtocolBufferException {
        return newBuilder().mergeFrom(data).buildParsed();
      }
      public static LogicalOperatorTree parseFrom(
          com.google.protobuf.ByteString data,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws com.google.protobuf.InvalidProtocolBufferException {
        return newBuilder().mergeFrom(data, extensionRegistry)
                 .buildParsed();
      }
      public static LogicalOperatorTree parseFrom(byte[] data)
          throws com.google.protobuf.InvalidProtocolBufferException {
        return newBuilder().mergeFrom(data).buildParsed();
      }
      public static LogicalOperatorTree parseFrom(
          byte[] data,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws com.google.protobuf.InvalidProtocolBufferException {
        return newBuilder().mergeFrom(data, extensionRegistry)
                 .buildParsed();
      }
      public static LogicalOperatorTree parseFrom(java.io.InputStream input)
          throws java.io.IOException {
        return newBuilder().mergeFrom(input).buildParsed();
      }
      public static LogicalOperatorTree parseFrom(
          java.io.InputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws java.io.IOException {
        return newBuilder().mergeFrom(input, extensionRegistry)
                 .buildParsed();
      }
      public static LogicalOperatorTree parseDelimitedFrom(java.io.InputStream input)
          throws java.io.IOException {
        Builder builder = newBuilder();
        if (builder.mergeDelimitedFrom(input)) {
          return builder.buildParsed();
        } else {
          return null;
        }
      }
      public static LogicalOperatorTree parseDelimitedFrom(
          java.io.InputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws java.io.IOException {
        Builder builder = newBuilder();
        if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
          return builder.buildParsed();
        } else {
          return null;
        }
      }
      public static LogicalOperatorTree parseFrom(
          com.google.protobuf.CodedInputStream input)
          throws java.io.IOException {
        return newBuilder().mergeFrom(input).buildParsed();
      }
      public static LogicalOperatorTree parseFrom(
          com.google.protobuf.CodedInputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws java.io.IOException {
        return newBuilder().mergeFrom(input, extensionRegistry)
                 .buildParsed();
      }
      
      public static Builder newBuilder() { return Builder.create(); }
      public Builder newBuilderForType() { return newBuilder(); }
      public static Builder newBuilder(LogicalOperatorTree prototype) {
        return newBuilder().mergeFrom(prototype);
      }
      public Builder toBuilder() { return newBuilder(this); }
      
      @Override
      protected Builder newBuilderForType(
          BuilderParent parent) {
        Builder builder = new Builder(parent);
        return builder;
      }
      public static final class Builder extends
          com.google.protobuf.GeneratedMessage.Builder<Builder>
         implements LogicalOperatorTreeOrBuilder {
        public static final com.google.protobuf.Descriptors.Descriptor
            getDescriptor() {
          return Lot.internal_static_apsara_odps_lot_LogicalOperatorTree_descriptor;
        }
        
        protected FieldAccessorTable
            internalGetFieldAccessorTable() {
          return Lot.internal_static_apsara_odps_lot_LogicalOperatorTree_fieldAccessorTable;
        }
        
        // Construct using apsara.odps.lot.Lot.LogicalOperatorTree.newBuilder()
        private Builder() {
          maybeForceBuilderInitialization();
        }
        
        private Builder(BuilderParent parent) {
          super(parent);
          maybeForceBuilderInitialization();
        }
        private void maybeForceBuilderInitialization() {
          if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
            getOperatorsFieldBuilder();
          }
        }
        private static Builder create() {
          return new Builder();
        }
        
        public Builder clear() {
          super.clear();
          if (operatorsBuilder_ == null) {
            operators_ = java.util.Collections.emptyList();
            bitField0_ = (bitField0_ & ~0x00000001);
          } else {
            operatorsBuilder_.clear();
          }
          return this;
        }
        
        public Builder clone() {
          return create().mergeFrom(buildPartial());
        }
        
        public com.google.protobuf.Descriptors.Descriptor
            getDescriptorForType() {
          return LogicalOperatorTree.getDescriptor();
        }
        
        public LogicalOperatorTree getDefaultInstanceForType() {
          return LogicalOperatorTree.getDefaultInstance();
        }
        
        public LogicalOperatorTree build() {
          LogicalOperatorTree result = buildPartial();
          if (!result.isInitialized()) {
            throw newUninitializedMessageException(result);
          }
          return result;
        }
        
        private LogicalOperatorTree buildParsed()
            throws com.google.protobuf.InvalidProtocolBufferException {
          LogicalOperatorTree result = buildPartial();
          if (!result.isInitialized()) {
            throw newUninitializedMessageException(
              result).asInvalidProtocolBufferException();
          }
          return result;
        }
        
        public LogicalOperatorTree buildPartial() {
          LogicalOperatorTree result = new LogicalOperatorTree(this);
          int from_bitField0_ = bitField0_;
          if (operatorsBuilder_ == null) {
            if (((bitField0_ & 0x00000001) == 0x00000001)) {
              operators_ = java.util.Collections.unmodifiableList(operators_);
              bitField0_ = (bitField0_ & ~0x00000001);
            }
            result.operators_ = operators_;
          } else {
            result.operators_ = operatorsBuilder_.build();
          }
          onBuilt();
          return result;
        }
        
        public Builder mergeFrom(com.google.protobuf.Message other) {
          if (other instanceof LogicalOperatorTree) {
            return mergeFrom((LogicalOperatorTree)other);
          } else {
            super.mergeFrom(other);
            return this;
          }
        }
        
        public Builder mergeFrom(LogicalOperatorTree other) {
          if (other == LogicalOperatorTree.getDefaultInstance()) return this;
          if (operatorsBuilder_ == null) {
            if (!other.operators_.isEmpty()) {
              if (operators_.isEmpty()) {
                operators_ = other.operators_;
                bitField0_ = (bitField0_ & ~0x00000001);
              } else {
                ensureOperatorsIsMutable();
                operators_.addAll(other.operators_);
              }
              onChanged();
            }
          } else {
            if (!other.operators_.isEmpty()) {
              if (operatorsBuilder_.isEmpty()) {
                operatorsBuilder_.dispose();
                operatorsBuilder_ = null;
                operators_ = other.operators_;
                bitField0_ = (bitField0_ & ~0x00000001);
                operatorsBuilder_ = 
                  com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders ?
                     getOperatorsFieldBuilder() : null;
              } else {
                operatorsBuilder_.addAllMessages(other.operators_);
              }
            }
          }
          this.mergeUnknownFields(other.getUnknownFields());
          return this;
        }
        
        public final boolean isInitialized() {
          for (int i = 0; i < getOperatorsCount(); i++) {
            if (!getOperators(i).isInitialized()) {
              
              return false;
            }
          }
          return true;
        }
        
        public Builder mergeFrom(
            com.google.protobuf.CodedInputStream input,
            com.google.protobuf.ExtensionRegistryLite extensionRegistry)
            throws java.io.IOException {
          com.google.protobuf.UnknownFieldSet.Builder unknownFields =
            com.google.protobuf.UnknownFieldSet.newBuilder(
              this.getUnknownFields());
          while (true) {
            int tag = input.readTag();
            switch (tag) {
              case 0:
                this.setUnknownFields(unknownFields.build());
                onChanged();
                return this;
              default: {
                if (!parseUnknownField(input, unknownFields,
                                       extensionRegistry, tag)) {
                  this.setUnknownFields(unknownFields.build());
                  onChanged();
                  return this;
                }
                break;
              }
              case 10: {
                LogicalOperator.Builder subBuilder = LogicalOperator.newBuilder();
                input.readMessage(subBuilder, extensionRegistry);
                addOperators(subBuilder.buildPartial());
                break;
              }
            }
          }
        }
        
        private int bitField0_;
        
        // repeated .apsara.odps.lot.LogicalOperator Operators = 1;
        private java.util.List<LogicalOperator> operators_ =
          java.util.Collections.emptyList();
        private void ensureOperatorsIsMutable() {
          if (!((bitField0_ & 0x00000001) == 0x00000001)) {
            operators_ = new java.util.ArrayList<LogicalOperator>(operators_);
            bitField0_ |= 0x00000001;
           }
        }
        
        private com.google.protobuf.RepeatedFieldBuilder<
            LogicalOperator, LogicalOperator.Builder, LogicalOperatorOrBuilder> operatorsBuilder_;
        
        public java.util.List<LogicalOperator> getOperatorsList() {
          if (operatorsBuilder_ == null) {
            return java.util.Collections.unmodifiableList(operators_);
          } else {
            return operatorsBuilder_.getMessageList();
          }
        }
        public int getOperatorsCount() {
          if (operatorsBuilder_ == null) {
            return operators_.size();
          } else {
            return operatorsBuilder_.getCount();
          }
        }
        public LogicalOperator getOperators(int index) {
          if (operatorsBuilder_ == null) {
            return operators_.get(index);
          } else {
            return operatorsBuilder_.getMessage(index);
          }
        }
        public Builder setOperators(
            int index, LogicalOperator value) {
          if (operatorsBuilder_ == null) {
            if (value == null) {
              throw new NullPointerException();
            }
            ensureOperatorsIsMutable();
            operators_.set(index, value);
            onChanged();
          } else {
            operatorsBuilder_.setMessage(index, value);
          }
          return this;
        }
        public Builder setOperators(
            int index, LogicalOperator.Builder builderForValue) {
          if (operatorsBuilder_ == null) {
            ensureOperatorsIsMutable();
            operators_.set(index, builderForValue.build());
            onChanged();
          } else {
            operatorsBuilder_.setMessage(index, builderForValue.build());
          }
          return this;
        }
        public Builder addOperators(LogicalOperator value) {
          if (operatorsBuilder_ == null) {
            if (value == null) {
              throw new NullPointerException();
            }
            ensureOperatorsIsMutable();
            operators_.add(value);
            onChanged();
          } else {
            operatorsBuilder_.addMessage(value);
          }
          return this;
        }
        public Builder addOperators(
            int index, LogicalOperator value) {
          if (operatorsBuilder_ == null) {
            if (value == null) {
              throw new NullPointerException();
            }
            ensureOperatorsIsMutable();
            operators_.add(index, value);
            onChanged();
          } else {
            operatorsBuilder_.addMessage(index, value);
          }
          return this;
        }
        public Builder addOperators(
            LogicalOperator.Builder builderForValue) {
          if (operatorsBuilder_ == null) {
            ensureOperatorsIsMutable();
            operators_.add(builderForValue.build());
            onChanged();
          } else {
            operatorsBuilder_.addMessage(builderForValue.build());
          }
          return this;
        }
        public Builder addOperators(
            int index, LogicalOperator.Builder builderForValue) {
          if (operatorsBuilder_ == null) {
            ensureOperatorsIsMutable();
            operators_.add(index, builderForValue.build());
            onChanged();
          } else {
            operatorsBuilder_.addMessage(index, builderForValue.build());
          }
          return this;
        }
        public Builder addAllOperators(
            Iterable<? extends LogicalOperator> values) {
          if (operatorsBuilder_ == null) {
            ensureOperatorsIsMutable();
            super.addAll(values, operators_);
            onChanged();
          } else {
            operatorsBuilder_.addAllMessages(values);
          }
          return this;
        }
        public Builder clearOperators() {
          if (operatorsBuilder_ == null) {
            operators_ = java.util.Collections.emptyList();
            bitField0_ = (bitField0_ & ~0x00000001);
            onChanged();
          } else {
            operatorsBuilder_.clear();
          }
          return this;
        }
        public Builder removeOperators(int index) {
          if (operatorsBuilder_ == null) {
            ensureOperatorsIsMutable();
            operators_.remove(index);
            onChanged();
          } else {
            operatorsBuilder_.remove(index);
          }
          return this;
        }
        public LogicalOperator.Builder getOperatorsBuilder(
            int index) {
          return getOperatorsFieldBuilder().getBuilder(index);
        }
        public LogicalOperatorOrBuilder getOperatorsOrBuilder(
            int index) {
          if (operatorsBuilder_ == null) {
            return operators_.get(index);  } else {
            return operatorsBuilder_.getMessageOrBuilder(index);
          }
        }
        public java.util.List<? extends LogicalOperatorOrBuilder>
             getOperatorsOrBuilderList() {
          if (operatorsBuilder_ != null) {
            return operatorsBuilder_.getMessageOrBuilderList();
          } else {
            return java.util.Collections.unmodifiableList(operators_);
          }
        }
        public LogicalOperator.Builder addOperatorsBuilder() {
          return getOperatorsFieldBuilder().addBuilder(
              LogicalOperator.getDefaultInstance());
        }
        public LogicalOperator.Builder addOperatorsBuilder(
            int index) {
          return getOperatorsFieldBuilder().addBuilder(
              index, LogicalOperator.getDefaultInstance());
        }
        public java.util.List<LogicalOperator.Builder>
             getOperatorsBuilderList() {
          return getOperatorsFieldBuilder().getBuilderList();
        }
        private com.google.protobuf.RepeatedFieldBuilder<
            LogicalOperator, LogicalOperator.Builder, LogicalOperatorOrBuilder>
            getOperatorsFieldBuilder() {
          if (operatorsBuilder_ == null) {
            operatorsBuilder_ = new com.google.protobuf.RepeatedFieldBuilder<
                LogicalOperator, LogicalOperator.Builder, LogicalOperatorOrBuilder>(
                    operators_,
                    ((bitField0_ & 0x00000001) == 0x00000001),
                    getParentForChildren(),
                    isClean());
            operators_ = null;
          }
          return operatorsBuilder_;
        }
        
        // @@protoc_insertion_point(builder_scope:apsara.odps.lot.LogicalOperatorTree)
      }
      
      static {
        defaultInstance = new LogicalOperatorTree(true);
        defaultInstance.initFields();
      }
      
      // @@protoc_insertion_point(class_scope:apsara.odps.lot.LogicalOperatorTree)
    }
    
    private static com.google.protobuf.Descriptors.Descriptor
      internal_static_apsara_odps_lot_LogicalOperator_descriptor;
    private static
      com.google.protobuf.GeneratedMessage.FieldAccessorTable
        internal_static_apsara_odps_lot_LogicalOperator_fieldAccessorTable;
    private static com.google.protobuf.Descriptors.Descriptor
      internal_static_apsara_odps_lot_LogicalOperatorTree_descriptor;
    private static
      com.google.protobuf.GeneratedMessage.FieldAccessorTable
        internal_static_apsara_odps_lot_LogicalOperatorTree_fieldAccessorTable;
    
    public static com.google.protobuf.Descriptors.FileDescriptor
        getDescriptor() {
      return descriptor;
    }
    private static com.google.protobuf.Descriptors.FileDescriptor
        descriptor;
    static {
      String[] descriptorData = {
        "\n\rlot/lot.proto\022\017apsara.odps.lot\032\017lot/ap" +
        "ply.proto\032\026lot/distributeby.proto\032\020lot/f" +
        "ilter.proto\032\023lot/aggregate.proto\032\016lot/jo" +
        "in.proto\032\020lot/select.proto\032\020lot/sortby.p" +
        "roto\032\024lot/datasource.proto\032\022lot/datasink" +
        ".proto\032\017lot/limit.proto\032\022lot/unionall.pr" +
        "oto\032\020lot/window.proto\032\023lot/transform.pro" +
        "to\"\306\004\n\017LogicalOperator\022%\n\005Apply\030\001 \001(\0132\026." +
        "apsara.odps.lot.Apply\0223\n\014DistributeBy\030\002 " +
        "\001(\0132\035.apsara.odps.lot.DistributeBy\022\'\n\006Fi",
        "lter\030\003 \001(\0132\027.apsara.odps.lot.Filter\022-\n\tA" +
        "ggregate\030\004 \001(\0132\032.apsara.odps.lot.Aggrega" +
        "te\022#\n\004Join\030\005 \001(\0132\025.apsara.odps.lot.Join\022" +
        "\'\n\006Select\030\006 \001(\0132\027.apsara.odps.lot.Select" +
        "\022\'\n\006SortBy\030\007 \001(\0132\027.apsara.odps.lot.SortB" +
        "y\022/\n\nDataSource\030\010 \001(\0132\033.apsara.odps.lot." +
        "DataSource\022+\n\010DataSink\030\t \001(\0132\031.apsara.od" +
        "ps.lot.DataSink\022%\n\005Limit\030\n \001(\0132\026.apsara." +
        "odps.lot.Limit\022+\n\010UnionAll\030\013 \001(\0132\031.apsar" +
        "a.odps.lot.UnionAll\022\'\n\006Window\030\014 \001(\0132\027.ap",
        "sara.odps.lot.Window\022-\n\tTransform\030\r \001(\0132" +
        "\032.apsara.odps.lot.Transform\"J\n\023LogicalOp" +
        "eratorTree\0223\n\tOperators\030\001 \003(\0132 .apsara.o" +
        "dps.lot.LogicalOperator"
      };
      com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
        new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
          public com.google.protobuf.ExtensionRegistry assignDescriptors(
              com.google.protobuf.Descriptors.FileDescriptor root) {
            descriptor = root;
            internal_static_apsara_odps_lot_LogicalOperator_descriptor =
              getDescriptor().getMessageTypes().get(0);
            internal_static_apsara_odps_lot_LogicalOperator_fieldAccessorTable = new
              com.google.protobuf.GeneratedMessage.FieldAccessorTable(
                internal_static_apsara_odps_lot_LogicalOperator_descriptor,
                new String[] { "Apply", "DistributeBy", "Filter", "Aggregate", "Join", "Select", "SortBy", "DataSource", "DataSink", "Limit", "UnionAll", "Window", "Transform", },
                LogicalOperator.class,
                LogicalOperator.Builder.class);
            internal_static_apsara_odps_lot_LogicalOperatorTree_descriptor =
              getDescriptor().getMessageTypes().get(1);
            internal_static_apsara_odps_lot_LogicalOperatorTree_fieldAccessorTable = new
              com.google.protobuf.GeneratedMessage.FieldAccessorTable(
                internal_static_apsara_odps_lot_LogicalOperatorTree_descriptor,
                new String[] { "Operators", },
                LogicalOperatorTree.class,
                LogicalOperatorTree.Builder.class);
            return null;
          }
        };
      com.google.protobuf.Descriptors.FileDescriptor
        .internalBuildGeneratedFileFrom(descriptorData,
          new com.google.protobuf.Descriptors.FileDescriptor[] {
            ApplyProtos.getDescriptor(),
            DistributeByProtos.getDescriptor(),
            FilterProtos.getDescriptor(),
            AggregateProtos.getDescriptor(),
            JoinProtos.getDescriptor(),
            SelectProtos.getDescriptor(),
            SortByProtos.getDescriptor(),
            DataSourceProtos.getDescriptor(),
            DataSinkProtos.getDescriptor(),
            LimitProtos.getDescriptor(),
            UnionAllProtos.getDescriptor(),
            WindowProtos.getDescriptor(),
            TransformProtos.getDescriptor(),
          }, assigner);
    }
    
    // @@protoc_insertion_point(outer_class_scope)
  }
  