필터 사용

Cloud Bigtable가 제공하는 필터 유형은 다음과 같습니다.

  • 제한 필터: 응답에 포함되는 행 또는 셀을 제어합니다.
  • 수정 필터: 개별 셀의 데이터 또는 메타데이터에 영향을 줍니다.
  • 구성 필터: 여러 필터를 하나로 통합할 수 있습니다.

이 페이지에서는 각 Cloud Bigtable 필터를 자세히 설명하고 Cloud 클라이언트 라이브러리를 통해 각 필터 유형을 사용하는 방법을 보여줍니다. 이 페이지를 읽기 전에 Cloud Bigtable 필터 개요를 읽어보세요.

필터를 사용하여 여러 행의 데이터를 읽는 방법을 보여주는 추가 샘플은 데이터 읽기에서 확인할 수 있습니다.

예시 데이터

이 페이지의 예시에서는 스마트폰 및 태블릿용 시계열 데이터를 저장하고 다음 데이터가 테이블에 기록되었다고 가정합니다. 테이블에는 stats_summarycell_plan이라는 두 개의 column family가 있습니다. 각 column family에는 세 개의 열이 있습니다.

stats_summary cell_plan
row key 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 빼기 한 시간

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

제한 필터

다음 섹션에서는 각 제한 필터에 대해 설명합니다. 제한 필터는 특정 기준과 일치하는지 여부에 따라 응답에 포함되는 행 또는 셀을 제어합니다.

체인을 사용하여 여러 제한 필터를 결합하는 경우 체인에서 각 필터의 입력 행은 이전 필터의 출력 행이라는 점에 주의하세요. 예를 들어 두 필터를 연결하고 첫 번째 필터가 원래 행의 셀 2개만 출력하는 경우 두 번째 필터는 이 2개의 셀만 보게 됩니다.

행 선택 필터

행 샘플

이 필터를 사용하면 지정된 범위 내의 무작위 행 샘플을 검색할 수 있습니다. 필터는 지정한 확률에 따라 출력 행이 입력 행과 동일해야 하는지 아니면 결과에서 생략되어야 하는지 무작위로 선택합니다.

Go

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

HBase

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

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

자바

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

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

Python

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

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

C#

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

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

C++

이 코드 샘플은 곧 제공될 예정입니다.

Node.js

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

PHP

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

Ruby

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

row key 정규식

이 필터는 입력 행의 row key가 정규 표현식과 일치하는지 확인합니다. row key가 일치하면 출력 행은 입력 행과 동일합니다. row key가 일치하지 않으면 출력 행이 비어 있습니다.

정규 표현식은 RE2 구문을 사용해야 합니다. row key에는 줄 바꿈 문자 등 임의 바이트가 포함될 수 있으므로 대부분의 경우 \C를 와일드 카드 표현식으로 사용해야 합니다. . 표현식은 줄 바꿈 문자와 일치하지 않습니다.

Go

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

HBase

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

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

자바

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

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

Python

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

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

C#

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

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

C++

이 코드 샘플은 곧 제공될 예정입니다.

Node.js

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

PHP

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

Ruby

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

셀 선택 필터

열당 셀 한도

이 필터는 각 열에서 출력 행에 포함되는 셀 수를 제한합니다. 이 필터가 적용되면 각 출력 행에 각 열의 가장 최근 셀 N개가 포함되며 해당 열의 다른 모든 셀은 생략됩니다.

인터리브 필터도 사용 중이고 인터리브 필터가 셀의 중복 복사본을 생성하는 경우 각 복사본이 한도에 포함됩니다.

Go

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

HBase

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

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

자바

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

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

Python

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

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

C#

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

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

C++

이 코드 샘플은 곧 제공될 예정입니다.

Node.js

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

PHP

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

Ruby

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

행당 셀 한도

이 필터는 각 출력 행의 셀 수를 제한합니다. 이 필터가 적용되면 각 출력 행에 입력 행의 처음 N개의 셀이 포함되고 다음에 오는 모든 셀은 해당 행에서 생략됩니다. 처음 N개의 셀은 어느 열에 있는지에 관계없이 저장된 순서로 읽힙니다.

행의 열 하나에 여러 개의 셀이 포함될 수 있습니다. 각 셀에는 열의 값과 고유한 타임스탬프가 포함됩니다. 따라서 행을 N개의 셀로 제한하는 것과 행에서 처음 N개의 열을 검색하는 것은 다를 수 있습니다. 예를 들어 행당 셀 한도가 20인 필터를 사용하여 열이 30개인 행을 읽고 각 열에 타임스탬프가 지정된 셀이 10개 있는 경우 출력 행은 행의 처음 두 열에서만 값을 반환합니다(2 * 10 = 20).

