org.apache.hadoop.hbase.filter.SingleColumnValueFilter.setLatestVersionOnly java code examples

Common ways to obtain SingleColumnValueFilter

private void myMethod () {
 SingleColumnValueFilter s =CompareFilter.CompareOp compareOp;new SingleColumnValueFilter(family, qualifier, compareOp, value)
ArrayList filterArguments;(SingleColumnValueFilter) SingleColumnValueFilter.createFilterFromArguments(filterArguments)
CompareFilter.CompareOp compareOp;ByteArrayComparable comparator;new SingleColumnValueFilter(family, qualifier, compareOp, comparator)
Smart code suggestions by Codota
}

public static Filter createFilterFromArguments(ArrayList<byte []> filterArguments) {
 Preconditions.checkArgument(filterArguments.size() == 4 || filterArguments.size() == 6,
               "Expected 4 or 6 but got: %s", filterArguments.size());
 byte [] family = ParseFilter.removeQuotesFromByteArray(filterArguments.get(0));
 byte [] qualifier = ParseFilter.removeQuotesFromByteArray(filterArguments.get(1));
 CompareOperator op = ParseFilter.createCompareOperator(filterArguments.get(2));
 org.apache.hadoop.hbase.filter.ByteArrayComparable comparator = ParseFilter.createComparator(
  ParseFilter.removeQuotesFromByteArray(filterArguments.get(3)));
 if (comparator instanceof RegexStringComparator ||
   comparator instanceof SubstringComparator) {
  if (op != CompareOperator.EQUAL &&
    op != CompareOperator.NOT_EQUAL) {
   throw new IllegalArgumentException ("A regexstring comparator and substring comparator " +
                     "can only be used with EQUAL and NOT_EQUAL");
  }
 }
 SingleColumnValueFilter filter = new SingleColumnValueFilter(family, qualifier,
                                op, comparator);
 if (filterArguments.size() == 6) {
  boolean filterIfMissing = ParseFilter.convertByteArrayToBoolean(filterArguments.get(4));
  boolean latestVersionOnly = ParseFilter.convertByteArrayToBoolean(filterArguments.get(5));
  filter.setFilterIfMissing(filterIfMissing);
  filter.setLatestVersionOnly(latestVersionOnly);
 }
 return filter;
}

((SingleColumnValueFilter)filter).setLatestVersionOnly(latestVersion);

