使用篩選器

Bigtable 提供下列類型的篩選器：

• 限制篩選器：控制回應中包含哪些資料列或儲存格。
• 修改篩選器，這會影響個別儲存格的資料或中繼資料。
• 組合篩選器：可將多個篩選器合併為一個。

本頁面詳細說明各個 Bigtable 篩選器，並介紹如何使用 Cloud 用戶端程式庫套用各類篩選器。閱讀本頁面之前，請先參閱「篩選器」。

注意：Java 適用的 HBase 用戶端會使用 HBase 的篩選器 API，而非 Bigtable Data API。如要瞭解 HBase 的篩選器 API，請參閱 HBase 說明文件。

如需更多範例，瞭解如何使用篩選器讀取多列資料，請參閱「讀取資料」。

警告：如果您未指定篩選器的資料列索引鍵或資料列範圍，篩選器會套用至完整資料表掃描中的所有資料列。資料列索引鍵規則運算式是例外狀況，如果規則運算式是固定前置字串，在某些情況下可以限制資料列範圍。

範例資料

本頁範例假設您儲存的是智慧型手機和平板電腦的時間序列資料，且下列資料已寫入資料表。資料表有兩個資料欄系列：stats_summary 和 cell_plan。每個資料欄系列都有三個資料欄。

	stats_summary			cell_plan
資料列索引鍵	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 one hour 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

限制篩選器

以下各節將說明各個限制篩選器。限制篩選器會根據資料列或儲存格是否符合特定條件，控制回應中包含哪些資料列或儲存格。

使用鏈結合併多個限制篩選器時，請注意，鏈結中每個篩選器的輸入資料列，都是鏈結中前一個篩選器的輸出資料列。舉例來說，如果您鏈結兩個篩選器，且第一個篩選器只輸出原始資料列中的兩個儲存格，則第二個篩選器只會看到這兩個儲存格。

資料列選取篩選器

本節說明可用於擷取資料表中資料列的篩選器。

資料列樣本

這個篩選器可讓您擷取指定範圍內的隨機資料列樣本。篩選器會根據您指定的機率，隨機選擇輸出資料列應與輸入資料列相同，還是應從結果中省略。

舉例來說，如果資料表有數百萬筆電話記錄，而您想檢查代表性子集，但不想讀取每一列，則可使用資料列樣本篩選器。

Go

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

HBase

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

def filter_limit_row_sample(project_id, instance_id, table_id):
    from google.cloud import bigtable
    from google.cloud.bigtable import row_filters

    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(0.75))
    for row in rows:
        print_row(row)

Python asyncio

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

async def filter_limit_row_sample(project_id, instance_id, table_id):
    from google.cloud.bigtable.data import (
        BigtableDataClientAsync,
        ReadRowsQuery,
        row_filters,
    )

    query = ReadRowsQuery(row_filter=row_filters.RowSampleFilter(0.75))

    async with BigtableDataClientAsync(project=project_id) as client:
        async with client.get_table(instance_id, table_id) as table:
            for row in await table.read_rows(query):
                print_row(row)

C#

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

/// <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 Task<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++

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

namespace cbt = ::google::cloud::bigtable;
using ::google::cloud::StatusOr;
[](cbt::Table table) {
  // Filter the results, only include rows with a given probability
  cbt::Filter filter = cbt::Filter::RowSample(0.75);

  // Read and print the rows.
  for (StatusOr<cbt::Row>& row :
       table.ReadRows(cbt::RowSet(cbt::RowRange::InfiniteRange()), filter)) {
    if (!row) throw std::move(row).status();
    std::cout << row->row_key() << " = ";
    for (auto const& cell : row->cells()) {
      std::cout << "[" << cell.family_name() << ", "
                << cell.column_qualifier() << ", " << cell.value() << "],";
    }
    std::cout << "\n";
  }
}

Node.js

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

PHP

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

use Google\Cloud\Bigtable\BigtableClient;
use Google\Cloud\Bigtable\Filter;

/**
 * Create a limiting filter on rows using a random sampling
 *
 * @param string $projectId The Google Cloud project ID
 * @param string $instanceId The ID of the Bigtable instance
 * @param string $tableId The ID of the table to read from
 */
function filter_limit_row_sample(
    string $projectId,
    string $instanceId,
    string $tableId
): void {
    // Connect to an existing table with an existing instance.
    $dataClient = new BigtableClient([
        'projectId' => $projectId,
    ]);
    $table = $dataClient->table($instanceId, $tableId);

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

    $rows = $table->readRows([
        'filter' => $filter
    ]);

    foreach ($rows as $key => $row) {
        // The "print_row" helper function is defined in https://cloud.google.com/bigtable/docs/samples/bigtable-reads-print
        print_row($key, $row);
    }
}

小茹

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

# instance_id = "my-instance"
# table_id    = "my-table"
filter = Google::Cloud::Bigtable::RowFilter.sample 0.75
read_with_filter instance_id, table_id, filter

資料列索引鍵規則運算式

這個篩選器會檢查輸入內容列的資料列索引鍵是否符合規則運算式。規則運算式必須使用 RE2 語法。資料列索引鍵可能含有任意位元組，因此請使用 \C 做為萬用字元運算式，而非使用 . 運算式來比對任何字元 (包括換行符號)。

為提升效能，Bigtable 會嘗試從規則運算式的開頭擷取常值前置字串，藉此最佳化篩選器。如果找到前置字串，Bigtable 會將搜尋範圍縮小至以該前置字串開頭的索引鍵範圍，避免完整掃描資料表。

這項最佳化作業只會在下列情況下執行：

• 前置字串只能包含英數字元和下列未逸出的符號：-、_、:、,。
• 前置字元擷取作業會在第一個未逸出且不在允許集合中的字元停止。舉例來說，常見的鍵分隔符 (例如雜湊 (#)) 或規則運算式中繼字元 (例如未逸出的句號 (.)) 會停止擷取。如要在最佳化前置字串中加入特殊字元，請使用反斜線 (\) 逸出，或使用 RE2 用戶端程式庫函式，例如 Java 中的 RE2.quoteMeta。
• 不支援管道字元 (|)。

如果規則運算式無法解析為常值前置字串 (例如以萬用字元開頭或搜尋子字串)，Bigtable 就需要完整掃描資料表。

下列程式碼範例使用規則運算式 .*#20190501$，擷取所有裝置上 2019 年 5 月 1 日的通話記錄。套用至範例資料集時，這個篩選器會傳回兩個相符資料列的所有儲存格：phone#4c410523#20190501 和 phone#5c10102#20190501。

Go

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

HBase

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

def filter_limit_row_regex(project_id, instance_id, table_id):
    from google.cloud import bigtable
    from google.cloud.bigtable import row_filters

    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)

Python asyncio

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

async def filter_limit_row_regex(project_id, instance_id, table_id):
    from google.cloud.bigtable.data import (
        BigtableDataClientAsync,
        ReadRowsQuery,
        row_filters,
    )

    query = ReadRowsQuery(
        row_filter=row_filters.RowKeyRegexFilter(".*#20190501$".encode("utf-8"))
    )

    async with BigtableDataClientAsync(project=project_id) as client:
        async with client.get_table(instance_id, table_id) as table:
            for row in await table.read_rows(query):
                print_row(row)

C#

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

/// <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 Task<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++

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

namespace cbt = ::google::cloud::bigtable;
using ::google::cloud::StatusOr;
[](cbt::Table table) {
  // Filter the results, only include rows where row_key matches given regular
  // expression
  cbt::Filter filter = cbt::Filter::RowKeysRegex(".*#20190501$");
  // Read and print the rows.
  for (StatusOr<cbt::Row>& row :
       table.ReadRows(cbt::RowSet(cbt::RowRange::InfiniteRange()), filter)) {
    if (!row) throw std::move(row).status();
    std::cout << row->row_key() << " = ";
    for (auto const& cell : row->cells()) {
      std::cout << "[" << cell.family_name() << ", "
                << cell.column_qualifier() << ", " << cell.value() << "],";
    }
    std::cout << "\n";
  }
}

Node.js

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

PHP

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

use Google\Cloud\Bigtable\BigtableClient;
use Google\Cloud\Bigtable\Filter;

/**
 * Create a limiting filter on a cell value using a regex
 *
 * @param string $projectId The Google Cloud project ID
 * @param string $instanceId The ID of the Bigtable instance
 * @param string $tableId The ID of the table to read from
 */
function filter_limit_row_regex(
    string $projectId,
    string $instanceId,
    string $tableId
): void {
    // Connect to an existing table with an existing instance.
    $dataClient = new BigtableClient([
        'projectId' => $projectId,
    ]);
    $table = $dataClient->table($instanceId, $tableId);

    $filter = Filter::key()->regex('.*#20190501$');

    $rows = $table->readRows([
        'filter' => $filter
    ]);

    foreach ($rows as $key => $row) {
        // The "print_row" helper function is defined in https://cloud.google.com/bigtable/docs/samples/bigtable-reads-print
        print_row($key, $row);
    }
}

小茹

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

# instance_id = "my-instance"
# table_id    = "my-table"
filter = Google::Cloud::Bigtable::RowFilter.key ".*#20190501$"
read_with_filter instance_id, table_id, filter

儲存格選取篩選器

本節說明可用於擷取資料表儲存格的篩選器。

每個資料欄的儲存格數量上限

這項篩選器會限制輸出資料列中各欄包含的儲存格數量。套用這個篩選器後，每個輸出資料列都會包含各資料欄中最新的 N 個儲存格，並省略該資料欄中的所有其他儲存格。

如果您也使用交錯篩選器，且交錯篩選器產生儲存格的重複副本，則每個副本都會計入限制。

如果資料欄儲存了帶有時間戳記的值記錄 (例如裝置數據方案的變更)，而您只想讀取最新值，這個篩選器就非常實用。下列程式碼範例會將每個資料欄限制為最近的兩個儲存格。範例資料集會傳回下列儲存格，如果存在兩個以上的儲存格，則會省略任何較舊的儲存格：

• 第 phone#4c410523#20190501 列 cell_plan:data_plan_01gb 欄中兩個有時間戳記的儲存格 (false@time 和 true@time minus one hour)

• 其他已填入資料的各欄中的單一儲存格

Go

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

HBase

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

def filter_limit_cells_per_col(project_id, instance_id, table_id):
    from google.cloud import bigtable
    from google.cloud.bigtable import row_filters

    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)