큰 행 읽기가 필요한 경우 이 필터를 오프셋 필터와 함께 사용하면 페이지 나누기에 유용합니다.

Go

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

HBase

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

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

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

자바

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

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

Python

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

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

C#

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

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

C++

이 코드 샘플은 곧 제공될 예정입니다.

Node.js

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

PHP

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

Ruby

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

행당 셀 오프셋

이 필터는 각 출력 행에서 처음 N개의 셀을 생략합니다. 나머지 셀은 모두 출력 행에 포함됩니다. 처음 N개의 셀은 어느 열에 있든 건너뜁니다.

행의 열 하나에 여러 개의 셀이 포함될 수 있습니다. 각 셀에는 열의 값과 고유한 타임스탬프가 포함됩니다. 따라서 행에서 처음 N개의 셀을 건너뛰는 것과 행의 처음 N개의 열을 건너뛰는 것은 다를 수 있습니다. 예를 들어 행당 셀 오프셋이 20인 필터를 사용하여 열이 30개인 행을 읽고 각 열에 타임스탬프가 지정된 셀이 10개 있는 경우 출력 행은 처음 두 열의 셀을 제외한 행의 모든 셀 값을 반환합니다(2 * 10 = 20).

인터리브 필터도 사용 중이고 인터리브 필터가 셀의 중복 복사본을 생성하는 경우 각 복사본이 오프셋에 포함됩니다.

Go

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

HBase

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

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

자바

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

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

Python

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

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

C#

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

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

C++

이 코드 샘플은 곧 제공될 예정입니다.

Node.js

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

PHP

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

Ruby

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

column family 정규식

이 필터는 셀의 column family가 정규 표현식과 일치하는 경우에만 출력 행에 셀을 포함합니다.

정규 표현식은 RE2 구문을 사용해야 합니다. : 문자가 리터럴로 사용되지 않더라도 정규 표현식에 이 문자를 포함해서는 안 됩니다. column family는 줄 바꿈 문자를 포함할 수 없으므로 . 또는 \C를 와일드 카드 표현식으로 사용할 수 있습니다.

Go

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

HBase

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

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

자바

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

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

Python

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

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

C#

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

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

C++

이 코드 샘플은 곧 제공될 예정입니다.

Node.js

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

PHP

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

Ruby

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

column qualifier 정규식

이 필터는 셀의 column qualifier가 정규 표현식과 일치하는 경우에만 출력 행에 셀을 포함합니다.

정규 표현식은 RE2 구문을 사용해야 합니다. column qualifier에는 줄 바꿈 문자 등 임의 바이트가 포함될 수 있으므로 대부분의 경우 \C를 와일드 카드 표현식으로 사용해야 합니다. . 표현식은 줄 바꿈 문자와 일치하지 않습니다.

Go

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

HBase

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

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

자바

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

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

Python

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

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

C#

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

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

C++

이 코드 샘플은 곧 제공될 예정입니다.

Node.js

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

PHP

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

Ruby

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

열 범위

이 필터는 셀이 특정 column family에 있고 column qualifier가 특정 범위 내에 있는 경우에만 출력 행에 셀을 포함합니다. 시작 한정자와 종료 한정자를 제공하여 범위를 지정합니다.

Go

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

HBase

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

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

자바

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

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

Python

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

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

C#

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

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

C++

이 코드 샘플은 곧 제공될 예정입니다.

Node.js

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

PHP

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

Ruby

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

값 범위

이 필터는 셀 값이 특정 범위 내에 있는 경우에만 출력 행에 셀을 포함합니다. 시작 값과 종료 값을 제공하여 범위를 지정합니다.

  • 값이 특정 값 앞에 오는 셀을 가져오려면 해당 값을 제외 종료 값으로 지정하고 시작 값을 생략합니다.
  • 값이 특정 값과 같거나 뒤인 셀을 가져오려면 해당 값을 포함 시작 값으로 지정하고 종료 값을 생략합니다.

Go

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

HBase

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

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

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

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

자바

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

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

Python

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

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

    for row in rows:
        print_row(row)

C#

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

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

C++

이 코드 샘플은 곧 제공될 예정입니다.

Node.js

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

PHP

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

Ruby

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

값 정규식

이 필터는 셀의 값이 정규 표현식과 일치하는 경우에만 출력 행에 셀을 포함합니다.

정규 표현식은 RE2 구문을 사용해야 합니다. 값에는 줄 바꿈 문자 등 임의 바이트가 포함될 수 있으므로 대부분의 경우 \C를 와일드 카드 표현식으로 사용해야 합니다. . 표현식은 줄 바꿈 문자와 일치하지 않습니다.

