org.apache.hadoop.hbase.filter.SingleColumnValueFilter.getFamily 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
}

 @Override
 public int hashCode() {
  return Objects.hash(Bytes.hashCode(getFamily()), Bytes.hashCode(getQualifier()),
   this.op, getComparator(), getFilterIfMissing(), getLatestVersionOnly());
 }
}

public static Filter createFilterFromArguments(ArrayList<byte []> filterArguments) {
 SingleColumnValueFilter tempFilter = (SingleColumnValueFilter)
  SingleColumnValueFilter.createFilterFromArguments(filterArguments);
 SingleColumnValueExcludeFilter filter = new SingleColumnValueExcludeFilter (
  tempFilter.getFamily(), tempFilter.getQualifier(),
  tempFilter.getOperator(), tempFilter.getComparator());
 if (filterArguments.size() == 6) {
  filter.setFilterIfMissing(tempFilter.getFilterIfMissing());
  filter.setLatestVersionOnly(tempFilter.getLatestVersionOnly());
 }
 return filter;
}

/**
 * @return true if and only if the fields of the filter that are serialized
 * are equal to the corresponding fields in other.  Used for testing.
 */
@Override
boolean areSerializedFieldsEqual(Filter o) {
 if (o == this) return true;
 if (!(o instanceof SingleColumnValueFilter)) return false;
 SingleColumnValueFilter other = (SingleColumnValueFilter)o;
 return Bytes.equals(this.getFamily(), other.getFamily())
  && Bytes.equals(this.getQualifier(), other.getQualifier())
  && this.op.equals(other.op)
  && this.getComparator().areSerializedFieldsEqual(other.getComparator())
  && this.getFilterIfMissing() == other.getFilterIfMissing()
  && this.getLatestVersionOnly() == other.getLatestVersionOnly();
}