Python asyncio

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

# Copyright 2024, Google LLC
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.


async def filter_limit_row_sample(project_id, instance_id, table_id):
    from google.cloud.bigtable.data import (
        BigtableDataClientAsync,
        ReadRowsQuery,
        row_filters,
    )

    query = ReadRowsQuery(row_filter=row_filters.RowSampleFilter(0.75))

    async with BigtableDataClientAsync(project=project_id) as client:
        async with client.get_table(instance_id, table_id) as table:
            for row in await table.read_rows(query):
                print_row(row)


async def filter_limit_row_regex(project_id, instance_id, table_id):
    from google.cloud.bigtable.data import (
        BigtableDataClientAsync,
        ReadRowsQuery,
        row_filters,
    )

    query = ReadRowsQuery(
        row_filter=row_filters.RowKeyRegexFilter(".*#20190501$".encode("utf-8"))
    )

    async with BigtableDataClientAsync(project=project_id) as client:
        async with client.get_table(instance_id, table_id) as table:
            for row in await table.read_rows(query):
                print_row(row)


async def filter_limit_cells_per_col(project_id, instance_id, table_id):
    from google.cloud.bigtable.data import (
        BigtableDataClientAsync,
        ReadRowsQuery,
        row_filters,
    )

    query = ReadRowsQuery(row_filter=row_filters.CellsColumnLimitFilter(2))

    async with BigtableDataClientAsync(project=project_id) as client:
        async with client.get_table(instance_id, table_id) as table:
            for row in await table.read_rows(query):
                print_row(row)


async def filter_limit_cells_per_row(project_id, instance_id, table_id):
    from google.cloud.bigtable.data import (
        BigtableDataClientAsync,
        ReadRowsQuery,
        row_filters,
    )

    query = ReadRowsQuery(row_filter=row_filters.CellsRowLimitFilter(2))

    async with BigtableDataClientAsync(project=project_id) as client:
        async with client.get_table(instance_id, table_id) as table:
            for row in await table.read_rows(query):
                print_row(row)


async def filter_limit_cells_per_row_offset(project_id, instance_id, table_id):
    from google.cloud.bigtable.data import (
        BigtableDataClientAsync,
        ReadRowsQuery,
        row_filters,
    )

    query = ReadRowsQuery(row_filter=row_filters.CellsRowOffsetFilter(2))

    async with BigtableDataClientAsync(project=project_id) as client:
        async with client.get_table(instance_id, table_id) as table:
            for row in await table.read_rows(query):
                print_row(row)


async def filter_limit_col_family_regex(project_id, instance_id, table_id):
    from google.cloud.bigtable.data import (
        BigtableDataClientAsync,
        ReadRowsQuery,
        row_filters,
    )

    query = ReadRowsQuery(
        row_filter=row_filters.FamilyNameRegexFilter("stats_.*$".encode("utf-8"))
    )

    async with BigtableDataClientAsync(project=project_id) as client:
        async with client.get_table(instance_id, table_id) as table:
            for row in await table.read_rows(query):
                print_row(row)


async def filter_limit_col_qualifier_regex(project_id, instance_id, table_id):
    from google.cloud.bigtable.data import (
        BigtableDataClientAsync,
        ReadRowsQuery,
        row_filters,
    )

    query = ReadRowsQuery(
        row_filter=row_filters.ColumnQualifierRegexFilter(
            "connected_.*$".encode("utf-8")
        )
    )

    async with BigtableDataClientAsync(project=project_id) as client:
        async with client.get_table(instance_id, table_id) as table:
            for row in await table.read_rows(query):
                print_row(row)


async def filter_limit_col_range(project_id, instance_id, table_id):
    from google.cloud.bigtable.data import (
        BigtableDataClientAsync,
        ReadRowsQuery,
        row_filters,
    )

    query = ReadRowsQuery(
        row_filter=row_filters.ColumnRangeFilter(
            "cell_plan", b"data_plan_01gb", b"data_plan_10gb", inclusive_end=False
        )
    )

    async with BigtableDataClientAsync(project=project_id) as client:
        async with client.get_table(instance_id, table_id) as table:
            for row in await table.read_rows(query):
                print_row(row)


async def filter_limit_value_range(project_id, instance_id, table_id):
    from google.cloud.bigtable.data import (
        BigtableDataClientAsync,
        ReadRowsQuery,
        row_filters,
    )

    query = ReadRowsQuery(
        row_filter=row_filters.ValueRangeFilter(b"PQ2A.190405", b"PQ2A.190406")
    )

    async with BigtableDataClientAsync(project=project_id) as client:
        async with client.get_table(instance_id, table_id) as table:
            for row in await table.read_rows(query):
                print_row(row)




async def filter_limit_value_regex(project_id, instance_id, table_id):
    from google.cloud.bigtable.data import (
        BigtableDataClientAsync,
        ReadRowsQuery,
        row_filters,
    )

    query = ReadRowsQuery(
        row_filter=row_filters.ValueRegexFilter("PQ2A.*$".encode("utf-8"))
    )

    async with BigtableDataClientAsync(project=project_id) as client:
        async with client.get_table(instance_id, table_id) as table:
            for row in await table.read_rows(query):
                print_row(row)


async def filter_limit_timestamp_range(project_id, instance_id, table_id):
    import datetime

    from google.cloud.bigtable.data import (
        BigtableDataClientAsync,
        ReadRowsQuery,
        row_filters,
    )

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

    query = ReadRowsQuery(row_filter=row_filters.TimestampRangeFilter(end=end))

    async with BigtableDataClientAsync(project=project_id) as client:
        async with client.get_table(instance_id, table_id) as table:
            for row in await table.read_rows(query):
                print_row(row)


async def filter_limit_block_all(project_id, instance_id, table_id):
    from google.cloud.bigtable.data import (
        BigtableDataClientAsync,
        ReadRowsQuery,
        row_filters,
    )

    query = ReadRowsQuery(row_filter=row_filters.BlockAllFilter(True))

    async with BigtableDataClientAsync(project=project_id) as client:
        async with client.get_table(instance_id, table_id) as table:
            for row in await table.read_rows(query):
                print_row(row)


async def filter_limit_pass_all(project_id, instance_id, table_id):
    from google.cloud.bigtable.data import (
        BigtableDataClientAsync,
        ReadRowsQuery,
        row_filters,
    )

    query = ReadRowsQuery(row_filter=row_filters.PassAllFilter(True))

    async with BigtableDataClientAsync(project=project_id) as client:
        async with client.get_table(instance_id, table_id) as table:
            for row in await table.read_rows(query):
                print_row(row)


async def filter_modify_strip_value(project_id, instance_id, table_id):
    from google.cloud.bigtable.data import (
        BigtableDataClientAsync,
        ReadRowsQuery,
        row_filters,
    )

    query = ReadRowsQuery(row_filter=row_filters.StripValueTransformerFilter(True))

    async with BigtableDataClientAsync(project=project_id) as client:
        async with client.get_table(instance_id, table_id) as table:
            for row in await table.read_rows(query):
                print_row(row)


async def filter_modify_apply_label(project_id, instance_id, table_id):
    from google.cloud.bigtable.data import (
        BigtableDataClientAsync,
        ReadRowsQuery,
        row_filters,
    )

    query = ReadRowsQuery(row_filter=row_filters.ApplyLabelFilter(label="labelled"))

    async with BigtableDataClientAsync(project=project_id) as client:
        async with client.get_table(instance_id, table_id) as table:
            for row in await table.read_rows(query):
                print_row(row)


async def filter_composing_chain(project_id, instance_id, table_id):
    from google.cloud.bigtable.data import (
        BigtableDataClientAsync,
        ReadRowsQuery,
        row_filters,
    )

    query = ReadRowsQuery(
        row_filter=row_filters.RowFilterChain(
            filters=[
                row_filters.CellsColumnLimitFilter(1),
                row_filters.FamilyNameRegexFilter("cell_plan"),
            ]
        )
    )

    async with BigtableDataClientAsync(project=project_id) as client:
        async with client.get_table(instance_id, table_id) as table:
            for row in await table.read_rows(query):
                print_row(row)


async def filter_composing_interleave(project_id, instance_id, table_id):
    from google.cloud.bigtable.data import (
        BigtableDataClientAsync,
        ReadRowsQuery,
        row_filters,
    )

    query = ReadRowsQuery(
        row_filter=row_filters.RowFilterUnion(
            filters=[
                row_filters.ValueRegexFilter("true"),
                row_filters.ColumnQualifierRegexFilter("os_build"),
            ]
        )
    )

    async with BigtableDataClientAsync(project=project_id) as client:
        async with client.get_table(instance_id, table_id) as table:
            for row in await table.read_rows(query):
                print_row(row)


async def filter_composing_condition(project_id, instance_id, table_id):
    from google.cloud.bigtable.data import (
        BigtableDataClientAsync,
        ReadRowsQuery,
        row_filters,
    )

    query = ReadRowsQuery(
        row_filter=row_filters.ConditionalRowFilter(
            predicate_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"),
        )
    )

    async with BigtableDataClientAsync(project=project_id) as client:
        async with client.get_table(instance_id, table_id) as table:
            for row in await table.read_rows(query):
                print_row(row)




