bigquery-fdw 2.2.0__py3-none-any.whl

bigquery_fdw/bqclient.py

@@ -0,0 +1,114 @@
+"""
+    See:
+    https://cloud.google.com/bigquery/docs/reference/libraries
+    https://googlecloudplatform.github.io/google-cloud-python/stable/bigquery/usage.html?highlight=insert_data
+    https://github.com/GoogleCloudPlatform/python-docs-samples/tree/master/bigquery/cloud-client
+"""
+
+import datetime
+
+from google.cloud import bigquery
+from google import auth
+
+
+class BqClient:
+
+    # Set vars
+    client = None
+    queryJob = None
+    location = None  # Override dataset location
+
+    def setClient(self):
+        """
+            Set BigQuery client with a Json key
+        """
+
+        try:
+            self.client = bigquery.Client()
+        except auth.exceptions.DefaultCredentialsError as e:
+            raise RuntimeError(
+                'BigQuery client is not instantiated properly: ' + str(e))
+
+    def getClient(self):
+        """
+            Returns `client`
+        """
+
+        return self.client
+
+    def runQuery(self, query, parameters=[], sqlDialect='standard'):
+        """
+            Run BigQuery query
+        """
+
+        if self.client:
+            if parameters:  # Parameterized query
+                # Prepare job configuration
+                job_config = bigquery.QueryJobConfig()
+                job_config.query_parameters = parameters
+
+                self.queryJob = self.client.query(
+                    query, job_config=job_config, location=None)
+            else:  # Non parameterized query
+                self.queryJob = self.client.query(query, location=None)
+
+            # Set SQL dialect
+            self.queryJob.UseLegacySQL = False
+            # if sqlDialect == 'legacy':
+            #     self.queryJob.UseLegacySQL = True
+            # else:
+            #     self.queryJob.UseLegacySQL = False
+
+        else:
+            raise RuntimeError(
+                'BigQuery client is not instantiated properly (from `runQuery`).')
+
+    def getQueryJob(self):
+        """
+            Returns `queryJob`
+        """
+
+        return self.queryJob
+
+    def readResult(self):
+        """
+            Returns query result
+        """
+
+        if self.queryJob:
+            result = self.queryJob.result()
+            return list(result)
+        else:
+            raise RuntimeError('No query is pending a result.')
+
+    def setParameter(self, type_, value):
+        """
+            Prepare a parameter for a parameterized query
+            As documented by Google, only standard SQL syntax supports parameters in queries
+
+            See https://github.com/GoogleCloudPlatform/python-docs-samples/blob/master/bigquery/cloud-client/query_params.py
+        """
+
+        return bigquery.ScalarQueryParameter(
+            # Set the name to None to use positional parameters (? symbol
+            # in the query).  Note that you cannot mix named and positional
+            # parameters.
+            None, type_, self.varToString(value))
+
+    def varToString(self, var):
+        """
+            Format a variable to a string
+
+            Examples:
+            `varToString(1234)` -> '1234'
+            `varToString('1234')` -> '1234'
+            `varToString(datetime.datetime.now())` -> '2017-10-03 11:47:54'
+            `varToString(datetime.datetime.now().date())` -> '2017-10-03'
+        """
+
+        if type(var) is datetime.date:
+            return var.strftime('%Y-%m-%d')
+        elif type(var) is datetime.datetime:
+            return var.strftime('%Y-%m-%d %H:%M:%S')
+
+        return str(var)

bigquery_fdw/bqclient_test.py

