Package com.ocient.jdbc.proto

## Class PlanProtocol.SortOperator.Builder

- java.lang.Object
- - com.google.protobuf.AbstractMessageLite.Builder
  - - com.google.protobuf.AbstractMessage.Builder<BuilderType>
    - - com.google.protobuf.GeneratedMessageV3.Builder<PlanProtocol.SortOperator.Builder>
      - - com.ocient.jdbc.proto.PlanProtocol.SortOperator.Builder

All Implemented Interfaces:
  `com.google.protobuf.Message.Builder`, `com.google.protobuf.MessageLite.Builder`, `com.google.protobuf.MessageLiteOrBuilder`, `com.google.protobuf.MessageOrBuilder`, `PlanProtocol.SortOperatorOrBuilder`, `Cloneable`

Enclosing class:
  PlanProtocol.SortOperator

    public static final class PlanProtocol.SortOperator.Builder
    extends com.google.protobuf.GeneratedMessageV3.Builder<PlanProtocol.SortOperator.Builder>
    implements PlanProtocol.SortOperatorOrBuilder

Protobuf type `xg.db.sqlPlans.SortOperator`

### Method Summary

All Methods Static Methods Instance Methods Concrete Methods
`PlanProtocol.SortOperator.Builder` `addAllDirections​(Iterable<? extends Boolean> values)` The directions for each sort col - true = ascending

`PlanProtocol.SortOperator.Builder`

`addAllPoint​(Iterable<? extends PlanProtocol.SortPartition> values)`

This defines the list of partitioning points for dividing the sort into streams There's no guarantees on the size of this It could be completely empty, which could happen if it look like all the data has the same sort key - implies that we don't know what to do besides one sort stream There is no guarantee that the partitioning points are in order

`PlanProtocol.SortOperator.Builder` `addAllSortKeys​(Iterable<String> values)` The sort columns - order matters
`PlanProtocol.SortOperator.Builder` `addDirections​(boolean value)` The directions for each sort col - true = ascending

`PlanProtocol.SortOperator.Builder`

`addPoint​(int index, PlanProtocol.SortPartition value)`

This defines the list of partitioning points for dividing the sort into streams There's no guarantees on the size of this It could be completely empty, which could happen if it look like all the data has the same sort key - implies that we don't know what to do besides one sort stream There is no guarantee that the partitioning points are in order

`PlanProtocol.SortOperator.Builder`

`addPoint​(int index, PlanProtocol.SortPartition.Builder builderForValue)`

This defines the list of partitioning points for dividing the sort into streams There's no guarantees on the size of this It could be completely empty, which could happen if it look like all the data has the same sort key - implies that we don't know what to do besides one sort stream There is no guarantee that the partitioning points are in order

`PlanProtocol.SortOperator.Builder`

`addPoint​(PlanProtocol.SortPartition value)`

This defines the list of partitioning points for dividing the sort into streams There's no guarantees on the size of this It could be completely empty, which could happen if it look like all the data has the same sort key - implies that we don't know what to do besides one sort stream There is no guarantee that the partitioning points are in order

`PlanProtocol.SortOperator.Builder`

`addPoint​(PlanProtocol.SortPartition.Builder builderForValue)`

This defines the list of partitioning points for dividing the sort into streams There's no guarantees on the size of this It could be completely empty, which could happen if it look like all the data has the same sort key - implies that we don't know what to do besides one sort stream There is no guarantee that the partitioning points are in order

`PlanProtocol.SortPartition.Builder`

`addPointBuilder()`

This defines the list of partitioning points for dividing the sort into streams There's no guarantees on the size of this It could be completely empty, which could happen if it look like all the data has the same sort key - implies that we don't know what to do besides one sort stream There is no guarantee that the partitioning points are in order

`PlanProtocol.SortPartition.Builder`

`addPointBuilder​(int index)`

This defines the list of partitioning points for dividing the sort into streams There's no guarantees on the size of this It could be completely empty, which could happen if it look like all the data has the same sort key - implies that we don't know what to do besides one sort stream There is no guarantee that the partitioning points are in order

