Filter verwenden

Cloud Bigtable bietet die folgenden Filtertypen:

  • Begrenzungsfilter, die steuern, welche Zeilen oder Zellen in der Antwort enthalten sind.
  • Änderungsfilter, die sich auf die Daten oder Metadaten einzelner Zellen auswirken.
  • Kombinationsfilter, mit denen Sie mehrere Filter zu einem einzigen Filter zusammenfassen können.

Auf dieser Seite wird jeder Cloud Bigtable-Filter ausführlich beschrieben. Außerdem erfahren Sie, wie Sie die einzelnen Filtertypen mit Cloud-Clientbibliotheken verwenden. Bevor Sie diese Seite lesen, sollten Sie das Dokument Cloud Bigtable-Filter – Übersicht durchlesen.

Weitere Beispiele zum Verwenden von Filtern zum Lesen mehrerer Datenzeilen finden Sie unter Daten lesen.

Daten für Beispiele

In den Beispielen auf dieser Seite wird davon ausgegangen, dass Sie Zeitachsendaten für Smartphones und Tablets speichern und dass die folgenden Daten in eine Tabelle geschrieben wurden. Die Tabelle umfasst die zwei Spaltenfamilien stats_summary und cell_plan. Jede Spaltenfamilie hat drei Spalten.

stats_summary cell_plan
Zeilenschlüssel connected_cell connected_wifi os_build data_plan_01gb data_plan_05gb data_plan_10gb
phone#4c410523#20190501 1 1 PQ2A.190405.003 true@time minus eine Stunde

False @time
true
phone#4c410523#20190502 1 1 PQ2A.190405.004 true
phone#4c410523#20190505 0 1 PQ2A.190406.000 true
phone#5c10102#20190501 1 1 PQ2A.190401.002 true
phone#5c10102#20190502 1 0 PQ2A.190406.000 true

Begrenzungsfilter

In den folgenden Abschnitten werden die verschiedenen Begrenzungsfilter beschrieben. Begrenzungsfilter geben bestimmte Kriterien vor, von denen es abhängt, ob bestimmte Zeilen oder Zellen in der Antwort enthalten sind.

Beachten Sie beim Kombinieren mehrerer Begrenzungsfilter mithilfe einer Kette, dass die Eingabezeile jedes Filters in der Kette die Ausgabezeile des vorherigen Filters in der Kette ist. Ein Beispiel: Wenn Sie zwei Filter verketten und der erste Filter nur zwei Zellen aus der ursprünglichen Zeile ausgibt, erkennt der zweite Filter nur diese beiden Zellen.

Zeilenauswahlfilter

Zufallsauswahl aus Zeilen

Mit diesem Filter können Sie eine zufällige Auswahl von Zeilen innerhalb eines bestimmten Bereichs abrufen. Anhand einer von Ihnen angegebenen Wahrscheinlichkeit bestimmt der Filter nach dem Zufallsprinzip, ob die Ausgabezeile mit der Eingabezeile identisch sein soll oder in den Ergebnissen weggelassen werden soll.

Go

func filterLimitRowSample(w io.Writer, projectID, instanceID string, tableName string) error {
	filter := bigtable.RowSampleFilter(.75)
	return readWithFilter(w, projectID, instanceID, tableName, filter)
}

HBase

public static void filterLimitRowSample() {
  // TODO(developer): Replace these variables before running the sample.
  String projectId = "my-project-id";
  String instanceId = "my-instance-id";
  String tableId = "mobile-time-series";
  filterLimitRowSample(projectId, instanceId, tableId);
}

public static void filterLimitRowSample(String projectId, String instanceId, String tableId) {
  // A filter that matches cells from a row with probability .75
  Filter filter = new RandomRowFilter(.75f);
  Scan scan = new Scan().setFilter(filter);
  readWithFilter(projectId, instanceId, tableId, scan);
}

Java

public static void filterLimitRowSample() {
  // TODO(developer): Replace these variables before running the sample.
  String projectId = "my-project-id";
  String instanceId = "my-instance-id";
  String tableId = "mobile-time-series";
  filterLimitRowSample(projectId, instanceId, tableId);
}

public static void filterLimitRowSample(String projectId, String instanceId, String tableId) {
  // A filter that matches cells from a row with probability .75
  Filter filter = FILTERS.key().sample(.75);
  readFilter(projectId, instanceId, tableId, filter);
}

Python

def filter_limit_row_sample(project_id, instance_id, table_id):
    client = bigtable.Client(project=project_id, admin=True)
    instance = client.instance(instance_id)
    table = instance.table(table_id)

    rows = table.read_rows(filter_=row_filters.RowSampleFilter(.75))
    for row in rows:
        print_row(row)

C#

/// <summary>
/// /// Read using a row sample filter from an existing table.
///</summary>
/// <param name="projectId">Your Google Cloud Project ID.</param>
/// <param name="instanceId">Your Google Cloud Bigtable Instance ID.</param>
/// <param name="tableId">Your Google Cloud Bigtable table ID.</param>

public string filterLimitRowSample(string projectId = "YOUR-PROJECT-ID", string instanceId = "YOUR-INSTANCE-ID", string tableId = "YOUR-TABLE-ID")
{
    // A filter that matches cells from a row with probability .75
    RowFilter filter = RowFilters.RowSample(.75);
    return readFilter(projectId, instanceId, tableId, filter);
}

C++

Dieses Codebeispiel ist demnächst verfügbar.

Node.js

const filter = {
  row: {
    sample: 0.75,
  },
};
readWithFilter(filter);

PHP

$filter = Filter::key()->sample(.75);
read_filter($table, $filter);

Ruby

filter = Google::Cloud::Bigtable::RowFilter.sample 0.75
read_with_filter project_id, instance_id, table_id, filter

Zeilenschlüssel-Regex

Dieser Filter prüft, ob der Zeilenschlüssel der Eingabezeile mit einem regulären Ausdruck übereinstimmt. Wenn der Zeilenschlüssel übereinstimmt, entspricht die Ausgabezeile der Eingabezeile. Wenn der Zeilenschlüssel nicht übereinstimmt, ist die Ausgabezeile leer.

Der reguläre Ausdruck muss die RE2-Syntax verwenden. Da Zeilenschlüssel beliebige Bytes enthalten können, einschließlich Zeilenumbruchzeichen, sollten Sie in den meisten Fällen \C als Platzhalterausdruck verwenden. Der Ausdruck . gleicht Zeilenumbruchzeichen nicht ab.

Go

func filterLimitRowRegex(w io.Writer, projectID, instanceID string, tableName string) error {
	filter := bigtable.RowKeyFilter(".*#20190501$")
	return readWithFilter(w, projectID, instanceID, tableName, filter)
}

HBase

public static void filterLimitRowRegex() {
  // TODO(developer): Replace these variables before running the sample.
  String projectId = "my-project-id";
  String instanceId = "my-instance-id";
  String tableId = "mobile-time-series";
  filterLimitRowRegex(projectId, instanceId, tableId);
}

public static void filterLimitRowRegex(String projectId, String instanceId, String tableId) {
  // A filter that matches cells from rows whose keys satisfy the given regex
  Filter filter = new RowFilter(CompareOp.EQUAL, new RegexStringComparator(".*#20190501$"));
  Scan scan = new Scan().setFilter(filter).setMaxVersions();
  readWithFilter(projectId, instanceId, tableId, scan);
}

Java

public static void filterLimitRowRegex() {
  // TODO(developer): Replace these variables before running the sample.
  String projectId = "my-project-id";
  String instanceId = "my-instance-id";
  String tableId = "mobile-time-series";
  filterLimitRowRegex(projectId, instanceId, tableId);
}

public static void filterLimitRowRegex(String projectId, String instanceId, String tableId) {
  // A filter that matches cells from rows whose keys satisfy the given regex
  Filter filter = FILTERS.key().regex(".*#20190501$");
  readFilter(projectId, instanceId, tableId, filter);
}

Python

def filter_limit_row_regex(project_id, instance_id, table_id):
    client = bigtable.Client(project=project_id, admin=True)
    instance = client.instance(instance_id)
    table = instance.table(table_id)

    rows = table.read_rows(
        filter_=row_filters.RowKeyRegexFilter(".*#20190501$".encode("utf-8")))
    for row in rows:
        print_row(row)

C#

/// <summary>
/// /// Read using a row regex filter from an existing table.
///</summary>
/// <param name="projectId">Your Google Cloud Project ID.</param>
/// <param name="instanceId">Your Google Cloud Bigtable Instance ID.</param>
/// <param name="tableId">Your Google Cloud Bigtable table ID.</param>

public string filterLimitRowRegex(string projectId = "YOUR-PROJECT-ID", string instanceId = "YOUR-INSTANCE-ID", string tableId = "YOUR-TABLE-ID")
{
    // A filter that matches cells from rows whose keys satisfy the given regex
    RowFilter filter = RowFilters.RowKeyRegex(".*#20190501$");
    return readFilter(projectId, instanceId, tableId, filter);
}

C++

Dieses Codebeispiel ist demnächst verfügbar.

Node.js

const filter = {
  row: /.*#20190501$/,
};
readWithFilter(filter);

