CheckAndMutateRowRequest.Builder (Cloud Bigtable HBase Client for Java 0.9.7.1 API)

com.google.bigtable.v2

Class CheckAndMutateRowRequest.Builder

    • Method Detail

      • getTableName

        public String getTableName()
         The unique name of the table to which the conditional mutation should be
         applied.
         Values are of the form
         projects/<project>/instances/<instance>/tables/<table>
         
        string table_name = 1;
        Specified by:
        getTableName in interface CheckAndMutateRowRequestOrBuilder
      • getTableNameBytes

        public ByteString getTableNameBytes()
         The unique name of the table to which the conditional mutation should be
         applied.
         Values are of the form
         projects/<project>/instances/<instance>/tables/<table>
         
        string table_name = 1;
        Specified by:
        getTableNameBytes in interface CheckAndMutateRowRequestOrBuilder
      • setTableName

        public CheckAndMutateRowRequest.Builder setTableName(String value)
         The unique name of the table to which the conditional mutation should be
         applied.
         Values are of the form
         projects/<project>/instances/<instance>/tables/<table>
         
        string table_name = 1;
      • clearTableName

        public CheckAndMutateRowRequest.Builder clearTableName()
         The unique name of the table to which the conditional mutation should be
         applied.
         Values are of the form
         projects/<project>/instances/<instance>/tables/<table>
         
        string table_name = 1;
      • setTableNameBytes

        public CheckAndMutateRowRequest.Builder setTableNameBytes(ByteString value)
         The unique name of the table to which the conditional mutation should be
         applied.
         Values are of the form
         projects/<project>/instances/<instance>/tables/<table>
         
        string table_name = 1;
      • clearRowKey

        public CheckAndMutateRowRequest.Builder clearRowKey()
         The key of the row to which the conditional mutation should be applied.
         
        bytes row_key = 2;
      • hasPredicateFilter

        public boolean hasPredicateFilter()
         The filter to be applied to the contents of the specified row. Depending
         on whether or not any results are yielded, either `true_mutations` or
         `false_mutations` will be executed. If unset, checks that the row contains
         any values at all.
         
        .google.bigtable.v2.RowFilter predicate_filter = 6;
        Specified by:
        hasPredicateFilter in interface CheckAndMutateRowRequestOrBuilder
      • getPredicateFilter

        public RowFilter getPredicateFilter()
         The filter to be applied to the contents of the specified row. Depending
         on whether or not any results are yielded, either `true_mutations` or
         `false_mutations` will be executed. If unset, checks that the row contains
         any values at all.
         
        .google.bigtable.v2.RowFilter predicate_filter = 6;
        Specified by:
        getPredicateFilter in interface CheckAndMutateRowRequestOrBuilder
      • setPredicateFilter

        public CheckAndMutateRowRequest.Builder setPredicateFilter(RowFilter value)
         The filter to be applied to the contents of the specified row. Depending
         on whether or not any results are yielded, either `true_mutations` or
         `false_mutations` will be executed. If unset, checks that the row contains
         any values at all.
         
        .google.bigtable.v2.RowFilter predicate_filter = 6;
      • setPredicateFilter

        public CheckAndMutateRowRequest.Builder setPredicateFilter(RowFilter.Builder builderForValue)
         The filter to be applied to the contents of the specified row. Depending
         on whether or not any results are yielded, either `true_mutations` or
         `false_mutations` will be executed. If unset, checks that the row contains
         any values at all.
         
        .google.bigtable.v2.RowFilter predicate_filter = 6;
      • mergePredicateFilter

        public CheckAndMutateRowRequest.Builder mergePredicateFilter(RowFilter value)
         The filter to be applied to the contents of the specified row. Depending
         on whether or not any results are yielded, either `true_mutations` or
         `false_mutations` will be executed. If unset, checks that the row contains
         any values at all.
         
        .google.bigtable.v2.RowFilter predicate_filter = 6;
      • clearPredicateFilter

        public CheckAndMutateRowRequest.Builder clearPredicateFilter()
         The filter to be applied to the contents of the specified row. Depending
         on whether or not any results are yielded, either `true_mutations` or
         `false_mutations` will be executed. If unset, checks that the row contains
         any values at all.
         
        .google.bigtable.v2.RowFilter predicate_filter = 6;
      • getPredicateFilterBuilder

        public RowFilter.Builder getPredicateFilterBuilder()
         The filter to be applied to the contents of the specified row. Depending
         on whether or not any results are yielded, either `true_mutations` or
         `false_mutations` will be executed. If unset, checks that the row contains
         any values at all.
         
        .google.bigtable.v2.RowFilter predicate_filter = 6;
      • getPredicateFilterOrBuilder

        public RowFilterOrBuilder getPredicateFilterOrBuilder()
         The filter to be applied to the contents of the specified row. Depending
         on whether or not any results are yielded, either `true_mutations` or
         `false_mutations` will be executed. If unset, checks that the row contains
         any values at all.
         
        .google.bigtable.v2.RowFilter predicate_filter = 6;
        Specified by:
        getPredicateFilterOrBuilder in interface CheckAndMutateRowRequestOrBuilder
      • getTrueMutationsList

        public List<Mutation> getTrueMutationsList()
         Changes to be atomically applied to the specified row if `predicate_filter`
         yields at least one cell when applied to `row_key`. Entries are applied in
         order, meaning that earlier mutations can be masked by later ones.
         Must contain at least one entry if `false_mutations` is empty, and at most
         100000.
         
        repeated .google.bigtable.v2.Mutation true_mutations = 4;
        Specified by:
        getTrueMutationsList in interface CheckAndMutateRowRequestOrBuilder
      • getTrueMutationsCount

        public int getTrueMutationsCount()
         Changes to be atomically applied to the specified row if `predicate_filter`
         yields at least one cell when applied to `row_key`. Entries are applied in
         order, meaning that earlier mutations can be masked by later ones.
         Must contain at least one entry if `false_mutations` is empty, and at most
         100000.
         
        repeated .google.bigtable.v2.Mutation true_mutations = 4;
        Specified by:
        getTrueMutationsCount in interface CheckAndMutateRowRequestOrBuilder
      • getTrueMutations

        public Mutation getTrueMutations(int index)
         Changes to be atomically applied to the specified row if `predicate_filter`
         yields at least one cell when applied to `row_key`. Entries are applied in
         order, meaning that earlier mutations can be masked by later ones.
         Must contain at least one entry if `false_mutations` is empty, and at most
         100000.
         
        repeated .google.bigtable.v2.Mutation true_mutations = 4;
        Specified by:
        getTrueMutations in interface CheckAndMutateRowRequestOrBuilder
      • setTrueMutations

        public CheckAndMutateRowRequest.Builder setTrueMutations(int index,
                                                                 Mutation value)
         Changes to be atomically applied to the specified row if `predicate_filter`
         yields at least one cell when applied to `row_key`. Entries are applied in
         order, meaning that earlier mutations can be masked by later ones.
         Must contain at least one entry if `false_mutations` is empty, and at most
         100000.
         
        repeated .google.bigtable.v2.Mutation true_mutations = 4;
      • setTrueMutations

        public CheckAndMutateRowRequest.Builder setTrueMutations(int index,
                                                                 Mutation.Builder builderForValue)
         Changes to be atomically applied to the specified row if `predicate_filter`
         yields at least one cell when applied to `row_key`. Entries are applied in
         order, meaning that earlier mutations can be masked by later ones.
         Must contain at least one entry if `false_mutations` is empty, and at most
         100000.
         
        repeated .google.bigtable.v2.Mutation true_mutations = 4;
      • addTrueMutations

        public CheckAndMutateRowRequest.Builder addTrueMutations(Mutation value)
         Changes to be atomically applied to the specified row if `predicate_filter`
         yields at least one cell when applied to `row_key`. Entries are applied in
         order, meaning that earlier mutations can be masked by later ones.
         Must contain at least one entry if `false_mutations` is empty, and at most
         100000.
         
        repeated .google.bigtable.v2.Mutation true_mutations = 4;
      • addTrueMutations

        public CheckAndMutateRowRequest.Builder addTrueMutations(int index,
                                                                 Mutation value)
         Changes to be atomically applied to the specified row if `predicate_filter`
         yields at least one cell when applied to `row_key`. Entries are applied in
         order, meaning that earlier mutations can be masked by later ones.
         Must contain at least one entry if `false_mutations` is empty, and at most
         100000.
         
        repeated .google.bigtable.v2.Mutation true_mutations = 4;
      • addTrueMutations

        public CheckAndMutateRowRequest.Builder addTrueMutations(Mutation.Builder builderForValue)
         Changes to be atomically applied to the specified row if `predicate_filter`
         yields at least one cell when applied to `row_key`. Entries are applied in
         order, meaning that earlier mutations can be masked by later ones.
         Must contain at least one entry if `false_mutations` is empty, and at most
         100000.
         
        repeated .google.bigtable.v2.Mutation true_mutations = 4;
      • addTrueMutations

        public CheckAndMutateRowRequest.Builder addTrueMutations(int index,
                                                                 Mutation.Builder builderForValue)
         Changes to be atomically applied to the specified row if `predicate_filter`
         yields at least one cell when applied to `row_key`. Entries are applied in
         order, meaning that earlier mutations can be masked by later ones.
         Must contain at least one entry if `false_mutations` is empty, and at most
         100000.
         
        repeated .google.bigtable.v2.Mutation true_mutations = 4;
      • addAllTrueMutations

        public CheckAndMutateRowRequest.Builder addAllTrueMutations(Iterable<? extends Mutation> values)
         Changes to be atomically applied to the specified row if `predicate_filter`
         yields at least one cell when applied to `row_key`. Entries are applied in
         order, meaning that earlier mutations can be masked by later ones.
         Must contain at least one entry if `false_mutations` is empty, and at most
         100000.
         
        repeated .google.bigtable.v2.Mutation true_mutations = 4;
      • clearTrueMutations

        public CheckAndMutateRowRequest.Builder clearTrueMutations()
         Changes to be atomically applied to the specified row if `predicate_filter`
         yields at least one cell when applied to `row_key`. Entries are applied in
         order, meaning that earlier mutations can be masked by later ones.
         Must contain at least one entry if `false_mutations` is empty, and at most
         100000.
         
        repeated .google.bigtable.v2.Mutation true_mutations = 4;
      • removeTrueMutations

        public CheckAndMutateRowRequest.Builder removeTrueMutations(int index)
         Changes to be atomically applied to the specified row if `predicate_filter`
         yields at least one cell when applied to `row_key`. Entries are applied in
         order, meaning that earlier mutations can be masked by later ones.
         Must contain at least one entry if `false_mutations` is empty, and at most
         100000.
         
        repeated .google.bigtable.v2.Mutation true_mutations = 4;
      • getTrueMutationsBuilder

        public Mutation.Builder getTrueMutationsBuilder(int index)
         Changes to be atomically applied to the specified row if `predicate_filter`
         yields at least one cell when applied to `row_key`. Entries are applied in
         order, meaning that earlier mutations can be masked by later ones.
         Must contain at least one entry if `false_mutations` is empty, and at most
         100000.
         
        repeated .google.bigtable.v2.Mutation true_mutations = 4;
      • getTrueMutationsOrBuilder

        public MutationOrBuilder getTrueMutationsOrBuilder(int index)
         Changes to be atomically applied to the specified row if `predicate_filter`
         yields at least one cell when applied to `row_key`. Entries are applied in
         order, meaning that earlier mutations can be masked by later ones.
         Must contain at least one entry if `false_mutations` is empty, and at most
         100000.
         
        repeated .google.bigtable.v2.Mutation true_mutations = 4;
        Specified by:
        getTrueMutationsOrBuilder in interface CheckAndMutateRowRequestOrBuilder
      • getTrueMutationsOrBuilderList

        public List<? extends MutationOrBuilder> getTrueMutationsOrBuilderList()
         Changes to be atomically applied to the specified row if `predicate_filter`
         yields at least one cell when applied to `row_key`. Entries are applied in
         order, meaning that earlier mutations can be masked by later ones.
         Must contain at least one entry if `false_mutations` is empty, and at most
         100000.
         
        repeated .google.bigtable.v2.Mutation true_mutations = 4;
        Specified by:
        getTrueMutationsOrBuilderList in interface CheckAndMutateRowRequestOrBuilder
      • addTrueMutationsBuilder

        public Mutation.Builder addTrueMutationsBuilder()
         Changes to be atomically applied to the specified row if `predicate_filter`
         yields at least one cell when applied to `row_key`. Entries are applied in
         order, meaning that earlier mutations can be masked by later ones.
         Must contain at least one entry if `false_mutations` is empty, and at most
         100000.
         
        repeated .google.bigtable.v2.Mutation true_mutations = 4;
      • addTrueMutationsBuilder

        public Mutation.Builder addTrueMutationsBuilder(int index)
         Changes to be atomically applied to the specified row if `predicate_filter`
         yields at least one cell when applied to `row_key`. Entries are applied in
         order, meaning that earlier mutations can be masked by later ones.
         Must contain at least one entry if `false_mutations` is empty, and at most
         100000.
         
        repeated .google.bigtable.v2.Mutation true_mutations = 4;
      • getTrueMutationsBuilderList

        public List<Mutation.Builder> getTrueMutationsBuilderList()
         Changes to be atomically applied to the specified row if `predicate_filter`
         yields at least one cell when applied to `row_key`. Entries are applied in
         order, meaning that earlier mutations can be masked by later ones.
         Must contain at least one entry if `false_mutations` is empty, and at most
         100000.
         
        repeated .google.bigtable.v2.Mutation true_mutations = 4;
      • getFalseMutationsList

        public List<Mutation> getFalseMutationsList()
         Changes to be atomically applied to the specified row if `predicate_filter`
         does not yield any cells when applied to `row_key`. Entries are applied in
         order, meaning that earlier mutations can be masked by later ones.
         Must contain at least one entry if `true_mutations` is empty, and at most
         100000.
         
        repeated .google.bigtable.v2.Mutation false_mutations = 5;
        Specified by:
        getFalseMutationsList in interface CheckAndMutateRowRequestOrBuilder
      • getFalseMutationsCount

        public int getFalseMutationsCount()
         Changes to be atomically applied to the specified row if `predicate_filter`
         does not yield any cells when applied to `row_key`. Entries are applied in
         order, meaning that earlier mutations can be masked by later ones.
         Must contain at least one entry if `true_mutations` is empty, and at most
         100000.
         
        repeated .google.bigtable.v2.Mutation false_mutations = 5;
        Specified by:
        getFalseMutationsCount in interface CheckAndMutateRowRequestOrBuilder
      • getFalseMutations

        public Mutation getFalseMutations(int index)
         Changes to be atomically applied to the specified row if `predicate_filter`
         does not yield any cells when applied to `row_key`. Entries are applied in
         order, meaning that earlier mutations can be masked by later ones.
         Must contain at least one entry if `true_mutations` is empty, and at most
         100000.
         
        repeated .google.bigtable.v2.Mutation false_mutations = 5;
        Specified by:
        getFalseMutations in interface CheckAndMutateRowRequestOrBuilder
      • setFalseMutations

        public CheckAndMutateRowRequest.Builder setFalseMutations(int index,
                                                                  Mutation value)
         Changes to be atomically applied to the specified row if `predicate_filter`
         does not yield any cells when applied to `row_key`. Entries are applied in
         order, meaning that earlier mutations can be masked by later ones.
         Must contain at least one entry if `true_mutations` is empty, and at most
         100000.
         
        repeated .google.bigtable.v2.Mutation false_mutations = 5;
      • setFalseMutations

        public CheckAndMutateRowRequest.Builder setFalseMutations(int index,
                                                                  Mutation.Builder builderForValue)
         Changes to be atomically applied to the specified row if `predicate_filter`
         does not yield any cells when applied to `row_key`. Entries are applied in
         order, meaning that earlier mutations can be masked by later ones.
         Must contain at least one entry if `true_mutations` is empty, and at most
         100000.
         
        repeated .google.bigtable.v2.Mutation false_mutations = 5;
      • addFalseMutations

        public CheckAndMutateRowRequest.Builder addFalseMutations(Mutation value)
         Changes to be atomically applied to the specified row if `predicate_filter`
         does not yield any cells when applied to `row_key`. Entries are applied in
         order, meaning that earlier mutations can be masked by later ones.
         Must contain at least one entry if `true_mutations` is empty, and at most
         100000.
         
        repeated .google.bigtable.v2.Mutation false_mutations = 5;
      • addFalseMutations

        public CheckAndMutateRowRequest.Builder addFalseMutations(int index,
                                                                  Mutation value)
         Changes to be atomically applied to the specified row if `predicate_filter`
         does not yield any cells when applied to `row_key`. Entries are applied in
         order, meaning that earlier mutations can be masked by later ones.
         Must contain at least one entry if `true_mutations` is empty, and at most
         100000.
         
        repeated .google.bigtable.v2.Mutation false_mutations = 5;
      • addFalseMutations

        public CheckAndMutateRowRequest.Builder addFalseMutations(Mutation.Builder builderForValue)
         Changes to be atomically applied to the specified row if `predicate_filter`
         does not yield any cells when applied to `row_key`. Entries are applied in
         order, meaning that earlier mutations can be masked by later ones.
         Must contain at least one entry if `true_mutations` is empty, and at most
         100000.
         
        repeated .google.bigtable.v2.Mutation false_mutations = 5;
      • addFalseMutations

        public CheckAndMutateRowRequest.Builder addFalseMutations(int index,
                                                                  Mutation.Builder builderForValue)
         Changes to be atomically applied to the specified row if `predicate_filter`
         does not yield any cells when applied to `row_key`. Entries are applied in
         order, meaning that earlier mutations can be masked by later ones.
         Must contain at least one entry if `true_mutations` is empty, and at most
         100000.
         
        repeated .google.bigtable.v2.Mutation false_mutations = 5;
      • addAllFalseMutations

        public CheckAndMutateRowRequest.Builder addAllFalseMutations(Iterable<? extends Mutation> values)
         Changes to be atomically applied to the specified row if `predicate_filter`
         does not yield any cells when applied to `row_key`. Entries are applied in
         order, meaning that earlier mutations can be masked by later ones.
         Must contain at least one entry if `true_mutations` is empty, and at most
         100000.
         
        repeated .google.bigtable.v2.Mutation false_mutations = 5;
      • clearFalseMutations

        public