@@ -0,0 +1,96 @@
+#!/usr/bin/python3
+
+import argparse
+
+from .bqclient import BqClient
+
+
+def run_test(query):
+    """
+        BigQuery client test
+    """
+
+    # BqClient instance
+    bq = set_bq_instance()
+
+    # Authentication
+    set_client(bq)
+    print(" * BigQuery client instance:")
+    print(get_client(bq))
+
+    # Run query
+    run_query(bq, query)
+    print(" * Query instance:")
+    print(get_query_job(bq))
+
+    # Print the results.
+    print(" * Query results:")
+    for row in read_results(bq):
+        print(row)
+
+    return True
+
+
+def set_bq_instance():
+    """
+        Create instance of BqClient
+    """
+
+    return BqClient()
+
+
+def set_client(bq):
+    """
+        Set BigQuery client
+    """
+
+    return bq.setClient()
+
+
+def get_client(bq):
+    """
+        Get BigQuery client
+    """
+
+    return bq.getClient()
+
+
+def run_query(bq, query):
+    """
+        Run query
+    """
+
+    return bq.runQuery(query)
+
+
+def get_query_job(bq):
+    """
+        Get query job
+    """
+
+    return bq.getQueryJob()
+
+
+def read_results(bq):
+    """
+        Read results
+    """
+
+    return [row for row in bq.readResult()]
+
+
+def main():
+
+    # Parse arguments
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-a", "--auth_type", type=str, help="Authentication type",
+                        choices=['service_account'], default='service_account')
+    parser.add_argument("-q", "--query", type=str,
+                        help="Query to run", required=True)
+    args = parser.parse_args()
+
+    run_test(query=args.query)
+
+
+if __name__ == '__main__':
+    main()

bigquery_fdw/fdw.py