byte[] qualifier = HBaseUtils.getBytes(field.getRootSegment().getChild().getNameSegment().getPath());
filter = new SingleColumnValueFilter(family, qualifier, compareOp, comparator);
((SingleColumnValueFilter)filter).setLatestVersionOnly(true);
if (!isNullTest) {
 ((SingleColumnValueFilter)filter).setFilterIfMissing(true);

byte[] qualifier = HBaseUtils.getBytes(field.getRootSegment().getChild().getNameSegment().getPath());
filter = new SingleColumnValueFilter(family, qualifier, compareOp, comparator);
((SingleColumnValueFilter)filter).setLatestVersionOnly(true);
if (!isNullTest) {
 ((SingleColumnValueFilter)filter).setFilterIfMissing(true);

assertTrue("basicFilterNotNull", filter.filterRow());
filter.reset();
filter.setLatestVersionOnly(false);
cell = new KeyValue(ROW, COLUMN_FAMILY, COLUMN_QUALIFIER, VAL_1);
assertTrue("basicFilter5", filter.filterCell(cell) == Filter.ReturnCode.INCLUDE);

public static Filter createFilterFromArguments(ArrayList<byte []> filterArguments) {
 Preconditions.checkArgument(filterArguments.size() == 4 || filterArguments.size() == 6,
               "Expected 4 or 6 but got: %s", filterArguments.size());
 byte [] family = ParseFilter.removeQuotesFromByteArray(filterArguments.get(0));
 byte [] qualifier = ParseFilter.removeQuotesFromByteArray(filterArguments.get(1));
 CompareOperator op = ParseFilter.createCompareOperator(filterArguments.get(2));
 org.apache.hadoop.hbase.filter.ByteArrayComparable comparator = ParseFilter.createComparator(
  ParseFilter.removeQuotesFromByteArray(filterArguments.get(3)));
 if (comparator instanceof RegexStringComparator ||
   comparator instanceof SubstringComparator) {
  if (op != CompareOperator.EQUAL &&
    op != CompareOperator.NOT_EQUAL) {
   throw new IllegalArgumentException ("A regexstring comparator and substring comparator " +
                     "can only be used with EQUAL and NOT_EQUAL");
  }
 }
 SingleColumnValueFilter filter = new SingleColumnValueFilter(family, qualifier,
                                op, comparator);
 if (filterArguments.size() == 6) {
  boolean filterIfMissing = ParseFilter.convertByteArrayToBoolean(filterArguments.get(4));
  boolean latestVersionOnly = ParseFilter.convertByteArrayToBoolean(filterArguments.get(5));
  filter.setFilterIfMissing(filterIfMissing);
  filter.setLatestVersionOnly(latestVersionOnly);
 }
 return filter;
}

public static Filter createFilterFromArguments(ArrayList<byte []> filterArguments) {
 Preconditions.checkArgument(filterArguments.size() == 4 || filterArguments.size() == 6,
               "Expected 4 or 6 but got: %s", filterArguments.size());
 byte [] family = ParseFilter.removeQuotesFromByteArray(filterArguments.get(0));
 byte [] qualifier = ParseFilter.removeQuotesFromByteArray(filterArguments.get(1));
 CompareOp compareOp = ParseFilter.createCompareOp(filterArguments.get(2));
 WritableByteArrayComparable comparator = ParseFilter.createComparator(
  ParseFilter.removeQuotesFromByteArray(filterArguments.get(3)));
 if (comparator instanceof RegexStringComparator ||
   comparator instanceof SubstringComparator) {
  if (compareOp != CompareOp.EQUAL &&
    compareOp != CompareOp.NOT_EQUAL) {
   throw new IllegalArgumentException ("A regexstring comparator and substring comparator " +
                     "can only be used with EQUAL and NOT_EQUAL");
  }
 }
 SingleColumnValueFilter filter = new SingleColumnValueFilter(family, qualifier,
                                compareOp, comparator);
 if (filterArguments.size() == 6) {
  boolean filterIfMissing = ParseFilter.convertByteArrayToBoolean(filterArguments.get(4));
  boolean latestVersionOnly = ParseFilter.convertByteArrayToBoolean(filterArguments.get(5));
  filter.setFilterIfMissing(filterIfMissing);
  filter.setLatestVersionOnly(latestVersionOnly);
 }
 return filter;
}

public static Filter createFilterFromArguments(ArrayList<byte []> filterArguments) {
 Preconditions.checkArgument(filterArguments.size() == 4 || filterArguments.size() == 6,
     "Expected 4 or 6 but got: %s", filterArguments.size());
 byte [] family = ParseFilter.removeQuotesFromByteArray(filterArguments.get(0));
 byte [] qualifier = ParseFilter.removeQuotesFromByteArray(filterArguments.get(1));
 CompareFilter.CompareOp compareOp = ParseFilter.createCompareOp(filterArguments.get(2));
 WritableByteArrayComparable comparator = ParseFilter.createComparator(
  ParseFilter.removeQuotesFromByteArray(filterArguments.get(3)));
 if (comparator instanceof RegexStringComparator ||
   comparator instanceof SubstringComparator) {
  if (compareOp != CompareFilter.CompareOp.EQUAL &&
    compareOp != CompareFilter.CompareOp.NOT_EQUAL) {
   throw new IllegalArgumentException ("A regexstring comparator and substring comparator " +
                     "can only be used with EQUAL and NOT_EQUAL");
  }
 }
 SingleColumnValueFilter filter = new SingleColumnValueFilter(family, qualifier,
                                compareOp, comparator);
 if (filterArguments.size() == 6) {
  boolean filterIfMissing = ParseFilter.convertByteArrayToBoolean(filterArguments.get(4));
  boolean latestVersionOnly = ParseFilter.convertByteArrayToBoolean(filterArguments.get(5));
  filter.setFilterIfMissing(filterIfMissing);
  filter.setLatestVersionOnly(latestVersionOnly);
 }
 return filter;
}

public static Filter createFilterFromArguments(ArrayList<byte []> filterArguments) {
 Preconditions.checkArgument(filterArguments.size() == 4 || filterArguments.size() == 6,
               "Expected 4 or 6 but got: %s", filterArguments.size());
 byte [] family = ParseFilter.removeQuotesFromByteArray(filterArguments.get(0));
 byte [] qualifier = ParseFilter.removeQuotesFromByteArray(filterArguments.get(1));
 CompareOperator op = ParseFilter.createCompareOperator(filterArguments.get(2));
 org.apache.hadoop.hbase.filter.ByteArrayComparable comparator = ParseFilter.createComparator(
  ParseFilter.removeQuotesFromByteArray(filterArguments.get(3)));
 if (comparator instanceof RegexStringComparator ||
   comparator instanceof SubstringComparator) {
  if (op != CompareOperator.EQUAL &&
    op != CompareOperator.NOT_EQUAL) {
   throw new IllegalArgumentException ("A regexstring comparator and substring comparator " +
                     "can only be used with EQUAL and NOT_EQUAL");
  }
 }
 SingleColumnValueFilter filter = new SingleColumnValueFilter(family, qualifier,
                                op, comparator);
 if (filterArguments.size() == 6) {
  boolean filterIfMissing = ParseFilter.convertByteArrayToBoolean(filterArguments.get(4));
  boolean latestVersionOnly = ParseFilter.convertByteArrayToBoolean(filterArguments.get(5));
  filter.setFilterIfMissing(filterIfMissing);
  filter.setLatestVersionOnly(latestVersionOnly);
 }
 return filter;
}

public static Filter createFilterFromArguments(ArrayList<byte []> filterArguments) {
 Preconditions.checkArgument(filterArguments.size() == 4 || filterArguments.size() == 6,
               "Expected 4 or 6 but got: %s", filterArguments.size());
 byte [] family = ParseFilter.removeQuotesFromByteArray(filterArguments.get(0));
 byte [] qualifier = ParseFilter.removeQuotesFromByteArray(filterArguments.get(1));
 CompareOp compareOp = ParseFilter.createCompareOp(filterArguments.get(2));
 ByteArrayComparable comparator = ParseFilter.createComparator(
  ParseFilter.removeQuotesFromByteArray(filterArguments.get(3)));
 if (comparator instanceof RegexStringComparator ||
   comparator instanceof SubstringComparator) {
  if (compareOp != CompareOp.EQUAL &&
    compareOp != CompareOp.NOT_EQUAL) {
   throw new IllegalArgumentException ("A regexstring comparator and substring comparator " +
                     "can only be used with EQUAL and NOT_EQUAL");
  }
 }
 SingleColumnValueFilter filter = new SingleColumnValueFilter(family, qualifier,
                                compareOp, comparator);
 if (filterArguments.size() == 6) {
  boolean filterIfMissing = ParseFilter.convertByteArrayToBoolean(filterArguments.get(4));
  boolean latestVersionOnly = ParseFilter.convertByteArrayToBoolean(filterArguments.get(5));
  filter.setFilterIfMissing(filterIfMissing);
  filter.setLatestVersionOnly(latestVersionOnly);
 }
 return filter;
}

/**
 * Filter : SingleColumnValueFilter('0', {COLUMM}, !=, null, true, true).
 * Get rows that contain column {COLUMN} and {COLUMN} is not null
 * @param column Column
 * @return Filter
 */
public Filter existingColumnFilter(byte[] column) {
  SingleColumnValueFilter filter = new SingleColumnValueFilter(genomeHelper.getColumnFamily(), column,
      CompareFilter.CompareOp.NOT_EQUAL, new NullComparator());
  filter.setFilterIfMissing(true);
  filter.setLatestVersionOnly(true);
  return filter;
}

/**
 * Creates a HBase {@link SingleColumnValueFilter}.
 *
 * @param columnFamily Column Family represented as bytes.
 * @param columnQualifier Column Qualifier represented as bytes.
 * @param value Value.
 * @param compareOp Compare operator.
 * @param filterIfMissing This flag decides if we should filter the row if the
 *     specified column is missing. This is based on the filter's keyMustExist
 *     field.
 * @return a {@link SingleColumnValueFilter} object
 * @throws IOException
 */
private static SingleColumnValueFilter createHBaseSingleColValueFilter(
  byte[] columnFamily, byte[] columnQualifier, byte[] value,
  CompareOp compareOp, boolean filterIfMissing) throws IOException {
 SingleColumnValueFilter singleColValFilter =
   new SingleColumnValueFilter(columnFamily, columnQualifier, compareOp,
   new BinaryComparator(value));
 singleColValFilter.setLatestVersionOnly(true);
 singleColValFilter.setFilterIfMissing(filterIfMissing);
 return singleColValFilter;
}

((SingleColumnValueFilter)filter).setLatestVersionOnly(latestVersion);

/** {@inheritDoc} */
@Override
public Filter toHBaseFilter(Context context) throws IOException {
 // Create a filter that accepts a cell from mFamily and mQualifier only if it is
 // equals to the specified value.
 final FijiColumnName column = FijiColumnName.create(mFamily, mQualifier);
 HBaseColumnName hbaseColumnName = context.getHBaseColumnName(column);
 SingleColumnValueFilter filter = new SingleColumnValueFilter(
   hbaseColumnName.getFamily(),
   hbaseColumnName.getQualifier(),
   CompareOp.EQUAL,
   context.getHBaseCellValue(column, mValue));
 filter.setLatestVersionOnly(true);
 filter.setFilterIfMissing(true);
 // Skip the entire row if the filter does not allow the column value.
 return new SkipFilter(filter);
}

byte[] qualifier = HBaseUtils.getBytes(field.getRootSegment().getChild().getNameSegment().getPath());
filter = new SingleColumnValueFilter(family, qualifier, compareOp, comparator);
((SingleColumnValueFilter)filter).setLatestVersionOnly(true);
if (!isNullTest) {
 ((SingleColumnValueFilter)filter).setFilterIfMissing(true);

byte[] qualifier = HBaseUtils.getBytes(field.getRootSegment().getChild().getNameSegment().getPath());
filter = new SingleColumnValueFilter(family, qualifier, compareOp, comparator);
((SingleColumnValueFilter)filter).setLatestVersionOnly(true);
if (!isNullTest) {
 ((SingleColumnValueFilter)filter).setFilterIfMissing(true);

((SingleColumnValueFilter)filter).setLatestVersionOnly(latestVersion);

((SingleColumnValueFilter)filter).setLatestVersionOnly(latestVersion);

assertTrue("basicFilterNotNull", filter.filterRow());
filter.reset();
filter.setLatestVersionOnly(false);
cell = new KeyValue(ROW, COLUMN_FAMILY, COLUMN_QUALIFIER, VAL_1);
assertTrue("basicFilter5", filter.filterCell(cell) == Filter.ReturnCode.INCLUDE);

  new SingleColumnValueFilter(COLUMN_FAMILY, qualifier1, CompareOp.EQUAL, valueComparable1);
filter.setFilterIfMissing(false);
filter.setLatestVersionOnly(false);
filter.setLatestVersionOnly(true);
scan.setFilter(filter);
results = table.getScanner(scan).next(10);

Javadoc

Set whether only the latest version of the column value should be compared. If true, the row will be returned if only the latest version of the column value matches. If false, the row will be returned if any version of the column value matches. The default is true.

Popular methods of SingleColumnValueFilter

<init>
Constructor for binary compare of the value of a single column. If the column is found and the condi
setFilterIfMissing
Set whether entire row should be filtered if column is not found. If true, the entire row will be sk
getFamily
getQualifier
getComparator
getFilterIfMissing
Get whether entire row should be filtered if column is not found.
getLatestVersionOnly
Get whether only the latest version of the column value should be compared. If true, the row will be
getOperator
areSerializedFieldsEqual
createFilterFromArguments
filterColumnValue
convert

Popular in Java

Parsing JSON documents to java classes using gson
runOnUiThread (Activity)
findViewById (Activity)
addToBackStack (FragmentTransaction)
MalformedURLException (java.net)
Thrown to indicate that a malformed URL has occurred. Either no legal protocol could be found in a s
Connection (java.sql)
A connection represents a link from a Java application to a database. All SQL statements and results
DateFormat (java.text)
Formats or parses dates and times.This class provides factories for obtaining instances configured f
GregorianCalendar (java.util)
GregorianCalendar is a concrete subclass of Calendarand provides the standard calendar used by most
Notification (javax.management)
JButton (javax.swing)

How to use setLatestVersionOnlymethodin org.apache.hadoop.hbase.filter.SingleColumnValueFilter

Best Java code snippets using org.apache.hadoop.hbase.filter.SingleColumnValueFilter.setLatestVersionOnly (Showing top 20 results out of 315)

How to use
setLatestVersionOnly
method
in
org.apache.hadoop.hbase.filter.SingleColumnValueFilter