Uses of Class
org.apache.hadoop.hbase.client.Mutation

Packages that use Mutation

Package	Description
org.apache.hadoop.hbase
org.apache.hadoop.hbase.client	Provides HBase Client
org.apache.hadoop.hbase.coprocessor	Table of Contents
org.apache.hadoop.hbase.mapreduce	Provides HBase MapReduce Input/OutputFormats, a table indexing MapReduce job, and utility methods.
org.apache.hadoop.hbase.master
org.apache.hadoop.hbase.quotas
org.apache.hadoop.hbase.quotas.policies
org.apache.hadoop.hbase.regionserver
org.apache.hadoop.hbase.rsgroup
org.apache.hadoop.hbase.security.access
org.apache.hadoop.hbase.security.visibility
org.apache.hadoop.hbase.tool
org.apache.hadoop.hbase.wal

Uses of Mutation in org.apache.hadoop.hbase

Methods in org.apache.hadoop.hbase with parameters of type Mutation

Modifier and Type	Method and Description
private static void	MetaTableAccessor.debugLogMutation(Mutation p)
private static void	MetaTableAccessor.multiMutate(Table table, byte[] row, Mutation... mutations)

Method parameters in org.apache.hadoop.hbase with type arguments of type Mutation

Modifier and Type	Method and Description
private static void	MetaTableAccessor.debugLogMutations(List<? extends Mutation> mutations)
private static void	MetaTableAccessor.multiMutate(Table table, byte[] row, List<Mutation> mutations) Performs an atomic multi-mutate operation against the given table.

Uses of Mutation in org.apache.hadoop.hbase.client

Subclasses of Mutation in org.apache.hadoop.hbase.client

Modifier and Type	Class and Description
class	Append Performs Append operations on a single row.
class	Delete Used to perform Delete operations on a single row.
class	Increment Used to perform Increment operations on a single row.
class	Put Used to perform Put operations for a single row.

Fields in org.apache.hadoop.hbase.client declared as Mutation

Modifier and Type	Field and Description
private Mutation	BufferedMutatorImpl.QueueRowAccess.last

Fields in org.apache.hadoop.hbase.client with type parameters of type Mutation

Modifier and Type	Field and Description
private List<Mutation>	AsyncBufferedMutatorImpl.mutations
private List<Mutation>	RowMutations.mutations
private ConcurrentLinkedQueue<Mutation>	BufferedMutatorImpl.writeAsyncBuffer

Methods in org.apache.hadoop.hbase.client that return Mutation

Modifier and Type	Method and Description
(package private) Mutation	Mutation.add(Cell cell)
Mutation	Mutation.setACL(Map<String,Permission> perms)
Mutation	Mutation.setACL(String user, Permission perms)
Mutation	Mutation.setCellVisibility(CellVisibility expression) Sets the visibility expression associated with cells in this Mutation.
Mutation	Mutation.setClusterIds(List<UUID> clusterIds) Marks that the clusters with the given clusterIds have consumed the mutation
Mutation	Mutation.setDurability(Durability d) Set the durability for this mutation
Mutation	Mutation.setFamilyCellMap(NavigableMap<byte[],List<Cell>> map) Deprecated. As of release 2.0.0, this will be removed in HBase 3.0.0. Use Mutation(byte[], long, NavigableMap) instead
protected Mutation	Mutation.setReturnResults(boolean returnResults)
Mutation	Mutation.setTimestamp(long timestamp) Set the timestamp of the delete.
Mutation	Mutation.setTTL(long ttl) Set the TTL desired for the result of the mutation, in milliseconds.

Methods in org.apache.hadoop.hbase.client that return types with arguments of type Mutation

Modifier and Type	Method and Description
List<Mutation>	RowMutations.getMutations()

Methods in org.apache.hadoop.hbase.client with parameters of type Mutation

Modifier and Type	Method and Description
RowMutations	RowMutations.add(Mutation mutation) Currently only supports Put and Delete mutations.
(package private) static void	ConnectionUtils.checkHasFamilies(Mutation mutation)
void	BufferedMutator.mutate(Mutation mutation) Sends a Mutation to the table.
void	BufferedMutatorImpl.mutate(Mutation m)
default CompletableFuture<Void>	AsyncBufferedMutator.mutate(Mutation mutation) Sends a Mutation to the table.

Method parameters in org.apache.hadoop.hbase.client with type arguments of type Mutation

