def get_many(self, keys: Sequence[str]) -> Iterator[Tuple[str, bytes]]:
rows = RowSet()
for key in keys:
rows.add_row_key(key)
for row in self._get_table().read_rows(row_set=rows):
yield row.row_key.decode("utf-8"), self.__decode_row(row)
def test_row_set_add_row_key():
from google.cloud.bigtable.row_set import RowSet
row_set = RowSet()
row_set.add_row_key("row_key1")
row_set.add_row_key("row_key2")
assert ["row_key1" == "row_key2"], row_set.row_keys
def read_row(self, row_key, filter_=None):
"""Read a single row from this table.
For example:
.. literalinclude:: snippets_table.py
:start-after: [START bigtable_read_row]
:end-before: [END bigtable_read_row]
:type row_key: bytes
:param row_key: The key of the row to read from.
:type filter_: :class:`.RowFilter`
:param filter_: (Optional) The filter to apply to the contents of the
row. If unset, returns the entire row.
:rtype: :class:`.PartialRowData`, :data:`NoneType <types.NoneType>`
:returns: The contents of the row if any chunks were returned in
the response, otherwise :data:`None`.
:raises: :class:`ValueError <exceptions.ValueError>` if a commit row
chunk is never encountered.
"""
row_set = RowSet()
row_set.add_row_key(row_key)
result_iter = iter(self.read_rows(filter_=filter_, row_set=row_set))
row = next(result_iter, None)
if next(result_iter, None) is not None:
raise ValueError("More than one row was returned.")
return row
def test_table_read_rows_w_row_set(data_table, rows_to_delete):
from google.cloud.bigtable.row_set import RowSet
from google.cloud.bigtable.row_set import RowRange
row_keys = [
b"row_key_1",
b"row_key_2",
b"row_key_3",
b"row_key_4",
b"row_key_5",
b"row_key_6",
b"row_key_7",
b"row_key_8",
b"row_key_9",
]
_populate_table(data_table, rows_to_delete, row_keys)
row_range = RowRange(start_key=b"row_key_3", end_key=b"row_key_7")
row_set = RowSet()
row_set.add_row_range(row_range)
row_set.add_row_key(b"row_key_1")
found_rows = data_table.read_rows(row_set=row_set)
found_row_keys = [row.row_key for row in found_rows]
expected_row_keys = [
row_key for row_key in row_keys[:6] if not row_key.endswith(b"_2")
]
assert found_row_keys == expected_row_keys
def read_row(self, row_key, filter_=None):
"""Read a single row from this table.
For example:
.. literalinclude:: snippets_table.py
:start-after: [START bigtable_read_row]
:end-before: [END bigtable_read_row]
:type row_key: bytes
:param row_key: The key of the row to read from.
:type filter_: :class:`.RowFilter`
:param filter_: (Optional) The filter to apply to the contents of the
row. If unset, returns the entire row.
:rtype: :class:`.PartialRowData`, :data:`NoneType <types.NoneType>`
:returns: The contents of the row if any chunks were returned in
the response, otherwise :data:`None`.
:raises: :class:`ValueError <exceptions.ValueError>` if a commit row
chunk is never encountered.
"""
row_set = RowSet()
row_set.add_row_key(row_key)
result_iter = iter(self.read_rows(filter_=filter_, row_set=row_set))
row = next(result_iter, None)
if next(result_iter, None) is not None:
raise ValueError("More than one row was returned.")
return row
def _get_row_set_from_rows(rows):
"""Return a RowSet object for the given rows
"""
row_set = RowSet()
for row_key in rows:
row_set.add_row_key(row_key)
return row_set
def test_yield_rows_with_row_set(self):
row_keys = [
b'row_key_1', b'row_key_2', b'row_key_3', b'row_key_4',
b'row_key_5', b'row_key_6', b'row_key_7', b'row_key_8',
b'row_key_9'
]
rows = []
for row_key in row_keys:
row = self._table.row(row_key)
row.set_cell(COLUMN_FAMILY_ID1, COL_NAME1, CELL_VAL1)
rows.append(row)
self.rows_to_delete.append(row)
self._table.mutate_rows(rows)
row_set = RowSet()
row_set.add_row_range(
RowRange(start_key=b'row_key_3', end_key=b'row_key_7'))
row_set.add_row_key(b'row_key_1')
read_rows = self._table.yield_rows(row_set=row_set)
expected_row_keys = [
b'row_key_1', b'row_key_3', b'row_key_4', b'row_key_5',
b'row_key_6'
]
found_row_keys = [row.row_key for row in read_rows]
self.assertEqual(found_row_keys, expected_row_keys)
def _get_row_range_with_row_keys(row_index):
row_set = RowSet()
start_index = 0
end_index = row_index
while start_index < end_index:
start_index += 1
key = "beam_key%s" % ('{0:07}'.format(start_index))
row_set.add_row_key(key)
return row_set
def _get_bytes_multi(self, id_list):
rv = {}
rows = RowSet()
for id in id_list:
rows.add_row_key(id)
rv[id] = None
for row in self.connection.read_rows(row_set=rows):
rv[row.row_key.decode("utf-8")] = self.decode_row(row)
return rv
def read_rows(project_id, instance_id, table_id):
client = bigtable.Client(project=project_id, admin=True)
instance = client.instance(instance_id)
table = instance.table(table_id)
row_set = RowSet()
row_set.add_row_key(b"phone#4c410523#20190501")
row_set.add_row_key(b"phone#4c410523#20190502")
rows = table.read_rows(row_set=row_set)
for row in rows:
print_row(row)
def row_generator(self,
row_keys=None,
start_key=None,
end_key=None,
column_families=None,
check_prefix=None):
if row_keys is None and start_key is None:
raise ValueError("use row_keys or start_key parameter")
if start_key is not None and (end_key is None
and check_prefix is None):
raise ValueError(
"use start_key together with end_key or check_prefix")
filters = [CellsColumnLimitFilter(1)]
if column_families is not None:
c_filters = []
for c in column_families:
c_filters.append(FamilyNameRegexFilter(c))
if len(c_filters) == 1:
filters.append(c_filters[0])
elif len(c_filters) > 1:
filters.append(RowFilterUnion(c_filters))
if len(filters) > 1:
filter_ = RowFilterChain(filters=filters)
else:
filter_ = filters[0]
row_set = RowSet()
if row_keys:
for r in row_keys:
row_set.add_row_key(r)
else:
row_set.add_row_range_from_keys(start_key=start_key,
end_key=end_key,
start_inclusive=True,
end_inclusive=True)
generator = self._low_level.read_rows(filter_=filter_, row_set=row_set)
i = -1
for rowdata in generator:
i += 1
if rowdata is None:
if row_keys:
yield (row_keys[i], {})
continue
rk = rowdata.row_key.decode("utf-8")
if check_prefix:
if not rk.startswith(check_prefix):
break
curr_row_dict = self.partial_row_to_ordered_dict(rowdata)
yield (rk, curr_row_dict)
def get_many(self, keys: Sequence[str]) -> Iterator[Tuple[str, bytes]]:
rows = RowSet()
for key in keys:
rows.add_row_key(key)
for row in self._get_table().read_rows(row_set=rows):
value = self.__decode_row(row)
# Even though Bigtable in't going to return empty rows, an empty
# value may be returned by ``__decode_row`` if the the row has
# outlived its TTL, so we need to check its value here.
if value is not None:
yield row.row_key.decode("utf-8"), value
def get(self):
bt_array = []
try:
table = instance.table(bt_table_name)
row_set = RowSet()
for row_key in row_keys:
row_set.add_row_key(row_key)
colFilters = []
for name, bt_name in bt_mapping_dict.items():
colFilters.append(
row_filters.ColumnQualifierRegexFilter(bt_name))
print("before read_rows...")
rows = table.read_rows(
row_set=row_set,
filter_=row_filters.RowFilterChain(filters=[
row_filters.CellsColumnLimitFilter(1),
row_filters.RowFilterUnion(filters=colFilters)
]),
retry=bigtable.table.DEFAULT_RETRY_READ_ROWS.with_deadline(
60.0))
print("after read_rows...")
for row in rows:
print("Reading data for {}:".format(
row.row_key.decode('utf-8')))
for cf, cols in sorted(row.cells.items()):
bt_dict = {}
bt_dict['id'] = row.row_key.decode('utf-8')
key = None
# using BT mapping to return data
for col, cells in sorted(cols.items()):
for cell in cells:
for name, bt_name in bt_mapping_dict.items():
if col.decode('utf-8') == bt_name:
key = name
break
if key is not None:
bt_dict[key] = cell.value.decode('utf-8')
bt_array.append(bt_dict)
except BaseException as error:
logging.error(
'An exception occurred - DemoBigTableGet::get(): {}'.format(
error))
print(bt_array)
return json.dumps(bt_array), 200, {'ContentType': 'application/json'}
def test_row_set__eq__len_row_keys_differ():
from google.cloud.bigtable.row_set import RowSet
row_key1 = b"row_key1"
row_key2 = b"row_key1"
row_set1 = RowSet()
row_set2 = RowSet()
row_set1.add_row_key(row_key1)
row_set1.add_row_key(row_key2)
row_set2.add_row_key(row_key2)
assert not (row_set1 == row_set2)
def get_multi(self, id_list):
if len(id_list) == 1:
id = id_list[0]
return {id: self.get(id)}
rv = {}
rows = RowSet()
for id in id_list:
rows.add_row_key(id)
rv[id] = None
for row in self.connection.read_rows(row_set=rows):
rv[row.row_key] = self.decode_row(row)
return rv
def test_row_set__ne__same_value():
from google.cloud.bigtable.row_set import RowRange
from google.cloud.bigtable.row_set import RowSet
row_key1 = b"row_key1"
row_key2 = b"row_key1"
row_range1 = RowRange(b"row_key4", b"row_key9")
row_range2 = RowRange(b"row_key4", b"row_key9")
row_set1 = RowSet()
row_set2 = RowSet()
row_set1.add_row_key(row_key1)
row_set2.add_row_key(row_key2)
row_set1.add_row_range(row_range1)
row_set2.add_row_range(row_range2)
assert not (row_set1 != row_set2)
def test_row_set__eq__():
from google.cloud.bigtable.row_set import RowRange
from google.cloud.bigtable.row_set import RowSet
row_key1 = b"row_key1"
row_key2 = b"row_key1"
row_range1 = RowRange(b"row_key4", b"row_key9")
row_range2 = RowRange(b"row_key4", b"row_key9")
row_set1 = RowSet()
row_set2 = RowSet()
row_set1.add_row_key(row_key1)
row_set2.add_row_key(row_key2)
row_set1.add_row_range(row_range1)
row_set2.add_row_range(row_range2)
assert row_set1 == row_set2
def test_row_set__update_message_request():
from google.cloud._helpers import _to_bytes
from google.cloud.bigtable.row_set import RowRange
from google.cloud.bigtable.row_set import RowSet
row_set = RowSet()
table_name = "table_name"
row_set.add_row_key("row_key1")
row_range1 = RowRange(b"row_key21", b"row_key29")
row_set.add_row_range(row_range1)
request = _ReadRowsRequestPB(table_name=table_name)
row_set._update_message_request(request)
expected_request = _ReadRowsRequestPB(table_name=table_name)
expected_request.rows.row_keys.append(_to_bytes("row_key1"))
expected_request.rows.row_ranges.append(row_range1.get_range_kwargs())
assert request == expected_request
def get_multi(self, id_list):
if len(id_list) == 1:
return {id_list[0]: self.get(id_list[0])}
cache_items = self._get_cache_items(id_list)
if len(cache_items) == len(id_list):
return cache_items
uncached_ids = [id for id in id_list if id not in cache_items]
rv = {}
rows = RowSet()
for id in uncached_ids:
rows.add_row_key(id)
rv[id] = None
for row in self.connection.read_rows(row_set=rows):
rv[row.row_key] = self.decode_row(row)
self._set_cache_items(rv)
rv.update(cache_items)
return rv
def test_row_set__eq__row_keys_differ():
from google.cloud.bigtable.row_set import RowSet
row_set1 = RowSet()
row_set2 = RowSet()
row_set1.add_row_key(b"row_key1")
row_set1.add_row_key(b"row_key2")
row_set1.add_row_key(b"row_key3")
row_set2.add_row_key(b"row_key1")
row_set2.add_row_key(b"row_key2")
row_set2.add_row_key(b"row_key4")
assert not (row_set1 == row_set2)
def test_yield_rows_with_row_set(self):
row_keys = [
b"row_key_1",
b"row_key_2",
b"row_key_3",
b"row_key_4",
b"row_key_5",
b"row_key_6",
b"row_key_7",
b"row_key_8",
b"row_key_9",
]
rows = []
for row_key in row_keys:
row = self._table.row(row_key)
row.set_cell(COLUMN_FAMILY_ID1, COL_NAME1, CELL_VAL1)
rows.append(row)
self.rows_to_delete.append(row)
self._table.mutate_rows(rows)
row_set = RowSet()
row_set.add_row_range(
RowRange(start_key=b"row_key_3", end_key=b"row_key_7"))
row_set.add_row_key(b"row_key_1")
read_rows = self._table.yield_rows(row_set=row_set)
expected_row_keys = [
b"row_key_1",
b"row_key_3",
b"row_key_4",
b"row_key_5",
b"row_key_6",
]
found_row_keys = [row.row_key for row in read_rows]
self.assertEqual(found_row_keys, expected_row_keys)
def test_yield_rows_with_row_set(self):
row_keys = [
b"row_key_1",
b"row_key_2",
b"row_key_3",
b"row_key_4",
b"row_key_5",
b"row_key_6",
b"row_key_7",
b"row_key_8",
b"row_key_9",
]
rows = []
for row_key in row_keys:
row = self._table.row(row_key)
row.set_cell(COLUMN_FAMILY_ID1, COL_NAME1, CELL_VAL1)
rows.append(row)
self.rows_to_delete.append(row)
self._table.mutate_rows(rows)
row_set = RowSet()
row_set.add_row_range(RowRange(start_key=b"row_key_3", end_key=b"row_key_7"))
row_set.add_row_key(b"row_key_1")
read_rows = self._table.yield_rows(row_set=row_set)
expected_row_keys = [
b"row_key_1",
b"row_key_3",
b"row_key_4",
b"row_key_5",
b"row_key_6",
]
found_row_keys = [row.row_key for row in read_rows]
self.assertEqual(found_row_keys, expected_row_keys)
def _create_row_request(table_name, row_key=None, start_key=None, end_key=None,
filter_=None, limit=None, end_inclusive=False,
app_profile_id=None, row_set=None):
"""Creates a request to read rows in a table.
:type table_name: str
:param table_name: The name of the table to read from.
:type row_key: bytes
:param row_key: (Optional) The key of a specific row to read from.
:type start_key: bytes
:param start_key: (Optional) The beginning of a range of row keys to
read from. The range will include ``start_key``. If
left empty, will be interpreted as the empty string.
:type end_key: bytes
:param end_key: (Optional) The end of a range of row keys to read from.
The range will not include ``end_key``. If left empty,
will be interpreted as an infinite string.
:type filter_: :class:`.RowFilter`
:param filter_: (Optional) The filter to apply to the contents of the
specified row(s). If unset, reads the entire table.
:type limit: int
:param limit: (Optional) The read will terminate after committing to N
rows' worth of results. The default (zero) is to return
all results.
:type end_inclusive: bool
:param end_inclusive: (Optional) Whether the ``end_key`` should be
considered inclusive. The default is False (exclusive).
:type: app_profile_id: str
:param app_profile_id: (Optional) The unique name of the AppProfile.
:type row_set: :class:`row_set.RowSet`
:param filter_: (Optional) The row set containing multiple row keys and
row_ranges.
:rtype: :class:`data_messages_v2_pb2.ReadRowsRequest`
:returns: The ``ReadRowsRequest`` protobuf corresponding to the inputs.
:raises: :class:`ValueError <exceptions.ValueError>` if both
``row_key`` and one of ``start_key`` and ``end_key`` are set
"""
request_kwargs = {'table_name': table_name}
if (row_key is not None and
(start_key is not None or end_key is not None)):
raise ValueError('Row key and row range cannot be '
'set simultaneously')
if (row_key is not None and row_set is not None):
raise ValueError('Row key and row set cannot be '
'set simultaneously')
if ((start_key is not None or end_key is not None) and
row_set is not None):
raise ValueError('Row range and row set cannot be '
'set simultaneously')
if filter_ is not None:
request_kwargs['filter'] = filter_.to_pb()
if limit is not None:
request_kwargs['rows_limit'] = limit
if app_profile_id is not None:
request_kwargs['app_profile_id'] = app_profile_id
message = data_messages_v2_pb2.ReadRowsRequest(**request_kwargs)
if row_key is not None:
row_set = RowSet()
row_set.add_row_key(row_key)
if start_key is not None or end_key is not None:
row_set = RowSet()
row_set.add_row_range(RowRange(start_key, end_key,
end_inclusive=end_inclusive))
if row_set is not None:
row_set._update_message_request(message)
return message
def read_byte_rows(
self,
start_key: Optional[bytes] = None,
end_key: Optional[bytes] = None,
end_key_inclusive: bool = False,
row_keys: Optional[Iterable[bytes]] = None,
columns: Optional[Union[Iterable[column_keys._Column],
column_keys._Column]] = None,
start_time: Optional[datetime.datetime] = None,
end_time: Optional[datetime.datetime] = None,
end_time_inclusive: bool = False
) -> Dict[bytes, Union[Dict[column_keys._Column,
List[bigtable.row_data.Cell]],
List[bigtable.row_data.Cell]]]:
"""Main function for reading a row range or non-contiguous row sets from Bigtable using
`bytes` keys.
Keyword Arguments:
start_key {Optional[bytes]} -- The first row to be read, ignored if `row_keys` is set.
If None, no lower boundary is used. (default: {None})
end_key {Optional[bytes]} -- The end of the row range, ignored if `row_keys` is set.
If None, no upper boundary is used. (default: {None})
end_key_inclusive {bool} -- Whether or not `end_key` itself should be included in the
request, ignored if `row_keys` is set or `end_key` is None. (default: {False})
row_keys {Optional[Iterable[bytes]]} -- An `Iterable` containing possibly
non-contiguous row keys. Takes precedence over `start_key` and `end_key`.
(default: {None})
columns {Optional[Union[Iterable[column_keys._Column], column_keys._Column]]} --
Optional filtering by columns to speed up the query. If `columns` is a single
column (not iterable), the column key will be omitted from the result.
(default: {None})
start_time {Optional[datetime.datetime]} -- Ignore cells with timestamp before
`start_time`. If None, no lower bound. (default: {None})
end_time {Optional[datetime.datetime]} -- Ignore cells with timestamp after `end_time`.
If None, no upper bound. (default: {None})
end_time_inclusive {bool} -- Whether or not `end_time` itself should be included in the
request, ignored if `end_time` is None. (default: {False})
Returns:
Dict[bytes, Union[Dict[column_keys._Column, List[bigtable.row_data.Cell]],
List[bigtable.row_data.Cell]]] --
Returns a dictionary of `byte` rows as keys. Their value will be a mapping of
columns to a List of cells (one cell per timestamp). Each cell has a `value`
property, which returns the deserialized field, and a `timestamp` property, which
returns the timestamp as `datetime.datetime` object.
If only a single `column_keys._Column` was requested, the List of cells will be
attached to the row dictionary directly (skipping the column dictionary).
"""
# Create filters: Column and Time
filter_ = get_time_range_and_column_filter(
columns=columns,
start_time=start_time,
end_time=end_time,
end_inclusive=end_time_inclusive)
# Create filters: Rows
row_set = RowSet()
if row_keys is not None:
for row_key in row_keys:
row_set.add_row_key(row_key)
elif start_key is not None and end_key is not None:
row_set.add_row_range_from_keys(start_key=start_key,
start_inclusive=True,
end_key=end_key,
end_inclusive=end_key_inclusive)
else:
raise cg_exceptions.PreconditionError(
"Need to either provide a valid set of rows, or"
" both, a start row and an end row.")
# Bigtable read with retries
rows = self._execute_read(row_set=row_set, row_filter=filter_)
return rows
def test_bigtable_add_row_add_row_range_add_row_range_from_keys():
row_keys = [
b"row_key_1",
b"row_key_2",
b"row_key_3",
b"row_key_4",
b"row_key_5",
b"row_key_6",
b"row_key_7",
b"row_key_8",
b"row_key_9",
]
rows = []
for row_key in row_keys:
row = Config.TABLE.row(row_key)
row.set_cell(COLUMN_FAMILY_ID, COL_NAME1, CELL_VAL1)
rows.append(row)
Config.TABLE.mutate_rows(rows)
# [START bigtable_add_row_key]
from google.cloud.bigtable import Client
from google.cloud.bigtable.row_set import RowSet
client = Client(admin=True)
instance = client.instance(INSTANCE_ID)
table = instance.table(TABLE_ID)
row_set = RowSet()
row_set.add_row_key(b"row_key_5")
# [END bigtable_add_row_key]
read_rows = table.read_rows(row_set=row_set)
expected_row_keys = [b"row_key_5"]
found_row_keys = [row.row_key for row in read_rows]
assert found_row_keys == expected_row_keys
# [START bigtable_add_row_range]
from google.cloud.bigtable import Client
from google.cloud.bigtable.row_set import RowSet
from google.cloud.bigtable.row_set import RowRange
client = Client(admin=True)
instance = client.instance(INSTANCE_ID)
table = instance.table(TABLE_ID)
row_set = RowSet()
row_set.add_row_range(RowRange(start_key=b"row_key_3", end_key=b"row_key_7"))
# [END bigtable_add_row_range]
read_rows = table.read_rows(row_set=row_set)
expected_row_keys = [b"row_key_3", b"row_key_4", b"row_key_5", b"row_key_6"]
found_row_keys = [row.row_key for row in read_rows]
assert found_row_keys == expected_row_keys
# [START bigtable_row_range_from_keys]
from google.cloud.bigtable import Client
from google.cloud.bigtable.row_set import RowSet
client = Client(admin=True)
instance = client.instance(INSTANCE_ID)
table = instance.table(TABLE_ID)
row_set = RowSet()
row_set.add_row_range_from_keys(start_key=b"row_key_3", end_key=b"row_key_7")
# [END bigtable_row_range_from_keys]
read_rows = table.read_rows(row_set=row_set)
expected_row_keys = [b"row_key_3", b"row_key_4", b"row_key_5", b"row_key_6"]
found_row_keys = [row.row_key for row in read_rows]
assert found_row_keys == expected_row_keys
table.truncate(timeout=200)
def table_id():
from google.cloud.bigtable.row_set import RowSet
client = bigtable.Client(project=PROJECT, admin=True)
instance = client.instance(BIGTABLE_INSTANCE)
table_id = TABLE_ID_PREFIX.format(str(uuid.uuid4())[:16])
table = instance.table(table_id)
if table.exists():
table.delete()
table.create(column_families={'stats_summary': None, 'cell_plan': None})
timestamp = datetime.datetime(2019, 5, 1)
timestamp_minus_hr = datetime.datetime(2019, 5,
1) - datetime.timedelta(hours=1)
row_keys = [
"phone#4c410523#20190501",
"phone#4c410523#20190502",
"phone#4c410523#20190505",
"phone#5c10102#20190501",
"phone#5c10102#20190502",
]
rows = [table.direct_row(row_key) for row_key in row_keys]
rows[0].set_cell("stats_summary", "connected_cell", 1, timestamp)
rows[0].set_cell("stats_summary", "connected_wifi", 1, timestamp)
rows[0].set_cell("stats_summary", "os_build", "PQ2A.190405.003", timestamp)
rows[0].set_cell("cell_plan", "data_plan_01gb", "true", timestamp_minus_hr)
rows[0].set_cell("cell_plan", "data_plan_01gb", "false", timestamp)
rows[0].set_cell("cell_plan", "data_plan_05gb", "true", timestamp)
rows[1].set_cell("stats_summary", "connected_cell", 1, timestamp)
rows[1].set_cell("stats_summary", "connected_wifi", 1, timestamp)
rows[1].set_cell("stats_summary", "os_build", "PQ2A.190405.004", timestamp)
rows[1].set_cell("cell_plan", "data_plan_05gb", "true", timestamp)
rows[2].set_cell("stats_summary", "connected_cell", 0, timestamp)
rows[2].set_cell("stats_summary", "connected_wifi", 1, timestamp)
rows[2].set_cell("stats_summary", "os_build", "PQ2A.190406.000", timestamp)
rows[2].set_cell("cell_plan", "data_plan_05gb", "true", timestamp)
rows[3].set_cell("stats_summary", "connected_cell", 1, timestamp)
rows[3].set_cell("stats_summary", "connected_wifi", 1, timestamp)
rows[3].set_cell("stats_summary", "os_build", "PQ2A.190401.002", timestamp)
rows[3].set_cell("cell_plan", "data_plan_10gb", "true", timestamp)
rows[4].set_cell("stats_summary", "connected_cell", 1, timestamp)
rows[4].set_cell("stats_summary", "connected_wifi", 0, timestamp)
rows[4].set_cell("stats_summary", "os_build", "PQ2A.190406.000", timestamp)
rows[4].set_cell("cell_plan", "data_plan_10gb", "true", timestamp)
table.mutate_rows(rows)
# Ensure mutations have propagated.
row_set = RowSet()
for row_key in row_keys:
row_set.add_row_key(row_key)
fetched = list(table.read_rows(row_set=row_set))
while len(fetched) < len(rows):
time.sleep(5)
fetched = list(table.read_rows(row_set=row_set))
yield table_id
table.delete()
def _create_row_request(table_name,
row_key=None,
start_key=None,
end_key=None,
filter_=None,
limit=None,
end_inclusive=False,
app_profile_id=None,
row_set=None):
"""Creates a request to read rows in a table.
:type table_name: str
:param table_name: The name of the table to read from.
:type row_key: bytes
:param row_key: (Optional) The key of a specific row to read from.
:type start_key: bytes
:param start_key: (Optional) The beginning of a range of row keys to
read from. The range will include ``start_key``. If
left empty, will be interpreted as the empty string.
:type end_key: bytes
:param end_key: (Optional) The end of a range of row keys to read from.
The range will not include ``end_key``. If left empty,
will be interpreted as an infinite string.
:type filter_: :class:`.RowFilter`
:param filter_: (Optional) The filter to apply to the contents of the
specified row(s). If unset, reads the entire table.
:type limit: int
:param limit: (Optional) The read will terminate after committing to N
rows' worth of results. The default (zero) is to return
all results.
:type end_inclusive: bool
:param end_inclusive: (Optional) Whether the ``end_key`` should be
considered inclusive. The default is False (exclusive).
:type: app_profile_id: str
:param app_profile_id: (Optional) The unique name of the AppProfile.
:type row_set: :class:`row_set.RowSet`
:param filter_: (Optional) The row set containing multiple row keys and
row_ranges.
:rtype: :class:`data_messages_v2_pb2.ReadRowsRequest`
:returns: The ``ReadRowsRequest`` protobuf corresponding to the inputs.
:raises: :class:`ValueError <exceptions.ValueError>` if both
``row_key`` and one of ``start_key`` and ``end_key`` are set
"""
request_kwargs = {'table_name': table_name}
if (row_key is not None
and (start_key is not None or end_key is not None)):
raise ValueError('Row key and row range cannot be '
'set simultaneously')
if (row_key is not None and row_set is not None):
raise ValueError('Row key and row set cannot be ' 'set simultaneously')
if ((start_key is not None or end_key is not None)
and row_set is not None):
raise ValueError('Row range and row set cannot be '
'set simultaneously')
if filter_ is not None:
request_kwargs['filter'] = filter_.to_pb()
if limit is not None:
request_kwargs['rows_limit'] = limit
if app_profile_id is not None:
request_kwargs['app_profile_id'] = app_profile_id
message = data_messages_v2_pb2.ReadRowsRequest(**request_kwargs)
if row_key is not None:
row_set = RowSet()
row_set.add_row_key(row_key)
if start_key is not None or end_key is not None:
row_set = RowSet()
row_set.add_row_range(
RowRange(start_key, end_key, end_inclusive=end_inclusive))
if row_set is not None:
row_set._update_message_request(message)
return message
def test_bigtable_add_row_add_row_range_add_row_range_from_keys():
row_keys = [
b"row_key_1",
b"row_key_2",
b"row_key_3",
b"row_key_4",
b"row_key_5",
b"row_key_6",
b"row_key_7",
b"row_key_8",
b"row_key_9",
]
rows = []
for row_key in row_keys:
row = Config.TABLE.row(row_key)
row.set_cell(COLUMN_FAMILY_ID, COL_NAME1, CELL_VAL1)
rows.append(row)
Config.TABLE.mutate_rows(rows)
# [START bigtable_add_row_key]
from google.cloud.bigtable import Client
from google.cloud.bigtable.row_set import RowSet
client = Client(admin=True)
instance = client.instance(INSTANCE_ID)
table = instance.table(TABLE_ID)
row_set = RowSet()
row_set.add_row_key(b"row_key_5")
# [END bigtable_add_row_key]
read_rows = table.read_rows(row_set=row_set)
expected_row_keys = [b"row_key_5"]
found_row_keys = [row.row_key for row in read_rows]
assert found_row_keys == expected_row_keys
# [START bigtable_add_row_range]
from google.cloud.bigtable import Client
from google.cloud.bigtable.row_set import RowSet
from google.cloud.bigtable.row_set import RowRange
client = Client(admin=True)
instance = client.instance(INSTANCE_ID)
table = instance.table(TABLE_ID)
row_set = RowSet()
row_set.add_row_range(RowRange(start_key=b"row_key_3", end_key=b"row_key_7"))
# [END bigtable_add_row_range]
read_rows = table.read_rows(row_set=row_set)
expected_row_keys = [b"row_key_3", b"row_key_4", b"row_key_5", b"row_key_6"]
found_row_keys = [row.row_key for row in read_rows]
assert found_row_keys == expected_row_keys
# [START bigtable_row_range_from_keys]
from google.cloud.bigtable import Client
from google.cloud.bigtable.row_set import RowSet
client = Client(admin=True)
instance = client.instance(INSTANCE_ID)
table = instance.table(TABLE_ID)
row_set = RowSet()
row_set.add_row_range_from_keys(start_key=b"row_key_3", end_key=b"row_key_7")
# [END bigtable_row_range_from_keys]
read_rows = table.read_rows(row_set=row_set)
expected_row_keys = [b"row_key_3", b"row_key_4", b"row_key_5", b"row_key_6"]
found_row_keys = [row.row_key for row in read_rows]
assert found_row_keys == expected_row_keys
table.truncate(timeout=200)