Before you start developing applications on MapR’s Converged Data Platform, consider how you will get the data onto the
platform, the format it will be stored in, the type of processing or modeling that is required, and how the data will
be accessed.

The mapr-client package must be installed on each node where you will be building and running your applications. This package installs
all of the MapR Libraries needed for application development regardless of programming language or type of MapR Database table (binary or JSON).

This topic describes the methods for passing a MapR Database table name. Binary table names can be passed by either specifying the table path in the API or by setting the table
path in the core-site.xml file. JSON table names are passed by specifying the table path in the API.

This section provides the MapR DatabaselibMapRClient C API library. This library is MapR's extension of the libhbase C API library. The libMapRClient header files are in this directory: /opt/mapr/include/hbase

Filters are specified in the Thrift Filter Language and are in this format: FilterName (argument, argument,... , argument). Arguments that represent strings are enclosed in single quotation marks (‘). Arguments that represent booleans,
integers, or comparison operators (<, <=, =, !=, >, >=) are not enclosed in single quotation marks.

As part of its support for JSON tables, MapR Database implements the OJAI API. The OJAI API provides methods for creating, reading, updating, and deleting JSON documents
in MapR Database JSON tables. It is available in Java, and starting in MEP 6.0, Node.js, and Python. MapR Database also provides a MapR Database JSON Client API for managing JSON tables and a MapR Database JSON REST API for performing basic operations using HTTP calls.

MapR supports public APIs for MapR Filesystem, MapR Database, and MapR Event Store For Apache Kafka. These APIs are available for application development purposes.

Supported Filters

Filter

Format

Description

ColumnCountGetFilter

ColumnCountGetFilter(x)

Returns the first x columns in a row. Used for GET operations.

ColumnPaginationFilter

ColumnPaginationFilter(x,y)

Returns the first x columns after the number y of columns that is specified for
the offset.

ColumnPrefixFilter

ColumnPrefixFilter('prefix')

Returns only those key-values in columns that have names that start with the
specified prefix. The column prefix must be of the form “qualifier”.

ColumnRangeFilter

ColumnRangFilter('minColumn','maxColumn',boolean,boolean)

Returns only those key-values that are in columns that have names between
minColumn and maxColumn.

For example, if minColumn is 'an', and maxColumn is 'be', the filter returns
key-values from columns named 'ana', 'bad', but not from columns named 'bed' or'eye'
If minColumn is null, there is no lower bound. If maxColumn is null, there is no
upper bound.

This filter also takes two boolean variables to indicate whether to include the
minColumn and maxColumn.

DependentColumnFilter

DependentColumnFilter('family','qualifier')

Tries to locate the specified column in each row and returns all key-values
that have the same timestamp in that column. If a row does not contain the specified
column, none of the key-values in that row are returned.

FamilyFilter

FamilyFilter(compareOperator,'comparator:value')

Filters by column family. If the comparison returns true, the filter returns
all of the key-values in the matching column family.

Serially compares each qualifier in a row with the given qualifiers. If the
current qualifier matches any of the given qualifiers, the filter stops and includes
the current row (up to the current qualifier) in the result set.

FuzzyRowFilter

FuzzyRowFilter('rowkey','fuzzy_info')

Filters data based on fuzzy row key. Performs fast-forwards during scanning. It
takes pairs (row key, fuzzy info) to match row keys. Where fuzzy info is a byte
array with 0 or 1 as its values:

0 - means that this byte in provided row key is fixed, i.e. row key's byte at
same position must match

1 - means that this byte in provided row key is NOT fixed, i.e. row key's byte
at this position can be different from the one in provided row key

Example: Let's assume row key format is userId_actionId_year_month. Length of
userId is fixed and is 4, length of actionId is 2 and year and month are 4 and 2
bytes long respectively. Let's assume that we need to fetch all users that performed
certain action (encoded as "99") in Jan of any year. Then the pair (row key, fuzzy
info) would be the following: row key = "????_99_????_01" (one can use any value
instead of "?") fuzzy info =
"\x01\x01\x01\x01\x00\x00\x00\x00\x01\x01\x01\x01\x00\x00\x00" I.e. fuzzy info tells
the matching mask is "????_99_????_01", where at ? can be any value.

InclusiveStopFilter

InclusiveStopFilter('rowKey')

Returns all key-values that are in the rows up to and including the specified
row that has the specified row key.

KeyOnlyFilter

KeyOnlyFilter()

Returns the key component of each key-value.

MultipleColumnPrefixFilter

MultipleColumnPrefixFilter('prefix_1','prefix_2',
...,'prefix_n')

Returns the key-values from columns that have names that begin with any of the
specified prefixes.

PageFilter

PageFilter(pageSize)

Returns the number of rows that is equivalent to the specified page
size..

PrefixFilter

PrefixFilter('rowKey_prefix')

Returns the key-values from a row that has a key which starts with the
specified row-key prefix.

QualifierFilter

QualifierFilter(compareOperator,'comparator:value')

Filters by column. If the comparison returns true, the filter returns all of
the key-values in the matching column.

RandomRowFilter

RandomRowFilter(probability)

Filters by probability. For example, RandomRowFilter(0.25) means that there is
a 1 in 4 chance that the filter will pick the first row, a 1 in 4 chance that the
filter will pick the next row, and so on until all rows in the table have been
processed in this way.

RowFilter

RowFilter(compareOperator,'comparator:value')

Filters by row key. If the comparison returns true, the filter returns all of
the key-values in the matching row.

This filter takes the same arguments and behaves the same as
SingleColumnValueFilter: however, if the column is found and the condition passes,
all of the columns of the row will be returned except for the tested column
value.

This filter takes a column family, a qualifier, a compare operator and a
comparator. If the specified column is not found: all of the columns of that row
will be emitted. If the column is found and the comparison with the comparator
returns true, all of the columns of the row will be emitted. If the condition fails,
the row will not be returned.