Modifier and Type	Method and Description
RowMutations	RowMutations.add(List<? extends Mutation> mutations) Currently only supports Put and Delete mutations.
void	BufferedMutator.mutate(List<? extends Mutation> mutations) Send some Mutations to the table.
List<CompletableFuture<Void>>	AsyncBufferedMutatorImpl.mutate(List<? extends Mutation> mutations)
void	BufferedMutatorImpl.mutate(List<? extends Mutation> ms)
List<CompletableFuture<Void>>	AsyncBufferedMutator.mutate(List<? extends Mutation> mutations) Send some Mutations to the table.
static RowMutations	RowMutations.of(List<? extends Mutation> mutations) Create a RowMutations with the specified mutations.

Constructors in org.apache.hadoop.hbase.client with parameters of type Mutation

Constructor and Description
Mutation(Mutation clone)

Uses of Mutation in org.apache.hadoop.hbase.coprocessor

Methods in org.apache.hadoop.hbase.coprocessor with parameters of type Mutation

Modifier and Type	Method and Description
default List<Pair<Cell,Cell>>	RegionObserver.postAppendBeforeWAL(ObserverContext<RegionCoprocessorEnvironment> ctx, Mutation mutation, List<Pair<Cell,Cell>> cellPairs) Called after a list of new cells has been created during an append operation, but before they are committed to the WAL or memstore.
default List<Pair<Cell,Cell>>	RegionObserver.postIncrementBeforeWAL(ObserverContext<RegionCoprocessorEnvironment> ctx, Mutation mutation, List<Pair<Cell,Cell>> cellPairs) Called after a list of new cells has been created during an increment operation, but before they are committed to the WAL or memstore.
default Cell	RegionObserver.postMutationBeforeWAL(ObserverContext<RegionCoprocessorEnvironment> ctx, RegionObserver.MutationType opType, Mutation mutation, Cell oldCell, Cell newCell) Deprecated. since 2.2.0 and will be removedin 4.0.0. Use RegionObserver.postIncrementBeforeWAL(ObserverContext, Mutation, List) or RegionObserver.postAppendBeforeWAL(ObserverContext, Mutation, List) instead.
default void	RegionObserver.prePrepareTimeStampForDeleteVersion(ObserverContext<RegionCoprocessorEnvironment> c, Mutation mutation, Cell cell, byte[] byteNow, Get get) Deprecated. Since hbase-2.0.0. No replacement. To be removed in hbase-3.0.0 and replaced with something that doesn't expose IntefaceAudience.Private classes.

Method parameters in org.apache.hadoop.hbase.coprocessor with type arguments of type Mutation

Modifier and Type	Method and Description
default void	RegionObserver.postBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c, MiniBatchOperationInProgress<Mutation> miniBatchOp) This will be called after applying a batch of Mutations on a region.
default void	RegionObserver.postBatchMutateIndispensably(ObserverContext<RegionCoprocessorEnvironment> ctx, MiniBatchOperationInProgress<Mutation> miniBatchOp, boolean success) Called after the completion of batch put/delete and will be called even if the batch operation fails.
default void	RegionObserver.preBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c, MiniBatchOperationInProgress<Mutation> miniBatchOp) This will be called for every batch mutation operation happening at the server.
default void	MasterObserver.preMergeRegionsCommitAction(ObserverContext<MasterCoprocessorEnvironment> ctx, RegionInfo[] regionsToMerge, List<Mutation> metaEntries) This will be called before update META step as part of regions merge transaction.
default void	MasterObserver.preSplitRegionBeforeMETAAction(ObserverContext<MasterCoprocessorEnvironment> ctx, byte[] splitKey, List<Mutation> metaEntries) This will be called before update META step as part of split transaction.

Uses of Mutation in org.apache.hadoop.hbase.mapreduce

Methods in org.apache.hadoop.hbase.mapreduce that return Mutation

Modifier and Type	Method and Description
Mutation	MutationSerialization.MutationDeserializer.deserialize(Mutation mutation)

Methods in org.apache.hadoop.hbase.mapreduce that return types with arguments of type Mutation

Modifier and Type	Method and Description
org.apache.hadoop.io.serializer.Deserializer<Mutation>	MutationSerialization.getDeserializer(Class<Mutation> c)
org.apache.hadoop.mapreduce.RecordWriter<KEY,Mutation>	TableOutputFormat.getRecordWriter(org.apache.hadoop.mapreduce.TaskAttemptContext context) Creates a new record writer.
org.apache.hadoop.mapreduce.RecordWriter<ImmutableBytesWritable,Mutation>	MultiTableOutputFormat.getRecordWriter(org.apache.hadoop.mapreduce.TaskAttemptContext context)
org.apache.hadoop.io.serializer.Serializer<Mutation>	MutationSerialization.getSerializer(Class<Mutation> c)

