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

Modifier and Type | Method | Description
--- | --- | ---
`PlanProtocol.SortOperator.Builder` | `addAllDirections​(Iterable<? extends Boolean> values)` | The directions for each sort col - true = ascending
`PlanProtocol.SortOperator.Builder` | `addAllHashSortKeys​(Iterable<String> values)` | The hash sort keys if there are any, primarily only for window these can be different from the regular sort keys if this isn't empty we do a hash based sort mutliplexing instead
`PlanProtocol.SortOperator.Builder` | `addAllNullsFirst​(Iterable<? extends Boolean> values)` | `repeated bool nulls_first = 6;`

`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` | `addHashSortKeys​(String value)` | The hash sort keys if there are any, primarily only for window these can be different from the regular sort keys if this isn't empty we do a hash based sort mutliplexing instead
`PlanProtocol.SortOperator.Builder` | `addHashSortKeysBytes​(com.google.protobuf.ByteString value)` | The hash sort keys if there are any, primarily only for window these can be different from the regular sort keys if this isn't empty we do a hash based sort mutliplexing instead
`PlanProtocol.SortOperator.Builder` | `addNullsFirst​(boolean value)` | `repeated bool nulls_first = 6;`

`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` | `clearHashSortKeys()` | The hash sort keys if there are any, primarily only for window these can be different from the regular sort keys if this isn't empty we do a hash based sort mutliplexing instead
`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` | `clearNullsFirst()` | `repeated bool nulls_first = 6;`
`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
`String` | `getHashSortKeys​(int index)` | The hash sort keys if there are any, primarily only for window these can be different from the regular sort keys if this isn't empty we do a hash based sort mutliplexing instead
`com.google.protobuf.ByteString` | `getHashSortKeysBytes​(int index)` | The hash sort keys if there are any, primarily only for window these can be different from the regular sort keys if this isn't empty we do a hash based sort mutliplexing instead
`int` | `getHashSortKeysCount()` | The hash sort keys if there are any, primarily only for window these can be different from the regular sort keys if this isn't empty we do a hash based sort mutliplexing instead
`com.google.protobuf.ProtocolStringList` | `getHashSortKeysList()` | The hash sort keys if there are any, primarily only for window these can be different from the regular sort keys if this isn't empty we do a hash based sort mutliplexing instead
`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
`boolean` | `getNullsFirst​(int index)` | `repeated bool nulls_first = 6;`
`int` | `getNullsFirstCount()` | `repeated bool nulls_first = 6;`
`List<Boolean>` | `getNullsFirstList()` | `repeated bool nulls_first = 6;`

`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` | `setHashSortKeys​(int index, String value)` | The hash sort keys if there are any, primarily only for window these can be different from the regular sort keys if this isn't empty we do a hash based sort mutliplexing instead
`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` | `setNullsFirst​(int index, boolean value)` | `repeated bool nulls_first = 6;`

`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 Details

### 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`

### getSortKeysCount

public int getSortKeysCount()

    The sort columns - order matters

`repeated string sortKeys = 1;`

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

### getSortKeys

public String getSortKeys​(int index)

    The sort columns - order matters

`repeated string sortKeys = 1;`

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

### 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`

### setSortKeys

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

    The sort columns - order matters

`repeated string sortKeys = 1;`

### addSortKeys

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

    The sort columns - order matters

`repeated string sortKeys = 1;`

### addAllSortKeys

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

    The sort columns - order matters

`repeated string sortKeys = 1;`

### clearSortKeys

public PlanProtocol.SortOperator.Builder clearSortKeys()

    The sort columns - order matters

`repeated string sortKeys = 1;`

### addSortKeysBytes

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

    The sort columns - order matters

`repeated string sortKeys = 1;`

### getDirectionsList

public List<Boolean> getDirectionsList()

    The directions for each sort col - true = ascending

`repeated bool directions = 2;`

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

### getDirectionsCount