`PlanProtocol.SortOperator.Builder` `addRepeatedField​(com.google.protobuf.Descriptors.FieldDescriptor field, Object value)`
`PlanProtocol.SortOperator.Builder` `addSortKeys​(String value)` The sort columns - order matters
`PlanProtocol.SortOperator.Builder` `addSortKeysBytes​(com.google.protobuf.ByteString value)` The sort columns - order matters
`PlanProtocol.SortOperator` `build()`
`PlanProtocol.SortOperator` `buildPartial()`
`PlanProtocol.SortOperator.Builder` `clear()`
`PlanProtocol.SortOperator.Builder` `clearDirections()` The directions for each sort col - true = ascending
`PlanProtocol.SortOperator.Builder` `clearField​(com.google.protobuf.Descriptors.FieldDescriptor field)`
`PlanProtocol.SortOperator.Builder` `clearLimitVal()` If we know we only need the top n rows of the sort that is noted here If there is no limit being applied, this is set to -1
`PlanProtocol.SortOperator.Builder` `clearOneof​(com.google.protobuf.Descriptors.OneofDescriptor oneof)`
`PlanProtocol.SortOperator.Builder` `clearPoint()` This defines the list of partitioning points for dividing the sort into streams There's no guarantees on the size of this It could be completely empty, which could happen if it look like all the data has the same sort key - implies that we don't know what to do besides one sort stream There is no guarantee that the partitioning points are in order
`PlanProtocol.SortOperator.Builder` `clearSortKeys()` The sort columns - order matters
`PlanProtocol.SortOperator.Builder` `clone()`
`PlanProtocol.SortOperator` `getDefaultInstanceForType()`
`static com.google.protobuf.Descriptors.Descriptor` `getDescriptor()`
`com.google.protobuf.Descriptors.Descriptor` `getDescriptorForType()`
`boolean` `getDirections​(int index)` The directions for each sort col - true = ascending
`int` `getDirectionsCount()` The directions for each sort col - true = ascending
`List<Boolean>` `getDirectionsList()` The directions for each sort col - true = ascending
`long` `getLimitVal()` If we know we only need the top n rows of the sort that is noted here If there is no limit being applied, this is set to -1

`PlanProtocol.SortPartition`

`getPoint​(int index)`

This defines the list of partitioning points for dividing the sort into streams There's no guarantees on the size of this It could be completely empty, which could happen if it look like all the data has the same sort key - implies that we don't know what to do besides one sort stream There is no guarantee that the partitioning points are in order

`PlanProtocol.SortPartition.Builder`

`getPointBuilder​(int index)`

This defines the list of partitioning points for dividing the sort into streams There's no guarantees on the size of this It could be completely empty, which could happen if it look like all the data has the same sort key - implies that we don't know what to do besides one sort stream There is no guarantee that the partitioning points are in order

`List<PlanProtocol.SortPartition.Builder>`

`getPointBuilderList()`

This defines the list of partitioning points for dividing the sort into streams There's no guarantees on the size of this It could be completely empty, which could happen if it look like all the data has the same sort key - implies that we don't know what to do besides one sort stream There is no guarantee that the partitioning points are in order

`int` `getPointCount()` This defines the list of partitioning points for dividing the sort into streams There's no guarantees on the size of this It could be completely empty, which could happen if it look like all the data has the same sort key - implies that we don't know what to do besides one sort stream There is no guarantee that the partitioning points are in order

`List<PlanProtocol.SortPartition>`

`getPointList()`

This defines the list of partitioning points for dividing the sort into streams There's no guarantees on the size of this It could be completely empty, which could happen if it look like all the data has the same sort key - implies that we don't know what to do besides one sort stream There is no guarantee that the partitioning points are in order

`PlanProtocol.SortPartitionOrBuilder`

`getPointOrBuilder​(int index)`

This defines the list of partitioning points for dividing the sort into streams There's no guarantees on the size of this It could be completely empty, which could happen if it look like all the data has the same sort key - implies that we don't know what to do besides one sort stream There is no guarantee that the partitioning points are in order

`List<? extends PlanProtocol.SortPartitionOrBuilder>`

`getPointOrBuilderList()`

This defines the list of partitioning points for dividing the sort into streams There's no guarantees on the size of this It could be completely empty, which could happen if it look like all the data has the same sort key - implies that we don't know what to do besides one sort stream There is no guarantee that the partitioning points are in order