PHP

$filter = Filter::key()->regex(".*#20190501$");
read_filter($table, $filter);

Ruby

filter = Google::Cloud::Bigtable::RowFilter.key ".*#20190501$"
read_with_filter project_id, instance_id, table_id, filter

Zellenauswahlfilter

Limit für Zellen pro Spalte

Dieser Filter begrenzt die Anzahl der Zellen pro Spalte, die in der Ausgabezeile enthalten sind. Wenn Sie diesen Filter anwenden, werden in jeder Ausgabezeile jeweils die N neuesten Zellen pro Spalte in die Ausgabe aufgenommen und alle anderen Zellen aus der betreffenden Spalte weggelassen.

Wenn Sie auch einen Interleave-Filter verwenden und dieser Filter Duplikate einer Zelle erzeugt, wird jedes Duplikat auf das Limit angerechnet.

Go

func filterLimitCellsPerCol(w io.Writer, projectID, instanceID string, tableName string) error {
	filter := bigtable.LatestNFilter(2)
	return readWithFilter(w, projectID, instanceID, tableName, filter)
}

HBase

public static void filterLimitCellsPerCol() {
  // TODO(developer): Replace these variables before running the sample.
  String projectId = "my-project-id";
  String instanceId = "my-instance-id";
  String tableId = "mobile-time-series";
  filterLimitCellsPerCol(projectId, instanceId, tableId);
}

public static void filterLimitCellsPerCol(String projectId, String instanceId, String tableId) {
  // A filter that matches only the most recent 2 cells within each column
  Scan scan = new Scan().setMaxVersions(2);
  readWithFilter(projectId, instanceId, tableId, scan);
}

Java

public static void filterLimitCellsPerCol() {
  // TODO(developer): Replace these variables before running the sample.
  String projectId = "my-project-id";
  String instanceId = "my-instance-id";
  String tableId = "mobile-time-series";
  filterLimitCellsPerCol(projectId, instanceId, tableId);
}

public static void filterLimitCellsPerCol(String projectId, String instanceId, String tableId) {
  // A filter that matches only the most recent 2 cells within each column
  Filter filter = FILTERS.limit().cellsPerColumn(2);
  readFilter(projectId, instanceId, tableId, filter);
}

Python

def filter_limit_cells_per_col(project_id, instance_id, table_id):
    client = bigtable.Client(project=project_id, admin=True)
    instance = client.instance(instance_id)
    table = instance.table(table_id)

    rows = table.read_rows(filter_=row_filters.CellsColumnLimitFilter(2))
    for row in rows:
        print_row(row)

C#

/// <summary>
/// /// Read using a cells per column filter from an existing table.
///</summary>
/// <param name="projectId">Your Google Cloud Project ID.</param>
/// <param name="instanceId">Your Google Cloud Bigtable Instance ID.</param>
/// <param name="tableId">Your Google Cloud Bigtable table ID.</param>

public string filterLimitCellsPerCol(string projectId = "YOUR-PROJECT-ID", string instanceId = "YOUR-INSTANCE-ID", string tableId = "YOUR-TABLE-ID")
{
    // A filter that matches only the most recent 2 cells within each column
    RowFilter filter = RowFilters.CellsPerColumnLimit(2);
    return readFilter(projectId, instanceId, tableId, filter);
}

C++

Dieses Codebeispiel ist demnächst verfügbar.

Node.js

const filter = {
  column: {
    cellLimit: 2,
  },
};
readWithFilter(filter);

PHP

$filter = Filter::limit()->cellsPerColumn(2);
read_filter($table, $filter);

Ruby

filter = Google::Cloud::Bigtable::RowFilter.cells_per_column 2
read_with_filter project_id, instance_id, table_id, filter

Limit für Zellen pro Zeile

Dieser Filter begrenzt die Anzahl der Zellen pro Ausgabezeile. Wenn Sie diesen Filter anwenden, werden pro Ausgabezeile jeweils die ersten N Zellen aus der Eingabezeile in die Ausgabe aufgenommen und alle anderen Zellen aus der betreffenden Zeile weggelassen. Die ersten N Zellen werden unabhängig von der Spalte, in der sie sich befinden, in der Reihenfolge ihrer Speicherung gelesen.

Eine Spalte in einer Zeile kann mehrere Zellen enthalten. Jede Zelle enthält einen Wert für die Spalte und einen eindeutigen Zeitstempel. Die kann unterschiedliche Ausgaben zur Folge haben, je nachdem, ob Sie eine Zeile auf die ersten N Zellen begrenzen oder aus derselben Zeile die ersten N Spalten abrufen. Wenn Sie beispielsweise einen Filter mit einem Limit von 20 Zellen pro Zeile verwenden, um eine Zeile mit 30 Spalten zu lesen, und jede Spalte 10 Zellen mit Zeitstempel hat, gibt die Ausgabezeile nur Werte aus den ersten beiden Spalten der Zeile zurück (2 x 10 = 20).

Die Verwendung dieses Filters in Kombination mit einem Versatzfilter ist für die Paginierung nützlich, wenn Sie eine große Zeile lesen müssen.

Go

func filterLimitCellsPerRow(w io.Writer, projectID, instanceID string, tableName string) error {
	filter := bigtable.CellsPerRowLimitFilter(2)
	return readWithFilter(w, projectID, instanceID, tableName, filter)
}

HBase

public static void filterLimitCellsPerRow() {
  // TODO(developer): Replace these variables before running the sample.
  String projectId = "my-project-id";
  String instanceId = "my-instance-id";
  String tableId = "mobile-time-series";
  filterLimitCellsPerRow(projectId, instanceId, tableId);
}

public static void filterLimitCellsPerRow(String projectId, String instanceId, String tableId) {
  // A filter that matches the first 2 cells of each row
  //    Filter filter = new ColumnCountGetFilter(2);
  Filter filter = new ColumnPaginationFilter(2, 0);

  Scan scan = new Scan().setFilter(filter);
  readWithFilter(projectId, instanceId, tableId, scan);
}

Java

public static void filterLimitCellsPerRow() {
  // TODO(developer): Replace these variables before running the sample.
  String projectId = "my-project-id";
  String instanceId = "my-instance-id";
  String tableId = "mobile-time-series";
  filterLimitCellsPerRow(projectId, instanceId, tableId);
}

public static void filterLimitCellsPerRow(String projectId, String instanceId, String tableId) {
  // A filter that matches the first 2 cells of each row
  Filter filter = FILTERS.limit().cellsPerRow(2);
  readFilter(projectId, instanceId, tableId, filter);
}

Python

def filter_limit_cells_per_row(project_id, instance_id, table_id):
    client = bigtable.Client(project=project_id, admin=True)
    instance = client.instance(instance_id)
    table = instance.table(table_id)

    rows = table.read_rows(filter_=row_filters.CellsRowLimitFilter(2))
    for row in rows:
        print_row(row)

C#

/// <summary>
/// /// Read using a cells per row filter from an existing table.
///</summary>
/// <param name="projectId">Your Google Cloud Project ID.</param>
/// <param name="instanceId">Your Google Cloud Bigtable Instance ID.</param>
/// <param name="tableId">Your Google Cloud Bigtable table ID.</param>

public string filterLimitCellsPerRow(string projectId = "YOUR-PROJECT-ID", string instanceId = "YOUR-INSTANCE-ID", string tableId = "YOUR-TABLE-ID")
{
    // A filter that matches the first 2 cells of each row
    RowFilter filter = RowFilters.CellsPerRowLimit(2);
    return readFilter(projectId, instanceId, tableId, filter);
}

C++

Dieses Codebeispiel ist demnächst verfügbar.

Node.js

const filter = {
  row: {
    cellLimit: 2,
  },
};
readWithFilter(filter);

PHP

$filter = Filter::limit()->cellsPerRow(2);
read_filter($table, $filter);

Ruby

filter = Google::Cloud::Bigtable::RowFilter.cells_per_row 2
read_with_filter project_id, instance_id, table_id, filter

Versatz für Zellen pro Zeile

Bei diesem Filter werden die ersten N Zellen in jeder Ausgabezeile weggelassen. Alle verbleibenden Zellen sind in der Ausgabezeile enthalten. Die ersten N Zellen werden übersprungen, unabhängig davon, in welcher Spalte sie sich befinden.

Eine Spalte in einer Zeile kann mehrere Zellen enthalten. Jede Zelle enthält einen Wert für die Spalte und einen eindeutigen Zeitstempel. Daher kann sich das Überspringen der ersten N Zellen in einer Zeile vom Überspringen der ersten N Spalten in der Zeile unterscheiden. Wenn Sie beispielsweise einen Filter mit einem Versatz von 20 Zellen pro Zeile verwenden, um eine Zeile mit 30 Spalten zu lesen, und jede Spalte 10 Zellen mit Zeitstempel hat, gibt die Ausgabezeile Werte für alle Zellen in der Zeile mit Ausnahme der Zellen in den ersten beiden Spalten zurück (2 x 10 = 20).

Wenn Sie auch einen Interleave-Filter verwenden und dieser Filter Duplikate einer Zelle erzeugt, wird jedes Duplikat auf den Versatz angerechnet.