@@ -0,0 +1,461 @@
+from collections import OrderedDict, namedtuple
+
+from multicorn import ForeignDataWrapper
+from multicorn.utils import log_to_postgres, ERROR, WARNING, INFO, DEBUG
+
+from .bqclient import BqClient
+
+
+class ConstantForeignDataWrapper(ForeignDataWrapper):
+
+    # Default vars
+    client = None  # BqClient instance
+    partitionPseudoColumn = 'partition_date'  # Name of the partition pseudo column
+    # Pseudo column to fetch `count(*)` when using the remote counting and grouping feature
+    countPseudoColumn = '_fdw_count'
+    castingRules = None  # Dict of casting rules when using the `fdw_casting` option
+
+    def __init__(self, options, columns):
+        """
+            Initialize instance, set class level vars
+        """
+
+        super(ConstantForeignDataWrapper, self).__init__(options, columns)
+
+        # Set options
+        self.setOptions(options)
+
+        # Set table columns
+        self.columns = columns
+
+        # Set data types and conversion rules mapping
+        self.setDatatypes()
+        self.setConversionRules()
+
+    def setOptions(self, options):
+        """
+            Set table options at class level
+        """
+
+        # Set options at class scope
+        try:
+            self.dataset = options['fdw_dataset']
+            self.table = options['fdw_table']
+            self.convertToTz = options.get('fdw_convert_tz')
+
+            # Set verbose option
+            self.setOptionVerbose(options.get('fdw_verbose'))
+
+            # Set SQL dialect
+            self.setOptionSqlDialect(options.get('fdw_sql_dialect'))
+
+            # Set grouping option
+            self.setOptionGroupBy(options.get('fdw_group'))
+
+            # Set casting rules
+            self.setOptionCasting(options.get('fdw_casting'))
+        except KeyError:
+            log_to_postgres(
+                "You must specify these options when creating the FDW: fdw_dataset, fdw_table", ERROR)
+
+    def setDatatypes(self):
+        """
+            Set data types mapping
+        """
+
+        # Create a named tuple
+        datatype = namedtuple('datatype', 'postgres bq_standard bq_legacy')
+
+        self.datatypes = [
+            datatype('text', 'STRING', 'STRING'),
+            # datatype('bytea', 'BYTES', 'BYTES'), # Not supported, need testing for support
+            datatype('bigint', 'INT64', 'INTEGER'),
+            datatype('double precision', 'FLOAT64', 'FLOAT'),
+            datatype('boolean', 'BOOL', 'BOOLEAN'),
+            datatype('timestamp without time zone', 'TIMESTAMP', 'TIMESTAMP'),
+            datatype('date', 'DATE', 'DATE'),
+            datatype('time without time zone', 'TIME', 'TIME'),
+            datatype('timestamp without time zone', 'DATETIME', 'DATETIME'),
+        ]
+
+    def setConversionRules(self):
+        """
+            Set list of allowed conversion rules
+        """
+
+        # Create a named tuple
+        conversionRule = namedtuple(
+            'conversionRule', 'bq_standard_from bq_standard_to')
+
+        self.conversionRules = [
+            conversionRule('INT64', ['BOOL', 'FLOAT64', 'INT64', 'STRING']),
+            conversionRule('FLOAT64', ['FLOAT64', 'INT64', 'STRING']),
+            conversionRule('BOOL', ['BOOL', 'INT64', 'STRING']),
+            conversionRule('STRING', ['BOOL', 'BYTES', 'DATE', 'DATETIME',
+                                      'FLOAT64', 'INT64', 'STRING', 'TIME', 'TIMESTAMP']),
+            conversionRule('BYTES', ['BYTES', 'STRING']),
+            conversionRule(
+                'DATE', ['DATE', 'DATETIME', 'STRING', 'TIMESTAMP']),
+            conversionRule(
+                'DATETIME', ['DATE', 'DATETIME', 'STRING', 'TIME', 'TIMESTAMP']),
+            conversionRule('TIME', ['STRING', 'TIME']),
+            conversionRule(
+                'TIMESTAMP', ['DATE', 'DATETIME', 'STRING', 'TIME', 'TIMESTAMP']),
+            conversionRule('ARRAY', ['ARRAY']),
+            conversionRule('STRUCT', ['STRUCT']),
+        ]
+
+    def setOptionSqlDialect(self, standard_sql=None):
+        """
+            Set a flag for the SQL dialect.
+            It can be `standard` or `legacy`. `standard` will be the default
+        """
+
+        self.dialect = 'standard'
+
+        if standard_sql == 'legacy':
+            self.dialect = 'legacy'
+
+        # Verbose log
+        if self.verbose:
+            log_to_postgres("Set SQL dialect to `" + self.dialect + "`", INFO)
+
+    def setOptionGroupBy(self, group):
+        """
+            Set a flag `self.groupBy` as `True` if `group` contains the string 'true'
+            Otherwise, set it as `False`
+        """
+
+        if group == 'true':
+            self.groupBy = True
+            return
+
+        self.groupBy = False
+
+    def setOptionVerbose(self, verbose):
+        """
+            Set a flag `self.verbose` as `True` if `verbose` contains the string 'true'
+            Otherwise, set it as `False`
+        """
+
+        if verbose == 'true':
+            self.verbose = True
+            return
+
+        self.verbose = False
+
+    def setOptionCasting(self, castingRules):
+        """
+            Conversion rules are received as a string, for example: '{"key": "FLOAT64", "datetime": "DATE"}'
+
+            The string will be converted to a dict
+        """
+
+        if castingRules:
+            # Cast string as a dict
+            try:
+                import ast
+                self.castingRules = ast.literal_eval(castingRules)
+            except Exception as e:
+                log_to_postgres(
+                    "fdw_casting conversion failed: `" + str(e) + "`", ERROR)
+
+            # For security reasons, ensure that the string was correctly casted as a dict
+            try:
+                if type(self.castingRules) is not dict:
+                    raise ValueError('fdw_casting format is incorrect.')
+            except Exception as e:
+                log_to_postgres(
+                    "fdw_casting conversion failed: `" + str(e) + "`", ERROR)
+
+    def getClient(self):
+        """
+            Manage a pool of instances of BqClient
+            If the user uses different private keys in different tables, this method will return
+               the correct instance of BqClient class associated to the table private key
+        """
+
+        # Returns an existing instance
+        if self.client:
+            return self.client
+
+        # Or create a new instance
+        return self.setClient()
+
+    def setClient(self):
+        """
+            Attempt to connect to BigQuery client
+        """
+
+        try:
+            # Attempt connection
+            bq = BqClient()
+            bq.setClient()
+
+            # Verbose log
+            if self.verbose:
+                log_to_postgres(
+                    "Connection to BigQuery client with BqClient instance ID " + str(id(bq)), INFO)
+
+            # Add to pool
+            self.client = bq
+
+            return bq
+        except RuntimeError:
+            log_to_postgres(
+                "Connection to BigQuery client failed", ERROR)
+
+    def execute(self, quals, columns):
+        """
+            Executes a query
+        """
+
+        # # Verbose log
+        # if self.verbose:
+        #     log_to_postgres('Quals...', INFO)
+        #     log_to_postgres(quals, INFO)
+        #     log_to_postgres('Columns...', INFO)
+        #     log_to_postgres(columns, INFO)
+
+        # Returns instance of BqClient
+        client = self.getClient()
+
+        # Prepare query
+        query, parameters = self.buildQuery(quals, columns)
+
+        # Run query
+        client.runQuery(query, parameters, self.dialect)
+
+        # Return query output
+        for row in client.readResult():
+            # Create an ordered dict with the column name and value
+            # Example: `OrderedDict([('column1', 'value1'), ('column2', value2)])`
+            line = OrderedDict()
+            for column in columns:
+                line[column] = row[column]
+
+            yield line
+
+    def buildQuery(self, quals, columns):
+        """
+            Builds a BigQuery query
+        """
+
+        # Set query var
+        query = ''
+
+        # Add SELECT clause
+        query += 'SELECT ' + self.buildColumnList(columns)
+
+        # Add FROM clause
+        query += " FROM `" + self.dataset + "." + self.table + "` "
+
+        # Add WHERE clause
+        clause, parameters = self.buildWhereClause(quals)
+        query += clause
+
+        # Add group by
+        if self.groupBy:
+            groupByColumns = self.buildColumnList(columns, 'GROUP_BY')
+            if groupByColumns:
+                query += ' GROUP BY ' + \
+                    self.buildColumnList(columns, 'GROUP_BY')
+
+        # Verbose log
+        if self.verbose:
+            log_to_postgres("Prepared query: `" + query + "`", INFO)
+
+        return query, parameters
+
+    def buildColumnList(self, columns, usage='SELECT'):
+        """
+            Build the SELECT clause of the SQL query
+        """
+
+        clause = ''
+
+        # Disable aliases for Group By
+        useAliases = True
+        if usage == 'GROUP_BY':
+            useAliases = False
+
+        if columns:  # If we have columns
+            for column in columns:
+                if column == self.countPseudoColumn:  # Pseudo column to count grouped rows
+                    if usage == 'SELECT':
+                        clause += "count(*) " + \
+                            self.addColumnAlias(column, useAliases) + ", "
+                elif column == self.partitionPseudoColumn:  # Partition pseudo column
+                    clause += "_PARTITIONTIME " + \
+                        self.addColumnAlias(column, useAliases) + ", "
+                else:  # Any other column
+                    # Get column data type
+                    dataType = self.getBigQueryDatatype(column)
+
+                    # Save column original name
+                    columnOriginalName = column
+
+                    # If the data type is a date or a timestamp
+                    if dataType in ['DATE', 'TIMESTAMP']:
+                        column = self.setTimeZone(column, dataType)
+
+                    # Data type casting
+                    column = self.castColumn(
+                        column, columnOriginalName, dataType)
+
+                    clause += column + " " + \
+                        self.addColumnAlias(
+                            columnOriginalName, useAliases) + ", "
+
+            # Remove final `, `
+            clause = clause.strip(', ')
+        elif usage == 'SELECT':  # Otherwise fetch all
+            clause += "*"
+
+        return clause
+
+    def setTimeZone(self, column, dataType):
+        """
+            If the option `fdw_convert_tz` is used, convert the time zone automatically from UTC to the desired time zone
+        """
+
+        # Option is set
+        if self.convertToTz:
+            if dataType == 'DATE':  # BigQuery column type is `DATE`
+                return 'DATE(' + column + ', "' + self.convertToTz + '") '
+            else:  # BigQuery column type is `TIMESTAMP`
+                return 'DATETIME(' + column + ', "' + self.convertToTz + '") '
+
+        # Option is not set
+        return column
+
+    def castColumn(self, column, columnOriginalName, dataType):
+        """
+            If the option `fdw_casting` is used, this method will attempt to cast the column to the new type
+        """
+
+        if self.castingRules and columnOriginalName in self.castingRules:  # If we have casting rule for this column
+            # Get desired casting
+            castTo = self.castingRules[columnOriginalName]
+
+            # Find if we have a matching rule
+            rule = [
+                conversionRule for conversionRule in self.conversionRules if conversionRule.bq_standard_from == dataType.upper()]
+
+            if rule:
+                # Check if casting from the original data type to the new one is supported
+                if castTo.upper() in rule[0].bq_standard_to:
+                    return 'CAST(' + column + ' as ' + castTo.upper() + ')'
+                else:
+                    log_to_postgres("Casting from the data type `" + dataType.upper(
+                    ) + "` to the data type `" + castTo.upper() + "` is not permitted.", ERROR)
+            else:
+                log_to_postgres(
+                    "Casting from the data type `" + dataType.upper() + "` is not permitted.", ERROR)
+
+        # Option is not set
+        return column
+
+    def addColumnAlias(self, alias, useAliases=True):
+        """
+            Returns a string "as `alias`" if `useAliases` is `True`
+        """
+
+        if useAliases:
+            return " as " + alias
+
+        return ''
+
+    def buildWhereClause(self, quals):
+        """
+            Build the WHERE clause of the SQL query
+        """
+
+        clause = ''
+        parameters = []
+
+        # Add WHERE clause
+        # `quals` example: `[Qual('test', '=', 'test 2'), Qual('test', '~~', '3')]`
+        if quals:
+            clause += "WHERE "
+            for qual in quals:
+                if qual.field_name == self.partitionPseudoColumn:
+                    clause += "_PARTITIONTIME " + \
+                        str(self.getOperator(qual.operator)) + " ?"
+
+                    # Format date as a timestamp
+                    value = qual.value.strftime("%Y-%m-%d 00:00:00")
+
+                    # Force data type to `TIMESTAMP`
+                    parameters.append(self.setParameter(
+                        qual.field_name, 'TIMESTAMP', value))
+                else:
+                    clause += str(qual.field_name) + " " + \
+                        str(self.getOperator(qual.operator)) + " ?"
+                    parameters.append(self.setParameter(
+                        qual.field_name, self.getBigQueryDatatype(qual.field_name), qual.value))
+
+                # Add ` AND `
+                clause += " AND "
+
+        # Remove final ` AND `
+        clause = clause.strip(' AND ')
+
+        return (clause, parameters)
+
+    def getOperator(self, operator):
+        """
+            Validate operator
+        """
+
+        # List of BigQuery operators supported
+        # Exhaustive list: https://cloud.google.com/bigquery/docs/reference/standard-sql/functions-and-operators#operators
+        # Non listed operators may or may not work
+        operators = ['=', '<', '>', '<=', '>=', '!=', '<>', 'LIKE', 'NOT LIKE']
+
+        # Mapping between multicorn operators and BigQuery operators
+        mapping = {}
+        mapping['~~'] = 'LIKE'
+        mapping['!~~'] = 'NOT LIKE'
+
+        if operator in operators:  # Operator is natively supported
+            return operator
+        elif operator in mapping:  # Multicorn operator has a BigQuery equivalent
+            return mapping[operator]
+        else:  # Operator is not supported
+            log_to_postgres(
+                "Operator `" + operator + "` is not currently supported", ERROR)
+
+    def getBigQueryDatatype(self, column, dialect='standard'):
+        """
+            Returns the BigQuery standard SQL data type of a PostgreSQL column
+
+            Example: `column1` has the PostgreSQL type `bigint` which is called `INT64` in BigQuery standard SQL
+        """
+
+        # Get PostgreSQL column type
+        # Example: `timestamp without time zone`
+        pgDatatype = self.columns[column].base_type_name
+
+        for datatype in self.datatypes:  # For each known data types
+            if datatype.postgres == pgDatatype:  # If the PostgreSQL data type matches the known data type
+                # Returns equivalent BigQuery data type
+                if dialect == 'legacy':
+                    return datatype.bq_legacy
+                else:
+                    return datatype.bq_standard
+
+        # Return a default data type in an attempt to save the day
+        return 'STRING'
+
+    def setParameter(self, column, type_, value):
+        """
+            Set a parameter in BigQuery client
+        """
+
+        # Verbose log
+        if self.verbose:
+            log_to_postgres(
+                "Add query parameter `" + self.client.varToString(value) + "` for column `" + column + "` with the type `" + type_ + "`", INFO)
+
+        return self.client.setParameter(type_, value)

