├── .coveragerc
├── .flake8
├── .github
    ├── .OwlBot.lock.yaml
    ├── .OwlBot.yaml
    ├── CODEOWNERS
    ├── CONTRIBUTING.md
    ├── ISSUE_TEMPLATE
    │   ├── bug_report.md
    │   ├── feature_request.md
    │   └── support_request.md
    ├── PULL_REQUEST_TEMPLATE.md
    ├── auto-approve.yml
    ├── auto-label.yaml
    ├── blunderbuss.yml
    ├── header-checker-lint.yml
    ├── release-please.yml
    ├── release-trigger.yml
    ├── snippet-bot.yml
    └── sync-repo-settings.yaml
├── .gitignore
├── .kokoro
    ├── build.sh
    ├── continuous
    │   ├── common.cfg
    │   ├── compliance.cfg
    │   ├── continuous.cfg
    │   └── prerelease-deps.cfg
    ├── populate-secrets.sh
    ├── presubmit
    │   ├── common.cfg
    │   ├── compliance.cfg
    │   ├── prerelease-deps.cfg
    │   └── presubmit.cfg
    ├── samples
    │   ├── lint
    │   │   ├── common.cfg
    │   │   ├── continuous.cfg
    │   │   ├── periodic.cfg
    │   │   └── presubmit.cfg
    │   ├── python3.10
    │   │   ├── common.cfg
    │   │   ├── continuous.cfg
    │   │   ├── periodic-head.cfg
    │   │   ├── periodic.cfg
    │   │   └── presubmit.cfg
    │   ├── python3.11
    │   │   ├── common.cfg
    │   │   ├── continuous.cfg
    │   │   ├── periodic-head.cfg
    │   │   ├── periodic.cfg
    │   │   └── presubmit.cfg
    │   ├── python3.12
    │   │   ├── common.cfg
    │   │   ├── continuous.cfg
    │   │   ├── periodic-head.cfg
    │   │   ├── periodic.cfg
    │   │   └── presubmit.cfg
    │   ├── python3.13
    │   │   ├── common.cfg
    │   │   ├── continuous.cfg
    │   │   ├── periodic-head.cfg
    │   │   ├── periodic.cfg
    │   │   └── presubmit.cfg
    │   ├── python3.7
    │   │   ├── common.cfg
    │   │   ├── continuous.cfg
    │   │   ├── periodic-head.cfg
    │   │   ├── periodic.cfg
    │   │   └── presubmit.cfg
    │   ├── python3.8
    │   │   ├── common.cfg
    │   │   ├── continuous.cfg
    │   │   ├── periodic-head.cfg
    │   │   ├── periodic.cfg
    │   │   └── presubmit.cfg
    │   └── python3.9
    │   │   ├── common.cfg
    │   │   ├── continuous.cfg
    │   │   ├── periodic-head.cfg
    │   │   ├── periodic.cfg
    │   │   └── presubmit.cfg
    ├── test-samples-against-head.sh
    ├── test-samples-impl.sh
    ├── test-samples.sh
    ├── trampoline.sh
    └── trampoline_v2.sh
├── .pre-commit-config.yaml
├── .repo-metadata.json
├── .trampolinerc
├── AUTHORS
├── CHANGELOG.md
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.rst
├── LICENSE
├── MANIFEST.in
├── README.rst
├── SECURITY.md
├── dev_requirements.txt
├── docs
    ├── README.rst
    ├── _static
    │   └── custom.css
    ├── _templates
    │   └── layout.html
    ├── alembic.rst
    ├── changelog.md
    ├── conf.py
    ├── geography.rst
    ├── index.rst
    ├── reference.rst
    ├── samples
    └── struct.rst
├── noxfile.py
├── owlbot.py
├── pyproject.toml
├── release-procedure.md
├── renovate.json
├── samples
    ├── __init__.py
    ├── pytest.ini
    └── snippets
    │   ├── STRUCT.py
    │   ├── STRUCT_test.py
    │   ├── __init__.py
    │   ├── conftest.py
    │   ├── geography.py
    │   ├── geography_test.py
    │   ├── noxfile.py
    │   ├── requirements-test.txt
    │   └── requirements.txt
├── scripts
    ├── decrypt-secrets.sh
    └── readme-gen
    │   ├── readme_gen.py
    │   └── templates
    │       ├── README.tmpl.rst
    │       ├── auth.tmpl.rst
    │       ├── auth_api_key.tmpl.rst
    │       ├── install_deps.tmpl.rst
    │       └── install_portaudio.tmpl.rst
├── setup.cfg
├── setup.py
├── sqlalchemy_bigquery
    ├── __init__.py
    ├── _helpers.py
    ├── _struct.py
    ├── _types.py
    ├── _versions_helpers.py
    ├── base.py
    ├── geography.py
    ├── parse_url.py
    ├── requirements.py
    └── version.py
├── testing
    ├── .gitignore
    ├── constraints-3.10.txt
    ├── constraints-3.11.txt
    ├── constraints-3.12.txt
    ├── constraints-3.13.txt
    ├── constraints-3.8.txt
    └── constraints-3.9.txt
├── tests
    ├── __init__.py
    ├── conftest.py
    ├── sqlalchemy_dialect_compliance
    │   ├── README.rst
    │   ├── conftest.py
    │   └── test_dialect_compliance.py
    ├── system
    │   ├── __init__.py
    │   ├── conftest.py
    │   ├── data
    │   │   ├── sample.json
    │   │   ├── sample_one_row.json
    │   │   └── schema.json
    │   ├── test__struct.py
    │   ├── test_alembic.py
    │   ├── test_geography.py
    │   ├── test_helpers.py
    │   ├── test_sqlalchemy_bigquery.py
    │   └── test_sqlalchemy_bigquery_remote.py
    └── unit
    │   ├── __init__.py
    │   ├── conftest.py
    │   ├── fauxdbi.py
    │   ├── test__struct.py
    │   ├── test__types.py
    │   ├── test_alembic.py
    │   ├── test_catalog_functions.py
    │   ├── test_comments.py
    │   ├── test_compiler.py
    │   ├── test_compliance.py
    │   ├── test_dialect_types.py
    │   ├── test_engine.py
    │   ├── test_geography.py
    │   ├── test_helpers.py
    │   ├── test_like_reescape.py
    │   ├── test_parse_url.py
    │   ├── test_select.py
    │   ├── test_sqlalchemy_bigquery.py
    │   ├── test_table_options.py
    │   ├── test_version.py
    │   └── test_view.py
└── third_party
    ├── __init__.py
    └── sqlalchemy_bigquery_vendored
        ├── __init__.py
        ├── py.typed
        └── sqlalchemy
            ├── AUTHORS
            ├── LICENSE
            ├── __init__.py
            └── postgresql
                ├── __init__.py
                └── base.py


/.coveragerc:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | #
 3 | # Copyright 2024 Google LLC
 4 | #
 5 | # Licensed under the Apache License, Version 2.0 (the "License");
 6 | # you may not use this file except in compliance with the License.
 7 | # You may obtain a copy of the License at
 8 | #
 9 | #     https://www.apache.org/licenses/LICENSE-2.0
10 | #
11 | # Unless required by applicable law or agreed to in writing, software
12 | # distributed under the License is distributed on an "AS IS" BASIS,
13 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | # See the License for the specific language governing permissions and
15 | # limitations under the License.
16 | 
17 | # Generated by synthtool. DO NOT EDIT!
18 | [run]
19 | branch = True
20 | omit =
21 |   google/__init__.py
22 |   sqlalchemy_bigquery/requirements.py
23 | 
24 | [report]
25 | fail_under = 100
26 | show_missing = True
27 | exclude_lines =
28 |     # Re-enable the standard pragma
29 |     pragma: NO COVER
30 |     # Ignore debug-only repr
31 |     def __repr__
32 |     # Ignore abstract methods
33 |     raise NotImplementedError
34 | omit =
35 |   */gapic/*.py
36 |   */proto/*.py
37 |   */core/*.py
38 |   */site-packages/*.py
39 |   sqlalchemy_bigquery/requirements.py
40 | 


--------------------------------------------------------------------------------
/.flake8:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | #
 3 | # Copyright 2024 Google LLC
 4 | #
 5 | # Licensed under the Apache License, Version 2.0 (the "License");
 6 | # you may not use this file except in compliance with the License.
 7 | # You may obtain a copy of the License at
 8 | #
 9 | #     https://www.apache.org/licenses/LICENSE-2.0
10 | #
11 | # Unless required by applicable law or agreed to in writing, software
12 | # distributed under the License is distributed on an "AS IS" BASIS,
13 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | # See the License for the specific language governing permissions and
15 | # limitations under the License.
16 | 
17 | # Generated by synthtool. DO NOT EDIT!
18 | [flake8]
19 | ignore = E203, E231, E266, E501, W503
20 | exclude =
21 |   # Exclude generated code.
22 |   **/proto/**
23 |   **/gapic/**
24 |   **/services/**
25 |   **/types/**
26 |   *_pb2.py
27 | 
28 |   # Standard linting exemptions.
29 |   **/.nox/**
30 |   __pycache__,
31 |   .git,
32 |   *.pyc,
33 |   conf.py
34 | 


--------------------------------------------------------------------------------
/.github/.OwlBot.lock.yaml:
--------------------------------------------------------------------------------
 1 | # Copyright 2025 Google LLC
 2 | #
 3 | # Licensed under the Apache License, Version 2.0 (the "License");
 4 | # you may not use this file except in compliance with the License.
 5 | # You may obtain a copy of the License at
 6 | #
 7 | #      http://www.apache.org/licenses/LICENSE-2.0
 8 | #
 9 | # Unless required by applicable law or agreed to in writing, software
10 | # distributed under the License is distributed on an "AS IS" BASIS,
11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | # See the License for the specific language governing permissions and
13 | # limitations under the License.
14 | docker:
15 |   image: gcr.io/cloud-devrel-public-resources/owlbot-python:latest
16 |   digest: sha256:25de45b58e52021d3a24a6273964371a97a4efeefe6ad3845a64e697c63b6447
17 | # created: 2025-04-14T14:34:43.260858345Z
18 | 


--------------------------------------------------------------------------------
/.github/.OwlBot.yaml:
--------------------------------------------------------------------------------
 1 | # Copyright 2021 Google LLC
 2 | #
 3 | # Licensed under the Apache License, Version 2.0 (the "License");
 4 | # you may not use this file except in compliance with the License.
 5 | # You may obtain a copy of the License at
 6 | #
 7 | #     http://www.apache.org/licenses/LICENSE-2.0
 8 | #
 9 | # Unless required by applicable law or agreed to in writing, software
10 | # distributed under the License is distributed on an "AS IS" BASIS,
11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | # See the License for the specific language governing permissions and
13 | # limitations under the License.
14 | 
15 | docker:
16 |   image: gcr.io/cloud-devrel-public-resources/owlbot-python:latest
17 | 
18 | begin-after-commit-hash: be22498ce258bf2d5fe12fd696d3ad9a2b6c430e
19 | 
20 | 


--------------------------------------------------------------------------------
/.github/CODEOWNERS:
--------------------------------------------------------------------------------
 1 | # Code owners file.
 2 | # This file controls who is tagged for review for any given pull request.
 3 | #
 4 | # For syntax help see:
 5 | # https://help.github.com/en/github/creating-cloning-and-archiving-repositories/about-code-owners#codeowners-syntax
 6 | # Note: This file is autogenerated. To make changes to the codeowner team, please update .repo-metadata.json.
 7 | 
 8 | # @googleapis/yoshi-python @googleapis/api-bigquery are the default owners for changes in this repo
 9 | *     @googleapis/yoshi-python @googleapis/api-bigquery
10 | 
11 | # @googleapis/python-samples-reviewers @googleapis/api-bigquery are the default owners for samples changes
12 | /samples/   @googleapis/python-samples-reviewers @googleapis/api-bigquery
13 | 


--------------------------------------------------------------------------------
/.github/CONTRIBUTING.md:
--------------------------------------------------------------------------------
 1 | # How to Contribute
 2 | 
 3 | We'd love to accept your patches and contributions to this project. There are
 4 | just a few small guidelines you need to follow.
 5 | 
 6 | ## Contributor License Agreement
 7 | 
 8 | Contributions to this project must be accompanied by a Contributor License
 9 | Agreement. You (or your employer) retain the copyright to your contribution;
10 | this simply gives us permission to use and redistribute your contributions as
11 | part of the project. Head over to <https://cla.developers.google.com/> to see
12 | your current agreements on file or to sign a new one.
13 | 
14 | You generally only need to submit a CLA once, so if you've already submitted one
15 | (even if it was for a different project), you probably don't need to do it
16 | again.
17 | 
18 | ## Code reviews
19 | 
20 | All submissions, including submissions by project members, require review. We
21 | use GitHub pull requests for this purpose. Consult
22 | [GitHub Help](https://help.github.com/articles/about-pull-requests/) for more
23 | information on using pull requests.
24 | 
25 | ## Community Guidelines
26 | 
27 | This project follows [Google's Open Source Community
28 | Guidelines](https://opensource.google.com/conduct/).
29 | 


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/bug_report.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: Bug report
 3 | about: Create a report to help us improve
 4 | 
 5 | ---
 6 | 
 7 | Thanks for stopping by to let us know something could be better!
 8 | 
 9 | **PLEASE READ**: If you have a support contract with Google, please create an issue in the [support console](https://cloud.google.com/support/) instead of filing on GitHub. This will ensure a timely response.
10 | 
11 | Please run down the following list and make sure you've tried the usual "quick fixes":
12 | 
13 |   - Search the issues already opened: https://github.com/googleapis/python-bigquery-sqlalchemy/issues
14 |   - Search StackOverflow: https://stackoverflow.com/questions/tagged/google-cloud-platform+python
15 | 
16 | If you are still having issues, please be sure to include as much information as possible:
17 | 
18 | #### Environment details
19 | 
20 |   - OS type and version:
21 |   - Python version: `python --version`
22 |   - pip version: `pip --version`
23 |   - `sqlalchemy-bigquery` version: `pip show sqlalchemy-bigquery`
24 | 
25 | #### Steps to reproduce
26 | 
27 |   1. ?
28 |   2. ?
29 | 
30 | #### Code example
31 | 
32 | ```python
33 | # example
34 | ```
35 | 
36 | #### Stack trace
37 | ```
38 | # example
39 | ```
40 | 
41 | Making sure to follow these steps will guarantee the quickest resolution possible.
42 | 
43 | Thanks!
44 | 


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/feature_request.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: Feature request
 3 | about: Suggest an idea for this library
 4 | 
 5 | ---
 6 | 
 7 | Thanks for stopping by to let us know something could be better!
 8 | 
 9 | **PLEASE READ**: If you have a support contract with Google, please create an issue in the [support console](https://cloud.google.com/support/) instead of filing on GitHub. This will ensure a timely response.
10 | 
11 |  **Is your feature request related to a problem? Please describe.**
12 | A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
13 |  **Describe the solution you'd like**
14 | A clear and concise description of what you want to happen.
15 |  **Describe alternatives you've considered**
16 | A clear and concise description of any alternative solutions or features you've considered.
17 |  **Additional context**
18 | Add any other context or screenshots about the feature request here.
19 | 


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/support_request.md:
--------------------------------------------------------------------------------
1 | ---
2 | name: Support request
3 | about: If you have a support contract with Google, please create an issue in the Google Cloud Support console.
4 | 
5 | ---
6 | 
7 | **PLEASE READ**: If you have a support contract with Google, please create an issue in the [support console](https://cloud.google.com/support/) instead of filing on GitHub. This will ensure a timely response.
8 | 


--------------------------------------------------------------------------------
/.github/PULL_REQUEST_TEMPLATE.md:
--------------------------------------------------------------------------------
1 | Thank you for opening a Pull Request! Before submitting your PR, there are a few things you can do to make sure it goes smoothly:
2 | - [ ] Make sure to open an issue as a [bug/issue](https://github.com/googleapis/python-bigquery-sqlalchemy/issues/new/choose) before writing your code!  That way we can discuss the change, evaluate designs, and agree on the general idea
3 | - [ ] Ensure the tests and linter pass
4 | - [ ] Code coverage does not decrease (if any source code was changed)
5 | - [ ] Appropriate docs were updated (if necessary)
6 | 
7 | Fixes #<issue_number_goes_here> 🦕
8 | 


--------------------------------------------------------------------------------
/.github/auto-approve.yml:
--------------------------------------------------------------------------------
1 | # https://github.com/googleapis/repo-automation-bots/tree/main/packages/auto-approve
2 | processes:
3 |   - "OwlBotTemplateChanges"
4 | 


--------------------------------------------------------------------------------
/.github/auto-label.yaml:
--------------------------------------------------------------------------------
 1 | # Copyright 2024 Google LLC
 2 | #
 3 | # Licensed under the Apache License, Version 2.0 (the "License");
 4 | # you may not use this file except in compliance with the License.
 5 | # You may obtain a copy of the License at
 6 | #
 7 | #     http://www.apache.org/licenses/LICENSE-2.0
 8 | #
 9 | # Unless required by applicable law or agreed to in writing, software
10 | # distributed under the License is distributed on an "AS IS" BASIS,
11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | # See the License for the specific language governing permissions and
13 | # limitations under the License.
14 | requestsize:
15 |   enabled: true
16 | 
17 | path:
18 |   pullrequest: true
19 |   paths:
20 |     samples: "samples"
21 | 


--------------------------------------------------------------------------------
/.github/blunderbuss.yml:
--------------------------------------------------------------------------------
 1 | # Blunderbuss config
 2 | #
 3 | # This file controls who is assigned for pull requests and issues.
 4 | # Note: This file is autogenerated. To make changes to the assignee
 5 | # team, please update `codeowner_team` in `.repo-metadata.json`.
 6 | assign_issues:
 7 |   - googleapis/api-bigquery
 8 | 
 9 | assign_issues_by:
10 |   - labels:
11 |       - "samples"
12 |     to:
13 |       - googleapis/python-samples-reviewers
14 |       - googleapis/api-bigquery
15 | 
16 | assign_prs:
17 |   - googleapis/api-bigquery
18 | 


--------------------------------------------------------------------------------
/.github/header-checker-lint.yml:
--------------------------------------------------------------------------------
 1 | {"allowedCopyrightHolders": ["Google LLC"],
 2 |  "allowedLicenses": ["Apache-2.0", "MIT", "BSD-3"],
 3 |  "ignoreFiles": ["**/requirements.txt", "**/requirements-test.txt", "**/__init__.py", "samples/**/constraints.txt", "samples/**/constraints-test.txt"],
 4 |  "sourceFileExtensions": [
 5 |  	"ts", 
 6 |  	"js", 
 7 |  	"java", 
 8 |  	"sh", 
 9 |  	"Dockerfile", 
10 |  	"yaml", 
11 |  	"py",
12 |  	"html",
13 |  	"txt"
14 |  ]
15 | }


--------------------------------------------------------------------------------
/.github/release-please.yml:
--------------------------------------------------------------------------------
1 | releaseType: python
2 | handleGHRelease: true
3 | 


--------------------------------------------------------------------------------
/.github/release-trigger.yml:
--------------------------------------------------------------------------------
1 | enabled: true
2 | multiScmName: python-bigquery-sqlalchemy
3 | 


--------------------------------------------------------------------------------
/.github/snippet-bot.yml:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/googleapis/python-bigquery-sqlalchemy/d0347202c5fb144f960558d9022b7a22af6ce3f7/.github/snippet-bot.yml


--------------------------------------------------------------------------------
/.github/sync-repo-settings.yaml:
--------------------------------------------------------------------------------
 1 | # https://github.com/googleapis/repo-automation-bots/tree/main/packages/sync-repo-settings
 2 | # Rules for main branch protection
 3 | branchProtectionRules:
 4 | # Identifies the protection rule pattern. Name of the branch to be protected.
 5 | # Defaults to `main`
 6 | - pattern: main
 7 |   requiresCodeOwnerReviews: true
 8 |   requiresStrictStatusChecks: true
 9 |   requiredStatusCheckContexts:
10 |     - 'cla/google'
11 |     - 'OwlBot Post Processor'
12 |     - 'Kokoro'
13 |     - 'Samples - Lint'
14 |     - 'Samples - Python 3.8'
15 |     - 'Samples - Python 3.9'
16 |     - 'Samples - Python 3.10'
17 |     - 'Samples - Python 3.11'
18 |     - 'Samples - Python 3.12'
19 | permissionRules:
20 |   - team: actools-python
21 |     permission: admin
22 |   - team: actools
23 |     permission: admin
24 |   - team: yoshi-python
25 |     permission: push
26 |   - team: python-samples-owners
27 |     permission: push
28 |   - team: python-samples-reviewers
29 |     permission: push
30 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | *.py[cod]
 2 | *.sw[op]
 3 | 
 4 | # C extensions
 5 | *.so
 6 | 
 7 | # Packages
 8 | *.egg
 9 | *.egg-info
10 | dist
11 | build
12 | eggs
13 | .eggs
14 | parts
15 | bin
16 | var
17 | sdist
18 | develop-eggs
19 | .installed.cfg
20 | lib
21 | lib64
22 | __pycache__
23 | 
24 | # Installer logs
25 | pip-log.txt
26 | 
27 | # Unit test / coverage reports
28 | .coverage
29 | .nox
30 | .cache
31 | .pytest_cache
32 | 
33 | 
34 | # Mac
35 | .DS_Store
36 | 
37 | # JetBrains
38 | .idea
39 | 
40 | # VS Code
41 | .vscode
42 | 
43 | # emacs
44 | *~
45 | 
46 | # Built documentation
47 | docs/_build
48 | bigquery/docs/generated
49 | docs.metadata
50 | 
51 | # Virtual environment
52 | env/
53 | venv/
54 | 
55 | # Test logs
56 | coverage.xml
57 | *sponge_log.xml
58 | 
59 | # System test environment variables.
60 | system_tests/local_test_setup
61 | 
62 | # Make sure a generated file isn't accidentally committed.
63 | pylintrc
64 | pylintrc.test
65 | 


--------------------------------------------------------------------------------
/.kokoro/build.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | # Copyright 2024 Google LLC
 3 | #
 4 | # Licensed under the Apache License, Version 2.0 (the "License");
 5 | # you may not use this file except in compliance with the License.
 6 | # You may obtain a copy of the License at
 7 | #
 8 | #     https://www.apache.org/licenses/LICENSE-2.0
 9 | #
10 | # Unless required by applicable law or agreed to in writing, software
11 | # distributed under the License is distributed on an "AS IS" BASIS,
12 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | # See the License for the specific language governing permissions and
14 | # limitations under the License.
15 | 
16 | set -eo pipefail
17 | 
18 | CURRENT_DIR=$(dirname "${BASH_SOURCE[0]}")
19 | 
20 | if [[ -z "${PROJECT_ROOT:-}" ]]; then
21 |   PROJECT_ROOT=$(realpath "${CURRENT_DIR}/..")
22 | fi
23 | 
24 | pushd "${PROJECT_ROOT}"
25 | 
26 | # Disable buffering, so that the logs stream through.
27 | export PYTHONUNBUFFERED=1
28 | 
29 | # Debug: show build environment
30 | env | grep KOKORO
31 | 
32 | # Setup service account credentials.
33 | if [[ -f "${KOKORO_GFILE_DIR}/service-account.json" ]]
34 | then
35 |   export GOOGLE_APPLICATION_CREDENTIALS=${KOKORO_GFILE_DIR}/service-account.json
36 | fi
37 | 
38 | # Setup project id.
39 | if [[ -f "${KOKORO_GFILE_DIR}/project-id.json" ]]
40 | then
41 |   export PROJECT_ID=$(cat "${KOKORO_GFILE_DIR}/project-id.json")
42 | fi
43 | 
44 | # If this is a continuous build, send the test log to the FlakyBot.
45 | # See https://github.com/googleapis/repo-automation-bots/tree/main/packages/flakybot.
46 | if [[ $KOKORO_BUILD_ARTIFACTS_SUBDIR = *"continuous"* ]]; then
47 |   cleanup() {
48 |     chmod +x $KOKORO_GFILE_DIR/linux_amd64/flakybot
49 |     $KOKORO_GFILE_DIR/linux_amd64/flakybot
50 |   }
51 |   trap cleanup EXIT HUP
52 | fi
53 | 
54 | # If NOX_SESSION is set, it only runs the specified session,
55 | # otherwise run all the sessions.
56 | if [[ -n "${NOX_SESSION:-}" ]]; then
57 |   python3 -m nox -s ${NOX_SESSION:-}
58 | else
59 |   python3 -m nox
60 | fi
61 | 


--------------------------------------------------------------------------------
/.kokoro/continuous/common.cfg:
--------------------------------------------------------------------------------
 1 | # Format: //devtools/kokoro/config/proto/build.proto
 2 | 
 3 | # Build logs will be here
 4 | action {
 5 |   define_artifacts {
 6 |     regex: "**/*sponge_log.xml"
 7 |   }
 8 | }
 9 | 
10 | # Download trampoline resources.
11 | gfile_resources: "/bigstore/cloud-devrel-kokoro-resources/trampoline"
12 | 
13 | # Download resources for system tests (service account key, etc.)
14 | gfile_resources: "/bigstore/cloud-devrel-kokoro-resources/google-cloud-python"
15 | 
16 | # Use the trampoline script to run in docker.
17 | build_file: "python-bigquery-sqlalchemy/.kokoro/trampoline.sh"
18 | 
19 | # Configure the docker image for kokoro-trampoline.
20 | env_vars: {
21 |     key: "TRAMPOLINE_IMAGE"
22 |     value: "gcr.io/cloud-devrel-kokoro-resources/python-multi"
23 | }
24 | env_vars: {
25 |     key: "TRAMPOLINE_BUILD_FILE"
26 |     value: "github/python-bigquery-sqlalchemy/.kokoro/build.sh"
27 | }
28 | 


--------------------------------------------------------------------------------
/.kokoro/continuous/compliance.cfg:
--------------------------------------------------------------------------------
1 | # Format: //devtools/kokoro/config/proto/build.proto
2 | 
3 | # Only run this nox session.
4 | env_vars: {
5 |     key: "NOX_SESSION"
6 |     value: "compliance"
7 | }
8 | 


--------------------------------------------------------------------------------
/.kokoro/continuous/continuous.cfg:
--------------------------------------------------------------------------------
1 | # Format: //devtools/kokoro/config/proto/build.proto


--------------------------------------------------------------------------------
/.kokoro/continuous/prerelease-deps.cfg:
--------------------------------------------------------------------------------
1 | # Format: //devtools/kokoro/config/proto/build.proto
2 | 
3 | # Only run this nox session.
4 | env_vars: {
5 |     key: "NOX_SESSION"
6 |     value: "prerelease_deps"
7 | }
8 | 


--------------------------------------------------------------------------------
/.kokoro/populate-secrets.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | # Copyright 2024 Google LLC.
 3 | #
 4 | # Licensed under the Apache License, Version 2.0 (the "License");
 5 | # you may not use this file except in compliance with the License.
 6 | # You may obtain a copy of the License at
 7 | #
 8 | #      http://www.apache.org/licenses/LICENSE-2.0
 9 | #
10 | # Unless required by applicable law or agreed to in writing, software
11 | # distributed under the License is distributed on an "AS IS" BASIS,
12 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | # See the License for the specific language governing permissions and
14 | # limitations under the License.
15 | 
16 | set -eo pipefail
17 | 
18 | function now { date +"%Y-%m-%d %H:%M:%S" | tr -d '\n' ;}
19 | function msg { println "$*" >&2 ;}
20 | function println { printf '%s\n' "$(now) $*" ;}
21 | 
22 | 
23 | # Populates requested secrets set in SECRET_MANAGER_KEYS from service account:
24 | # kokoro-trampoline@cloud-devrel-kokoro-resources.iam.gserviceaccount.com
25 | SECRET_LOCATION="${KOKORO_GFILE_DIR}/secret_manager"
26 | msg "Creating folder on disk for secrets: ${SECRET_LOCATION}"
27 | mkdir -p ${SECRET_LOCATION}
28 | for key in $(echo ${SECRET_MANAGER_KEYS} | sed "s/,/ /g")
29 | do
30 |   msg "Retrieving secret ${key}"
31 |   docker run --entrypoint=gcloud \
32 |     --volume=${KOKORO_GFILE_DIR}:${KOKORO_GFILE_DIR} \
33 |     gcr.io/google.com/cloudsdktool/cloud-sdk \
34 |     secrets versions access latest \
35 |     --project cloud-devrel-kokoro-resources \
36 |     --secret ${key} > \
37 |     "${SECRET_LOCATION}/${key}"
38 |   if [[ $? == 0 ]]; then
39 |     msg "Secret written to ${SECRET_LOCATION}/${key}"
40 |   else
41 |     msg "Error retrieving secret ${key}"
42 |   fi
43 | done
44 | 


--------------------------------------------------------------------------------
/.kokoro/presubmit/common.cfg:
--------------------------------------------------------------------------------
 1 | # Format: //devtools/kokoro/config/proto/build.proto
 2 | 
 3 | # Build logs will be here
 4 | action {
 5 |   define_artifacts {
 6 |     regex: "**/*sponge_log.xml"
 7 |   }
 8 | }
 9 | 
10 | # Download trampoline resources.
11 | gfile_resources: "/bigstore/cloud-devrel-kokoro-resources/trampoline"
12 | 
13 | # Download resources for system tests (service account key, etc.)
14 | gfile_resources: "/bigstore/cloud-devrel-kokoro-resources/google-cloud-python"
15 | 
16 | # Use the trampoline script to run in docker.
17 | build_file: "python-bigquery-sqlalchemy/.kokoro/trampoline.sh"
18 | 
19 | # Configure the docker image for kokoro-trampoline.
20 | env_vars: {
21 |     key: "TRAMPOLINE_IMAGE"
22 |     value: "gcr.io/cloud-devrel-kokoro-resources/python-multi"
23 | }
24 | env_vars: {
25 |     key: "TRAMPOLINE_BUILD_FILE"
26 |     value: "github/python-bigquery-sqlalchemy/.kokoro/build.sh"
27 | }
28 | 


--------------------------------------------------------------------------------
/.kokoro/presubmit/compliance.cfg:
--------------------------------------------------------------------------------
1 | # Format: //devtools/kokoro/config/proto/build.proto
2 | 
3 | # Only run this nox session.
4 | env_vars: {
5 |     key: "NOX_SESSION"
6 |     value: "compliance"
7 | }
8 | 