case SingleColumnValueFilter: {
 SingleColumnValueFilter scvf = (SingleColumnValueFilter) filter;
 this.family = Bytes.toString(Base64.getEncoder().encode(scvf.getFamily()));
 byte[] qualifier = scvf.getQualifier();
 if (qualifier != null) {

@Test
public void testSingleColumnValueFilter() throws IOException {
 String filterString = "SingleColumnValueFilter " +
  "('family', 'qualifier', >=, 'binary:a', true, false)";
 SingleColumnValueFilter singleColumnValueFilter =
  doTestFilter(filterString, SingleColumnValueFilter.class);
 assertEquals("family", new String(singleColumnValueFilter.getFamily(), StandardCharsets.UTF_8));
 assertEquals("qualifier",
   new String(singleColumnValueFilter.getQualifier(), StandardCharsets.UTF_8));
 assertEquals(CompareOperator.GREATER_OR_EQUAL, singleColumnValueFilter.getCompareOperator());
 assertTrue(singleColumnValueFilter.getComparator() instanceof BinaryComparator);
 BinaryComparator binaryComparator = (BinaryComparator) singleColumnValueFilter.getComparator();
 assertEquals("a", new String(binaryComparator.getValue(), StandardCharsets.UTF_8));
 assertTrue(singleColumnValueFilter.getFilterIfMissing());
 assertFalse(singleColumnValueFilter.getLatestVersionOnly());
 filterString = "SingleColumnValueFilter ('family', 'qualifier', >, 'binaryprefix:a')";
 singleColumnValueFilter = doTestFilter(filterString, SingleColumnValueFilter.class);
 assertEquals("family", new String(singleColumnValueFilter.getFamily(), StandardCharsets.UTF_8));
 assertEquals("qualifier",
   new String(singleColumnValueFilter.getQualifier(), StandardCharsets.UTF_8));
 assertEquals(CompareOperator.GREATER, singleColumnValueFilter.getCompareOperator());
 assertTrue(singleColumnValueFilter.getComparator() instanceof BinaryPrefixComparator);
 BinaryPrefixComparator binaryPrefixComparator =
  (BinaryPrefixComparator) singleColumnValueFilter.getComparator();
 assertEquals("a", new String(binaryPrefixComparator.getValue(), StandardCharsets.UTF_8));
 assertFalse(singleColumnValueFilter.getFilterIfMissing());
 assertTrue(singleColumnValueFilter.getLatestVersionOnly());
}

public static Filter createFilterFromArguments(ArrayList<byte []> filterArguments) {
 SingleColumnValueFilter tempFilter = (SingleColumnValueFilter)
  SingleColumnValueFilter.createFilterFromArguments(filterArguments);
 SingleColumnValueExcludeFilter filter = new SingleColumnValueExcludeFilter (
  tempFilter.getFamily(), tempFilter.getQualifier(),
  tempFilter.getOperator(), tempFilter.getComparator());
 if (filterArguments.size() == 6) {
  filter.setFilterIfMissing(tempFilter.getFilterIfMissing());
  filter.setLatestVersionOnly(tempFilter.getLatestVersionOnly());
 }
 return filter;
}

/**
 * @return true if and only if the fields of the filter that are serialized
 * are equal to the corresponding fields in other.  Used for testing.
 */
@Override
boolean areSerializedFieldsEqual(Filter o) {
 if (o == this) return true;
 if (!(o instanceof SingleColumnValueFilter)) return false;
 SingleColumnValueFilter other = (SingleColumnValueFilter)o;
 return Bytes.equals(this.getFamily(), other.getFamily())
  && Bytes.equals(this.getQualifier(), other.getQualifier())
  && this.op.equals(other.op)
  && this.getComparator().areSerializedFieldsEqual(other.getComparator())
  && this.getFilterIfMissing() == other.getFilterIfMissing()
  && this.getLatestVersionOnly() == other.getLatestVersionOnly();
}

private static void extractColumnFamiliesFromFiltersBasedOnFilters(
  Filter hbaseFilterBasedOnTLSFilter, Set<String> columnFamilies) {
 if (hbaseFilterBasedOnTLSFilter instanceof SingleColumnValueFilter) {
  byte[] cf =  ((SingleColumnValueFilter)
    hbaseFilterBasedOnTLSFilter).getFamily();
  columnFamilies.add(Bytes.toString(cf));
 } else if (hbaseFilterBasedOnTLSFilter instanceof FilterList) {
  FilterList filterListBase = (FilterList) hbaseFilterBasedOnTLSFilter;
  for (Filter fs: filterListBase.getFilters()) {
   extractColumnFamiliesFromFiltersBasedOnFilters(fs, columnFamilies);
  }
 }
}

protected static void workaroundHBASE2198(Get get, Filter filter,byte[][] qualifiers) {
  if (filter instanceof SingleColumnValueFilter) {
    if(qualifiers == null) {
      get.addFamily(((SingleColumnValueFilter) filter).getFamily());
    }else{
      get.addColumn(((SingleColumnValueFilter) filter).getFamily(), ((SingleColumnValueFilter) filter).getQualifier());
    }
    return;
  }
  if (filter instanceof FilterList) {
    for (Filter f : ((FilterList)filter).getFilters()) {
      workaroundHBASE2198(get, f,qualifiers);
    }
  }
}

protected static void workaroundHBASE2198(Get get, Filter filter, byte[][] qualifiers) {
  if (filter instanceof SingleColumnValueFilter) {
    if (qualifiers == null) {
      get.addFamily(((SingleColumnValueFilter)filter).getFamily());
    } else {
      get.addColumn(((SingleColumnValueFilter)filter).getFamily(),
             ((SingleColumnValueFilter)filter).getQualifier());
    }
    return;
  }
  if (filter instanceof FilterList) {
    for (Filter f : ((FilterList)filter).getFilters()) {
      workaroundHBASE2198(get, f, qualifiers);
    }
  }
}

/**
 * <h2>History</h2>.
 * <ul>
 * <li><b>Nov 19th, 2014</b>: Fix for out put all qualifiers</li>
 * </ul>
 *
 * @param s1
 * @param filter
 */
protected void workaroundHBASE2198(Scan s1, Filter filter) {
  if (filter instanceof SingleColumnValueFilter) {
    if (this.qualifiers == null) {
      s1.addFamily(((SingleColumnValueFilter)filter).getFamily());
    } else {
      s1.addColumn(((SingleColumnValueFilter)filter).getFamily(),
             ((SingleColumnValueFilter)filter).getQualifier());
    }
    return;
  }
  if (filter instanceof FilterList) {
    for (Filter f : ((FilterList)filter).getFilters()) {
      workaroundHBASE2198(s1, f);
    }
  }
}

/**
 * <h2>History</h2>
 * <ul>
 *     <li><b>Nov 19th, 2014</b>: Fix for out put all qualifiers</li>
 * </ul>
 * @param s1
 * @param filter
 */
protected void workaroundHBASE2198(Scan s1, Filter filter) {
  if (filter instanceof SingleColumnValueFilter) {
    if(this.qualifiers == null){
      s1.addFamily(((SingleColumnValueFilter) filter).getFamily());
    }else {
      s1.addColumn(((SingleColumnValueFilter) filter).getFamily(), ((SingleColumnValueFilter) filter).getQualifier());
    }
    return;
  }
  if (filter instanceof FilterList) {
    for (Filter f : ((FilterList)filter).getFilters()) {
      workaroundHBASE2198(s1, f);
    }
  }
}

public static Filter createFilterFromArguments(ArrayList<byte []> filterArguments) {
 SingleColumnValueFilter tempFilter = (SingleColumnValueFilter)
  SingleColumnValueFilter.createFilterFromArguments(filterArguments);
 SingleColumnValueExcludeFilter filter = new SingleColumnValueExcludeFilter (
  tempFilter.getFamily(), tempFilter.getQualifier(),
  tempFilter.getOperator(), tempFilter.getComparator());
 if (filterArguments.size() == 6) {
  filter.setFilterIfMissing(tempFilter.getFilterIfMissing());
  filter.setLatestVersionOnly(tempFilter.getLatestVersionOnly());
 }
 return filter;
}

public static Filter createFilterFromArguments(ArrayList<byte []> filterArguments) {
 SingleColumnValueFilter tempFilter = (SingleColumnValueFilter)
  SingleColumnValueFilter.createFilterFromArguments(filterArguments);
 SingleColumnValueExcludeFilter filter = new SingleColumnValueExcludeFilter (
  tempFilter.getFamily(), tempFilter.getQualifier(),
  tempFilter.getOperator(), tempFilter.getComparator());
 if (filterArguments.size() == 6) {
  filter.setFilterIfMissing(tempFilter.getFilterIfMissing());
  filter.setLatestVersionOnly(tempFilter.getLatestVersionOnly());
 }
 return filter;
}

/**
 * @return true if and only if the fields of the filter that are serialized
 * are equal to the corresponding fields in other.  Used for testing.
 */
@Override
boolean areSerializedFieldsEqual(Filter o) {
 if (o == this) return true;
 if (!(o instanceof SingleColumnValueFilter)) return false;
 SingleColumnValueFilter other = (SingleColumnValueFilter)o;
 return Bytes.equals(this.getFamily(), other.getFamily())
  && Bytes.equals(this.getQualifier(), other.getQualifier())
  && this.op.equals(other.op)
  && this.getComparator().areSerializedFieldsEqual(other.getComparator())
  && this.getFilterIfMissing() == other.getFilterIfMissing()
  && this.getLatestVersionOnly() == other.getLatestVersionOnly();
}

 public static Filter createFilterFromArguments(ArrayList<byte []> filterArguments) {
  SingleColumnValueFilter tempFilter = (SingleColumnValueFilter)
   SingleColumnValueFilter.createFilterFromArguments(filterArguments);
  SingleColumnValueExcludeFilter filter = new SingleColumnValueExcludeFilter (
   tempFilter.getFamily(), tempFilter.getQualifier(),
   tempFilter.getOperator(), tempFilter.getComparator());

  if (filterArguments.size() == 6) {
   filter.setFilterIfMissing(tempFilter.getFilterIfMissing());
   filter.setLatestVersionOnly(tempFilter.getLatestVersionOnly());
}
  return filter;
 }
}

/**
 * @param other
 * @return true if and only if the fields of the filter that are serialized
 * are equal to the corresponding fields in other.  Used for testing.
 */
boolean areSerializedFieldsEqual(Filter o) {
 if (o == this) return true;
 if (!(o instanceof SingleColumnValueFilter)) return false;
 SingleColumnValueFilter other = (SingleColumnValueFilter)o;
 return Bytes.equals(this.getFamily(), other.getFamily())
  && Bytes.equals(this.getQualifier(), other.getQualifier())
  && this.compareOp.equals(other.compareOp)
  && this.getComparator().areSerializedFieldsEqual(other.getComparator())
  && this.getFilterIfMissing() == other.getFilterIfMissing()
  && this.getLatestVersionOnly() == other.getLatestVersionOnly();
}

@Test
public void testSingleColumnValueFilter() throws IOException {
 String filterString = "SingleColumnValueFilter " +
  "('family', 'qualifier', >=, 'binary:a', true, false)";
 SingleColumnValueFilter singleColumnValueFilter =
  doTestFilter(filterString, SingleColumnValueFilter.class);
 assertEquals("family", new String(singleColumnValueFilter.getFamily(), StandardCharsets.UTF_8));
 assertEquals("qualifier",
   new String(singleColumnValueFilter.getQualifier(), StandardCharsets.UTF_8));
 assertEquals(CompareOperator.GREATER_OR_EQUAL, singleColumnValueFilter.getCompareOperator());
 assertTrue(singleColumnValueFilter.getComparator() instanceof BinaryComparator);
 BinaryComparator binaryComparator = (BinaryComparator) singleColumnValueFilter.getComparator();
 assertEquals("a", new String(binaryComparator.getValue(), StandardCharsets.UTF_8));
 assertTrue(singleColumnValueFilter.getFilterIfMissing());
 assertFalse(singleColumnValueFilter.getLatestVersionOnly());
 filterString = "SingleColumnValueFilter ('family', 'qualifier', >, 'binaryprefix:a')";
 singleColumnValueFilter = doTestFilter(filterString, SingleColumnValueFilter.class);
 assertEquals("family", new String(singleColumnValueFilter.getFamily(), StandardCharsets.UTF_8));
 assertEquals("qualifier",
   new String(singleColumnValueFilter.getQualifier(), StandardCharsets.UTF_8));
 assertEquals(CompareOperator.GREATER, singleColumnValueFilter.getCompareOperator());
 assertTrue(singleColumnValueFilter.getComparator() instanceof BinaryPrefixComparator);
 BinaryPrefixComparator binaryPrefixComparator =
  (BinaryPrefixComparator) singleColumnValueFilter.getComparator();
 assertEquals("a", new String(binaryPrefixComparator.getValue(), StandardCharsets.UTF_8));
 assertFalse(singleColumnValueFilter.getFilterIfMissing());
 assertTrue(singleColumnValueFilter.getLatestVersionOnly());
}

Filter toFilter(FilterAdapterContext context, SingleColumnValueFilter filter)
  throws IOException {
 // filter to check if the column exists
 ChainFilter columnSpecFilter = getColumnSpecFilter(
   filter.getFamily(),
   filter.getQualifier(),
   filter.getLatestVersionOnly());
 // filter to return the row if the condition is met
 if (filter.getFilterIfMissing()) {
  return FILTERS.condition(addValue(context, filter, columnSpecFilter))
       .then(FILTERS.pass());
 } else {
  return FILTERS.interleave()
    .filter(FILTERS.condition(addValue(context, filter, columnSpecFilter.clone()))
         .then(FILTERS.pass()))
    .filter(FILTERS.condition(columnSpecFilter)
         .otherwise(FILTERS.pass()));
 }
}

Filter toFilter(FilterAdapterContext context, SingleColumnValueFilter filter)
  throws IOException {
 // filter to check if the column exists
 ChainFilter columnSpecFilter = getColumnSpecFilter(
   filter.getFamily(),
   filter.getQualifier(),
   filter.getLatestVersionOnly());
 // filter to return the row if the condition is met
 if (filter.getFilterIfMissing()) {
  return FILTERS.condition(addValue(context, filter, columnSpecFilter))
       .then(FILTERS.pass());
 } else {
  return FILTERS.interleave()
    .filter(FILTERS.condition(addValue(context, filter, columnSpecFilter.clone()))
         .then(FILTERS.pass()))
    .filter(FILTERS.condition(columnSpecFilter)
         .otherwise(FILTERS.pass()));
 }
}

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
setLatestVersionOnly
Set whether only the latest version of the column value should be compared. If true, the row will be
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

Reading from database using SQL prepared statement
getSharedPreferences (Context)
requestLocationUpdates (LocationManager)
getSupportFragmentManager (FragmentActivity)
Return the FragmentManager for interacting with fragments associated with this activity.
GridLayout (java.awt)
The GridLayout class is a layout manager that lays out a container's components in a rectangular gri
BufferedReader (java.io)
Reads text from a character-input stream, buffering characters so as to provide for the efficient re
Charset (java.nio.charset)
A charset is a named mapping between Unicode characters and byte sequences. Every Charset can decode
Locale (java.util)
A Locale object represents a specific geographical, political, or cultural region. An operation that
NoSuchElementException (java.util)
Thrown when trying to retrieve an element past the end of an Enumeration or Iterator.
Location (org.springframework.beans.factory.parsing)
Class that models an arbitrary location in a Resource.Typically used to track the location of proble

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

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

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