Go

func filterLimitCellsPerRowOffset(w io.Writer, projectID, instanceID string, tableName string) error {
	filter := bigtable.CellsPerRowOffsetFilter(2)
	return readWithFilter(w, projectID, instanceID, tableName, filter)
}

HBase

public static void filterLimitCellsPerRowOffset() {
  // TODO(developer): Replace these variables before running the sample.
  String projectId = "my-project-id";
  String instanceId = "my-instance-id";
  String tableId = "mobile-time-series";
  filterLimitCellsPerRowOffset(projectId, instanceId, tableId);
}

public static void filterLimitCellsPerRowOffset(
    String projectId, String instanceId, String tableId) {
  // A filter that skips the first 2 cells per row
  Filter filter = new ColumnPaginationFilter(Integer.MAX_VALUE, 2);
  Scan scan = new Scan().setFilter(filter);
  readWithFilter(projectId, instanceId, tableId, scan);
}

Java

public static void filterLimitCellsPerRowOffset() {
  // TODO(developer): Replace these variables before running the sample.
  String projectId = "my-project-id";
  String instanceId = "my-instance-id";
  String tableId = "mobile-time-series";
  filterLimitCellsPerRowOffset(projectId, instanceId, tableId);
}

public static void filterLimitCellsPerRowOffset(
    String projectId, String instanceId, String tableId) {
  // A filter that skips the first 2 cells per row
  Filter filter = FILTERS.offset().cellsPerRow(2);
  readFilter(projectId, instanceId, tableId, filter);
}

Python

def filter_limit_cells_per_row_offset(project_id, instance_id, table_id):
    client = bigtable.Client(project=project_id, admin=True)
    instance = client.instance(instance_id)
    table = instance.table(table_id)

    rows = table.read_rows(filter_=row_filters.CellsRowOffsetFilter(2))
    for row in rows:
        print_row(row)

C#

    /// <summary>
    /// /// Read using a cells per row offset filter from an existing table.
    ///</summary>
    /// <param name="projectId">Your Google Cloud Project ID.</param>
    /// <param name="instanceId">Your Google Cloud Bigtable Instance ID.</param>
    /// <param name="tableId">Your Google Cloud Bigtable table ID.</param>

    public string filterLimitCellsPerRowOffset(
String projectId, String instanceId, String tableId)
    {
        // A filter that skips the first 2 cells per row
        RowFilter filter = RowFilters.CellsPerRowOffset(2);
        return readFilter(projectId, instanceId, tableId, filter);
    }

C++

Dieses Codebeispiel ist demnächst verfügbar.

Node.js

const filter = {
  row: {
    cellOffset: 2,
  },
};
readWithFilter(filter);

PHP

$filter = Filter::offset()->cellsPerRow(2);
read_filter($table, $filter);

Ruby

filter = Google::Cloud::Bigtable::RowFilter.cells_per_row_offset 2
read_with_filter project_id, instance_id, table_id, filter

Spaltenfamilien-Regex

Dieser Filter schließt Zellen nur dann in die Ausgabezeile ein, wenn die Spaltenfamilie einer Zelle mit einem regulären Ausdruck übereinstimmt.

Der reguläre Ausdruck muss die RE2-Syntax verwenden. Der reguläre Ausdruck darf das Zeichen : nicht enthalten, auch wenn das Zeichen nicht als Literal verwendet wird. Da Spaltenfamilien keine Zeilenumbruchzeichen enthalten dürfen, können Sie entweder . oder \C als Platzhalterausdruck verwenden.

Go

func filterLimitColFamilyRegex(w io.Writer, projectID, instanceID string, tableName string) error {
	filter := bigtable.FamilyFilter("stats_.*$")
	return readWithFilter(w, projectID, instanceID, tableName, filter)
}

HBase

public static void filterLimitColFamilyRegex() {
  // TODO(developer): Replace these variables before running the sample.
  String projectId = "my-project-id";
  String instanceId = "my-instance-id";
  String tableId = "mobile-time-series";
  filterLimitColFamilyRegex(projectId, instanceId, tableId);
}

public static void filterLimitColFamilyRegex(
    String projectId, String instanceId, String tableId) {
  // A filter that matches cells whose column family satisfies the given regex
  Filter filter = new FamilyFilter(CompareOp.EQUAL, new RegexStringComparator("stats_.*$"));
  Scan scan = new Scan().setFilter(filter);
  readWithFilter(projectId, instanceId, tableId, scan);
}

Java

public static void filterLimitColFamilyRegex() {
  // TODO(developer): Replace these variables before running the sample.
  String projectId = "my-project-id";
  String instanceId = "my-instance-id";
  String tableId = "mobile-time-series";
  filterLimitColFamilyRegex(projectId, instanceId, tableId);
}

public static void filterLimitColFamilyRegex(
    String projectId, String instanceId, String tableId) {
  // A filter that matches cells whose column family satisfies the given regex
  Filter filter = FILTERS.family().regex("stats_.*$");
  readFilter(projectId, instanceId, tableId, filter);
}

Python

def filter_limit_col_family_regex(project_id, instance_id, table_id):
    client = bigtable.Client(project=project_id, admin=True)
    instance = client.instance(instance_id)
    table = instance.table(table_id)

    rows = table.read_rows(
        filter_=row_filters.FamilyNameRegexFilter("stats_.*$".encode("utf-8")))
    for row in rows:
        print_row(row)

C#

    /// <summary>
    /// /// Read using a family regex filter from an existing table.
    ///</summary>
    /// <param name="projectId">Your Google Cloud Project ID.</param>
    /// <param name="instanceId">Your Google Cloud Bigtable Instance ID.</param>
    /// <param name="tableId">Your Google Cloud Bigtable table ID.</param>

    public string filterLimitColFamilyRegex(
String projectId, String instanceId, String tableId)
    {
        // A filter that matches cells whose column family satisfies the given regex
        RowFilter filter = RowFilters.FamilyNameRegex("stats_.*$");
        return readFilter(projectId, instanceId, tableId, filter);
    }

C++

Dieses Codebeispiel ist demnächst verfügbar.

Node.js

const filter = {
  family: /stats_.*$/,
};
readWithFilter(filter);

PHP

$filter = Filter::family()->regex("stats_.*$");
read_filter($table, $filter);

Ruby

filter = Google::Cloud::Bigtable::RowFilter.family "stats_.*$"
read_with_filter project_id, instance_id, table_id, filter

Spaltenqualifizierer-Regex

Dieser Filter schließt Zellen nur dann in die Ausgabezeile ein, wenn der Spaltenqualifizierer für eine Zelle mit einem regulären Ausdruck übereinstimmt.

Der reguläre Ausdruck muss die RE2-Syntax verwenden. Da Spaltenqualifizierer beliebige Bytes enthalten können, einschließlich Zeilenumbruchzeichen, sollten Sie in den meisten Fällen \C als Platzhalterausdruck verwenden. Der Ausdruck . gleicht Zeilenumbruchzeichen nicht ab.

Go

func filterLimitColQualifierRegex(w io.Writer, projectID, instanceID string, tableName string) error {
	filter := bigtable.ColumnFilter("connected_.*$")
	return readWithFilter(w, projectID, instanceID, tableName, filter)
}

HBase

public static void filterLimitColQualifierRegex() {
  // TODO(developer): Replace these variables before running the sample.
  String projectId = "my-project-id";
  String instanceId = "my-instance-id";
  String tableId = "mobile-time-series";
  filterLimitColQualifierRegex(projectId, instanceId, tableId);
}

public static void filterLimitColQualifierRegex(
    String projectId, String instanceId, String tableId) {
  // A filter that matches cells whose column qualifier satisfies the given regex
  Filter filter =
      new QualifierFilter(CompareOp.EQUAL, new RegexStringComparator("connected_.*$"));
  Scan scan = new Scan().setFilter(filter);
  readWithFilter(projectId, instanceId, tableId, scan);
}

Java

public static void filterLimitColQualifierRegex() {
  // TODO(developer): Replace these variables before running the sample.
  String projectId = "my-project-id";
  String instanceId = "my-instance-id";
  String tableId = "mobile-time-series";
  filterLimitColQualifierRegex(projectId, instanceId, tableId);
}

public static void filterLimitColQualifierRegex(
    String projectId, String instanceId, String tableId) {
  // A filter that matches cells whose column qualifier satisfies the given regex
  Filter filter = FILTERS.qualifier().regex("connected_.*$");
  readFilter(projectId, instanceId, tableId, filter);
}

Python

def filter_limit_col_qualifier_regex(project_id, instance_id, table_id):
    client = bigtable.Client(project=project_id, admin=True)
    instance = client.instance(instance_id)
    table = instance.table(table_id)

    rows = table.read_rows(
        filter_=row_filters.ColumnQualifierRegexFilter(
            "connected_.*$".encode("utf-8")))
    for row in rows:
        print_row(row)

