public static final class RowFilter.Interleave.Builder extends com.google.protobuf.GeneratedMessage.Builder<RowFilter.Interleave.Builder> implements RowFilter.InterleaveOrBuilder
A RowFilter which sends each row to each of several component RowFilters and interleaves the results.Protobuf type
google.bigtable.v2.RowFilter.Interleave| Modifier and Type | Method and Description |
|---|---|
RowFilter.Interleave.Builder |
addAllFilters(Iterable<? extends RowFilter> values)
The elements of "filters" all process a copy of the input row, and the
results are pooled, sorted, and combined into a single output row.
|
RowFilter.Interleave.Builder |
addFilters(int index,
RowFilter.Builder builderForValue)
The elements of "filters" all process a copy of the input row, and the
results are pooled, sorted, and combined into a single output row.
|
RowFilter.Interleave.Builder |
addFilters(int index,
RowFilter value)
The elements of "filters" all process a copy of the input row, and the
results are pooled, sorted, and combined into a single output row.
|
RowFilter.Interleave.Builder |
addFilters(RowFilter.Builder builderForValue)
The elements of "filters" all process a copy of the input row, and the
results are pooled, sorted, and combined into a single output row.
|
RowFilter.Interleave.Builder |
addFilters(RowFilter value)
The elements of "filters" all process a copy of the input row, and the
results are pooled, sorted, and combined into a single output row.
|
RowFilter.Builder |
addFiltersBuilder()
The elements of "filters" all process a copy of the input row, and the
results are pooled, sorted, and combined into a single output row.
|
RowFilter.Builder |
addFiltersBuilder(int index)
The elements of "filters" all process a copy of the input row, and the
results are pooled, sorted, and combined into a single output row.
|
RowFilter.Interleave |
build() |
RowFilter.Interleave |
buildPartial() |
RowFilter.Interleave.Builder |
clear() |
RowFilter.Interleave.Builder |
clearFilters()
The elements of "filters" all process a copy of the input row, and the
results are pooled, sorted, and combined into a single output row.
|
RowFilter.Interleave |
getDefaultInstanceForType() |
static com.google.protobuf.Descriptors.Descriptor |
getDescriptor() |
com.google.protobuf.Descriptors.Descriptor |
getDescriptorForType() |
RowFilter |
getFilters(int index)
The elements of "filters" all process a copy of the input row, and the
results are pooled, sorted, and combined into a single output row.
|
RowFilter.Builder |
getFiltersBuilder(int index)
The elements of "filters" all process a copy of the input row, and the
results are pooled, sorted, and combined into a single output row.
|
List<RowFilter.Builder> |
getFiltersBuilderList()
The elements of "filters" all process a copy of the input row, and the
results are pooled, sorted, and combined into a single output row.
|
int |
getFiltersCount()
The elements of "filters" all process a copy of the input row, and the
results are pooled, sorted, and combined into a single output row.
|
List<RowFilter> |
getFiltersList()
The elements of "filters" all process a copy of the input row, and the
results are pooled, sorted, and combined into a single output row.
|
RowFilterOrBuilder |
getFiltersOrBuilder(int index)
The elements of "filters" all process a copy of the input row, and the
results are pooled, sorted, and combined into a single output row.
|
List<? extends RowFilterOrBuilder> |
getFiltersOrBuilderList()
The elements of "filters" all process a copy of the input row, and the
results are pooled, sorted, and combined into a single output row.
|
protected com.google.protobuf.GeneratedMessage.FieldAccessorTable |
internalGetFieldAccessorTable() |
boolean |
isInitialized() |
RowFilter.Interleave.Builder |
mergeFrom(com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry) |
RowFilter.Interleave.Builder |
mergeFrom(com.google.protobuf.Message other) |
RowFilter.Interleave.Builder |
mergeFrom(RowFilter.Interleave other) |
RowFilter.Interleave.Builder |
removeFilters(int index)
The elements of "filters" all process a copy of the input row, and the
results are pooled, sorted, and combined into a single output row.
|
RowFilter.Interleave.Builder |
setFilters(int index,
RowFilter.Builder builderForValue)
The elements of "filters" all process a copy of the input row, and the
results are pooled, sorted, and combined into a single output row.
|
RowFilter.Interleave.Builder |
setFilters(int index,
RowFilter value)
The elements of "filters" all process a copy of the input row, and the
results are pooled, sorted, and combined into a single output row.
|
addRepeatedField, clearField, clearOneof, clone, getAllFields, getField, getFieldBuilder, getOneofFieldDescriptor, getParentForChildren, getRepeatedField, getRepeatedFieldBuilder, getRepeatedFieldCount, getUnknownFields, getUnknownFieldSetBuilder, hasField, hasOneof, internalGetMapField, internalGetMapFieldReflection, internalGetMutableMapField, internalGetMutableMapFieldReflection, isClean, markClean, mergeUnknownFields, mergeUnknownLengthDelimitedField, mergeUnknownVarintField, newBuilderForField, onBuilt, onChanged, parseUnknownField, setField, setRepeatedField, setUnknownFields, setUnknownFieldSetBuilder, setUnknownFieldsProto3findInitializationErrors, getInitializationErrorString, internalMergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, newUninitializedMessageException, toStringaddAll, addAll, mergeDelimitedFrom, mergeDelimitedFrom, mergeFrom, newUninitializedMessageExceptionequals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, waitfindInitializationErrors, getAllFields, getField, getInitializationErrorString, getOneofFieldDescriptor, getRepeatedField, getRepeatedFieldCount, getUnknownFields, hasField, hasOneofpublic static final com.google.protobuf.Descriptors.Descriptor getDescriptor()
protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable()
internalGetFieldAccessorTable in class com.google.protobuf.GeneratedMessage.Builder<RowFilter.Interleave.Builder>public RowFilter.Interleave.Builder clear()
clear in interface com.google.protobuf.Message.Builderclear in interface com.google.protobuf.MessageLite.Builderclear in class com.google.protobuf.GeneratedMessage.Builder<RowFilter.Interleave.Builder>public com.google.protobuf.Descriptors.Descriptor getDescriptorForType()
getDescriptorForType in interface com.google.protobuf.Message.BuildergetDescriptorForType in interface com.google.protobuf.MessageOrBuildergetDescriptorForType in class com.google.protobuf.GeneratedMessage.Builder<RowFilter.Interleave.Builder>public RowFilter.Interleave getDefaultInstanceForType()
getDefaultInstanceForType in interface com.google.protobuf.MessageLiteOrBuildergetDefaultInstanceForType in interface com.google.protobuf.MessageOrBuilderpublic RowFilter.Interleave build()
build in interface com.google.protobuf.Message.Builderbuild in interface com.google.protobuf.MessageLite.Builderpublic RowFilter.Interleave buildPartial()
buildPartial in interface com.google.protobuf.Message.BuilderbuildPartial in interface com.google.protobuf.MessageLite.Builderpublic RowFilter.Interleave.Builder mergeFrom(com.google.protobuf.Message other)
mergeFrom in interface com.google.protobuf.Message.BuildermergeFrom in class com.google.protobuf.AbstractMessage.Builder<RowFilter.Interleave.Builder>public RowFilter.Interleave.Builder mergeFrom(RowFilter.Interleave other)
public final boolean isInitialized()
isInitialized in interface com.google.protobuf.MessageLiteOrBuilderisInitialized in class com.google.protobuf.GeneratedMessage.Builder<RowFilter.Interleave.Builder>public RowFilter.Interleave.Builder mergeFrom(com.google.protobuf.CodedInputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws IOException
mergeFrom in interface com.google.protobuf.Message.BuildermergeFrom in interface com.google.protobuf.MessageLite.BuildermergeFrom in class com.google.protobuf.AbstractMessage.Builder<RowFilter.Interleave.Builder>IOExceptionpublic List<RowFilter> getFiltersList()
The elements of "filters" all process a copy of the input row, and the results are pooled, sorted, and combined into a single output row. If multiple cells are produced with the same column and timestamp, they will all appear in the output row in an unspecified mutual order. Consider the following example, with three filters: input row | ----------------------------------------------------- | | | f(0) f(1) f(2) | | | 1: foo,bar,10,x foo,bar,10,z far,bar,7,a 2: foo,blah,11,z far,blah,5,x far,blah,5,x | | | ----------------------------------------------------- | 1: foo,bar,10,z // could have switched with #2 2: foo,bar,10,x // could have switched with #1 3: foo,blah,11,z 4: far,bar,7,a 5: far,blah,5,x // identical to #6 6: far,blah,5,x // identical to #5 All interleaved filters are executed atomically.
repeated .google.bigtable.v2.RowFilter filters = 1;getFiltersList in interface RowFilter.InterleaveOrBuilderpublic int getFiltersCount()
The elements of "filters" all process a copy of the input row, and the results are pooled, sorted, and combined into a single output row. If multiple cells are produced with the same column and timestamp, they will all appear in the output row in an unspecified mutual order. Consider the following example, with three filters: input row | ----------------------------------------------------- | | | f(0) f(1) f(2) | | | 1: foo,bar,10,x foo,bar,10,z far,bar,7,a 2: foo,blah,11,z far,blah,5,x far,blah,5,x | | | ----------------------------------------------------- | 1: foo,bar,10,z // could have switched with #2 2: foo,bar,10,x // could have switched with #1 3: foo,blah,11,z 4: far,bar,7,a 5: far,blah,5,x // identical to #6 6: far,blah,5,x // identical to #5 All interleaved filters are executed atomically.
repeated .google.bigtable.v2.RowFilter filters = 1;getFiltersCount in interface RowFilter.InterleaveOrBuilderpublic RowFilter getFilters(int index)
The elements of "filters" all process a copy of the input row, and the results are pooled, sorted, and combined into a single output row. If multiple cells are produced with the same column and timestamp, they will all appear in the output row in an unspecified mutual order. Consider the following example, with three filters: input row | ----------------------------------------------------- | | | f(0) f(1) f(2) | | | 1: foo,bar,10,x foo,bar,10,z far,bar,7,a 2: foo,blah,11,z far,blah,5,x far,blah,5,x | | | ----------------------------------------------------- | 1: foo,bar,10,z // could have switched with #2 2: foo,bar,10,x // could have switched with #1 3: foo,blah,11,z 4: far,bar,7,a 5: far,blah,5,x // identical to #6 6: far,blah,5,x // identical to #5 All interleaved filters are executed atomically.
repeated .google.bigtable.v2.RowFilter filters = 1;getFilters in interface RowFilter.InterleaveOrBuilderpublic RowFilter.Interleave.Builder setFilters(int index, RowFilter value)
The elements of "filters" all process a copy of the input row, and the results are pooled, sorted, and combined into a single output row. If multiple cells are produced with the same column and timestamp, they will all appear in the output row in an unspecified mutual order. Consider the following example, with three filters: input row | ----------------------------------------------------- | | | f(0) f(1) f(2) | | | 1: foo,bar,10,x foo,bar,10,z far,bar,7,a 2: foo,blah,11,z far,blah,5,x far,blah,5,x | | | ----------------------------------------------------- | 1: foo,bar,10,z // could have switched with #2 2: foo,bar,10,x // could have switched with #1 3: foo,blah,11,z 4: far,bar,7,a 5: far,blah,5,x // identical to #6 6: far,blah,5,x // identical to #5 All interleaved filters are executed atomically.
repeated .google.bigtable.v2.RowFilter filters = 1;public RowFilter.Interleave.Builder setFilters(int index, RowFilter.Builder builderForValue)
The elements of "filters" all process a copy of the input row, and the results are pooled, sorted, and combined into a single output row. If multiple cells are produced with the same column and timestamp, they will all appear in the output row in an unspecified mutual order. Consider the following example, with three filters: input row | ----------------------------------------------------- | | | f(0) f(1) f(2) | | | 1: foo,bar,10,x foo,bar,10,z far,bar,7,a 2: foo,blah,11,z far,blah,5,x far,blah,5,x | | | ----------------------------------------------------- | 1: foo,bar,10,z // could have switched with #2 2: foo,bar,10,x // could have switched with #1 3: foo,blah,11,z 4: far,bar,7,a 5: far,blah,5,x // identical to #6 6: far,blah,5,x // identical to #5 All interleaved filters are executed atomically.
repeated .google.bigtable.v2.RowFilter filters = 1;public RowFilter.Interleave.Builder addFilters(RowFilter value)
The elements of "filters" all process a copy of the input row, and the results are pooled, sorted, and combined into a single output row. If multiple cells are produced with the same column and timestamp, they will all appear in the output row in an unspecified mutual order. Consider the following example, with three filters: input row | ----------------------------------------------------- | | | f(0) f(1) f(2) | | | 1: foo,bar,10,x foo,bar,10,z far,bar,7,a 2: foo,blah,11,z far,blah,5,x far,blah,5,x | | | ----------------------------------------------------- | 1: foo,bar,10,z // could have switched with #2 2: foo,bar,10,x // could have switched with #1 3: foo,blah,11,z 4: far,bar,7,a 5: far,blah,5,x // identical to #6 6: far,blah,5,x // identical to #5 All interleaved filters are executed atomically.
repeated .google.bigtable.v2.RowFilter filters = 1;public RowFilter.Interleave.Builder addFilters(int index, RowFilter value)
The elements of "filters" all process a copy of the input row, and the results are pooled, sorted, and combined into a single output row. If multiple cells are produced with the same column and timestamp, they will all appear in the output row in an unspecified mutual order. Consider the following example, with three filters: input row | ----------------------------------------------------- | | | f(0) f(1) f(2) | | | 1: foo,bar,10,x foo,bar,10,z far,bar,7,a 2: foo,blah,11,z far,blah,5,x far,blah,5,x | | | ----------------------------------------------------- | 1: foo,bar,10,z // could have switched with #2 2: foo,bar,10,x // could have switched with #1 3: foo,blah,11,z 4: far,bar,7,a 5: far,blah,5,x // identical to #6 6: far,blah,5,x // identical to #5 All interleaved filters are executed atomically.
repeated .google.bigtable.v2.RowFilter filters = 1;public RowFilter.Interleave.Builder addFilters(RowFilter.Builder builderForValue)
The elements of "filters" all process a copy of the input row, and the results are pooled, sorted, and combined into a single output row. If multiple cells are produced with the same column and timestamp, they will all appear in the output row in an unspecified mutual order. Consider the following example, with three filters: input row | ----------------------------------------------------- | | | f(0) f(1) f(2) | | | 1: foo,bar,10,x foo,bar,10,z far,bar,7,a 2: foo,blah,11,z far,blah,5,x far,blah,5,x | | | ----------------------------------------------------- | 1: foo,bar,10,z // could have switched with #2 2: foo,bar,10,x // could have switched with #1 3: foo,blah,11,z 4: far,bar,7,a 5: far,blah,5,x // identical to #6 6: far,blah,5,x // identical to #5 All interleaved filters are executed atomically.
repeated .google.bigtable.v2.RowFilter filters = 1;public RowFilter.Interleave.Builder addFilters(int index, RowFilter.Builder builderForValue)
The elements of "filters" all process a copy of the input row, and the results are pooled, sorted, and combined into a single output row. If multiple cells are produced with the same column and timestamp, they will all appear in the output row in an unspecified mutual order. Consider the following example, with three filters: input row | ----------------------------------------------------- | | | f(0) f(1) f(2) | | | 1: foo,bar,10,x foo,bar,10,z far,bar,7,a 2: foo,blah,11,z far,blah,5,x far,blah,5,x | | | ----------------------------------------------------- | 1: foo,bar,10,z // could have switched with #2 2: foo,bar,10,x // could have switched with #1 3: foo,blah,11,z 4: far,bar,7,a 5: far,blah,5,x // identical to #6 6: far,blah,5,x // identical to #5 All interleaved filters are executed atomically.
repeated .google.bigtable.v2.RowFilter filters = 1;public RowFilter.Interleave.Builder addAllFilters(Iterable<? extends RowFilter> values)
The elements of "filters" all process a copy of the input row, and the results are pooled, sorted, and combined into a single output row. If multiple cells are produced with the same column and timestamp, they will all appear in the output row in an unspecified mutual order. Consider the following example, with three filters: input row | ----------------------------------------------------- | | | f(0) f(1) f(2) | | | 1: foo,bar,10,x foo,bar,10,z far,bar,7,a 2: foo,blah,11,z far,blah,5,x far,blah,5,x | | | ----------------------------------------------------- | 1: foo,bar,10,z // could have switched with #2 2: foo,bar,10,x // could have switched with #1 3: foo,blah,11,z 4: far,bar,7,a 5: far,blah,5,x // identical to #6 6: far,blah,5,x // identical to #5 All interleaved filters are executed atomically.
repeated .google.bigtable.v2.RowFilter filters = 1;public RowFilter.Interleave.Builder clearFilters()
The elements of "filters" all process a copy of the input row, and the results are pooled, sorted, and combined into a single output row. If multiple cells are produced with the same column and timestamp, they will all appear in the output row in an unspecified mutual order. Consider the following example, with three filters: input row | ----------------------------------------------------- | | | f(0) f(1) f(2) | | | 1: foo,bar,10,x foo,bar,10,z far,bar,7,a 2: foo,blah,11,z far,blah,5,x far,blah,5,x | | | ----------------------------------------------------- | 1: foo,bar,10,z // could have switched with #2 2: foo,bar,10,x // could have switched with #1 3: foo,blah,11,z 4: far,bar,7,a 5: far,blah,5,x // identical to #6 6: far,blah,5,x // identical to #5 All interleaved filters are executed atomically.
repeated .google.bigtable.v2.RowFilter filters = 1;public RowFilter.Interleave.Builder removeFilters(int index)
The elements of "filters" all process a copy of the input row, and the results are pooled, sorted, and combined into a single output row. If multiple cells are produced with the same column and timestamp, they will all appear in the output row in an unspecified mutual order. Consider the following example, with three filters: input row | ----------------------------------------------------- | | | f(0) f(1) f(2) | | | 1: foo,bar,10,x foo,bar,10,z far,bar,7,a 2: foo,blah,11,z far,blah,5,x far,blah,5,x | | | ----------------------------------------------------- | 1: foo,bar,10,z // could have switched with #2 2: foo,bar,10,x // could have switched with #1 3: foo,blah,11,z 4: far,bar,7,a 5: far,blah,5,x // identical to #6 6: far,blah,5,x // identical to #5 All interleaved filters are executed atomically.
repeated .google.bigtable.v2.RowFilter filters = 1;public RowFilter.Builder getFiltersBuilder(int index)
The elements of "filters" all process a copy of the input row, and the results are pooled, sorted, and combined into a single output row. If multiple cells are produced with the same column and timestamp, they will all appear in the output row in an unspecified mutual order. Consider the following example, with three filters: input row | ----------------------------------------------------- | | | f(0) f(1) f(2) | | | 1: foo,bar,10,x foo,bar,10,z far,bar,7,a 2: foo,blah,11,z far,blah,5,x far,blah,5,x | | | ----------------------------------------------------- | 1: foo,bar,10,z // could have switched with #2 2: foo,bar,10,x // could have switched with #1 3: foo,blah,11,z 4: far,bar,7,a 5: far,blah,5,x // identical to #6 6: far,blah,5,x // identical to #5 All interleaved filters are executed atomically.
repeated .google.bigtable.v2.RowFilter filters = 1;public RowFilterOrBuilder getFiltersOrBuilder(int index)
The elements of "filters" all process a copy of the input row, and the results are pooled, sorted, and combined into a single output row. If multiple cells are produced with the same column and timestamp, they will all appear in the output row in an unspecified mutual order. Consider the following example, with three filters: input row | ----------------------------------------------------- | | | f(0) f(1) f(2) | | | 1: foo,bar,10,x foo,bar,10,z far,bar,7,a 2: foo,blah,11,z far,blah,5,x far,blah,5,x | | | ----------------------------------------------------- | 1: foo,bar,10,z // could have switched with #2 2: foo,bar,10,x // could have switched with #1 3: foo,blah,11,z 4: far,bar,7,a 5: far,blah,5,x // identical to #6 6: far,blah,5,x // identical to #5 All interleaved filters are executed atomically.
repeated .google.bigtable.v2.RowFilter filters = 1;getFiltersOrBuilder in interface RowFilter.InterleaveOrBuilderpublic List<? extends RowFilterOrBuilder> getFiltersOrBuilderList()
The elements of "filters" all process a copy of the input row, and the results are pooled, sorted, and combined into a single output row. If multiple cells are produced with the same column and timestamp, they will all appear in the output row in an unspecified mutual order. Consider the following example, with three filters: input row | ----------------------------------------------------- | | | f(0) f(1) f(2) | | | 1: foo,bar,10,x foo,bar,10,z far,bar,7,a 2: foo,blah,11,z far,blah,5,x far,blah,5,x | | | ----------------------------------------------------- | 1: foo,bar,10,z // could have switched with #2 2: foo,bar,10,x // could have switched with #1 3: foo,blah,11,z 4: far,bar,7,a 5: far,blah,5,x // identical to #6 6: far,blah,5,x // identical to #5 All interleaved filters are executed atomically.
repeated .google.bigtable.v2.RowFilter filters = 1;getFiltersOrBuilderList in interface RowFilter.InterleaveOrBuilderpublic RowFilter.Builder addFiltersBuilder()
The elements of "filters" all process a copy of the input row, and the results are pooled, sorted, and combined into a single output row. If multiple cells are produced with the same column and timestamp, they will all appear in the output row in an unspecified mutual order. Consider the following example, with three filters: input row | ----------------------------------------------------- | | | f(0) f(1) f(2) | | | 1: foo,bar,10,x foo,bar,10,z far,bar,7,a 2: foo,blah,11,z far,blah,5,x far,blah,5,x | | | ----------------------------------------------------- | 1: foo,bar,10,z // could have switched with #2 2: foo,bar,10,x // could have switched with #1 3: foo,blah,11,z 4: far,bar,7,a 5: far,blah,5,x // identical to #6 6: far,blah,5,x // identical to #5 All interleaved filters are executed atomically.
repeated .google.bigtable.v2.RowFilter filters = 1;public RowFilter.Builder addFiltersBuilder(int index)
The elements of "filters" all process a copy of the input row, and the results are pooled, sorted, and combined into a single output row. If multiple cells are produced with the same column and timestamp, they will all appear in the output row in an unspecified mutual order. Consider the following example, with three filters: input row | ----------------------------------------------------- | | | f(0) f(1) f(2) | | | 1: foo,bar,10,x foo,bar,10,z far,bar,7,a 2: foo,blah,11,z far,blah,5,x far,blah,5,x | | | ----------------------------------------------------- | 1: foo,bar,10,z // could have switched with #2 2: foo,bar,10,x // could have switched with #1 3: foo,blah,11,z 4: far,bar,7,a 5: far,blah,5,x // identical to #6 6: far,blah,5,x // identical to #5 All interleaved filters are executed atomically.
repeated .google.bigtable.v2.RowFilter filters = 1;public List<RowFilter.Builder> getFiltersBuilderList()
The elements of "filters" all process a copy of the input row, and the results are pooled, sorted, and combined into a single output row. If multiple cells are produced with the same column and timestamp, they will all appear in the output row in an unspecified mutual order. Consider the following example, with three filters: input row | ----------------------------------------------------- | | | f(0) f(1) f(2) | | | 1: foo,bar,10,x foo,bar,10,z far,bar,7,a 2: foo,blah,11,z far,blah,5,x far,blah,5,x | | | ----------------------------------------------------- | 1: foo,bar,10,z // could have switched with #2 2: foo,bar,10,x // could have switched with #1 3: foo,blah,11,z 4: far,bar,7,a 5: far,blah,5,x // identical to #6 6: far,blah,5,x // identical to #5 All interleaved filters are executed atomically.
repeated .google.bigtable.v2.RowFilter filters = 1;Copyright © 2026 Google LLC. All rights reserved.