org.apache.hadoop.mapreduce.Mapper$Context.getCurrentKey java code examples

Common ways to obtain Mapper$Context

private void myMethod () {
 Mapper$Context m =WrappedMapper wrappedMapper;new Context(wrappedMapper)
Mockito mockito;mockito.mock(Mapper.Context.class)
Smart code suggestions by Codota
}

@Override
public void run(Context context) throws IOException, InterruptedException
{
 setup(context);
 while (context.nextKeyValue()) {
  map(context.getCurrentKey(), context.getCurrentValue(), context);
 }
 for (Map.Entry<Interval, HyperLogLogCollector> entry : hyperLogLogs.entrySet()) {
  context.write(
    new LongWritable(entry.getKey().getStartMillis()),
    new BytesWritable(entry.getValue().toByteArray())
  );
 }
 cleanup(context);
}

 @Override
 protected boolean filter(Context context, Cell cell) {
  // TODO: Can I do a better compare than this copying out key?
  byte [] row = new byte [cell.getRowLength()];
  System.arraycopy(cell.getRowArray(), cell.getRowOffset(), row, 0, cell.getRowLength());
  boolean b = this.keysToFind.contains(row);
  if (b) {
   String keyStr = Bytes.toStringBinary(row);
   try {
    LOG.info("Found cell=" + cell + " , walKey=" + context.getCurrentKey());
   } catch (IOException|InterruptedException e) {
    LOG.warn(e.toString(), e);
   }
   if (rows.addAndGet(1) < MISSING_ROWS_TO_LOG) {
    context.getCounter(FOUND_GROUP_KEY, keyStr).increment(1);
   }
   context.getCounter(FOUND_GROUP_KEY, "CELL_WITH_MISSING_ROW").increment(1);
  }
  return b;
 }
}

 @Override
 protected boolean filter(Context context, Cell cell) {
  // TODO: Can I do a better compare than this copying out key?
  byte [] row = new byte [cell.getRowLength()];
  System.arraycopy(cell.getRowArray(), cell.getRowOffset(), row, 0, cell.getRowLength());
  boolean b = this.keysToFind.contains(row);
  if (b) {
   String keyStr = Bytes.toStringBinary(row);
   try {
    LOG.info("Found cell=" + cell + " , walKey=" + context.getCurrentKey());
   } catch (IOException|InterruptedException e) {
    LOG.warn(e.toString(), e);
   }
   if (rows.addAndGet(1) < MISSING_ROWS_TO_LOG) {
    context.getCounter(FOUND_GROUP_KEY, keyStr).increment(1);
   }
   context.getCounter(FOUND_GROUP_KEY, "CELL_WITH_MISSING_ROW").increment(1);
  }
  return b;
 }
}

@Override
public void run(Context context) throws IOException, InterruptedException {
  setup(context);
  while ((count < fequency) && context.nextKeyValue()) {
    float diff = fequency - count;
    if (random.nextFloat() <= diff) {
      map(context.getCurrentKey(), context.getCurrentValue(), context);
    }
    count++;
  }
  cleanup(context);
}

@Override
public boolean nextKeyValue() throws IOException, InterruptedException {
  synchronized(outer) {
    if(!outer.nextKeyValue()) {
      return false;
    }
    key = ReflectionUtils.copy(outer.getConfiguration(), outer.getCurrentKey(), key);
    value = ReflectionUtils.copy(conf, outer.getCurrentValue(), value);
    return true;
  }
}

private static RyaStatement nextRyaStatement(final Context context, final RyaTripleContext ryaContext) throws IOException, InterruptedException {
  RyaStatement ryaStatement = null;
  if (context.nextKeyValue()) {
    final Key key = context.getCurrentKey();
    final Value value = context.getCurrentValue();
    try {
      ryaStatement = createRyaStatement(key, value, ryaContext);
    } catch (final TripleRowResolverException e) {
      log.error("TripleRowResolverException encountered while creating statement", e);
    }
  }
  return ryaStatement;
}

 /**
  * Expert users can override this method for more complete control over the
  * execution of the Mapper.
  * @param context
  * @throws IOException
  */
 public void run(Context context) throws IOException, InterruptedException {
  setup(context);
  while (context.nextKeyValue()) {
   map(context.getCurrentKey(), context.getCurrentValue(), context);
  }
  cleanup(context);
 }
}

@Override
public void run(Context context) throws IOException, InterruptedException {
  setup(context);
  while ((count < limit) && context.nextKeyValue()) {
    map(context.getCurrentKey(), context.getCurrentValue(), context);
    count++;
  }
  cleanup(context);
}

  @Override
  public void run(Context context) throws IOException, InterruptedException {
    setup(context);
    try {
      while (!ContentPump.shutdown && context.nextKeyValue()) {
        map(context.getCurrentKey(), context.getCurrentValue(), context);
      }
    } finally {
      if (ContentPump.shutdown && LOG.isDebugEnabled()) {
        LOG.debug("Aborting task...");
      }
      cleanup(context);
    }
  }
}

@Override
public void run(Context context) throws IOException, InterruptedException
{
 setup(context);
 while (context.nextKeyValue()) {
  map(context.getCurrentKey(), context.getCurrentValue(), context);
 }
 for (Map.Entry<Interval, HyperLogLogCollector> entry : hyperLogLogs.entrySet()) {
  context.write(
    new LongWritable(entry.getKey().getStartMillis()),
    new BytesWritable(entry.getValue().toByteArray())
  );
 }
 cleanup(context);
}