C#

    /// <summary>
    /// /// Read using a qualifier regex filter from an existing table.
    ///</summary>
    /// <param name="projectId">Your Google Cloud Project ID.</param>
    /// <param name="instanceId">Your Google Cloud Bigtable Instance ID.</param>
    /// <param name="tableId">Your Google Cloud Bigtable table ID.</param>

    public string filterLimitColQualifierRegex(
String projectId, String instanceId, String tableId)
    {
        // A filter that matches cells whose column qualifier satisfies the given regex
        RowFilter filter = RowFilters.ColumnQualifierRegex("connected_.*$");
        return readFilter(projectId, instanceId, tableId, filter);
    }

C++

Dieses Codebeispiel ist demnächst verfügbar.

Node.js

const filter = {
  column: /connected_.*$/,
};
readWithFilter(filter);

PHP

$filter = Filter::qualifier()->regex("connected_.*$");
read_filter($table, $filter);

Ruby

filter = Google::Cloud::Bigtable::RowFilter.qualifier "connected_.*$"
read_with_filter project_id, instance_id, table_id, filter

Spaltenbereich

Dieser Filter schließt Zellen nur dann in die Ausgabezeile ein, wenn sie sich in einer bestimmten Spaltenfamilie befinden und ihre Spaltenqualifizierer außerdem in einen bestimmten Bereich fallen. Zum Angeben des Bereichs stellen Sie einen Startqualifizierer und einen Endqualifizierer bereit.

Go

func filterLimitColRange(w io.Writer, projectID, instanceID string, tableName string) error {
	filter := bigtable.ColumnRangeFilter("cell_plan", "data_plan_01gb", "data_plan_10gb")
	return readWithFilter(w, projectID, instanceID, tableName, filter)
}

HBase

public static void filterLimitColRange() {
  // TODO(developer): Replace these variables before running the sample.
  String projectId = "my-project-id";
  String instanceId = "my-instance-id";
  String tableId = "mobile-time-series";
  filterLimitColRange(projectId, instanceId, tableId);
}

public static void filterLimitColRange(String projectId, String instanceId, String tableId) {
  // A filter that matches cells whose column qualifiers are between data_plan_01gb and
  // data_plan_10gb in the column family cell_plan
  Filter filter =
      new ColumnRangeFilter(
          Bytes.toBytes("data_plan_01gb"), true, Bytes.toBytes("data_plan_10gb"), false);
  Scan scan = new Scan().addFamily(Bytes.toBytes("cell_plan")).setFilter(filter).setMaxVersions();
  readWithFilter(projectId, instanceId, tableId, scan);
}

Java

public static void filterLimitColRange() {
  // TODO(developer): Replace these variables before running the sample.
  String projectId = "my-project-id";
  String instanceId = "my-instance-id";
  String tableId = "mobile-time-series";
  filterLimitColRange(projectId, instanceId, tableId);
}

public static void filterLimitColRange(String projectId, String instanceId, String tableId) {
  // A filter that matches cells whose column qualifiers are between data_plan_01gb and
  // data_plan_10gb in the column family cell_plan
  Filter filter =
      FILTERS
          .qualifier()
          .rangeWithinFamily("cell_plan")
          .startClosed("data_plan_01gb")
          .endOpen("data_plan_10gb");
  readFilter(projectId, instanceId, tableId, filter);
}

Python

def filter_limit_col_range(project_id, instance_id, table_id):
    client = bigtable.Client(project=project_id, admin=True)
    instance = client.instance(instance_id)
    table = instance.table(table_id)

    rows = table.read_rows(
        filter_=row_filters.ColumnRangeFilter("cell_plan",
                                              b"data_plan_01gb",
                                              b"data_plan_10gb",
                                              inclusive_end=False))
    for row in rows:
        print_row(row)

C#

/// <summary>
/// /// Read using a qualifer range filter from an existing table.
///</summary>
/// <param name="projectId">Your Google Cloud Project ID.</param>
/// <param name="instanceId">Your Google Cloud Bigtable Instance ID.</param>
/// <param name="tableId">Your Google Cloud Bigtable table ID.</param>

public string filterLimitColRange(string projectId = "YOUR-PROJECT-ID", string instanceId = "YOUR-INSTANCE-ID", string tableId = "YOUR-TABLE-ID")
{
    // A filter that matches cells whose column qualifiers are between data_plan_01gb and
    // data_plan_10gb in the column family cell_plan
    RowFilter filter = RowFilters.ColumnRange(ColumnRange.ClosedOpen("cell_plan", "data_plan_01gb", "data_plan_10gb"));
    return readFilter(projectId, instanceId, tableId, filter);
}

C++

Dieses Codebeispiel ist demnächst verfügbar.

Node.js

const filter = {
  column: {
    family: 'cell_plan',
    start: 'data_plan_01gb',
    end: {
      value: 'data_plan_10gb',
      inclusive: false,
    },
  },
};
readWithFilter(filter);

PHP

$filter = Filter::qualifier()
    ->rangeWithinFamily("cell_plan")
    ->startClosed("data_plan_01gb")
    ->endOpen("data_plan_10gb");
read_filter($table, $filter);

Ruby

range = Google::Cloud::Bigtable::ColumnRange.new("cell_plan").from("data_plan_01gb").to("data_plan_10gb")
filter = Google::Cloud::Bigtable::RowFilter.column_range range
read_with_filter project_id, instance_id, table_id, filter

Wertebereich

Dieser Filter schließt Zellen nur dann in die Ausgabezeile ein, wenn ihre Werte in einen bestimmten Bereich fallen. Zum Angeben des Bereichs stellen Sie einen Startwert und einen Endwert bereit.

  • Wenn Sie Zellen abrufen möchten, deren Wert vor einem bestimmten Wert liegt, geben Sie diesen Wert als exklusiven Endwert an und lassen den Startwert weg.
  • Wenn Sie Zellen abrufen möchten, deren Wert einem bestimmten Wert entspricht oder nach diesem liegt, geben Sie diesen Wert als inklusiven Startwert an und lassen den Endwert weg.

Go

func filterLimitValueRange(w io.Writer, projectID, instanceID string, tableName string) error {
	filter := bigtable.ValueRangeFilter([]byte("PQ2A.190405"), []byte("PQ2A.190406"))
	return readWithFilter(w, projectID, instanceID, tableName, filter)
}

HBase

public static void filterLimitValueRange() {
  // TODO(developer): Replace these variables before running the sample.
  String projectId = "my-project-id";
  String instanceId = "my-instance-id";
  String tableId = "mobile-time-series";
  filterLimitValueRange(projectId, instanceId, tableId);
}

public static void filterLimitValueRange(String projectId, String instanceId, String tableId) {
  // A filter that matches cells whose values are between the given values
  ValueFilter valueGreaterFilter =
      new ValueFilter(
          CompareFilter.CompareOp.GREATER_OR_EQUAL,
          new BinaryComparator(Bytes.toBytes("PQ2A.190405")));
  ValueFilter valueLesserFilter =
      new ValueFilter(
          CompareFilter.CompareOp.LESS_OR_EQUAL,
          new BinaryComparator(Bytes.toBytes("PQ2A.190406")));

  FilterList filter = new FilterList(FilterList.Operator.MUST_PASS_ALL);
  filter.addFilter(valueGreaterFilter);
  filter.addFilter(valueLesserFilter);

  Scan scan = new Scan().setFilter(filter);
  readWithFilter(projectId, instanceId, tableId, scan);
}

Java

public static void filterLimitValueRange() {
  // TODO(developer): Replace these variables before running the sample.
  String projectId = "my-project-id";
  String instanceId = "my-instance-id";
  String tableId = "mobile-time-series";
  filterLimitValueRange(projectId, instanceId, tableId);
}

public static void filterLimitValueRange(String projectId, String instanceId, String tableId) {
  // A filter that matches cells whose values are between the given values
  Filter filter = FILTERS.value().range().startClosed("PQ2A.190405").endClosed("PQ2A.190406");
  readFilter(projectId, instanceId, tableId, filter);
}

Python

def filter_limit_value_range(project_id, instance_id, table_id):
    client = bigtable.Client(project=project_id, admin=True)
    instance = client.instance(instance_id)
    table = instance.table(table_id)

    rows = table.read_rows(
        filter_=row_filters.ValueRangeFilter(b"PQ2A.190405", b"PQ2A.190406"))

    for row in rows:
        print_row(row)

C#

/// <summary>
/// /// Read using a value range filter from an existing table.
///</summary>
/// <param name="projectId">Your Google Cloud Project ID.</param>
/// <param name="instanceId">Your Google Cloud Bigtable Instance ID.</param>
/// <param name="tableId">Your Google Cloud Bigtable table ID.</param>

public string filterLimitValueRange(string projectId = "YOUR-PROJECT-ID", string instanceId = "YOUR-INSTANCE-ID", string tableId = "YOUR-TABLE-ID")
{
    // A filter that matches cells whose values are between the given values
    RowFilter filter = RowFilters.ValueRange(ValueRange.Closed("PQ2A.190405", "PQ2A.190406"));
    return readFilter(projectId, instanceId, tableId, filter);
}

C++

Dieses Codebeispiel ist demnächst verfügbar.

Node.js

const filter = {
  value: {
    start: 'PQ2A.190405',
    end: 'PQ2A.190406',
  },
};
readWithFilter(filter);

PHP