def print_row(row):
    from google.cloud._helpers import _datetime_from_microseconds

    print("Reading data for {}:".format(row.row_key.decode("utf-8")))
    last_family = None
    for cell in row.cells:
        if last_family != cell.family:
            print("Column Family {}".format(cell.family))
            last_family = cell.family

        labels = " [{}]".format(",".join(cell.labels)) if len(cell.labels) else ""
        print(
            "\t{}: {} @{}{}".format(
                cell.qualifier.decode("utf-8"),
                cell.value.decode("utf-8"),
                _datetime_from_microseconds(cell.timestamp_micros),
                labels,
            )
        )
    print("")

C#

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

/// <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 Task<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++

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

namespace cbt = ::google::cloud::bigtable;
using ::google::cloud::StatusOr;
[](cbt::Table table) {
  // Filter the results, only include limited cells
  cbt::Filter filter = cbt::Filter::Latest(2);
  // Read and print the rows.
  for (StatusOr<cbt::Row>& row :
       table.ReadRows(cbt::RowSet(cbt::RowRange::InfiniteRange()), filter)) {
    if (!row) throw std::move(row).status();
    std::cout << row->row_key() << " = ";
    for (auto const& cell : row->cells()) {
      std::cout << "[" << cell.family_name() << ", "
                << cell.column_qualifier() << ", " << cell.value() << "],";
    }
    std::cout << "\n";
  }
}

Node.js

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

PHP

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

use Google\Cloud\Bigtable\BigtableClient;
use Google\Cloud\Bigtable\Filter;

/**
 * Create a limiting filter on cells per column
 *
 * @param string $projectId The Google Cloud project ID
 * @param string $instanceId The ID of the Bigtable instance
 * @param string $tableId The ID of the table to read from
 */
function filter_limit_cells_per_col(
    string $projectId,
    string $instanceId,
    string $tableId
): void {
    // Connect to an existing table with an existing instance.
    $dataClient = new BigtableClient([
        'projectId' => $projectId,
    ]);
    $table = $dataClient->table($instanceId, $tableId);

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

    $rows = $table->readRows([
        'filter' => $filter
    ]);

    foreach ($rows as $key => $row) {
        // The "print_row" helper function is defined in https://cloud.google.com/bigtable/docs/samples/bigtable-reads-print
        print_row($key, $row);
    }
}

小茹

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

# instance_id = "my-instance"
# table_id    = "my-table"
filter = Google::Cloud::Bigtable::RowFilter.cells_per_column 2
read_with_filter instance_id, table_id, filter

每列儲存格數量上限

這項篩選器會限制每個輸出資料列中的儲存格數量。套用這項篩選器後，每個輸出資料列都會包含輸入資料列的前 N 個儲存格，並省略該資料列後續的所有儲存格。無論儲存格位於哪一欄，系統都會按照儲存格在 Bigtable 中的儲存順序，讀取前 N 個儲存格。

如要進一步瞭解資料在 Bigtable 中的儲存方式，請參閱「結構定義設計最佳做法」。

一列中的一欄可以包含多個儲存格。每個儲存格都包含資料欄的值和專屬時間戳記。因此，將資料列限制為 N 個儲存格，可能與從資料列擷取前 N 個資料欄不同。舉例來說，如果您使用每列儲存格上限為 20 的篩選器，讀取含有 30 個資料欄的資料列，且每個資料欄都有 10 個時間戳記儲存格，則輸出資料列只會傳回資料列中前兩個資料欄的值 (2 * 10 = 20)。

注意：如果您也使用交錯篩選器，且交錯篩選器產生重複的儲存格，則每個副本都會計入限制。

如需讀取大型資料列，可搭配使用這個篩選器和偏移篩選器，以便進行分頁。

下列程式碼範例會將每個輸出資料列限制為前兩個儲存格，例如在對資料列進行分頁時擷取第一頁儲存格。套用至範例資料集時，這個篩選器會傳回五個資料列中，每個資料列的前兩個儲存格。如要擷取下一頁的儲存格，請將這個篩選器與每列儲存格偏移篩選器搭配使用。

Go

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

HBase

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

def filter_limit_cells_per_row(project_id, instance_id, table_id):
    from google.cloud import bigtable
    from google.cloud.bigtable import row_filters

    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)

Python asyncio

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

async def filter_limit_cells_per_row(project_id, instance_id, table_id):
    from google.cloud.bigtable.data import (
        BigtableDataClientAsync,
        ReadRowsQuery,
        row_filters,
    )

    query = ReadRowsQuery(row_filter=row_filters.CellsRowLimitFilter(2))

    async with BigtableDataClientAsync(project=project_id) as client:
        async with client.get_table(instance_id, table_id) as table:
            for row in await table.read_rows(query):
                print_row(row)

C#

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

/// <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 Task<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++

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

namespace cbt = ::google::cloud::bigtable;
using ::google::cloud::StatusOr;
[](cbt::Table table) {
  // Filter the results, only include limited cells per row
  cbt::Filter filter = cbt::Filter::CellsRowLimit(2);
  // Read and print the rows.
  for (StatusOr<cbt::Row>& row :
       table.ReadRows(cbt::RowSet(cbt::RowRange::InfiniteRange()), filter)) {
    if (!row) throw std::move(row).status();
    std::cout << row->row_key() << " = ";
    for (auto const& cell : row->cells()) {
      std::cout << "[" << cell.family_name() << ", "
                << cell.column_qualifier() << ", " << cell.value() << "],";
    }
    std::cout << "\n";
  }
}

Node.js

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

PHP

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

use Google\Cloud\Bigtable\BigtableClient;
use Google\Cloud\Bigtable\Filter;

/**
 * Create a limiting filter on cells per row
 *
 * @param string $projectId The Google Cloud project ID
 * @param string $instanceId The ID of the Bigtable instance
 * @param string $tableId The ID of the table to read from
 */
function filter_limit_cells_per_row(
    string $projectId,
    string $instanceId,
    string $tableId
): void {
    // Connect to an existing table with an existing instance.
    $dataClient = new BigtableClient([
        'projectId' => $projectId,
    ]);
    $table = $dataClient->table($instanceId, $tableId);

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

    $rows = $table->readRows([
        'filter' => $filter
    ]);

    foreach ($rows as $key => $row) {
        // The "print_row" helper function is defined in https://cloud.google.com/bigtable/docs/samples/bigtable-reads-print
        print_row($key, $row);
    }
}

小茹

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

# instance_id = "my-instance"
# table_id    = "my-table"
filter = Google::Cloud::Bigtable::RowFilter.cells_per_row 2
read_with_filter instance_id, table_id, filter

每列儲存格偏移量

這項篩選器會省略每個輸出資料列的前 N 個儲存格。其餘所有儲存格都會納入輸出資料列。無論前 N 個儲存格位於哪一欄，系統都會略過。

一列中的一欄可以包含多個儲存格。每個儲存格都包含資料欄的值和專屬時間戳記。因此，略過資料列中的前 N 個儲存格，可能與略過資料列中的前 N 欄不同。舉例來說，如果您使用每列儲存格偏移量為 20 的篩選器，讀取含有 30 欄的資料列，且每欄有 10 個加上時間戳記的儲存格，則輸出資料列會傳回該列中所有儲存格的值，但前兩欄 (2 * 10 = 20) 除外。

如果您也使用交錯篩選器，且交錯篩選器產生儲存格的重複副本，則每個副本都會計入偏移量。

下列程式碼範例使用 2 的偏移量，略過每個資料列的前兩個儲存格，例如，在使用每個資料列的儲存格數量限制篩選器讀取前兩個儲存格後，擷取下一頁的儲存格。套用至範例資料集時，這個篩選器會略過前兩個儲存格，並傳回五個資料列中其餘的所有儲存格。

Go

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

HBase

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

def filter_limit_cells_per_row_offset(project_id, instance_id, table_id):
    from google.cloud import bigtable
    from google.cloud.bigtable import row_filters

    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)

Python asyncio

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

async def filter_limit_cells_per_row_offset(project_id, instance_id, table_id):
    from google.cloud.bigtable.data import (
        BigtableDataClientAsync,
        ReadRowsQuery,
        row_filters,
    )

    query = ReadRowsQuery(row_filter=row_filters.CellsRowOffsetFilter(2))

    async with BigtableDataClientAsync(project=project_id) as client:
        async with client.get_table(instance_id, table_id) as table:
            for row in await table.read_rows(query):
                print_row(row)

C#

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

/// <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 Task<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++

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

namespace cbt = ::google::cloud::bigtable;
using ::google::cloud::StatusOr;
[](cbt::Table table) {
  cbt::Filter filter = cbt::Filter::CellsRowOffset(2);
  // Read and print the rows.
  for (StatusOr<cbt::Row>& row :
       table.ReadRows(cbt::RowSet(cbt::RowRange::InfiniteRange()), filter)) {
    if (!row) throw std::move(row).status();
    std::cout << row->row_key() << " = ";
    for (auto const& cell : row->cells()) {
      std::cout << "[" << cell.family_name() << ", "
                << cell.column_qualifier() << ", " << cell.value() << "],";
    }
    std::cout << "\n";
  }
}

Node.js

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

PHP

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

use Google\Cloud\Bigtable\BigtableClient;
use Google\Cloud\Bigtable\Filter;

/**
 * Create a limiting filter offsetting cells per row
 *
 * @param string $projectId The Google Cloud project ID
 * @param string $instanceId The ID of the Bigtable instance
 * @param string $tableId The ID of the table to read from
 */
function filter_limit_cells_per_row_offset(
    string $projectId,
    string $instanceId,
    string $tableId
): void {
    // Connect to an existing table with an existing instance.
    $dataClient = new BigtableClient([
        'projectId' => $projectId,
    ]);
    $table = $dataClient->table($instanceId, $tableId);

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

    $rows = $table->readRows([
        'filter' => $filter
    ]);

    foreach ($rows as $key => $row) {
        // The "print_row" helper function is defined in https://cloud.google.com/bigtable/docs/samples/bigtable-reads-print
        print_row($key, $row);
    }
}

