public static final class RowFilter.Interleave.Builder extends GeneratedMessageV3.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
Methods
addAllFilters(Iterable<? extends RowFilter> values)
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;
| Name | Description |
| values | Iterable<? extends com.google.bigtable.v2.RowFilter>
|
Returns
addFilters(RowFilter value)
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;
addFilters(RowFilter.Builder builderForValue)
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;
addFilters(int index, RowFilter value)
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;
addFilters(int index, RowFilter.Builder builderForValue)
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;
addFiltersBuilder()
public 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;
addFiltersBuilder(int index)
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;
addRepeatedField(Descriptors.FieldDescriptor field, Object value)
public RowFilter.Interleave.Builder addRepeatedField(Descriptors.FieldDescriptor field, Object value)
Parameters
Returns
Overrides
build()
public RowFilter.Interleave build()
Returns
buildPartial()
public RowFilter.Interleave buildPartial()
Returns
clear()
public RowFilter.Interleave.Builder clear()
Returns
Overrides
clearField(Descriptors.FieldDescriptor field)
public RowFilter.Interleave.Builder clearField(Descriptors.FieldDescriptor field)
Parameter
Returns
Overrides
clearFilters()
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;
clearOneof(Descriptors.OneofDescriptor oneof)
public RowFilter.Interleave.Builder clearOneof(Descriptors.OneofDescriptor oneof)
Parameter
Returns
Overrides
clone()
public RowFilter.Interleave.Builder clone()
Returns
Overrides
getDefaultInstanceForType()
public RowFilter.Interleave getDefaultInstanceForType()
Returns
getDescriptor()
public static final Descriptors.Descriptor getDescriptor()
Returns
getDescriptorForType()
public Descriptors.Descriptor getDescriptorForType()
Returns
Overrides
getFilters(int index)
public 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;
getFiltersBuilder(int index)
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;
getFiltersBuilderList()
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;
getFiltersCount()
public 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;
getFiltersList()
public 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;
getFiltersOrBuilder(int index)
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;
getFiltersOrBuilderList()
public 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;
| Type | Description |
| List<? extends com.google.bigtable.v2.RowFilterOrBuilder> | |
internalGetFieldAccessorTable()
protected GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable()
Returns
Overrides
isInitialized()
public final boolean isInitialized()
Returns
Overrides
mergeFrom(RowFilter.Interleave other)
public RowFilter.Interleave.Builder mergeFrom(RowFilter.Interleave other)
Parameter
Returns
public RowFilter.Interleave.Builder mergeFrom(CodedInputStream input, ExtensionRegistryLite extensionRegistry)
Parameters
Returns
Overrides
Exceptions
mergeFrom(Message other)
public RowFilter.Interleave.Builder mergeFrom(Message other)
Parameter
Returns
Overrides
mergeUnknownFields(UnknownFieldSet unknownFields)
public final RowFilter.Interleave.Builder mergeUnknownFields(UnknownFieldSet unknownFields)
Parameter
Returns
Overrides
removeFilters(int index)
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;
setField(Descriptors.FieldDescriptor field, Object value)
public RowFilter.Interleave.Builder setField(Descriptors.FieldDescriptor field, Object value)
Parameters
Returns
Overrides
setFilters(int index, RowFilter value)
public 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;
setFilters(int index, RowFilter.Builder builderForValue)
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;
setRepeatedField(Descriptors.FieldDescriptor field, int index, Object value)
public RowFilter.Interleave.Builder setRepeatedField(Descriptors.FieldDescriptor field, int index, Object value)
Parameters
Returns
Overrides
setUnknownFields(UnknownFieldSet unknownFields)
public final RowFilter.Interleave.Builder setUnknownFields(UnknownFieldSet unknownFields)
Parameter
Returns
Overrides