Methods in org.apache.hadoop.hbase.mapreduce with parameters of type Mutation

Modifier and Type	Method and Description
Mutation	MutationSerialization.MutationDeserializer.deserialize(Mutation mutation)
void	MutationSerialization.MutationSerializer.serialize(Mutation mutation)
void	MultiTableOutputFormat.MultiTableRecordWriter.write(ImmutableBytesWritable tableName, Mutation action) Writes an action (Put or Delete) to the specified table.
void	TableOutputFormat.TableRecordWriter.write(KEY key, Mutation value) Writes a key/value pair into the table.

Method parameters in org.apache.hadoop.hbase.mapreduce with type arguments of type Mutation

Modifier and Type	Method and Description
org.apache.hadoop.io.serializer.Deserializer<Mutation>	MutationSerialization.getDeserializer(Class<Mutation> c)
org.apache.hadoop.io.serializer.Serializer<Mutation>	MutationSerialization.getSerializer(Class<Mutation> c)
void	IdentityTableReducer.reduce(org.apache.hadoop.io.Writable key, Iterable<Mutation> values, org.apache.hadoop.mapreduce.Reducer.Context context) Writes each given record, consisting of the row key and the given values, to the configured OutputFormat.

Uses of Mutation in org.apache.hadoop.hbase.master

Method parameters in org.apache.hadoop.hbase.master with type arguments of type Mutation

Modifier and Type	Method and Description
void	MasterCoprocessorHost.preMergeRegionsCommit(RegionInfo[] regionsToMerge, List<Mutation> metaEntries, User user) Invoked before merge regions operation writes the new region to hbase:meta
void	MasterCoprocessorHost.preSplitBeforeMETAAction(byte[] splitKey, List<Mutation> metaEntries, User user) This will be called before update META step as part of split table region procedure.

Uses of Mutation in org.apache.hadoop.hbase.quotas

Methods in org.apache.hadoop.hbase.quotas with parameters of type Mutation

Modifier and Type	Method and Description
void	DefaultOperationQuota.addMutation(Mutation mutation)
void	NoopOperationQuota.addMutation(Mutation mutation)
void	OperationQuota.addMutation(Mutation mutation) Add a mutation result.
static long	QuotaUtil.calculateMutationSize(Mutation mutation)
void	SpaceViolationPolicyEnforcement.check(Mutation m) Checks the given Mutation against this policy.

Uses of Mutation in org.apache.hadoop.hbase.quotas.policies

Methods in org.apache.hadoop.hbase.quotas.policies with parameters of type Mutation

Modifier and Type	Method and Description
void	DefaultViolationPolicyEnforcement.check(Mutation m)
void	MissingSnapshotViolationPolicyEnforcement.check(Mutation m)
void	DisableTableViolationPolicyEnforcement.check(Mutation m)
void	NoInsertsViolationPolicyEnforcement.check(Mutation m)
void	NoWritesViolationPolicyEnforcement.check(Mutation m)

Uses of Mutation in org.apache.hadoop.hbase.regionserver

Fields in org.apache.hadoop.hbase.regionserver declared as Mutation

Modifier and Type	Field and Description
private Mutation[][]	MiniBatchOperationInProgress.operationsFromCoprocessors

Methods in org.apache.hadoop.hbase.regionserver that return Mutation

Modifier and Type	Method and Description
abstract Mutation	HRegion.BatchOperation.getMutation(int index)
Mutation	HRegion.MutationBatchOperation.getMutation(int index)
Mutation	HRegion.ReplayBatchOperation.getMutation(int index)
abstract Mutation[]	HRegion.BatchOperation.getMutationsForCoprocs() This method is potentially expensive and useful mostly for non-replay CP path.
Mutation[]	HRegion.MutationBatchOperation.getMutationsForCoprocs()
Mutation[]	HRegion.ReplayBatchOperation.getMutationsForCoprocs()
Mutation[]	MiniBatchOperationInProgress.getOperationsFromCoprocessors(int index)

Methods in org.apache.hadoop.hbase.regionserver that return types with arguments of type Mutation