--------------------------------------------------------------------------------
/.kokoro/presubmit/prerelease-deps.cfg:
--------------------------------------------------------------------------------
1 | # Format: //devtools/kokoro/config/proto/build.proto
2 | 
3 | # Only run this nox session.
4 | env_vars: {
5 |     key: "NOX_SESSION"
6 |     value: "prerelease_deps"
7 | }
8 | 


--------------------------------------------------------------------------------
/.kokoro/presubmit/presubmit.cfg:
--------------------------------------------------------------------------------
1 | # Format: //devtools/kokoro/config/proto/build.proto


--------------------------------------------------------------------------------
/.kokoro/samples/lint/common.cfg:
--------------------------------------------------------------------------------
 1 | # Format: //devtools/kokoro/config/proto/build.proto
 2 | 
 3 | # Build logs will be here
 4 | action {
 5 |   define_artifacts {
 6 |     regex: "**/*sponge_log.xml"
 7 |   }
 8 | }
 9 | 
10 | # Specify which tests to run
11 | env_vars: {
12 |     key: "RUN_TESTS_SESSION"
13 |     value: "lint"
14 | }
15 | 
16 | env_vars: {
17 |     key: "TRAMPOLINE_BUILD_FILE"
18 |     value: "github/python-bigquery-sqlalchemy/.kokoro/test-samples.sh"
19 | }
20 | 
21 | # Configure the docker image for kokoro-trampoline.
22 | env_vars: {
23 |     key: "TRAMPOLINE_IMAGE"
24 |     value: "gcr.io/cloud-devrel-kokoro-resources/python-samples-testing-docker"
25 | }
26 | 
27 | # Download secrets for samples
28 | gfile_resources: "/bigstore/cloud-devrel-kokoro-resources/python-docs-samples"
29 | 
30 | # Download trampoline resources.
31 | gfile_resources: "/bigstore/cloud-devrel-kokoro-resources/trampoline"
32 | 
33 | # Use the trampoline script to run in docker.
34 | build_file: "python-bigquery-sqlalchemy/.kokoro/trampoline_v2.sh"


--------------------------------------------------------------------------------
/.kokoro/samples/lint/continuous.cfg:
--------------------------------------------------------------------------------
1 | # Format: //devtools/kokoro/config/proto/build.proto
2 | 
3 | env_vars: {
4 |     key: "INSTALL_LIBRARY_FROM_SOURCE"
5 |     value: "True"
6 | }


--------------------------------------------------------------------------------
/.kokoro/samples/lint/periodic.cfg:
--------------------------------------------------------------------------------
1 | # Format: //devtools/kokoro/config/proto/build.proto
2 | 
3 | env_vars: {
4 |     key: "INSTALL_LIBRARY_FROM_SOURCE"
5 |     value: "False"
6 | }


--------------------------------------------------------------------------------
/.kokoro/samples/lint/presubmit.cfg:
--------------------------------------------------------------------------------
1 | # Format: //devtools/kokoro/config/proto/build.proto
2 | 
3 | env_vars: {
4 |     key: "INSTALL_LIBRARY_FROM_SOURCE"
5 |     value: "True"
6 | }


--------------------------------------------------------------------------------
/.kokoro/samples/python3.10/common.cfg:
--------------------------------------------------------------------------------
 1 | # Format: //devtools/kokoro/config/proto/build.proto
 2 | 
 3 | # Build logs will be here
 4 | action {
 5 |   define_artifacts {
 6 |     regex: "**/*sponge_log.xml"
 7 |   }
 8 | }
 9 | 
10 | # Specify which tests to run
11 | env_vars: {
12 |     key: "RUN_TESTS_SESSION"
13 |     value: "py-3.10"
14 | }
15 | 
16 | # Declare build specific Cloud project.
17 | env_vars: {
18 |     key: "BUILD_SPECIFIC_GCLOUD_PROJECT"
19 |     value: "python-docs-samples-tests-310"
20 | }
21 | 
22 | env_vars: {
23 |     key: "TRAMPOLINE_BUILD_FILE"
24 |     value: "github/python-bigquery-sqlalchemy/.kokoro/test-samples.sh"
25 | }
26 | 
27 | # Configure the docker image for kokoro-trampoline.
28 | env_vars: {
29 |     key: "TRAMPOLINE_IMAGE"
30 |     value: "gcr.io/cloud-devrel-kokoro-resources/python-samples-testing-docker"
31 | }
32 | 
33 | # Download secrets for samples
34 | gfile_resources: "/bigstore/cloud-devrel-kokoro-resources/python-docs-samples"
35 | 
36 | # Download trampoline resources.
37 | gfile_resources: "/bigstore/cloud-devrel-kokoro-resources/trampoline"
38 | 
39 | # Use the trampoline script to run in docker.
40 | build_file: "python-bigquery-sqlalchemy/.kokoro/trampoline_v2.sh"


--------------------------------------------------------------------------------
/.kokoro/samples/python3.10/continuous.cfg:
--------------------------------------------------------------------------------
1 | # Format: //devtools/kokoro/config/proto/build.proto
2 | 
3 | env_vars: {
4 |     key: "INSTALL_LIBRARY_FROM_SOURCE"
5 |     value: "True"
6 | }


--------------------------------------------------------------------------------
/.kokoro/samples/python3.10/periodic-head.cfg:
--------------------------------------------------------------------------------
 1 | # Format: //devtools/kokoro/config/proto/build.proto
 2 | 
 3 | env_vars: {
 4 |     key: "INSTALL_LIBRARY_FROM_SOURCE"
 5 |     value: "True"
 6 | }
 7 | 
 8 | env_vars: {
 9 |     key: "TRAMPOLINE_BUILD_FILE"
10 |     value: "github/python-bigquery-sqlalchemy/.kokoro/test-samples-against-head.sh"
11 | }
12 | 


--------------------------------------------------------------------------------
/.kokoro/samples/python3.10/periodic.cfg:
--------------------------------------------------------------------------------
1 | # Format: //devtools/kokoro/config/proto/build.proto
2 | 
3 | env_vars: {
4 |     key: "INSTALL_LIBRARY_FROM_SOURCE"
5 |     value: "False"
6 | }
7 | 


--------------------------------------------------------------------------------
/.kokoro/samples/python3.10/presubmit.cfg:
--------------------------------------------------------------------------------
1 | # Format: //devtools/kokoro/config/proto/build.proto
2 | 
3 | env_vars: {
4 |     key: "INSTALL_LIBRARY_FROM_SOURCE"
5 |     value: "True"
6 | }


--------------------------------------------------------------------------------
/.kokoro/samples/python3.11/common.cfg:
--------------------------------------------------------------------------------
 1 | # Format: //devtools/kokoro/config/proto/build.proto
 2 | 
 3 | # Build logs will be here
 4 | action {
 5 |   define_artifacts {
 6 |     regex: "**/*sponge_log.xml"
 7 |   }
 8 | }
 9 | 
10 | # Specify which tests to run
11 | env_vars: {
12 |     key: "RUN_TESTS_SESSION"
13 |     value: "py-3.11"
14 | }
15 | 
16 | # Declare build specific Cloud project.
17 | env_vars: {
18 |     key: "BUILD_SPECIFIC_GCLOUD_PROJECT"
19 |     value: "python-docs-samples-tests-311"
20 | }
21 | 
22 | env_vars: {
23 |     key: "TRAMPOLINE_BUILD_FILE"
24 |     value: "github/python-bigquery-sqlalchemy/.kokoro/test-samples.sh"
25 | }
26 | 
27 | # Configure the docker image for kokoro-trampoline.
28 | env_vars: {
29 |     key: "TRAMPOLINE_IMAGE"
30 |     value: "gcr.io/cloud-devrel-kokoro-resources/python-samples-testing-docker"
31 | }
32 | 
33 | # Download secrets for samples
34 | gfile_resources: "/bigstore/cloud-devrel-kokoro-resources/python-docs-samples"
35 | 
36 | # Download trampoline resources.
37 | gfile_resources: "/bigstore/cloud-devrel-kokoro-resources/trampoline"
38 | 
39 | # Use the trampoline script to run in docker.
40 | build_file: "python-bigquery-sqlalchemy/.kokoro/trampoline_v2.sh"


--------------------------------------------------------------------------------
/.kokoro/samples/python3.11/continuous.cfg:
--------------------------------------------------------------------------------
1 | # Format: //devtools/kokoro/config/proto/build.proto
2 | 
3 | env_vars: {
4 |     key: "INSTALL_LIBRARY_FROM_SOURCE"
5 |     value: "True"
6 | }


--------------------------------------------------------------------------------
/.kokoro/samples/python3.11/periodic-head.cfg:
--------------------------------------------------------------------------------
 1 | # Format: //devtools/kokoro/config/proto/build.proto
 2 | 
 3 | env_vars: {
 4 |     key: "INSTALL_LIBRARY_FROM_SOURCE"
 5 |     value: "True"
 6 | }
 7 | 
 8 | env_vars: {
 9 |     key: "TRAMPOLINE_BUILD_FILE"
10 |     value: "github/python-bigquery-sqlalchemy/.kokoro/test-samples-against-head.sh"
11 | }
12 | 


--------------------------------------------------------------------------------
/.kokoro/samples/python3.11/periodic.cfg:
--------------------------------------------------------------------------------
1 | # Format: //devtools/kokoro/config/proto/build.proto
2 | 
3 | env_vars: {
4 |     key: "INSTALL_LIBRARY_FROM_SOURCE"
5 |     value: "False"
6 | }
7 | 


--------------------------------------------------------------------------------
/.kokoro/samples/python3.11/presubmit.cfg:
--------------------------------------------------------------------------------
1 | # Format: //devtools/kokoro/config/proto/build.proto
2 | 
3 | env_vars: {
4 |     key: "INSTALL_LIBRARY_FROM_SOURCE"
5 |     value: "True"
6 | }


--------------------------------------------------------------------------------
/.kokoro/samples/python3.12/common.cfg:
--------------------------------------------------------------------------------
 1 | # Format: //devtools/kokoro/config/proto/build.proto
 2 | 
 3 | # Build logs will be here
 4 | action {
 5 |   define_artifacts {
 6 |     regex: "**/*sponge_log.xml"
 7 |   }
 8 | }
 9 | 
10 | # Specify which tests to run
11 | env_vars: {
12 |     key: "RUN_TESTS_SESSION"
13 |     value: "py-3.12"
14 | }
15 | 
16 | # Declare build specific Cloud project.
17 | env_vars: {
18 |     key: "BUILD_SPECIFIC_GCLOUD_PROJECT"
19 |     value: "python-docs-samples-tests-312"
20 | }
21 | 
22 | env_vars: {
23 |     key: "TRAMPOLINE_BUILD_FILE"
24 |     value: "github/python-bigquery-sqlalchemy/.kokoro/test-samples.sh"
25 | }
26 | 
27 | # Configure the docker image for kokoro-trampoline.
28 | env_vars: {
29 |     key: "TRAMPOLINE_IMAGE"
30 |     value: "gcr.io/cloud-devrel-kokoro-resources/python-samples-testing-docker"
31 | }
32 | 
33 | # Download secrets for samples
34 | gfile_resources: "/bigstore/cloud-devrel-kokoro-resources/python-docs-samples"
35 | 
36 | # Download trampoline resources.
37 | gfile_resources: "/bigstore/cloud-devrel-kokoro-resources/trampoline"
38 | 
39 | # Use the trampoline script to run in docker.
40 | build_file: "python-bigquery-sqlalchemy/.kokoro/trampoline_v2.sh"


--------------------------------------------------------------------------------
/.kokoro/samples/python3.12/continuous.cfg:
--------------------------------------------------------------------------------
1 | # Format: //devtools/kokoro/config/proto/build.proto
2 | 
3 | env_vars: {
4 |     key: "INSTALL_LIBRARY_FROM_SOURCE"
5 |     value: "True"
6 | }


--------------------------------------------------------------------------------
/.kokoro/samples/python3.12/periodic-head.cfg:
--------------------------------------------------------------------------------
 1 | # Format: //devtools/kokoro/config/proto/build.proto
 2 | 
 3 | env_vars: {
 4 |     key: "INSTALL_LIBRARY_FROM_SOURCE"
 5 |     value: "True"
 6 | }
 7 | 
 8 | env_vars: {
 9 |     key: "TRAMPOLINE_BUILD_FILE"
10 |     value: "github/python-bigquery-sqlalchemy/.kokoro/test-samples-against-head.sh"
11 | }
12 | 


--------------------------------------------------------------------------------
/.kokoro/samples/python3.12/periodic.cfg:
--------------------------------------------------------------------------------
1 | # Format: //devtools/kokoro/config/proto/build.proto
2 | 
3 | env_vars: {
4 |     key: "INSTALL_LIBRARY_FROM_SOURCE"
5 |     value: "False"
6 | }
7 | 


--------------------------------------------------------------------------------
/.kokoro/samples/python3.12/presubmit.cfg:
--------------------------------------------------------------------------------
1 | # Format: //devtools/kokoro/config/proto/build.proto
2 | 
3 | env_vars: {
4 |     key: "INSTALL_LIBRARY_FROM_SOURCE"
5 |     value: "True"
6 | }


--------------------------------------------------------------------------------
/.kokoro/samples/python3.13/common.cfg:
--------------------------------------------------------------------------------
 1 | # Format: //devtools/kokoro/config/proto/build.proto
 2 | 
 3 | # Build logs will be here
 4 | action {
 5 |   define_artifacts {
 6 |     regex: "**/*sponge_log.xml"
 7 |   }
 8 | }
 9 | 
10 | # Specify which tests to run
11 | env_vars: {
12 |     key: "RUN_TESTS_SESSION"
13 |     value: "py-3.13"
14 | }
15 | 
16 | # Declare build specific Cloud project.
17 | env_vars: {
18 |     key: "BUILD_SPECIFIC_GCLOUD_PROJECT"
19 |     value: "python-docs-samples-tests-313"
20 | }
21 | 
22 | env_vars: {
23 |     key: "TRAMPOLINE_BUILD_FILE"
24 |     value: "github/python-bigquery-sqlalchemy/.kokoro/test-samples.sh"
25 | }
26 | 
27 | # Configure the docker image for kokoro-trampoline.
28 | env_vars: {
29 |     key: "TRAMPOLINE_IMAGE"
30 |     value: "gcr.io/cloud-devrel-kokoro-resources/python-samples-testing-docker"
31 | }
32 | 
33 | # Download secrets for samples
34 | gfile_resources: "/bigstore/cloud-devrel-kokoro-resources/python-docs-samples"
35 | 
36 | # Download trampoline resources.
37 | gfile_resources: "/bigstore/cloud-devrel-kokoro-resources/trampoline"
38 | 
39 | # Use the trampoline script to run in docker.
40 | build_file: "python-bigquery-sqlalchemy/.kokoro/trampoline_v2.sh"
41 | 


--------------------------------------------------------------------------------
/.kokoro/samples/python3.13/continuous.cfg:
--------------------------------------------------------------------------------
1 | # Format: //devtools/kokoro/config/proto/build.proto
2 | 
3 | env_vars: {
4 |     key: "INSTALL_LIBRARY_FROM_SOURCE"
5 |     value: "True"
6 | }


--------------------------------------------------------------------------------
/.kokoro/samples/python3.13/periodic-head.cfg:
--------------------------------------------------------------------------------
 1 | # Format: //devtools/kokoro/config/proto/build.proto
 2 | 
 3 | env_vars: {
 4 |     key: "INSTALL_LIBRARY_FROM_SOURCE"
 5 |     value: "True"
 6 | }
 7 | 
 8 | env_vars: {
 9 |     key: "TRAMPOLINE_BUILD_FILE"
10 |     value: "github/python-bigquery-sqlalchemy/.kokoro/test-samples-against-head.sh"
11 | }
12 | 


--------------------------------------------------------------------------------
/.kokoro/samples/python3.13/periodic.cfg:
--------------------------------------------------------------------------------
1 | # Format: //devtools/kokoro/config/proto/build.proto
2 | 
3 | env_vars: {
4 |     key: "INSTALL_LIBRARY_FROM_SOURCE"
5 |     value: "False"
6 | }
7 | 


--------------------------------------------------------------------------------
/.kokoro/samples/python3.13/presubmit.cfg:
--------------------------------------------------------------------------------
1 | # Format: //devtools/kokoro/config/proto/build.proto
2 | 
3 | env_vars: {
4 |     key: "INSTALL_LIBRARY_FROM_SOURCE"
5 |     value: "True"
6 | }


--------------------------------------------------------------------------------
/.kokoro/samples/python3.7/common.cfg:
--------------------------------------------------------------------------------
 1 | # Format: //devtools/kokoro/config/proto/build.proto
 2 | 
 3 | # Build logs will be here
 4 | action {
 5 |   define_artifacts {
 6 |     regex: "**/*sponge_log.xml"
 7 |   }
 8 | }
 9 | 
10 | # Specify which tests to run
11 | env_vars: {
12 |     key: "RUN_TESTS_SESSION"
13 |     value: "py-3.7"
14 | }
15 | 
16 | # Declare build specific Cloud project.
17 | env_vars: {
18 |     key: "BUILD_SPECIFIC_GCLOUD_PROJECT"
19 |     value: "python-docs-samples-tests-py37"
20 | }
21 | 
22 | env_vars: {
23 |     key: "TRAMPOLINE_BUILD_FILE"
24 |     value: "github/python-bigquery-sqlalchemy/.kokoro/test-samples.sh"
25 | }
26 | 
27 | # Configure the docker image for kokoro-trampoline.
28 | env_vars: {
29 |     key: "TRAMPOLINE_IMAGE"
30 |     value: "gcr.io/cloud-devrel-kokoro-resources/python-samples-testing-docker"
31 | }
32 | 
33 | # Download secrets for samples
34 | gfile_resources: "/bigstore/cloud-devrel-kokoro-resources/python-docs-samples"
35 | 
36 | # Download trampoline resources.
37 | gfile_resources: "/bigstore/cloud-devrel-kokoro-resources/trampoline"
38 | 
39 | # Use the trampoline script to run in docker.
40 | build_file: "python-bigquery-sqlalchemy/.kokoro/trampoline_v2.sh"


--------------------------------------------------------------------------------
/.kokoro/samples/python3.7/continuous.cfg:
--------------------------------------------------------------------------------
1 | # Format: //devtools/kokoro/config/proto/build.proto
2 | 
3 | env_vars: {
4 |     key: "INSTALL_LIBRARY_FROM_SOURCE"
5 |     value: "True"
6 | }


--------------------------------------------------------------------------------
/.kokoro/samples/python3.7/periodic-head.cfg:
--------------------------------------------------------------------------------
 1 | # Format: //devtools/kokoro/config/proto/build.proto
 2 | 
 3 | env_vars: {
 4 |     key: "INSTALL_LIBRARY_FROM_SOURCE"
 5 |     value: "True"
 6 | }
 7 | 
 8 | env_vars: {
 9 |     key: "TRAMPOLINE_BUILD_FILE"
10 |     value: "github/python-bigquery-sqlalchemy/.kokoro/test-samples-against-head.sh"
11 | }
12 | 


--------------------------------------------------------------------------------
/.kokoro/samples/python3.7/periodic.cfg:
--------------------------------------------------------------------------------
1 | # Format: //devtools/kokoro/config/proto/build.proto
2 | 
3 | env_vars: {
4 |     key: "INSTALL_LIBRARY_FROM_SOURCE"
5 |     value: "False"
6 | }
7 | 


--------------------------------------------------------------------------------
/.kokoro/samples/python3.7/presubmit.cfg:
--------------------------------------------------------------------------------
1 | # Format: //devtools/kokoro/config/proto/build.proto
2 | 
3 | env_vars: {
4 |     key: "INSTALL_LIBRARY_FROM_SOURCE"
5 |     value: "True"
6 | }


--------------------------------------------------------------------------------
/.kokoro/samples/python3.8/common.cfg:
--------------------------------------------------------------------------------
 1 | # Format: //devtools/kokoro/config/proto/build.proto
 2 | 
 3 | # Build logs will be here
 4 | action {
 5 |   define_artifacts {
 6 |     regex: "**/*sponge_log.xml"
 7 |   }
 8 | }
 9 | 
10 | # Specify which tests to run
11 | env_vars: {
12 |     key: "RUN_TESTS_SESSION"
13 |     value: "py-3.8"
14 | }
15 | 
16 | # Declare build specific Cloud project.
17 | env_vars: {
18 |     key: "BUILD_SPECIFIC_GCLOUD_PROJECT"
19 |     value: "python-docs-samples-tests-py38"
20 | }
21 | 
22 | env_vars: {
23 |     key: "TRAMPOLINE_BUILD_FILE"
24 |     value: "github/python-bigquery-sqlalchemy/.kokoro/test-samples.sh"
25 | }
26 | 
27 | # Configure the docker image for kokoro-trampoline.
28 | env_vars: {
29 |     key: "TRAMPOLINE_IMAGE"
30 |     value: "gcr.io/cloud-devrel-kokoro-resources/python-samples-testing-docker"
31 | }
32 | 
33 | # Download secrets for samples
34 | gfile_resources: "/bigstore/cloud-devrel-kokoro-resources/python-docs-samples"
35 | 
36 | # Download trampoline resources.
37 | gfile_resources: "/bigstore/cloud-devrel-kokoro-resources/trampoline"
38 | 
39 | # Use the trampoline script to run in docker.
40 | build_file: "python-bigquery-sqlalchemy/.kokoro/trampoline_v2.sh"


--------------------------------------------------------------------------------
/.kokoro/samples/python3.8/continuous.cfg:
--------------------------------------------------------------------------------
1 | # Format: //devtools/kokoro/config/proto/build.proto
2 | 
3 | env_vars: {
4 |     key: "INSTALL_LIBRARY_FROM_SOURCE"
5 |     value: "True"
6 | }


--------------------------------------------------------------------------------
/.kokoro/samples/python3.8/periodic-head.cfg:
--------------------------------------------------------------------------------
 1 | # Format: //devtools/kokoro/config/proto/build.proto
 2 | 
 3 | env_vars: {
 4 |     key: "INSTALL_LIBRARY_FROM_SOURCE"
 5 |     value: "True"
 6 | }
 7 | 
 8 | env_vars: {
 9 |     key: "TRAMPOLINE_BUILD_FILE"
10 |     value: "github/python-bigquery-sqlalchemy/.kokoro/test-samples-against-head.sh"
11 | }
12 | 


--------------------------------------------------------------------------------
/.kokoro/samples/python3.8/periodic.cfg:
--------------------------------------------------------------------------------
1 | # Format: //devtools/kokoro/config/proto/build.proto
2 | 
3 | env_vars: {
4 |     key: "INSTALL_LIBRARY_FROM_SOURCE"
5 |     value: "False"
6 | }
7 | 


--------------------------------------------------------------------------------
/.kokoro/samples/python3.8/presubmit.cfg:
--------------------------------------------------------------------------------
1 | # Format: //devtools/kokoro/config/proto/build.proto
2 | 
3 | env_vars: {
4 |     key: "INSTALL_LIBRARY_FROM_SOURCE"
5 |     value: "True"
6 | }


--------------------------------------------------------------------------------
/.kokoro/samples/python3.9/common.cfg:
--------------------------------------------------------------------------------
 1 | # Format: //devtools/kokoro/config/proto/build.proto
 2 | 
 3 | # Build logs will be here
 4 | action {
 5 |   define_artifacts {
 6 |     regex: "**/*sponge_log.xml"
 7 |   }
 8 | }
 9 | 
10 | # Specify which tests to run
11 | env_vars: {
12 |     key: "RUN_TESTS_SESSION"
13 |     value: "py-3.9"
14 | }
15 | 
16 | # Declare build specific Cloud project.
17 | env_vars: {
18 |     key: "BUILD_SPECIFIC_GCLOUD_PROJECT"
19 |     value: "python-docs-samples-tests-py39"
20 | }
21 | 
22 | env_vars: {
23 |     key: "TRAMPOLINE_BUILD_FILE"
24 |     value: "github/python-bigquery-sqlalchemy/.kokoro/test-samples.sh"
25 | }
26 | 
27 | # Configure the docker image for kokoro-trampoline.
28 | env_vars: {
29 |     key: "TRAMPOLINE_IMAGE"
30 |     value: "gcr.io/cloud-devrel-kokoro-resources/python-samples-testing-docker"
31 | }
32 | 
33 | # Download secrets for samples
34 | gfile_resources: "/bigstore/cloud-devrel-kokoro-resources/python-docs-samples"
35 | 
36 | # Download trampoline resources.
37 | gfile_resources: "/bigstore/cloud-devrel-kokoro-resources/trampoline"
38 | 
39 | # Use the trampoline script to run in docker.
40 | build_file: "python-bigquery-sqlalchemy/.kokoro/trampoline_v2.sh"


--------------------------------------------------------------------------------
/.kokoro/samples/python3.9/continuous.cfg:
--------------------------------------------------------------------------------
1 | # Format: //devtools/kokoro/config/proto/build.proto
2 | 
3 | env_vars: {
4 |     key: "INSTALL_LIBRARY_FROM_SOURCE"
5 |     value: "True"
6 | }


--------------------------------------------------------------------------------
/.kokoro/samples/python3.9/periodic-head.cfg:
--------------------------------------------------------------------------------
 1 | # Format: //devtools/kokoro/config/proto/build.proto
 2 | 
 3 | env_vars: {
 4 |     key: "INSTALL_LIBRARY_FROM_SOURCE"
 5 |     value: "True"
 6 | }
 7 | 
 8 | env_vars: {
 9 |     key: "TRAMPOLINE_BUILD_FILE"
10 |     value: "github/python-bigquery-sqlalchemy/.kokoro/test-samples-against-head.sh"
11 | }
12 | 


--------------------------------------------------------------------------------
/.kokoro/samples/python3.9/periodic.cfg:
--------------------------------------------------------------------------------
1 | # Format: //devtools/kokoro/config/proto/build.proto
2 | 
3 | env_vars: {
4 |     key: "INSTALL_LIBRARY_FROM_SOURCE"
5 |     value: "False"
6 | }
7 | 


--------------------------------------------------------------------------------
/.kokoro/samples/python3.9/presubmit.cfg:
--------------------------------------------------------------------------------
1 | # Format: //devtools/kokoro/config/proto/build.proto
2 | 
3 | env_vars: {
4 |     key: "INSTALL_LIBRARY_FROM_SOURCE"
5 |     value: "True"
6 | }


--------------------------------------------------------------------------------
/.kokoro/test-samples-against-head.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | # Copyright 2024 Google LLC
 3 | #
 4 | # Licensed under the Apache License, Version 2.0 (the "License");
 5 | # you may not use this file except in compliance with the License.
 6 | # You may obtain a copy of the License at
 7 | #
 8 | #     https://www.apache.org/licenses/LICENSE-2.0
 9 | #
10 | # Unless required by applicable law or agreed to in writing, software
11 | # distributed under the License is distributed on an "AS IS" BASIS,
12 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | # See the License for the specific language governing permissions and
14 | # limitations under the License.
15 | 
16 | # A customized test runner for samples.
17 | #
18 | # For periodic builds, you can specify this file for testing against head.
19 | 
20 | # `-e` enables the script to automatically fail when a command fails
21 | # `-o pipefail` sets the exit code to the rightmost comment to exit with a non-zero
22 | set -eo pipefail
23 | # Enables `**` to include files nested inside sub-folders
24 | shopt -s globstar
25 | 
26 | exec .kokoro/test-samples-impl.sh
27 | 


--------------------------------------------------------------------------------
/.kokoro/test-samples-impl.sh:
--------------------------------------------------------------------------------
  1 | #!/bin/bash
  2 | # Copyright 2024 Google LLC
  3 | #
  4 | # Licensed under the Apache License, Version 2.0 (the "License");
  5 | # you may not use this file except in compliance with the License.
  6 | # You may obtain a copy of the License at
  7 | #
  8 | #     https://www.apache.org/licenses/LICENSE-2.0
  9 | #
 10 | # Unless required by applicable law or agreed to in writing, software
 11 | # distributed under the License is distributed on an "AS IS" BASIS,
 12 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 | # See the License for the specific language governing permissions and
 14 | # limitations under the License.
 15 | 
 16 | 
 17 | # `-e` enables the script to automatically fail when a command fails
 18 | # `-o pipefail` sets the exit code to the rightmost comment to exit with a non-zero
 19 | set -eo pipefail
 20 | # Enables `**` to include files nested inside sub-folders
 21 | shopt -s globstar
 22 | 
 23 | # Exit early if samples don't exist
 24 | if ! find samples -name 'requirements.txt' | grep -q .; then
 25 |   echo "No tests run. './samples/**/requirements.txt' not found"
 26 |   exit 0
 27 | fi
 28 | 
 29 | # Disable buffering, so that the logs stream through.
 30 | export PYTHONUNBUFFERED=1
 31 | 
 32 | # Debug: show build environment
 33 | env | grep KOKORO
 34 | 
 35 | # Install nox
 36 | # `virtualenv==20.26.6` is added for Python 3.7 compatibility
 37 | python3.9 -m pip install --upgrade --quiet nox virtualenv==20.26.6
 38 | 
 39 | # Use secrets acessor service account to get secrets
 40 | if [[ -f "${KOKORO_GFILE_DIR}/secrets_viewer_service_account.json" ]]; then
 41 |     gcloud auth activate-service-account \
 42 | 	   --key-file="${KOKORO_GFILE_DIR}/secrets_viewer_service_account.json" \
 43 | 	   --project="cloud-devrel-kokoro-resources"
 44 | fi
 45 | 
 46 | # This script will create 3 files:
 47 | # - testing/test-env.sh
 48 | # - testing/service-account.json
 49 | # - testing/client-secrets.json
 50 | ./scripts/decrypt-secrets.sh
 51 | 
 52 | source ./testing/test-env.sh
 53 | export GOOGLE_APPLICATION_CREDENTIALS=$(pwd)/testing/service-account.json
 54 | 
 55 | # For cloud-run session, we activate the service account for gcloud sdk.
 56 | gcloud auth activate-service-account \
 57 |        --key-file "${GOOGLE_APPLICATION_CREDENTIALS}"
 58 | 
 59 | export GOOGLE_CLIENT_SECRETS=$(pwd)/testing/client-secrets.json
 60 | 
 61 | echo -e "\n******************** TESTING PROJECTS ********************"
 62 | 
 63 | # Switch to 'fail at end' to allow all tests to complete before exiting.
 64 | set +e
 65 | # Use RTN to return a non-zero value if the test fails.
 66 | RTN=0
 67 | ROOT=$(pwd)
 68 | # Find all requirements.txt in the samples directory (may break on whitespace).
 69 | for file in samples/**/requirements.txt; do
 70 |     cd "$ROOT"
 71 |     # Navigate to the project folder.
 72 |     file=$(dirname "$file")
 73 |     cd "$file"
 74 | 
 75 |     echo "------------------------------------------------------------"
 76 |     echo "- testing $file"
 77 |     echo "------------------------------------------------------------"
 78 | 
 79 |     # Use nox to execute the tests for the project.
 80 |     python3.9 -m nox -s "$RUN_TESTS_SESSION"
 81 |     EXIT=$?
 82 | 
 83 |     # If this is a periodic build, send the test log to the FlakyBot.
 84 |     # See https://github.com/googleapis/repo-automation-bots/tree/main/packages/flakybot.
 85 |     if [[ $KOKORO_BUILD_ARTIFACTS_SUBDIR = *"periodic"* ]]; then
 86 |       chmod +x $KOKORO_GFILE_DIR/linux_amd64/flakybot
 87 |       $KOKORO_GFILE_DIR/linux_amd64/flakybot
 88 |     fi
 89 | 
 90 |     if [[ $EXIT -ne 0 ]]; then
 91 |       RTN=1
 92 |       echo -e "\n Testing failed: Nox returned a non-zero exit code. \n"
 93 |     else
 94 |       echo -e "\n Testing completed.\n"
 95 |     fi
 96 | 
 97 | done
 98 | cd "$ROOT"
 99 | 