小茹

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

# instance_id = "my-instance"
# table_id    = "my-table"
filter = Google::Cloud::Bigtable::RowFilter.cells_per_row_offset 2
read_with_filter instance_id, table_id, filter

資料欄系列規則運算式

只有在儲存格的資料欄系列符合規則運算式時，這個篩選器才會將儲存格納入輸出內容列。

規則運算式必須使用 RE2 語法。規則運算式不得包含 : 字元，即使該字元並非用作常值也一樣。資料欄系列不得包含換行字元，因此您可以使用 . 或 \C 做為萬用字元運算式。

注意：這項篩選器可讓您篩選資料欄系列，也就是一組資料欄的名稱。如要篩選資料欄限定詞 (資料欄系列中的不重複名稱)，請使用資料欄限定詞規則運算式篩選器。

舉例來說，如果您想讀取裝置摘要統計資料，而不擷取數據方案資料欄，可以篩選 stats_summary 資料欄系列。下列程式碼範例使用規則運算式 stats_.*$，傳回範例資料集中所有五個資料列的 stats_summary 資料欄系列中的所有儲存格，並省略 cell_plan 中的所有儲存格。

Go

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

HBase

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

def filter_limit_col_family_regex(project_id, instance_id, table_id):
    from google.cloud import bigtable
    from google.cloud.bigtable import row_filters

    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)

Python asyncio

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

async def filter_limit_col_family_regex(project_id, instance_id, table_id):
    from google.cloud.bigtable.data import (
        BigtableDataClientAsync,
        ReadRowsQuery,
        row_filters,
    )

    query = ReadRowsQuery(
        row_filter=row_filters.FamilyNameRegexFilter("stats_.*$".encode("utf-8"))
    )

    async with BigtableDataClientAsync(project=project_id) as client:
        async with client.get_table(instance_id, table_id) as table:
            for row in await table.read_rows(query):
                print_row(row)

C#

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

/// <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 Task<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++

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

namespace cbt = ::google::cloud::bigtable;
using ::google::cloud::StatusOr;
[](cbt::Table table) {
  cbt::Filter filter = cbt::Filter::FamilyRegex("stats_.*$");
  // Read and print the rows.
  for (StatusOr<cbt::Row>& row :
       table.ReadRows(cbt::RowSet(cbt::RowRange::InfiniteRange()), filter)) {
    if (!row) throw std::move(row).status();
    std::cout << row->row_key() << " = ";
    for (auto const& cell : row->cells()) {
      std::cout << "[" << cell.family_name() << ", "
                << cell.column_qualifier() << ", " << cell.value() << "],";
    }
    std::cout << "\n";
  }
}

Node.js

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

PHP

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

use Google\Cloud\Bigtable\BigtableClient;
use Google\Cloud\Bigtable\Filter;

/**
 * Create a limiting filter on a column family with a regex
 *
 * @param string $projectId The Google Cloud project ID
 * @param string $instanceId The ID of the Bigtable instance
 * @param string $tableId The ID of the table to read from
 */
function filter_limit_col_family_regex(
    string $projectId,
    string $instanceId,
    string $tableId
): void {
    // Connect to an existing table with an existing instance.
    $dataClient = new BigtableClient([
        'projectId' => $projectId,
    ]);
    $table = $dataClient->table($instanceId, $tableId);

    $filter = Filter::family()->regex('stats_.*$');

    $rows = $table->readRows([
        'filter' => $filter
    ]);

    foreach ($rows as $key => $row) {
        // The "print_row" helper function is defined in https://cloud.google.com/bigtable/docs/samples/bigtable-reads-print
        print_row($key, $row);
    }
}

小茹

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

# instance_id = "my-instance"
# table_id    = "my-table"
filter = Google::Cloud::Bigtable::RowFilter.family "stats_.*$"
read_with_filter instance_id, table_id, filter

資料欄限定詞規則運算式

只有在儲存格的資料欄限定詞符合規則運算式時，這個篩選器才會將儲存格納入輸出內容列。

規則運算式必須使用 RE2 語法。資料欄限定詞可能含有任意內容 (包括換行字元)，因此在多數情況下，請使用 \C 做為萬用字元運算式，. 運算式不會對應至換行字元。

注意：這項篩選器可讓您篩選資料欄限定詞，也就是資料欄系列中的專屬名稱。如要篩選資料欄系列 (即一組資料欄的名稱)，請使用資料欄系列規則運算式篩選器。

注意：如果資料欄限定詞用於多個資料欄系列，系統會傳回所有具有該資料欄限定詞的資料欄。如要指定特定資料欄限定詞，請使用鏈結篩選器。

舉例來說，如果您只想檢查每部裝置的行動網路和 Wi-Fi 連線能力，可以篩選開頭為 connected_ 的資料欄限定詞。下列程式碼範例使用規則運算式 connected_.*$，僅傳回範例資料集中五個資料列的 connected_cell 和 connected_wifi 儲存格，並省略 os_build 和所有 cell_plan 資料欄。

Go

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

HBase

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

def filter_limit_col_qualifier_regex(project_id, instance_id, table_id):
    from google.cloud import bigtable
    from google.cloud.bigtable import row_filters

    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)

Python asyncio

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

async def filter_limit_col_qualifier_regex(project_id, instance_id, table_id):
    from google.cloud.bigtable.data import (
        BigtableDataClientAsync,
        ReadRowsQuery,
        row_filters,
    )

    query = ReadRowsQuery(
        row_filter=row_filters.ColumnQualifierRegexFilter(
            "connected_.*$".encode("utf-8")
        )
    )

    async with BigtableDataClientAsync(project=project_id) as client:
        async with client.get_table(instance_id, table_id) as table:
            for row in await table.read_rows(query):
                print_row(row)

C#

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

/// <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 Task<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++

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

namespace cbt = ::google::cloud::bigtable;
using ::google::cloud::StatusOr;
[](cbt::Table table) {
  cbt::Filter filter = cbt::Filter::ColumnRegex("connected_.*$");
  // Read and print the rows.
  for (StatusOr<cbt::Row>& row :
       table.ReadRows(cbt::RowSet(cbt::RowRange::InfiniteRange()), filter)) {
    if (!row) throw std::move(row).status();
    std::cout << row->row_key() << " = ";
    for (auto const& cell : row->cells()) {
      std::cout << "[" << cell.family_name() << ", "
                << cell.column_qualifier() << ", " << cell.value() << "],";
    }
    std::cout << "\n";
  }
}

Node.js

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

PHP

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

use Google\Cloud\Bigtable\BigtableClient;
use Google\Cloud\Bigtable\Filter;

/**
 * Create a limiting filter on a column qualifier with a regex
 *
 * @param string $projectId The Google Cloud project ID
 * @param string $instanceId The ID of the Bigtable instance
 * @param string $tableId The ID of the table to read from
 */
function filter_limit_col_qualifier_regex(
    string $projectId,
    string $instanceId,
    string $tableId
): void {
    // Connect to an existing table with an existing instance.
    $dataClient = new BigtableClient([
        'projectId' => $projectId,
    ]);
    $table = $dataClient->table($instanceId, $tableId);

    $filter = Filter::qualifier()->regex('connected_.*$');

    $rows = $table->readRows([
        'filter' => $filter
    ]);

    foreach ($rows as $key => $row) {
        // The "print_row" helper function is defined in https://cloud.google.com/bigtable/docs/samples/bigtable-reads-print
        print_row($key, $row);
    }
}

小茹

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

# instance_id = "my-instance"
# table_id    = "my-table"
filter = Google::Cloud::Bigtable::RowFilter.qualifier "connected_.*$"
read_with_filter instance_id, table_id, filter

資料欄範圍

只有在輸出資料列中的儲存格位於特定資料欄系列，且其資料欄限定詞在特定範圍內時，這個篩選器才會包含這些儲存格。您只要提供起始和結束限定詞，即可指定範圍。

下列程式碼範例會篩選 cell_plan 資料欄系列，找出從 data_plan_01gb (含) 到 data_plan_10gb (不含) 的資料欄限定詞，例如檢查哪些記錄使用 1 GB 或 5 GB 數據方案。在範例資料集中，這項篩選器會傳回三個 phone#4c410523 資料列的 data_plan_01gb 和 data_plan_05gb 儲存格。由於兩個 phone#5c10102 資料列在 data_plan_10gb 中只有 cell_plan 值，因此這些資料列沒有相符的儲存格，也不會傳回。

Go

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

def filter_limit_col_range(project_id, instance_id, table_id):
    from google.cloud import bigtable
    from google.cloud.bigtable import row_filters

    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)

Python asyncio

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

async def filter_limit_col_range(project_id, instance_id, table_id):
    from google.cloud.bigtable.data import (
        BigtableDataClientAsync,
        ReadRowsQuery,
        row_filters,
    )

    query = ReadRowsQuery(
        row_filter=row_filters.ColumnRangeFilter(
            "cell_plan", b"data_plan_01gb", b"data_plan_10gb", inclusive_end=False
        )
    )

    async with BigtableDataClientAsync(project=project_id) as client:
        async with client.get_table(instance_id, table_id) as table:
            for row in await table.read_rows(query):
                print_row(row)

C#

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

/// <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 Task<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++

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

namespace cbt = ::google::cloud::bigtable;
using ::google::cloud::StatusOr;
[](cbt::Table table) {
  cbt::Filter filter = cbt::Filter::ColumnRange("cell_plan", "data_plan_01gb",
                                                "data_plan_10gb");
  // Read and print the rows.
  for (StatusOr<cbt::Row>& row :
       table.ReadRows(cbt::RowSet(cbt::RowRange::InfiniteRange()), filter)) {
    if (!row) throw std::move(row).status();
    std::cout << row->row_key() << " = ";
    for (auto const& cell : row->cells()) {
      std::cout << "[" << cell.family_name() << ", "
                << cell.column_qualifier() << ", " << cell.value() << "],";
    }
    std::cout << "\n";
  }
}