bigquery_fdw-2.2.0.dist-info/METADATA

@@ -0,0 +1,153 @@
+Metadata-Version: 2.4
+Name: bigquery-fdw
+Version: 2.2.0
+Summary: BigQuery Foreign Data Wrapper for PostgreSQL
+Home-page: https://github.com/gabfl/bigquery_fdw
+Author: Gabriel Bordeaux
+Author-email: pypi@gab.lc
+License: MIT
+Classifier: Topic :: Database
+Classifier: Topic :: Database :: Database Engines/Servers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python
+Classifier: Development Status :: 4 - Beta
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: google-cloud-bigquery==3.47.0
+Requires-Dist: google-auth==2.62.2
+Requires-Dist: google-auth-oauthlib==1.5.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# bigquery_fdw: BigQuery Foreign Data Wrapper for PostgreSQL
+
+[![Pypi](https://img.shields.io/pypi/v/bigquery-fdw.svg)](https://pypi.org/project/bigquery-fdw/)
+[![Build Status](https://github.com/gabfl/bigquery_fdw/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/gabfl/bigquery_fdw/actions)
+[![codecov](https://codecov.io/gh/gabfl/bigquery_fdw/branch/main/graph/badge.svg)](https://codecov.io/gh/gabfl/bigquery_fdw)
+[![MIT licensed](https://img.shields.io/badge/license-MIT-green.svg)](https://raw.githubusercontent.com/gabfl/bigquery_fdw/main/LICENSE)
+
+bigquery_fdw is a BigQuery foreign data wrapper for PostgreSQL using [Multicorn](https://github.com/Segfault-Inc/Multicorn).
+
+It allows to write queries in PostgreSQL SQL syntax using a foreign table. It supports most of BigQuery's [data types](docs/data_types.md) and [operators](docs/operators.md).
+
+## Features and limitations
+
+ - Table partitioning is supported. [You can use partitions in your SQL queries](docs/table_partitioning.md).
+ - Queries are parameterized when sent to BigQuery
+ - BigQuery's standard SQL support (legacy SQL is not supported)
+ - Authentication works with a "[Service Account](docs/service_account.md)" Json private key
+
+[Read more](docs/README.md).
+
+## Requirements
+
+ - PostgreSQL 14 to 18
+ - Python >= 3.10
+
+## Get started
+
+### Using docker
+
+See [getting started with Docker](docs/docker.md)
+
+### Installation on Debian/Ubuntu
+
+#### Dependencies required to install bigquery_fdw:
+
+You need to install the following dependencies:
+
+```bash
+# Install required packages
+apt update
+apt install -y postgresql-server-dev-18 python3-setuptools python3-dev make gcc git
+```
+
+PostgreSQL versions 14 to 18 are tested in CI.
+
+#### Installation
+
+```bash
+# Install Multicorn
+# multicorn2 is a fork of Segfault-Inc/Multicorn that adds support for recent PostgreSQL versions.
+# The original pgsql-io/multicorn2 repository was removed in October 2026; this copy is pinned to its v3.2 release.
+# Alternatively, up to PostgreSQL 12, you can use gabfl/Multicorn that adds better support for Python3.
+# You may also choose to build against the original project instead.
+git clone https://github.com/ShaheedHaque/multicorn2.git Multicorn && cd Multicorn
+git checkout 4e0feaa8c8a4e7db80ff442d71fb7786d5519e29
+make && make install
+
+# Install bigquery_fdw
+pip3 install bigquery-fdw
+```
+
+Major dependencies installed automatically during the installation process:
+
+ - [Google Cloud BigQuery](https://pypi.org/project/google-cloud-bigquery/)
+ - [Multicorn](https://github.com/ShaheedHaque/multicorn2)
+
+## Authentication
+
+bigquery_fdw relies on [Google Cloud API's default authentication](https://cloud.google.com/docs/authentication/getting-started#linux-or-macos). 
+
+Your need to have an environment variable `GOOGLE_APPLICATION_CREDENTIALS` that has to be accessible by bigquery_fdw. Setting environment variables varies depending on OS but for Ubuntu or Debian, the preferred way is to edit `/etc/postgresql/[version]/main/environment` and add:
+```
+GOOGLE_APPLICATION_CREDENTIALS = '/path/to/key.json'
+```
+
+Restarting PostgreSQL is required for the environment variable to be loaded.
+
+## Usage
+
+We recommend testing the [BigQuery client connectivity](docs/test_client.md) before trying to use the FDW.
+
+With `psql`:
+
+```sql
+CREATE EXTENSION multicorn;
+
+CREATE SERVER bigquery_srv FOREIGN DATA WRAPPER multicorn
+OPTIONS (
+    wrapper 'bigquery_fdw.fdw.ConstantForeignDataWrapper'
+);
+
+CREATE FOREIGN TABLE my_bigquery_table (
+    column1 text,
+    column2 bigint
+) SERVER bigquery_srv
+OPTIONS (
+    fdw_dataset  'my_dataset',
+    fdw_table 'my_table'
+);
+```
+
+## Options
+
+List of options implemented in `CREATE FOREIGN TABLE` syntax:
+
+| Option | Default | Description |
+|-----|----|----|
+| `fdw_dataset` | - | BigQuery dataset name |
+| `fdw_table` | - | BigQuery table name |
+| `fdw_convert_tz` | - | Convert BigQuery time zone for dates and timestamps to selected time zone. Example: `'US/Eastern'`. |
+| `fdw_group` |  `'false'` | See [Remote grouping and counting](docs/remote_grouping.md). |
+| `fdw_casting` |  - | See [Casting](docs/casting.md). |
+| `fdw_verbose` | `'false'` | Set to `'true'` to output debug information in PostrgeSQL's logs |
+| `fdw_sql_dialect` | `'standard'` | BigQuery SQL dialect. Currently only `standard` is supported. |
+
+## More documentation
+
+See [bigquery_fdw documentation](docs/README.md).

bigquery_fdw-2.2.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+bigquery_fdw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bigquery_fdw/bqclient.py,sha256=KUGLS39JA2aWtXlqtsrCjvxxSTXdgLkisNzXGlfjzJA,3440
+bigquery_fdw/bqclient_test.py,sha256=v7HUbo4p-kPvQY0sJYXVEzW83tjSbGvDkNYTWogYSes,1556
+bigquery_fdw/fdw.py,sha256=KRZ1SJsQ0no-IdjliMn915ygm8tManoXWSzwy98q8G0,16042
+bigquery_fdw-2.2.0.dist-info/licenses/LICENSE,sha256=WqS7GgVJk_T1GouVCLKKsR1q83EOah9Hpb72mq0pQ64,1073
+bigquery_fdw-2.2.0.dist-info/METADATA,sha256=f6ekcTeYu3Cj3n74Rgndpnm_Dyh1qSm33Pmzm-PbR2U,5470
+bigquery_fdw-2.2.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+bigquery_fdw-2.2.0.dist-info/entry_points.txt,sha256=xJLSDIqPEAwwv2Lahm16mzJfDse44QQYhhC7-WKB4-g,67
+bigquery_fdw-2.2.0.dist-info/top_level.txt,sha256=R9SGcYIac_hb4IO_zPBpaqodCaVGPLsdIxtO2Zfnxks,13
+bigquery_fdw-2.2.0.dist-info/RECORD,,

bigquery_fdw-2.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

bigquery_fdw-2.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+bq_client_test = bigquery_fdw.bqclient_test:main

bigquery_fdw-2.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Gabriel Bordeaux
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

bigquery_fdw-2.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+bigquery_fdw