public int getDirectionsCount()

    The directions for each sort col - true = ascending

`repeated bool directions = 2;`

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

### 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`

### setDirections

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

    The directions for each sort col - true = ascending

`repeated bool directions = 2;`

### addDirections

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

    The directions for each sort col - true = ascending

`repeated bool directions = 2;`

### addAllDirections

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

    The directions for each sort col - true = ascending

`repeated bool directions = 2;`

### clearDirections

public PlanProtocol.SortOperator.Builder clearDirections()

    The directions for each sort col - true = ascending

`repeated bool directions = 2;`

### 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`

### 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;`

### 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;`

### 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;`

### getHashSortKeysList

public com.google.protobuf.ProtocolStringList getHashSortKeysList()

    The hash sort keys if there are any, primarily only for window
    these can be different from the regular sort keys
    if this isn't empty we do a hash based sort mutliplexing instead

`repeated string hashSortKeys = 5;`

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

### getHashSortKeysCount

public int getHashSortKeysCount()

    The hash sort keys if there are any, primarily only for window
    these can be different from the regular sort keys
    if this isn't empty we do a hash based sort mutliplexing instead

`repeated string hashSortKeys = 5;`

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

### getHashSortKeys

public String getHashSortKeys​(int index)

    The hash sort keys if there are any, primarily only for window
    these can be different from the regular sort keys
    if this isn't empty we do a hash based sort mutliplexing instead

`repeated string hashSortKeys = 5;`

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

### getHashSortKeysBytes

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

    The hash sort keys if there are any, primarily only for window
    these can be different from the regular sort keys
    if this isn't empty we do a hash based sort mutliplexing instead

`repeated string hashSortKeys = 5;`

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

### setHashSortKeys

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

    The hash sort keys if there are any, primarily only for window
    these can be different from the regular sort keys
    if this isn't empty we do a hash based sort mutliplexing instead

`repeated string hashSortKeys = 5;`

### addHashSortKeys

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

    The hash sort keys if there are any, primarily only for window
    these can be different from the regular sort keys
    if this isn't empty we do a hash based sort mutliplexing instead

`repeated string hashSortKeys = 5;`

### addAllHashSortKeys

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

    The hash sort keys if there are any, primarily only for window
    these can be different from the regular sort keys
    if this isn't empty we do a hash based sort mutliplexing instead

`repeated string hashSortKeys = 5;`

### clearHashSortKeys

public PlanProtocol.SortOperator.Builder clearHashSortKeys()

    The hash sort keys if there are any, primarily only for window
    these can be different from the regular sort keys
    if this isn't empty we do a hash based sort mutliplexing instead

`repeated string hashSortKeys = 5;`

### addHashSortKeysBytes

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

    The hash sort keys if there are any, primarily only for window
    these can be different from the regular sort keys
    if this isn't empty we do a hash based sort mutliplexing instead

`repeated string hashSortKeys = 5;`

### getNullsFirstList

public List<Boolean> getNullsFirstList()
`repeated bool nulls_first = 6;`

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

### getNullsFirstCount

public int getNullsFirstCount()
`repeated bool nulls_first = 6;`

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

### getNullsFirst

public boolean getNullsFirst​(int index)
`repeated bool nulls_first = 6;`

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

### setNullsFirst

public PlanProtocol.SortOperator.Builder setNullsFirst​(int index, boolean value)
`repeated bool nulls_first = 6;`

### addNullsFirst

public PlanProtocol.SortOperator.Builder addNullsFirst​(boolean value)
`repeated bool nulls_first = 6;`

### addAllNullsFirst

public PlanProtocol.SortOperator.Builder addAllNullsFirst​(Iterable<? extends Boolean> values)
`repeated bool nulls_first = 6;`

### clearNullsFirst

public PlanProtocol.SortOperator.Builder clearNullsFirst()
`repeated bool nulls_first = 6;`

### 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>`