Node.js

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

PHP

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

use Google\Cloud\Bigtable\BigtableClient;
use Google\Cloud\Bigtable\Filter;

/**
 * Create a limiting filter on a range of columns
 *
 * @param string $projectId The Google Cloud project ID
 * @param string $instanceId The ID of the Bigtable instance
 * @param string $tableId The ID of the table to read from
 */
function filter_limit_col_range(
    string $projectId,
    string $instanceId,
    string $tableId
): void {
    // Connect to an existing table with an existing instance.
    $dataClient = new BigtableClient([
        'projectId' => $projectId,
    ]);
    $table = $dataClient->table($instanceId, $tableId);

    $filter = Filter::qualifier()
        ->rangeWithinFamily('cell_plan')
        ->startClosed('data_plan_01gb')
        ->endOpen('data_plan_10gb');

    $rows = $table->readRows([
        'filter' => $filter
    ]);

    foreach ($rows as $key => $row) {
        // The "print_row" helper function is defined in https://cloud.google.com/bigtable/docs/samples/bigtable-reads-print
        print_row($key, $row);
    }
}

小茹

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

# instance_id = "my-instance"
# table_id    = "my-table"
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 instance_id, table_id, filter

值範圍

只有在輸出資料列中的儲存格值位於特定範圍內時，這個篩選器才會納入這些儲存格。您可以提供起始值和結束值來指定範圍。

• 如要取得值在特定值之前的儲存格，請將該值指定為不含端值的結束值，並省略起始值。
• 如要取得值等於或晚於特定值的儲存格，請將該值指定為包含起始值，並省略結束值。

下列程式碼範例會篩選 PQ2A.190405 到 PQ2A.190406 之間的儲存格值，找出 OS 版本在該範圍內的記錄。在範例資料集中，這個篩選器只會傳回 phone#4c410523#20190501 和 phone#4c410523#20190502 的 stats_summary:os_build 儲存格，並省略所有其他儲存格，以及 os_build 值超出範圍的其餘三個資料列。

Go

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

def filter_limit_value_range(project_id, instance_id, table_id):
    from google.cloud import bigtable
    from google.cloud.bigtable import row_filters

    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)

Python asyncio

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

async def filter_limit_value_range(project_id, instance_id, table_id):
    from google.cloud.bigtable.data import (
        BigtableDataClientAsync,
        ReadRowsQuery,
        row_filters,
    )

    query = ReadRowsQuery(
        row_filter=row_filters.ValueRangeFilter(b"PQ2A.190405", b"PQ2A.190406")
    )

    async with BigtableDataClientAsync(project=project_id) as client:
        async with client.get_table(instance_id, table_id) as table:
            for row in await table.read_rows(query):
                print_row(row)

C#

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

/// <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 Task<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++

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

namespace cbt = ::google::cloud::bigtable;
using ::google::cloud::StatusOr;
[](cbt::Table table) {
  cbt::Filter filter = cbt::Filter::ValueRange("PQ2A.190405", "PQ2A.190406");
  // Read and print the rows.
  for (StatusOr<cbt::Row>& row :
       table.ReadRows(cbt::RowSet(cbt::RowRange::InfiniteRange()), filter)) {
    if (!row) throw std::move(row).status();
    std::cout << row->row_key() << " = ";
    for (auto const& cell : row->cells()) {
      std::cout << "[" << cell.family_name() << ", "
                << cell.column_qualifier() << ", " << cell.value() << "],";
    }
    std::cout << "\n";
  }
}

Node.js

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

PHP

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

use Google\Cloud\Bigtable\BigtableClient;
use Google\Cloud\Bigtable\Filter;

/**
 * Create a limiting filter on a range of cell values
 *
 * @param string $projectId The Google Cloud project ID
 * @param string $instanceId The ID of the Bigtable instance
 * @param string $tableId The ID of the table to read from
 */
function filter_limit_value_range(
    string $projectId,
    string $instanceId,
    string $tableId
): void {
    // Connect to an existing table with an existing instance.
    $dataClient = new BigtableClient([
        'projectId' => $projectId,
    ]);
    $table = $dataClient->table($instanceId, $tableId);

    $filter = Filter::value()
        ->range()
        ->startClosed('PQ2A.190405')
        ->endOpen('PQ2A.190406');

    $rows = $table->readRows([
        'filter' => $filter
    ]);

    foreach ($rows as $key => $row) {
        // The "print_row" helper function is defined in https://cloud.google.com/bigtable/docs/samples/bigtable-reads-print
        print_row($key, $row);
    }
}

小茹

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

值規則運算式

只有在儲存格的值符合規則運算式時，這個篩選器才會將儲存格納入輸出內容列。

規則運算式必須使用 RE2 語法。值可能含有任意內容 (包括換行字元)，因此在多數情況下，請使用 \C 做為萬用字元運算式，. 運算式不會對應至換行字元。

下列程式碼範例使用規則運算式 PQ2A.*$，比對開頭為 PQ2A 的儲存格值，例如擷取 PQ2A 版本系列中的 OS 版本。套用至範例資料集時，這個篩選器只會傳回五個資料列中每個資料列的 stats_summary:os_build 儲存格，並省略所有其他儲存格。

Go

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

HBase

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

def filter_limit_value_regex(project_id, instance_id, table_id):
    from google.cloud import bigtable
    from google.cloud.bigtable import row_filters

    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)

Python asyncio

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

async def filter_limit_value_regex(project_id, instance_id, table_id):
    from google.cloud.bigtable.data import (
        BigtableDataClientAsync,
        ReadRowsQuery,
        row_filters,
    )

    query = ReadRowsQuery(
        row_filter=row_filters.ValueRegexFilter("PQ2A.*$".encode("utf-8"))
    )

    async with BigtableDataClientAsync(project=project_id) as client:
        async with client.get_table(instance_id, table_id) as table:
            for row in await table.read_rows(query):
                print_row(row)

C#

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

/// <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 Task<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++

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

namespace cbt = ::google::cloud::bigtable;
using ::google::cloud::StatusOr;
[](cbt::Table table) {
  cbt::Filter filter = cbt::Filter::ValueRegex("PQ2A.*$");
  // Read and print the rows.
  for (StatusOr<cbt::Row>& row :
       table.ReadRows(cbt::RowSet(cbt::RowRange::InfiniteRange()), filter)) {
    if (!row) throw std::move(row).status();
    std::cout << row->row_key() << " = ";
    for (auto const& cell : row->cells()) {
      std::cout << "[" << cell.family_name() << ", "
                << cell.column_qualifier() << ", " << cell.value() << "],";
    }
    std::cout << "\n";
  }
}

Node.js

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

PHP

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

use Google\Cloud\Bigtable\BigtableClient;
use Google\Cloud\Bigtable\Filter;

/**
 * Create a limiting filter on a cell value using a regex
 *
 * @param string $projectId The Google Cloud project ID
 * @param string $instanceId The ID of the Bigtable instance
 * @param string $tableId The ID of the table to read from
 */
function filter_limit_value_regex(
    string $projectId,
    string $instanceId,
    string $tableId
): void {
    // Connect to an existing table with an existing instance.
    $dataClient = new BigtableClient([
        'projectId' => $projectId,
    ]);
    $table = $dataClient->table($instanceId, $tableId);

    $filter = Filter::value()->regex('PQ2A.*$');

    $rows = $table->readRows([
        'filter' => $filter
    ]);

    foreach ($rows as $key => $row) {
        // The "print_row" helper function is defined in https://cloud.google.com/bigtable/docs/samples/bigtable-reads-print
        print_row($key, $row);
    }
}

小茹

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

# instance_id = "my-instance"
# table_id    = "my-table"
filter = Google::Cloud::Bigtable::RowFilter.value "PQ2A.*$"
read_with_filter instance_id, table_id, filter

時間戳記範圍

只有在時間戳記位於特定範圍內時，這個篩選器才會將儲存格納入輸出資料列。您需要提供開始時間 (含) 和結束時間 (不含) 來指定範圍。預設單位為微秒，時間戳記必須是 1,000 的倍數。

• 如要取得時間戳記早於特定時間的儲存格，請將該時間指定為結束時間，並省略開始時間，使其不受限制。
• 如要取得時間戳記等於或晚於特定時間的儲存格，請將該時間指定為開始時間，並省略結束時間，使其不受限制。

下列程式碼範例會篩選一小時前或更早寫入的儲存格。在範例資料集中，所有其他儲存格都是在 @time 寫入，因此這個篩選器只會傳回 phone#4c410523#20190501 列中 cell_plan:data_plan_01gb 欄的 true@time minus one hour 儲存格。

Go

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

注意：這個用戶端程式庫中的時間戳記範圍篩選器不支援 startOpen() 和 endClosed() 方法。

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

def filter_limit_timestamp_range(project_id, instance_id, table_id):
    from google.cloud import bigtable
    from google.cloud.bigtable import row_filters
    import datetime

    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)

Python asyncio

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

async def filter_limit_timestamp_range(project_id, instance_id, table_id):
    import datetime

    from google.cloud.bigtable.data import (
        BigtableDataClientAsync,
        ReadRowsQuery,
        row_filters,
    )

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

    query = ReadRowsQuery(row_filter=row_filters.TimestampRangeFilter(end=end))

    async with BigtableDataClientAsync(project=project_id) as client:
        async with client.get_table(instance_id, table_id) as table:
            for row in await table.read_rows(query):
                print_row(row)

C#

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

/// <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 Task<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++

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