100 | # Workaround for Kokoro permissions issue: delete secrets
101 | rm testing/{test-env.sh,client-secrets.json,service-account.json}
102 | 
103 | exit "$RTN"
104 | 


--------------------------------------------------------------------------------
/.kokoro/test-samples.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | # Copyright 2024 Google LLC
 3 | #
 4 | # Licensed under the Apache License, Version 2.0 (the "License");
 5 | # you may not use this file except in compliance with the License.
 6 | # You may obtain a copy of the License at
 7 | #
 8 | #     https://www.apache.org/licenses/LICENSE-2.0
 9 | #
10 | # Unless required by applicable law or agreed to in writing, software
11 | # distributed under the License is distributed on an "AS IS" BASIS,
12 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | # See the License for the specific language governing permissions and
14 | # limitations under the License.
15 | 
16 | # The default test runner for samples.
17 | #
18 | # For periodic builds, we rewinds the repo to the latest release, and
19 | # run test-samples-impl.sh.
20 | 
21 | # `-e` enables the script to automatically fail when a command fails
22 | # `-o pipefail` sets the exit code to the rightmost comment to exit with a non-zero
23 | set -eo pipefail
24 | # Enables `**` to include files nested inside sub-folders
25 | shopt -s globstar
26 | 
27 | # Run periodic samples tests at latest release
28 | if [[ $KOKORO_BUILD_ARTIFACTS_SUBDIR = *"periodic"* ]]; then
29 |     # preserving the test runner implementation.
30 |     cp .kokoro/test-samples-impl.sh "${TMPDIR}/test-samples-impl.sh"
31 |     echo "--- IMPORTANT IMPORTANT IMPORTANT ---"
32 |     echo "Now we rewind the repo back to the latest release..."
33 |     LATEST_RELEASE=$(git describe --abbrev=0 --tags)
34 |     git checkout $LATEST_RELEASE
35 |     echo "The current head is: "
36 |     echo $(git rev-parse --verify HEAD)
37 |     echo "--- IMPORTANT IMPORTANT IMPORTANT ---"
38 |     # move back the test runner implementation if there's no file.
39 |     if [ ! -f .kokoro/test-samples-impl.sh ]; then
40 | 	cp "${TMPDIR}/test-samples-impl.sh" .kokoro/test-samples-impl.sh
41 |     fi
42 | fi
43 | 
44 | exec .kokoro/test-samples-impl.sh
45 | 


--------------------------------------------------------------------------------
/.kokoro/trampoline.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | # Copyright 2024 Google LLC
 3 | #
 4 | # Licensed under the Apache License, Version 2.0 (the "License");
 5 | # you may not use this file except in compliance with the License.
 6 | # You may obtain a copy of the License at
 7 | #
 8 | #      http://www.apache.org/licenses/LICENSE-2.0
 9 | #
10 | # Unless required by applicable law or agreed to in writing, software
11 | # distributed under the License is distributed on an "AS IS" BASIS,
12 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | # See the License for the specific language governing permissions and
14 | # limitations under the License.
15 | 
16 | set -eo pipefail
17 | 
18 | # Always run the cleanup script, regardless of the success of bouncing into
19 | # the container.
20 | function cleanup() {
21 |     chmod +x ${KOKORO_GFILE_DIR}/trampoline_cleanup.sh
22 |     ${KOKORO_GFILE_DIR}/trampoline_cleanup.sh
23 |     echo "cleanup";
24 | }
25 | trap cleanup EXIT
26 | 
27 | $(dirname $0)/populate-secrets.sh # Secret Manager secrets.
28 | python3 "${KOKORO_GFILE_DIR}/trampoline_v1.py"


--------------------------------------------------------------------------------
/.pre-commit-config.yaml:
--------------------------------------------------------------------------------
 1 | # Copyright 2024 Google LLC
 2 | #
 3 | # Licensed under the Apache License, Version 2.0 (the "License");
 4 | # you may not use this file except in compliance with the License.
 5 | # You may obtain a copy of the License at
 6 | #
 7 | # http://www.apache.org/licenses/LICENSE-2.0
 8 | #
 9 | # Unless required by applicable law or agreed to in writing, software
10 | # distributed under the License is distributed on an "AS IS" BASIS,
11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | # See the License for the specific language governing permissions and
13 | # limitations under the License.
14 | #
15 | # See https://pre-commit.com for more information
16 | # See https://pre-commit.com/hooks.html for more hooks
17 | repos:
18 | -   repo: https://github.com/pre-commit/pre-commit-hooks
19 |     rev: v4.0.1
20 |     hooks:
21 |     -   id: trailing-whitespace
22 |     -   id: end-of-file-fixer
23 |     -   id: check-yaml
24 | -   repo: https://github.com/psf/black
25 |     rev: 23.7.0
26 |     hooks:
27 |     - id: black
28 | -   repo: https://github.com/pycqa/flake8
29 |     rev: 6.1.0
30 |     hooks:
31 |     - id: flake8
32 | 


--------------------------------------------------------------------------------
/.repo-metadata.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "sqlalchemy-bigquery",
 3 |     "name_pretty": "SQLAlchemy dialect for BigQuery",
 4 |     "client_documentation": "https://googleapis.dev/python/sqlalchemy-bigquery/latest/index.html",
 5 |     "release_level": "preview",
 6 |     "language": "python",
 7 |     "library_type": "INTEGRATION",
 8 |     "repo": "googleapis/python-bigquery-sqlalchemy",
 9 |     "distribution_name": "sqlalchemy-bigquery",
10 |     "api_id": "bigquery.googleapis.com",
11 |     "default_version": "",
12 |     "codeowner_team": "@googleapis/api-bigquery"
13 | }
14 | 


--------------------------------------------------------------------------------
/.trampolinerc:
--------------------------------------------------------------------------------
 1 | # Copyright 2024 Google LLC
 2 | #
 3 | # Licensed under the Apache License, Version 2.0 (the "License");
 4 | # you may not use this file except in compliance with the License.
 5 | # You may obtain a copy of the License at
 6 | #
 7 | #      http://www.apache.org/licenses/LICENSE-2.0
 8 | #
 9 | # Unless required by applicable law or agreed to in writing, software
10 | # distributed under the License is distributed on an "AS IS" BASIS,
11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | # See the License for the specific language governing permissions and
13 | # limitations under the License.
14 | 
15 | # Add required env vars here.
16 | required_envvars+=(
17 | )
18 | 
19 | # Add env vars which are passed down into the container here.
20 | pass_down_envvars+=(
21 |     "NOX_SESSION"
22 |     ###############
23 |     # Docs builds
24 |     ###############
25 |     "STAGING_BUCKET"
26 |     "V2_STAGING_BUCKET"
27 |     ##################
28 |     # Samples builds
29 |     ##################
30 |     "INSTALL_LIBRARY_FROM_SOURCE"
31 |     "RUN_TESTS_SESSION"
32 |     "BUILD_SPECIFIC_GCLOUD_PROJECT"
33 |     # Target directories.
34 |     "RUN_TESTS_DIRS"
35 |     # The nox session to run.
36 |     "RUN_TESTS_SESSION"
37 | )
38 | 
39 | # Prevent unintentional override on the default image.
40 | if [[ "${TRAMPOLINE_IMAGE_UPLOAD:-false}" == "true" ]] && \
41 |    [[ -z "${TRAMPOLINE_IMAGE:-}" ]]; then
42 |    echo "Please set TRAMPOLINE_IMAGE if you want to upload the Docker image."
43 |    exit 1
44 | fi
45 | 
46 | # Define the default value if it makes sense.
47 | if [[ -z "${TRAMPOLINE_IMAGE_UPLOAD:-}" ]]; then
48 |     TRAMPOLINE_IMAGE_UPLOAD=""
49 | fi
50 | 
51 | if [[ -z "${TRAMPOLINE_IMAGE:-}" ]]; then
52 |     TRAMPOLINE_IMAGE=""
53 | fi
54 | 
55 | if [[ -z "${TRAMPOLINE_DOCKERFILE:-}" ]]; then
56 |     TRAMPOLINE_DOCKERFILE=""
57 | fi
58 | 
59 | if [[ -z "${TRAMPOLINE_BUILD_FILE:-}" ]]; then
60 |     TRAMPOLINE_BUILD_FILE=""
61 | fi
62 | 


--------------------------------------------------------------------------------
/AUTHORS:
--------------------------------------------------------------------------------
 1 | # This is the list of sqlalchemy-bigquery's significant contributors.
 2 | #
 3 | # This does not necessarily list everyone who has contributed code,
 4 | # especially since many employees of one corporation may be contributing.
 5 | # To see the full list of contributors, see the revision history in
 6 | # source control.
 7 | alm (alonme)
 8 | Arttu Modig (amodig)
 9 | Blaine Hansen (blainehansen)
10 | Dmytro Karacheban
11 | Google LLC
12 | Harshal Sheth
13 | Jacob Hayes
14 | James Campbell
15 | Jim Fulton
16 | Joshua Carp
17 | Kurian (kuriancheeramelil)
18 | Maksym Voitko
19 | Maxim Zudilov (mxmzdlv)
20 | Maxime Beauchemin (mistercrunch)
21 | Romain Rigaux
22 | Sharoon Thomas (sharoonthomas)
23 | Sumedh Sakdeo
24 | Tim Swast (tswast)
25 | Vince Broz
26 | Wade Tsai
27 | 


--------------------------------------------------------------------------------
/CODE_OF_CONDUCT.md:
--------------------------------------------------------------------------------
 1 | <!-- # Generated by synthtool. DO NOT EDIT! !-->
 2 | # Code of Conduct
 3 | 
 4 | ## Our Pledge
 5 | 
 6 | In the interest of fostering an open and welcoming environment, we as
 7 | contributors and maintainers pledge to making participation in our project and
 8 | our community a harassment-free experience for everyone, regardless of age, body
 9 | size, disability, ethnicity, gender identity and expression, level of
10 | experience, education, socio-economic status, nationality, personal appearance,
11 | race, religion, or sexual identity and orientation.
12 | 
13 | ## Our Standards
14 | 
15 | Examples of behavior that contributes to creating a positive environment
16 | include:
17 | 
18 | *   Using welcoming and inclusive language
19 | *   Being respectful of differing viewpoints and experiences
20 | *   Gracefully accepting constructive criticism
21 | *   Focusing on what is best for the community
22 | *   Showing empathy towards other community members
23 | 
24 | Examples of unacceptable behavior by participants include:
25 | 
26 | *   The use of sexualized language or imagery and unwelcome sexual attention or
27 |     advances
28 | *   Trolling, insulting/derogatory comments, and personal or political attacks
29 | *   Public or private harassment
30 | *   Publishing others' private information, such as a physical or electronic
31 |     address, without explicit permission
32 | *   Other conduct which could reasonably be considered inappropriate in a
33 |     professional setting
34 | 
35 | ## Our Responsibilities
36 | 
37 | Project maintainers are responsible for clarifying the standards of acceptable
38 | behavior and are expected to take appropriate and fair corrective action in
39 | response to any instances of unacceptable behavior.
40 | 
41 | Project maintainers have the right and responsibility to remove, edit, or reject
42 | comments, commits, code, wiki edits, issues, and other contributions that are
43 | not aligned to this Code of Conduct, or to ban temporarily or permanently any
44 | contributor for other behaviors that they deem inappropriate, threatening,
45 | offensive, or harmful.
46 | 
47 | ## Scope
48 | 
49 | This Code of Conduct applies both within project spaces and in public spaces
50 | when an individual is representing the project or its community. Examples of
51 | representing a project or community include using an official project e-mail
52 | address, posting via an official social media account, or acting as an appointed
53 | representative at an online or offline event. Representation of a project may be
54 | further defined and clarified by project maintainers.
55 | 
56 | This Code of Conduct also applies outside the project spaces when the Project
57 | Steward has a reasonable belief that an individual's behavior may have a
58 | negative impact on the project or its community.
59 | 
60 | ## Conflict Resolution
61 | 
62 | We do not believe that all conflict is bad; healthy debate and disagreement
63 | often yield positive results. However, it is never okay to be disrespectful or
64 | to engage in behavior that violates the project’s code of conduct.
65 | 
66 | If you see someone violating the code of conduct, you are encouraged to address
67 | the behavior directly with those involved. Many issues can be resolved quickly
68 | and easily, and this gives people more control over the outcome of their
69 | dispute. If you are unable to resolve the matter for any reason, or if the
70 | behavior is threatening or harassing, report it. We are dedicated to providing
71 | an environment where participants feel welcome and safe.
72 | 
73 | 
74 | Reports should be directed to *googleapis-stewards@google.com*, the
75 | Project Steward(s) for *Google Cloud Client Libraries*. It is the Project Steward’s duty to
76 | receive and address reported violations of the code of conduct. They will then
77 | work with a committee consisting of representatives from the Open Source
78 | Programs Office and the Google Open Source Strategy team. If for any reason you
79 | are uncomfortable reaching out to the Project Steward, please email
80 | opensource@google.com.
81 | 
82 | We will investigate every complaint, but you may not receive a direct response.
83 | We will use our discretion in determining when and how to follow up on reported
84 | incidents, which may range from not taking action to permanent expulsion from
85 | the project and project-sponsored spaces. We will notify the accused of the
86 | report and provide them an opportunity to discuss it before any action is taken.
87 | The identity of the reporter will be omitted from the details of the report
88 | supplied to the accused. In potentially harmful situations, such as ongoing
89 | harassment or threats to anyone's safety, we may take action without notice.
90 | 
91 | ## Attribution
92 | 
93 | This Code of Conduct is adapted from the Contributor Covenant, version 1.4,
94 | available at
95 | https://www.contributor-covenant.org/version/1/4/code-of-conduct.html


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


--------------------------------------------------------------------------------
/MANIFEST.in:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | #
 3 | # Copyright 2024 Google LLC
 4 | #
 5 | # Licensed under the Apache License, Version 2.0 (the "License");
 6 | # you may not use this file except in compliance with the License.
 7 | # You may obtain a copy of the License at
 8 | #
 9 | #     https://www.apache.org/licenses/LICENSE-2.0
10 | #
11 | # Unless required by applicable law or agreed to in writing, software
12 | # distributed under the License is distributed on an "AS IS" BASIS,
13 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | # See the License for the specific language governing permissions and
15 | # limitations under the License.
16 | 
17 | # Generated by synthtool. DO NOT EDIT!
18 | include README.rst LICENSE
19 | recursive-include third_party/sqlalchemy_bigquery_vendored *
20 | recursive-include sqlalchemy_bigquery *.json *.proto py.typed
21 | recursive-include tests *
22 | global-exclude *.py[co]
23 | global-exclude __pycache__
24 | 
25 | # Exclude scripts for samples readmegen
26 | prune scripts/readme-gen
27 | 


--------------------------------------------------------------------------------
/SECURITY.md:
--------------------------------------------------------------------------------
1 | # Security Policy
2 | 
3 | To report a security issue, please use [g.co/vulnz](https://g.co/vulnz).
4 | 
5 | The Google Security Team will respond within 5 working days of your report on g.co/vulnz.
6 | 
7 | We use g.co/vulnz for our intake, and do coordination and disclosure here using GitHub Security Advisory to privately discuss and fix the issue.
8 | 


--------------------------------------------------------------------------------
/dev_requirements.txt:
--------------------------------------------------------------------------------
1 | sqlalchemy>=2.0.15,<2.1.0
2 | google-cloud-bigquery>=1.6.0
3 | pytest===6.2.5
4 | pytest-flake8===1.1.0  # versions 1.1.1 and above require pytest 7
5 | pytz==2025.2
6 | 


--------------------------------------------------------------------------------
/docs/README.rst:
--------------------------------------------------------------------------------
1 | ../README.rst


--------------------------------------------------------------------------------
/docs/_static/custom.css:
--------------------------------------------------------------------------------
 1 | div#python2-eol {
 2 | 	border-color: red;
 3 | 	border-width: medium;
 4 | }
 5 | 
 6 | /* Ensure minimum width for 'Parameters' / 'Returns' column */
 7 | dl.field-list > dt {
 8 |     min-width: 100px
 9 | }
10 | 
11 | /* Insert space between methods for readability */
12 | dl.method {
13 | 	padding-top: 10px;
14 | 	padding-bottom: 10px
15 | }
16 | 
17 | /* Insert empty space between classes */
18 | dl.class {
19 | 	padding-bottom: 50px
20 | }
21 | 


--------------------------------------------------------------------------------
/docs/_templates/layout.html:
--------------------------------------------------------------------------------
 1 | 
 2 | {% extends "!layout.html" %}
 3 | {%- block content %}
 4 | {%- if theme_fixed_sidebar|lower == 'true' %}
 5 |   <div class="document">
 6 |     {{ sidebar() }}
 7 |     {%- block document %}
 8 |       <div class="documentwrapper">
 9 |       {%- if render_sidebar %}
10 |         <div class="bodywrapper">
11 |       {%- endif %}
12 | 
13 |           {%- block relbar_top %}
14 |             {%- if theme_show_relbar_top|tobool %}
15 |               <div class="related top">
16 |                 &nbsp;
17 |                 {{- rellink_markup () }}
18 |               </div>
19 |             {%- endif %}
20 |           {% endblock %}
21 | 
22 |           <div class="body" role="main">
23 |           	<div class="admonition" id="python2-eol"> 
24 |           	 As of January 1, 2020 this library no longer supports Python 2 on the latest released version. 
25 |           	 Library versions released prior to that date will continue to be available. For more information please
26 |           	 visit <a href="https://cloud.google.com/python/docs/python2-sunset/">Python 2 support on Google Cloud</a>.
27 |           	</div>
28 |             {% block body %} {% endblock %}
29 |           </div>
30 | 
31 |           {%- block relbar_bottom %}
32 |             {%- if theme_show_relbar_bottom|tobool %}
33 |               <div class="related bottom">
34 |                 &nbsp;
35 |                 {{- rellink_markup () }}
36 |               </div>
37 |             {%- endif %}
38 |           {% endblock %}
39 | 
40 |       {%- if render_sidebar %}
41 |         </div>
42 |       {%- endif %}
43 |       </div>
44 |     {%- endblock %}
45 |     <div class="clearer"></div>
46 |   </div>
47 | {%- else %}
48 | {{ super() }}
49 | {%- endif %}
50 | {%- endblock %}
51 | 


--------------------------------------------------------------------------------
/docs/alembic.rst:
--------------------------------------------------------------------------------
 1 | Alembic support
 2 | ^^^^^^^^^^^^^^^
 3 | 
 4 | `Alembic <https://alembic.sqlalchemy.org>`_ is a lightweight database
 5 | migration tool for usage with the SQLAlchemy Database Toolkit for
 6 | Python.  It can use this BigQuery SQLAlchemy support to manage
 7 | BigQuery shemas.
 8 | 
 9 | Some features, like management of constrains and indexes, aren't
10 | supported because `BigQuery doesn't support them
11 | <https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language>`_.
12 | 
13 | Supported operations:
14 | 
15 | `add_column(table_name, column, schema=None)
16 | <https://alembic.sqlalchemy.org/en/latest/ops.html#alembic.operations.Operations.add_column>`_
17 | 
18 | `alter_column(table_name, column_name, nullable=None, schema=None, type_=None)
19 | <https://alembic.sqlalchemy.org/en/latest/ops.html#alembic.operations.Operations.alter_column>`_
20 | 
21 | `bulk_insert(table, rows, multiinsert=True)
22 | <https://alembic.sqlalchemy.org/en/latest/ops.html#alembic.operations.Operations.bulk_insert>`_
23 | 
24 | `create_table(table_name, *columns, **kw)
25 | <https://alembic.sqlalchemy.org/en/latest/ops.html#alembic.operations.Operations.create_table>`_
26 | 
27 | `create_table_comment(table_name, comment, schema=None)
28 | <https://alembic.sqlalchemy.org/en/latest/ops.html#alembic.operations.Operations.create_table_comment>`_
29 | 
30 | `drop_column(table_name, column_name, schema=None)
31 | <https://alembic.sqlalchemy.org/en/latest/ops.html#alembic.operations.Operations.drop_column>`_
32 | 
33 | `drop_table(table_name, schema=None)
34 | <https://alembic.sqlalchemy.org/en/latest/ops.html#alembic.operations.Operations.drop_table>`_
35 | 
36 | `drop_table_comment(table_name, schema=None)
37 | <https://alembic.sqlalchemy.org/en/latest/ops.html#alembic.operations.Operations.drop_table_comment>`_
38 | 
39 | `execute(sqltext, execution_options=None)
40 | <https://alembic.sqlalchemy.org/en/latest/ops.html#alembic.operations.Operations.execute>`_
41 | 
42 | `rename_table(old_table_name, new_table_name, schema=None)
43 | <https://alembic.sqlalchemy.org/en/latest/ops.html#alembic.operations.Operations.rename_table>`_
44 | 
45 | Note that some of the operations above have limited capability, again
46 | due to `BigQuery limitations
47 | <https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language>`_.
48 | 
49 | The `execute` operation allows access to BigQuery-specific
50 | `data-definition-language
51 | <https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language>`_.
52 | 


--------------------------------------------------------------------------------
/docs/changelog.md:
--------------------------------------------------------------------------------
1 | ../CHANGELOG.md


--------------------------------------------------------------------------------
/docs/geography.rst:
--------------------------------------------------------------------------------
 1 | Working with Geographic data
 2 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 3 | 
 4 | BigQuery provides a `GEOGRAPHY data type
 5 | <https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#geography_type>`_
 6 | for `working with geographic data
 7 | <https://cloud.google.com/bigquery/docs/gis-data>`_, including:
 8 | 
 9 | - Points,
10 | - Linestrings,
11 | - Polygons, and
12 | - Collections of points, linestrings, and polygons.
13 | 
14 | Geographic data uses the `WGS84
15 | <https://earth-info.nga.mil/#tab_wgs84-data>`_ coordinate system.
16 | 
17 | To define a geography column, use the `GEOGRAPHY` data type imported
18 | from the `sqlalchemy_bigquery` module:
19 | 
20 | .. literalinclude:: samples/snippets/geography.py
21 |    :language: python
22 |    :dedent: 4
23 |    :start-after: [START bigquery_sqlalchemy_create_table_with_geography]
24 |    :end-before: [END bigquery_sqlalchemy_create_table_with_geography]
25 | 
26 | BigQuery has a variety of `SQL geographic functions
27 | <https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions>`_
28 | for working with geographic data.  Among these are functions for
29 | converting between SQL geometry objects and `standard text (WKT) and
30 | binary (WKB) representations
31 | <https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry>`_.
32 | 
33 | Geography data is typically represented in Python as text strings in
34 | WKT format or as `WKB` objects, which contain binary data in WKB
35 | format.  Querying geographic data returns `WKB` objects and `WKB`
36 | objects may be used in queries.  When
37 | calling spatial functions that expect geographic arguments, text
38 | arguments are automatically coerced to geography.
39 | 
40 | Inserting data
41 | ~~~~~~~~~~~~~~
42 | 
43 | When inserting geography data, you can pass WKT strings, `WKT` objects,
44 | or `WKB` objects:
45 | 
46 | .. literalinclude:: samples/snippets/geography.py
47 |    :language: python
48 |    :dedent: 4
49 |    :start-after: [START bigquery_sqlalchemy_insert_geography]
50 |    :end-before: [END bigquery_sqlalchemy_insert_geography]
51 | 
52 | Note that in the `lake3` example, we got a `WKB` object by creating a
53 | `WKT` object and getting its `wkb` property.  Normally, we'd get `WKB`
54 | objects as results of previous queries.
55 | 
56 | Queries
57 | ~~~~~~~
58 | 
59 | When performing spacial queries, and geography objects are expected,
60 | you can to pass `WKB` or `WKT` objects:
61 | 
62 | .. literalinclude:: samples/snippets/geography.py
63 |    :language: python
64 |    :dedent: 4
65 |    :start-after: [START bigquery_sqlalchemy_query_geography_wkb]
66 |    :end-before: [END bigquery_sqlalchemy_query_geography_wkb]
67 | 
68 | In this example, we passed the `geog` attribute of `lake2`, which is a WKB object.
69 | 
70 | Or you can pass strings in WKT format:
71 | 
72 | .. literalinclude:: samples/snippets/geography.py
73 |    :language: python
74 |    :dedent: 4
75 |    :start-after: [START bigquery_sqlalchemy_query_geography_text]
76 |    :end-before: [END bigquery_sqlalchemy_query_geography_text]
77 | 
78 | Installing geography support
79 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
80 | 
81 | To get geography support, you need to install `sqlalchemy-bigquery`
82 | with the `geography` extra, or separately install `GeoAlchemy2` and
83 | `shapely`.
84 | 
85 | .. code-block:: console
86 | 
87 |     pip install 'sqlalchemy-bigquery[geography]'
88 | 


--------------------------------------------------------------------------------
/docs/index.rst:
--------------------------------------------------------------------------------
 1 | 
 2 | .. toctree::
 3 |    :maxdepth: 2
 4 | 
 5 |    README
 6 |    struct
 7 |    geography
 8 |    alembic
 9 |    reference
10 | 
11 | Changelog
12 | ---------
13 | 
14 | For a list of all ``sqlalchemy-bigquery`` releases:
15 | 
16 | .. toctree::
17 |    :maxdepth: 2
18 | 
19 |    changelog
20 | 


--------------------------------------------------------------------------------
/docs/reference.rst:
--------------------------------------------------------------------------------
 1 | API Reference
 2 | ^^^^^^^^^^^^^
 3 | 
 4 | Geography
 5 | ~~~~~~~~~
 6 | 
 7 | .. autoclass::  sqlalchemy_bigquery.geography.GEOGRAPHY
 8 |    :exclude-members: bind_expression, ElementType, bind_processor
 9 | 
10 | .. automodule:: sqlalchemy_bigquery.geography
11 |    :members: WKB, WKT
12 |    :exclude-members: GEOGRAPHY
13 | 


--------------------------------------------------------------------------------
/docs/samples:
--------------------------------------------------------------------------------
1 | ../samples


--------------------------------------------------------------------------------
/docs/struct.rst:
--------------------------------------------------------------------------------
 1 | Working with BigQuery STRUCT data
 2 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 3 | 
 4 | The BigQuery `STRUCT data type
 5 | <https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#struct_type>`_
 6 | provided data that are collections of named fields.
 7 | 
 8 | `sqlalchemy-bigquery` provided a STRUCT type that can be used to
 9 | define tables with STRUCT columns:
10 | 
11 | .. literalinclude:: samples/snippets/STRUCT.py
12 |    :language: python
13 |    :dedent: 4
14 |    :start-after: [START bigquery_sqlalchemy_create_table_with_struct]
15 |    :end-before: [END bigquery_sqlalchemy_create_table_with_struct]
16 | 
17 | `STRUCT` types can be nested, as in this example.  Struct fields can
18 | be defined in two ways:
19 | 
20 | - Fields can be provided as keyword arguments, as in the `cylinder`
21 |   and `horsepower` fields in this example.
22 | 
23 | - Fields can be provided as name-type tuples provided as positional
24 |   arguments, as with the `count` and `compression` fields in this example.
25 | 
26 | STRUCT columns are automatically created when existing database tables
27 | containing STRUCT columns are introspected.
28 | 
29 | Struct data are represented in Python as Python dictionaries:
30 | 
31 | .. literalinclude:: samples/snippets/STRUCT.py
32 |    :language: python
33 |    :dedent: 4
34 |    :start-after: [START bigquery_sqlalchemy_insert_struct]
35 |    :end-before: [END bigquery_sqlalchemy_insert_struct]
36 | 
37 | When querying struct fields, you can use attribute access syntax:
38 | 
39 | .. literalinclude:: samples/snippets/STRUCT.py
40 |    :language: python
41 |    :dedent: 4
42 |    :start-after: [START bigquery_sqlalchemy_query_struct]
43 |    :end-before: [END bigquery_sqlalchemy_query_struct]
44 | 
45 | or mapping access:
46 | 
47 | .. literalinclude:: samples/snippets/STRUCT.py
48 |    :language: python
49 |    :dedent: 4
50 |    :start-after: [START bigquery_sqlalchemy_query_getitem]
51 |    :end-before: [END bigquery_sqlalchemy_query_getitem]
52 | 
53 | and field names are case insensitive:
54 | 
55 | .. literalinclude:: samples/snippets/STRUCT.py
56 |    :language: python
57 |    :dedent: 4
58 |    :start-after: [START bigquery_sqlalchemy_query_STRUCT]
59 |    :end-before: [END bigquery_sqlalchemy_query_STRUCT]
60 | 
61 | When using attribute-access syntax, field names may conflict with
62 | column attribute names.  For example SQLAlchemy columns have `name`
63 | and `type` attributes, among others.  When accessing a field whose name
64 | conflicts with a column attribute name, either use mapping access, or
65 | spell the field name with upper-case letters.
66 | 
67 | 
68 | 
69 | 
70 | 