`String` `getSortKeys​(int index)` The sort columns - order matters
`com.google.protobuf.ByteString` `getSortKeysBytes​(int index)` The sort columns - order matters
`int` `getSortKeysCount()` The sort columns - order matters
`com.google.protobuf.ProtocolStringList` `getSortKeysList()` The sort columns - order matters
`protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable` `internalGetFieldAccessorTable()`
`boolean` `isInitialized()`
`PlanProtocol.SortOperator.Builder` `mergeFrom​(com.google.protobuf.CodedInputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry)`
`PlanProtocol.SortOperator.Builder` `mergeFrom​(com.google.protobuf.Message other)`
`PlanProtocol.SortOperator.Builder` `mergeFrom​(PlanProtocol.SortOperator other)`
`PlanProtocol.SortOperator.Builder` `mergeUnknownFields​(com.google.protobuf.UnknownFieldSet unknownFields)`

`PlanProtocol.SortOperator.Builder`

`removePoint​(int index)`

This defines the list of partitioning points for dividing the sort into streams There's no guarantees on the size of this It could be completely empty, which could happen if it look like all the data has the same sort key - implies that we don't know what to do besides one sort stream There is no guarantee that the partitioning points are in order

`PlanProtocol.SortOperator.Builder` `setDirections​(int index, boolean value)` The directions for each sort col - true = ascending
`PlanProtocol.SortOperator.Builder` `setField​(com.google.protobuf.Descriptors.FieldDescriptor field, Object value)`
`PlanProtocol.SortOperator.Builder` `setLimitVal​(long value)` If we know we only need the top n rows of the sort that is noted here If there is no limit being applied, this is set to -1

`PlanProtocol.SortOperator.Builder`

`setPoint​(int index, PlanProtocol.SortPartition value)`

This defines the list of partitioning points for dividing the sort into streams There's no guarantees on the size of this It could be completely empty, which could happen if it look like all the data has the same sort key - implies that we don't know what to do besides one sort stream There is no guarantee that the partitioning points are in order

`PlanProtocol.SortOperator.Builder`

`setPoint​(int index, PlanProtocol.SortPartition.Builder builderForValue)`

This defines the list of partitioning points for dividing the sort into streams There's no guarantees on the size of this It could be completely empty, which could happen if it look like all the data has the same sort key - implies that we don't know what to do besides one sort stream There is no guarantee that the partitioning points are in order

`PlanProtocol.SortOperator.Builder` `setRepeatedField​(com.google.protobuf.Descriptors.FieldDescriptor field, int index, Object value)`
`PlanProtocol.SortOperator.Builder` `setSortKeys​(int index, String value)` The sort columns - order matters
`PlanProtocol.SortOperator.Builder` `setUnknownFields​(com.google.protobuf.UnknownFieldSet unknownFields)`

### Methods inherited from class com.google.protobuf.GeneratedMessageV3.Builder

`getAllFields, getField, getFieldBuilder, getOneofFieldDescriptor, getParentForChildren, getRepeatedField, getRepeatedFieldBuilder, getRepeatedFieldCount, getUnknownFields, hasField, hasOneof, internalGetMapField, internalGetMutableMapField, isClean, markClean, newBuilderForField, onBuilt, onChanged, setUnknownFieldsProto3`

### Methods inherited from class com.google.protobuf.AbstractMessage.Builder

`findInitializationErrors, getInitializationErrorString, internalMergeFrom, mergeDelimitedFrom, mergeDelimitedFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, newUninitializedMessageException, toString`

### Methods inherited from class com.google.protobuf.AbstractMessageLite.Builder

`addAll, addAll, mergeFrom, newUninitializedMessageException`

### Methods inherited from class java.lang.Object

`equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

### Methods inherited from interface com.google.protobuf.MessageLite.Builder

`mergeFrom`

### Methods inherited from interface com.google.protobuf.MessageOrBuilder

`findInitializationErrors, getAllFields, getField, getInitializationErrorString, getOneofFieldDescriptor, getRepeatedField, getRepeatedFieldCount, getUnknownFields, hasField, hasOneof`

### Method Detail

#### getDescriptor

    public static final com.google.protobuf.Descriptors.Descriptor getDescriptor()

#### internalGetFieldAccessorTable

    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable()

Specified by:
  `internalGetFieldAccessorTable` in class `com.google.protobuf.GeneratedMessageV3.Builder<PlanProtocol.SortOperator.Builder>`

#### clear

    public PlanProtocol.SortOperator.Builder clear()

Specified by:
  `clear` in interface `com.google.protobuf.Message.Builder`
Specified by:
  `clear` in interface `com.google.protobuf.MessageLite.Builder`
Overrides:
  `clear` in class `com.google.protobuf.GeneratedMessageV3.Builder<PlanProtocol.SortOperator.Builder>`

#### getDescriptorForType

    public com.google.protobuf.Descriptors.Descriptor getDescriptorForType()

Specified by:
  `getDescriptorForType` in interface `com.google.protobuf.Message.Builder`
Specified by:
  `getDescriptorForType` in interface `com.google.protobuf.MessageOrBuilder`
Overrides:
  `getDescriptorForType` in class `com.google.protobuf.GeneratedMessageV3.Builder<PlanProtocol.SortOperator.Builder>`

#### getDefaultInstanceForType

    public PlanProtocol.SortOperator getDefaultInstanceForType()

Specified by:
  `getDefaultInstanceForType` in interface `com.google.protobuf.MessageLiteOrBuilder`
Specified by:
  `getDefaultInstanceForType` in interface `com.google.protobuf.MessageOrBuilder`

#### build

    public PlanProtocol.SortOperator build()

Specified by:
  `build` in interface `com.google.protobuf.Message.Builder`
Specified by:
  `build` in interface `com.google.protobuf.MessageLite.Builder`

#### buildPartial

    public PlanProtocol.SortOperator buildPartial()

Specified by:
  `buildPartial` in interface `com.google.protobuf.Message.Builder`
Specified by:
  `buildPartial` in interface `com.google.protobuf.MessageLite.Builder`

#### clone

    public PlanProtocol.SortOperator.Builder clone()

Specified by:
  `clone` in interface `com.google.protobuf.Message.Builder`
Specified by:
  `clone` in interface `com.google.protobuf.MessageLite.Builder`
Overrides:
  `clone` in class `com.google.protobuf.GeneratedMessageV3.Builder<PlanProtocol.SortOperator.Builder>`

#### setField

    public PlanProtocol.SortOperator.Builder setField​(com.google.protobuf.Descriptors.FieldDescriptor field,
                                                      Object value)

Specified by:
  `setField` in interface `com.google.protobuf.Message.Builder`
Overrides:
  `setField` in class `com.google.protobuf.GeneratedMessageV3.Builder<PlanProtocol.SortOperator.Builder>`

#### clearField

    public PlanProtocol.SortOperator.Builder clearField​(com.google.protobuf.Descriptors.FieldDescriptor field)

Specified by:
  `clearField` in interface `com.google.protobuf.Message.Builder`
Overrides:
  `clearField` in class `com.google.protobuf.GeneratedMessageV3.Builder<PlanProtocol.SortOperator.Builder>`

#### clearOneof

    public PlanProtocol.SortOperator.Builder clearOneof​(com.google.protobuf.Descriptors.OneofDescriptor oneof)

Specified by:
  `clearOneof` in interface `com.google.protobuf.Message.Builder`
Overrides:
  `clearOneof` in class `com.google.protobuf.GeneratedMessageV3.Builder<PlanProtocol.SortOperator.Builder>`

#### setRepeatedField

    public PlanProtocol.SortOperator.Builder setRepeatedField​(com.google.protobuf.Descriptors.FieldDescriptor field,
                                                              int index,
                                                              Object value)

Specified by:
  `setRepeatedField` in interface `com.google.protobuf.Message.Builder`
Overrides:
  `setRepeatedField` in class `com.google.protobuf.GeneratedMessageV3.Builder<PlanProtocol.SortOperator.Builder>`

#### addRepeatedField

    public PlanProtocol.SortOperator.Builder addRepeatedField​(com.google.protobuf.Descriptors.FieldDescriptor field,
                                                              Object value)

Specified by:
  `addRepeatedField` in interface `com.google.protobuf.Message.Builder`
Overrides:
  `addRepeatedField` in class `com.google.protobuf.GeneratedMessageV3.Builder<PlanProtocol.SortOperator.Builder>`

#### mergeFrom

    public PlanProtocol.SortOperator.Builder mergeFrom​(com.google.protobuf.Message other)

Specified by:
  `mergeFrom` in interface `com.google.protobuf.Message.Builder`
Overrides:
  `mergeFrom` in class `com.google.protobuf.AbstractMessage.Builder<PlanProtocol.SortOperator.Builder>`

#### mergeFrom

    public PlanProtocol.SortOperator.Builder mergeFrom​(PlanProtocol.SortOperator other)

#### isInitialized

    public final boolean isInitialized()

Specified by:
  `isInitialized` in interface `com.google.protobuf.MessageLiteOrBuilder`
Overrides:
  `isInitialized` in class `com.google.protobuf.GeneratedMessageV3.Builder<PlanProtocol.SortOperator.Builder>`

#### mergeFrom

    public PlanProtocol.SortOperator.Builder mergeFrom​(com.google.protobuf.CodedInputStream input,
                                                       com.google.protobuf.ExtensionRegistryLite extensionRegistry)
                                                throws IOException

Specified by:
  `mergeFrom` in interface `com.google.protobuf.Message.Builder`
Specified by:
  `mergeFrom` in interface `com.google.protobuf.MessageLite.Builder`
Overrides:
  `mergeFrom` in class `com.google.protobuf.AbstractMessage.Builder<PlanProtocol.SortOperator.Builder>`
Throws:
  `IOException`

#### getSortKeysList

    public com.google.protobuf.ProtocolStringList getSortKeysList()

    The sort columns - order matters

`repeated string sortKeys = 1;`

Specified by:
  `getSortKeysList` in interface `PlanProtocol.SortOperatorOrBuilder`
Returns:
  A list containing the sortKeys.

#### getSortKeysCount

    public int getSortKeysCount()

    The sort columns - order matters

`repeated string sortKeys = 1;`

Specified by:
  `getSortKeysCount` in interface `PlanProtocol.SortOperatorOrBuilder`
Returns:
  The count of sortKeys.

#### getSortKeys

    public String getSortKeys​(int index)

    The sort columns - order matters

`repeated string sortKeys = 1;`

Specified by:
  `getSortKeys` in interface `PlanProtocol.SortOperatorOrBuilder`
Parameters:
  `index` - The index of the element to return.
Returns:
  The sortKeys at the given index.

#### getSortKeysBytes

    public com.google.protobuf.ByteString getSortKeysBytes​(int index)

    The sort columns - order matters

`repeated string sortKeys = 1;`

Specified by:
  `getSortKeysBytes` in interface `PlanProtocol.SortOperatorOrBuilder`
Parameters:
  `index` - The index of the value to return.
Returns:
  The bytes of the sortKeys at the given index.

#### setSortKeys

    public PlanProtocol.SortOperator.Builder setSortKeys​(int index,
                                                         String value)

    The sort columns - order matters

`repeated string sortKeys = 1;`

Parameters:
  `index` - The index to set the value at.
  `value` - The sortKeys to set.
Returns:
  This builder for chaining.

#### addSortKeys

    public PlanProtocol.SortOperator.Builder addSortKeys​(String value)

    The sort columns - order matters

`repeated string sortKeys = 1;`

Parameters:
  `value` - The sortKeys to add.
Returns:
  This builder for chaining.

#### addAllSortKeys

    public PlanProtocol.SortOperator.Builder addAllSortKeys​(Iterable<String> values)

    The sort columns - order matters

`repeated string sortKeys = 1;`

Parameters:
  `values` - The sortKeys to add.
Returns:
  This builder for chaining.

#### clearSortKeys

    public PlanProtocol.SortOperator.Builder clearSortKeys()

    The sort columns - order matters

`repeated string sortKeys = 1;`

Returns:
  This builder for chaining.

#### addSortKeysBytes

    public PlanProtocol.SortOperator.Builder addSortKeysBytes​(com.google.protobuf.ByteString value)

    The sort columns - order matters

`repeated string sortKeys = 1;`

Parameters:
  `value` - The bytes of the sortKeys to add.
Returns:
  This builder for chaining.

#### getDirectionsList

    public List<Boolean> getDirectionsList()

    The directions for each sort col - true = ascending

`repeated bool directions = 2;`

Specified by:
  `getDirectionsList` in interface `PlanProtocol.SortOperatorOrBuilder`
Returns:
  A list containing the directions.

#### getDirectionsCount

    public int getDirectionsCount()

    The directions for each sort col - true = ascending

`repeated bool directions = 2;`

Specified by:
  `getDirectionsCount` in interface `PlanProtocol.SortOperatorOrBuilder`
Returns:
  The count of directions.

#### getDirections

    public boolean getDirections​(int index)

    The directions for each sort col - true = ascending

`repeated bool directions = 2;`

Specified by:
  `getDirections` in interface `PlanProtocol.SortOperatorOrBuilder`
Parameters:
  `index` - The index of the element to return.
Returns:
  The directions at the given index.

#### setDirections

    public PlanProtocol.SortOperator.Builder setDirections​(int index,
                                                           boolean value)

    The directions for each sort col - true = ascending

`repeated bool directions = 2;`

Parameters:
  `index` - The index to set the value at.
  `value` - The directions to set.
Returns:
  This builder for chaining.

#### addDirections

    public PlanProtocol.SortOperator.Builder addDirections​(boolean value)

    The directions for each sort col - true = ascending

`repeated bool directions = 2;`

Parameters:
  `value` - The directions to add.
Returns:
  This builder for chaining.

#### addAllDirections

    public PlanProtocol.SortOperator.Builder addAllDirections​(Iterable<? extends Boolean> values)

    The directions for each sort col - true = ascending

`repeated bool directions = 2;`

Parameters:
  `values` - The directions to add.
Returns:
  This builder for chaining.

#### clearDirections

    public PlanProtocol.SortOperator.Builder clearDirections()

    The directions for each sort col - true = ascending

`repeated bool directions = 2;`

Returns:
  This builder for chaining.

#### getLimitVal

    public long getLimitVal()

    If we know we only need the top n rows of the sort
    that is noted here
    If there is no limit being applied, this is set to -1

`int64 limitVal = 3;`

Specified by:
  `getLimitVal` in interface `PlanProtocol.SortOperatorOrBuilder`
Returns:
  The limitVal.

#### setLimitVal

    public PlanProtocol.SortOperator.Builder setLimitVal​(long value)

    If we know we only need the top n rows of the sort
    that is noted here
    If there is no limit being applied, this is set to -1

`int64 limitVal = 3;`

Parameters:
  `value` - The limitVal to set.
Returns:
  This builder for chaining.

#### clearLimitVal

    public PlanProtocol.SortOperator.Builder clearLimitVal()

    If we know we only need the top n rows of the sort
    that is noted here
    If there is no limit being applied, this is set to -1

`int64 limitVal = 3;`

Returns:
  This builder for chaining.

#### getPointList

    public List<PlanProtocol.SortPartition> getPointList()

    This defines the list of partitioning points for dividing the sort into streams
    There's no guarantees on the size of this
    It could be completely empty, which could happen if it look like all the data
    has the same sort key - implies that we don't know what to do besides
    one sort stream
    There is no guarantee that the partitioning points are in order

`repeated .xg.db.sqlPlans.SortPartition point = 4;`

Specified by:
  `getPointList` in interface `PlanProtocol.SortOperatorOrBuilder`

#### getPointCount

    public int getPointCount()

    This defines the list of partitioning points for dividing the sort into streams
    There's no guarantees on the size of this
    It could be completely empty, which could happen if it look like all the data
    has the same sort key - implies that we don't know what to do besides
    one sort stream
    There is no guarantee that the partitioning points are in order

`repeated .xg.db.sqlPlans.SortPartition point = 4;`

Specified by:
  `getPointCount` in interface `PlanProtocol.SortOperatorOrBuilder`

#### getPoint

    public PlanProtocol.SortPartition getPoint​(int index)

    This defines the list of partitioning points for dividing the sort into streams
    There's no guarantees on the size of this
    It could be completely empty, which could happen if it look like all the data
    has the same sort key - implies that we don't know what to do besides
    one sort stream
    There is no guarantee that the partitioning points are in order

`repeated .xg.db.sqlPlans.SortPartition point = 4;`

Specified by:
  `getPoint` in interface `PlanProtocol.SortOperatorOrBuilder`

#### setPoint

    public PlanProtocol.SortOperator.Builder setPoint​(int index,
                                                      PlanProtocol.SortPartition value)

    This defines the list of partitioning points for dividing the sort into streams
    There's no guarantees on the size of this
    It could be completely empty, which could happen if it look like all the data
    has the same sort key - implies that we don't know what to do besides
    one sort stream
    There is no guarantee that the partitioning points are in order

`repeated .xg.db.sqlPlans.SortPartition point = 4;`

#### setPoint

    public PlanProtocol.SortOperator.Builder setPoint​(int index,
                                                      PlanProtocol.SortPartition.Builder builderForValue)

    This defines the list of partitioning points for dividing the sort into streams
    There's no guarantees on the size of this
    It could be completely empty, which could happen if it look like all the data
    has the same sort key - implies that we don't know what to do besides
    one sort stream
    There is no guarantee that the partitioning points are in order

`repeated .xg.db.sqlPlans.SortPartition point = 4;`

#### addPoint

    public PlanProtocol.SortOperator.Builder addPoint​(PlanProtocol.SortPartition value)

    This defines the list of partitioning points for dividing the sort into streams
    There's no guarantees on the size of this
    It could be completely empty, which could happen if it look like all the data
    has the same sort key - implies that we don't know what to do besides
    one sort stream
    There is no guarantee that the partitioning points are in order

`repeated .xg.db.sqlPlans.SortPartition point = 4;`

#### addPoint

    public PlanProtocol.SortOperator.Builder addPoint​(int index,
                                                      PlanProtocol.SortPartition value)

    This defines the list of partitioning points for dividing the sort into streams
    There's no guarantees on the size of this
    It could be completely empty, which could happen if it look like all the data
    has the same sort key - implies that we don't know what to do besides
    one sort stream
    There is no guarantee that the partitioning points are in order

`repeated .xg.db.sqlPlans.SortPartition point = 4;`

#### addPoint

    public PlanProtocol.SortOperator.Builder addPoint​(PlanProtocol.SortPartition.Builder builderForValue)

    This defines the list of partitioning points for dividing the sort into streams
    There's no guarantees on the size of this
    It could be completely empty, which could happen if it look like all the data
    has the same sort key - implies that we don't know what to do besides
    one sort stream
    There is no guarantee that the partitioning points are in order

`repeated .xg.db.sqlPlans.SortPartition point = 4;`

#### addPoint

    public PlanProtocol.SortOperator.Builder addPoint​(int index,
                                                      PlanProtocol.SortPartition.Builder builderForValue)

    This defines the list of partitioning points for dividing the sort into streams
    There's no guarantees on the size of this
    It could be completely empty, which could happen if it look like all the data
    has the same sort key - implies that we don't know what to do besides
    one sort stream
    There is no guarantee that the partitioning points are in order

`repeated .xg.db.sqlPlans.SortPartition point = 4;`

#### addAllPoint

    public PlanProtocol.SortOperator.Builder addAllPoint​(Iterable<? extends PlanProtocol.SortPartition> values)

    This defines the list of partitioning points for dividing the sort into streams
    There's no guarantees on the size of this
    It could be completely empty, which could happen if it look like all the data
    has the same sort key - implies that we don't know what to do besides
    one sort stream
    There is no guarantee that the partitioning points are in order

`repeated .xg.db.sqlPlans.SortPartition point = 4;`

#### clearPoint

    public PlanProtocol.SortOperator.Builder clearPoint()

    This defines the list of partitioning points for dividing the sort into streams
    There's no guarantees on the size of this
    It could be completely empty, which could happen if it look like all the data
    has the same sort key - implies that we don't know what to do besides
    one sort stream
    There is no guarantee that the partitioning points are in order

`repeated .xg.db.sqlPlans.SortPartition point = 4;`

#### removePoint

    public PlanProtocol.SortOperator.Builder removePoint​(int index)

    This defines the list of partitioning points for dividing the sort into streams
    There's no guarantees on the size of this
    It could be completely empty, which could happen if it look like all the data
    has the same sort key - implies that we don't know what to do besides
    one sort stream
    There is no guarantee that the partitioning points are in order

`repeated .xg.db.sqlPlans.SortPartition point = 4;`

#### getPointBuilder

    public PlanProtocol.SortPartition.Builder getPointBuilder​(int index)

    This defines the list of partitioning points for dividing the sort into streams
    There's no guarantees on the size of this
    It could be completely empty, which could happen if it look like all the data
    has the same sort key - implies that we don't know what to do besides
    one sort stream
    There is no guarantee that the partitioning points are in order

`repeated .xg.db.sqlPlans.SortPartition point = 4;`

#### getPointOrBuilder

    public PlanProtocol.SortPartitionOrBuilder getPointOrBuilder​(int index)

    This defines the list of partitioning points for dividing the sort into streams
    There's no guarantees on the size of this
    It could be completely empty, which could happen if it look like all the data
    has the same sort key - implies that we don't know what to do besides
    one sort stream
    There is no guarantee that the partitioning points are in order

`repeated .xg.db.sqlPlans.SortPartition point = 4;`

Specified by:
  `getPointOrBuilder` in interface `PlanProtocol.SortOperatorOrBuilder`

#### getPointOrBuilderList

    public List<? extends PlanProtocol.SortPartitionOrBuilder> getPointOrBuilderList()

    This defines the list of partitioning points for dividing the sort into streams
    There's no guarantees on the size of this
    It could be completely empty, which could happen if it look like all the data
    has the same sort key - implies that we don't know what to do besides
    one sort stream
    There is no guarantee that the partitioning points are in order

`repeated .xg.db.sqlPlans.SortPartition point = 4;`

Specified by:
  `getPointOrBuilderList` in interface `PlanProtocol.SortOperatorOrBuilder`

#### addPointBuilder

    public PlanProtocol.SortPartition.Builder addPointBuilder()

    This defines the list of partitioning points for dividing the sort into streams
    There's no guarantees on the size of this
    It could be completely empty, which could happen if it look like all the data
    has the same sort key - implies that we don't know what to do besides
    one sort stream
    There is no guarantee that the partitioning points are in order

`repeated .xg.db.sqlPlans.SortPartition point = 4;`

#### addPointBuilder

    public PlanProtocol.SortPartition.Builder addPointBuilder​(int index)

    This defines the list of partitioning points for dividing the sort into streams
    There's no guarantees on the size of this
    It could be completely empty, which could happen if it look like all the data
    has the same sort key - implies that we don't know what to do besides
    one sort stream
    There is no guarantee that the partitioning points are in order

`repeated .xg.db.sqlPlans.SortPartition point = 4;`

#### getPointBuilderList

    public List<PlanProtocol.SortPartition.Builder> getPointBuilderList()

    This defines the list of partitioning points for dividing the sort into streams
    There's no guarantees on the size of this
    It could be completely empty, which could happen if it look like all the data
    has the same sort key - implies that we don't know what to do besides
    one sort stream
    There is no guarantee that the partitioning points are in order

`repeated .xg.db.sqlPlans.SortPartition point = 4;`

#### setUnknownFields

    public final PlanProtocol.SortOperator.Builder setUnknownFields​(com.google.protobuf.UnknownFieldSet unknownFields)

Specified by:
  `setUnknownFields` in interface `com.google.protobuf.Message.Builder`
Overrides:
  `setUnknownFields` in class `com.google.protobuf.GeneratedMessageV3.Builder<PlanProtocol.SortOperator.Builder>`

#### mergeUnknownFields

    public final PlanProtocol.SortOperator.Builder mergeUnknownFields​(com.google.protobuf.UnknownFieldSet unknownFields)

Specified by:
  `mergeUnknownFields` in interface `com.google.protobuf.Message.Builder`
Overrides:
  `mergeUnknownFields` in class `com.google.protobuf.GeneratedMessageV3.Builder<PlanProtocol.SortOperator.Builder>`