$filter = Filter::value()
    ->range()
    ->startClosed("PQ2A.190405")
    ->endOpen("PQ2A.190406");
read_filter($table, $filter);

Ruby

range = Google::Cloud::Bigtable::ValueRange.new.from("PQ2A.190405").to("PQ2A.190406")
filter = Google::Cloud::Bigtable::RowFilter.value_range range
read_with_filter project_id, instance_id, table_id, filter

Wert-Regex

Dieser Filter schließt Zellen nur dann in die Ausgabezeile ein, wenn der Wert der Zelle mit einem regulären Ausdruck übereinstimmt.

Der reguläre Ausdruck muss die RE2-Syntax verwenden. Da Werte beliebige Bytes enthalten können, einschließlich Zeilenumbruchzeichen, sollten Sie in den meisten Fällen \C als Platzhalterausdruck verwenden. Der Ausdruck . gleicht Zeilenumbruchzeichen nicht ab.

Go

func filterLimitValueRegex(w io.Writer, projectID, instanceID string, tableName string) error {
	filter := bigtable.ValueFilter("PQ2A.*$")
	return readWithFilter(w, projectID, instanceID, tableName, filter)
}

HBase

public static void filterLimitValueRegex() {
  // TODO(developer): Replace these variables before running the sample.
  String projectId = "my-project-id";
  String instanceId = "my-instance-id";
  String tableId = "mobile-time-series";
  filterLimitValueRegex(projectId, instanceId, tableId);
}

public static void filterLimitValueRegex(String projectId, String instanceId, String tableId) {
  // A filter that matches cells whose value satisfies the given regex
  Filter filter = new ValueFilter(CompareOp.EQUAL, new RegexStringComparator("PQ2A.*$"));

  Scan scan = new Scan().setFilter(filter);
  readWithFilter(projectId, instanceId, tableId, scan);
}

Java

public static void filterLimitValueRegex() {
  // TODO(developer): Replace these variables before running the sample.
  String projectId = "my-project-id";
  String instanceId = "my-instance-id";
  String tableId = "mobile-time-series";
  filterLimitValueRegex(projectId, instanceId, tableId);
}

public static void filterLimitValueRegex(String projectId, String instanceId, String tableId) {
  // A filter that matches cells whose value satisfies the given regex
  Filter filter = FILTERS.value().regex("PQ2A.*$");
  readFilter(projectId, instanceId, tableId, filter);
}

Python



def filter_limit_value_regex(project_id, instance_id, table_id):
    client = bigtable.Client(project=project_id, admin=True)
    instance = client.instance(instance_id)
    table = instance.table(table_id)

    rows = table.read_rows(
        filter_=row_filters.ValueRegexFilter("PQ2A.*$".encode("utf-8")))
    for row in rows:
        print_row(row)

C#

/// <summary>
/// /// Read using a value regex filter from an existing table.
///</summary>
/// <param name="projectId">Your Google Cloud Project ID.</param>
/// <param name="instanceId">Your Google Cloud Bigtable Instance ID.</param>
/// <param name="tableId">Your Google Cloud Bigtable table ID.</param>

public string filterLimitValueRegex(string projectId = "YOUR-PROJECT-ID", string instanceId = "YOUR-INSTANCE-ID", string tableId = "YOUR-TABLE-ID")
{
    // A filter that matches cells whose value satisfies the given regex
    RowFilter filter = RowFilters.ValueRegex("PQ2A.*$");
    return readFilter(projectId, instanceId, tableId, filter);
}

C++

Dieses Codebeispiel ist demnächst verfügbar.

Node.js

const filter = {
  value: /PQ2A.*$/,
};
readWithFilter(filter);

PHP

$filter = Filter::value()->regex("PQ2A.*$");
read_filter($table, $filter);

Ruby

filter = Google::Cloud::Bigtable::RowFilter.value "PQ2A.*$"
read_with_filter project_id, instance_id, table_id, filter

Zeitstempelbereich

Dieser Filter schließt Zellen nur dann in die Ausgabezeile ein, wenn ihre Zeitstempel in einen bestimmten Bereich fallen. Zum Angeben des Bereichs stellen Sie eine (inklusive) Startzeit und eine (exklusive) Endzeit bereit. Die Standardeinheit ist Mikrosekunden und der Zeitstempel muss ein Vielfaches von 1.000 sein.

  • Wenn Sie Zellen abrufen möchten, deren Zeitstempel vor einem bestimmten Zeitpunkt liegen, geben Sie diesen Zeitpunkt als Endzeit an und lassen die Startzeit weg, um sie unbegrenzt zu lassen.
  • Wenn Sie Zellen abrufen möchten, deren Zeitstempel einem bestimmten Zeitpunkt entsprechen oder nach diesem liegen, geben Sie diesen Zeitpunkt als Startzeit an und lassen die Endzeit weg, um sie unbegrenzt zu lassen.

Go

func filterLimitTimestampRange(w io.Writer, projectID, instanceID string, tableName string) error {
	startTime := time.Unix(0, 0)
	endTime := time.Now().Add(-1 * time.Hour)
	filter := bigtable.TimestampRangeFilter(startTime, endTime)

	return readWithFilter(w, projectID, instanceID, tableName, filter)
}

HBase

public static void filterLimitTimestampRange() {
  // TODO(developer): Replace these variables before running the sample.
  String projectId = "my-project-id";
  String instanceId = "my-instance-id";
  String tableId = "mobile-time-series";
  filterLimitTimestampRange(projectId, instanceId, tableId);
}

public static void filterLimitTimestampRange(
    String projectId, String instanceId, String tableId) {
  // A filter that matches cells whose timestamp is from an hour ago or earlier
  // Get a time representing one hour ago
  long timestamp = Instant.now().minus(1, ChronoUnit.HOURS).toEpochMilli();
  try {
    Scan scan = new Scan().setTimeRange(0, timestamp).setMaxVersions();
    readWithFilter(projectId, instanceId, tableId, scan);
  } catch (IOException e) {
    System.out.println("There was an issue with your timestamp \n" + e.toString());
  }
}

Java

Hinweis: Die Methoden startOpen() und endClosed() werden derzeit nicht für Zeitstempelbereichsfilter in dieser Clientbibliothek unterstützt.

public static void filterLimitTimestampRange() {
  // TODO(developer): Replace these variables before running the sample.
  String projectId = "my-project-id";
  String instanceId = "my-instance-id";
  String tableId = "mobile-time-series";
  filterLimitTimestampRange(projectId, instanceId, tableId);
}

public static void filterLimitTimestampRange(
    String projectId, String instanceId, String tableId) {
  // Get a time representing one hour ago
  long timestamp = Instant.now().minus(1, ChronoUnit.HOURS).toEpochMilli() * 1000;

  // A filter that matches cells whose timestamp is from an hour ago or earlier
  Filter filter = FILTERS.timestamp().range().startClosed(0L).endOpen(timestamp);
  readFilter(projectId, instanceId, tableId, filter);
}

Python

def filter_limit_timestamp_range(project_id, instance_id, table_id):
    client = bigtable.Client(project=project_id, admin=True)
    instance = client.instance(instance_id)
    table = instance.table(table_id)

    end = datetime.datetime(2019, 5, 1)

    rows = table.read_rows(
        filter_=row_filters.TimestampRangeFilter(
            row_filters.TimestampRange(end=end)))
    for row in rows:
        print_row(row)

C#

    /// <summary>
    /// /// Read using a timestamp range filter from an existing table.
    ///</summary>
    /// <param name="projectId">Your Google Cloud Project ID.</param>
    /// <param name="instanceId">Your Google Cloud Bigtable Instance ID.</param>
    /// <param name="tableId">Your Google Cloud Bigtable table ID.</param>

    public string filterLimitTimestampRange(
String projectId, String instanceId, String tableId)
    {
        BigtableVersion timestamp_minus_hr = new BigtableVersion(new DateTime(2020, 1, 10, 13, 0, 0, DateTimeKind.Utc));

        // A filter that matches cells whose timestamp is from an hour ago or earlier
        RowFilter filter = RowFilters.TimestampRange(new DateTime(0), timestamp_minus_hr.ToDateTime());
        return readFilter(projectId, instanceId, tableId, filter);
    }

C++

Dieses Codebeispiel ist demnächst verfügbar.

Node.js

const start = 0;
const end = new Date(2019, 5, 1);
end.setUTCHours(0);
const filter = {
  time: {
    start,
    end,
  },
};
readWithFilter(filter);

PHP

$start = 0;
$end = (time() - 60 * 60) * 1000 * 1000;
$filter = Filter::timestamp()
    ->range()
    ->startClosed($start)
    ->endOpen($end);
read_filter($table, $filter);

Ruby

timestamp_minus_hr = (Time.now.to_f * 1_000_000).round(-3) - 60 * 60 * 1000 * 1000
puts timestamp_minus_hr
filter = Google::Cloud::Bigtable::RowFilter.timestamp_range from: 0, to: timestamp_minus_hr

read_with_filter project_id, instance_id, table_id, filter

Erweiterte Einzelfilter

Die Verwendung der folgenden Filter kann sich schwierig gestalten.

Alle blockieren

Dieser Filter entfernt alle Zellen aus der Ausgabezeile.