@Override
public void run(Context context) throws IOException, InterruptedException
{
 setup(context);
 while (context.nextKeyValue()) {
  map(context.getCurrentKey(), context.getCurrentValue(), context);
 }
 for (Map.Entry<Interval, HyperLogLogCollector> entry : hyperLogLogs.entrySet()) {
  context.write(
    new LongWritable(entry.getKey().getStartMillis()),
    new BytesWritable(entry.getValue().toByteArray())
  );
 }
 cleanup(context);
}

@Override
public void run(Context context) throws IOException, InterruptedException
{
 setup(context);
 while (context.nextKeyValue()) {
  map(context.getCurrentKey(), context.getCurrentValue(), context);
 }
 for (Map.Entry<Interval, HyperLogLogCollector> entry : hyperLogLogs.entrySet()) {
  context.write(
    new LongWritable(entry.getKey().getStartMillis()),
    new BytesWritable(entry.getValue().toByteArray())
  );
 }
 cleanup(context);
}

@Override
public void run(Context context) throws IOException, InterruptedException {
  this.setup(context);
  try {
    while (context.nextKeyValue()) {
      this.map(context.getCurrentKey(), context.getCurrentValue(), context);
      annotateVariants(context, false);
    }
    annotateVariants(context, true);
  } catch (VariantAnnotatorException e) {
    throw new RuntimeException(e);
  } finally {
    this.cleanup(context);
  }
}

@Override
public boolean nextKeyValue() throws IOException, InterruptedException {
  synchronized(outer) {
    if(!outer.nextKeyValue()) {
      return false;
    }
    key = ReflectionUtils.copy(outer.getConfiguration(), outer.getCurrentKey(), key);
    value = ReflectionUtils.copy(conf, outer.getCurrentValue(), value);
    return true;
  }
}

 /**
  * Expert users can override this method for more complete control over the
  * execution of the Mapper.
  * @param context
  * @throws IOException
  */
 public void run(Context context) throws IOException, InterruptedException {
  setup(context);
  try {
   while (context.nextKeyValue()) {
    map(context.getCurrentKey(), context.getCurrentValue(), context);
   }
  } finally {
   cleanup(context);
  }
 }
}

this.map(context.getCurrentKey(), context.getCurrentValue(), context);

 /**
  * Expert users can override this method for more complete control over the
  * execution of the Mapper.
  * @param context
  * @throws IOException
  */
 public void run(Context context) throws IOException, InterruptedException {
  setup(context);
  try {
   while (context.nextKeyValue()) {
    map(context.getCurrentKey(), context.getCurrentValue(), context);
   }
  } finally {
   cleanup(context);
  }
 }
}

 /**
  * Expert users can override this method for more complete control over the
  * execution of the Mapper.
  * @param context
  * @throws IOException
  */
 public void run(Context context) throws IOException, InterruptedException {
  setup(context);
  try {
   while (context.nextKeyValue()) {
    map(context.getCurrentKey(), context.getCurrentValue(), context);
   }
  } finally {
   cleanup(context);
  }
 }
}

 /**
  * Expert users can override this method for more complete control over the
  * execution of the Mapper.
  * @param context
  * @throws IOException
  */
 public void run(Context context) throws IOException, InterruptedException {
  setup(context);
  try {
   while (context.nextKeyValue()) {
    map(context.getCurrentKey(), context.getCurrentValue(), context);
   }
  } finally {
   cleanup(context);
  }
 }
}

 /**
  * Expert users can override this method for more complete control over the
  * execution of the Mapper.
  * @param context
  * @throws IOException
  */
 public void run(Context context) throws IOException, InterruptedException {
  setup(context);
  while (context.nextKeyValue()) {
   map(context.getCurrentKey(), context.getCurrentValue(), context);
  }
  cleanup(context);
 }
}

Popular methods of Mapper$Context

Popular in Java

Start an intent from android
setScale (BigDecimal)
compareTo (BigDecimal)
Compares this BigDecimal with the specified BigDecimal. Two BigDecimal objects that are equal in val
getOriginalFilename (MultipartFile)
Return the original filename in the client's filesystem.This may contain path information depending
IOException (java.io)
Signals that an I/O exception of some sort has occurred. This class is the general class of exceptio
BigInteger (java.math)
Immutable arbitrary-precision integers. All operations behave as if BigIntegers were represented in
ByteBuffer (java.nio)
A buffer for bytes. A byte buffer can be created in either one of the following ways: * #allocate(i
Hashtable (java.util)
Hashtable is a synchronized implementation of Map. All optional operations are supported.Neither key
IOUtils (org.apache.commons.io)
General IO stream manipulation utilities. This class provides static utility methods for input/outpu
Runner (org.openjdk.jmh.runner)

How to use getCurrentKeymethodin org.apache.hadoop.mapreduce.Mapper$Context

Best Java code snippets using org.apache.hadoop.mapreduce.Mapper$Context.getCurrentKey (Showing top 20 results out of 315)

How to use
getCurrentKey
method
in
org.apache.hadoop.mapreduce.Mapper$Context