Modifier and Type	Method and Description
protected MiniBatchOperationInProgress<Mutation>	HRegion.BatchOperation.createMiniBatch(int lastIndexExclusive, int readyToWriteCount)
MiniBatchOperationInProgress<Mutation>	HRegion.BatchOperation.lockRowsAndBuildMiniBatch(List<Region.RowLock> acquiredRowLocks) Creates Mini-batch of all operations [nextIndexToProcess, lastIndexExclusive) for which a row lock can be acquired.

Methods in org.apache.hadoop.hbase.regionserver with parameters of type Mutation

Modifier and Type	Method and Description
void	MiniBatchOperationInProgress.addOperationsFromCP(int index, Mutation[] newOperations) Add more Mutations corresponding to the Mutation at the given index to be committed atomically in the same batch.
OperationStatus[]	Region.batchMutate(Mutation[] mutations) Perform a batch of mutations.
OperationStatus[]	HRegion.batchMutate(Mutation[] mutations)
OperationStatus[]	HRegion.batchMutate(Mutation[] mutations, boolean atomic, long nonceGroup, long nonce)
OperationStatus[]	HRegion.batchMutate(Mutation[] mutations, long nonceGroup, long nonce)
default boolean	Region.checkAndMutate(byte[] row, byte[] family, byte[] qualifier, CompareOperator op, ByteArrayComparable comparator, Mutation mutation) Atomically checks if a row/family/qualifier value matches the expected value and if it does, it performs the mutation.
boolean	Region.checkAndMutate(byte[] row, byte[] family, byte[] qualifier, CompareOperator op, ByteArrayComparable comparator, TimeRange timeRange, Mutation mutation) Atomically checks if a row/family/qualifier value matches the expected value and if it does, it performs the mutation.
boolean	HRegion.checkAndMutate(byte[] row, byte[] family, byte[] qualifier, CompareOperator op, ByteArrayComparable comparator, TimeRange timeRange, Mutation mutation)
protected void	HRegion.BatchOperation.checkAndPrepareMutation(Mutation mutation, long timestamp) Helper method that checks and prepares only one mutation.
private void	RSRpcServices.checkCellSizeLimit(HRegion r, Mutation m)
private void	HRegion.checkMutationType(Mutation mutation, byte[] row)
private void	HRegion.doBatchMutate(Mutation mutation)
private boolean	HRegion.doCheckAndRowMutate(byte[] row, byte[] family, byte[] qualifier, CompareOperator op, ByteArrayComparable comparator, TimeRange timeRange, RowMutations rowMutations, Mutation mutation) checkAndMutate and checkAndRowMutate are 90% the same.
private Result	HRegion.doCoprocessorPreCall(Region.Operation op, Mutation mutation) Do coprocessor pre-increment or pre-append call.
private Result	HRegion.doDelta(Region.Operation op, Mutation mutation, long nonceGroup, long nonce, boolean returnResults) Add "deltas" to Cells.
private List<Cell>	HRegion.get(Mutation mutation, HStore store, List<Cell> coordinates, IsolationLevel isolation, TimeRange tr) Do a specific Get on passed columnFamily and column qualifiers.
List<Pair<Cell,Cell>>	RegionCoprocessorHost.postAppendBeforeWAL(Mutation mutation, List<Pair<Cell,Cell>> cellPairs)
List<Pair<Cell,Cell>>	RegionCoprocessorHost.postIncrementBeforeWAL(Mutation mutation, List<Pair<Cell,Cell>> cellPairs)
void	HRegion.prepareDeleteTimestamps(Mutation mutation, Map<byte[],List<Cell>> familyMap, byte[] byteNow) Set up correct timestamps in the KVs in Delete object.
boolean	RegionCoprocessorHost.prePrepareTimeStampForDeleteVersion(Mutation mutation, Cell kv, byte[] byteNow, Get get) Deprecated. In hbase-2.0.0. Will be removed in hbase-3.0.0. Added explicitly for a single Coprocessor for its needs only. Will be removed.
private static Cell	HRegion.reckonDelta(Cell delta, Cell currentCell, byte[] columnFamily, long now, Mutation mutation, Function<Cell,byte[]> supplier)
private WALEdit	HRegion.reckonDeltas(Region.Operation op, Mutation mutation, Durability effectiveDurability, Map<HStore,List<Cell>> forMemStore, List<Cell> results) Reckon the Cells to apply to WAL, memstore, and to return to the Client; these Sets are not always the same dependent on whether to write WAL.
private List<Cell>	HRegion.reckonDeltasByStore(HStore store, Region.Operation op, Mutation mutation, Durability effectiveDurability, long now, List<Cell> deltas, List<Cell> results) Reckon the Cells to apply to WAL, memstore, and to return to the Client in passed column family/Store.
(package private) void	HRegion.rewriteCellTags(Map<byte[],List<Cell>> familyMap, Mutation m) Possibly rewrite incoming cell tags.