Wenn Sie einen Interleave-Filter verwenden, können Sie den Filter "Alle blockieren" mit dem Kettenfilter kombinieren, um einen Teil des Interleaves vorübergehend zu deaktivieren.

Go

func filterLimitBlockAll(w io.Writer, projectID, instanceID string, tableName string) error {
	filter := bigtable.BlockAllFilter()
	return readWithFilter(w, projectID, instanceID, tableName, filter)
}

HBase

public static void filterLimitBlockAll() {
  // TODO(developer): Replace these variables before running the sample.
  String projectId = "my-project-id";
  String instanceId = "my-instance-id";
  String tableId = "mobile-time-series";
  filterLimitBlockAll(projectId, instanceId, tableId);
}

public static void filterLimitBlockAll(String projectId, String instanceId, String tableId) {
  // A filter that does not match any cells
  Filter filter = new SkipFilter(new RandomRowFilter(1));
  Scan scan = new Scan().setFilter(filter);
  readWithFilter(projectId, instanceId, tableId, scan);
}

Java

public static void filterLimitBlockAll() {
  // TODO(developer): Replace these variables before running the sample.
  String projectId = "my-project-id";
  String instanceId = "my-instance-id";
  String tableId = "mobile-time-series";
  filterLimitBlockAll(projectId, instanceId, tableId);
}

public static void filterLimitBlockAll(String projectId, String instanceId, String tableId) {
  // A filter that does not match any cells
  Filter filter = FILTERS.block();
  readFilter(projectId, instanceId, tableId, filter);
}

Python

def filter_limit_block_all(project_id, instance_id, table_id):
    client = bigtable.Client(project=project_id, admin=True)
    instance = client.instance(instance_id)
    table = instance.table(table_id)

    rows = table.read_rows(filter_=row_filters.BlockAllFilter(True))
    for row in rows:
        print_row(row)

C#

/// <summary>
/// /// Read using a block all filter from an existing table.
///</summary>
/// <param name="projectId">Your Google Cloud Project ID.</param>
/// <param name="instanceId">Your Google Cloud Bigtable Instance ID.</param>
/// <param name="tableId">Your Google Cloud Bigtable table ID.</param>

public string filterLimitBlockAll(string projectId = "YOUR-PROJECT-ID", string instanceId = "YOUR-INSTANCE-ID", string tableId = "YOUR-TABLE-ID")
{
    // A filter that does not match any cells
    RowFilter filter = RowFilters.BlockAllFilter();
    return readFilter(projectId, instanceId, tableId, filter);
}

C++

Dieses Codebeispiel ist demnächst verfügbar.

Node.js

const filter = {
  all: false,
};
readWithFilter(filter);

PHP

$filter = Filter::block();
read_filter($table, $filter);

Ruby

filter = Google::Cloud::Bigtable::RowFilter.block
read_with_filter project_id, instance_id, table_id, filter

Alle übergeben

Dieser Filter schließt alle Zellen der Eingabezeile in die Ausgabezeile ein. Er entspricht einem Lesevorgang ohne Filter.

Der Filter "Alle übergeben" kann nützlich sein, wenn Sie mehrere Filter kombinieren und Zellen in einigen Fällen ausgeben müssen, in anderen jedoch nicht.

Go

func filterLimitPassAll(w io.Writer, projectID, instanceID string, tableName string) error {
	filter := bigtable.PassAllFilter()
	return readWithFilter(w, projectID, instanceID, tableName, filter)
}

HBase

Diese Clientbibliothek unterstützt diesen Filter nicht.

Java

public static void filterLimitPassAll() {
  // TODO(developer): Replace these variables before running the sample.
  String projectId = "my-project-id";
  String instanceId = "my-instance-id";
  String tableId = "mobile-time-series";
  filterLimitPassAll(projectId, instanceId, tableId);
}

public static void filterLimitPassAll(String projectId, String instanceId, String tableId) {
  // A filter that matches all cells
  Filter filter = FILTERS.pass();
  readFilter(projectId, instanceId, tableId, filter);
}

Python

def filter_limit_pass_all(project_id, instance_id, table_id):
    client = bigtable.Client(project=project_id, admin=True)
    instance = client.instance(instance_id)
    table = instance.table(table_id)

    rows = table.read_rows(filter_=row_filters.PassAllFilter(True))
    for row in rows:
        print_row(row)

C#

/// <summary>
/// /// Read using a pass all filter from an existing table.
///</summary>
/// <param name="projectId">Your Google Cloud Project ID.</param>
/// <param name="instanceId">Your Google Cloud Bigtable Instance ID.</param>
/// <param name="tableId">Your Google Cloud Bigtable table ID.</param>

public string filterLimitPassAll(string projectId = "YOUR-PROJECT-ID", string instanceId = "YOUR-INSTANCE-ID", string tableId = "YOUR-TABLE-ID")
{
    // A filter that matches all cells
    RowFilter filter = RowFilters.PassAllFilter();
    return readFilter(projectId, instanceId, tableId, filter);
}

C++

Dieses Codebeispiel ist demnächst verfügbar.

Node.js

const filter = {
  all: true,
};
readWithFilter(filter);

PHP

$filter = Filter::pass();
read_filter($table, $filter);

Ruby

filter = Google::Cloud::Bigtable::RowFilter.pass
read_with_filter project_id, instance_id, table_id, filter

Senke

Dieser Filter kopiert alle Zellen der Eingabezeile in die endgültige Ausgabezeile, auch wenn diese Zellen normalerweise durch einen anderen Filter entfernt oder geändert würden.

Wenn Sie eine Kette von Filtern verwenden, können sich andere Begrenzungsfilter nur auf ihre eigene Ausgabezeile auswirken, die dann als Eingabezeile für den nächsten Filter in der Kette dient. Der Senkenfilter ist anders: Er fügt Zellen direkt in die endgültige Ausgabezeile ein, die in den Leseergebnissen angezeigt wird.

Angenommen, Sie erstellen eine Kette aus zwei Filtern:

  1. Dem Senkenfilter
  2. Dem Filter "Alle blockieren", der alle Zellen aus der Zeile löscht

Alleine würde der Filter "Alle blockieren" zu einer leeren Zeile führen, die nicht in den Leseergebnissen enthalten wäre. Der Senkenfilter erzwingt jedoch, dass alle Zellen aus der Eingabezeile in die endgültige Ausgabezeile kopiert werden, unabhängig davon, was andere Filter in der Kette bewirken könnten. Wenn Sie also den Senkenfilter und den Filter "Alle blockieren" kombinieren, ist das so, als würden Sie gar keinen Filter verwenden. Die ursprüngliche Eingabezeile wird dann mit allen ihren Zellen in den Leseergebnissen angezeigt.

Änderungsfilter

In den folgenden Abschnitten wird jeder Änderungsfilter beschrieben. Änderungsfilter wirken sich auf die Daten oder Metadaten einzelner Zellen aus.

Label anwenden

Dieser Filter fügt allen Zellen in einer Zeile ein Label hinzu. Verwenden Sie diesen Filter als Teil eines Interleaves, um anzugeben, durch welchen Filter eine Zelle in die Ausgabezeile eingeschlossen wurde. Die Anwendung kann das Label der jeweiligen Zelle verwenden, um zusätzliche clientseitige Verarbeitungsschritte auszuführen.

Die einzelnen Labels dürfen nicht länger als 15 Zeichen sein. Darüber hinaus muss jedes Label mit dem regulären RE2-Ausdruck [a-z0-9\\-]+ übereinstimmen.

Jede Zelle kann nur ein Label haben. Daher kann eine Kette von Filtern den Filter "Label anwenden" nur einmal enthalten.

Go

Diese Clientbibliothek unterstützt diesen Filter nicht.

HBase

Diese Clientbibliothek unterstützt diesen Filter nicht.

Java

public static void filterModifyApplyLabel() {
  // TODO(developer): Replace these variables before running the sample.
  String projectId = "my-project-id";
  String instanceId = "my-instance-id";
  String tableId = "mobile-time-series";
  filterModifyApplyLabel(projectId, instanceId, tableId);
}

public static void filterModifyApplyLabel(String projectId, String instanceId, String tableId) {
  // A filter that applies the given label to the outputted cell
  Filter filter = FILTERS.label("labelled");
  readFilter(projectId, instanceId, tableId, filter);
}

Python

def filter_modify_apply_label(project_id, instance_id, table_id):
    client = bigtable.Client(project=project_id, admin=True)
    instance = client.instance(instance_id)
    table = instance.table(table_id)

    rows = table.read_rows(
        filter_=row_filters.ApplyLabelFilter(label="labelled"))
    for row in rows:
        print_row(row)

C#

/// <summary>
/// /// Read using a strip value filter from an existing table.
///</summary>
/// <param name="projectId">Your Google Cloud Project ID.</param>
/// <param name="instanceId">Your Google Cloud Bigtable Instance ID.</param>
/// <param name="tableId">Your Google Cloud Bigtable table ID.</param>

