a !fy<@sdZddlmZddlmZddlmZddlmZ ddl m Z ddl m Z ddl mZdd l mZdd l mZdd lmZGd d d eZdddZdS)z8User friendly container for Google Cloud Bigtable Table.) _to_bytes) bigtable_pb2)bigtable_table_admin_pb2) table_pb2)_gc_rule_from_pb ColumnFamily) AppendRow)ConditionalRow) DirectRow)PartialRowsDatac@s~eZdZdZddZeddZdddZdd d Zd d Z ddZ dddZ ddZ ddZ d ddZd!ddZddZdS)"TableaRepresentation of a Google Cloud Bigtable Table. .. note:: We don't define any properties on a table other than the name. The only other fields are ``column_families`` and ``granularity``, The ``column_families`` are not stored locally and ``granularity`` is an enum with only one value. We can use a :class:`Table` to: * :meth:`create` the table * :meth:`rename` the table * :meth:`delete` the table * :meth:`list_column_families` in the table :type table_id: str :param table_id: The ID of the table. :type instance: :class:`Instance <.instance.Instance>` :param instance: The instance that owns the table. cCs||_||_dSN)table_id _instance)selfrinstancerV/var/www/html/python-backend/venv/lib/python3.9/site-packages/gcloud/bigtable/table.py__init__8szTable.__init__cCs|jjd|jS)aETable name used in requests. .. note:: This property will not change if ``table_id`` does not, but the return value is not cached. The table name is of the form ``"projects/../instances/../tables/{table_id}"`` :rtype: str :returns: The table name. z/tables/)rnamer)rrrrr<sz Table.nameNcCst|||dS)a Factory to create a column family associated with this table. :type column_family_id: str :param column_family_id: The ID of the column family. Must be of the form ``[_a-zA-Z0-9][-_.a-zA-Z0-9]*``. :type gc_rule: :class:`.GarbageCollectionRule` :param gc_rule: (Optional) The garbage collection settings for this column family. :rtype: :class:`.ColumnFamily` :returns: A column family owned by this table. gc_ruler)rcolumn_family_idrrrr column_familyNszTable.column_familyFcCsF|r|durtd|r"t||S|dur8t|||dSt||SdS)a-Factory to create a row associated with this table. .. warning:: At most one of ``filter_`` and ``append`` can be used in a :class:`Row`. :type row_key: bytes :param row_key: The key for the row being created. :type filter_: :class:`.RowFilter` :param filter_: (Optional) Filter to be used for conditional mutations. See :class:`.DirectRow` for more details. :type append: bool :param append: (Optional) Flag to determine if the row should be used for append mutations. :rtype: :class:`.DirectRow` :returns: A row owned by this table. :raises: :class:`ValueError ` if both ``filter_`` and ``append`` are used. Nz,At most one of filter_ and append can be set)filter_) ValueErrorr r r )rrow_keyrappendrrrrow^s  z Table.rowcCs(t||jsdS|j|jko&|j|jkS)NF) isinstance __class__rrrotherrrr__eq__s    z Table.__eq__cCs || Sr)r$r"rrr__ne__sz Table.__ne__rcs|dur"tjjfdd|D}d}|rVt}|D]}|j}|j||q6tj|p`g|j j |j |d}|j j }|j ||jdS)aCreates this table. .. note:: A create request returns a :class:`._generated.table_pb2.Table` but we don't use this response. :type initial_split_keys: list :param initial_split_keys: (Optional) List of row keys that will be used to initially split the table into several tablets (Tablets are similar to HBase regions). Given two split keys, ``"s1"`` and ``"s2"``, three tablets will be created, spanning the key ranges: ``[, s1)``, ``[s1, s2)``, ``[s2, )``. :type column_families: list :param column_families: (Optional) List or other iterable of :class:`.ColumnFamily` instances. Ncsg|]}|dqS))keyr).0r&Zsplit_pbrr sz Table.create..)Zinitial_splitsparentrtable)table_admin_messages_v2_pb2ZCreateTableRequestZSplit table_v2_pb2r rcolumn_familiesZ MergeFromto_pbrrr_client _table_stubZ CreateTabletimeout_seconds)rZinitial_split_keysr.table_pbZcol_famZcurr_id request_pbclientrr(rcreates& z Table.createcCs*tj|jd}|jj}|j||jdS)zDelete this table.rN)r,ZDeleteTableRequestrrr0r1Z DeleteTabler2)rr4r5rrrdeletes z Table.deletec Csbtj|jd}|jj}|j||j}i}|j D](\}}t |j }|j ||d}|||<q4|S)aList the column families owned by this table. :rtype: dict :returns: Dictionary of column families attached to this table. Keys are strings (column family names) and values are :class:`.ColumnFamily` instances. :raises: :class:`ValueError ` if the column family name from the response does not agree with the computed name from the column family ID. r7r) r,ZGetTableRequestrrr0r1ZGetTabler2r.itemsrrr) rr4r5r3resultrZvalue_pbrrrrrlist_column_familiess   zTable.list_column_familiescCsnt|j||d}|jj}|j||j}t|}||j |j |j fvrRt dt |jdkrddS|j|S)aRead a single row from this table. :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 ` :returns: The contents of the row if any chunks were returned in the response, otherwise :data:`None`. :raises: :class:`ValueError ` if a commit row chunk is never encountered. )rrz+The row remains partial / is not committed.rN)_create_row_requestrrr0 _data_stubReadRowsr2r Z consume_allstateZNEW_ROWSTARTrlenrows)rrrr4r5response_iteratorZ rows_datarrrread_rowszTable.read_rowcCs4t|j||||d}|jj}|j||j}t|S)aRead rows from this table. :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 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 filter_: :class:`.RowFilter` :param filter_: (Optional) The filter to apply to the contents of the specified row(s). If unset, reads every column in each row. :rtype: :class:`.PartialRowsData` :returns: A :class:`.PartialRowsData` convenience wrapper for consuming the streamed results. ) start_keyend_keyrlimit)r<rrr0r=r>r2r )rrErFrGrr4r5rCrrr read_rowss zTable.read_rowscCs*tj|jd}|jj}|j||j}|S)aRead a sample of row keys in the table. The returned row keys will delimit contiguous sections of the table of approximately equal size, which can be used to break up the data for distributed tasks like mapreduces. The elements in the iterator are a SampleRowKeys response and they have the properties ``offset_bytes`` and ``row_key``. They occur in sorted order. The table might have contents before the first row key in the list and after the last one, but a key containing the empty string indicates "end of table" and will be the last response given, if present. .. note:: Row keys in this list may not have ever been written to or read from, and users should therefore not make any assumptions about the row key structure that are specific to their use case. The ``offset_bytes`` field on a response indicates the approximate total storage space used by all rows in the table which precede ``row_key``. Buffering the contents of all rows between two subsequent samples would require space roughly equal to the difference in their ``offset_bytes`` fields. :rtype: :class:`grpc.framework.alpha._reexport._CancellableIterator` :returns: A cancel-able iterator. Can be consumed by calling ``next()`` or by casting to a :class:`list` and can be cancelled by calling ``cancel()``. ) table_name)data_messages_v2_pb2ZSampleRowKeysRequestrrr0r=Z SampleRowKeysr2)rr4r5rCrrrsample_row_keysszTable.sample_row_keys)N)NF)Nr)N)NNNN)__name__ __module__ __qualname____doc__rpropertyrrrr$r%r6r8r;rDrHrKrrrrr s    ! ,  %r Nc Csd|i}|dur(|dus |dur(tdi}|dus<|durd|durPt||d<|durdt||d<|durx||d<|dur||d<tjfi|}|dur|jjt||r|jjj fi||S)afCreates 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. :rtype: :class:`data_messages_v2_pb2.ReadRowsRequest` :returns: The ``ReadRowsRequest`` protobuf corresponding to the inputs. :raises: :class:`ValueError ` if both ``row_key`` and one of ``start_key`` and ``end_key`` are set rINz2Row key and row range cannot be set simultaneouslyZstart_key_closedZ end_key_openfilterZ rows_limit) rrr/rJZReadRowsRequestrBZrow_keysrZ row_rangesadd) rIrrErFrrGZrequest_kwargsZ range_kwargsmessagerrrr<As."   r<)NNNNN)rOZgcloud._helpersrZgcloud.bigtable._generatedrrJrr,rr-Zgcloud.bigtable.column_familyrrZgcloud.bigtable.rowr r r Zgcloud.bigtable.row_datar objectr r<rrrrs           #