namespace cbt = ::google::cloud::bigtable;
using ::google::cloud::StatusOr;
[](cbt::Table table) {
  cbt::Filter filter =
      cbt::Filter::TimestampRange(microseconds(1000), milliseconds(2));
  // Read and print the rows.
  for (StatusOr<cbt::Row>& row :
       table.ReadRows(cbt::RowSet(cbt::RowRange::InfiniteRange()), filter)) {
    if (!row) throw std::move(row).status();
    std::cout << row->row_key() << " = ";
    for (auto const& cell : row->cells()) {
      std::cout << "[" << cell.family_name() << ", "
                << cell.column_qualifier() << ", " << cell.value() << "],";
    }
    std::cout << "\n";
  }
}

Node.js

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

PHP

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

use Google\Cloud\Bigtable\BigtableClient;
use Google\Cloud\Bigtable\Filter;

/**
 * Create a limiting filter on a range of cell timestamps
 *
 * @param string $projectId The Google Cloud project ID
 * @param string $instanceId The ID of the Bigtable instance
 * @param string $tableId The ID of the table to read from
 * @param int $endTime The timestamp upto which you want to fetch the rows
 */
function filter_limit_timestamp_range(
    string $projectId,
    string $instanceId,
    string $tableId,
    int $endTime = null
): void {
    // Connect to an existing table with an existing instance.
    $dataClient = new BigtableClient([
        'projectId' => $projectId,
    ]);
    $table = $dataClient->table($instanceId, $tableId);
    $endTime = is_null($endTime) ? (time() - 60 * 60) * 1000 * 1000 : $endTime;

    $start = 0;
    $filter = Filter::timestamp()
        ->range()
        ->startClosed($start)
        ->endOpen($endTime);

    $rows = $table->readRows([
        'filter' => $filter
    ]);

    foreach ($rows as $key => $row) {
        // The "print_row" helper function is defined in https://cloud.google.com/bigtable/docs/samples/bigtable-reads-print
        print_row($key, $row);
    }
}

小茹

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

# instance_id = "my-instance"
# table_id    = "my-table"
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 instance_id, table_id, filter

進階單一篩選器

下列篩選器可能較難使用。

全部封鎖

這個篩選器會從輸出資料列中移除所有儲存格。

如果您使用交錯篩選器，可以將 block all 篩選器與鏈結篩選器結合，暫時停用部分交錯。

下列程式碼範例會將 block all 篩選器套用至讀取要求。對範例資料集執行時，這個篩選器會移除所有五個資料列中的所有儲存格，並傳回空白回應。

Go

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

HBase

這個用戶端程式庫不支援此篩選器。

Java

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

def filter_limit_block_all(project_id, instance_id, table_id):
    from google.cloud import bigtable
    from google.cloud.bigtable import row_filters

    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)

Python asyncio

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

async def filter_limit_block_all(project_id, instance_id, table_id):
    from google.cloud.bigtable.data import (
        BigtableDataClientAsync,
        ReadRowsQuery,
        row_filters,
    )

    query = ReadRowsQuery(row_filter=row_filters.BlockAllFilter(True))

    async with BigtableDataClientAsync(project=project_id) as client:
        async with client.get_table(instance_id, table_id) as table:
            for row in await table.read_rows(query):
                print_row(row)

C#

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

/// <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 Task<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++

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

namespace cbt = ::google::cloud::bigtable;
using ::google::cloud::StatusOr;
[](cbt::Table table) {
  cbt::Filter filter = cbt::Filter::BlockAllFilter();
  // Read and print the rows.
  for (StatusOr<cbt::Row>& row :
       table.ReadRows(cbt::RowSet(cbt::RowRange::InfiniteRange()), filter)) {
    if (!row) throw std::move(row).status();
    std::cout << row->row_key();
    std::cout << row->row_key() << " = ";
    for (auto const& cell : row->cells()) {
      std::cout << "[" << cell.family_name() << ", "
                << cell.column_qualifier() << ", " << cell.value() << "],";
    }
    std::cout << "\n";
  }
}

Node.js

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

PHP

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

use Google\Cloud\Bigtable\BigtableClient;
use Google\Cloud\Bigtable\Filter;

/**
 * Create a block all filter
 *
 * @param string $projectId The Google Cloud project ID
 * @param string $instanceId The ID of the Bigtable instance
 * @param string $tableId The ID of the table to read from
 */
function filter_limit_block_all(
    string $projectId,
    string $instanceId,
    string $tableId
): void {
    // Connect to an existing table with an existing instance.
    $dataClient = new BigtableClient([
        'projectId' => $projectId,
    ]);
    $table = $dataClient->table($instanceId, $tableId);

    $filter = Filter::block();

    $rows = $table->readRows([
        'filter' => $filter
    ]);

    foreach ($rows as $key => $row) {
        // The "print_row" helper function is defined in https://cloud.google.com/bigtable/docs/samples/bigtable-reads-print
        print_row($key, $row);
    }
}

小茹

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

# instance_id = "my-instance"
# table_id    = "my-table"
filter = Google::Cloud::Bigtable::RowFilter.block
read_with_filter instance_id, table_id, filter

全部通過

這個篩選器會將輸入內容列的所有儲存格納入輸出內容列。這相當於不含篩選條件的讀取作業。

如果您要組合多個篩選器，且需要在某些情況下輸出儲存格，但在其他情況下不輸出，則 pass all 篩選器會很有用。

下列程式碼範例會將 pass all 篩選器套用至讀取要求。對範例資料集執行時，這個篩選器會傳回資料表中所有五個資料列的所有儲存格，包括 cell_plan:data_plan_01gb 中 phone#4c410523#20190501 資料列的兩個時間戳記儲存格。

Go

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

HBase

這個用戶端程式庫不支援此篩選器。

Java

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

def filter_limit_pass_all(project_id, instance_id, table_id):
    from google.cloud import bigtable
    from google.cloud.bigtable import row_filters

    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)

Python asyncio

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

async def filter_limit_pass_all(project_id, instance_id, table_id):
    from google.cloud.bigtable.data import (
        BigtableDataClientAsync,
        ReadRowsQuery,
        row_filters,
    )

    query = ReadRowsQuery(row_filter=row_filters.PassAllFilter(True))

    async with BigtableDataClientAsync(project=project_id) as client:
        async with client.get_table(instance_id, table_id) as table:
            for row in await table.read_rows(query):
                print_row(row)

C#

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

/// <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 Task<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++

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

namespace cbt = ::google::cloud::bigtable;
using ::google::cloud::StatusOr;
[](cbt::Table table) {
  cbt::Filter filter = cbt::Filter::PassAllFilter();
  // Read and print the rows.
  for (StatusOr<cbt::Row>& row :
       table.ReadRows(cbt::RowSet(cbt::RowRange::InfiniteRange()), filter)) {
    if (!row) throw std::move(row).status();
    std::cout << row->row_key() << " = ";
    for (auto const& cell : row->cells()) {
      std::cout << "[" << cell.family_name() << ", "
                << cell.column_qualifier() << ", " << cell.value() << "],";
    }
    std::cout << "\n";
  }
}

Node.js

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

PHP

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

use Google\Cloud\Bigtable\BigtableClient;
use Google\Cloud\Bigtable\Filter;

/**
 * Create a pass all filter
 *
 * @param string $projectId The Google Cloud project ID
 * @param string $instanceId The ID of the Bigtable instance
 * @param string $tableId The ID of the table to read from
 */
function filter_limit_pass_all(
    string $projectId,
    string $instanceId,
    string $tableId
): void {
    // Connect to an existing table with an existing instance.
    $dataClient = new BigtableClient([
        'projectId' => $projectId,
    ]);
    $table = $dataClient->table($instanceId, $tableId);

    $filter = Filter::pass();

    $rows = $table->readRows([
        'filter' => $filter
    ]);

    foreach ($rows as $key => $row) {
        // The "print_row" helper function is defined in https://cloud.google.com/bigtable/docs/samples/bigtable-reads-print
        print_row($key, $row);
    }
}

小茹

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

# instance_id = "my-instance"
# table_id    = "my-table"
filter = Google::Cloud::Bigtable::RowFilter.pass
read_with_filter instance_id, table_id, filter

接收器

這個篩選器會將輸入內容列的所有儲存格複製到最終輸出內容列，即使其他篩選器通常會移除或變更這些儲存格也一樣。

注意：一般來說，您可能不需要使用接收器篩選器。這項功能旨在支援少數進階用途。此外，這項功能也可用於偵錯複雜的篩選器組合。

使用篩選器鏈時，其他限制篩選器只能影響自己的輸出資料列，該資料列會成為鏈中下一個篩選器的輸入資料列。接收器篩選器則不同，會直接將儲存格插入最終輸出資料列，並顯示在讀取結果中。

舉例來說，假設您建立由兩個篩選器組成的鏈結：

1. 接收器篩選器
2. block all 篩選器：刪除資料列中的所有儲存格

單獨使用時，block all 篩選器會產生空白資料列，不會包含在讀取結果中。不過，不論鏈結中的其他篩選器可能執行什麼動作，接收器篩選器都會強制將輸入資料列中的所有儲存格複製到最終輸出資料列。因此，將接收器篩選器和 block all 篩選器合併，效果與完全不使用篩選器相同，而且原始輸入資料列及其所有儲存格都會顯示在讀取結果中。

修改篩選器

以下各節將說明各個修改篩選器。修改篩選器會影響個別儲存格的資料或中繼資料。

套用標籤

這個篩選器會為資料列中的所有儲存格加上標籤。請將這個篩選器做為交錯的一部分，指出哪個篩選器導致儲存格包含在輸出資料列中。應用程式可以使用每個儲存格的標籤，執行額外的用戶端處理作業。

注意：「套用標籤」篩選器與可新增至 Bigtable 資源的標籤無關。為 Bigtable 資源加上標籤不會影響資料讀取。

每個標籤不得超過 15 個字元。此外，每個標籤都必須符合 RE2 規則運算式 [a-z0-9\\-]+。

每個儲存格只能有一個標籤。因此，篩選器鏈只能包含一個套用標籤篩選器。