public string filterModifyApplyLabel(string projectId = "YOUR-PROJECT-ID", string instanceId = "YOUR-INSTANCE-ID", string tableId = "YOUR-TABLE-ID")
{
    // A filter that applies the given label to the outputted cell
    RowFilter filter = new RowFilter { ApplyLabelTransformer = "labelled" };
    return readFilter(projectId, instanceId, tableId, filter);
}

C++

Dieses Codebeispiel ist demnächst verfügbar.

Node.js

const filter = {
  label: 'labelled',
};
readWithFilter(filter);

PHP

$filter = Filter::label("labelled");
read_filter($table, $filter);

Ruby

filter = Google::Cloud::Bigtable::RowFilter.label "labelled"
read_with_filter project_id, instance_id, table_id, filter

Wert entfernen

Dieser Filter ersetzt den Wert jeder Zelle durch einen leeren String. Verwenden Sie diesen Filter, wenn Sie nur die Anzahl der Zeilen oder Zellen zählen müssen, die Ihren Kriterien entsprechen, anstatt alle Daten aus diesen Zeilen oder Zellen abzurufen.

Go

func filterModifyStripValue(w io.Writer, projectID, instanceID string, tableName string) error {
	filter := bigtable.StripValueFilter()
	return readWithFilter(w, projectID, instanceID, tableName, filter)
}

HBase

Diese Clientbibliothek unterstützt diesen Filter nicht.

Java

public static void filterModifyStripValue() {
  // TODO(developer): Replace these variables before running the sample.
  String projectId = "my-project-id";
  String instanceId = "my-instance-id";
  String tableId = "mobile-time-series";
  filterModifyStripValue(projectId, instanceId, tableId);
}

public static void filterModifyStripValue(String projectId, String instanceId, String tableId) {
  // A filter that replaces the outputted cell value with the empty string
  Filter filter = FILTERS.value().strip();
  readFilter(projectId, instanceId, tableId, filter);
}

Python

def filter_modify_strip_value(project_id, instance_id, table_id):
    client = bigtable.Client(project=project_id, admin=True)
    instance = client.instance(instance_id)
    table = instance.table(table_id)

    rows = table.read_rows(
        filter_=row_filters.StripValueTransformerFilter(True))
    for row in rows:
        print_row(row)

C#

/// <summary>
/// /// Read using a strip value filter from an existing table.
///</summary>
/// <param name="projectId">Your Google Cloud Project ID.</param>
/// <param name="instanceId">Your Google Cloud Bigtable Instance ID.</param>
/// <param name="tableId">Your Google Cloud Bigtable table ID.</param>

public string filterModifyStripValue(string projectId = "YOUR-PROJECT-ID", string instanceId = "YOUR-INSTANCE-ID", string tableId = "YOUR-TABLE-ID")
{
    // A filter that replaces the outputted cell value with the empty string
    RowFilter filter = RowFilters.StripValueTransformer();
    return readFilter(projectId, instanceId, tableId, filter);
}

C++

Dieses Codebeispiel ist demnächst verfügbar.

Node.js

const filter = {
  value: {
    strip: true,
  },
};
readWithFilter(filter);

PHP

$filter = Filter::value()->strip();
read_filter($table, $filter);

Ruby

filter = Google::Cloud::Bigtable::RowFilter.strip_value
read_with_filter project_id, instance_id, table_id, filter

Kombinationsfilter

In den folgenden Abschnitten werden die verschiedenen Kombinationsfilter beschrieben. Mit Kombinationsfiltern können Sie mehrere Filter zu einem Filter zusammenfassen, sodass Sie mehrere Filter auf eine einzelne Leseanfrage anwenden können.

Kette

Dieser Filter wendet eine Reihe von Filtern nacheinander auf jede Ausgabezeile an. Ein Kettenfilter ist mit einem logischen UND vergleichbar.

Jeder Filter in der Kette sieht nur die Ausgabe des vorherigen Filters. Wenn Sie beispielsweise zwei Filter verketten und der erste Filter die Hälfte der Zellen aus der Ausgabezeile entfernt, hat der zweite Filter keinen Zugriff auf die entfernten Zellen.

Mit anderen Worten, die Reihenfolge der Filter ist wichtig. Wenn Sie die Reihenfolge der verketteten Filter ändern, werden in den Ausgabezeilen möglicherweise andere Daten angezeigt.

Go

func filterComposingChain(w io.Writer, projectID, instanceID string, tableName string) error {
	filter := bigtable.ChainFilters(bigtable.LatestNFilter(1), bigtable.FamilyFilter("cell_plan"))
	return readWithFilter(w, projectID, instanceID, tableName, filter)
}

HBase

public static void filterComposingChain() {
  // TODO(developer): Replace these variables before running the sample.
  String projectId = "my-project-id";
  String instanceId = "my-instance-id";
  String tableId = "mobile-time-series";
  filterComposingChain(projectId, instanceId, tableId);
}

public static void filterComposingChain(String projectId, String instanceId, String tableId) {
  // A filter that selects one cell per row AND within the column family cell_plan
  Filter familyFilter =
      new FamilyFilter(CompareOp.EQUAL, new BinaryComparator(Bytes.toBytes("cell_plan")));
  Filter columnCountGetFilter = new ColumnCountGetFilter(3);

  FilterList filter = new FilterList(FilterList.Operator.MUST_PASS_ALL);
  filter.addFilter(columnCountGetFilter);
  filter.addFilter(familyFilter);
  Scan scan = new Scan().setFilter(filter);
  readWithFilter(projectId, instanceId, tableId, scan);
}

Java

public static void filterComposingChain() {
  // TODO(developer): Replace these variables before running the sample.
  String projectId = "my-project-id";
  String instanceId = "my-instance-id";
  String tableId = "mobile-time-series";
  filterComposingChain(projectId, instanceId, tableId);
}

public static void filterComposingChain(String projectId, String instanceId, String tableId) {
  // A filter that selects one cell per column AND within the column family cell_plan
  Filter filter =
      FILTERS
          .chain()
          .filter(FILTERS.limit().cellsPerColumn(1))
          .filter(FILTERS.family().exactMatch("cell_plan"));
  readFilter(projectId, instanceId, tableId, filter);
}

Python

def filter_composing_chain(project_id, instance_id, table_id):
    client = bigtable.Client(project=project_id, admin=True)
    instance = client.instance(instance_id)
    table = instance.table(table_id)

    rows = table.read_rows(filter_=row_filters.RowFilterChain(
        filters=[row_filters.CellsColumnLimitFilter(1),
                 row_filters.FamilyNameRegexFilter("cell_plan")]))
    for row in rows:
        print_row(row)

C#

/// <summary>
/// /// Read using a chain filter from an existing table.
///</summary>
/// <param name="projectId">Your Google Cloud Project ID.</param>
/// <param name="instanceId">Your Google Cloud Bigtable Instance ID.</param>
/// <param name="tableId">Your Google Cloud Bigtable table ID.</param>

public string filterComposingChain(string projectId = "YOUR-PROJECT-ID", string instanceId = "YOUR-INSTANCE-ID", string tableId = "YOUR-TABLE-ID")
{
    // A filter that selects one cell per column AND within the column family cell_plan
    RowFilter filter = RowFilters.Chain(RowFilters.CellsPerColumnLimit(1), RowFilters.FamilyNameExact("cell_plan"));
    return readFilter(projectId, instanceId, tableId, filter);
}

C++

Dieses Codebeispiel ist demnächst verfügbar.

Node.js

const filter = [
  {
    column: {
      cellLimit: 1,
    },
  },
  {
    family: 'cell_plan',
  },
];
readWithFilter(filter);

PHP

$filter = Filter::chain()
    ->addFilter(Filter::limit()->cellsPerColumn(1))
    ->addFilter(Filter::family()->exactMatch("cell_plan"));
read_filter($table, $filter);

Ruby

filter = Google::Cloud::Bigtable::RowFilter.chain.cells_per_column(1).family("cell_plan")
read_with_filter project_id, instance_id, table_id, filter

Interleave

Dieser Filter schickt die Eingabezeile durch mehrere Komponentenfilter, wobei von jedem Komponentenfilter eine temporäre Ausgabezeile generiert wird. Alle Zellen aus den temporären Ausgabezeilen werden dann zu einer endgültigen Ausgabezeile zusammengefasst. Ein Interleave-Filter ist mit einem logischen ODER vergleichbar.

Interleaves können zu doppelten Zellen in der Ausgabezeile führen. Wenn das Interleave beispielsweise zwei Filter umfasst und beide Filter eine bestimmte Zelle in ihren temporären Ausgabezeilen enthalten, sind in der endgültigen Ausgabezeile zwei Kopien dieser Zelle zu finden.

Wenn die Komponentenfilter mehrere Zellen ausgeben, die alle dieselbe Spaltenfamilie, denselben Spaltenqualifizierer und denselben Zeitstempel haben, werden diese Zellen in der endgültigen Ausgabezeile in einer nicht spezifizierten Reihenfolge zusammengefasst.

Go

func filterComposingInterleave(w io.Writer, projectID, instanceID string, tableName string) error {
	filter := bigtable.InterleaveFilters(bigtable.ValueFilter("true"), bigtable.ColumnFilter("os_build"))
	return readWithFilter(w, projectID, instanceID, tableName, filter)
}