Method parameters in org.apache.hadoop.hbase.regionserver with type arguments of type Mutation

Modifier and Type	Method and Description
List<Pair<NonceKey,WALEdit>>	HRegion.BatchOperation.buildWALEdits(MiniBatchOperationInProgress<Mutation> miniBatchOp) Builds separate WALEdit per nonce by applying input mutations.
List<Pair<NonceKey,WALEdit>>	HRegion.MutationBatchOperation.buildWALEdits(MiniBatchOperationInProgress<Mutation> miniBatchOp)
private void	HRegion.MutationBatchOperation.checkAndMergeCPMutations(MiniBatchOperationInProgress<Mutation> miniBatchOp, List<Region.RowLock> acquiredRowLocks, long timestamp)
void	HRegion.BatchOperation.completeMiniBatchOperations(MiniBatchOperationInProgress<Mutation> miniBatchOp, MultiVersionConcurrencyControl.WriteEntry writeEntry) This method completes mini-batch operations by calling postBatchMutate() CP hook (if required) and completing mvcc.
void	HRegion.MutationBatchOperation.completeMiniBatchOperations(MiniBatchOperationInProgress<Mutation> miniBatchOp, MultiVersionConcurrencyControl.WriteEntry writeEntry)
void	HRegion.ReplayBatchOperation.completeMiniBatchOperations(MiniBatchOperationInProgress<Mutation> miniBatchOp, MultiVersionConcurrencyControl.WriteEntry writeEntry)
private void	HRegion.BatchOperation.doFinishHotnessProtector(MiniBatchOperationInProgress<Mutation> miniBatchOp)
void	HRegion.BatchOperation.doPostOpCleanupForMiniBatch(MiniBatchOperationInProgress<Mutation> miniBatchOp, WALEdit walEdit, boolean success)
void	HRegion.MutationBatchOperation.doPostOpCleanupForMiniBatch(MiniBatchOperationInProgress<Mutation> miniBatchOp, WALEdit walEdit, boolean success)
private void	HRegion.doProcessRowWithTimeout(RowProcessor<?,?> processor, long now, HRegion region, List<Mutation> mutations, WALEdit walEdit, long timeout)
void	Region.mutateRowsWithLocks(Collection<Mutation> mutations, Collection<byte[]> rowsToLock, long nonceGroup, long nonce) Perform atomic mutations within the region.
void	HRegion.mutateRowsWithLocks(Collection<Mutation> mutations, Collection<byte[]> rowsToLock, long nonceGroup, long nonce) Perform atomic (all or none) mutations within the region.
void	RegionCoprocessorHost.postBatchMutate(MiniBatchOperationInProgress<Mutation> miniBatchOp)
void	RegionCoprocessorHost.postBatchMutateIndispensably(MiniBatchOperationInProgress<Mutation> miniBatchOp, boolean success)
void	RegionCoprocessorHost.preBatchMutate(MiniBatchOperationInProgress<Mutation> miniBatchOp)
abstract void	HRegion.BatchOperation.prepareMiniBatchOperations(MiniBatchOperationInProgress<Mutation> miniBatchOp, long timestamp, List<Region.RowLock> acquiredRowLocks) If necessary, calls preBatchMutate() CP hook for a mini-batch and updates metrics, cell count, tags and timestamp for all cells of all operations in a mini-batch.
void	HRegion.MutationBatchOperation.prepareMiniBatchOperations(MiniBatchOperationInProgress<Mutation> miniBatchOp, long timestamp, List<Region.RowLock> acquiredRowLocks)
void	HRegion.ReplayBatchOperation.prepareMiniBatchOperations(MiniBatchOperationInProgress<Mutation> miniBatchOp, long timestamp, List<Region.RowLock> acquiredRowLocks)
void	RowProcessor.process(long now, HRegion region, List<Mutation> mutations, WALEdit walEdit) Deprecated. HRegion handles the locks and MVCC and invokes this method properly.
protected void	HRegion.BatchOperation.writeMiniBatchOperationsToMemStore(MiniBatchOperationInProgress<Mutation> miniBatchOp, long writeNumber)
abstract MultiVersionConcurrencyControl.WriteEntry	HRegion.BatchOperation.writeMiniBatchOperationsToMemStore(MiniBatchOperationInProgress<Mutation> miniBatchOp, MultiVersionConcurrencyControl.WriteEntry writeEntry) Write mini-batch operations to MemStore
MultiVersionConcurrencyControl.WriteEntry	HRegion.MutationBatchOperation.writeMiniBatchOperationsToMemStore(MiniBatchOperationInProgress<Mutation> miniBatchOp, MultiVersionConcurrencyControl.WriteEntry writeEntry)
MultiVersionConcurrencyControl.WriteEntry	HRegion.ReplayBatchOperation.writeMiniBatchOperationsToMemStore(MiniBatchOperationInProgress<Mutation> miniBatchOp, MultiVersionConcurrencyControl.WriteEntry writeEntry)