下列程式碼範例會將標籤 labelled 套用至從資料表讀取的儲存格。對範例資料集執行時，這個篩選器會傳回所有五個資料列中的所有儲存格，並在每個儲存格中附加 labelled 中繼資料標籤。

Go

這個用戶端程式庫不支援此篩選器。

HBase

這個用戶端程式庫不支援此篩選器。

Java

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

def filter_modify_apply_label(project_id, instance_id, table_id):
    from google.cloud import bigtable
    from google.cloud.bigtable import row_filters

    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)

Python asyncio

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

async def filter_modify_apply_label(project_id, instance_id, table_id):
    from google.cloud.bigtable.data import (
        BigtableDataClientAsync,
        ReadRowsQuery,
        row_filters,
    )

    query = ReadRowsQuery(row_filter=row_filters.ApplyLabelFilter(label="labelled"))

    async with BigtableDataClientAsync(project=project_id) as client:
        async with client.get_table(instance_id, table_id) as table:
            for row in await table.read_rows(query):
                print_row(row)

C#

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

/// <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 Task<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++

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

namespace cbt = ::google::cloud::bigtable;
using ::google::cloud::StatusOr;
[](cbt::Table table) {
  cbt::Filter filter = cbt::Filter::ApplyLabelTransformer("labelled");
  // Read and print the rows.
  for (StatusOr<cbt::Row>& row :
       table.ReadRows(cbt::RowSet(cbt::RowRange::InfiniteRange()), filter)) {
    if (!row) throw std::move(row).status();
    std::cout << row->row_key() << " = ";
    for (auto const& cell : row->cells()) {
      std::cout << "[" << cell.family_name() << ", "
                << cell.column_qualifier() << ", " << cell.value()
                << ", label(";
      for (auto const& label : cell.labels()) {
        std::cout << label << ",";
      }
      std::cout << ")],";
    }
    std::cout << "\n";
  }
}

Node.js

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

PHP

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

use Google\Cloud\Bigtable\BigtableClient;
use Google\Cloud\Bigtable\Filter;

/**
 * Create a filter that applies a label
 *
 * @param string $projectId The Google Cloud project ID
 * @param string $instanceId The ID of the Bigtable instance
 * @param string $tableId The ID of the table to read from
 */
function filter_modify_apply_label(
    string $projectId,
    string $instanceId,
    string $tableId
): void {
    // Connect to an existing table with an existing instance.
    $dataClient = new BigtableClient([
        'projectId' => $projectId,
    ]);
    $table = $dataClient->table($instanceId, $tableId);

    $filter = Filter::label('labelled');

    $rows = $table->readRows([
        'filter' => $filter
    ]);

    foreach ($rows as $key => $row) {
        // The "print_row" helper function is defined in https://cloud.google.com/bigtable/docs/samples/bigtable-reads-print
        print_row($key, $row);
    }
}

小茹

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

# instance_id = "my-instance"
# table_id    = "my-table"
filter = Google::Cloud::Bigtable::RowFilter.label "labelled"
read_with_filter instance_id, table_id, filter

去除值

這項篩選器會將每個儲存格的值替換為空字串。如果只需要計算符合條件的資料列或儲存格數量，而非擷取這些資料列或儲存格中的所有資料，請使用這個篩選器。

下列程式碼範例會套用 strip value 篩選器，在不傳輸儲存格值的情況下擷取儲存格中繼資料。對範例資料集執行時，這個篩選器會傳回所有五個資料列中的所有儲存格，並保留其資料列索引鍵、資料欄系列、資料欄限定詞和時間戳記，但會將每個儲存格值 (例如 1、PQ2A.190405.003 或 true) 替換為空字串。

Go

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

HBase

在 HBase 用戶端程式庫中，去除值篩選器稱為 KeyOnlyFilter。無法提供範例。

Java

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

def filter_modify_strip_value(project_id, instance_id, table_id):
    from google.cloud import bigtable
    from google.cloud.bigtable import row_filters

    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)

Python asyncio

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

async def filter_modify_strip_value(project_id, instance_id, table_id):
    from google.cloud.bigtable.data import (
        BigtableDataClientAsync,
        ReadRowsQuery,
        row_filters,
    )

    query = ReadRowsQuery(row_filter=row_filters.StripValueTransformerFilter(True))

    async with BigtableDataClientAsync(project=project_id) as client:
        async with client.get_table(instance_id, table_id) as table:
            for row in await table.read_rows(query):
                print_row(row)

C#

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

/// <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 Task<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++

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

namespace cbt = ::google::cloud::bigtable;
using ::google::cloud::StatusOr;
[](cbt::Table table) {
  cbt::Filter filter = cbt::Filter::StripValueTransformer();
  // Read and print the rows.
  for (StatusOr<cbt::Row>& row :
       table.ReadRows(cbt::RowSet(cbt::RowRange::InfiniteRange()), filter)) {
    if (!row) throw std::move(row).status();
    std::cout << row->row_key() << " = ";
    for (auto const& cell : row->cells()) {
      std::cout << "[" << cell.family_name() << ", "
                << cell.column_qualifier() << ", " << cell.value() << "],";
    }
    std::cout << "\n";
  }
}

Node.js

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

PHP

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

use Google\Cloud\Bigtable\BigtableClient;
use Google\Cloud\Bigtable\Filter;

/**
 * Create a filter that strips the value
 *
 * @param string $projectId The Google Cloud project ID
 * @param string $instanceId The ID of the Bigtable instance
 * @param string $tableId The ID of the table to read from
 */
function filter_modify_strip_value(
    string $projectId,
    string $instanceId,
    string $tableId
): void {
    // Connect to an existing table with an existing instance.
    $dataClient = new BigtableClient([
        'projectId' => $projectId,
    ]);
    $table = $dataClient->table($instanceId, $tableId);

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

    $rows = $table->readRows([
        'filter' => $filter
    ]);

    foreach ($rows as $key => $row) {
        // The "print_row" helper function is defined in https://cloud.google.com/bigtable/docs/samples/bigtable-reads-print
        print_row($key, $row);
    }
}

小茹

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

# instance_id = "my-instance"
# table_id    = "my-table"
filter = Google::Cloud::Bigtable::RowFilter.strip_value
read_with_filter instance_id, table_id, filter

組合篩選器

以下各節將說明各個組成篩選器。組合篩選器可讓您將多個篩選器合併為一個，進而對單一讀取要求套用多個篩選器。

Chain

這個篩選器會依序對每個輸出資料列套用一系列篩選器。鏈結篩選器就像使用邏輯 AND。

鏈結中的每個篩選器只會看到前一個篩選器的輸出內容。舉例來說，如果您鏈結兩個篩選器，且第一個篩選器從輸出資料列中移除一半的儲存格，則第二個篩選器無法存取已移除的儲存格。

換句話說，篩選器的順序很重要。如果變更鏈結篩選器的順序，輸出資料列中的資料可能會不同。

舉例來說，如果您只想查看每筆記錄的最新數據方案設定，而不讀取 stats_summary 欄，可以將每個資料欄的儲存格數量限制篩選器 1 與 cell_plan 的資料欄系列規則運算式篩選器鏈結。在範例資料集中，下列程式碼範例會省略所有 stats_summary 儲存格，並只傳回每個已填入 cell_plan 資料欄的最新儲存格。對於 phone#4c410523#20190501 列，系統會省略 data_plan_01gb 中較舊的 true@time minus one hour 儲存格，僅傳回 data_plan_01gb 中的 false@time 儲存格和 data_plan_05gb 中的儲存格，而其他四列則各自傳回單一 cell_plan 儲存格。

Go

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

def filter_composing_chain(project_id, instance_id, table_id):
    from google.cloud import bigtable
    from google.cloud.bigtable import row_filters

    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)

Python asyncio

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

async def filter_composing_chain(project_id, instance_id, table_id):
    from google.cloud.bigtable.data import (
        BigtableDataClientAsync,
        ReadRowsQuery,
        row_filters,
    )

    query = ReadRowsQuery(
        row_filter=row_filters.RowFilterChain(
            filters=[
                row_filters.CellsColumnLimitFilter(1),
                row_filters.FamilyNameRegexFilter("cell_plan"),
            ]
        )
    )

    async with BigtableDataClientAsync(project=project_id) as client:
        async with client.get_table(instance_id, table_id) as table:
            for row in await table.read_rows(query):
                print_row(row)

C#

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

/// <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 Task<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++

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

namespace cbt = ::google::cloud::bigtable;
using ::google::cloud::StatusOr;
[](cbt::Table table) {
  cbt::Filter filter = cbt::Filter::Chain(
      cbt::Filter::Latest(1), cbt::Filter::FamilyRegex("cell_plan"));
  // Read and print the rows.
  for (StatusOr<cbt::Row>& row :
       table.ReadRows(cbt::RowSet(cbt::RowRange::InfiniteRange()), filter)) {
    if (!row) throw std::move(row).status();
    std::cout << row->row_key() << " = ";
    for (auto const& cell : row->cells()) {
      std::cout << "[" << cell.family_name() << ", "
                << cell.column_qualifier() << ", " << cell.value() << "],";
    }
    std::cout << "\n";
  }
}

Node.js

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

PHP

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

use Google\Cloud\Bigtable\BigtableClient;
use Google\Cloud\Bigtable\Filter;

/**
 * Create a composite filter using chaining
 *
 * @param string $projectId The Google Cloud project ID
 * @param string $instanceId The ID of the Bigtable instance
 * @param string $tableId The ID of the table to read from
 */
function filter_composing_chain(
    string $projectId,
    string $instanceId,
    string $tableId
): void {
    // Connect to an existing table with an existing instance.
    $dataClient = new BigtableClient([
        'projectId' => $projectId,
    ]);
    $table = $dataClient->table($instanceId, $tableId);

    $filter = Filter::chain()
        ->addFilter(Filter::limit()->cellsPerColumn(1))
        ->addFilter(Filter::family()->exactMatch('cell_plan'));

    $rows = $table->readRows([
        'filter' => $filter
    ]);

    foreach ($rows as $key => $row) {
        // The "print_row" helper function is defined in https://cloud.google.com/bigtable/docs/samples/bigtable-reads-print
        print_row($key, $row);
    }
}