HBase

public static void filterComposingInterleave() {
  // TODO(developer): Replace these variables before running the sample.
  String projectId = "my-project-id";
  String instanceId = "my-instance-id";
  String tableId = "mobile-time-series";
  filterComposingInterleave(projectId, instanceId, tableId);
}

public static void filterComposingInterleave(
    String projectId, String instanceId, String tableId) {
  // A filter that matches cells with the value true OR with the column qualifier os_build
  Filter qualifierFilter =
      new QualifierFilter(CompareOp.EQUAL, new BinaryComparator(Bytes.toBytes("os_build")));
  Filter valueFilter =
      new ValueFilter(CompareOp.EQUAL, new BinaryComparator(Bytes.toBytes("true")));

  FilterList filter = new FilterList(Operator.MUST_PASS_ONE);
  filter.addFilter(qualifierFilter);
  filter.addFilter(valueFilter);

  Scan scan = new Scan().setFilter(filter).setMaxVersions();
  readWithFilter(projectId, instanceId, tableId, scan);
}

Java

public static void filterComposingInterleave() {
  // TODO(developer): Replace these variables before running the sample.
  String projectId = "my-project-id";
  String instanceId = "my-instance-id";
  String tableId = "mobile-time-series";
  filterComposingInterleave(projectId, instanceId, tableId);
}

public static void filterComposingInterleave(
    String projectId, String instanceId, String tableId) {
  // A filter that matches cells with the value true OR with the column qualifier os_build
  Filter filter =
      FILTERS
          .interleave()
          .filter(FILTERS.value().exactMatch("true"))
          .filter(FILTERS.qualifier().exactMatch("os_build"));
  readFilter(projectId, instanceId, tableId, filter);
}

Python

def filter_composing_interleave(project_id, instance_id, table_id):
    client = bigtable.Client(project=project_id, admin=True)
    instance = client.instance(instance_id)
    table = instance.table(table_id)

    rows = table.read_rows(filter_=row_filters.RowFilterUnion(
        filters=[row_filters.ValueRegexFilter("true"),
                 row_filters.ColumnQualifierRegexFilter("os_build")]))
    for row in rows:
        print_row(row)

C#

    /// <summary>
    /// /// Read using an interleave filter from an existing table.
    ///</summary>
    /// <param name="projectId">Your Google Cloud Project ID.</param>
    /// <param name="instanceId">Your Google Cloud Bigtable Instance ID.</param>
    /// <param name="tableId">Your Google Cloud Bigtable table ID.</param>

    public string filterComposingInterleave(
String projectId, String instanceId, String tableId)
    {
        // A filter that matches cells with the value true OR with the column qualifier os_build
        RowFilter filter = RowFilters.Interleave(RowFilters.ValueExact("true"), RowFilters.ColumnQualifierExact("os_build"));
        return readFilter(projectId, instanceId, tableId, filter);
    }

C++

Dieses Codebeispiel ist demnächst verfügbar.

Node.js

const filter = {
  interleave: [
    {
      value: 'true',
    },
    {column: 'os_build'},
  ],
};
readWithFilter(filter);

PHP

$filter = Filter::interleave()
    ->addFilter(Filter::value()->exactMatch(unpack('C*', 1)))
    ->addFilter(Filter::qualifier()->exactMatch("os_build"));
read_filter($table, $filter);

Ruby

filter = Google::Cloud::Bigtable::RowFilter.interleave.value("true").qualifier("os_build")
read_with_filter project_id, instance_id, table_id, filter

Bedingung

Dieser Filter wendet entweder einen True-Filter oder einen False-Filter auf die Eingabezeile an.

Zur Auswahl zwischen den True- und False-Filtern wird ein Prädikatfilter auf die Eingabezeile angewendet. Wenn die Ausgabe des Prädikatfilters mindestens eine Zelle enthält, wird der True-Filter angewendet. Wenn die Ausgabe des Prädikatfilters leer ist, wird der False-Filter angewendet.

Die Ausgabezeile des Prädikatfilters wird nur verwendet, um zwischen den True- und False-Filtern auszuwählen. Sie wird nicht in der Antwort auf die Leseanfrage angezeigt.

Der Prädikatfilter wird nicht atomar mit dem True- oder False-Filter ausgeführt. Mit anderen Worten, die Daten in der Eingabezeile können sich zwischen dem Zeitpunkt, an dem der Prädikatfilter ausgeführt wird, und dem Zeitpunkt, an dem der True- oder False-Filter ausgeführt wird, ändern. Dieses Verhalten kann zu inkonsistenten oder unerwarteten Ergebnissen führen.

Wenn Sie den Bedingungsfilter verwenden, können Sie den True- oder False-Filter weglassen. Das Weglassen eines Filters entspricht der Angabe des Filters "Alle blockieren". Wenn der Prädikatfilter eine Bedingung auswählt, die Sie weggelassen haben, ist die Ausgabezeile leer.

Go

func filterComposingCondition(w io.Writer, projectID, instanceID string, tableName string) error {
	filter := bigtable.ConditionFilter(
		bigtable.ChainFilters(bigtable.ColumnFilter("data_plan_10gb"), bigtable.ValueFilter("true")),
		bigtable.StripValueFilter(),
		bigtable.PassAllFilter())
	return readWithFilter(w, projectID, instanceID, tableName, filter)
}

HBase

Diese Clientbibliothek unterstützt diesen Filter nicht.

Java

public static void filterComposingCondition() {
  // TODO(developer): Replace these variables before running the sample.
  String projectId = "my-project-id";
  String instanceId = "my-instance-id";
  String tableId = "mobile-time-series";
  filterComposingCondition(projectId, instanceId, tableId);
}

public static void filterComposingCondition(String projectId, String instanceId, String tableId) {
  // A filter that applies the label passed-filter IF the cell has the column qualifier
  // data_plan_10gb AND the value true, OTHERWISE applies the label filtered-out
  Filter filter =
      FILTERS
          .condition(
              FILTERS
                  .chain()
                  .filter(FILTERS.qualifier().exactMatch("data_plan_10gb"))
                  .filter(FILTERS.value().exactMatch("true")))
          .then(FILTERS.label("passed-filter"))
          .otherwise(FILTERS.label("filtered-out"));
  readFilter(projectId, instanceId, tableId, filter);
}

Python

def filter_composing_condition(project_id, instance_id, table_id):
    client = bigtable.Client(project=project_id, admin=True)
    instance = client.instance(instance_id)
    table = instance.table(table_id)

    rows = table.read_rows(filter_=row_filters.ConditionalRowFilter(
        base_filter=row_filters.RowFilterChain(filters=[
            row_filters.ColumnQualifierRegexFilter(
                "data_plan_10gb"),
            row_filters.ValueRegexFilter(
                "true")]),
        true_filter=row_filters.ApplyLabelFilter(label="passed-filter"),
        false_filter=row_filters.ApplyLabelFilter(label="filtered-out")

    ))
    for row in rows:
        print_row(row)

C#

/// <summary>
/// /// Read using a conditional filter from an existing table.
///</summary>
/// <param name="projectId">Your Google Cloud Project ID.</param>
/// <param name="instanceId">Your Google Cloud Bigtable Instance ID.</param>
/// <param name="tableId">Your Google Cloud Bigtable table ID.</param>

public string filterComposingCondition(string projectId = "YOUR-PROJECT-ID", string instanceId = "YOUR-INSTANCE-ID", string tableId = "YOUR-TABLE-ID")
{
    // A filter that applies the label passed-filter IF the cell has the column qualifier
    // data_plan_10gb AND the value true, OTHERWISE applies the label filtered-out
    RowFilter filter = RowFilters.Condition(
        RowFilters.Chain(RowFilters.ColumnQualifierExact("data_plan_10gb"), RowFilters.ValueExact("true")),
        new RowFilter { ApplyLabelTransformer = "passed-filter" },
        new RowFilter { ApplyLabelTransformer = "filtered-out" }
        );
    return readFilter(projectId, instanceId, tableId, filter);
}

C++

Dieses Codebeispiel ist demnächst verfügbar.

Node.js

const filter = {
  condition: {
    test: [
      {column: 'data_plan_10gb'},
      {
        value: 'true',
      },
    ],
    pass: {
      label: 'passed-filter',
    },
    fail: {
      label: 'filtered-out',
    },
  },
};
readWithFilter(filter);

PHP

$filter = Filter::condition(
    Filter::chain()
        ->addFilter(Filter::value()->exactMatch(unpack('C*', 1)))
        ->addFilter(Filter::qualifier()->exactMatch("data_plan_10gb"))
)
    ->then(Filter::label("passed-filter"))
    ->otherwise(Filter::label("filtered-out"));
read_filter($table, $filter);

Ruby

filter = Google::Cloud::Bigtable::RowFilter.condition(
  Google::Cloud::Bigtable::RowFilter.chain.qualifier("data_plan_10gb").value("true")
)
                                           .on_match(Google::Cloud::Bigtable::RowFilter.label("passed-filter"))
                                           .otherwise(Google::Cloud::Bigtable::RowFilter.label("filtered-out"))
read_with_filter project_id, instance_id, table_id, filter

Nächste Schritte