Go

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

HBase

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

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

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

자바

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

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

Python



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

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

C#

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

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

C++

이 코드 샘플은 곧 제공될 예정입니다.

Node.js

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

PHP

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

Ruby

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

타임스탬프 범위

이 필터는 셀의 타임스탬프가 특정 범위 내에 있는 경우에만 출력 행에 셀을 포함합니다. 시작 시간(포함)과 종료 시간(제외)을 제공하여 범위를 지정합니다. 기본 단위는 마이크로초이며, 타임스탬프는 1,000의 배수여야 합니다.

  • 특정 시간보다 타임스탬프가 오래된 셀을 가져오려면 해당 시간을 종료 시간으로 지정하고 시작 시간을 생략하여 제한되지 않도록 합니다.
  • 타임스탬프가 특정 시간보다 크거나 같은 셀을 가져오려면 해당 시간을 시작 시간으로 지정하고 종료 시간을 생략하여 제한되지 않도록 합니다.

Go

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

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

HBase

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

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

자바

참고: 현재 이 클라이언트 라이브러리의 타임스탬프 범위 필터에는 startOpen()endClosed() 메서드가 지원되지 않습니다.

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

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

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

Python

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

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

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

C#

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

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

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

C++

이 코드 샘플은 곧 제공될 예정입니다.

Node.js

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

PHP

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

Ruby

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

read_with_filter project_id, instance_id, table_id, filter

고급 단일 필터

다음 필터는 사용하기 어려울 수 있습니다.

모두 차단

이 필터는 출력 행에서 모든 셀을 삭제합니다.

인터리브 필터를 사용하는 경우 모두 차단 필터와 체인 필터를 결합하여 인터리브의 일부를 일시적으로 사용 중지할 수 있습니다.

Go

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

HBase

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

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

자바

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

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

Python

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

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

C#

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

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

C++

이 코드 샘플은 곧 제공될 예정입니다.

Node.js

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

PHP

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

Ruby

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

모두 통과

이 필터는 출력 행에 입력 행의 모든 셀을 포함합니다. 필터가 없는 읽기와 같습니다.

모두 통과 필터는 여러 필터를 구성 중이고 경우에 따라 셀을 출력해야 하는 경우에 유용합니다.

Go

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

HBase

이 클라이언트 라이브러리는 이 필터를 지원하지 않습니다.

자바

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

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

Python

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

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

C#

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

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

C++

이 코드 샘플은 곧 제공될 예정입니다.

Node.js

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

PHP

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

Ruby

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

싱크

이 필터는 다른 필터가 일반적으로 제거하거나 변경하는 입력 행의 모든 셀도 최종 출력 행에 복사합니다.

필터 체인을 사용하는 경우 다른 제한 필터는 체인의 다음 필터에 대한 입력 행이 되는 자체 출력 행에만 영향을 미칩니다. 싱크 필터는 다릅니다. 싱크 필터는 읽기 결과에 나타나는 최종 출력 행에 셀을 직접 삽입합니다.

예를 들어 다음과 같은 두 개의 필터 체인을 만든다고 가정해 보세요.

  1. 싱크 필터
  2. 행에서 모든 셀을 삭제하는 모두 차단 필터

모두 차단 필터 자체는 읽기 결과에 포함되지 않는 빈 행을 초래합니다. 하지만 싱크 필터는 체인의 다른 필터가 수행하는 작업과 관계없이 입력 행의 모든 셀을 최종 출력 행에 강제로 복사합니다. 따라서 싱크 필터와 모두 차단 필터를 결합하면 필터를 전혀 사용하지 않는 것과 효과가 동일하며, 원래 입력 행과 모든 셀이 읽기 결과에 표시됩니다.

수정 필터

다음 섹션에서는 각 수정 필터에 대해 설명합니다. 수정 필터는 개별 셀의 데이터 또는 메타데이터에 영향을 줍니다.

라벨 적용

이 필터는 행의 모든 셀에 라벨을 추가합니다. 인터리브의 일부로 이 필터를 사용하여 셀을 출력 행에 포함시킨 필터를 표시합니다. 애플리케이션은 각 셀의 라벨을 사용하여 추가 클라이언트 측 처리를 수행할 수 있습니다.

각 라벨은 15자(영문 기준) 이하여야 합니다. 또한 각 라벨은 RE2 정규 표현식 [a-z0-9\\-]+와 일치해야 합니다.

각 셀에는 라벨이 하나만 있을 수 있습니다. 따라서 필터 체인에는 라벨 적용 필터가 한 번만 포함될 수 있습니다.