--------------------------------------------------------------------------------
/owlbot.py:
--------------------------------------------------------------------------------
  1 | # Copyright 2021 Google LLC
  2 | #
  3 | # Licensed under the Apache License, Version 2.0 (the "License");
  4 | # you may not use this file except in compliance with the License.
  5 | # You may obtain a copy of the License at
  6 | #
  7 | #     http://www.apache.org/licenses/LICENSE-2.0
  8 | #
  9 | # Unless required by applicable law or agreed to in writing, software
 10 | # distributed under the License is distributed on an "AS IS" BASIS,
 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 12 | # See the License for the specific language governing permissions and
 13 | # limitations under the License.
 14 | 
 15 | """This script is used to synthesize generated parts of this library."""
 16 | 
 17 | import pathlib
 18 | import re
 19 | 
 20 | import synthtool as s
 21 | from synthtool import gcp
 22 | from synthtool.languages import python
 23 | 
 24 | REPO_ROOT = pathlib.Path(__file__).parent.absolute()
 25 | 
 26 | common = gcp.CommonTemplates()
 27 | 
 28 | # ----------------------------------------------------------------------------
 29 | # Add templated files
 30 | # ----------------------------------------------------------------------------
 31 | extras = ["tests"]
 32 | extras_by_python = {
 33 |     "3.8": ["tests", "alembic", "bqstorage"],
 34 |     "3.11": ["tests", "geography", "bqstorage"],
 35 |     "3.12": ["tests", "geography", "bqstorage"],
 36 | }
 37 | templated_files = common.py_library(
 38 |     unit_test_python_versions=["3.8", "3.9", "3.10", "3.11", "3.12"],
 39 |     system_test_python_versions=["3.8", "3.11", "3.12"],
 40 |     cov_level=100,
 41 |     unit_test_extras=extras,
 42 |     unit_test_extras_by_python=extras_by_python,
 43 |     system_test_extras=extras,
 44 |     system_test_extras_by_python=extras_by_python,
 45 | )
 46 | s.move(
 47 |     templated_files,
 48 |     excludes=[
 49 |         # sqlalchemy-bigquery was originally licensed MIT
 50 |         "LICENSE",
 51 |         "docs/multiprocessing.rst",
 52 |         # exclude gh actions as credentials are needed for tests
 53 |         ".github/workflows",
 54 |         "README.rst",
 55 |     ],
 56 | )
 57 | 
 58 | # ----------------------------------------------------------------------------
 59 | # Fixup files
 60 | # ----------------------------------------------------------------------------
 61 | 
 62 | s.replace(
 63 |     [".coveragerc"],
 64 |     "google/cloud/__init__.py",
 65 |     "sqlalchemy_bigquery/requirements.py",
 66 | )
 67 | 
 68 | 
 69 | # Add DB config for SQLAlchemy dialect test suite.
 70 | # https://github.com/googleapis/python-bigquery-sqlalchemy/issues/89
 71 | s.replace(
 72 |     ["setup.cfg"],
 73 |     "universal = 1\n",
 74 |     """universal = 1
 75 | """,
 76 | )
 77 | 
 78 | # ----------------------------------------------------------------------------
 79 | # Samples templates
 80 | # ----------------------------------------------------------------------------
 81 | 
 82 | 
 83 | python.py_samples(skip_readmes=True)
 84 | 
 85 | s.replace(
 86 |     ["./samples/snippets/noxfile.py"],
 87 |     """session.install\("-e", _get_repo_root\(\)\)""",
 88 |     """session.install("-e", _get_repo_root())
 89 |     else:
 90 |         # ensure that sqlalchemy_bigquery gets installed
 91 |         # for tests that are not based on source
 92 |         session.install("sqlalchemy_bigquery")""",
 93 | )
 94 | 
 95 | 
 96 | # ----------------------------------------------------------------------------
 97 | # Final cleanup
 98 | # ----------------------------------------------------------------------------
 99 | 
100 | s.shell.run(["nox", "-s", "blacken"], hide_output=False)
101 | for noxfile in REPO_ROOT.glob("samples/**/noxfile.py"):
102 |     s.shell.run(["nox", "-s", "blacken"], cwd=noxfile.parent, hide_output=False)
103 | 


--------------------------------------------------------------------------------
/pyproject.toml:
--------------------------------------------------------------------------------
1 | # Added so third_party folder is included when running `pip install -e .`
2 | # See PR #1083 for more detail
3 | [build-system]
4 | requires = ["setuptools"]
5 | build-backend = "setuptools.build_meta"
6 | 


--------------------------------------------------------------------------------
/release-procedure.md:
--------------------------------------------------------------------------------
 1 | # sqlalchemy-bigquery release procedure
 2 | 
 3 | *   Checkout main branch
 4 | 
 5 |         git fetch upstream main
 6 |         git checkout main
 7 |         git rebase -i upstream/main
 8 | 
 9 | *   Update version number in `setup.py`