Constructors in org.apache.hadoop.hbase.regionserver with parameters of type Mutation

Constructor and Description
MutationBatchOperation(HRegion region, Mutation[] operations, boolean atomic, long nonceGroup, long nonce)

Uses of Mutation in org.apache.hadoop.hbase.rsgroup

Method parameters in org.apache.hadoop.hbase.rsgroup with type arguments of type Mutation

Modifier and Type	Method and Description
private void	RSGroupInfoManagerImpl.multiMutate(List<Mutation> mutations)

Uses of Mutation in org.apache.hadoop.hbase.security.access

Methods in org.apache.hadoop.hbase.security.access with parameters of type Mutation

Modifier and Type	Method and Description
private void	AccessController.checkForReservedTagPresence(User user, Mutation m)
private Cell	AccessController.createNewCellWithTags(Mutation mutation, Cell oldCell, Cell newCell)
List<Pair<Cell,Cell>>	AccessController.postAppendBeforeWAL(ObserverContext<RegionCoprocessorEnvironment> ctx, Mutation mutation, List<Pair<Cell,Cell>> cellPairs)
List<Pair<Cell,Cell>>	AccessController.postIncrementBeforeWAL(ObserverContext<RegionCoprocessorEnvironment> ctx, Mutation mutation, List<Pair<Cell,Cell>> cellPairs)

Method parameters in org.apache.hadoop.hbase.security.access with type arguments of type Mutation

Modifier and Type	Method and Description
void	AccessController.preBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c, MiniBatchOperationInProgress<Mutation> miniBatchOp)

Uses of Mutation in org.apache.hadoop.hbase.security.visibility

Methods in org.apache.hadoop.hbase.security.visibility with parameters of type Mutation

Modifier and Type	Method and Description
private Cell	VisibilityController.createNewCellWithTags(Mutation mutation, Cell newCell)
List<Pair<Cell,Cell>>	VisibilityController.postAppendBeforeWAL(ObserverContext<RegionCoprocessorEnvironment> ctx, Mutation mutation, List<Pair<Cell,Cell>> cellPairs)
List<Pair<Cell,Cell>>	VisibilityController.postIncrementBeforeWAL(ObserverContext<RegionCoprocessorEnvironment> ctx, Mutation mutation, List<Pair<Cell,Cell>> cellPairs)
void	VisibilityController.prePrepareTimeStampForDeleteVersion(ObserverContext<RegionCoprocessorEnvironment> ctx, Mutation delete, Cell cell, byte[] byteNow, Get get)

Method parameters in org.apache.hadoop.hbase.security.visibility with type arguments of type Mutation

Modifier and Type	Method and Description
private boolean	DefaultVisibilityLabelServiceImpl.mutateLabelsRegion(List<Mutation> mutations, OperationStatus[] finalOpStatus) Adds the mutations to labels region and set the results to the finalOpStatus.
void	VisibilityController.preBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c, MiniBatchOperationInProgress<Mutation> miniBatchOp)

Uses of Mutation in org.apache.hadoop.hbase.tool

Method parameters in org.apache.hadoop.hbase.tool with type arguments of type Mutation

Modifier and Type	Method and Description
void	WriteSinkCoprocessor.preBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c, MiniBatchOperationInProgress<Mutation> miniBatchOp)

Uses of Mutation in org.apache.hadoop.hbase.wal

Fields in org.apache.hadoop.hbase.wal declared as Mutation

Modifier and Type	Field and Description
Mutation	WALSplitUtil.MutationReplay.mutation

Constructors in org.apache.hadoop.hbase.wal with parameters of type Mutation

Constructor and Description
MutationReplay(org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.MutationProto.MutationType type, Mutation mutation, long nonceGroup, long nonce)