Go

이 클라이언트 라이브러리는 이 필터를 지원하지 않습니다.

HBase

이 클라이언트 라이브러리는 이 필터를 지원하지 않습니다.

자바

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

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

Python

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

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

C#

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

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

C++

이 코드 샘플은 곧 제공될 예정입니다.

Node.js

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

PHP

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

Ruby

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

값 제거

이 필터는 각 셀의 값을 빈 문자열로 바꿉니다. 이 필터는 기준과 일치하는 행 또는 셀에서 모든 데이터를 검색하는 것이 아니라 그 행 또는 셀의 수만 계산해야 할 때 사용합니다.

Go

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

HBase

이 클라이언트 라이브러리는 이 필터를 지원하지 않습니다.

자바

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

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

Python

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

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

C#

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

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

C++

이 코드 샘플은 곧 제공될 예정입니다.

Node.js

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

PHP

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

Ruby

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

구성 필터

다음 섹션에서는 각 구성 필터에 대해 설명합니다. 구성 필터를 사용하면 여러 필터를 하나로 결합하여 단일 읽기 요청에 필터를 두 개 이상 적용할 수 있습니다.

체인

이 필터는 일련의 필터를 각 출력 행에 순서대로 적용합니다. 체인 필터는 논리곱을 사용하는 것과 같습니다.

체인의 각 필터는 이전 필터의 출력만 봅니다. 예를 들어 두 필터를 연결하고 첫 번째 필터가 출력 행에서 셀의 절반을 삭제하면 두 번째 필터는 삭제된 셀에 액세스할 수 없습니다.

즉 필터의 순서가 중요합니다. 연결된 필터의 순서를 변경하면 출력 행의 데이터가 달라질 수 있습니다.

Go

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

HBase

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

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

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

자바

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

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

Python

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

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

C#

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

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

C++

이 코드 샘플은 곧 제공될 예정입니다.

Node.js

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

PHP

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

Ruby

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

인터리브

이 필터는 여러 구성요소 필터를 통해 입력 행을 전송하여 각 구성요소 필터에서 임시 출력 행을 생성합니다. 그런 다음 임시 출력 행의 모든 셀이 최종 출력 행으로 결합됩니다. 인터리브 필터는 논리합을 사용하는 것과 같습니다.

인터리브를 사용하면 출력 행에서 셀이 중복될 수 있습니다. 예를 들어 인터리브에 두 개의 필터가 포함되어 있고 두 필터 모두 임시 출력 행에 특정 셀을 포함하는 경우 최종 출력 행에는 해당 셀의 복사본 두 개가 포함됩니다.

구성요소 필터가 column family, column qualifier, 타임스탬프가 모두 동일한 여러 셀을 출력하는 경우 최종 출력 행은 이러한 셀을 모두 지정되지 않은 순서로 그룹화합니다.

Go

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

HBase

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

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

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

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

자바

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

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

Python

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

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

C#

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

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

C++

이 코드 샘플은 곧 제공될 예정입니다.

Node.js

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

PHP

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

Ruby

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

조건

이 필터는 입력 행에 true 필터 또는 false 필터를 적용합니다.

true 필터와 false 필터 중 선택하기 위해 입력 행에 조건자 필터가 적용됩니다. 조건자 필터의 출력에 셀이 하나 이상 포함되어 있으면 true 필터가 적용됩니다. 조건자 필터의 출력이 비어 있으면 false 필터가 적용됩니다.

조건자 필터의 출력 행은 true 필터와 false 필터 중 선택하기 위해서만 사용됩니다. 읽기 요청에 대한 응답에는 표시되지 않습니다.

조건자 필터는 true 또는 false 필터를 사용하여 원자적으로 실행되지 않습니다. 즉, 조건자 필터가 실행되는 시간과 true 또는 false 필터가 실행되는 시간 사이에 입력 행의 데이터가 변경될 수 있습니다. 이 동작으로 인해 일관되지 않거나 예기치 않은 결과가 발생할 수 있습니다.

조건 필터를 사용할 때 true 또는 false 필터를 생략할 수 있습니다. 필터를 생략하는 것은 모두 차단 필터를 지정하는 것과 같습니다. 생략한 조건을 조건자 필터가 선택하면 출력 행이 비어 있게 됩니다.

Go

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

HBase

이 클라이언트 라이브러리는 이 필터를 지원하지 않습니다.

자바

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

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

Python

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

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

    ))
    for row in rows:
        print_row(row)

C#

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

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

C++

이 코드 샘플은 곧 제공될 예정입니다.

Node.js

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

PHP

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

Ruby

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

다음 단계