10 | 
11 | *   Update `CHANGELOG.md`
12 | 
13 | *   Commit and push
14 | 
15 |         git commit -m "Release x.x.x"
16 |         git push upstream main
17 | 
18 | *   Build the package
19 | 
20 |         git clean -xfd
21 |         python setup.py register sdist bdist_wheel --universal
22 | 
23 | *   Upload to test PyPI
24 | 
25 |         twine upload --repository testpypi dist/*
26 | 
27 | *   Try out test PyPI package
28 | 
29 |         pip install --upgrade --index-url https://test.pypi.org/simple/ --extra-index-url https://pypi.org/simple sqlalchemy-bigquery
30 | 
31 | *   Upload to PyPI
32 | 
33 |         twine upload dist/*
34 | 
35 | *   Tag release on GitHub
36 | 
37 | 


--------------------------------------------------------------------------------
/renovate.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "extends": [
 3 |     "config:base",
 4 |     "group:all",
 5 |     ":preserveSemverRanges",
 6 |     ":disableDependencyDashboard"
 7 |   ],
 8 |   "ignorePaths": [".pre-commit-config.yaml", ".kokoro/requirements.txt", "setup.py", ".github/workflows/unittest.yml"],
 9 |   "pip_requirements": {
10 |     "fileMatch": ["requirements-test.txt", "samples/[\\S/]*constraints.txt", "samples/[\\S/]*constraints-test.txt"]
11 |   }
12 | }
13 | 


--------------------------------------------------------------------------------
/samples/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/googleapis/python-bigquery-sqlalchemy/d0347202c5fb144f960558d9022b7a22af6ce3f7/samples/__init__.py


--------------------------------------------------------------------------------
/samples/pytest.ini:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/googleapis/python-bigquery-sqlalchemy/d0347202c5fb144f960558d9022b7a22af6ce3f7/samples/pytest.ini


--------------------------------------------------------------------------------
/samples/snippets/STRUCT.py:
--------------------------------------------------------------------------------
 1 | # Copyright (c) 2021 The sqlalchemy-bigquery Authors
 2 | #
 3 | # Permission is hereby granted, free of charge, to any person obtaining a copy of
 4 | # this software and associated documentation files (the "Software"), to deal in
 5 | # the Software without restriction, including without limitation the rights to
 6 | # use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 7 | # the Software, and to permit persons to whom the Software is furnished to do so,
 8 | # subject to the following conditions:
 9 | #
10 | # The above copyright notice and this permission notice shall be included in all
11 | # copies or substantial portions of the Software.
12 | #
13 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
15 | # FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
16 | # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
17 | # IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
18 | # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
19 | 
20 | 
21 | def example(engine):
22 |     # fmt: off
23 |     # [START bigquery_sqlalchemy_create_table_with_struct]
24 |     from sqlalchemy.ext.declarative import declarative_base
25 |     from sqlalchemy import Column, String, Integer, Float
26 |     from sqlalchemy_bigquery import STRUCT
27 | 
28 |     Base = declarative_base()
29 | 
30 |     class Car(Base):
31 |         __tablename__ = "Cars"
32 | 
33 |         model = Column(String, primary_key=True)
34 |         engine = Column(
35 |             STRUCT(
36 |                 cylinder=STRUCT(("count", Integer),
37 |                                 ("compression", Float)),
38 |                 horsepower=Integer)
39 |             )
40 | 
41 |     # [END bigquery_sqlalchemy_create_table_with_struct]
42 |     Car.__table__.create(engine)
43 | 
44 |     # [START bigquery_sqlalchemy_insert_struct]
45 |     from sqlalchemy.orm import sessionmaker
46 | 
47 |     Session = sessionmaker(bind=engine)
48 |     session = Session()
49 | 
50 |     sebring = Car(model="Sebring",
51 |                   engine=dict(
52 |                       cylinder=dict(
53 |                           count=6,
54 |                           compression=18.0),
55 |                       horsepower=235))
56 |     townc = Car(model="Town and Counttry",
57 |                 engine=dict(
58 |                     cylinder=dict(
59 |                         count=6,
60 |                         compression=16.0),
61 |                     horsepower=251))
62 |     xj8 = Car(model="XJ8",
63 |               engine=dict(
64 |                   cylinder=dict(
65 |                       count=8,
66 |                       compression=10.75),
67 |                   horsepower=575))
68 | 
69 |     session.add_all((sebring, townc, xj8))
70 |     session.commit()
71 | 
72 |     # [END bigquery_sqlalchemy_insert_struct]
73 | 
74 |     # [START bigquery_sqlalchemy_query_struct]
75 |     sixes = session.query(Car).filter(Car.engine.cylinder.count == 6)
76 |     # [END bigquery_sqlalchemy_query_struct]
77 |     sixes1 = list(sixes)
78 | 
79 |     # [START bigquery_sqlalchemy_query_STRUCT]
80 |     sixes = session.query(Car).filter(Car.engine.CYLINDER.COUNT == 6)
81 |     # [END bigquery_sqlalchemy_query_STRUCT]
82 |     sixes2 = list(sixes)
83 | 
84 |     # [START bigquery_sqlalchemy_query_getitem]
85 |     sixes = session.query(Car).filter(Car.engine["cylinder"]["count"] == 6)
86 |     # [END bigquery_sqlalchemy_query_getitem]
87 |     # fmt: on
88 |     sixes3 = list(sixes)
89 | 
90 |     return sixes1, sixes2, sixes3
91 | 


--------------------------------------------------------------------------------
/samples/snippets/STRUCT_test.py:
--------------------------------------------------------------------------------
 1 | # Copyright (c) 2021 The sqlalchemy-bigquery Authors
 2 | #
 3 | # Permission is hereby granted, free of charge, to any person obtaining a copy of
 4 | # this software and associated documentation files (the "Software"), to deal in
 5 | # the Software without restriction, including without limitation the rights to
 6 | # use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 7 | # the Software, and to permit persons to whom the Software is furnished to do so,
 8 | # subject to the following conditions:
 9 | #
10 | # The above copyright notice and this permission notice shall be included in all
11 | # copies or substantial portions of the Software.
12 | #
13 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
15 | # FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
16 | # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
17 | # IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
18 | # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
19 | 
20 | 
21 | def test_struct(engine):
22 |     from . import STRUCT
23 | 
24 |     sixeses = STRUCT.example(engine)
25 | 
26 |     for sixes in sixeses:
27 |         assert sorted(car.model for car in sixes) == ["Sebring", "Town and Counttry"]
28 | 


--------------------------------------------------------------------------------
/samples/snippets/__init__.py:
--------------------------------------------------------------------------------
 1 | # Copyright (c) 2021 The sqlalchemy-bigquery Authors
 2 | #
 3 | # Permission is hereby granted, free of charge, to any person obtaining a copy of
 4 | # this software and associated documentation files (the "Software"), to deal in
 5 | # the Software without restriction, including without limitation the rights to
 6 | # use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 7 | # the Software, and to permit persons to whom the Software is furnished to do so,
 8 | # subject to the following conditions:
 9 | #
10 | # The above copyright notice and this permission notice shall be included in all
11 | # copies or substantial portions of the Software.
12 | #
13 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
15 | # FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
16 | # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
17 | # IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
18 | # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
19 | 
20 | __version__ = "1.0.0-a1"
21 | 


--------------------------------------------------------------------------------
/samples/snippets/conftest.py:
--------------------------------------------------------------------------------
 1 | # Copyright (c) 2021 The sqlalchemy-bigquery Authors
 2 | #
 3 | # Permission is hereby granted, free of charge, to any person obtaining a copy of
 4 | # this software and associated documentation files (the "Software"), to deal in
 5 | # the Software without restriction, including without limitation the rights to
 6 | # use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 7 | # the Software, and to permit persons to whom the Software is furnished to do so,
 8 | # subject to the following conditions:
 9 | #
10 | # The above copyright notice and this permission notice shall be included in all
11 | # copies or substantial portions of the Software.
12 | #
13 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
15 | # FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
16 | # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
17 | # IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
18 | # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
19 | """
20 | SQLAlchemy dialect for Google BigQuery
21 | """
22 | 
23 | from google.cloud import bigquery
24 | import pytest
25 | import sqlalchemy
26 | import test_utils.prefixer
27 | 
28 | prefixer = test_utils.prefixer.Prefixer("python-bigquery-sqlalchemy", "tests/system")
29 | 
30 | 
31 | @pytest.fixture(scope="session")
32 | def client():
33 |     return bigquery.Client()
34 | 
35 | 
36 | @pytest.fixture(scope="session")
37 | def dataset_id(client: bigquery.Client):
38 |     project_id = client.project
39 |     dataset_id = prefixer.create_prefix()
40 |     dataset = bigquery.Dataset(f"{project_id}.{dataset_id}")
41 |     dataset = client.create_dataset(dataset)
42 |     yield dataset_id
43 |     client.delete_dataset(dataset_id, delete_contents=True)
44 | 
45 | 
46 | @pytest.fixture(scope="session")
47 | def engine(dataset_id):
48 |     return sqlalchemy.create_engine(f"bigquery:///{dataset_id}")
49 | 


--------------------------------------------------------------------------------
/samples/snippets/geography.py:
--------------------------------------------------------------------------------
 1 | # Copyright (c) 2021 The sqlalchemy-bigquery Authors
 2 | #
 3 | # Permission is hereby granted, free of charge, to any person obtaining a copy of
 4 | # this software and associated documentation files (the "Software"), to deal in
 5 | # the Software without restriction, including without limitation the rights to
 6 | # use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 7 | # the Software, and to permit persons to whom the Software is furnished to do so,
 8 | # subject to the following conditions:
 9 | #
10 | # The above copyright notice and this permission notice shall be included in all
11 | # copies or substantial portions of the Software.
12 | #
13 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
15 | # FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
16 | # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
17 | # IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
18 | # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
19 | 
20 | 
21 | def example(engine):
22 |     # [START bigquery_sqlalchemy_create_table_with_geography]
23 |     from sqlalchemy.ext.declarative import declarative_base
24 |     from sqlalchemy import Column, String
25 |     from sqlalchemy_bigquery import GEOGRAPHY
26 | 
27 |     Base = declarative_base()
28 | 
29 |     class Lake(Base):
30 |         __tablename__ = "lakes"
31 | 
32 |         name = Column(String, primary_key=True)
33 |         geog = Column(GEOGRAPHY)
34 | 
35 |     # [END bigquery_sqlalchemy_create_table_with_geography]
36 |     Lake.__table__.create(engine)
37 | 
38 |     # [START bigquery_sqlalchemy_insert_geography]
39 |     from sqlalchemy.orm import sessionmaker
40 |     from sqlalchemy_bigquery import WKT
41 | 
42 |     Session = sessionmaker(bind=engine)
43 |     session = Session()
44 | 
45 |     lake = Lake(name="Majeur", geog="POLYGON((0 0,1 0,1 1,0 1,0 0))")
46 |     lake2 = Lake(name="Garde", geog=WKT("POLYGON((1 0,3 0,3 2,1 2,1 0))"))
47 |     b = WKT("POLYGON((3 0,6 0,6 3,3 3,3 0))").wkb
48 |     lake3 = Lake(name="Orta", geog=b)
49 | 
50 |     session.add_all((lake, lake2, lake3))
51 |     session.commit()
52 |     # [END bigquery_sqlalchemy_insert_geography]
53 | 
54 |     # [START bigquery_sqlalchemy_query_geography_wkb]
55 |     from sqlalchemy import func
56 | 
57 |     lakes_touching_lake2 = list(
58 |         session.query(Lake).filter(func.ST_Touches(Lake.geog, lake2.geog))
59 |     )
60 |     # [END bigquery_sqlalchemy_query_geography_wkb]
61 |     # [START bigquery_sqlalchemy_query_geography_text]
62 |     lakes_containing = list(
63 |         session.query(Lake).filter(func.ST_Contains(Lake.geog, "POINT(4 1)"))
64 |     )
65 |     # [END bigquery_sqlalchemy_query_geography_text]
66 |     return lakes_touching_lake2, lakes_containing
67 | 


--------------------------------------------------------------------------------
/samples/snippets/geography_test.py:
--------------------------------------------------------------------------------
 1 | # Copyright (c) 2021 The sqlalchemy-bigquery Authors
 2 | #
 3 | # Permission is hereby granted, free of charge, to any person obtaining a copy of
 4 | # this software and associated documentation files (the "Software"), to deal in
 5 | # the Software without restriction, including without limitation the rights to
 6 | # use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 7 | # the Software, and to permit persons to whom the Software is furnished to do so,
 8 | # subject to the following conditions:
 9 | #
10 | # The above copyright notice and this permission notice shall be included in all
11 | # copies or substantial portions of the Software.
12 | #
13 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
15 | # FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
16 | # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
17 | # IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
18 | # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
19 | 
20 | 
21 | def test_geography(engine):
22 |     from . import geography
23 | 
24 |     lakes_touching_lake2, lakes_containing = geography.example(engine)
25 | 
26 |     assert sorted(lake.name for lake in lakes_touching_lake2) == ["Majeur", "Orta"]
27 |     assert [lake.name for lake in lakes_containing] == ["Orta"]
28 | 


--------------------------------------------------------------------------------
/samples/snippets/requirements-test.txt:
--------------------------------------------------------------------------------
 1 | attrs==25.3.0
 2 | click===8.1.8; python_version <= '3.9'
 3 | click==8.2.1; python_version >= '3.10'
 4 | google-auth==2.40.3
 5 | google-cloud-testutils==1.6.4
 6 | iniconfig==2.1.0
 7 | packaging==25.0
 8 | pluggy===1.5.0; python_version == '3.8'
 9 | pluggy==1.6.0; python_version >= '3.9'
10 | py==1.11.0
11 | pyasn1==0.6.1
12 | pyasn1-modules==0.4.2
13 | pyparsing===3.1.4; python_version == '3.8'
14 | pyparsing==3.2.3; python_version >= '3.9'
15 | pytest===6.2.5
16 | rsa==4.9.1
17 | six==1.17.0
18 | toml==0.10.2
19 | typing-extensions===4.13.0; python_version == '3.8'
20 | typing-extensions==4.14.0; python_version >= '3.9'
21 | 


--------------------------------------------------------------------------------
/samples/snippets/requirements.txt:
--------------------------------------------------------------------------------
 1 | alembic===1.14.0; python_version == '3.8'
 2 | alembic==1.16.1;  python_version >= '3.9'
 3 | certifi==2025.4.26
 4 | charset-normalizer==3.4.2
 5 | geoalchemy2==0.17.1
 6 | google-api-core[grpc]==2.25.0
 7 | google-auth==2.40.3
 8 | google-cloud-bigquery===3.30.0; python_version == '3.8'
 9 | google-cloud-bigquery==3.34.0; python_version >= '3.9'
10 | google-cloud-core==2.4.3
11 | google-crc32c===1.5.0; python_version == '3.8'
12 | google-crc32c==1.7.1; python_version >= '3.9'
13 | google-resumable-media==2.7.2
14 | googleapis-common-protos==1.70.0
15 | greenlet===3.1.1; python_version == '3.8'
16 | greenlet==3.2.2; python_version >= '3.9'
17 | grpcio===1.68.0; python_version == '3.8'
18 | grpcio==1.72.1; python_version >= '3.9'
19 | grpcio-status===1.68.0; python_version == '3.8'
20 | grpcio-status==1.72.1; python_version >= '3.9'
21 | idna==3.10
22 | importlib-resources===6.4.5; python_version == '3.8'
23 | importlib-resources==6.5.2; python_version >= '3.9'
24 | mako===1.3.5; python_version == '3.8'
25 | mako==1.3.10; python_version >= '3.9'
26 | markupsafe===2.1.5; python_version == '3.8'
27 | markupsafe==3.0.2; python_version >= '3.9'
28 | packaging==25.0
29 | proto-plus==1.26.1
30 | protobuf===5.28.3; python_version == '3.8'
31 | protobuf==6.30.0; python_version >= '3.9'
32 | pyasn1==0.6.1
33 | pyasn1-modules==0.4.2
34 | pyparsing===3.1.4; python_version == '3.8'
35 | pyparsing==3.2.3; python_version >= '3.9'
36 | python-dateutil==2.9.0.post0
37 | pytz==2025.2
38 | requests==2.32.3
39 | rsa==4.9.1
40 | shapely===2.0.7; python_version <= '3.9'
41 | shapely==2.1.1; python_version >= '3.10'
42 | six==1.17.0
43 | sqlalchemy===1.4.27
44 | typing-extensions===4.13.0; python_version == '3.8'
45 | typing-extensions==4.14.0; python_version >= '3.9'
46 | urllib3===2.2.3; python_version == '3.8'
47 | urllib3==2.4.0; python_version >= '3.9'
48 | 


--------------------------------------------------------------------------------
/scripts/decrypt-secrets.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # Copyright 2024 Google LLC All rights reserved.
 4 | #
 5 | # Licensed under the Apache License, Version 2.0 (the "License");
 6 | # you may not use this file except in compliance with the License.
 7 | # You may obtain a copy of the License at
 8 | #
 9 | #     http://www.apache.org/licenses/LICENSE-2.0
10 | #
11 | # Unless required by applicable law or agreed to in writing, software
12 | # distributed under the License is distributed on an "AS IS" BASIS,
13 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | # See the License for the specific language governing permissions and
15 | # limitations under the License.
16 | 
17 | DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
18 | ROOT=$( dirname "$DIR" )
19 | 
20 | # Work from the project root.
21 | cd $ROOT
22 | 
23 | # Prevent it from overriding files.
24 | # We recommend that sample authors use their own service account files and cloud project.
25 | # In that case, they are supposed to prepare these files by themselves.
26 | if [[ -f "testing/test-env.sh" ]] || \
27 |        [[ -f "testing/service-account.json" ]] || \
28 |        [[ -f "testing/client-secrets.json" ]]; then
29 |     echo "One or more target files exist, aborting."
30 |     exit 1
31 | fi
32 | 
33 | # Use SECRET_MANAGER_PROJECT if set, fallback to cloud-devrel-kokoro-resources.
34 | PROJECT_ID="${SECRET_MANAGER_PROJECT:-cloud-devrel-kokoro-resources}"
35 | 
36 | gcloud secrets versions access latest --secret="python-docs-samples-test-env" \
37 |        --project="${PROJECT_ID}" \
38 |        > testing/test-env.sh
39 | gcloud secrets versions access latest \
40 |        --secret="python-docs-samples-service-account" \
41 |        --project="${PROJECT_ID}" \
42 |        > testing/service-account.json
43 | gcloud secrets versions access latest \
44 |        --secret="python-docs-samples-client-secrets" \
45 |        --project="${PROJECT_ID}" \
46 |        > testing/client-secrets.json
47 | 


--------------------------------------------------------------------------------
/scripts/readme-gen/readme_gen.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | 
 3 | # Copyright 2024 Google LLC
 4 | #
 5 | # Licensed under the Apache License, Version 2.0 (the "License");
 6 | # you may not use this file except in compliance with the License.
 7 | # You may obtain a copy of the License at
 8 | #
 9 | #      http://www.apache.org/licenses/LICENSE-2.0
10 | #
11 | # Unless required by applicable law or agreed to in writing, software
12 | # distributed under the License is distributed on an "AS IS" BASIS,
13 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | # See the License for the specific language governing permissions and
15 | # limitations under the License.
16 | 
17 | """Generates READMEs using configuration defined in yaml."""
18 | 
19 | import argparse
20 | import io
21 | import os
22 | import subprocess
23 | 
24 | import jinja2
25 | import yaml
26 | 
27 | 
28 | jinja_env = jinja2.Environment(
29 |     trim_blocks=True,
30 |     loader=jinja2.FileSystemLoader(
31 |         os.path.abspath(os.path.join(os.path.dirname(__file__), "templates"))
32 |     ),
33 |     autoescape=True,
34 | )
35 | 
36 | README_TMPL = jinja_env.get_template("README.tmpl.rst")
37 | 
38 | 
39 | def get_help(file):
40 |     return subprocess.check_output(["python", file, "--help"]).decode()
41 | 
42 | 
43 | def main():
44 |     parser = argparse.ArgumentParser()
45 |     parser.add_argument("source")
46 |     parser.add_argument("--destination", default="README.rst")
47 | 
48 |     args = parser.parse_args()
49 | 
50 |     source = os.path.abspath(args.source)
51 |     root = os.path.dirname(source)
52 |     destination = os.path.join(root, args.destination)
53 | 
54 |     jinja_env.globals["get_help"] = get_help
55 | 
56 |     with io.open(source, "r") as f:
57 |         config = yaml.load(f)
58 | 
59 |     # This allows get_help to execute in the right directory.
60 |     os.chdir(root)
61 | 
62 |     output = README_TMPL.render(config)
63 | 
64 |     with io.open(destination, "w") as f:
65 |         f.write(output)
66 | 
67 | 
68 | if __name__ == "__main__":
69 |     main()
70 | 


--------------------------------------------------------------------------------
/scripts/readme-gen/templates/README.tmpl.rst:
--------------------------------------------------------------------------------
 1 | {# The following line is a lie. BUT! Once jinja2 is done with it, it will
 2 |     become truth! #}
 3 | .. This file is automatically generated. Do not edit this file directly.
 4 | 
 5 | {{product.name}} Python Samples
 6 | ===============================================================================
 7 | 
 8 | .. image:: https://gstatic.com/cloudssh/images/open-btn.png
 9 |    :target: https://console.cloud.google.com/cloudshell/open?git_repo=https://github.com/GoogleCloudPlatform/python-docs-samples&page=editor&open_in_editor={{folder}}/README.rst
10 | 
11 | 
12 | This directory contains samples for {{product.name}}. {{product.description}}
13 | 
14 | {{description}}
15 | 
16 | .. _{{product.name}}: {{product.url}}
17 | 
18 | {% if required_api_url %}
19 | To run the sample, you need to enable the API at: {{required_api_url}}
20 | {% endif %}
21 | 
22 | {% if required_role %}
23 | To run the sample, you need to have `{{required_role}}` role.
24 | {% endif %}
25 | 
26 | {{other_required_steps}}
27 | 
28 | {% if setup %}
29 | Setup
30 | -------------------------------------------------------------------------------
31 | 
32 | {% for section in setup %}
33 | 
34 | {% include section + '.tmpl.rst' %}
35 | 
36 | {% endfor %}
37 | {% endif %}
38 | 
39 | {% if samples %}
40 | Samples
41 | -------------------------------------------------------------------------------
42 | 
43 | {% for sample in samples %}
44 | {{sample.name}}
45 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
46 | 
47 | {% if not sample.hide_cloudshell_button %}
48 | .. image:: https://gstatic.com/cloudssh/images/open-btn.png
49 |    :target: https://console.cloud.google.com/cloudshell/open?git_repo=https://github.com/GoogleCloudPlatform/python-docs-samples&page=editor&open_in_editor={{folder}}/{{sample.file}},{{folder}}/README.rst
50 | {% endif %}
51 | 
52 | 
53 | {{sample.description}}
54 | 
55 | To run this sample:
56 | 
57 | .. code-block:: bash
58 | 
59 |     $ python {{sample.file}}
60 | {% if sample.show_help %}
61 | 
62 |     {{get_help(sample.file)|indent}}
63 | {% endif %}
64 | 
65 | 
66 | {% endfor %}
67 | {% endif %}
68 | 
69 | {% if cloud_client_library %}
70 | 
71 | The client library
72 | -------------------------------------------------------------------------------
73 | 
74 | This sample uses the `Google Cloud Client Library for Python`_.
75 | You can read the documentation for more details on API usage and use GitHub
76 | to `browse the source`_ and  `report issues`_.
77 | 
78 | .. _Google Cloud Client Library for Python:
79 |     https://googlecloudplatform.github.io/google-cloud-python/
80 | .. _browse the source:
81 |     https://github.com/GoogleCloudPlatform/google-cloud-python
82 | .. _report issues:
83 |     https://github.com/GoogleCloudPlatform/google-cloud-python/issues
84 | 
85 | {% endif %}
86 | 
87 | .. _Google Cloud SDK: https://cloud.google.com/sdk/


--------------------------------------------------------------------------------
/scripts/readme-gen/templates/auth.tmpl.rst:
--------------------------------------------------------------------------------
 1 | Authentication
 2 | ++++++++++++++
 3 | 
 4 | This sample requires you to have authentication setup. Refer to the
 5 | `Authentication Getting Started Guide`_ for instructions on setting up
 6 | credentials for applications.
 7 | 
 8 | .. _Authentication Getting Started Guide:
 9 |     https://cloud.google.com/docs/authentication/getting-started
10 | 


--------------------------------------------------------------------------------
/scripts/readme-gen/templates/auth_api_key.tmpl.rst:
--------------------------------------------------------------------------------
 1 | Authentication
 2 | ++++++++++++++
 3 | 
 4 | Authentication for this service is done via an `API Key`_. To obtain an API
 5 | Key:
 6 | 
 7 | 1. Open the `Cloud Platform Console`_
 8 | 2. Make sure that billing is enabled for your project.
 9 | 3. From the **Credentials** page, create a new **API Key** or use an existing
10 |    one for your project.
11 | 
12 | .. _API Key:
13 |     https://developers.google.com/api-client-library/python/guide/aaa_apikeys
14 | .. _Cloud Console: https://console.cloud.google.com/project?_
15 | 


--------------------------------------------------------------------------------
/scripts/readme-gen/templates/install_deps.tmpl.rst:
--------------------------------------------------------------------------------
 1 | Install Dependencies
 2 | ++++++++++++++++++++
 3 | 
 4 | #. Clone python-docs-samples and change directory to the sample directory you want to use.
 5 | 
 6 |     .. code-block:: bash
 7 | 
 8 |         $ git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git
 9 | 
10 | #. Install `pip`_ and `virtualenv`_ if you do not already have them. You may want to refer to the `Python Development Environment Setup Guide`_ for Google Cloud Platform for instructions.
11 | 
12 |    .. _Python Development Environment Setup Guide:
13 |        https://cloud.google.com/python/setup
14 | 
15 | #. Create a virtualenv. Samples are compatible with Python 3.7+.
16 | 
17 |     .. code-block:: bash
18 | 
19 |         $ virtualenv env
20 |         $ source env/bin/activate
21 | 
22 | #. Install the dependencies needed to run the samples.
23 | 
24 |     .. code-block:: bash
25 | 
26 |         $ pip install -r requirements.txt
27 | 
28 | .. _pip: https://pip.pypa.io/
29 | .. _virtualenv: https://virtualenv.pypa.io/
30 | 


--------------------------------------------------------------------------------
/scripts/readme-gen/templates/install_portaudio.tmpl.rst:
--------------------------------------------------------------------------------
 1 | Install PortAudio
 2 | +++++++++++++++++
 3 | 
 4 | Install `PortAudio`_. This is required by the `PyAudio`_ library to stream
 5 | audio from your computer's microphone. PyAudio depends on PortAudio for cross-platform compatibility, and is installed differently depending on the
 6 | platform.
 7 | 
 8 | * For Mac OS X, you can use `Homebrew`_::
 9 | 
10 |       brew install portaudio
11 | 
12 |   **Note**: if you encounter an error when running `pip install` that indicates
13 |   it can't find `portaudio.h`, try running `pip install` with the following
14 |   flags::
15 | 
16 |       pip install --global-option='build_ext' \
17 |           --global-option='-I/usr/local/include' \
18 |           --global-option='-L/usr/local/lib' \
19 |           pyaudio
20 | 
21 | * For Debian / Ubuntu Linux::
22 | 
23 |       apt-get install portaudio19-dev python-all-dev
24 | 
25 | * Windows may work without having to install PortAudio explicitly (it will get
26 |   installed with PyAudio).
27 | 
28 | For more details, see the `PyAudio installation`_ page.
29 | 
30 | 
31 | .. _PyAudio: https://people.csail.mit.edu/hubert/pyaudio/
32 | .. _PortAudio: http://www.portaudio.com/
33 | .. _PyAudio installation:
34 |   https://people.csail.mit.edu/hubert/pyaudio/#downloads
35 | .. _Homebrew: http://brew.sh
36 | 


--------------------------------------------------------------------------------
/setup.cfg:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | #
 3 | # Copyright 2023 Google LLC
 4 | #
 5 | # Licensed under the Apache License, Version 2.0 (the "License");
 6 | # you may not use this file except in compliance with the License.
 7 | # You may obtain a copy of the License at
 8 | #
 9 | #     https://www.apache.org/licenses/LICENSE-2.0
10 | #
11 | # Unless required by applicable law or agreed to in writing, software
12 | # distributed under the License is distributed on an "AS IS" BASIS,
13 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | # See the License for the specific language governing permissions and
15 | # limitations under the License.
16 | 
17 | [sqla_testing]
18 | requirement_cls=sqlalchemy_bigquery.requirements:Requirements
19 | profile_file=.sqlalchemy_dialect_compliance-profiles.txt
20 | 
21 | [tool:pytest]
22 | addopts= --tb native -v -r fxX
23 | python_files=tests/*test_*.py
24 | 


--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | # Copyright (c) 2017 The sqlalchemy-bigquery Authors
  3 | #
  4 | # Permission is hereby granted, free of charge, to any person obtaining a copy of
  5 | # this software and associated documentation files (the "Software"), to deal in
  6 | # the Software without restriction, including without limitation the rights to
  7 | # use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
  8 | # the Software, and to permit persons to whom the Software is furnished to do so,
  9 | # subject to the following conditions:
 10 | #
 11 | # The above copyright notice and this permission notice shall be included in all
 12 | # copies or substantial portions of the Software.
 13 | #
 14 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 15 | # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 16 | # FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 17 | # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 18 | # IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 19 | # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 20 | 
 21 | import io
 22 | import itertools
 23 | import os
 24 | import re
 25 | import setuptools
 26 | from setuptools import setup
 27 | 
 28 | # Package metadata.
 29 | 
 30 | name = "sqlalchemy-bigquery"
 31 | description = "SQLAlchemy dialect for BigQuery"
 32 | 
 33 | # Should be one of:
 34 | # 'Development Status :: 3 - Alpha'
 35 | # 'Development Status :: 4 - Beta'
 36 | # 'Development Status :: 5 - Production/Stable'
 37 | release_status = "Development Status :: 5 - Production/Stable"
 38 | 
 39 | package_root = os.path.abspath(os.path.dirname(__file__))
 40 | with open(os.path.join(package_root, "sqlalchemy_bigquery", "version.py")) as f:
 41 |     version = re.search('__version__ = "([^"]+)"', f.read()).group(1)
 42 | 
 43 | 
 44 | def readme():
 45 |     with io.open("README.rst", "r", encoding="utf8") as f:
 46 |         return f.read()
 47 | 
 48 | 
 49 | extras = {
 50 |     "geography": ["GeoAlchemy2", "shapely"],
 51 |     "alembic": ["alembic"],
 52 |     "tests": ["packaging", "pytz"],
 53 |     # Keep the no-op bqstorage extra for backward compatibility.
 54 |     # See: https://github.com/googleapis/python-bigquery/issues/757
 55 |     "bqstorage": [
 56 |         "google-cloud-bigquery-storage >= 2.0.0, <3.0.0",
 57 |         # Due to an issue in pip's dependency resolver, the `grpc` extra is not
 58 |         # installed, even though `google-cloud-bigquery-storage` specifies it
 59 |         # as `google-api-core[grpc]`. We thus need to explicitly specify it here.
 60 |         # See: https://github.com/googleapis/python-bigquery/issues/83 The
 61 |         # grpc.Channel.close() method isn't added until 1.32.0.
 62 |         # https://github.com/grpc/grpc/pull/15254
 63 |         "grpcio >= 1.47.0, < 2.0.0",
 64 |         "grpcio >= 1.49.1, < 2.0.0; python_version>='3.11'",
 65 |         "pyarrow >= 3.0.0",
 66 |     ],
 67 | }
 68 | 
 69 | extras["all"] = set(itertools.chain.from_iterable(extras.values()))
 70 | 
 71 | packages = [
 72 |     package
 73 |     for package in setuptools.find_namespace_packages()
 74 |     if package.startswith("sqlalchemy_bigquery")
 75 | ] + [
 76 |     package
 77 |     for package in setuptools.find_namespace_packages("third_party")
 78 |     if package.startswith("sqlalchemy_bigquery_vendored")
 79 | ]
 80 | 
 81 | setup(
 82 |     name=name,
 83 |     version=version,
 84 |     description=description,
 85 |     long_description=readme(),
 86 |     long_description_content_type="text/x-rst",
 87 |     author="The Sqlalchemy-Bigquery Authors",
 88 |     author_email="googleapis-packages@google.com",
 89 |     package_dir={
 90 |         "sqlalchemy-bigquery": "sqlalchemy_bigquery",
 91 |         "sqlalchemy_bigquery_vendored": "third_party/sqlalchemy_bigquery_vendored",
 92 |     },
 93 |     packages=packages,
 94 |     url="https://github.com/googleapis/python-bigquery-sqlalchemy",
 95 |     keywords=["bigquery", "sqlalchemy"],
 96 |     classifiers=[
 97 |         release_status,
 98 |         "Intended Audience :: Developers",
 99 |         "License :: OSI Approved :: MIT License",
100 |         "Programming Language :: Python",
101 |         "Programming Language :: Python :: 3",
102 |         "Programming Language :: Python :: 3.8",
103 |         "Programming Language :: Python :: 3.9",
104 |         "Programming Language :: Python :: 3.10",
105 |         "Programming Language :: Python :: 3.11",
106 |         "Programming Language :: Python :: 3.12",
107 |         "Operating System :: OS Independent",
108 |         "Topic :: Database :: Front-Ends",
109 |     ],
110 |     platforms="Posix; MacOS X; Windows",
111 |     install_requires=[
112 |         "google-api-core >= 1.31.5, <3.0.0,!=2.0.*,!=2.1.*,!=2.2.*,!=2.3.0",
113 |         # NOTE: Maintainers, please do not require google-auth>=2.x.x
114 |         # Until this issue is closed
115 |         # https://github.com/googleapis/google-cloud-python/issues/10566
116 |         "google-auth>=1.25.0,<3.0.0",  # Work around pip wack.
117 |         "google-cloud-bigquery>=3.3.6,<4.0.0",
118 |         "packaging",
119 |         "sqlalchemy>=1.4.16,<3.0.0",
120 |     ],
121 |     extras_require=extras,
122 |     python_requires=">=3.8, <3.13",
123 |     tests_require=["packaging", "pytz"],
124 |     entry_points={
125 |         "sqlalchemy.dialects": ["bigquery = sqlalchemy_bigquery:BigQueryDialect"]
126 |     },
127 |     # Document that this replaces pybigquery, however, this isn't
128 |     # enforced by pip, because doing so would allow rogue packages to
129 |     # obsolete legitimate ones.
130 |     obsoletes=["pybigquery"],
131 | )
132 | 


--------------------------------------------------------------------------------
/sqlalchemy_bigquery/__init__.py:
--------------------------------------------------------------------------------
  1 | # Copyright (c) 2017 The sqlalchemy-bigquery Authors
  2 | #
  3 | # Permission is hereby granted, free of charge, to any person obtaining a copy of
  4 | # this software and associated documentation files (the "Software"), to deal in
  5 | # the Software without restriction, including without limitation the rights to
  6 | # use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
  7 | # the Software, and to permit persons to whom the Software is furnished to do so,
  8 | # subject to the following conditions:
  9 | #
 10 | # The above copyright notice and this permission notice shall be included in all
 11 | # copies or substantial portions of the Software.
 12 | #
 13 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 14 | # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 15 | # FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 16 | # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 17 | # IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 18 | # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 19 | """
 20 | SQLAlchemy dialect for Google BigQuery
 21 | """
 22 | 
 23 | import warnings
 24 | 
 25 | from .version import __version__
 26 | 
 27 | from .base import BigQueryDialect, dialect
 28 | from ._types import (
 29 |     ARRAY,
 30 |     BIGNUMERIC,
 31 |     BOOL,
 32 |     BOOLEAN,
 33 |     BYTES,
 34 |     DATE,
 35 |     DATETIME,
 36 |     FLOAT,
 37 |     FLOAT64,
 38 |     INT64,
 39 |     INTEGER,
 40 |     NUMERIC,
 41 |     RECORD,
 42 |     STRING,
 43 |     STRUCT,
 44 |     TIME,
 45 |     TIMESTAMP,
 46 | )
 47 | 
 48 | from . import _versions_helpers
 49 | 
 50 | sys_major, sys_minor, sys_micro = _versions_helpers.extract_runtime_version()
 51 | if sys_major == 3 and sys_minor in (7, 8):
 52 |     warnings.warn(
 53 |         "The python-bigquery library will stop supporting Python 3.7 "
 54 |         "and Python 3.8 in a future major release expected in Q4 2024. "
 55 |         f"Your Python version is {sys_major}.{sys_minor}.{sys_micro}. We "
 56 |         "recommend that you update soon to ensure ongoing support. For "
 57 |         "more details, see: [Google Cloud Client Libraries Supported Python Versions policy](https://cloud.google.com/python/docs/supported-python-versions)",
 58 |         PendingDeprecationWarning,
 59 |     )
 60 | 
 61 | 
 62 | __all__ = [
 63 |     "__version__",
 64 |     "dialect",
 65 |     "ARRAY",
 66 |     "BIGNUMERIC",
 67 |     "BigQueryDialect",
 68 |     "BOOL",
 69 |     "BOOLEAN",
 70 |     "BYTES",
 71 |     "DATE",
 72 |     "DATETIME",
 73 |     "FLOAT",
 74 |     "FLOAT64",
 75 |     "INT64",
 76 |     "INTEGER",
 77 |     "NUMERIC",
 78 |     "RECORD",
 79 |     "STRING",
 80 |     "STRUCT",
 81 |     "TIME",
 82 |     "TIMESTAMP",
 83 | ]
 84 | 
 85 | try:
 86 |     from .geography import GEOGRAPHY, WKB, WKT  # noqa
 87 | except ImportError:  # pragma: NO COVER
 88 |     pass
 89 | else:
 90 |     __all__.extend(["GEOGRAPHY", "WKB", "WKT"])
 91 | 
 92 | try:
 93 |     import pybigquery  # noqa
 94 | except ImportError:
 95 |     pass
 96 | else:  # pragma: NO COVER
 97 |     import warnings
 98 | 
 99 |     warnings.warn(
100 |         "Obsolete pybigquery is installed, which is likely to\n"
101 |         "interfere with sqlalchemy_bigquery.\n"
102 |         "pybigquery should be uninstalled.",
103 |         stacklevel=2,
104 |     )
105 | 


--------------------------------------------------------------------------------
/sqlalchemy_bigquery/_helpers.py:
--------------------------------------------------------------------------------
  1 | # Copyright 2021 The sqlalchemy-bigquery Authors
  2 | #
  3 | # Use of this source code is governed by an MIT-style
  4 | # license that can be found in the LICENSE file or at
  5 | # https://opensource.org/licenses/MIT.
  6 | 
  7 | import functools
  8 | import re
  9 | from typing import Optional
 10 | 
 11 | from google.api_core import client_info
 12 | import google.auth
 13 | from google.cloud import bigquery
 14 | from google.oauth2 import service_account
 15 | import sqlalchemy
 16 | import base64
 17 | import json
 18 | 
 19 | 
 20 | USER_AGENT_TEMPLATE = "sqlalchemy/{}"
 21 | SCOPES = (
 22 |     "https://www.googleapis.com/auth/bigquery",
 23 |     "https://www.googleapis.com/auth/cloud-platform",
 24 |     "https://www.googleapis.com/auth/drive",
 25 | )
 26 | 
 27 | 
 28 | def google_client_info(
 29 |     user_agent: Optional[str] = None,
 30 | ) -> google.api_core.client_info.ClientInfo:
 31 |     """
 32 |     Return a client_info object, with an optional user agent
 33 |     string.  If user_agent is None, use a default value.
 34 |     """
 35 | 
 36 |     if user_agent is None:
 37 |         user_agent = USER_AGENT_TEMPLATE.format(sqlalchemy.__version__)
 38 |     return client_info.ClientInfo(user_agent=user_agent)
 39 | 
 40 | 
 41 | def create_bigquery_client(
 42 |     credentials_info: Optional[dict] = None,
 43 |     credentials_path: Optional[str] = None,
 44 |     credentials_base64: Optional[str] = None,
 45 |     default_query_job_config: Optional[google.cloud.bigquery.job.QueryJobConfig] = None,
 46 |     location: Optional[str] = None,
 47 |     project_id: Optional[str] = None,
 48 |     user_agent: Optional[google.api_core.client_info.ClientInfo] = None,
 49 | ) -> google.cloud.bigquery.Client:
 50 |     """Construct a BigQuery client object.
 51 | 
 52 |     Args:
 53 |         credentials_info Optional[dict]:
 54 |         credentials_path Optional[str]:
 55 |         credentials_base64 Optional[str]:
 56 |         default_query_job_config (Optional[google.cloud.bigquery.job.QueryJobConfig]):
 57 |             Default ``QueryJobConfig``.
 58 |             Will be merged into job configs passed into the ``query`` method.
 59 |         location (Optional[str]):
 60 |             Default location for jobs / datasets / tables.
 61 |         project_id (Optional[str]):
 62 |             Project ID for the project which the client acts on behalf of.
 63 |         user_agent (Optional[google.api_core.client_info.ClientInfo]):
 64 |             The client info used to send a user-agent string along with API
 65 |             requests. If ``None``, then default info will be used. Generally,
 66 |             you only need to set this if you're developing your own library
 67 |             or partner tool.
 68 |     """
 69 | 
 70 |     default_project = None
 71 | 
 72 |     if credentials_base64:
 73 |         credentials_info = json.loads(base64.b64decode(credentials_base64))
 74 | 
 75 |     if credentials_path:
 76 |         credentials = service_account.Credentials.from_service_account_file(
 77 |             credentials_path
 78 |         )
 79 |         credentials = credentials.with_scopes(SCOPES)
 80 |         default_project = credentials.project_id
 81 |     elif credentials_info:
 82 |         credentials = service_account.Credentials.from_service_account_info(
 83 |             credentials_info
 84 |         )
 85 |         credentials = credentials.with_scopes(SCOPES)
 86 |         default_project = credentials.project_id
 87 |     else:
 88 |         credentials, default_project = google.auth.default(scopes=SCOPES)
 89 | 
 90 |     if project_id is None:
 91 |         project_id = default_project
 92 | 
 93 |     client_info = google_client_info(user_agent=user_agent)
 94 | 
 95 |     return bigquery.Client(
 96 |         client_info=client_info,
 97 |         project=project_id,
 98 |         credentials=credentials,
 99 |         location=location,
100 |         default_query_job_config=default_query_job_config,
101 |     )
102 | 
103 | 
104 | def substitute_re_method(r, flags=0, repl=None):
105 |     if repl is None:
106 |         return lambda f: substitute_re_method(r, flags, f)
107 | 
108 |     r = re.compile(r, flags)
109 | 
110 |     @functools.wraps(repl)
111 |     def sub(self, s, *args, **kw):
112 |         def repl_(m):
113 |             return repl(self, m, *args, **kw)
114 | 
115 |         return r.sub(repl_, s)
116 | 
117 |     return sub
118 | 
119 | 
120 | def substitute_string_re_method(r, *, repl, flags=0):
121 |     r = re.compile(r, flags)
122 |     return lambda self, s: r.sub(repl, s)
123 | 


--------------------------------------------------------------------------------
/sqlalchemy_bigquery/_struct.py:
--------------------------------------------------------------------------------
  1 | # Copyright (c) 2021 The sqlalchemy-bigquery Authors
  2 | #
  3 | # Permission is hereby granted, free of charge, to any person obtaining a copy of
  4 | # this software and associated documentation files (the "Software"), to deal in
  5 | # the Software without restriction, including without limitation the rights to
  6 | # use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
  7 | # the Software, and to permit persons to whom the Software is furnished to do so,
  8 | # subject to the following conditions:
  9 | #
 10 | # The above copyright notice and this permission notice shall be included in all
 11 | # copies or substantial portions of the Software.
 12 | #
 13 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 14 | # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 15 | # FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 16 | # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 17 | # IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 18 | # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 19 | 
 20 | import sqlalchemy.sql.default_comparator
 21 | import sqlalchemy.sql.sqltypes
 22 | import sqlalchemy.types
 23 | 
 24 | from . import base
 25 | 
 26 | import sqlalchemy.sql.coercions
 27 | import sqlalchemy.sql.roles
 28 | 
 29 | 
 30 | def _get_subtype_col_spec(type_):
 31 |     global _get_subtype_col_spec
 32 | 
 33 |     type_compiler = base.dialect.type_compiler(base.dialect())
 34 |     _get_subtype_col_spec = type_compiler.process
 35 |     return _get_subtype_col_spec(type_)
 36 | 
 37 | 
 38 | class STRUCT(sqlalchemy.sql.sqltypes.Indexable, sqlalchemy.types.UserDefinedType):
 39 |     """
 40 |     A type for BigQuery STRUCT/RECORD data
 41 | 
 42 |     See https://googleapis.dev/python/sqlalchemy-bigquery/latest/struct.html
 43 |     """
 44 | 
 45 |     # See https://docs.sqlalchemy.org/en/14/core/custom_types.html#creating-new-types
 46 | 
 47 |     def __init__(
 48 |         self,
 49 |         *fields,
 50 |         **kwfields,
 51 |     ):
 52 |         # Note that because:
 53 |         # https://docs.python.org/3/whatsnew/3.6.html#pep-468-preserving-keyword-argument-order
 54 |         # We know that `kwfields` preserves order.
 55 |         self._STRUCT_fields = tuple(
 56 |             (
 57 |                 name,
 58 |                 type_ if isinstance(type_, sqlalchemy.types.TypeEngine) else type_(),
 59 |             )
 60 |             for (name, type_) in (fields + tuple(kwfields.items()))
 61 |         )
 62 | 
 63 |         self._STRUCT_byname = {
 64 |             name.lower(): type_ for (name, type_) in self._STRUCT_fields
 65 |         }
 66 | 
 67 |     def __repr__(self):
 68 |         fields = ", ".join(
 69 |             f"{name}={repr(type_)}" for name, type_ in self._STRUCT_fields
 70 |         )
 71 |         return f"STRUCT({fields})"
 72 | 
 73 |     def get_col_spec(self, **kw):
 74 |         fields = ", ".join(
 75 |             f"{name} {_get_subtype_col_spec(type_)}"
 76 |             for name, type_ in self._STRUCT_fields
 77 |         )
 78 |         return f"STRUCT<{fields}>"
 79 | 
 80 |     def bind_processor(self, dialect):
 81 |         return dict
 82 | 
 83 |     class Comparator(sqlalchemy.sql.sqltypes.Indexable.Comparator):
 84 |         def _setup_getitem(self, name):
 85 |             if not isinstance(name, str):
 86 |                 raise TypeError(
 87 |                     f"STRUCT fields can only be accessed with strings field names,"
 88 |                     f" not {repr(name)}."
 89 |                 )
 90 |             subtype = self.expr.type._STRUCT_byname.get(name.lower())
 91 |             if subtype is None:
 92 |                 raise KeyError(name)
 93 |             operator = struct_getitem_op
 94 |             index = _field_index(self, name, operator)
 95 |             return operator, index, subtype
 96 | 
 97 |         def __getattr__(self, name):
 98 |             if name.lower() in self.expr.type._STRUCT_byname:
 99 |                 return self[name]
100 |             else:
101 |                 raise AttributeError(name)
102 | 
103 |     comparator_factory = Comparator
104 | 
105 | 
106 | def _field_index(self, name, operator):
107 |     return sqlalchemy.sql.coercions.expect(
108 |         sqlalchemy.sql.roles.BinaryElementRole,
109 |         name,
110 |         expr=self.expr,
111 |         operator=operator,
112 |         bindparam_type=sqlalchemy.types.String(),
113 |     )
114 | 
115 | 
116 | def struct_getitem_op(a, b):
117 |     raise NotImplementedError()
118 | 
119 | 
120 | sqlalchemy.sql.default_comparator.operator_lookup[
121 |     struct_getitem_op.__name__
122 | ] = sqlalchemy.sql.default_comparator.operator_lookup["json_getitem_op"]
123 | 
124 | 
125 | class SQLCompiler:
126 |     def visit_struct_getitem_op_binary(self, binary, operator_, **kw):
127 |         left = self.process(binary.left, **kw)
128 |         return f"{left}.{binary.right.value}"
129 | 


--------------------------------------------------------------------------------
/sqlalchemy_bigquery/_types.py:
--------------------------------------------------------------------------------
  1 | # Copyright (c) 2021 The sqlalchemy-bigquery Authors
  2 | #
  3 | # Permission is hereby granted, free of charge, to any person obtaining a copy of
  4 | # this software and associated documentation files (the "Software"), to deal in
  5 | # the Software without restriction, including without limitation the rights to
  6 | # use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
  7 | # the Software, and to permit persons to whom the Software is furnished to do so,
  8 | # subject to the following conditions:
  9 | #
 10 | # The above copyright notice and this permission notice shall be included in all
 11 | # copies or substantial portions of the Software.
 12 | #
 13 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 14 | # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 15 | # FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 16 | # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 17 | # IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 18 | # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 19 | 
 20 | import sqlalchemy.types
 21 | import sqlalchemy.util
 22 | 
 23 | from google.cloud.bigquery.schema import SchemaField
 24 | 
 25 | try:
 26 |     from .geography import GEOGRAPHY
 27 | except ImportError:  # pragma: NO COVER
 28 |     pass
 29 | 
 30 | from ._struct import STRUCT
 31 | 
 32 | _type_map = {
 33 |     "ARRAY": sqlalchemy.types.ARRAY,
 34 |     "BIGNUMERIC": sqlalchemy.types.Numeric,
 35 |     "BOOLEAN": sqlalchemy.types.Boolean,
 36 |     "BOOL": sqlalchemy.types.Boolean,
 37 |     "BYTES": sqlalchemy.types.BINARY,
 38 |     "DATETIME": sqlalchemy.types.DATETIME,
 39 |     "DATE": sqlalchemy.types.DATE,
 40 |     "FLOAT64": sqlalchemy.types.Float,
 41 |     "FLOAT": sqlalchemy.types.Float,
 42 |     "INT64": sqlalchemy.types.Integer,
 43 |     "INTEGER": sqlalchemy.types.Integer,
 44 |     "NUMERIC": sqlalchemy.types.Numeric,
 45 |     "RECORD": STRUCT,
 46 |     "STRING": sqlalchemy.types.String,
 47 |     "STRUCT": STRUCT,
 48 |     "TIMESTAMP": sqlalchemy.types.TIMESTAMP,
 49 |     "TIME": sqlalchemy.types.TIME,
 50 | }
 51 | 
 52 | # By convention, dialect-provided types are spelled with all upper case.
 53 | ARRAY = _type_map["ARRAY"]
 54 | BIGNUMERIC = _type_map["NUMERIC"]
 55 | BOOLEAN = _type_map["BOOLEAN"]
 56 | BOOL = _type_map["BOOL"]
 57 | BYTES = _type_map["BYTES"]
 58 | DATETIME = _type_map["DATETIME"]
 59 | DATE = _type_map["DATE"]
 60 | FLOAT64 = _type_map["FLOAT64"]
 61 | FLOAT = _type_map["FLOAT"]
 62 | INT64 = _type_map["INT64"]
 63 | INTEGER = _type_map["INTEGER"]
 64 | NUMERIC = _type_map["NUMERIC"]
 65 | RECORD = _type_map["RECORD"]
 66 | STRING = _type_map["STRING"]
 67 | TIMESTAMP = _type_map["TIMESTAMP"]
 68 | TIME = _type_map["TIME"]
 69 | 
 70 | try:
 71 |     _type_map["GEOGRAPHY"] = GEOGRAPHY
 72 | except NameError:  # pragma: NO COVER
 73 |     pass
 74 | 
 75 | STRUCT_FIELD_TYPES = "RECORD", "STRUCT"
 76 | 
 77 | 
 78 | def _get_transitive_schema_fields(fields):
 79 |     """
 80 |     Recurse into record type and return all the nested field names.
 81 |     As contributed by @sumedhsakdeo on issue #17
 82 |     """
 83 |     results = []
 84 |     for field in fields:
 85 |         results += [field]
 86 |         if field.field_type in STRUCT_FIELD_TYPES and field.mode != "REPEATED":
 87 |             sub_fields = [
 88 |                 SchemaField.from_api_repr(
 89 |                     dict(f.to_api_repr(), name=f"{field.name}.{f.name}")
 90 |                 )
 91 |                 for f in field.fields
 92 |             ]
 93 |             results += _get_transitive_schema_fields(sub_fields)
 94 |     return results
 95 | 
 96 | 
 97 | def _get_sqla_column_type(field):
 98 |     try:
 99 |         coltype = _type_map[field.field_type]
100 |     except KeyError:
101 |         sqlalchemy.util.warn(
102 |             "Did not recognize type '%s' of column '%s'"
103 |             % (field.field_type, field.name)
104 |         )
105 |         coltype = sqlalchemy.types.NullType
106 |     else:
107 |         if field.field_type.endswith("NUMERIC"):
108 |             coltype = coltype(precision=field.precision, scale=field.scale)
109 |         elif field.field_type == "STRING" or field.field_type == "BYTES":
110 |             coltype = coltype(field.max_length)
111 |         elif field.field_type == "RECORD" or field.field_type == "STRUCT":
112 |             coltype = STRUCT(
113 |                 *(
114 |                     (subfield.name, _get_sqla_column_type(subfield))
115 |                     for subfield in field.fields
116 |                 )
117 |             )
118 |         else:
119 |             coltype = coltype()
120 | 
121 |     if field.mode == "REPEATED":
122 |         coltype = ARRAY(coltype)
123 | 
124 |     return coltype
125 | 
126 | 
127 | def get_columns(bq_schema):
128 |     fields = _get_transitive_schema_fields(bq_schema)
129 |     return [
130 |         {
131 |             "name": field.name,
132 |             "type": _get_sqla_column_type(field),
133 |             "nullable": field.mode == "NULLABLE" or field.mode == "REPEATED",
134 |             "comment": field.description,
135 |             "default": None,
136 |             "precision": field.precision,
137 |             "scale": field.scale,
138 |             "max_length": field.max_length,
139 |         }
140 |         for field in fields
141 |     ]
142 | 


--------------------------------------------------------------------------------
/sqlalchemy_bigquery/_versions_helpers.py:
--------------------------------------------------------------------------------
 1 | # Copyright 2024 Google LLC
 2 | #
 3 | # Licensed under the Apache License, Version 2.0 (the "License");
 4 | # you may not use this file except in compliance with the License.
 5 | # You may obtain a copy of the License at
 6 | #
 7 | #     http://www.apache.org/licenses/LICENSE-2.0
 8 | #
 9 | # Unless required by applicable law or agreed to in writing, software
10 | # distributed under the License is distributed on an "AS IS" BASIS,
11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | # See the License for the specific language governing permissions and
13 | # limitations under the License.
14 | 
15 | """Shared helper functions for verifying versions of installed modules."""
16 | 
17 | 
18 | import sys
19 | from typing import Tuple
20 | 
21 | 
22 | def extract_runtime_version() -> Tuple[int, int, int]:
23 |     # Retrieve the version information
24 |     version_info = sys.version_info
25 | 
26 |     # Extract the major, minor, and micro components
27 |     major = version_info.major
28 |     minor = version_info.minor
29 |     micro = version_info.micro
30 | 
31 |     # Display the version number in a clear format
32 |     return major, minor, micro
33 | 


--------------------------------------------------------------------------------
/sqlalchemy_bigquery/version.py:
--------------------------------------------------------------------------------
 1 | # Copyright (c) 2021 The sqlalchemy-bigquery Authors
 2 | #
 3 | # Permission is hereby granted, free of charge, to any person obtaining a copy of
 4 | # this software and associated documentation files (the "Software"), to deal in
 5 | # the Software without restriction, including without limitation the rights to
 6 | # use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 7 | # the Software, and to permit persons to whom the Software is furnished to do so,
 8 | # subject to the following conditions:
 9 | #
10 | # The above copyright notice and this permission notice shall be included in all
11 | # copies or substantial portions of the Software.
12 | #
13 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
15 | # FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
16 | # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
17 | # IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
18 | # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
19 | 
20 | __version__ = "1.14.1"
21 | 


--------------------------------------------------------------------------------
/testing/.gitignore:
--------------------------------------------------------------------------------
1 | test-env.sh
2 | service-account.json
3 | client-secrets.json


--------------------------------------------------------------------------------
/testing/constraints-3.10.txt:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/googleapis/python-bigquery-sqlalchemy/d0347202c5fb144f960558d9022b7a22af6ce3f7/testing/constraints-3.10.txt


--------------------------------------------------------------------------------
/testing/constraints-3.11.txt:
--------------------------------------------------------------------------------
1 | numpy>=1.23
2 | 


--------------------------------------------------------------------------------
/testing/constraints-3.12.txt:
--------------------------------------------------------------------------------
1 | numpy>=1.23
2 | 


--------------------------------------------------------------------------------
/testing/constraints-3.13.txt:
--------------------------------------------------------------------------------
 1 | # This constraints file is used to check that lower bounds
 2 | # are correct in setup.py
 3 | # List all library dependencies and extras in this file.
 4 | # Pin the version to the lower bound.
 5 | # e.g., if setup.py has "google-cloud-foo >= 1.14.0, < 2.0.0dev",
 6 | # Then this file should have google-cloud-foo==1.14.0
 7 | google-api-core == 1.31.5
 8 | google-auth==1.25.0
 9 | google-cloud-bigquery==3.3.6
10 | google-cloud-bigquery-storage == 2.0.0
11 | grpcio == 1.47.0
12 | pyarrow == 3.0.0
13 | sqlalchemy==1.4.16
14 | 


--------------------------------------------------------------------------------
/testing/constraints-3.8.txt:
--------------------------------------------------------------------------------
 1 | # This constraints file is used to check that lower bounds
 2 | # are correct in setup.py
 3 | # List *all* library dependencies and extras in this file.
 4 | # Pin the version to the lower bound.
 5 | #
 6 | # e.g., if setup.py has "foo >= 1.14.0, < 2.0.0dev",
 7 | sqlalchemy==1.4.16
 8 | google-auth==1.25.0
 9 | google-cloud-bigquery==3.3.6
10 | google-cloud-bigquery-storage==2.0.0
11 | google-api-core==1.31.5
12 | grpcio==1.47.0
13 | pyarrow==3.0.0
14 | 


--------------------------------------------------------------------------------
/testing/constraints-3.9.txt:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/googleapis/python-bigquery-sqlalchemy/d0347202c5fb144f960558d9022b7a22af6ce3f7/testing/constraints-3.9.txt


--------------------------------------------------------------------------------
/tests/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/googleapis/python-bigquery-sqlalchemy/d0347202c5fb144f960558d9022b7a22af6ce3f7/tests/__init__.py


--------------------------------------------------------------------------------
/tests/conftest.py:
--------------------------------------------------------------------------------
 1 | # Copyright (c) 2017 The sqlalchemy-bigquery Authors
 2 | #
 3 | # Permission is hereby granted, free of charge, to any person obtaining a copy of
 4 | # this software and associated documentation files (the "Software"), to deal in
 5 | # the Software without restriction, including without limitation the rights to
 6 | # use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 7 | # the Software, and to permit persons to whom the Software is furnished to do so,
 8 | # subject to the following conditions:
 9 | #
10 | # The above copyright notice and this permission notice shall be included in all
11 | # copies or substantial portions of the Software.
12 | #
13 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
15 | # FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
16 | # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
17 | # IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
18 | # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
19 | 
20 | from sqlalchemy.dialects import registry
21 | 
22 | registry.register("bigquery", "sqlalchemy_bigquery", "BigQueryDialect")
23 | 
24 | # sqlalchemy's dialect-testing machinery wants an entry like this.
25 | # This seems to be based around dialects maybe having multiple drivers
26 | # and wanting to test drover-specific URLs, but doesn't seem to make
27 | # much sense for dialects with only one driver. ¯\_(ツ)_/¯
28 | registry.register("bigquery.bigquery", "sqlalchemy_bigquery", "BigQueryDialect")
29 | 


--------------------------------------------------------------------------------
/tests/sqlalchemy_dialect_compliance/README.rst:
--------------------------------------------------------------------------------
 1 | ==================================
 2 | SQLAlchemy Dialog Compliance Tests
 3 | ==================================
 4 | 
 5 | SQLAlchemy provides reusable tests that test that SQLAlchemy dialects
 6 | work properly. This directory applies these tests to the BigQuery
 7 | SQLAlchemy dialect.
 8 | 
 9 | These are "system" tests, meaning that they run against a real
10 | BigQuery account. To run the tests, you need a BigQuery account with
11 | empty `test_schema` schema. Other test schemas will be created on the
12 | fly. You need to have the `GOOGLE_APPLICATION_CREDENTIALS` environment
13 | variable set to the path of a Google Cloud authentication file.
14 | 


--------------------------------------------------------------------------------
/tests/sqlalchemy_dialect_compliance/conftest.py:
--------------------------------------------------------------------------------
 1 | # Copyright (c) 2021 The sqlalchemy-bigquery Authors
 2 | #
 3 | # Permission is hereby granted, free of charge, to any person obtaining a copy of
 4 | # this software and associated documentation files (the "Software"), to deal in
 5 | # the Software without restriction, including without limitation the rights to
 6 | # use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 7 | # the Software, and to permit persons to whom the Software is furnished to do so,
 8 | # subject to the following conditions:
 9 | #
10 | # The above copyright notice and this permission notice shall be included in all
11 | # copies or substantial portions of the Software.
12 | #
13 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
15 | # FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
16 | # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
17 | # IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
18 | # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
19 | 
20 | import contextlib
21 | import re
22 | import traceback
23 | 
24 | from sqlalchemy.testing import config
25 | from sqlalchemy.testing.plugin.pytestplugin import *  # noqa
26 | from sqlalchemy.testing.plugin.pytestplugin import (
27 |     pytest_sessionstart as _pytest_sessionstart,
28 |     pytest_sessionfinish as _pytest_sessionfinish,
29 | )
30 | 
31 | import google.cloud.bigquery.dbapi.connection
32 | import test_utils.prefixer
33 | 
34 | import sqlalchemy_bigquery.base
35 | 
36 | sqlalchemy_bigquery.BigQueryDialect.preexecute_autoincrement_sequences = True
37 | 
38 | 
39 | prefixer = test_utils.prefixer.Prefixer(
40 |     "python-bigquery-sqlalchemy", "tests/compliance"
41 | )
42 | 
43 | google.cloud.bigquery.dbapi.connection.Connection.rollback = lambda self: None
44 | 
45 | _where = re.compile(r"\s+WHERE\s+", re.IGNORECASE).search
46 | 
47 | # BigQuery requires delete statements to have where clauses. Other
48 | # databases don't and sqlalchemy doesn't include where clauses when
49 | # cleaning up test data.  So we add one when we see a delete without a
50 | # where clause when tearing down tests.  We only do this during tear
51 | # down, by inspecting the stack, because we don't want to hide bugs
52 | # outside of test house-keeping.
53 | 
54 | 
55 | def visit_delete(self, delete_stmt, *args, **kw):
56 |     text = super(sqlalchemy_bigquery.base.BigQueryCompiler, self).visit_delete(
57 |         delete_stmt, *args, **kw
58 |     )
59 | 
60 |     if not _where(text) and any(
61 |         "teardown" in f.name.lower() for f in traceback.extract_stack()
62 |     ):
63 |         text += " WHERE true"
64 | 
65 |     return text
66 | 
67 | 
68 | sqlalchemy_bigquery.base.BigQueryCompiler.visit_delete = visit_delete
69 | 
70 | 
71 | def pytest_sessionstart(session):
72 |     dataset_id = prefixer.create_prefix()
73 |     session.config.option.dburi = [f"bigquery:///{dataset_id}"]
74 |     with contextlib.closing(google.cloud.bigquery.Client()) as client:
75 |         client.create_dataset(dataset_id)
76 |     _pytest_sessionstart(session)
77 | 
78 | 
79 | def pytest_sessionfinish(session):
80 |     dataset_id = config.db.dialect.dataset_id
81 |     _pytest_sessionfinish(session)
82 |     with contextlib.closing(google.cloud.bigquery.Client()) as client:
83 |         client.delete_dataset(dataset_id, delete_contents=True, not_found_ok=True)
84 |         for dataset in client.list_datasets():
85 |             if prefixer.should_cleanup(dataset.dataset_id):
86 |                 client.delete_dataset(dataset, delete_contents=True, not_found_ok=True)
87 | 


--------------------------------------------------------------------------------
/tests/system/__init__.py:
--------------------------------------------------------------------------------
 1 | # Copyright (c) 2017 The sqlalchemy-bigquery Authors
 2 | #
 3 | # Permission is hereby granted, free of charge, to any person obtaining a copy of
 4 | # this software and associated documentation files (the "Software"), to deal in
 5 | # the Software without restriction, including without limitation the rights to
 6 | # use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 7 | # the Software, and to permit persons to whom the Software is furnished to do so,
 8 | # subject to the following conditions:
 9 | #
10 | # The above copyright notice and this permission notice shall be included in all
11 | # copies or substantial portions of the Software.
12 | #
13 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
15 | # FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
16 | # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
17 | # IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
18 | # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
19 | 


--------------------------------------------------------------------------------
/tests/system/conftest.py:
--------------------------------------------------------------------------------
  1 | # Copyright (c) 2021 The sqlalchemy-bigquery Authors
  2 | #
  3 | # Permission is hereby granted, free of charge, to any person obtaining a copy of
  4 | # this software and associated documentation files (the "Software"), to deal in
  5 | # the Software without restriction, including without limitation the rights to
  6 | # use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
  7 | # the Software, and to permit persons to whom the Software is furnished to do so,
  8 | # subject to the following conditions:
  9 | #
 10 | # The above copyright notice and this permission notice shall be included in all
 11 | # copies or substantial portions of the Software.
 12 | #
 13 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 14 | # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 15 | # FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 16 | # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 17 | # IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 18 | # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 19 | 
 20 | import pathlib
 21 | from typing import List
 22 | 
 23 | import pytest
 24 | import sqlalchemy
 25 | 
 26 | from google.api_core import exceptions
 27 | from google.cloud import bigquery
 28 | import test_utils.prefixer
 29 | import test_utils.retry
 30 | 
 31 | from sqlalchemy_bigquery import BigQueryDialect
 32 | 
 33 | prefixer = test_utils.prefixer.Prefixer("python-bigquery-sqlalchemy", "tests/system")
 34 | 
 35 | DATA_DIR = pathlib.Path(__file__).parent / "data"
 36 | 
 37 | 
 38 | def load_sample_data(
 39 |     full_table_id: str,
 40 |     bigquery_client: bigquery.Client,
 41 |     bigquery_schema: List[bigquery.SchemaField],
 42 |     filename: str = "sample.json",
 43 | ):
 44 |     sample_config = bigquery.LoadJobConfig()
 45 |     sample_config.destination_table_description = (
 46 |         "A sample table containing most data types."
 47 |     )
 48 |     sample_config.schema = bigquery_schema
 49 |     sample_config.time_partitioning = bigquery.TimePartitioning(field="timestamp")
 50 |     sample_config.clustering_fields = ["integer", "string"]
 51 |     sample_config.source_format = bigquery.SourceFormat.NEWLINE_DELIMITED_JSON
 52 |     sample_config.write_disposition = bigquery.WriteDisposition.WRITE_TRUNCATE
 53 | 
 54 |     with open(DATA_DIR / filename, "rb") as data_file:
 55 |         return bigquery_client.load_table_from_file(
 56 |             data_file,
 57 |             full_table_id,
 58 |             job_config=sample_config,
 59 |         )
 60 | 
 61 | 
 62 | @pytest.fixture(scope="session")
 63 | def bigquery_client():
 64 |     return bigquery.Client()
 65 | 
 66 | 
 67 | @pytest.fixture(scope="session")
 68 | def bigquery_schema(bigquery_client: bigquery.Client):
 69 |     return bigquery_client.schema_from_json(DATA_DIR / "schema.json")
 70 | 
 71 | 
 72 | @pytest.fixture(scope="session")
 73 | def bigquery_dataset(
 74 |     bigquery_client: bigquery.Client, bigquery_schema: List[bigquery.SchemaField]
 75 | ):
 76 |     project_id = bigquery_client.project
 77 |     dataset_id = prefixer.create_prefix()
 78 |     dataset = bigquery.Dataset(f"{project_id}.{dataset_id}")
 79 |     dataset = bigquery_client.create_dataset(dataset)
 80 |     sample_table_id = f"{project_id}.{dataset_id}.sample"
 81 |     job1 = load_sample_data(sample_table_id, bigquery_client, bigquery_schema)
 82 |     job1.result()
 83 |     one_row_table_id = f"{project_id}.{dataset_id}.sample_one_row"
 84 |     job2 = load_sample_data(
 85 |         one_row_table_id,
 86 |         bigquery_client,
 87 |         bigquery_schema,
 88 |         filename="sample_one_row.json",
 89 |     )
 90 |     job2.result()
 91 |     view = bigquery.Table(
 92 |         f"{project_id}.{dataset_id}.sample_view",
 93 |     )
 94 |     view.view_query = f"SELECT string FROM `{dataset_id}.sample`"
 95 |     bigquery_client.create_table(view)
 96 |     yield dataset_id
 97 |     bigquery_client.delete_dataset(dataset_id, delete_contents=True)
 98 | 
 99 | 
100 | @pytest.fixture(scope="session", autouse=True)
101 | def bigquery_empty_table(
102 |     bigquery_dataset: str,
103 |     bigquery_client: bigquery.Client,
104 |     bigquery_schema: List[bigquery.SchemaField],
105 | ):
106 |     project_id = bigquery_client.project
107 |     # Create new table in its own dataset.
108 |     dataset_id = bigquery_dataset
109 |     table_id = f"{project_id}.{dataset_id}.sample_dml_empty"
110 |     empty_table = bigquery.Table(table_id, schema=bigquery_schema)
111 |     bigquery_client.create_table(empty_table)
112 |     return table_id
113 | 
114 | 
115 | @pytest.fixture(scope="session")
116 | def bigquery_regional_dataset(bigquery_client, bigquery_schema):
117 |     project_id = bigquery_client.project
118 |     dataset_id = prefixer.create_prefix()
119 |     dataset = bigquery.Dataset(f"{project_id}.{dataset_id}")
120 |     dataset.location = "asia-northeast1"
121 |     dataset = bigquery_client.create_dataset(dataset)
122 |     sample_table_id = f"{project_id}.{dataset_id}.sample_one_row"
123 |     job = load_sample_data(
124 |         sample_table_id,
125 |         bigquery_client,
126 |         bigquery_schema,
127 |         filename="sample_one_row.json",
128 |     )
129 |     job.result()
130 |     yield dataset_id
131 |     bigquery_client.delete_dataset(dataset_id, delete_contents=True)
132 | 
133 | 
134 | @pytest.fixture(autouse=True)
135 | def cleanup_extra_tables(bigquery_client, bigquery_dataset):
136 |     common = "sample", "sample_one_row", "sample_view", "sample_dml_empty"
137 |     # Back-end may raise 403 for a dataset not ready yet.
138 |     retry_403 = test_utils.retry.RetryErrors(exceptions.Forbidden)
139 |     tables = retry_403(bigquery_client.list_tables)(bigquery_dataset)
140 |     for table in tables:
141 |         if table.table_id not in common:
142 |             bigquery_client.delete_table(table)
143 | 
144 | 
145 | @pytest.fixture(scope="session", autouse=True)
146 | def cleanup_datasets(bigquery_client: bigquery.Client):
147 |     for dataset in bigquery_client.list_datasets():
148 |         if prefixer.should_cleanup(dataset.dataset_id):
149 |             bigquery_client.delete_dataset(
150 |                 dataset, delete_contents=True, not_found_ok=True
151 |             )
152 | 
153 | 
154 | @pytest.fixture(scope="session")
155 | def engine():
156 |     engine = sqlalchemy.create_engine("bigquery://", echo=True)
157 |     return engine
158 | 
159 | 
160 | @pytest.fixture(scope="session")
161 | def dialect():
162 |     return BigQueryDialect()
163 | 
164 | 
165 | @pytest.fixture
166 | def metadata():
167 |     return sqlalchemy.MetaData()
168 | 


--------------------------------------------------------------------------------
/tests/system/data/sample_one_row.json:
--------------------------------------------------------------------------------
1 | {"integer":"588","timestamp":"1381404436","string":"W 52 St & 11 Ave","float":"40.76727216","numeric":"40.76727216","boolean":"false","date":"2013-10-10","datetime":"2013-10-10T11:27:16","time":"11:27:16","bytes":"7w==","record":{"name": "John Doe","age":"100"},"nested_record":{"record":{"name": "John Doe 2","age":"200"}},"array":[1,2,3]}


--------------------------------------------------------------------------------
/tests/system/data/schema.json:
--------------------------------------------------------------------------------
 1 | [{
 2 |   "mode": "NULLABLE",
 3 |   "name": "integer",
 4 |   "type": "INTEGER"
 5 | },
 6 | {
 7 |   "mode": "NULLABLE",
 8 |   "name": "timestamp",
 9 |   "type": "TIMESTAMP"
10 | },
11 | {
12 |   "mode": "NULLABLE",
13 |   "name": "string",
14 |   "type": "STRING"
15 | },
16 | {
17 |   "mode": "NULLABLE",
18 |   "name": "float",
19 |   "type": "FLOAT"
20 | },
21 | {
22 |   "mode": "NULLABLE",
23 |   "name": "numeric",
24 |   "type": "NUMERIC"
25 | },
26 | {
27 |   "mode": "NULLABLE",
28 |   "name": "boolean",
29 |   "type": "BOOLEAN"
30 | },
31 | {
32 |   "mode": "NULLABLE",
33 |   "name": "date",
34 |   "type": "DATE"
35 | },
36 | {
37 |   "mode": "NULLABLE",
38 |   "name": "datetime",
39 |   "type": "DATETIME"
40 | },
41 | {
42 |   "mode": "NULLABLE",
43 |   "name": "time",
44 |   "type": "TIME"
45 | },
46 | {
47 |   "mode": "NULLABLE",
48 |   "name": "bytes",
49 |   "type": "BYTES"
50 | },
51 | {
52 |   "mode": "NULLABLE",
53 |   "name": "record",
54 |   "type": "RECORD",
55 |   "description": "In Standard SQL this data type is a STRUCT<name STRING, age INT64>.",
56 |   "fields": [
57 |     {
58 |       "mode": "NULLABLE",
59 |       "name": "name",
60 |       "type": "STRING"
61 |     },
62 |     {
63 |       "mode": "NULLABLE",
64 |       "name": "age",
65 |       "type": "INTEGER"
66 |     }
67 |   ]
68 | },
69 | {
70 |   "mode": "NULLABLE",
71 |   "name": "nested_record",
72 |   "type": "RECORD",
73 |   "fields": [
74 |     {
75 |       "mode": "NULLABLE",
76 |       "name": "record",
77 |       "type": "RECORD",
78 |       "fields": [
79 |         {
80 |           "mode": "NULLABLE",
81 |           "name": "name",
82 |           "type": "STRING"
83 |         },
84 |         {
85 |           "mode": "NULLABLE",
86 |           "name": "age",
87 |           "type": "INTEGER"
88 |         }
89 |       ]
90 |     }
91 |   ]
92 | },
93 | {
94 |   "mode": "REPEATED",
95 |   "name": "array",
96 |   "type": "INTEGER"
97 | }]


--------------------------------------------------------------------------------
/tests/system/test__struct.py:
--------------------------------------------------------------------------------
  1 | # Copyright (c) 2021 The sqlalchemy-bigquery Authors
  2 | #
  3 | # Permission is hereby granted, free of charge, to any person obtaining a copy of
  4 | # this software and associated documentation files (the "Software"), to deal in
  5 | # the Software without restriction, including without limitation the rights to
  6 | # use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
  7 | # the Software, and to permit persons to whom the Software is furnished to do so,
  8 | # subject to the following conditions:
  9 | #
 10 | # The above copyright notice and this permission notice shall be included in all
 11 | # copies or substantial portions of the Software.
 12 | #
 13 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 14 | # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 15 | # FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 16 | # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 17 | # IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 18 | # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 19 | 
 20 | import datetime
 21 | 
 22 | import packaging.version
 23 | import pytest
 24 | import sqlalchemy
 25 | 
 26 | import sqlalchemy_bigquery
 27 | 
 28 | 
 29 | def test_struct(engine, bigquery_dataset, metadata):
 30 |     conn = engine.connect()
 31 |     table = sqlalchemy.Table(
 32 |         f"{bigquery_dataset}.test_struct",
 33 |         metadata,
 34 |         sqlalchemy.Column(
 35 |             "person",
 36 |             sqlalchemy_bigquery.STRUCT(
 37 |                 name=sqlalchemy.String,
 38 |                 children=sqlalchemy.ARRAY(
 39 |                     sqlalchemy_bigquery.STRUCT(
 40 |                         name=sqlalchemy.String, bdate=sqlalchemy.DATE
 41 |                     )
 42 |                 ),
 43 |             ),
 44 |         ),
 45 |     )
 46 |     metadata.create_all(engine)
 47 | 
 48 |     conn.execute(
 49 |         table.insert().values(
 50 |             person=dict(
 51 |                 name="bob",
 52 |                 children=[dict(name="billy", bdate=datetime.date(2020, 1, 1))],
 53 |             )
 54 |         )
 55 |     )
 56 | 
 57 |     assert list(conn.execute(sqlalchemy.select(table))) == [
 58 |         (
 59 |             {
 60 |                 "name": "bob",
 61 |                 "children": [{"name": "billy", "bdate": datetime.date(2020, 1, 1)}],
 62 |             },
 63 |         )
 64 |     ]
 65 |     assert list(conn.execute(sqlalchemy.select(table.c.person.NAME))) == [("bob",)]
 66 |     assert list(conn.execute(sqlalchemy.select(table.c.person.children[0]))) == [
 67 |         ({"name": "billy", "bdate": datetime.date(2020, 1, 1)},)
 68 |     ]
 69 |     assert list(conn.execute(sqlalchemy.select(table.c.person.children[0].bdate))) == [
 70 |         (datetime.date(2020, 1, 1),)
 71 |     ]
 72 |     assert list(
 73 |         conn.execute(
 74 |             sqlalchemy.select(table).where(table.c.person.children[0].NAME == "billy")
 75 |         )
 76 |     ) == [
 77 |         (
 78 |             {
 79 |                 "name": "bob",
 80 |                 "children": [{"name": "billy", "bdate": datetime.date(2020, 1, 1)}],
 81 |             },
 82 |         )
 83 |     ]
 84 |     assert (
 85 |         list(
 86 |             conn.execute(
 87 |                 sqlalchemy.select(table).where(
 88 |                     table.c.person.children[0].NAME == "sally"
 89 |                 )
 90 |             )
 91 |         )
 92 |         == []
 93 |     )
 94 | 
 95 | 
 96 | def test_complex_literals_pr_67(engine, bigquery_dataset, metadata):
 97 |     # https://github.com/googleapis/python-bigquery-sqlalchemy/pull/67
 98 | 
 99 |     # Simple select example:
100 | 
101 |     table_name = f"{bigquery_dataset}.test_comples_literals_pr_67"
102 |     with engine.connect() as conn:
103 |         conn.execute(
104 |             sqlalchemy.text(
105 |                 f"""
106 |             create table {table_name} as (
107 |                 select 'a' as id,
108 |                 struct(1 as x__count, 2 as y__count, 3 as z__count) as dimensions
109 |                 )
110 |             """
111 |             )
112 |         )
113 | 
114 |     table = sqlalchemy.Table(table_name, metadata, autoload_with=engine)
115 | 
116 |     got = str(
117 |         sqlalchemy.select((table.c.dimensions.x__count + 5).label("c")).compile(engine)
118 |     )
119 |     want = (
120 |         f"SELECT (`{table_name}`.`dimensions`.x__count) + %(param_1:INT64)s AS `c` \n"
121 |         f"FROM `{table_name}`"
122 |     )
123 | 
124 |     assert got == want
125 | 
126 |     # Hopefully, "Example doing a pivot" is addressed by
127 |     # test_unnest_and_struct_access_233 below :)
128 | 
129 | 
130 | @pytest.mark.skipif(
131 |     packaging.version.parse(sqlalchemy.__version__) < packaging.version.parse("1.4"),
132 |     reason="unnest (and other table-valued-function) support required version 1.4",
133 | )
134 | def test_unnest_and_struct_access_233(engine, bigquery_dataset, metadata):
135 |     # https://github.com/googleapis/python-bigquery-sqlalchemy/issues/233
136 | 
137 |     from sqlalchemy import Table, select, Column, ARRAY, String, func
138 |     from sqlalchemy.orm import sessionmaker
139 |     from sqlalchemy_bigquery import STRUCT
140 | 
141 |     conn = engine.connect()
142 | 
143 |     mock_table = Table(f"{bigquery_dataset}.Mock", metadata, Column("mock_id", String))
144 |     another_mock_table = Table(
145 |         f"{bigquery_dataset}.AnotherMock",
146 |         metadata,
147 |         Column("objects", ARRAY(STRUCT(object_id=String))),
148 |     )
149 |     metadata.create_all(engine)
150 | 
151 |     conn.execute(
152 |         mock_table.insert(),
153 |         [
154 |             dict(mock_id="x"),
155 |             dict(mock_id="y"),
156 |             dict(mock_id="z"),
157 |         ],
158 |     )
159 |     conn.execute(
160 |         another_mock_table.insert(),
161 |         dict(objects=[dict(object_id="x"), dict(object_id="y"), dict(object_id="q")]),
162 |     )
163 | 
164 |     subquery = select(
165 |         func.unnest(another_mock_table.c.objects).alias("another_mock_objects").column
166 |     ).subquery()
167 | 
168 |     join = mock_table.join(
169 |         subquery,
170 |         subquery.c.another_mock_objects["object_id"] == mock_table.c.mock_id,
171 |     )
172 | 
173 |     query = select(mock_table).select_from(join)
174 | 
175 |     got = str(query.compile(engine))
176 |     want = (
177 |         f"SELECT `{bigquery_dataset}.Mock`.`mock_id` \n"
178 |         f"FROM `{bigquery_dataset}.Mock` "
179 |         f"JOIN ("
180 |         f"SELECT `another_mock_objects` \n"
181 |         f"FROM "
182 |         f"`{bigquery_dataset}.AnotherMock` `{bigquery_dataset}.AnotherMock_1`, "
183 |         f"unnest(`{bigquery_dataset}.AnotherMock_1`.`objects`)"
184 |         f" AS `another_mock_objects`"
185 |         f") AS `anon_1` "
186 |         f"ON "
187 |         f"(`anon_1`.`another_mock_objects`.object_id) = "
188 |         f"`{bigquery_dataset}.Mock`.`mock_id`"
189 |     )
190 |     assert got == want
191 | 
192 |     Session = sessionmaker(bind=engine)
193 |     session = Session()
194 |     results = sorted(session.execute(query))
195 | 
196 |     assert results == [("x",), ("y",)]
197 | 


--------------------------------------------------------------------------------
/tests/system/test_alembic.py:
--------------------------------------------------------------------------------
  1 | # Copyright (c) 2021 The sqlalchemy-bigquery Authors
  2 | #
  3 | # Permission is hereby granted, free of charge, to any person obtaining a copy of
  4 | # this software and associated documentation files (the "Software"), to deal in
  5 | # the Software without restriction, including without limitation the rights to
  6 | # use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
  7 | # the Software, and to permit persons to whom the Software is furnished to do so,
  8 | # subject to the following conditions:
  9 | #
 10 | # The above copyright notice and this permission notice shall be included in all
 11 | # copies or substantial portions of the Software.
 12 | #
 13 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 14 | # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 15 | # FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 16 | # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 17 | # IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 18 | # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 19 | 
 20 | import contextlib
 21 | 
 22 | import pytest
 23 | from sqlalchemy import Column, DateTime, Integer, String, Numeric
 24 | 
 25 | import google.api_core.exceptions
 26 | from google.cloud.bigquery import SchemaField, TimePartitioning
 27 | 
 28 | alembic = pytest.importorskip("alembic")
 29 | 
 30 | 
 31 | @pytest.fixture
 32 | def alembic_table(bigquery_dataset, bigquery_client):
 33 |     import sqlalchemy
 34 |     import alembic.migration
 35 |     import alembic.operations
 36 | 
 37 |     def get_table(table_name, data="table"):
 38 |         try:
 39 |             table_id = f"{bigquery_dataset}.{table_name}"
 40 |             if data == "rows":
 41 |                 return [dict(r) for r in bigquery_client.list_rows(table_id)]
 42 |             else:
 43 |                 table = bigquery_client.get_table(table_id)
 44 |                 if data == "table":
 45 |                     return table
 46 |                 elif data == "schema":
 47 |                     return table.schema
 48 |                 else:
 49 |                     raise ValueError(data)
 50 |         except google.api_core.exceptions.NotFound:
 51 |             return None
 52 | 
 53 |     engine = sqlalchemy.create_engine(f"bigquery:///{bigquery_dataset}")
 54 |     with contextlib.closing(engine.connect()) as conn:
 55 |         migration_context = alembic.migration.MigrationContext.configure(conn, {})
 56 |         with alembic.operations.Operations.context(migration_context):
 57 |             yield get_table
 58 | 
 59 | 
 60 | def test_alembic_scenario(alembic_table):
 61 |     """
 62 |     Exercise all of the operations we support.
 63 | 
 64 |     It's a little awkward because we have to avoid doing too many
 65 |     operations on the same table to avoid tripping over limits on
 66 |     table mods within a short time.
 67 |     """
 68 |     from alembic import op
 69 |     from sqlalchemy_bigquery.base import SqlalchemyBigqueryImpl
 70 | 
 71 |     # Register the BigQuery Implementation to test the customized methods.
 72 |     op.implementation_for(SqlalchemyBigqueryImpl)
 73 | 
 74 |     assert alembic_table("account") is None
 75 | 
 76 |     account = op.create_table(
 77 |         "account",
 78 |         Column("id", Integer, nullable=False),
 79 |         Column("name", String(50), nullable=False, comment="The name"),
 80 |         Column("description", String(200)),
 81 |     )
 82 |     assert alembic_table("account", "schema") == [
 83 |         SchemaField("id", "INTEGER", "REQUIRED"),
 84 |         SchemaField("name", "STRING(50)", "REQUIRED", description="The name"),
 85 |         SchemaField("description", "STRING(200)"),
 86 |     ]
 87 | 
 88 |     op.bulk_insert(
 89 |         account,
 90 |         [
 91 |             dict(id=1, name="home", description="the home account"),
 92 |             dict(id=2, name="operations", description="the ops account"),
 93 |             dict(id=3, name="savings", description=None),
 94 |         ],
 95 |     )
 96 | 
 97 |     assert alembic_table("account", "rows") == [
 98 |         {"description": "the home account", "id": 1, "name": "home"},
 99 |         {"description": "the ops account", "id": 2, "name": "operations"},
100 |         {"description": None, "id": 3, "name": "savings"},
101 |     ]
102 | 
103 |     op.add_column(
104 |         "account", Column("last_transaction_date", DateTime, comment="when updated")
105 |     )
106 | 
107 |     # Tests customized visit_column_name()
108 |     op.alter_column("account", "name", new_column_name="friendly_name")
109 |     assert alembic_table("account", "schema") == [
110 |         SchemaField("id", "INTEGER", "REQUIRED"),
111 |         SchemaField("friendly_name", "STRING(50)", "REQUIRED", description="The name"),
112 |         SchemaField("description", "STRING(200)"),
113 |         SchemaField("last_transaction_date", "DATETIME", description="when updated"),
114 |     ]
115 | 
116 |     op.create_table(
117 |         "account_w_comment",
118 |         Column("id", Integer, nullable=False),
119 |         Column("name", String(50), nullable=False, comment="The name"),
120 |         Column("description", String(200)),
121 |         comment="This table has comments",
122 |     )
123 |     assert alembic_table("account_w_comment").description == "This table has comments"
124 |     op.drop_table_comment("account_w_comment")
125 |     assert alembic_table("account_w_comment").description is None
126 | 
127 |     op.drop_column("account_w_comment", "description")
128 |     assert alembic_table("account_w_comment", "schema") == [
129 |         SchemaField("id", "INTEGER", "REQUIRED"),
130 |         SchemaField("name", "STRING(50)", "REQUIRED", description="The name"),
131 |     ]
132 | 
133 |     op.drop_table("account_w_comment")
134 |     assert alembic_table("account_w_comment") is None
135 | 
136 |     op.rename_table("account", "accounts")
137 |     assert alembic_table("account") is None
138 |     assert alembic_table("accounts", "schema") == [
139 |         SchemaField("id", "INTEGER", "REQUIRED"),
140 |         SchemaField("friendly_name", "STRING(50)", "REQUIRED", description="The name"),
141 |         SchemaField("description", "STRING(200)"),
142 |         SchemaField("last_transaction_date", "DATETIME", description="when updated"),
143 |     ]
144 |     op.drop_table("accounts")
145 |     assert alembic_table("accounts") is None
146 | 
147 |     op.create_table(
148 |         "transactions",
149 |         Column("account", Integer, nullable=False),
150 |         Column("transaction_time", DateTime(), nullable=False),
151 |         Column("amount", Numeric(11, 2), nullable=False),
152 |         bigquery_time_partitioning=TimePartitioning(field="transaction_time"),
153 |     )
154 | 
155 |     op.alter_column("transactions", "amount", nullable=True)
156 |     assert alembic_table("transactions", "schema") == [
157 |         SchemaField("account", "INTEGER", "REQUIRED"),
158 |         SchemaField("transaction_time", "DATETIME", "REQUIRED"),
159 |         SchemaField("amount", "NUMERIC(11, 2)"),
160 |     ]
161 | 
162 |     op.create_table_comment("transactions", "Transaction log")
163 |     assert alembic_table("transactions").description == "Transaction log"
164 | 
165 |     op.drop_table("transactions")
166 | 
167 |     # Another thing we can do is alter the datatype of a nullable column,
168 |     # if allowed by BigQuery's type coercion rules
169 |     op.create_table("identifiers", Column("id", Integer))
170 | 
171 |     # Tests customized visit_column_type()
172 |     op.alter_column("identifiers", "id", type_=Numeric)
173 |     assert alembic_table("identifiers", "schema") == [SchemaField("id", "NUMERIC")]
174 | 
175 |     op.drop_table("identifiers")
176 | 


--------------------------------------------------------------------------------
/tests/system/test_helpers.py:
--------------------------------------------------------------------------------
  1 | # Copyright 2021 The sqlalchemy-bigquery Authors
  2 | #
  3 | # Use of this source code is governed by an MIT-style
  4 | # license that can be found in the LICENSE file or at
  5 | # https://opensource.org/licenses/MIT.
  6 | 
  7 | import base64
  8 | import os
  9 | import json
 10 | 
 11 | import pytest
 12 | 
 13 | 
 14 | @pytest.fixture(scope="session")
 15 | def module_under_test():
 16 |     from sqlalchemy_bigquery import _helpers
 17 | 
 18 |     return _helpers
 19 | 
 20 | 
 21 | @pytest.fixture
 22 | def credentials_path():
 23 |     if "GOOGLE_APPLICATION_CREDENTIALS" not in os.environ:
 24 |         pytest.skip("GOOGLE_APPLICATION_CREDENTIALS must be set")
 25 |     return os.environ["GOOGLE_APPLICATION_CREDENTIALS"]
 26 | 
 27 | 
 28 | @pytest.fixture
 29 | def credentials_info(credentials_path):
 30 |     with open(credentials_path) as credentials_file:
 31 |         return json.load(credentials_file)
 32 | 
 33 | 
 34 | @pytest.fixture
 35 | def credentials_base64(credentials_path):
 36 |     with open(credentials_path) as credentials_file:
 37 |         return base64.b64encode(credentials_file.read().encode()).decode()
 38 | 
 39 | 
 40 | def test_create_bigquery_client_with_credentials_path(
 41 |     module_under_test, credentials_path, credentials_info
 42 | ):
 43 |     bqclient = module_under_test.create_bigquery_client(
 44 |         credentials_path=credentials_path
 45 |     )
 46 |     assert bqclient.project == credentials_info["project_id"]
 47 | 
 48 | 
 49 | def test_create_bigquery_client_with_credentials_path_respects_project(
 50 |     module_under_test, credentials_path
 51 | ):
 52 |     """Test that project_id is used, even when there is a default project.
 53 | 
 54 |     https://github.com/googleapis/python-bigquery-sqlalchemy/issues/48
 55 |     """
 56 |     bqclient = module_under_test.create_bigquery_client(
 57 |         credentials_path=credentials_path,
 58 |         project_id="connection-url-project",
 59 |     )
 60 |     assert bqclient.project == "connection-url-project"
 61 | 
 62 | 
 63 | def test_create_bigquery_client_with_credentials_info(
 64 |     module_under_test, credentials_info
 65 | ):
 66 |     bqclient = module_under_test.create_bigquery_client(
 67 |         credentials_info=credentials_info
 68 |     )
 69 |     assert bqclient.project == credentials_info["project_id"]
 70 | 
 71 | 
 72 | def test_create_bigquery_client_with_credentials_info_respects_project(
 73 |     module_under_test, credentials_info
 74 | ):
 75 |     """Test that project_id is used, even when there is a default project.
 76 | 
 77 |     https://github.com/googleapis/python-bigquery-sqlalchemy/issues/48
 78 |     """
 79 |     bqclient = module_under_test.create_bigquery_client(
 80 |         credentials_info=credentials_info,
 81 |         project_id="connection-url-project",
 82 |     )
 83 |     assert bqclient.project == "connection-url-project"
 84 | 
 85 | 
 86 | def test_create_bigquery_client_with_credentials_base64(
 87 |     module_under_test, credentials_base64, credentials_info
 88 | ):
 89 |     bqclient = module_under_test.create_bigquery_client(
 90 |         credentials_base64=credentials_base64
 91 |     )
 92 |     assert bqclient.project == credentials_info["project_id"]
 93 | 
 94 | 
 95 | def test_create_bigquery_client_with_credentials_base64_respects_project(
 96 |     module_under_test, credentials_base64
 97 | ):
 98 |     """Test that project_id is used, even when there is a default project.
 99 | 
100 |     https://github.com/googleapis/python-bigquery-sqlalchemy/issues/48
101 |     """
102 |     bqclient = module_under_test.create_bigquery_client(
103 |         credentials_base64=credentials_base64,
104 |         project_id="connection-url-project",
105 |     )
106 |     assert bqclient.project == "connection-url-project"
107 | 
108 | 
109 | def test_create_bigquery_client_with_user_agent(module_under_test):
110 |     user_agent = "test_user_agent"
111 | 
112 |     bqclient = module_under_test.create_bigquery_client(user_agent=user_agent)
113 | 
114 |     assert bqclient._connection._client_info.user_agent == user_agent
115 | 


--------------------------------------------------------------------------------
/tests/system/test_sqlalchemy_bigquery_remote.py:
--------------------------------------------------------------------------------
  1 | # Copyright (c) 2017 The sqlalchemy-bigquery Authors
  2 | #
  3 | # Permission is hereby granted, free of charge, to any person obtaining a copy of
  4 | # this software and associated documentation files (the "Software"), to deal in
  5 | # the Software without restriction, including without limitation the rights to
  6 | # use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
  7 | # the Software, and to permit persons to whom the Software is furnished to do so,
  8 | # subject to the following conditions:
  9 | #
 10 | # The above copyright notice and this permission notice shall be included in all
 11 | # copies or substantial portions of the Software.
 12 | #
 13 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 14 | # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 15 | # FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 16 | # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 17 | # IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 18 | # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 19 | 
 20 | # -*- coding: utf-8 -*-
 21 | 
 22 | from sqlalchemy.engine import create_engine
 23 | from sqlalchemy.exc import DatabaseError
 24 | from sqlalchemy.schema import Table, MetaData
 25 | import pytest
 26 | import sqlalchemy
 27 | import google.api_core.exceptions as core_exceptions
 28 | 
 29 | 
 30 | EXPECTED_STATES = ["AL", "CA", "FL", "KY"]
 31 | 
 32 | REMOTE_TESTS = [
 33 |     ("bigquery-public-data", "bigquery-public-data.usa_names.usa_1910_2013"),
 34 |     ("bigquery-public-data", "usa_names.usa_1910_2013"),
 35 |     ("bigquery-public-data/usa_names", "bigquery-public-data.usa_names.usa_1910_2013"),
 36 |     ("bigquery-public-data/usa_names", "usa_1910_2013"),
 37 |     ("bigquery-public-data/usa_names", "usa_names.usa_1910_2013"),
 38 | ]
 39 | 
 40 | 
 41 | @pytest.fixture(scope="session")
 42 | def engine_using_remote_dataset(bigquery_client):
 43 |     engine = create_engine(
 44 |         "bigquery://bigquery-public-data/usa_names",
 45 |         billing_project_id=bigquery_client.project,
 46 |         echo=True,
 47 |     )
 48 |     return engine
 49 | 
 50 | 
 51 | def test_remote_tables_list(engine_using_remote_dataset):
 52 |     tables = sqlalchemy.inspect(engine_using_remote_dataset).get_table_names()
 53 |     assert "usa_1910_2013" in tables
 54 | 
 55 | 
 56 | @pytest.mark.parametrize(
 57 |     ["urlpath", "table_name"],
 58 |     REMOTE_TESTS,
 59 |     ids=[f"test_engine_remote_sql_{x}" for x in range(len(REMOTE_TESTS))],
 60 | )
 61 | def test_engine_remote_sql(bigquery_client, urlpath, table_name):
 62 |     engine = create_engine(
 63 |         f"bigquery://{urlpath}", billing_project_id=bigquery_client.project, echo=True
 64 |     )
 65 |     with engine.connect() as conn:
 66 |         rows = conn.execute(
 67 |             sqlalchemy.text(f"SELECT DISTINCT(state) FROM `{table_name}`")
 68 |         ).fetchall()
 69 |         states = set(map(lambda row: row[0], rows))
 70 |         assert set(EXPECTED_STATES).issubset(states)
 71 | 
 72 | 
 73 | @pytest.mark.parametrize(
 74 |     ["urlpath", "table_name"],
 75 |     REMOTE_TESTS,
 76 |     ids=[f"test_engine_remote_table_{x}" for x in range(len(REMOTE_TESTS))],
 77 | )
 78 | def test_engine_remote_table(bigquery_client, urlpath, table_name):
 79 |     engine = create_engine(
 80 |         f"bigquery://{urlpath}", billing_project_id=bigquery_client.project, echo=True
 81 |     )
 82 |     with engine.connect() as conn:
 83 |         table = Table(table_name, MetaData(), autoload_with=engine)
 84 |         prepared = sqlalchemy.select(
 85 |             sqlalchemy.distinct(table.c.state)
 86 |         ).set_label_style(sqlalchemy.LABEL_STYLE_TABLENAME_PLUS_COL)
 87 |         rows = conn.execute(prepared).fetchall()
 88 |         states = set(map(lambda row: row[0], rows))
 89 |         assert set(EXPECTED_STATES).issubset(states)
 90 | 
 91 | 
 92 | @pytest.mark.parametrize(
 93 |     ["urlpath", "table_name"],
 94 |     REMOTE_TESTS,
 95 |     ids=[f"test_engine_remote_table_fail_{x}" for x in range(len(REMOTE_TESTS))],
 96 | )
 97 | def test_engine_remote_table_fail(urlpath, table_name):
 98 |     engine = create_engine(f"bigquery://{urlpath}", echo=True)
 99 |     with pytest.raises(
100 |         (DatabaseError, core_exceptions.Forbidden), match="Access Denied"
101 |     ):
102 |         with engine.connect() as conn:
103 |             table = Table(table_name, MetaData(), autoload_with=engine)
104 |             prepared = sqlalchemy.select(
105 |                 sqlalchemy.distinct(table.c.state)
106 |             ).set_label_style(sqlalchemy.LABEL_STYLE_TABLENAME_PLUS_COL)
107 |             conn.execute(prepared).fetchall()
108 | 


--------------------------------------------------------------------------------
/tests/unit/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/googleapis/python-bigquery-sqlalchemy/d0347202c5fb144f960558d9022b7a22af6ce3f7/tests/unit/__init__.py


--------------------------------------------------------------------------------
/tests/unit/conftest.py:
--------------------------------------------------------------------------------
  1 | # Copyright (c) 2021 The sqlalchemy-bigquery Authors
  2 | #
  3 | # Permission is hereby granted, free of charge, to any person obtaining a copy of
  4 | # this software and associated documentation files (the "Software"), to deal in
  5 | # the Software without restriction, including without limitation the rights to
  6 | # use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
  7 | # the Software, and to permit persons to whom the Software is furnished to do so,
  8 | # subject to the following conditions:
  9 | #
 10 | # The above copyright notice and this permission notice shall be included in all
 11 | # copies or substantial portions of the Software.
 12 | #
 13 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 14 | # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 15 | # FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 16 | # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 17 | # IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 18 | # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 19 | 
 20 | import contextlib
 21 | import mock
 22 | import sqlite3
 23 | 
 24 | import packaging.version
 25 | import pytest
 26 | import sqlalchemy
 27 | 
 28 | from sqlalchemy_bigquery.base import BigQueryDDLCompiler, BigQueryDialect
 29 | 
 30 | from . import fauxdbi
 31 | 
 32 | sqlalchemy_version = packaging.version.parse(sqlalchemy.__version__)
 33 | sqlalchemy_before_2_0 = pytest.mark.skipif(
 34 |     sqlalchemy_version >= packaging.version.parse("2.0"),
 35 |     reason="requires sqlalchemy 1.3 or lower",
 36 | )
 37 | sqlalchemy_2_0_or_higher = pytest.mark.skipif(
 38 |     sqlalchemy_version < packaging.version.parse("2.0"),
 39 |     reason="requires sqlalchemy 1.4 or higher",
 40 | )
 41 | 
 42 | 
 43 | @pytest.fixture()
 44 | def faux_conn():
 45 |     test_data = dict(execute=[])
 46 |     connection = sqlite3.connect(":memory:")
 47 | 
 48 |     def factory(*args, **kw):
 49 |         conn = fauxdbi.Connection(connection, test_data, *args, **kw)
 50 |         return conn
 51 | 
 52 |     with mock.patch("google.cloud.bigquery.dbapi.connection.Connection", factory):
 53 |         # We want to bypass client creation. We don't need it and it requires creds.
 54 |         with mock.patch(
 55 |             "sqlalchemy_bigquery._helpers.create_bigquery_client", fauxdbi.FauxClient
 56 |         ):
 57 |             with mock.patch("google.auth.default", return_value=("authdb", "authproj")):
 58 |                 engine = sqlalchemy.create_engine("bigquery://myproject/mydataset")
 59 |                 conn = engine.connect()
 60 |                 conn.test_data = test_data
 61 | 
 62 |                 def ex(sql, *args, **kw):
 63 |                     with contextlib.closing(
 64 |                         conn.connection.connection.connection.cursor()
 65 |                     ) as cursor:
 66 |                         cursor.execute(sql, *args, **kw)
 67 | 
 68 |                 conn.ex = ex
 69 | 
 70 |                 ex("create table comments" " (key string primary key, comment string)")
 71 | 
 72 |                 yield conn
 73 |                 conn.close()
 74 | 
 75 | 
 76 | @pytest.fixture()
 77 | def last_query(faux_conn):
 78 |     def last_query(sql, params=None, offset=1):
 79 |         actual_sql, actual_params = faux_conn.test_data["execute"][-offset]
 80 |         assert actual_sql == sql
 81 |         if params is not None:
 82 |             assert actual_params == params
 83 | 
 84 |     return last_query
 85 | 
 86 | 
 87 | @pytest.fixture()
 88 | def metadata():
 89 |     return sqlalchemy.MetaData()
 90 | 
 91 | 
 92 | @pytest.fixture()
 93 | def ddl_compiler():
 94 |     return BigQueryDDLCompiler(BigQueryDialect(), None)
 95 | 
 96 | 
 97 | def setup_table(connection, name, *columns, initial_data=(), **kw):
 98 |     metadata = sqlalchemy.MetaData()
 99 |     table = sqlalchemy.Table(name, metadata, *columns, **kw)
100 |     metadata.create_all(connection.engine)
101 |     if initial_data:
102 |         connection.execute(table.insert(), initial_data)
103 |     return table
104 | 


--------------------------------------------------------------------------------
/tests/unit/test__struct.py:
--------------------------------------------------------------------------------
  1 | # Copyright (c) 2017 The sqlalchemy-bigquery Authors
  2 | #
  3 | # Permission is hereby granted, free of charge, to any person obtaining a copy of
  4 | # this software and associated documentation files (the "Software"), to deal in
  5 | # the Software without restriction, including without limitation the rights to
  6 | # use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
  7 | # the Software, and to permit persons to whom the Software is furnished to do so,
  8 | # subject to the following conditions:
  9 | #
 10 | # The above copyright notice and this permission notice shall be included in all
 11 | # copies or substantial portions of the Software.
 12 | #
 13 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 14 | # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 15 | # FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 16 | # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 17 | # IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 18 | # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 19 | import datetime
 20 | 
 21 | import pytest
 22 | 
 23 | import sqlalchemy
 24 | 
 25 | 
 26 | def _test_struct():
 27 |     from sqlalchemy_bigquery import STRUCT
 28 | 
 29 |     return STRUCT(
 30 |         name=sqlalchemy.String,
 31 |         children=sqlalchemy.ARRAY(
 32 |             STRUCT(name=sqlalchemy.String, bdate=sqlalchemy.DATE)
 33 |         ),
 34 |     )
 35 | 
 36 | 
 37 | def test_struct_colspec():
 38 |     assert _test_struct().get_col_spec() == (
 39 |         "STRUCT<name STRING, children ARRAY<STRUCT<name STRING, bdate DATE>>>"
 40 |     )
 41 | 
 42 | 
 43 | def test_struct_repr():
 44 |     assert repr(_test_struct()) == (
 45 |         "STRUCT(name=String(), children=ARRAY(STRUCT(name=String(), bdate=DATE())))"
 46 |     )
 47 | 
 48 | 
 49 | def test_bind_processor():
 50 |     assert _test_struct().bind_processor(None) is dict
 51 | 
 52 | 
 53 | def _col():
 54 |     return sqlalchemy.Table(
 55 |         "t",
 56 |         sqlalchemy.MetaData(),
 57 |         sqlalchemy.Column("person", _test_struct()),
 58 |     ).c.person
 59 | 
 60 | 
 61 | @pytest.mark.parametrize(
 62 |     "expr,sql",
 63 |     [
 64 |         (_col()["name"], "`t`.`person`.name"),
 65 |         (_col()["Name"], "`t`.`person`.Name"),
 66 |         (_col().NAME, "`t`.`person`.NAME"),
 67 |         (_col().children, "`t`.`person`.children"),
 68 |         (
 69 |             # SQLAlchemy doesn't add the label in this case for some reason.
 70 |             # TODO: why?
 71 |             # https://github.com/googleapis/python-bigquery-sqlalchemy/issues/336
 72 |             _col().children[0].label("anon_1"),
 73 |             "(`t`.`person`.children)[OFFSET(%(param_1:INT64)s)]",
 74 |         ),
 75 |         (
 76 |             _col().children[0]["bdate"],
 77 |             "((`t`.`person`.children)[OFFSET(%(param_1:INT64)s)]).bdate",
 78 |         ),
 79 |         (
 80 |             _col().children[0].bdate,
 81 |             "((`t`.`person`.children)[OFFSET(%(param_1:INT64)s)]).bdate",
 82 |         ),
 83 |     ],
 84 | )
 85 | def test_struct_traversal_project(faux_conn, expr, sql):
 86 |     sql = f"SELECT {sql} AS `anon_1` \nFROM `t`"
 87 |     assert str(sqlalchemy.select(expr).compile(faux_conn.engine)) == sql
 88 | 
 89 | 
 90 | @pytest.mark.parametrize(
 91 |     "expr,sql",
 92 |     [
 93 |         (_col()["name"] == "x", "(`t`.`person`.name) = %(param_1:STRING)s"),
 94 |         (_col()["Name"] == "x", "(`t`.`person`.Name) = %(param_1:STRING)s"),
 95 |         (_col().NAME == "x", "(`t`.`person`.NAME) = %(param_1:STRING)s"),
 96 |         (
 97 |             _col().children[0] == dict(name="foo", bdate=datetime.date(2020, 1, 1)),
 98 |             "(`t`.`person`.children)[OFFSET(%(param_1:INT64)s)]"
 99 |             " = %(param_2:STRUCT<name STRING, bdate DATE>)s",
100 |         ),
101 |         (
102 |             _col().children[0] == dict(name="foo", bdate=datetime.date(2020, 1, 1)),
103 |             "(`t`.`person`.children)[OFFSET(%(param_1:INT64)s)]"
104 |             " = %(param_2:STRUCT<name STRING, bdate DATE>)s",
105 |         ),
106 |         (
107 |             _col().children[0]["bdate"] == datetime.date(2021, 8, 30),
108 |             "(((`t`.`person`.children)[OFFSET(%(param_1:INT64)s)]).bdate)"
109 |             " = %(param_2:DATE)s",
110 |         ),
111 |         (
112 |             _col().children[0].bdate == datetime.date(2021, 8, 30),
113 |             "(((`t`.`person`.children)[OFFSET(%(param_1:INT64)s)]).bdate)"
114 |             " = %(param_2:DATE)s",
115 |         ),
116 |     ],
117 | )
118 | def test_struct_traversal_filter(faux_conn, expr, sql, param=1):
119 |     want = f"SELECT `t`.`person` \nFROM `t`, `t` \nWHERE {sql}"
120 |     got = str(sqlalchemy.select(_col()).where(expr).compile(faux_conn.engine))
121 |     assert got == want
122 | 
123 | 
124 | def test_struct_insert_type_info(faux_conn, metadata):
125 |     t = sqlalchemy.Table("t", metadata, sqlalchemy.Column("person", _test_struct()))
126 |     got = str(
127 |         t.insert()
128 |         .values(
129 |             person=dict(
130 |                 name="bob",
131 |                 children=[dict(name="billy", bdate=datetime.date(2020, 1, 1))],
132 |             )
133 |         )
134 |         .compile(faux_conn.engine)
135 |     )
136 | 
137 |     assert got == (
138 |         "INSERT INTO `t` (`person`) VALUES (%(person:"
139 |         "STRUCT<name STRING, children ARRAY<STRUCT<name STRING, bdate DATE>>>"
140 |         ")s)"
141 |     )
142 | 
143 | 
144 | def test_struct_non_string_field_access(faux_conn):
145 |     with pytest.raises(
146 |         TypeError,
147 |         match="STRUCT fields can only be accessed with strings field names, not 42",
148 |     ):
149 |         _col()[42]
150 | 
151 | 
152 | def test_struct_bad_name(faux_conn):
153 |     with pytest.raises(KeyError, match="42"):
154 |         _col()["42"]
155 | 


--------------------------------------------------------------------------------
/tests/unit/test_alembic.py:
--------------------------------------------------------------------------------
 1 | # Copyright (c) 2021 The sqlalchemy-bigquery Authors
 2 | #
 3 | # Permission is hereby granted, free of charge, to any person obtaining a copy of
 4 | # this software and associated documentation files (the "Software"), to deal in
 5 | # the Software without restriction, including without limitation the rights to
 6 | # use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 7 | # the Software, and to permit persons to whom the Software is furnished to do so,
 8 | # subject to the following conditions:
 9 | #
10 | # The above copyright notice and this permission notice shall be included in all
11 | # copies or substantial portions of the Software.
12 | #
13 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
15 | # FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
16 | # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
17 | # IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
18 | # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
19 | 
20 | from alembic.ddl.base import ColumnName, ColumnType
21 | from sqlalchemy import Integer
22 | 
23 | 
24 | def test_alter_table_rename_column_bigquery(ddl_compiler):
25 |     from sqlalchemy_bigquery.base import visit_column_name
26 | 
27 |     column = ColumnName(name="t", column_name="a", newname="b")
28 |     res = visit_column_name(element=column, compiler=ddl_compiler)
29 |     assert res == "ALTER TABLE `t` RENAME COLUMN `a` TO `b`"
30 | 
31 | 
32 | def test_alter_column_new_type_bigquery(ddl_compiler):
33 |     from sqlalchemy_bigquery.base import visit_column_type
34 | 
35 |     column = ColumnType(name="t", column_name="a", type_=Integer())
36 |     res = visit_column_type(element=column, compiler=ddl_compiler)
37 |     assert res == "ALTER TABLE `t` ALTER COLUMN `a` SET DATA TYPE INT64"
38 | 


--------------------------------------------------------------------------------
/tests/unit/test_comments.py:
--------------------------------------------------------------------------------
  1 | # Copyright (c) 2021 The sqlalchemy-bigquery Authors
  2 | #
  3 | # Permission is hereby granted, free of charge, to any person obtaining a copy of
  4 | # this software and associated documentation files (the "Software"), to deal in
  5 | # the Software without restriction, including without limitation the rights to
  6 | # use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
  7 | # the Software, and to permit persons to whom the Software is furnished to do so,
  8 | # subject to the following conditions:
  9 | #
 10 | # The above copyright notice and this permission notice shall be included in all
 11 | # copies or substantial portions of the Software.
 12 | #
 13 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 14 | # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 15 | # FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 16 | # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 17 | # IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 18 | # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 19 | 
 20 | import sqlalchemy
 21 | 
 22 | from .conftest import setup_table
 23 | 
 24 | 
 25 | def test_inline_comments(faux_conn):
 26 |     setup_table(
 27 |         faux_conn,
 28 |         "some_table",
 29 |         sqlalchemy.Column("id", sqlalchemy.Integer, comment="identifier"),
 30 |         comment="a fine table",
 31 |     )
 32 | 
 33 |     dialect = faux_conn.dialect
 34 |     assert dialect.get_table_comment(faux_conn, "some_table") == {
 35 |         "text": "a fine table"
 36 |     }
 37 |     assert dialect.get_columns(faux_conn, "some_table")[0]["comment"] == "identifier"
 38 | 
 39 | 
 40 | def test_set_drop_table_comment(faux_conn):
 41 |     table = setup_table(
 42 |         faux_conn,
 43 |         "some_table",
 44 |         sqlalchemy.Column("id", sqlalchemy.Integer),
 45 |     )
 46 | 
 47 |     dialect = faux_conn.dialect
 48 |     assert dialect.get_table_comment(faux_conn, "some_table") == {"text": None}
 49 | 
 50 |     table.comment = "a fine table"
 51 |     faux_conn.execute(sqlalchemy.schema.SetTableComment(table))
 52 |     assert dialect.get_table_comment(faux_conn, "some_table") == {
 53 |         "text": "a fine table"
 54 |     }
 55 | 
 56 |     faux_conn.execute(sqlalchemy.schema.DropTableComment(table))
 57 |     assert dialect.get_table_comment(faux_conn, "some_table") == {"text": None}
 58 | 
 59 | 
 60 | def test_table_description_dialect_option(faux_conn):
 61 |     setup_table(
 62 |         faux_conn,
 63 |         "some_table",
 64 |         sqlalchemy.Column("id", sqlalchemy.Integer),
 65 |         bigquery_description="a fine table",
 66 |     )
 67 |     dialect = faux_conn.dialect
 68 |     assert dialect.get_table_comment(faux_conn, "some_table") == {
 69 |         "text": "a fine table"
 70 |     }
 71 | 
 72 | 
 73 | def test_table_friendly_name_dialect_option(faux_conn):
 74 |     setup_table(
 75 |         faux_conn,
 76 |         "some_table",
 77 |         sqlalchemy.Column("id", sqlalchemy.Integer),
 78 |         bigquery_friendly_name="bob",
 79 |     )
 80 | 
 81 |     assert " ".join(faux_conn.test_data["execute"][-1][0].strip().split()) == (
 82 |         "CREATE TABLE `some_table` ( `id` INT64 )" " OPTIONS(friendly_name='bob')"
 83 |     )
 84 | 
 85 | 
 86 | def test_table_friendly_name_description_dialect_option(faux_conn):
 87 |     setup_table(
 88 |         faux_conn,
 89 |         "some_table",
 90 |         sqlalchemy.Column("id", sqlalchemy.Integer),
 91 |         bigquery_friendly_name="bob",
 92 |         bigquery_description="a fine table",
 93 |     )
 94 | 
 95 |     dialect = faux_conn.dialect
 96 |     assert dialect.get_table_comment(faux_conn, "some_table") == {
 97 |         "text": "a fine table"
 98 |     }
 99 |     assert " ".join(faux_conn.test_data["execute"][-1][0].strip().split()) == (
100 |         "CREATE TABLE `some_table` ( `id` INT64 )"
101 |         " OPTIONS(description='a fine table', friendly_name='bob')"
102 |     )
103 | 


--------------------------------------------------------------------------------
/tests/unit/test_compliance.py:
--------------------------------------------------------------------------------
  1 | # Copyright (c) 2021 The sqlalchemy-bigquery Authors
  2 | #
  3 | # Permission is hereby granted, free of charge, to any person obtaining a copy of
  4 | # this software and associated documentation files (the "Software"), to deal in
  5 | # the Software without restriction, including without limitation the rights to
  6 | # use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
  7 | # the Software, and to permit persons to whom the Software is furnished to do so,
  8 | # subject to the following conditions:
  9 | #
 10 | # The above copyright notice and this permission notice shall be included in all
 11 | # copies or substantial portions of the Software.
 12 | #
 13 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 14 | # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 15 | # FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 16 | # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 17 | # IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 18 | # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 19 | """
 20 | Ported compliance tests.
 21 | 
 22 | Mainly to get better unit test coverage.
 23 | """
 24 | 
 25 | import pytest
 26 | import sqlalchemy
 27 | from sqlalchemy import Column, Integer, literal_column, select, String, Table, union
 28 | from sqlalchemy.testing.assertions import eq_, in_
 29 | 
 30 | from .conftest import setup_table
 31 | 
 32 | 
 33 | def assert_result(connection, sel, expected, params=()):
 34 |     eq_(connection.execute(sel, params).fetchall(), expected)
 35 | 
 36 | 
 37 | def some_table(connection):
 38 |     return setup_table(
 39 |         connection,
 40 |         "some_table",
 41 |         Column("id", Integer),
 42 |         Column("x", Integer),
 43 |         Column("y", Integer),
 44 |         initial_data=[
 45 |             {"id": 1, "x": 1, "y": 2},
 46 |             {"id": 2, "x": 2, "y": 3},
 47 |             {"id": 3, "x": 3, "y": 4},
 48 |             {"id": 4, "x": 4, "y": 5},
 49 |         ],
 50 |     )
 51 | 
 52 | 
 53 | def test_distinct_selectable_in_unions(faux_conn):
 54 |     table = some_table(faux_conn)
 55 |     s1 = select(table).where(table.c.id == 2).distinct()
 56 |     s2 = select(table).where(table.c.id == 3).distinct()
 57 | 
 58 |     u1 = union(s1, s2).limit(2)
 59 |     assert_result(faux_conn, u1.order_by(u1.c.id), [(2, 2, 3), (3, 3, 4)])
 60 | 
 61 | 
 62 | def test_limit_offset_aliased_selectable_in_unions(faux_conn):
 63 |     table = some_table(faux_conn)
 64 |     s1 = (
 65 |         select(table)
 66 |         .where(table.c.id == 2)
 67 |         .limit(1)
 68 |         .order_by(table.c.id)
 69 |         .alias()
 70 |         .select()
 71 |     )
 72 |     s2 = (
 73 |         select(table)
 74 |         .where(table.c.id == 3)
 75 |         .limit(1)
 76 |         .order_by(table.c.id)
 77 |         .alias()
 78 |         .select()
 79 |     )
 80 | 
 81 |     u1 = union(s1, s2).limit(2)
 82 |     assert_result(faux_conn, u1.order_by(u1.c.id), [(2, 2, 3), (3, 3, 4)])
 83 | 
 84 | 
 85 | def test_percent_sign_round_trip(faux_conn, metadata):
 86 |     """test that the DBAPI accommodates for escaped / nonescaped
 87 |     percent signs in a way that matches the compiler
 88 | 
 89 |     """
 90 |     t = Table("t", metadata, Column("data", String(50)))
 91 |     t.create(faux_conn.engine)
 92 |     faux_conn.execute(t.insert(), dict(data="some % value"))
 93 |     faux_conn.execute(t.insert(), dict(data="some %% other value"))
 94 |     eq_(
 95 |         faux_conn.scalar(
 96 |             select(t.c.data).where(t.c.data == literal_column("'some % value'"))
 97 |         ),
 98 |         "some % value",
 99 |     )
100 | 
101 |     eq_(
102 |         faux_conn.scalar(
103 |             select(t.c.data).where(t.c.data == literal_column("'some %% other value'"))
104 |         ),
105 |         "some %% other value",
106 |     )
107 | 
108 | 
109 | def test_empty_set_against_integer(faux_conn):
110 |     table = some_table(faux_conn)
111 | 
112 |     stmt = (
113 |         select(table.c.id)
114 |         .where(table.c.x.in_(sqlalchemy.bindparam("q", expanding=True)))
115 |         .order_by(table.c.id)
116 |     )
117 | 
118 |     assert_result(faux_conn, stmt, [], params={"q": []})
119 | 
120 | 
121 | def test_null_in_empty_set_is_false(faux_conn):
122 |     stmt = select(
123 |         sqlalchemy.case(
124 |             (
125 |                 sqlalchemy.null().in_(
126 |                     sqlalchemy.bindparam("foo", value=(), expanding=True)
127 |                 ),
128 |                 sqlalchemy.true(),
129 |             ),
130 |             else_=sqlalchemy.false(),
131 |         )
132 |     )
133 |     in_(faux_conn.execute(stmt).fetchone()[0], (False, 0))
134 | 
135 | 
136 | @pytest.mark.parametrize(
137 |     "meth,arg,expected",
138 |     [
139 |         ("contains", "b%cde", {1, 2, 3, 4, 5, 6, 7, 8, 9}),
140 |         ("startswith", "ab%c", {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}),
141 |         ("endswith", "e%fg", {1, 2, 3, 4, 5, 6, 7, 8, 9}),
142 |     ],
143 | )
144 | def test_likish(faux_conn, meth, arg, expected):
145 |     # See sqlalchemy.testing.suite.test_select.LikeFunctionsTest
146 |     table = setup_table(
147 |         faux_conn,
148 |         "t",
149 |         Column("id", Integer, primary_key=True),
150 |         Column("data", String(50)),
151 |         initial_data=[
152 |             {"id": 1, "data": "abcdefg"},
153 |             {"id": 2, "data": "ab/cdefg"},
154 |             {"id": 3, "data": "ab%cdefg"},
155 |             {"id": 4, "data": "ab_cdefg"},
156 |             {"id": 5, "data": "abcde/fg"},
157 |             {"id": 6, "data": "abcde%fg"},
158 |             {"id": 7, "data": "ab#cdefg"},
159 |             {"id": 8, "data": "ab9cdefg"},
160 |             {"id": 9, "data": "abcde#fg"},
161 |             {"id": 10, "data": "abcd9fg"},
162 |         ],
163 |     )
164 |     expr = getattr(table.c.data, meth)(arg)
165 |     rows = {value for value, in faux_conn.execute(select(table.c.id).where(expr))}
166 |     eq_(rows, expected)
167 | 
168 |     all = {i for i in range(1, 11)}
169 |     expr = sqlalchemy.not_(expr)
170 |     rows = {value for value, in faux_conn.execute(select(table.c.id).where(expr))}
171 |     eq_(rows, all - expected)
172 | 
173 | 
174 | def test_group_by_composed(faux_conn):
175 |     table = setup_table(
176 |         faux_conn,
177 |         "t",
178 |         Column("id", Integer, primary_key=True),
179 |         Column("x", Integer),
180 |         Column("y", Integer),
181 |         Column("q", String(50)),
182 |         Column("p", String(50)),
183 |         initial_data=[
184 |             {"id": 1, "x": 1, "y": 2, "q": "q1", "p": "p3"},
185 |             {"id": 2, "x": 2, "y": 3, "q": "q2", "p": "p2"},
186 |             {"id": 3, "x": 3, "y": 4, "q": "q3", "p": "p1"},
187 |         ],
188 |     )
189 | 
190 |     expr = (table.c.x + table.c.y).label("lx")
191 |     stmt = select(sqlalchemy.func.count(table.c.id), expr).group_by(expr).order_by(expr)
192 |     assert_result(faux_conn, stmt, [(1, 3), (1, 5), (1, 7)])
193 | 
194 | 
195 | def test_cast_type_decorator(faux_conn, last_query):
196 |     # [artial dup of:
197 |     #   sqlalchemy.testing.suite.test_types.CastTypeDecoratorTest.test_special_type
198 |     # That test failes without code that's otherwise not covered by the unit tests.
199 | 
200 |     class StringAsInt(sqlalchemy.TypeDecorator):
201 |         impl = sqlalchemy.String(50)
202 | 
203 |         def bind_expression(self, col):
204 |             return sqlalchemy.cast(col, String(50))
205 | 
206 |     t = setup_table(faux_conn, "t", Column("x", StringAsInt()))
207 |     faux_conn.execute(t.insert(), [{"x": x} for x in [1, 2, 3]])
208 |     last_query("INSERT INTO `t` (`x`) VALUES (CAST(%(x:STRING)s AS STRING))", {"x": 3})
209 | 


--------------------------------------------------------------------------------
/tests/unit/test_dialect_types.py:
--------------------------------------------------------------------------------
 1 | # Copyright (c) 2017 The sqlalchemy-bigquery Authors
 2 | #
 3 | # Permission is hereby granted, free of charge, to any person obtaining a copy of
 4 | # this software and associated documentation files (the "Software"), to deal in
 5 | # the Software without restriction, including without limitation the rights to
 6 | # use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 7 | # the Software, and to permit persons to whom the Software is furnished to do so,
 8 | # subject to the following conditions:
 9 | #
10 | # The above copyright notice and this permission notice shall be included in all
11 | # copies or substantial portions of the Software.
12 | #
13 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
15 | # FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
16 | # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
17 | # IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
18 | # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
19 | 
20 | import importlib
21 | 
22 | 
23 | # https://docs.sqlalchemy.org/en/13/core/type_basics.html#vendor-specific-types
24 | def test_types_import():
25 |     """Demonstrate behavior of importing types independent of any other import."""
26 |     dialect_module = importlib.import_module("sqlalchemy_bigquery")
27 |     _types_module = importlib.import_module("sqlalchemy_bigquery._types")
28 |     custom_types = getattr(_types_module, "_type_map")
29 |     for type_name, type_value in custom_types.items():
30 |         assert getattr(dialect_module, type_name) == type_value
31 | 


--------------------------------------------------------------------------------
/tests/unit/test_engine.py:
--------------------------------------------------------------------------------
 1 | # Copyright (c) 2021 The sqlalchemy-bigquery Authors
 2 | #
 3 | # Permission is hereby granted, free of charge, to any person obtaining a copy of
 4 | # this software and associated documentation files (the "Software"), to deal in
 5 | # the Software without restriction, including without limitation the rights to
 6 | # use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 7 | # the Software, and to permit persons to whom the Software is furnished to do so,
 8 | # subject to the following conditions:
 9 | #
10 | # The above copyright notice and this permission notice shall be included in all
11 | # copies or substantial portions of the Software.
12 | #
13 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
15 | # FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
16 | # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
17 | # IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
18 | # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
19 | 
20 | import pytest
21 | import sqlalchemy
22 | 
23 | 
24 | def test_engine_dataset_but_no_project(faux_conn):
25 |     engine = sqlalchemy.create_engine("bigquery:///foo")
26 |     conn = engine.connect()
27 |     assert conn.connection._client.project == "authproj"
28 | 
29 | 
30 | def test_engine_dataset_with_billing_project(faux_conn):
31 |     engine = sqlalchemy.create_engine("bigquery://foo", billing_project_id="bar")
32 |     conn = engine.connect()
33 |     assert conn.connection._client.project == "bar"
34 | 
35 | 
36 | def test_engine_no_dataset_no_project(faux_conn):
37 |     engine = sqlalchemy.create_engine("bigquery://")
38 |     conn = engine.connect()
39 |     assert conn.connection._client.project == "authproj"
40 | 
41 | 
42 | @pytest.mark.parametrize("arraysize", [0, None])
43 | def test_set_arraysize_not_set_if_false(faux_conn, metadata, arraysize):
44 |     engine = sqlalchemy.create_engine("bigquery://", arraysize=arraysize)
45 |     sqlalchemy.Table("t", metadata, sqlalchemy.Column("c", sqlalchemy.Integer))
46 |     conn = engine.connect()
47 |     metadata.create_all(engine)
48 | 
49 |     # Because we gave a false array size, the array size wasn't set on the cursor:
50 |     assert "arraysize" not in conn.connection.test_data
51 | 
52 | 
53 | def test_set_arraysize(faux_conn, metadata):
54 |     engine = sqlalchemy.create_engine("bigquery://", arraysize=42)
55 |     sqlalchemy.Table("t", metadata, sqlalchemy.Column("c", sqlalchemy.Integer))
56 |     conn = engine.connect()
57 |     metadata.create_all(engine)
58 | 
59 |     # Because we gave a false array size, the array size wasn't set on the cursor:
60 |     assert conn.connection.test_data["arraysize"] == 42
61 | 
62 | 
63 | def test_arraysize_querystring_takes_precedence_over_default(faux_conn, metadata):
64 |     arraysize = 42
65 |     engine = sqlalchemy.create_engine(
66 |         f"bigquery://myproject/mydataset?arraysize={arraysize}"
67 |     )
68 |     sqlalchemy.Table("t", metadata, sqlalchemy.Column("c", sqlalchemy.Integer))
69 |     conn = engine.connect()
70 |     metadata.create_all(engine)
71 | 
72 |     assert conn.connection.test_data["arraysize"] == arraysize
73 | 


--------------------------------------------------------------------------------
/tests/unit/test_geography.py:
--------------------------------------------------------------------------------
  1 | # Copyright (c) 2021 The PyBigQuery Authors
  2 | #
  3 | # Permission is hereby granted, free of charge, to any person obtaining a copy of
  4 | # this software and associated documentation files (the "Software"), to deal in
  5 | # the Software without restriction, including without limitation the rights to
  6 | # use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
  7 | # the Software, and to permit persons to whom the Software is furnished to do so,
  8 | # subject to the following conditions:
  9 | #
 10 | # The above copyright notice and this permission notice shall be included in all
 11 | # copies or substantial portions of the Software.
 12 | #
 13 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 14 | # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 15 | # FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 16 | # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 17 | # IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 18 | # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 19 | 
 20 | import pytest
 21 | 
 22 | from .conftest import setup_table
 23 | 
 24 | geoalchemy2 = pytest.importorskip("geoalchemy2")
 25 | 
 26 | 
 27 | def test_geoalchemy2_core(faux_conn, last_query):
 28 |     """Make sure GeoAlchemy 2 Core Tutorial works as adapted to only having geometry"""
 29 |     conn = faux_conn
 30 | 
 31 |     # Create the Table
 32 | 
 33 |     from sqlalchemy import Column, String
 34 |     from sqlalchemy_bigquery import GEOGRAPHY
 35 | 
 36 |     lake_table = setup_table(
 37 |         conn, "lake", Column("name", String), Column("geog", GEOGRAPHY)
 38 |     )
 39 | 
 40 |     # Insertions
 41 | 
 42 |     conn.execute(
 43 |         lake_table.insert().values(
 44 |             name="Majeur",
 45 |             geog="POLYGON((0 0,1 0,1 1,0 1,0 0))",
 46 |         )
 47 |     )
 48 | 
 49 |     last_query(
 50 |         "INSERT INTO `lake` (`name`, `geog`)"
 51 |         " VALUES (%(name:STRING)s, %(geog:geography)s)",
 52 |         ({"geog": "POLYGON((0 0,1 0,1 1,0 1,0 0))", "name": "Majeur"}),
 53 |     )
 54 | 
 55 |     conn.execute(
 56 |         lake_table.insert(),
 57 |         [
 58 |             {"name": "Garde", "geog": "POLYGON((1 0,3 0,3 2,1 2,1 0))"},
 59 |             {"name": "Orta", "geog": "POLYGON((3 0,6 0,6 3,3 3,3 0))"},
 60 |         ],
 61 |     )
 62 |     last_query(
 63 |         "INSERT INTO `lake` (`name`, `geog`)"
 64 |         " VALUES (%(name:STRING)s, %(geog:geography)s)",
 65 |         {"name": "Garde", "geog": "POLYGON((1 0,3 0,3 2,1 2,1 0))"},
 66 |         offset=2,
 67 |     )
 68 |     last_query(
 69 |         "INSERT INTO `lake` (`name`, `geog`)"
 70 |         " VALUES (%(name:STRING)s, %(geog:geography)s)",
 71 |         {"name": "Orta", "geog": "POLYGON((3 0,6 0,6 3,3 3,3 0))"},
 72 |     )
 73 | 
 74 |     # Selections
 75 | 
 76 |     from sqlalchemy.sql import select
 77 | 
 78 |     try:
 79 |         conn.execute(select(lake_table))
 80 |     except Exception:
 81 |         pass  # sqlite had no special functions :)
 82 |     last_query(
 83 |         "SELECT `lake`.`name`, ST_AsBinary(`lake`.`geog`) AS `geog` \n" "FROM `lake`"
 84 |     )
 85 | 
 86 |     # Spatial query
 87 | 
 88 |     from sqlalchemy import func
 89 | 
 90 |     try:
 91 |         conn.execute(
 92 |             select(lake_table.c.name).where(
 93 |                 func.ST_Contains(lake_table.c.geog, "POINT(4 1)")
 94 |             )
 95 |         )
 96 |     except Exception:
 97 |         pass  # sqlite had no special functions :)
 98 |     last_query(
 99 |         "SELECT `lake`.`name` \n"
100 |         "FROM `lake` \n"
101 |         "WHERE ST_Contains(`lake`.`geog`, %(ST_Contains_1:geography)s)",
102 |         {"ST_Contains_1": "POINT(4 1)"},
103 |     )
104 | 
105 |     try:
106 |         conn.execute(
107 |             select(lake_table.c.name, lake_table.c.geog.ST_Area().label("area"))
108 |         )
109 |     except Exception:
110 |         pass  # sqlite had no special functions :)
111 |     last_query("SELECT `lake`.`name`, ST_Area(`lake`.`geog`) AS `area` \nFROM `lake`")
112 | 
113 |     # Extra: Make sure we can save a retrieved value back:
114 | 
115 |     from sqlalchemy_bigquery import WKB, WKT
116 | 
117 |     geog = WKT("point(0 0)").wkb
118 |     assert isinstance(geog, WKB)
119 |     assert geog.data == (
120 |         b"\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00"
121 |         b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
122 |     )
123 |     conn.execute(lake_table.insert().values(name="test", geog=geog))
124 |     last_query(
125 |         "INSERT INTO `lake` (`name`, `geog`)"
126 |         " VALUES (%(name:STRING)s, %(geog:geography)s)",
127 |         {"name": "test", "geog": "POINT (0 0)"},
128 |     )
129 | 
130 |     # and, while we're at it, that we can insert WKTs, although we
131 |     # normally wouldn't want to.
132 | 
133 |     conn.execute(
134 |         lake_table.insert().values(
135 |             name="test2",
136 |             geog=WKT("POLYGON((1 0,3 0,3 2,1 2,1 0))"),
137 |         )
138 |     )
139 |     last_query(
140 |         "INSERT INTO `lake` (`name`, `geog`)"
141 |         " VALUES (%(name:STRING)s, %(geog:geography)s)",
142 |         {"name": "test2", "geog": "POLYGON((1 0,3 0,3 2,1 2,1 0))"},
143 |     )
144 | 
145 | 
146 | def test_GEOGRAPHY_ElementType_bad_srid():
147 |     from sqlalchemy_bigquery import GEOGRAPHY
148 | 
149 |     with pytest.raises(AssertionError, match="Bad srid"):
150 |         GEOGRAPHY.ElementType("data", srid=-1)
151 | 
152 | 
153 | def test_GEOGRAPHY_ElementType_bad_extended():
154 |     from sqlalchemy_bigquery import GEOGRAPHY
155 | 
156 |     with pytest.raises(AssertionError, match="Extended must be True."):
157 |         GEOGRAPHY.ElementType("data", extended=False)
158 | 
159 | 
160 | def test_GEOGRAPHY_ElementType():
161 |     from sqlalchemy_bigquery import GEOGRAPHY, WKB
162 | 
163 |     # The data argument here should be composed of hex characters:
164 |     # 1-0 and a-f
165 |     data = GEOGRAPHY.ElementType("123def")
166 |     assert isinstance(data, WKB)
167 |     assert (data.data, data.srid, data.extended) == ("123def", 4326, True)
168 | 
169 | 
170 | def test_calling_st_functions_that_dont_take_geographies(faux_conn, last_query):
171 |     from sqlalchemy import select, func
172 | 
173 |     try:
174 |         faux_conn.execute(select(func.ST_GeogFromText("point(0 0)")))
175 |     except Exception:
176 |         pass  # sqlite had no special functions :)
177 | 
178 |     last_query(
179 |         "SELECT ST_AsBinary(ST_GeogFromText(%(ST_GeogFromText_2:STRING)s))"
180 |         " AS `ST_GeogFromText_1`",
181 |         dict(ST_GeogFromText_2="point(0 0)"),
182 |     )
183 | 


--------------------------------------------------------------------------------
/tests/unit/test_like_reescape.py:
--------------------------------------------------------------------------------
 1 | # Copyright (c) 2021 The sqlalchemy-bigquery Authors
 2 | #
 3 | # Permission is hereby granted, free of charge, to any person obtaining a copy of
 4 | # this software and associated documentation files (the "Software"), to deal in
 5 | # the Software without restriction, including without limitation the rights to
 6 | # use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 7 | # the Software, and to permit persons to whom the Software is furnished to do so,
 8 | # subject to the following conditions:
 9 | #
10 | # The above copyright notice and this permission notice shall be included in all
11 | # copies or substantial portions of the Software.
12 | #
13 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
15 | # FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
16 | # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
17 | # IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
18 | # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
19 | 
20 | """SQLAlchemy and BigQuery escape % and _ differently in like expressions.
21 | 
22 | We need to correct for the autoescape option in various string
23 | functions.
24 | """
25 | 
26 | import sqlalchemy.sql.operators
27 | import sqlalchemy.sql.schema
28 | import sqlalchemy_bigquery.base
29 | 
30 | 
31 | def _check(raw, escaped, escape=None, autoescape=True):
32 |     col = sqlalchemy.sql.schema.Column()
33 |     op = col.contains(raw, escape=escape, autoescape=autoescape)
34 |     o2 = sqlalchemy_bigquery.base.BigQueryCompiler._maybe_reescape(op)
35 |     assert o2.left.__dict__ == op.left.__dict__
36 |     assert not o2.modifiers.get("escape")
37 | 
38 |     assert o2.right.value == escaped
39 | 
40 | 
41 | def test_like_autoescape_reescape():
42 |     _check("ab%cd", "ab\\%cd")
43 |     _check("ab%c_d", "ab\\%c\\_d")
44 |     _check("ab%cd", "ab%cd", autoescape=False)
45 |     _check("ab%c_d", "ab\\%c\\_d", escape="\\")
46 |     _check("ab/%c/_/d", "ab/\\%c/\\_/d")
47 | 


--------------------------------------------------------------------------------
/tests/unit/test_version.py:
--------------------------------------------------------------------------------
 1 | # Copyright (c) 2022 The sqlalchemy-bigquery Authors
 2 | #
 3 | # Permission is hereby granted, free of charge, to any person obtaining a copy of
 4 | # this software and associated documentation files (the "Software"), to deal in
 5 | # the Software without restriction, including without limitation the rights to
 6 | # use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 7 | # the Software, and to permit persons to whom the Software is furnished to do so,
 8 | # subject to the following conditions:
 9 | #
10 | # The above copyright notice and this permission notice shall be included in all
11 | # copies or substantial portions of the Software.
12 | #
13 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
15 | # FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
16 | # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
17 | # IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
18 | # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
19 | 
20 | import sqlalchemy_bigquery
21 | import sqlalchemy_bigquery.version
22 | 
23 | 
24 | def test_sqlalchemy_bigquery_has_version():
25 |     assert isinstance(sqlalchemy_bigquery.__version__, str)
26 | 
27 | 
28 | def test_version_module_has_version():
29 |     assert isinstance(sqlalchemy_bigquery.version.__version__, str)
30 | 


--------------------------------------------------------------------------------
/tests/unit/test_view.py:
--------------------------------------------------------------------------------
 1 | # Copyright (c) 2021 The sqlalchemy-bigquery Authors
 2 | #
 3 | # Permission is hereby granted, free of charge, to any person obtaining a copy of
 4 | # this software and associated documentation files (the "Software"), to deal in
 5 | # the Software without restriction, including without limitation the rights to
 6 | # use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 7 | # the Software, and to permit persons to whom the Software is furnished to do so,
 8 | # subject to the following conditions:
 9 | #
10 | # The above copyright notice and this permission notice shall be included in all
11 | # copies or substantial portions of the Software.
12 | #
13 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
15 | # FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
16 | # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
17 | # IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
18 | # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
19 | 
20 | 
21 | def test_view_definition(faux_conn):
22 |     cursor = faux_conn.connection.cursor()
23 |     cursor.execute("create view foo as select 1")
24 | 
25 |     # pass the connection:
26 |     assert faux_conn.dialect.get_view_definition(faux_conn, "foo") == "select 1"
27 | 
28 |     # pass the engine:
29 |     assert faux_conn.dialect.get_view_definition(faux_conn.engine, "foo") == "select 1"
30 | 
31 |     # remove dataset id from dialect:
32 |     faux_conn.dialect.dataset_id = None
33 |     assert (
34 |         faux_conn.dialect.get_view_definition(faux_conn, "mydataset.foo") == "select 1"
35 |     )
36 | 


--------------------------------------------------------------------------------
/third_party/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/googleapis/python-bigquery-sqlalchemy/d0347202c5fb144f960558d9022b7a22af6ce3f7/third_party/__init__.py


--------------------------------------------------------------------------------
/third_party/sqlalchemy_bigquery_vendored/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/googleapis/python-bigquery-sqlalchemy/d0347202c5fb144f960558d9022b7a22af6ce3f7/third_party/sqlalchemy_bigquery_vendored/__init__.py


--------------------------------------------------------------------------------
/third_party/sqlalchemy_bigquery_vendored/py.typed:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/googleapis/python-bigquery-sqlalchemy/d0347202c5fb144f960558d9022b7a22af6ce3f7/third_party/sqlalchemy_bigquery_vendored/py.typed


--------------------------------------------------------------------------------
/third_party/sqlalchemy_bigquery_vendored/sqlalchemy/AUTHORS:
--------------------------------------------------------------------------------
 1 | SQLAlchemy was created by Michael Bayer.
 2 | 
 3 | Major contributing authors include:
 4 | 
 5 | - Mike Bayer
 6 | - Jason Kirtland
 7 | - Michael Trier
 8 | - Diana Clarke
 9 | - Gaetan de Menten
10 | - Lele Gaifax
11 | - Jonathan Ellis
12 | - Gord Thompson
13 | - Federico Caselli
14 | - Philip Jenvey
15 | - Rick Morrison
16 | - Chris Withers
17 | - Ants Aasma
18 | - Sheila Allen
19 | - Paul Johnston
20 | - Tony Locke
21 | - Hajime Nakagami
22 | - Vraj Mohan
23 | - Robert Leftwich
24 | - Taavi Burns
25 | - Jonathan Vanasco
26 | - Jeff Widman
27 | - Scott Dugas
28 | - Dobes Vandermeer
29 | - Ville Skytta
30 | - Rodrigo Menezes
31 | 


--------------------------------------------------------------------------------
/third_party/sqlalchemy_bigquery_vendored/sqlalchemy/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright 2005-2024 SQLAlchemy authors and contributors <see AUTHORS file>.
 2 | 
 3 | Permission is hereby granted, free of charge, to any person obtaining a copy of
 4 | this software and associated documentation files (the "Software"), to deal in
 5 | the Software without restriction, including without limitation the rights to
 6 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
 7 | of the Software, and to permit persons to whom the Software is furnished to do
 8 | so, subject to the following conditions:
 9 | 
10 | The above copyright notice and this permission notice shall be included in all
11 | copies or substantial portions of the Software.
12 | 
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
19 | SOFTWARE.
20 | 


--------------------------------------------------------------------------------
/third_party/sqlalchemy_bigquery_vendored/sqlalchemy/__init__.py:
--------------------------------------------------------------------------------
1 | # __init__.py
2 | # Copyright (C) 2005-2024 the SQLAlchemy authors and contributors
3 | # <see AUTHORS file>
4 | #
5 | # This module is part of SQLAlchemy and is released under
6 | # the MIT License: https://www.opensource.org/licenses/mit-license.php
7 | 


--------------------------------------------------------------------------------
/third_party/sqlalchemy_bigquery_vendored/sqlalchemy/postgresql/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/googleapis/python-bigquery-sqlalchemy/d0347202c5fb144f960558d9022b7a22af6ce3f7/third_party/sqlalchemy_bigquery_vendored/sqlalchemy/postgresql/__init__.py


--------------------------------------------------------------------------------
/third_party/sqlalchemy_bigquery_vendored/sqlalchemy/postgresql/base.py:
--------------------------------------------------------------------------------
 1 | # dialects/postgresql/base.py
 2 | # Copyright (C) 2005-2024 the SQLAlchemy authors and contributors
 3 | # <see AUTHORS file>
 4 | #
 5 | # This module is part of SQLAlchemy and is released under
 6 | # the MIT License: https://www.opensource.org/licenses/mit-license.php
 7 | # mypy: ignore-errors
 8 | 
 9 | from sqlalchemy.sql import compiler
10 | 
11 | 
12 | class PGCompiler(compiler.SQLCompiler):
13 |     def update_from_clause(
14 |         self, update_stmt, from_table, extra_froms, from_hints, **kw
15 |     ):
16 |         kw["asfrom"] = True
17 |         return "FROM " + ", ".join(
18 |             t._compiler_dispatch(self, fromhints=from_hints, **kw) for t in extra_froms
19 |         )
20 | 


--------------------------------------------------------------------------------