diff --git a/spanner/postgresql/README.md b/spanner/postgresql/README.md new file mode 100644 index 00000000000..6806e1a22eb --- /dev/null +++ b/spanner/postgresql/README.md @@ -0,0 +1,27 @@ +# Cloud Spanner PostgreSQL-Dialect Samples + +Python samples demonstrating PostgreSQL-dialect Spanner queries, DML `RETURNING` clauses, and `last_statement=True` transaction optimizations. + +## Setup + +1. Create and activate a Python 3.13+ virtual environment: + + ```sh + python3 -m venv env + source env/bin/activate + ``` + +2. Install dependencies: + + ```sh + pip install -r requirements.txt + ``` + +## Running Tests + +Run unit tests offline: + +```sh +pip install -r requirements-test.txt +pytest tests +``` diff --git a/spanner/postgresql/noxfile_config.py b/spanner/postgresql/noxfile_config.py new file mode 100644 index 00000000000..fe371aaf480 --- /dev/null +++ b/spanner/postgresql/noxfile_config.py @@ -0,0 +1,21 @@ +# Copyright 2026 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +TEST_CONFIG_OVERRIDE = { + "ignored_versions": ["2.7", "3.7", "3.8", "3.9", "3.10", "3.11", "3.12"], + "enforce_type_hints": True, + "gcloud_project_env": "GOOGLE_CLOUD_PROJECT", + "pip_version_override": None, + "envs": {}, +} diff --git a/spanner/postgresql/pyproject.toml b/spanner/postgresql/pyproject.toml new file mode 100644 index 00000000000..754d6461912 --- /dev/null +++ b/spanner/postgresql/pyproject.toml @@ -0,0 +1,30 @@ +# Copyright 2026 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# Local samples only. This package isn't published: install it from this +# directory with `pip install -e .`, never by name from PyPI. +[build-system] +requires = ["setuptools>=64"] +build-backend = "setuptools.build_meta" + +[project] +name = "spanner-postgresql-samples" +version = "0.0.0" +requires-python = ">=3.13" +dependencies = [ + "google-api-core==2.44.0", + "google-cloud-spanner==3.72.0", +] +# PyPI rejects uploads with this classifier. +classifiers = ["Private :: Do Not Upload"] diff --git a/spanner/postgresql/requirements-test.txt b/spanner/postgresql/requirements-test.txt new file mode 100644 index 00000000000..ac63bdc5a92 --- /dev/null +++ b/spanner/postgresql/requirements-test.txt @@ -0,0 +1,2 @@ +-e . +pytest==9.2.0 diff --git a/spanner/postgresql/requirements.txt b/spanner/postgresql/requirements.txt new file mode 100644 index 00000000000..a56c81cc2eb --- /dev/null +++ b/spanner/postgresql/requirements.txt @@ -0,0 +1,2 @@ +google-api-core==2.44.0 +google-cloud-spanner==3.72.0 diff --git a/spanner/postgresql/src/spanner_postgresql/__init__.py b/spanner/postgresql/src/spanner_postgresql/__init__.py new file mode 100644 index 00000000000..58d482ea386 --- /dev/null +++ b/spanner/postgresql/src/spanner_postgresql/__init__.py @@ -0,0 +1,13 @@ +# Copyright 2026 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. diff --git a/spanner/postgresql/src/spanner_postgresql/postgresql_dml_last_statement.py b/spanner/postgresql/src/spanner_postgresql/postgresql_dml_last_statement.py new file mode 100644 index 00000000000..811c0c142a9 --- /dev/null +++ b/spanner/postgresql/src/spanner_postgresql/postgresql_dml_last_statement.py @@ -0,0 +1,101 @@ +# Copyright 2026 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# [START spanner_postgresql_dml_last_statement] +import sys + +from google.api_core import exceptions +from google.cloud import spanner +from google.cloud import spanner_v1 +from google.cloud.spanner_v1 import param_types + + +def update_postgresql_dml_last_statement( + project_id: str, instance_id: str, database_id: str +) -> None: + """Executes the final PostgreSQL DML statement with last_statement=True. + + Setting last_statement=True commits the transaction inline with the final + DML request, avoiding a separate Commit RPC round trip. + + Args: + project_id: The Google Cloud project ID. + instance_id: The Spanner instance ID. + database_id: The PostgreSQL-dialect Spanner database ID. + """ + client = spanner.Client(project=project_id) + database = client.instance(instance_id).database(database_id) + updated_count = 0 + + def update_singers(transaction: spanner_v1.Transaction) -> None: + nonlocal updated_count + row_count = transaction.execute_update( + "UPDATE Singers SET LastName = $1 WHERE SingerId = $2", + params={"p1": "Doe", "p2": 54214}, + param_types={"p1": param_types.STRING, "p2": param_types.INT64}, + last_statement=True, + ) + updated_count = int(row_count) + + try: + database.run_in_transaction(update_singers) + except exceptions.NotFound as err: + print( + f"error: PostgreSQL database '{database_id}' on instance " + f"'{instance_id}' was not found: {err.message}", + file=sys.stderr, + ) + except exceptions.GoogleAPICallError as err: + print( + f"error: PostgreSQL DML last_statement update failed on database " + f"'{database_id}' in instance '{instance_id}': {err.message}", + file=sys.stderr, + ) + else: + print(f"Resource ID: {database_id}") + print(f"Updated Rows: {updated_count}") + + +# [END spanner_postgresql_dml_last_statement] + + +if __name__ == "__main__": + import argparse + import os + + parser = argparse.ArgumentParser( + description="Execute a PostgreSQL-dialect DML update with last_statement=True." + ) + parser.add_argument( + "--project-id", + default=os.environ.get("GOOGLE_CLOUD_PROJECT", "example-project-id"), + help="Google Cloud project ID (default: $GOOGLE_CLOUD_PROJECT)", + ) + parser.add_argument( + "--instance-id", + default=os.environ.get("SPANNER_INSTANCE_ID", "example-instance"), + help="Spanner instance ID (default: $SPANNER_INSTANCE_ID)", + ) + parser.add_argument( + "--database-id", + default=os.environ.get("SPANNER_DATABASE_ID", "example-pg-db"), + help="PostgreSQL-dialect Spanner database ID (default: $SPANNER_DATABASE_ID)", + ) + args = parser.parse_args() + + update_postgresql_dml_last_statement( + project_id=args.project_id, + instance_id=args.instance_id, + database_id=args.database_id, + ) diff --git a/spanner/postgresql/src/spanner_postgresql/postgresql_drop_sequence.py b/spanner/postgresql/src/spanner_postgresql/postgresql_drop_sequence.py new file mode 100644 index 00000000000..fc7f3a7d4ca --- /dev/null +++ b/spanner/postgresql/src/spanner_postgresql/postgresql_drop_sequence.py @@ -0,0 +1,105 @@ +# Copyright 2026 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# [START spanner_postgresql_drop_sequence] +import sys + +from google.api_core import exceptions +from google.cloud import spanner_admin_database_v1 + + +def drop_postgresql_sequence( + project_id: str, instance_id: str, database_id: str +) -> None: + """Detaches a column DEFAULT and drops a PostgreSQL sequence via DDL. + + Args: + project_id: The Google Cloud project ID. + instance_id: The Spanner instance ID. + database_id: The PostgreSQL-dialect Spanner database ID with Seq. + """ + client = spanner_admin_database_v1.DatabaseAdminClient() + database_path = client.database_path(project_id, instance_id, database_id) + sequence_name = "Seq" + request = spanner_admin_database_v1.UpdateDatabaseDdlRequest( + database=database_path, + statements=[ + "ALTER TABLE Customers ALTER COLUMN CustomerId DROP DEFAULT", + f"DROP SEQUENCE {sequence_name}", + ], + ) + + try: + operation = client.update_database_ddl(request=request) + print( + f"Waiting for PostgreSQL sequence '{sequence_name}' drop on " + f"'{database_id}'..." + ) + operation.result(timeout=300) + except exceptions.FailedPrecondition as err: + print( + f"error: sequence '{sequence_name}' is still referenced or missing " + f"on database '{database_id}' in instance '{instance_id}': {err.message}", + file=sys.stderr, + ) + except TimeoutError as err: + print( + f"error: timed out waiting to drop PostgreSQL sequence " + f"'{sequence_name}' on database '{database_id}' in instance " + f"'{instance_id}'; the operation may still be running: {err}", + file=sys.stderr, + ) + except exceptions.GoogleAPICallError as err: + print( + f"error: failed to drop PostgreSQL sequence '{sequence_name}' on " + f"database '{database_id}' in instance '{instance_id}': {err.message}", + file=sys.stderr, + ) + else: + print(f"Resource ID: {database_id}") + print(f"Dropped Sequence: {sequence_name}") + + +# [END spanner_postgresql_drop_sequence] + + +if __name__ == "__main__": + import argparse + import os + + parser = argparse.ArgumentParser( + description="Detach column default and drop a PostgreSQL sequence." + ) + parser.add_argument( + "--project-id", + default=os.environ.get("GOOGLE_CLOUD_PROJECT", "example-project-id"), + help="Google Cloud project ID (default: $GOOGLE_CLOUD_PROJECT)", + ) + parser.add_argument( + "--instance-id", + default=os.environ.get("SPANNER_INSTANCE_ID", "example-instance"), + help="Spanner instance ID (default: $SPANNER_INSTANCE_ID)", + ) + parser.add_argument( + "--database-id", + default=os.environ.get("SPANNER_PG_DATABASE_ID", "example-db"), + help="Spanner database ID", + ) + args = parser.parse_args() + + drop_postgresql_sequence( + project_id=args.project_id, + instance_id=args.instance_id, + database_id=args.database_id, + ) diff --git a/spanner/postgresql/tests/__init__.py b/spanner/postgresql/tests/__init__.py new file mode 100644 index 00000000000..58d482ea386 --- /dev/null +++ b/spanner/postgresql/tests/__init__.py @@ -0,0 +1,13 @@ +# Copyright 2026 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. diff --git a/spanner/postgresql/tests/conftest.py b/spanner/postgresql/tests/conftest.py new file mode 100644 index 00000000000..cd0aa69802f --- /dev/null +++ b/spanner/postgresql/tests/conftest.py @@ -0,0 +1,38 @@ +# Copyright 2026 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Shared live-test configuration for Cloud Spanner PostgreSQL-Dialect Samples.""" + +import os + +import pytest + +LIVE_PROJECT_ID = os.environ.get("GOOGLE_CLOUD_PROJECT", "") +LIVE_INSTANCE_ID = os.environ.get("SPANNER_INSTANCE_ID", "") +LIVE_DATABASE_ID = os.environ.get( + "SPANNER_PG_DATABASE_ID", os.environ.get("SPANNER_DATABASE_ID", "") +) + +if os.environ.get("RUN_INTEGRATION_TESTS") == "true" and ( + not LIVE_PROJECT_ID or not LIVE_INSTANCE_ID or not LIVE_DATABASE_ID +): + raise RuntimeError( + "Set GOOGLE_CLOUD_PROJECT, SPANNER_INSTANCE_ID, and " + "SPANNER_PG_DATABASE_ID when RUN_INTEGRATION_TESTS=true." + ) + +live_only = pytest.mark.skipif( + os.environ.get("RUN_INTEGRATION_TESTS") != "true", + reason="Set RUN_INTEGRATION_TESTS=true to run integration tests.", +) diff --git a/spanner/postgresql/tests/postgresql_dml_last_statement_test.py b/spanner/postgresql/tests/postgresql_dml_last_statement_test.py new file mode 100644 index 00000000000..36c0bbacde5 --- /dev/null +++ b/spanner/postgresql/tests/postgresql_dml_last_statement_test.py @@ -0,0 +1,155 @@ +# Copyright 2026 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import runpy +from unittest import mock + +from google.api_core import exceptions +from google.cloud import spanner +import pytest +from spanner_postgresql import postgresql_dml_last_statement + +from . import conftest + +PROJECT_ID = "example-project-id" +INSTANCE_ID = "example-instance" +DATABASE_ID = "example-pg-db" +DATABASE_NAME = f"projects/{PROJECT_ID}/instances/{INSTANCE_ID}/databases/{DATABASE_ID}" +SPANNER_CLIENT = "google.cloud.spanner.Client" + + +@mock.patch(SPANNER_CLIENT) +def test_update_postgresql_dml_last_statement_success( + mock_client_class: mock.MagicMock, capsys: pytest.CaptureFixture[str] +) -> None: + database = ( + mock_client_class.return_value.instance.return_value.database.return_value + ) + database.name = DATABASE_NAME + transaction = mock.MagicMock() + transaction.execute_update.return_value = 1 + database.run_in_transaction.side_effect = lambda fn: fn(transaction) + + postgresql_dml_last_statement.update_postgresql_dml_last_statement( + PROJECT_ID, INSTANCE_ID, DATABASE_ID + ) + + call = transaction.execute_update.call_args + assert "$1" in call.args[0] + assert call.kwargs["last_statement"] is True + out, err = capsys.readouterr() + assert f"Resource ID: {DATABASE_ID}" in out + assert PROJECT_ID not in out + assert "Updated Rows: 1" in out + assert err == "" + + +@pytest.mark.parametrize( + "error, expected_prefix", + [ + ( + exceptions.NotFound("db missing"), + "error: PostgreSQL database 'example-pg-db' on instance", + ), + ( + exceptions.Aborted("aborted"), + "error: PostgreSQL DML last_statement update failed", + ), + ], +) +@mock.patch(SPANNER_CLIENT) +def test_update_postgresql_dml_last_statement_errors( + mock_client_class: mock.MagicMock, + capsys: pytest.CaptureFixture[str], + error: Exception, + expected_prefix: str, +) -> None: + database = ( + mock_client_class.return_value.instance.return_value.database.return_value + ) + database.run_in_transaction.side_effect = error + + postgresql_dml_last_statement.update_postgresql_dml_last_statement( + PROJECT_ID, INSTANCE_ID, DATABASE_ID + ) + + out, err = capsys.readouterr() + assert out == "" + assert err.startswith(expected_prefix) + assert PROJECT_ID not in err + assert PROJECT_ID not in err + assert PROJECT_ID not in err + + +@mock.patch(SPANNER_CLIENT) +def test_update_postgresql_dml_last_statement_cli_entrypoint( + mock_client_class: mock.MagicMock, + monkeypatch: pytest.MonkeyPatch, + capsys: pytest.CaptureFixture[str], +) -> None: + database = ( + mock_client_class.return_value.instance.return_value.database.return_value + ) + database.name = DATABASE_NAME + transaction = mock.MagicMock() + transaction.execute_update.return_value = 1 + database.run_in_transaction.side_effect = lambda fn: fn(transaction) + monkeypatch.setattr( + "sys.argv", + [ + "postgresql_dml_last_statement.py", + "--project-id", + PROJECT_ID, + "--instance-id", + INSTANCE_ID, + "--database-id", + DATABASE_ID, + ], + ) + + runpy.run_module( + "spanner_postgresql.postgresql_dml_last_statement", run_name="__main__" + ) + + assert "Updated Rows: 1" in capsys.readouterr().out + + +@conftest.live_only +def test_update_postgresql_dml_last_statement_live( + capsys: pytest.CaptureFixture[str], +) -> None: + client = spanner.Client(project=conftest.LIVE_PROJECT_ID) + database = client.instance(conftest.LIVE_INSTANCE_ID).database( + conftest.LIVE_DATABASE_ID + ) + database.run_in_transaction(lambda txn: txn.execute_update(""" + INSERT INTO Singers (SingerId, FirstName, LastName) + VALUES (54214, 'John', 'Smith') + ON CONFLICT (SingerId) DO UPDATE SET LastName = 'Smith' + """)) + try: + postgresql_dml_last_statement.update_postgresql_dml_last_statement( + conftest.LIVE_PROJECT_ID, + conftest.LIVE_INSTANCE_ID, + conftest.LIVE_DATABASE_ID, + ) + + out, err = capsys.readouterr() + assert err == "" + assert conftest.LIVE_PROJECT_ID not in out + assert "Updated Rows: 1" in out + finally: + database.run_in_transaction( + lambda txn: txn.execute_update("DELETE FROM Singers WHERE SingerId = 54214") + ) diff --git a/spanner/postgresql/tests/postgresql_drop_sequence_test.py b/spanner/postgresql/tests/postgresql_drop_sequence_test.py new file mode 100644 index 00000000000..111685f09dc --- /dev/null +++ b/spanner/postgresql/tests/postgresql_drop_sequence_test.py @@ -0,0 +1,168 @@ +# Copyright 2026 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import runpy +from unittest import mock + +from google.api_core import exceptions +from google.cloud import spanner_admin_database_v1 +import pytest +from spanner_postgresql import postgresql_create_sequence +from spanner_postgresql import postgresql_drop_sequence + +from . import conftest + +PROJECT_ID = "example-project-id" +INSTANCE_ID = "example-instance" +DATABASE_ID = "example-pg-db" +ADMIN_CLIENT = "google.cloud.spanner_admin_database_v1.DatabaseAdminClient" + + +@mock.patch(ADMIN_CLIENT) +def test_drop_postgresql_sequence_success( + mock_client_class: mock.MagicMock, capsys: pytest.CaptureFixture[str] +) -> None: + mock_client_class.return_value.instance_path.return_value = ( + f"projects/{PROJECT_ID}/instances/{INSTANCE_ID}" + ) + mock_client_class.return_value.database_path.return_value = ( + f"projects/{PROJECT_ID}/instances/{INSTANCE_ID}/databases/{DATABASE_ID}" + ) + postgresql_drop_sequence.drop_postgresql_sequence( + PROJECT_ID, INSTANCE_ID, DATABASE_ID + ) + + req = mock_client_class.return_value.update_database_ddl.call_args.kwargs["request"] + assert len(req.statements) == 2 + out, err = capsys.readouterr() + assert f"Resource ID: {DATABASE_ID}" in out + assert "Dropped Sequence: Seq" in out + assert PROJECT_ID not in out + assert err == "" + + +@pytest.mark.parametrize( + "error, expected_prefix", + [ + ( + exceptions.FailedPrecondition("in use"), + "error: sequence 'Seq' is still referenced or missing", + ), + ( + TimeoutError("deadline"), + "error: timed out waiting to drop PostgreSQL sequence 'Seq'", + ), + ( + exceptions.PermissionDenied("denied"), + "error: failed to drop PostgreSQL sequence 'Seq'", + ), + ], +) +@mock.patch(ADMIN_CLIENT) +def test_drop_postgresql_sequence_errors( + mock_client_class: mock.MagicMock, + capsys: pytest.CaptureFixture[str], + error: Exception, + expected_prefix: str, +) -> None: + mock_client_class.return_value.instance_path.return_value = ( + f"projects/{PROJECT_ID}/instances/{INSTANCE_ID}" + ) + mock_client_class.return_value.database_path.return_value = ( + f"projects/{PROJECT_ID}/instances/{INSTANCE_ID}/databases/{DATABASE_ID}" + ) + mock_client_class.return_value.update_database_ddl.side_effect = error + + postgresql_drop_sequence.drop_postgresql_sequence( + PROJECT_ID, INSTANCE_ID, DATABASE_ID + ) + + _out, err = capsys.readouterr() + assert err.startswith(expected_prefix) + assert PROJECT_ID not in err + + +@mock.patch(ADMIN_CLIENT) +def test_drop_postgresql_sequence_cli_entrypoint( + mock_client_class: mock.MagicMock, + monkeypatch: pytest.MonkeyPatch, + capsys: pytest.CaptureFixture[str], +) -> None: + mock_client_class.return_value.instance_path.return_value = ( + f"projects/{PROJECT_ID}/instances/{INSTANCE_ID}" + ) + mock_client_class.return_value.database_path.return_value = ( + f"projects/{PROJECT_ID}/instances/{INSTANCE_ID}/databases/{DATABASE_ID}" + ) + monkeypatch.setattr( + "sys.argv", + [ + "postgresql_drop_sequence.py", + "--project-id", + PROJECT_ID, + "--instance-id", + INSTANCE_ID, + "--database-id", + DATABASE_ID, + ], + ) + + runpy.run_module("spanner_postgresql.postgresql_drop_sequence", run_name="__main__") + + assert "Dropped Sequence: Seq" in capsys.readouterr().out + + +@conftest.live_only +def test_drop_postgresql_sequence_live(capsys: pytest.CaptureFixture[str]) -> None: + admin = spanner_admin_database_v1.DatabaseAdminClient() + db_path = admin.database_path( + conftest.LIVE_PROJECT_ID, + conftest.LIVE_INSTANCE_ID, + conftest.LIVE_DATABASE_ID, + ) + admin.update_database_ddl( + request={ + "database": db_path, + "statements": [ + "DROP TABLE IF EXISTS Customers", + "DROP SEQUENCE IF EXISTS Seq", + ], + } + ).result(timeout=240) + try: + postgresql_create_sequence.create_postgresql_sequence( + conftest.LIVE_PROJECT_ID, + conftest.LIVE_INSTANCE_ID, + conftest.LIVE_DATABASE_ID, + ) + capsys.readouterr() + postgresql_drop_sequence.drop_postgresql_sequence( + conftest.LIVE_PROJECT_ID, + conftest.LIVE_INSTANCE_ID, + conftest.LIVE_DATABASE_ID, + ) + out, err = capsys.readouterr() + assert err == "" + assert conftest.LIVE_PROJECT_ID not in out + assert "Dropped Sequence: Seq" in out + finally: + admin.update_database_ddl( + request={ + "database": db_path, + "statements": [ + "DROP TABLE IF EXISTS Customers", + "DROP SEQUENCE IF EXISTS Seq", + ], + } + ).result(timeout=240)