| :py:mod:`airflow.providers.google.cloud.hooks.bigquery` |
| ======================================================= |
| |
| .. py:module:: airflow.providers.google.cloud.hooks.bigquery |
| |
| .. autoapi-nested-parse:: |
| |
| This module contains a BigQuery Hook, as well as a very basic PEP 249 |
| implementation for BigQuery. |
| |
| |
| |
| Module Contents |
| --------------- |
| |
| Classes |
| ~~~~~~~ |
| |
| .. autoapisummary:: |
| |
| airflow.providers.google.cloud.hooks.bigquery.BigQueryHook |
| airflow.providers.google.cloud.hooks.bigquery.BigQueryConnection |
| airflow.providers.google.cloud.hooks.bigquery.BigQueryBaseCursor |
| airflow.providers.google.cloud.hooks.bigquery.BigQueryCursor |
| |
| |
| |
| |
| Attributes |
| ~~~~~~~~~~ |
| |
| .. autoapisummary:: |
| |
| airflow.providers.google.cloud.hooks.bigquery.log |
| airflow.providers.google.cloud.hooks.bigquery.BigQueryJob |
| |
| |
| .. py:data:: log |
| |
| |
| |
| |
| .. py:data:: BigQueryJob |
| |
| |
| |
| |
| .. py:class:: BigQueryHook(gcp_conn_id = GoogleBaseHook.default_conn_name, delegate_to = None, use_legacy_sql = True, location = None, api_resource_configs = None, impersonation_chain = None, labels = None) |
| |
| Bases: :py:obj:`airflow.providers.google.common.hooks.base_google.GoogleBaseHook`, :py:obj:`airflow.hooks.dbapi.DbApiHook` |
| |
| Interact with BigQuery. This hook uses the Google Cloud connection. |
| |
| :param gcp_conn_id: The Airflow connection used for GCP credentials. |
| :param delegate_to: This performs a task on one host with reference to other hosts. |
| :param use_legacy_sql: This specifies whether to use legacy SQL dialect. |
| :param location: The location of the BigQuery resource. |
| :param api_resource_configs: This contains params configuration applied for Google BigQuery jobs. |
| :param impersonation_chain: This is the optional service account to impersonate using short term |
| credentials. |
| :param labels: The BigQuery resource label. |
| |
| .. py:attribute:: conn_name_attr |
| :annotation: = gcp_conn_id |
| |
| |
| |
| .. py:attribute:: default_conn_name |
| :annotation: = google_cloud_bigquery_default |
| |
| |
| |
| .. py:attribute:: conn_type |
| :annotation: = gcpbigquery |
| |
| |
| |
| .. py:attribute:: hook_name |
| :annotation: = Google Bigquery |
| |
| |
| |
| .. py:method:: get_conn(self) |
| |
| Returns a BigQuery PEP 249 connection object. |
| |
| |
| .. py:method:: get_service(self) |
| |
| Returns a BigQuery service object. |
| |
| |
| .. py:method:: get_client(self, project_id = None, location = None) |
| |
| Returns authenticated BigQuery Client. |
| |
| :param project_id: Project ID for the project which the client acts on behalf of. |
| :param location: Default location for jobs / datasets / tables. |
| :return: |
| |
| |
| .. py:method:: get_uri(self) |
| |
| Override DbApiHook get_uri method for get_sqlalchemy_engine() |
| |
| |
| .. py:method:: get_sqlalchemy_engine(self, engine_kwargs=None) |
| |
| Get an sqlalchemy_engine object. |
| |
| :param engine_kwargs: Kwargs used in :func:`~sqlalchemy.create_engine`. |
| :return: the created engine. |
| |
| |
| .. py:method:: get_records(self, sql, parameters=None) |
| |
| Executes the sql and returns a set of records. |
| |
| :param sql: the sql statement to be executed (str) or a list of |
| sql statements to execute |
| :param parameters: The parameters to render the SQL query with. |
| |
| |
| .. py:method:: insert_rows(self, table, rows, target_fields = None, commit_every = 1000, replace = False, **kwargs) |
| :abstractmethod: |
| |
| Insertion is currently unsupported. Theoretically, you could use |
| BigQuery's streaming API to insert rows into a table, but this hasn't |
| been implemented. |
| |
| |
| .. py:method:: get_pandas_df(self, sql, parameters = None, dialect = None, **kwargs) |
| |
| Returns a Pandas DataFrame for the results produced by a BigQuery |
| query. The DbApiHook method must be overridden because Pandas |
| doesn't support PEP 249 connections, except for SQLite. See: |
| |
| https://github.com/pydata/pandas/blob/master/pandas/io/sql.py#L447 |
| https://github.com/pydata/pandas/issues/6900 |
| |
| :param sql: The BigQuery SQL to execute. |
| :param parameters: The parameters to render the SQL query with (not |
| used, leave to override superclass method) |
| :param dialect: Dialect of BigQuery SQL – legacy SQL or standard SQL |
| defaults to use `self.use_legacy_sql` if not specified |
| :param kwargs: (optional) passed into pandas_gbq.read_gbq method |
| |
| |
| .. py:method:: table_exists(self, dataset_id, table_id, project_id) |
| |
| Checks for the existence of a table in Google BigQuery. |
| |
| :param project_id: The Google cloud project in which to look for the |
| table. The connection supplied to the hook must provide access to |
| the specified project. |
| :param dataset_id: The name of the dataset in which to look for the |
| table. |
| :param table_id: The name of the table to check the existence of. |
| |
| |
| .. py:method:: table_partition_exists(self, dataset_id, table_id, partition_id, project_id) |
| |
| Checks for the existence of a partition in a table in Google BigQuery. |
| |
| :param project_id: The Google cloud project in which to look for the |
| table. The connection supplied to the hook must provide access to |
| the specified project. |
| :param dataset_id: The name of the dataset in which to look for the |
| table. |
| :param table_id: The name of the table to check the existence of. |
| :param partition_id: The name of the partition to check the existence of. |
| |
| |
| .. py:method:: create_empty_table(self, project_id = None, dataset_id = None, table_id = None, table_resource = None, schema_fields = None, time_partitioning = None, cluster_fields = None, labels = None, view = None, materialized_view = None, encryption_configuration = None, retry = DEFAULT_RETRY, location = None, exists_ok = True) |
| |
| Creates a new, empty table in the dataset. |
| To create a view, which is defined by a SQL query, parse a dictionary to 'view' kwarg |
| |
| :param project_id: The project to create the table into. |
| :param dataset_id: The dataset to create the table into. |
| :param table_id: The Name of the table to be created. |
| :param table_resource: Table resource as described in documentation: |
| https://cloud.google.com/bigquery/docs/reference/rest/v2/tables#Table |
| If provided all other parameters are ignored. |
| :param schema_fields: If set, the schema field list as defined here: |
| https://cloud.google.com/bigquery/docs/reference/rest/v2/jobs#configuration.load.schema |
| :param labels: a dictionary containing labels for the table, passed to BigQuery |
| :param retry: Optional. How to retry the RPC. |
| |
| **Example**: :: |
| |
| schema_fields=[{"name": "emp_name", "type": "STRING", "mode": "REQUIRED"}, |
| {"name": "salary", "type": "INTEGER", "mode": "NULLABLE"}] |
| |
| :param time_partitioning: configure optional time partitioning fields i.e. |
| partition by field, type and expiration as per API specifications. |
| |
| .. seealso:: |
| https://cloud.google.com/bigquery/docs/reference/rest/v2/tables#timePartitioning |
| :param cluster_fields: [Optional] The fields used for clustering. |
| BigQuery supports clustering for both partitioned and |
| non-partitioned tables. |
| https://cloud.google.com/bigquery/docs/reference/rest/v2/tables#clustering.fields |
| :param view: [Optional] A dictionary containing definition for the view. |
| If set, it will create a view instead of a table: |
| https://cloud.google.com/bigquery/docs/reference/rest/v2/tables#ViewDefinition |
| |
| **Example**: :: |
| |
| view = { |
| "query": "SELECT * FROM `test-project-id.test_dataset_id.test_table_prefix*` LIMIT 1000", |
| "useLegacySql": False |
| } |
| |
| :param materialized_view: [Optional] The materialized view definition. |
| :param encryption_configuration: [Optional] Custom encryption configuration (e.g., Cloud KMS keys). |
| **Example**: :: |
| |
| encryption_configuration = { |
| "kmsKeyName": "projects/testp/locations/us/keyRings/test-kr/cryptoKeys/test-key" |
| } |
| :param num_retries: Maximum number of retries in case of connection problems. |
| :param location: (Optional) The geographic location where the table should reside. |
| :param exists_ok: If ``True``, ignore "already exists" errors when creating the table. |
| :return: Created table |
| |
| |
| .. py:method:: create_empty_dataset(self, dataset_id = None, project_id = None, location = None, dataset_reference = None, exists_ok = True) |
| |
| Create a new empty dataset: |
| https://cloud.google.com/bigquery/docs/reference/rest/v2/datasets/insert |
| |
| :param project_id: The name of the project where we want to create |
| an empty a dataset. Don't need to provide, if projectId in dataset_reference. |
| :param dataset_id: The id of dataset. Don't need to provide, if datasetId in dataset_reference. |
| :param location: (Optional) The geographic location where the dataset should reside. |
| There is no default value but the dataset will be created in US if nothing is provided. |
| :param dataset_reference: Dataset reference that could be provided with request body. More info: |
| https://cloud.google.com/bigquery/docs/reference/rest/v2/datasets#resource |
| :param exists_ok: If ``True``, ignore "already exists" errors when creating the dataset. |
| |
| |
| .. py:method:: get_dataset_tables(self, dataset_id, project_id = None, max_results = None, retry = DEFAULT_RETRY) |
| |
| Get the list of tables for a given dataset. |
| |
| For more information, see: |
| https://cloud.google.com/bigquery/docs/reference/rest/v2/tables/list |
| |
| :param dataset_id: the dataset ID of the requested dataset. |
| :param project_id: (Optional) the project of the requested dataset. If None, |
| self.project_id will be used. |
| :param max_results: (Optional) the maximum number of tables to return. |
| :param retry: How to retry the RPC. |
| :return: List of tables associated with the dataset. |
| |
| |
| .. py:method:: delete_dataset(self, dataset_id, project_id = None, delete_contents = False, retry = DEFAULT_RETRY) |
| |
| Delete a dataset of Big query in your project. |
| |
| :param project_id: The name of the project where we have the dataset. |
| :param dataset_id: The dataset to be delete. |
| :param delete_contents: If True, delete all the tables in the dataset. |
| If False and the dataset contains tables, the request will fail. |
| :param retry: How to retry the RPC. |
| |
| |
| .. py:method:: create_external_table(self, external_project_dataset_table, schema_fields, source_uris, source_format = 'CSV', autodetect = False, compression = 'NONE', ignore_unknown_values = False, max_bad_records = 0, skip_leading_rows = 0, field_delimiter = ',', quote_character = None, allow_quoted_newlines = False, allow_jagged_rows = False, encoding = 'UTF-8', src_fmt_configs = None, labels = None, description = None, encryption_configuration = None, location = None, project_id = None) |
| |
| Creates a new external table in the dataset with the data from Google |
| Cloud Storage. See here: |
| |
| https://cloud.google.com/bigquery/docs/reference/rest/v2/tables#resource |
| |
| for more details about these parameters. |
| |
| :param external_project_dataset_table: |
| The dotted ``(<project>.|<project>:)<dataset>.<table>($<partition>)`` BigQuery |
| table name to create external table. |
| If ``<project>`` is not included, project will be the |
| project defined in the connection json. |
| :param schema_fields: The schema field list as defined here: |
| https://cloud.google.com/bigquery/docs/reference/rest/v2/tables#resource |
| :param source_uris: The source Google Cloud |
| Storage URI (e.g. gs://some-bucket/some-file.txt). A single wild |
| per-object name can be used. |
| :param source_format: File format to export. |
| :param autodetect: Try to detect schema and format options automatically. |
| Any option specified explicitly will be honored. |
| :param compression: [Optional] The compression type of the data source. |
| Possible values include GZIP and NONE. |
| The default value is NONE. |
| This setting is ignored for Google Cloud Bigtable, |
| Google Cloud Datastore backups and Avro formats. |
| :param ignore_unknown_values: [Optional] Indicates if BigQuery should allow |
| extra values that are not represented in the table schema. |
| If true, the extra values are ignored. If false, records with extra columns |
| are treated as bad records, and if there are too many bad records, an |
| invalid error is returned in the job result. |
| :param max_bad_records: The maximum number of bad records that BigQuery can |
| ignore when running the job. |
| :param skip_leading_rows: Number of rows to skip when loading from a CSV. |
| :param field_delimiter: The delimiter to use when loading from a CSV. |
| :param quote_character: The value that is used to quote data sections in a CSV |
| file. |
| :param allow_quoted_newlines: Whether to allow quoted newlines (true) or not |
| (false). |
| :param allow_jagged_rows: Accept rows that are missing trailing optional columns. |
| The missing values are treated as nulls. If false, records with missing |
| trailing columns are treated as bad records, and if there are too many bad |
| records, an invalid error is returned in the job result. Only applicable when |
| source_format is CSV. |
| :param encoding: The character encoding of the data. See: |
| |
| .. seealso:: |
| https://cloud.google.com/bigquery/docs/reference/rest/v2/tables#externalDataConfiguration.csvOptions.encoding |
| :param src_fmt_configs: configure optional fields specific to the source format |
| :param labels: A dictionary containing labels for the BiqQuery table. |
| :param description: A string containing the description for the BigQuery table. |
| :param encryption_configuration: [Optional] Custom encryption configuration (e.g., Cloud KMS keys). |
| **Example**: :: |
| |
| encryption_configuration = { |
| "kmsKeyName": "projects/testp/locations/us/keyRings/test-kr/cryptoKeys/test-key" |
| } |
| |
| |
| .. py:method:: update_table(self, table_resource, fields = None, dataset_id = None, table_id = None, project_id = None) |
| |
| Change some fields of a table. |
| |
| Use ``fields`` to specify which fields to update. At least one field |
| must be provided. If a field is listed in ``fields`` and is ``None`` |
| in ``table``, the field value will be deleted. |
| |
| If ``table.etag`` is not ``None``, the update will only succeed if |
| the table on the server has the same ETag. Thus reading a table with |
| ``get_table``, changing its fields, and then passing it to |
| ``update_table`` will ensure that the changes will only be saved if |
| no modifications to the table occurred since the read. |
| |
| :param project_id: The project to create the table into. |
| :param dataset_id: The dataset to create the table into. |
| :param table_id: The Name of the table to be created. |
| :param table_resource: Table resource as described in documentation: |
| https://cloud.google.com/bigquery/docs/reference/rest/v2/tables#Table |
| The table has to contain ``tableReference`` or ``project_id``, ``dataset_id`` and ``table_id`` |
| have to be provided. |
| :param fields: The fields of ``table`` to change, spelled as the Table |
| properties (e.g. "friendly_name"). |
| |
| |
| .. py:method:: patch_table(self, dataset_id, table_id, project_id = None, description = None, expiration_time = None, external_data_configuration = None, friendly_name = None, labels = None, schema = None, time_partitioning = None, view = None, require_partition_filter = None, encryption_configuration = None) |
| |
| Patch information in an existing table. |
| It only updates fields that are provided in the request object. |
| |
| Reference: https://cloud.google.com/bigquery/docs/reference/rest/v2/tables/patch |
| |
| :param dataset_id: The dataset containing the table to be patched. |
| :param table_id: The Name of the table to be patched. |
| :param project_id: The project containing the table to be patched. |
| :param description: [Optional] A user-friendly description of this table. |
| :param expiration_time: [Optional] The time when this table expires, |
| in milliseconds since the epoch. |
| :param external_data_configuration: [Optional] A dictionary containing |
| properties of a table stored outside of BigQuery. |
| :param friendly_name: [Optional] A descriptive name for this table. |
| :param labels: [Optional] A dictionary containing labels associated with this table. |
| :param schema: [Optional] If set, the schema field list as defined here: |
| https://cloud.google.com/bigquery/docs/reference/rest/v2/jobs#configuration.load.schema |
| The supported schema modifications and unsupported schema modification are listed here: |
| https://cloud.google.com/bigquery/docs/managing-table-schemas |
| **Example**: :: |
| |
| schema=[{"name": "emp_name", "type": "STRING", "mode": "REQUIRED"}, |
| {"name": "salary", "type": "INTEGER", "mode": "NULLABLE"}] |
| |
| :param time_partitioning: [Optional] A dictionary containing time-based partitioning |
| definition for the table. |
| :param view: [Optional] A dictionary containing definition for the view. |
| If set, it will patch a view instead of a table: |
| https://cloud.google.com/bigquery/docs/reference/rest/v2/tables#ViewDefinition |
| **Example**: :: |
| |
| view = { |
| "query": "SELECT * FROM `test-project-id.test_dataset_id.test_table_prefix*` LIMIT 500", |
| "useLegacySql": False |
| } |
| |
| :param require_partition_filter: [Optional] If true, queries over the this table require a |
| partition filter. If false, queries over the table |
| :param encryption_configuration: [Optional] Custom encryption configuration (e.g., Cloud KMS keys). |
| **Example**: :: |
| |
| encryption_configuration = { |
| "kmsKeyName": "projects/testp/locations/us/keyRings/test-kr/cryptoKeys/test-key" |
| } |
| |
| |
| |
| .. py:method:: insert_all(self, project_id, dataset_id, table_id, rows, ignore_unknown_values = False, skip_invalid_rows = False, fail_on_error = False) |
| |
| Method to stream data into BigQuery one record at a time without needing |
| to run a load job |
| |
| .. seealso:: |
| For more information, see: |
| https://cloud.google.com/bigquery/docs/reference/rest/v2/tabledata/insertAll |
| |
| :param project_id: The name of the project where we have the table |
| :param dataset_id: The name of the dataset where we have the table |
| :param table_id: The name of the table |
| :param rows: the rows to insert |
| |
| **Example or rows**: |
| rows=[{"json": {"a_key": "a_value_0"}}, {"json": {"a_key": "a_value_1"}}] |
| |
| :param ignore_unknown_values: [Optional] Accept rows that contain values |
| that do not match the schema. The unknown values are ignored. |
| The default value is false, which treats unknown values as errors. |
| :param skip_invalid_rows: [Optional] Insert all valid rows of a request, |
| even if invalid rows exist. The default value is false, which causes |
| the entire request to fail if any invalid rows exist. |
| :param fail_on_error: [Optional] Force the task to fail if any errors occur. |
| The default value is false, which indicates the task should not fail |
| even if any insertion errors occur. |
| |
| |
| .. py:method:: update_dataset(self, fields, dataset_resource, dataset_id = None, project_id = None, retry = DEFAULT_RETRY) |
| |
| Change some fields of a dataset. |
| |
| Use ``fields`` to specify which fields to update. At least one field |
| must be provided. If a field is listed in ``fields`` and is ``None`` in |
| ``dataset``, it will be deleted. |
| |
| If ``dataset.etag`` is not ``None``, the update will only |
| succeed if the dataset on the server has the same ETag. Thus |
| reading a dataset with ``get_dataset``, changing its fields, |
| and then passing it to ``update_dataset`` will ensure that the changes |
| will only be saved if no modifications to the dataset occurred |
| since the read. |
| |
| :param dataset_resource: Dataset resource that will be provided |
| in request body. |
| https://cloud.google.com/bigquery/docs/reference/rest/v2/datasets#resource |
| :param dataset_id: The id of the dataset. |
| :param fields: The properties of ``dataset`` to change (e.g. "friendly_name"). |
| :param project_id: The Google Cloud Project ID |
| :param retry: How to retry the RPC. |
| |
| |
| .. py:method:: patch_dataset(self, dataset_id, dataset_resource, project_id = None) |
| |
| Patches information in an existing dataset. |
| It only replaces fields that are provided in the submitted dataset resource. |
| More info: |
| https://cloud.google.com/bigquery/docs/reference/rest/v2/datasets/patch |
| |
| :param dataset_id: The BigQuery Dataset ID |
| :param dataset_resource: Dataset resource that will be provided |
| in request body. |
| https://cloud.google.com/bigquery/docs/reference/rest/v2/datasets#resource |
| :param project_id: The Google Cloud Project ID |
| :rtype: dataset |
| https://cloud.google.com/bigquery/docs/reference/rest/v2/datasets#resource |
| |
| |
| .. py:method:: get_dataset_tables_list(self, dataset_id, project_id = None, table_prefix = None, max_results = None) |
| |
| Method returns tables list of a BigQuery tables. If table prefix is specified, |
| only tables beginning by it are returned. |
| |
| For more information, see: |
| https://cloud.google.com/bigquery/docs/reference/rest/v2/tables/list |
| |
| :param dataset_id: The BigQuery Dataset ID |
| :param project_id: The Google Cloud Project ID |
| :param table_prefix: Tables must begin by this prefix to be returned (case sensitive) |
| :param max_results: The maximum number of results to return in a single response page. |
| Leverage the page tokens to iterate through the entire collection. |
| :return: List of tables associated with the dataset |
| |
| |
| .. py:method:: get_datasets_list(self, project_id = None, include_all = False, filter_ = None, max_results = None, page_token = None, retry = DEFAULT_RETRY) |
| |
| Method returns full list of BigQuery datasets in the current project |
| |
| For more information, see: |
| https://cloud.google.com/bigquery/docs/reference/rest/v2/datasets/list |
| |
| :param project_id: Google Cloud Project for which you try to get all datasets |
| :param include_all: True if results include hidden datasets. Defaults to False. |
| :param filter_: An expression for filtering the results by label. For syntax, see |
| https://cloud.google.com/bigquery/docs/reference/rest/v2/datasets/list#filter. |
| :param filter_: str |
| :param max_results: Maximum number of datasets to return. |
| :param max_results: int |
| :param page_token: Token representing a cursor into the datasets. If not passed, |
| the API will return the first page of datasets. The token marks the beginning of the |
| iterator to be returned and the value of the ``page_token`` can be accessed at |
| ``next_page_token`` of the :class:`~google.api_core.page_iterator.HTTPIterator`. |
| :param page_token: str |
| :param retry: How to retry the RPC. |
| |
| |
| .. py:method:: get_dataset(self, dataset_id, project_id = None) |
| |
| Fetch the dataset referenced by dataset_id. |
| |
| :param dataset_id: The BigQuery Dataset ID |
| :param project_id: The Google Cloud Project ID |
| :return: dataset_resource |
| |
| .. seealso:: |
| For more information, see Dataset Resource content: |
| https://cloud.google.com/bigquery/docs/reference/rest/v2/datasets#resource |
| |
| |
| .. py:method:: run_grant_dataset_view_access(self, source_dataset, view_dataset, view_table, view_project = None, project_id = None) |
| |
| Grant authorized view access of a dataset to a view table. |
| If this view has already been granted access to the dataset, do nothing. |
| This method is not atomic. Running it may clobber a simultaneous update. |
| |
| :param source_dataset: the source dataset |
| :param view_dataset: the dataset that the view is in |
| :param view_table: the table of the view |
| :param project_id: the project of the source dataset. If None, |
| self.project_id will be used. |
| :param view_project: the project that the view is in. If None, |
| self.project_id will be used. |
| :return: the datasets resource of the source dataset. |
| |
| |
| .. py:method:: run_table_upsert(self, dataset_id, table_resource, project_id = None) |
| |
| If the table already exists, update the existing table if not create new. |
| Since BigQuery does not natively allow table upserts, this is not an |
| atomic operation. |
| |
| :param dataset_id: the dataset to upsert the table into. |
| :param table_resource: a table resource. see |
| https://cloud.google.com/bigquery/docs/reference/v2/tables#resource |
| :param project_id: the project to upsert the table into. If None, |
| project will be self.project_id. |
| :return: |
| |
| |
| .. py:method:: run_table_delete(self, deletion_dataset_table, ignore_if_missing = False) |
| |
| Delete an existing table from the dataset; |
| If the table does not exist, return an error unless ignore_if_missing |
| is set to True. |
| |
| :param deletion_dataset_table: A dotted |
| ``(<project>.|<project>:)<dataset>.<table>`` that indicates which table |
| will be deleted. |
| :param ignore_if_missing: if True, then return success even if the |
| requested table does not exist. |
| :return: |
| |
| |
| .. py:method:: delete_table(self, table_id, not_found_ok = True, project_id = None) |
| |
| Delete an existing table from the dataset. If the table does not exist, return an error |
| unless not_found_ok is set to True. |
| |
| :param table_id: A dotted ``(<project>.|<project>:)<dataset>.<table>`` |
| that indicates which table will be deleted. |
| :param not_found_ok: if True, then return success even if the |
| requested table does not exist. |
| :param project_id: the project used to perform the request |
| |
| |
| .. py:method:: get_tabledata(self, dataset_id, table_id, max_results = None, selected_fields = None, page_token = None, start_index = None) |
| |
| Get the data of a given dataset.table and optionally with selected columns. |
| see https://cloud.google.com/bigquery/docs/reference/v2/tabledata/list |
| |
| :param dataset_id: the dataset ID of the requested table. |
| :param table_id: the table ID of the requested table. |
| :param max_results: the maximum results to return. |
| :param selected_fields: List of fields to return (comma-separated). If |
| unspecified, all fields are returned. |
| :param page_token: page token, returned from a previous call, |
| identifying the result set. |
| :param start_index: zero based index of the starting row to read. |
| :return: list of rows |
| |
| |
| .. py:method:: list_rows(self, dataset_id, table_id, max_results = None, selected_fields = None, page_token = None, start_index = None, project_id = None, location = None) |
| |
| List the rows of the table. |
| See https://cloud.google.com/bigquery/docs/reference/rest/v2/tabledata/list |
| |
| :param dataset_id: the dataset ID of the requested table. |
| :param table_id: the table ID of the requested table. |
| :param max_results: the maximum results to return. |
| :param selected_fields: List of fields to return (comma-separated). If |
| unspecified, all fields are returned. |
| :param page_token: page token, returned from a previous call, |
| identifying the result set. |
| :param start_index: zero based index of the starting row to read. |
| :param project_id: Project ID for the project which the client acts on behalf of. |
| :param location: Default location for job. |
| :return: list of rows |
| |
| |
| .. py:method:: get_schema(self, dataset_id, table_id, project_id = None) |
| |
| Get the schema for a given dataset and table. |
| see https://cloud.google.com/bigquery/docs/reference/v2/tables#resource |
| |
| :param dataset_id: the dataset ID of the requested table |
| :param table_id: the table ID of the requested table |
| :param project_id: the optional project ID of the requested table. |
| If not provided, the connector's configured project will be used. |
| :return: a table schema |
| |
| |
| .. py:method:: update_table_schema(self, schema_fields_updates, include_policy_tags, dataset_id, table_id, project_id = None) |
| |
| Update fields within a schema for a given dataset and table. Note that |
| some fields in schemas are immutable and trying to change them will cause |
| an exception. |
| If a new field is included it will be inserted which requires all required fields to be set. |
| See https://cloud.google.com/bigquery/docs/reference/rest/v2/tables#TableSchema |
| |
| :param include_policy_tags: If set to True policy tags will be included in |
| the update request which requires special permissions even if unchanged |
| see https://cloud.google.com/bigquery/docs/column-level-security#roles |
| :param dataset_id: the dataset ID of the requested table to be updated |
| :param table_id: the table ID of the table to be updated |
| :param schema_fields_updates: a partial schema resource. see |
| https://cloud.google.com/bigquery/docs/reference/rest/v2/tables#TableSchema |
| |
| **Example**: :: |
| |
| schema_fields_updates=[ |
| {"name": "emp_name", "description": "Some New Description"}, |
| {"name": "salary", "description": "Some New Description"}, |
| {"name": "departments", "fields": [ |
| {"name": "name", "description": "Some New Description"}, |
| {"name": "type", "description": "Some New Description"} |
| ]}, |
| ] |
| |
| :param project_id: The name of the project where we want to update the table. |
| |
| |
| .. py:method:: poll_job_complete(self, job_id, project_id = None, location = None, retry = DEFAULT_RETRY) |
| |
| Check if jobs completed. |
| |
| :param job_id: id of the job. |
| :param project_id: Google Cloud Project where the job is running |
| :param location: location the job is running |
| :param retry: How to retry the RPC. |
| :rtype: bool |
| |
| |
| .. py:method:: cancel_query(self) |
| |
| Cancel all started queries that have not yet completed |
| |
| |
| .. py:method:: cancel_job(self, job_id, project_id = None, location = None) |
| |
| Cancels a job an wait for cancellation to complete |
| |
| :param job_id: id of the job. |
| :param project_id: Google Cloud Project where the job is running |
| :param location: location the job is running |
| |
| |
| .. py:method:: get_job(self, job_id = None, project_id = None, location = None) |
| |
| Retrieves a BigQuery job. For more information see: |
| https://cloud.google.com/bigquery/docs/reference/v2/jobs |
| |
| :param job_id: The ID of the job. The ID must contain only letters (a-z, A-Z), |
| numbers (0-9), underscores (_), or dashes (-). The maximum length is 1,024 |
| characters. If not provided then uuid will be generated. |
| :param project_id: Google Cloud Project where the job is running |
| :param location: location the job is running |
| |
| |
| .. py:method:: insert_job(self, configuration, job_id = None, project_id = None, location = None, nowait = False, retry = DEFAULT_RETRY, timeout = None) |
| |
| Executes a BigQuery job. Waits for the job to complete and returns job id. |
| See here: |
| |
| https://cloud.google.com/bigquery/docs/reference/v2/jobs |
| |
| :param configuration: The configuration parameter maps directly to |
| BigQuery's configuration field in the job object. See |
| https://cloud.google.com/bigquery/docs/reference/v2/jobs for |
| details. |
| :param job_id: The ID of the job. The ID must contain only letters (a-z, A-Z), |
| numbers (0-9), underscores (_), or dashes (-). The maximum length is 1,024 |
| characters. If not provided then uuid will be generated. |
| :param project_id: Google Cloud Project where the job is running |
| :param location: location the job is running |
| :param nowait: specify whether to insert job without waiting for the result |
| :param retry: How to retry the RPC. |
| :param timeout: The number of seconds to wait for the underlying HTTP transport |
| before using ``retry``. |
| |
| |
| .. py:method:: run_with_configuration(self, configuration) |
| |
| Executes a BigQuery SQL query. See here: |
| |
| https://cloud.google.com/bigquery/docs/reference/v2/jobs |
| |
| For more details about the configuration parameter. |
| |
| :param configuration: The configuration parameter maps directly to |
| BigQuery's configuration field in the job object. See |
| https://cloud.google.com/bigquery/docs/reference/v2/jobs for |
| details. |
| |
| |
| .. py:method:: run_load(self, destination_project_dataset_table, source_uris, schema_fields = None, source_format = 'CSV', create_disposition = 'CREATE_IF_NEEDED', skip_leading_rows = 0, write_disposition = 'WRITE_EMPTY', field_delimiter = ',', max_bad_records = 0, quote_character = None, ignore_unknown_values = False, allow_quoted_newlines = False, allow_jagged_rows = False, encoding = 'UTF-8', schema_update_options = None, src_fmt_configs = None, time_partitioning = None, cluster_fields = None, autodetect = False, encryption_configuration = None, labels = None, description = None) |
| |
| Executes a BigQuery load command to load data from Google Cloud Storage |
| to BigQuery. See here: |
| |
| https://cloud.google.com/bigquery/docs/reference/v2/jobs |
| |
| For more details about these parameters. |
| |
| :param destination_project_dataset_table: |
| The dotted ``(<project>.|<project>:)<dataset>.<table>($<partition>)`` BigQuery |
| table to load data into. If ``<project>`` is not included, project will be the |
| project defined in the connection json. If a partition is specified the |
| operator will automatically append the data, create a new partition or create |
| a new DAY partitioned table. |
| :param schema_fields: The schema field list as defined here: |
| https://cloud.google.com/bigquery/docs/reference/v2/jobs#configuration.load |
| Required if autodetect=False; optional if autodetect=True. |
| :param autodetect: Attempt to autodetect the schema for CSV and JSON |
| source files. |
| :param source_uris: The source Google Cloud |
| Storage URI (e.g. gs://some-bucket/some-file.txt). A single wild |
| per-object name can be used. |
| :param source_format: File format to export. |
| :param create_disposition: The create disposition if the table doesn't exist. |
| :param skip_leading_rows: Number of rows to skip when loading from a CSV. |
| :param write_disposition: The write disposition if the table already exists. |
| :param field_delimiter: The delimiter to use when loading from a CSV. |
| :param max_bad_records: The maximum number of bad records that BigQuery can |
| ignore when running the job. |
| :param quote_character: The value that is used to quote data sections in a CSV |
| file. |
| :param ignore_unknown_values: [Optional] Indicates if BigQuery should allow |
| extra values that are not represented in the table schema. |
| If true, the extra values are ignored. If false, records with extra columns |
| are treated as bad records, and if there are too many bad records, an |
| invalid error is returned in the job result. |
| :param allow_quoted_newlines: Whether to allow quoted newlines (true) or not |
| (false). |
| :param allow_jagged_rows: Accept rows that are missing trailing optional columns. |
| The missing values are treated as nulls. If false, records with missing |
| trailing columns are treated as bad records, and if there are too many bad |
| records, an invalid error is returned in the job result. Only applicable when |
| source_format is CSV. |
| :param encoding: The character encoding of the data. |
| |
| .. seealso:: |
| https://cloud.google.com/bigquery/docs/reference/rest/v2/tables#externalDataConfiguration.csvOptions.encoding |
| :param schema_update_options: Allows the schema of the destination |
| table to be updated as a side effect of the load job. |
| :param src_fmt_configs: configure optional fields specific to the source format |
| :param time_partitioning: configure optional time partitioning fields i.e. |
| partition by field, type and expiration as per API specifications. |
| :param cluster_fields: Request that the result of this load be stored sorted |
| by one or more columns. BigQuery supports clustering for both partitioned and |
| non-partitioned tables. The order of columns given determines the sort order. |
| :param encryption_configuration: [Optional] Custom encryption configuration (e.g., Cloud KMS keys). |
| **Example**: :: |
| |
| encryption_configuration = { |
| "kmsKeyName": "projects/testp/locations/us/keyRings/test-kr/cryptoKeys/test-key" |
| } |
| :param labels: A dictionary containing labels for the BiqQuery table. |
| :param description: A string containing the description for the BigQuery table. |
| |
| |
| .. py:method:: run_copy(self, source_project_dataset_tables, destination_project_dataset_table, write_disposition = 'WRITE_EMPTY', create_disposition = 'CREATE_IF_NEEDED', labels = None, encryption_configuration = None) |
| |
| Executes a BigQuery copy command to copy data from one BigQuery table |
| to another. See here: |
| |
| https://cloud.google.com/bigquery/docs/reference/v2/jobs#configuration.copy |
| |
| For more details about these parameters. |
| |
| :param source_project_dataset_tables: One or more dotted |
| ``(project:|project.)<dataset>.<table>`` |
| BigQuery tables to use as the source data. Use a list if there are |
| multiple source tables. |
| If ``<project>`` is not included, project will be the project defined |
| in the connection json. |
| :param destination_project_dataset_table: The destination BigQuery |
| table. Format is: ``(project:|project.)<dataset>.<table>`` |
| :param write_disposition: The write disposition if the table already exists. |
| :param create_disposition: The create disposition if the table doesn't exist. |
| :param labels: a dictionary containing labels for the job/query, |
| passed to BigQuery |
| :param encryption_configuration: [Optional] Custom encryption configuration (e.g., Cloud KMS keys). |
| **Example**: :: |
| |
| encryption_configuration = { |
| "kmsKeyName": "projects/testp/locations/us/keyRings/test-kr/cryptoKeys/test-key" |
| } |
| |
| |
| .. py:method:: run_extract(self, source_project_dataset_table, destination_cloud_storage_uris, compression = 'NONE', export_format = 'CSV', field_delimiter = ',', print_header = True, labels = None, return_full_job = False) |
| |
| Executes a BigQuery extract command to copy data from BigQuery to |
| Google Cloud Storage. See here: |
| |
| https://cloud.google.com/bigquery/docs/reference/v2/jobs |
| |
| For more details about these parameters. |
| |
| :param source_project_dataset_table: The dotted ``<dataset>.<table>`` |
| BigQuery table to use as the source data. |
| :param destination_cloud_storage_uris: The destination Google Cloud |
| Storage URI (e.g. gs://some-bucket/some-file.txt). Follows |
| convention defined here: |
| https://cloud.google.com/bigquery/exporting-data-from-bigquery#exportingmultiple |
| :param compression: Type of compression to use. |
| :param export_format: File format to export. |
| :param field_delimiter: The delimiter to use when extracting to a CSV. |
| :param print_header: Whether to print a header for a CSV file extract. |
| :param labels: a dictionary containing labels for the job/query, |
| passed to BigQuery |
| :param return_full_job: return full job instead of job id only |
| |
| |
| .. py:method:: run_query(self, sql, destination_dataset_table = None, write_disposition = 'WRITE_EMPTY', allow_large_results = False, flatten_results = None, udf_config = None, use_legacy_sql = None, maximum_billing_tier = None, maximum_bytes_billed = None, create_disposition = 'CREATE_IF_NEEDED', query_params = None, labels = None, schema_update_options = None, priority = 'INTERACTIVE', time_partitioning = None, api_resource_configs = None, cluster_fields = None, location = None, encryption_configuration = None) |
| |
| Executes a BigQuery SQL query. Optionally persists results in a BigQuery |
| table. See here: |
| |
| https://cloud.google.com/bigquery/docs/reference/v2/jobs |
| |
| For more details about these parameters. |
| |
| :param sql: The BigQuery SQL to execute. |
| :param destination_dataset_table: The dotted ``<dataset>.<table>`` |
| BigQuery table to save the query results. |
| :param write_disposition: What to do if the table already exists in |
| BigQuery. |
| :param allow_large_results: Whether to allow large results. |
| :param flatten_results: If true and query uses legacy SQL dialect, flattens |
| all nested and repeated fields in the query results. ``allowLargeResults`` |
| must be true if this is set to false. For standard SQL queries, this |
| flag is ignored and results are never flattened. |
| :param udf_config: The User Defined Function configuration for the query. |
| See https://cloud.google.com/bigquery/user-defined-functions for details. |
| :param use_legacy_sql: Whether to use legacy SQL (true) or standard SQL (false). |
| If `None`, defaults to `self.use_legacy_sql`. |
| :param api_resource_configs: a dictionary that contain params |
| 'configuration' applied for Google BigQuery Jobs API: |
| https://cloud.google.com/bigquery/docs/reference/rest/v2/jobs |
| for example, {'query': {'useQueryCache': False}}. You could use it |
| if you need to provide some params that are not supported by the |
| BigQueryHook like args. |
| :param maximum_billing_tier: Positive integer that serves as a |
| multiplier of the basic price. |
| :param maximum_bytes_billed: Limits the bytes billed for this job. |
| Queries that will have bytes billed beyond this limit will fail |
| (without incurring a charge). If unspecified, this will be |
| set to your project default. |
| :param create_disposition: Specifies whether the job is allowed to |
| create new tables. |
| :param query_params: a list of dictionary containing query parameter types and |
| values, passed to BigQuery |
| :param labels: a dictionary containing labels for the job/query, |
| passed to BigQuery |
| :param schema_update_options: Allows the schema of the destination |
| table to be updated as a side effect of the query job. |
| :param priority: Specifies a priority for the query. |
| Possible values include INTERACTIVE and BATCH. |
| The default value is INTERACTIVE. |
| :param time_partitioning: configure optional time partitioning fields i.e. |
| partition by field, type and expiration as per API specifications. |
| :param cluster_fields: Request that the result of this query be stored sorted |
| by one or more columns. BigQuery supports clustering for both partitioned and |
| non-partitioned tables. The order of columns given determines the sort order. |
| :param location: The geographic location of the job. Required except for |
| US and EU. See details at |
| https://cloud.google.com/bigquery/docs/locations#specifying_your_location |
| :param encryption_configuration: [Optional] Custom encryption configuration (e.g., Cloud KMS keys). |
| **Example**: :: |
| |
| encryption_configuration = { |
| "kmsKeyName": "projects/testp/locations/us/keyRings/test-kr/cryptoKeys/test-key" |
| } |
| |
| |
| |
| .. py:class:: BigQueryConnection(*args, **kwargs) |
| |
| BigQuery does not have a notion of a persistent connection. Thus, these |
| objects are small stateless factories for cursors, which do all the real |
| work. |
| |
| .. py:method:: close(self) |
| |
| The BigQueryConnection does not have anything to close |
| |
| |
| .. py:method:: commit(self) |
| |
| The BigQueryConnection does not support transactions |
| |
| |
| .. py:method:: cursor(self) |
| |
| Return a new :py:class:`Cursor` object using the connection |
| |
| |
| .. py:method:: rollback(self) |
| :abstractmethod: |
| |
| The BigQueryConnection does not have transactions |
| |
| |
| |
| .. py:class:: BigQueryBaseCursor(service, project_id, hook, use_legacy_sql = True, api_resource_configs = None, location = None, num_retries = 5, labels = None) |
| |
| Bases: :py:obj:`airflow.utils.log.logging_mixin.LoggingMixin` |
| |
| The BigQuery base cursor contains helper methods to execute queries against |
| BigQuery. The methods can be used directly by operators, in cases where a |
| PEP 249 cursor isn't needed. |
| |
| .. py:method:: create_empty_table(self, *args, **kwargs) |
| |
| This method is deprecated. |
| Please use `airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.create_empty_table` |
| |
| |
| .. py:method:: create_empty_dataset(self, *args, **kwargs) |
| |
| This method is deprecated. |
| Please use `airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.create_empty_dataset` |
| |
| |
| .. py:method:: get_dataset_tables(self, *args, **kwargs) |
| |
| This method is deprecated. |
| Please use `airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.get_dataset_tables` |
| |
| |
| .. py:method:: delete_dataset(self, *args, **kwargs) |
| |
| This method is deprecated. |
| Please use `airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.delete_dataset` |
| |
| |
| .. py:method:: create_external_table(self, *args, **kwargs) |
| |
| This method is deprecated. |
| Please use `airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.create_external_table` |
| |
| |
| .. py:method:: patch_table(self, *args, **kwargs) |
| |
| This method is deprecated. |
| Please use `airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.patch_table` |
| |
| |
| .. py:method:: insert_all(self, *args, **kwargs) |
| |
| This method is deprecated. |
| Please use `airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.insert_all` |
| |
| |
| .. py:method:: update_dataset(self, *args, **kwargs) |
| |
| This method is deprecated. |
| Please use `airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.update_dataset` |
| |
| |
| .. py:method:: patch_dataset(self, *args, **kwargs) |
| |
| This method is deprecated. |
| Please use `airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.patch_dataset` |
| |
| |
| .. py:method:: get_dataset_tables_list(self, *args, **kwargs) |
| |
| This method is deprecated. |
| Please use `airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.get_dataset_tables_list` |
| |
| |
| .. py:method:: get_datasets_list(self, *args, **kwargs) |
| |
| This method is deprecated. |
| Please use `airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.get_datasets_list` |
| |
| |
| .. py:method:: get_dataset(self, *args, **kwargs) |
| |
| This method is deprecated. |
| Please use `airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.get_dataset` |
| |
| |
| .. py:method:: run_grant_dataset_view_access(self, *args, **kwargs) |
| |
| This method is deprecated. |
| Please use `airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.run_grant_dataset_view_access` |
| |
| |
| .. py:method:: run_table_upsert(self, *args, **kwargs) |
| |
| This method is deprecated. |
| Please use `airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.run_table_upsert` |
| |
| |
| .. py:method:: run_table_delete(self, *args, **kwargs) |
| |
| This method is deprecated. |
| Please use `airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.run_table_delete` |
| |
| |
| .. py:method:: get_tabledata(self, *args, **kwargs) |
| |
| This method is deprecated. |
| Please use `airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.get_tabledata` |
| |
| |
| .. py:method:: get_schema(self, *args, **kwargs) |
| |
| This method is deprecated. |
| Please use `airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.get_schema` |
| |
| |
| .. py:method:: poll_job_complete(self, *args, **kwargs) |
| |
| This method is deprecated. |
| Please use `airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.poll_job_complete` |
| |
| |
| .. py:method:: cancel_query(self, *args, **kwargs) |
| |
| This method is deprecated. |
| Please use `airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.cancel_query` |
| |
| |
| .. py:method:: run_with_configuration(self, *args, **kwargs) |
| |
| This method is deprecated. |
| Please use `airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.run_with_configuration` |
| |
| |
| .. py:method:: run_load(self, *args, **kwargs) |
| |
| This method is deprecated. |
| Please use `airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.run_load` |
| |
| |
| .. py:method:: run_copy(self, *args, **kwargs) |
| |
| This method is deprecated. |
| Please use `airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.run_copy` |
| |
| |
| .. py:method:: run_extract(self, *args, **kwargs) |
| |
| This method is deprecated. |
| Please use `airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.run_extract` |
| |
| |
| .. py:method:: run_query(self, *args, **kwargs) |
| |
| This method is deprecated. |
| Please use `airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.run_query` |
| |
| |
| |
| .. py:class:: BigQueryCursor(service, project_id, hook, use_legacy_sql = True, location = None, num_retries = 5) |
| |
| Bases: :py:obj:`BigQueryBaseCursor` |
| |
| A very basic BigQuery PEP 249 cursor implementation. The PyHive PEP 249 |
| implementation was used as a reference: |
| |
| https://github.com/dropbox/PyHive/blob/master/pyhive/presto.py |
| https://github.com/dropbox/PyHive/blob/master/pyhive/common.py |
| |
| .. py:attribute:: arraysize |
| |
| |
| |
| |
| .. py:method:: description(self) |
| :property: |
| |
| The schema description method is not currently implemented |
| |
| |
| .. py:method:: close(self) |
| |
| By default, do nothing |
| |
| |
| .. py:method:: rowcount(self) |
| :property: |
| |
| By default, return -1 to indicate that this is not supported |
| |
| |
| .. py:method:: execute(self, operation, parameters = None) |
| |
| Executes a BigQuery query, and returns the job ID. |
| |
| :param operation: The query to execute. |
| :param parameters: Parameters to substitute into the query. |
| |
| |
| .. py:method:: executemany(self, operation, seq_of_parameters) |
| |
| Execute a BigQuery query multiple times with different parameters. |
| |
| :param operation: The query to execute. |
| :param seq_of_parameters: List of dictionary parameters to substitute into the |
| query. |
| |
| |
| .. py:method:: flush_results(self) |
| |
| Flush results related cursor attributes |
| |
| |
| .. py:method:: fetchone(self) |
| |
| Fetch the next row of a query result set |
| |
| |
| .. py:method:: next(self) |
| |
| Helper method for fetchone, which returns the next row from a buffer. |
| If the buffer is empty, attempts to paginate through the result set for |
| the next page, and load it into the buffer. |
| |
| |
| .. py:method:: fetchmany(self, size = None) |
| |
| Fetch the next set of rows of a query result, returning a sequence of sequences |
| (e.g. a list of tuples). An empty sequence is returned when no more rows are |
| available. The number of rows to fetch per call is specified by the parameter. |
| If it is not given, the cursor's arraysize determines the number of rows to be |
| fetched. The method should try to fetch as many rows as indicated by the size |
| parameter. If this is not possible due to the specified number of rows not being |
| available, fewer rows may be returned. An :py:class:`~pyhive.exc.Error` |
| (or subclass) exception is raised if the previous call to |
| :py:meth:`execute` did not produce any result set or no call was issued yet. |
| |
| |
| .. py:method:: fetchall(self) |
| |
| Fetch all (remaining) rows of a query result, returning them as a sequence of |
| sequences (e.g. a list of tuples). |
| |
| |
| .. py:method:: get_arraysize(self) |
| |
| Specifies the number of rows to fetch at a time with .fetchmany() |
| |
| |
| .. py:method:: set_arraysize(self, arraysize) |
| |
| Specifies the number of rows to fetch at a time with .fetchmany() |
| |
| |
| .. py:method:: setinputsizes(self, sizes) |
| |
| Does nothing by default |
| |
| |
| .. py:method:: setoutputsize(self, size, column = None) |
| |
| Does nothing by default |
| |
| |
| |