小茹

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

# instance_id = "my-instance"
# table_id    = "my-table"
filter = Google::Cloud::Bigtable::RowFilter.chain.cells_per_column(1).family("cell_plan")
read_with_filter instance_id, table_id, filter

交錯

這個篩選器會將輸入資料列傳送至多個元件篩選器，並從每個元件篩選器產生暫時輸出資料列。接著，暫時輸出資料列中的所有儲存格會合併為最終輸出資料列。交錯篩選器就像使用邏輯 OR。

交錯可能會導致輸出資料列中的儲存格重複。舉例來說，如果交錯包含兩個篩選器，且兩個篩選器的暫時輸出資料列都包含特定儲存格，則最終輸出資料列會包含該儲存格的兩個副本。

如果元件篩選器輸出多個儲存格，且這些儲存格都具有相同的資料欄系列、資料欄限定詞和時間戳記，則最終輸出資料列會以未指定的順序將所有這些儲存格分組在一起。

舉例來說，如果您想在單一要求中讀取每部裝置的 OS 版本，以及設為 true 的任何數據方案儲存格，可以將這兩項條件合併為交錯篩選器。下列程式碼範例會交錯使用 true 的值規則運算式篩選器，以及 os_build 的資料欄限定詞規則運算式篩選器。套用至範例資料集時，這個篩選器會傳回 stats_summary:os_build 儲存格，以及五個資料列中值為 true 的所有 cell_plan 儲存格，並省略 cell_plan:data_plan_01gb 中 phone#4c410523#20190501 的 false@time 儲存格，以及 connected_cell 和 connected_wifi 欄。

Go

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

def filter_composing_interleave(project_id, instance_id, table_id):
    from google.cloud import bigtable
    from google.cloud.bigtable import row_filters

    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)

Python asyncio

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

async def filter_composing_interleave(project_id, instance_id, table_id):
    from google.cloud.bigtable.data import (
        BigtableDataClientAsync,
        ReadRowsQuery,
        row_filters,
    )

    query = ReadRowsQuery(
        row_filter=row_filters.RowFilterUnion(
            filters=[
                row_filters.ValueRegexFilter("true"),
                row_filters.ColumnQualifierRegexFilter("os_build"),
            ]
        )
    )

    async with BigtableDataClientAsync(project=project_id) as client:
        async with client.get_table(instance_id, table_id) as table:
            for row in await table.read_rows(query):
                print_row(row)

C#

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

/// <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 Task<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++

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

namespace cbt = ::google::cloud::bigtable;
using ::google::cloud::StatusOr;
[](cbt::Table table) {
  cbt::Filter filter = cbt::Filter::Interleave(
      cbt::Filter::ValueRegex("true"), cbt::Filter::ColumnRegex("os_build"));
  // Read and print the rows.
  for (StatusOr<cbt::Row>& row :
       table.ReadRows(cbt::RowSet(cbt::RowRange::InfiniteRange()), filter)) {
    if (!row) throw std::move(row).status();
    std::cout << row->row_key() << " = ";
    for (auto const& cell : row->cells()) {
      std::cout << "[" << cell.family_name() << ", "
                << cell.column_qualifier() << ", " << cell.value() << "],";
    }
    std::cout << "\n";
  }
}

Node.js

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

PHP

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

use Google\Cloud\Bigtable\BigtableClient;
use Google\Cloud\Bigtable\Filter;

/**
 * Create a composite filter using interleaving
 *
 * @param string $projectId The Google Cloud project ID
 * @param string $instanceId The ID of the Bigtable instance
 * @param string $tableId The ID of the table to read from
 */
function filter_composing_interleave(
    string $projectId,
    string $instanceId,
    string $tableId
): void {
    // Connect to an existing table with an existing instance.
    $dataClient = new BigtableClient([
        'projectId' => $projectId,
    ]);
    $table = $dataClient->table($instanceId, $tableId);

    $filter = Filter::interleave()
        ->addFilter(Filter::value()->exactMatch('1'))
        ->addFilter(Filter::qualifier()->exactMatch('os_build'));

    $rows = $table->readRows([
        'filter' => $filter
    ]);

    foreach ($rows as $key => $row) {
        // The "print_row" helper function is defined in https://cloud.google.com/bigtable/docs/samples/bigtable-reads-print
        print_row($key, $row);
    }
}

小茹

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

# instance_id = "my-instance"
# table_id    = "my-table"
filter = Google::Cloud::Bigtable::RowFilter.interleave.value("true").qualifier("os_build")
read_with_filter instance_id, table_id, filter

條件

這個篩選器會對輸入資料列套用真篩選器或假篩選器。

注意：條件篩選器的速度比其他篩選器慢得多，尤其是條件篩選器指定 false 篩選器時。建議您不要使用條件篩選器。

如要在 true 和 false 篩選器之間選擇，請對輸入資料列套用「述詞篩選器」。如果述詞篩選器的輸出內容包含至少一個儲存格，系統就會套用 true 篩選器。如果述詞篩選器的輸出內容空白，則會套用 false 篩選器。

述詞篩選器的輸出資料列僅用於選擇 true 和 false 篩選器。不會顯示在讀取要求的回應中。

述詞篩選器不會與 true 或 false 篩選器一起執行。換句話說，輸入資料列中的資料可能會在執行述詞篩選器和執行 true 或 false 篩選器之間變更。這種行為可能會導致結果不一致或不符預期。

使用條件篩選器時，可以省略 true 或 false 篩選器。省略篩選器等同於指定 block all 篩選器。如果述詞篩選器選擇了您省略的條件，輸出資料列就會是空白。

下列程式碼範例使用述詞篩選器，將 data_plan_10gb 的資料欄限定詞規則運算式篩選器，與 true 的值規則運算式篩選器鏈結，檢查記錄是否有有效的 10 GB 數據方案。在範例資料集中，phone#5c10102#20190501 和 phone#5c10102#20190502 列符合述詞，因此 true 篩選器會將 passed-filter 標籤套用至這兩列的所有儲存格。三個 phone#4c410523 資料列在 data_plan_10gb 中沒有相符的儲存格，因此 false 篩選器會將 filtered-out 標籤套用至這些資料列中的所有儲存格。

Go

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

這個用戶端程式庫不支援此篩選器。

Java

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

def filter_composing_condition(project_id, instance_id, table_id):
    from google.cloud import bigtable
    from google.cloud.bigtable import row_filters

    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)

Python asyncio

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

async def filter_composing_condition(project_id, instance_id, table_id):
    from google.cloud.bigtable.data import (
        BigtableDataClientAsync,
        ReadRowsQuery,
        row_filters,
    )

    query = ReadRowsQuery(
        row_filter=row_filters.ConditionalRowFilter(
            predicate_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"),
        )
    )

    async with BigtableDataClientAsync(project=project_id) as client:
        async with client.get_table(instance_id, table_id) as table:
            for row in await table.read_rows(query):
                print_row(row)

C#

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

/// <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 Task<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++

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

namespace cbt = ::google::cloud::bigtable;
using ::google::cloud::StatusOr;
[](cbt::Table table) {
  cbt::Filter filter = cbt::Filter::Condition(
      cbt::Filter::Chain(cbt::Filter::ValueRegex("true"),
                         cbt::Filter::ColumnRegex("data_plan_10gb")),
      cbt::Filter::ApplyLabelTransformer("passed-filter"),
      cbt::Filter::ApplyLabelTransformer("filtered-out"));
  // Read and print the rows.
  for (StatusOr<cbt::Row>& row :
       table.ReadRows(cbt::RowSet(cbt::RowRange::InfiniteRange()), filter)) {
    if (!row) throw std::move(row).status();
    std::cout << row->row_key() << " = ";
    for (auto const& cell : row->cells()) {
      std::cout << "[" << cell.family_name() << ", "
                << cell.column_qualifier() << ", " << cell.value()
                << ", label(";
      for (auto const& label : cell.labels()) {
        std::cout << label << ",";
      }
      std::cout << ")],";
    }
    std::cout << "\n";
  }
}

Node.js

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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

PHP

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

use Google\Cloud\Bigtable\BigtableClient;
use Google\Cloud\Bigtable\Filter;

/**
 * Create a composite filter using a conditional
 *
 * @param string $projectId The Google Cloud project ID
 * @param string $instanceId The ID of the Bigtable instance
 * @param string $tableId The ID of the table to read from
 */
function filter_composing_condition(
    string $projectId,
    string $instanceId,
    string $tableId
): void {
    // Connect to an existing table with an existing instance.
    $dataClient = new BigtableClient([
        'projectId' => $projectId,
    ]);
    $table = $dataClient->table($instanceId, $tableId);

    $filter = Filter::condition(
        Filter::chain()
            ->addFilter(Filter::value()->exactMatch('1'))
            ->addFilter(Filter::qualifier()->exactMatch('data_plan_10gb'))
    )
        ->then(Filter::label('passed-filter'))
        ->otherwise(Filter::label('filtered-out'));

    $rows = $table->readRows([
        'filter' => $filter
    ]);

    foreach ($rows as $key => $row) {
        // The "print_row" helper function is defined in https://cloud.google.com/bigtable/docs/samples/bigtable-reads-print
        print_row($key, $row);
    }
}

小茹

如要瞭解如何安裝及使用 Bigtable 的用戶端程式庫，請參閱「Bigtable 用戶端程式庫」。

如要向 Bigtable 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

# instance_id = "my-instance"
# table_id    = "my-table"
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 instance_id, table_id, filter

後續步驟

• 閱讀讀取作業總覽。
• 瞭解寫入作業。