google-cloud-spanner 3.42.0__tar.gz → 3.43.0__tar.gz

{google-cloud-spanner-3.42.0/google_cloud_spanner.egg-info → google-cloud-spanner-3.43.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: google-cloud-spanner
-Version: 3.42.0
+Version: 3.43.0
 Summary: Google Cloud Spanner API client library
 Home-page: https://github.com/googleapis/python-spanner
 Author: Google LLC

{google-cloud-spanner-3.42.0 → google-cloud-spanner-3.43.0}/google/cloud/spanner_admin_database_v1/gapic_version.py

@@ -13,4 +13,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-__version__ = "3.42.0"  # {x-release-please-version}
+__version__ = "3.43.0"  # {x-release-please-version}

{google-cloud-spanner-3.42.0 → google-cloud-spanner-3.43.0}/google/cloud/spanner_admin_instance_v1/gapic_version.py

@@ -13,4 +13,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-__version__ = "3.42.0"  # {x-release-please-version}
+__version__ = "3.43.0"  # {x-release-please-version}

{google-cloud-spanner-3.42.0 → google-cloud-spanner-3.43.0}/google/cloud/spanner_dbapi/_helpers.py

@@ -18,13 +18,13 @@ from google.cloud.spanner_v1 import param_types
 SQL_LIST_TABLES = """
 SELECT table_name
 FROM information_schema.tables
-WHERE table_catalog = '' AND table_schema = ''
+WHERE table_catalog = '' AND table_schema = @table_schema
 """
 
 SQL_GET_TABLE_COLUMN_SCHEMA = """
 SELECT COLUMN_NAME, IS_NULLABLE, SPANNER_TYPE
 FROM INFORMATION_SCHEMA.COLUMNS
-WHERE TABLE_SCHEMA = '' AND TABLE_NAME = @table_name
+WHERE TABLE_SCHEMA = @table_schema AND TABLE_NAME = @table_name
 """
 
 # This table maps spanner_types to Spanner's data type sizes as per

{google-cloud-spanner-3.42.0 → google-cloud-spanner-3.43.0}/google/cloud/spanner_dbapi/client_side_statement_executor.py

@@ -105,6 +105,8 @@ def execute(cursor: "Cursor", parsed_statement: ParsedStatement):
         )
     if statement_type == ClientSideStatementType.RUN_PARTITIONED_QUERY:
         return connection.run_partitioned_query(parsed_statement)
+    if statement_type == ClientSideStatementType.SET_AUTOCOMMIT_DML_MODE:
+        return connection._set_autocommit_dml_mode(parsed_statement)
 
 
 def _get_streamed_result_set(column_name, type_code, column_values):

{google-cloud-spanner-3.42.0 → google-cloud-spanner-3.43.0}/google/cloud/spanner_dbapi/client_side_statement_parser.py

@@ -38,6 +38,9 @@ RE_RUN_PARTITION = re.compile(r"^\s*(RUN)\s+(PARTITION)\s+(.+)", re.IGNORECASE)
 RE_RUN_PARTITIONED_QUERY = re.compile(
     r"^\s*(RUN)\s+(PARTITIONED)\s+(QUERY)\s+(.+)", re.IGNORECASE
 )
+RE_SET_AUTOCOMMIT_DML_MODE = re.compile(
+    r"^\s*(SET)\s+(AUTOCOMMIT_DML_MODE)\s+(=)\s+(.+)", re.IGNORECASE
+)
 
 
 def parse_stmt(query):
@@ -82,6 +85,10 @@ def parse_stmt(query):
         match = re.search(RE_RUN_PARTITION, query)
         client_side_statement_params.append(match.group(3))
         client_side_statement_type = ClientSideStatementType.RUN_PARTITION
+    elif RE_SET_AUTOCOMMIT_DML_MODE.match(query):
+        match = re.search(RE_SET_AUTOCOMMIT_DML_MODE, query)
+        client_side_statement_params.append(match.group(4))
+        client_side_statement_type = ClientSideStatementType.SET_AUTOCOMMIT_DML_MODE
     if client_side_statement_type is not None:
         return ParsedStatement(
             StatementType.CLIENT_SIDE,

{google-cloud-spanner-3.42.0 → google-cloud-spanner-3.43.0}/google/cloud/spanner_dbapi/connection.py

@@ -23,6 +23,7 @@ from google.cloud.spanner_dbapi.batch_dml_executor import BatchMode, BatchDmlExe
 from google.cloud.spanner_dbapi.parse_utils import _get_statement_type
 from google.cloud.spanner_dbapi.parsed_statement import (
     StatementType,
+    AutocommitDmlMode,
 )
 from google.cloud.spanner_dbapi.partition_helper import PartitionId
 from google.cloud.spanner_dbapi.parsed_statement import ParsedStatement, Statement
@@ -116,6 +117,26 @@ class Connection:
         self._batch_mode = BatchMode.NONE
         self._batch_dml_executor: BatchDmlExecutor = None
         self._transaction_helper = TransactionRetryHelper(self)
+        self._autocommit_dml_mode: AutocommitDmlMode = AutocommitDmlMode.TRANSACTIONAL
+
+    @property
+    def spanner_client(self):
+        """Client for interacting with Cloud Spanner API. This property exposes
+        the spanner client so that underlying methods can be accessed.
+        """
+        return self._instance._client
+
+    @property
+    def current_schema(self):
+        """schema name for this connection.
+
+        :rtype: str
+        :returns: the current default schema of this connection. Currently, this
+         is always "" for GoogleSQL and "public" for PostgreSQL databases.
+        """
+        if self.database is None:
+            raise ValueError("database property not set on the connection")
+        return self.database.default_schema_name
 
     @property
     def autocommit(self):
@@ -148,6 +169,23 @@ class Connection:
         """
         return self._database
 
+    @property
+    def autocommit_dml_mode(self):
+        """Modes for executing DML statements in autocommit mode for this connection.
+
+        The DML autocommit modes are:
+        1) TRANSACTIONAL - DML statements are executed as single read-write transaction.
+        After successful execution, the DML statement is guaranteed to have been applied
+        exactly once to the database.
+
+        2) PARTITIONED_NON_ATOMIC - DML statements are executed as partitioned DML transactions.
+        If an error occurs during the execution of the DML statement, it is possible that the
+        statement has been applied to some but not all of the rows specified in the statement.
+
+        :rtype: :class:`~google.cloud.spanner_dbapi.parsed_statement.AutocommitDmlMode`
+        """
+        return self._autocommit_dml_mode
+
     @property
     @deprecated(
         reason="This method is deprecated. Use _spanner_transaction_started field"
@@ -558,6 +596,37 @@ class Connection:
             partitioned_query, statement.params, statement.param_types
         )
 
+    @check_not_closed
+    def _set_autocommit_dml_mode(
+        self,
+        parsed_statement: ParsedStatement,
+    ):
+        autocommit_dml_mode_str = parsed_statement.client_side_statement_params[0]
+        autocommit_dml_mode = AutocommitDmlMode[autocommit_dml_mode_str.upper()]
+        self.set_autocommit_dml_mode(autocommit_dml_mode)
+
+    def set_autocommit_dml_mode(
+        self,
+        autocommit_dml_mode,
+    ):
+        """
+        Sets the mode for executing DML statements in autocommit mode for this connection.
+        This mode is only used when the connection is in autocommit mode, and may only
+        be set while the transaction is in autocommit mode and not in a temporary transaction.
+        """
+
+        if self._client_transaction_started is True:
+            raise ProgrammingError(
+                "Cannot set autocommit DML mode while not in autocommit mode or while a transaction is active."
+            )
+        if self.read_only is True:
+            raise ProgrammingError(
+                "Cannot set autocommit DML mode for a read-only connection."
+            )
+        if self._batch_mode is not BatchMode.NONE:
+            raise ProgrammingError("Cannot set autocommit DML mode while in a batch.")
+        self._autocommit_dml_mode = autocommit_dml_mode
+
     def _partitioned_query_validation(self, partitioned_query, statement):
         if _get_statement_type(Statement(partitioned_query)) is not StatementType.QUERY:
             raise ProgrammingError(
@@ -657,9 +726,10 @@ def connect(
             raise ValueError("project in url does not match client object project")
 
     instance = client.instance(instance_id)
-    conn = Connection(
-        instance, instance.database(database_id, pool=pool) if database_id else None
-    )
+    database = None
+    if database_id:
+        database = instance.database(database_id, pool=pool)
+    conn = Connection(instance, database)
     if pool is not None:
         conn._own_pool = False
 

{google-cloud-spanner-3.42.0 → google-cloud-spanner-3.43.0}/google/cloud/spanner_dbapi/cursor.py

@@ -45,6 +45,7 @@ from google.cloud.spanner_dbapi.parsed_statement import (
     StatementType,
     Statement,
     ParsedStatement,
+    AutocommitDmlMode,
 )
 from google.cloud.spanner_dbapi.transaction_helper import CursorStatementType
 from google.cloud.spanner_dbapi.utils import PeekIterator
@@ -272,6 +273,17 @@ class Cursor(object):
                 self._batch_DDLs(sql)
                 if not self.connection._client_transaction_started:
                     self.connection.run_prior_DDL_statements()
+            elif (
+                self.connection.autocommit_dml_mode
+                is AutocommitDmlMode.PARTITIONED_NON_ATOMIC
+            ):
+                self._row_count = self.connection.database.execute_partitioned_dml(
+                    sql,
+                    params=args,
+                    param_types=self._parsed_statement.statement.param_types,
+                    request_options=self.connection.request_options,
+                )
+                self._result_set = None
             else:
                 self._execute_in_rw_transaction()
 
@@ -510,13 +522,17 @@ class Cursor(object):
             raise ProgrammingError("no results to return")
         return self._itr
 
-    def list_tables(self):
+    def list_tables(self, schema_name=""):
         """List the tables of the linked Database.
 
         :rtype: list
         :returns: The list of tables within the Database.
         """
-        return self.run_sql_in_snapshot(_helpers.SQL_LIST_TABLES)
+        return self.run_sql_in_snapshot(
+            sql=_helpers.SQL_LIST_TABLES,
+            params={"table_schema": schema_name},
+            param_types={"table_schema": spanner.param_types.STRING},
+        )
 
     def run_sql_in_snapshot(self, sql, params=None, param_types=None):
         # Some SQL e.g. for INFORMATION_SCHEMA cannot be run in read-write transactions
@@ -528,11 +544,14 @@ class Cursor(object):
         with self.connection.database.snapshot() as snapshot:
             return list(snapshot.execute_sql(sql, params, param_types))
 
-    def get_table_column_schema(self, table_name):
+    def get_table_column_schema(self, table_name, schema_name=""):
         rows = self.run_sql_in_snapshot(
             sql=_helpers.SQL_GET_TABLE_COLUMN_SCHEMA,
-            params={"table_name": table_name},
-            param_types={"table_name": spanner.param_types.STRING},
+            params={"schema_name": schema_name, "table_name": table_name},
+            param_types={
+                "schema_name": spanner.param_types.STRING,
+                "table_name": spanner.param_types.STRING,
+            },
         )
 
         column_details = {}

{google-cloud-spanner-3.42.0 → google-cloud-spanner-3.43.0}/google/cloud/spanner_dbapi/parse_utils.py

@@ -154,7 +154,9 @@ RE_WITH = re.compile(r"^\s*(WITH)", re.IGNORECASE)
 
 # DDL statements follow
 # https://cloud.google.com/spanner/docs/data-definition-language
-RE_DDL = re.compile(r"^\s*(CREATE|ALTER|DROP|GRANT|REVOKE)", re.IGNORECASE | re.DOTALL)
+RE_DDL = re.compile(
+    r"^\s*(CREATE|ALTER|DROP|GRANT|REVOKE|RENAME)", re.IGNORECASE | re.DOTALL
+)
 
 RE_IS_INSERT = re.compile(r"^\s*(INSERT)", re.IGNORECASE | re.DOTALL)
 

{google-cloud-spanner-3.42.0 → google-cloud-spanner-3.43.0}/google/cloud/spanner_dbapi/parsed_statement.py

@@ -36,6 +36,12 @@ class ClientSideStatementType(Enum):
     PARTITION_QUERY = 9
     RUN_PARTITION = 10
     RUN_PARTITIONED_QUERY = 11
+    SET_AUTOCOMMIT_DML_MODE = 12
+
+
+class AutocommitDmlMode(Enum):
+    TRANSACTIONAL = 1
+    PARTITIONED_NON_ATOMIC = 2
 
 
 @dataclass

{google-cloud-spanner-3.42.0 → google-cloud-spanner-3.43.0}/google/cloud/spanner_v1/batch.py

@@ -146,7 +146,9 @@ class Batch(_BatchBase):
         if self.committed is not None:
             raise ValueError("Batch already committed")
 
-    def commit(self, return_commit_stats=False, request_options=None):
+    def commit(
+        self, return_commit_stats=False, request_options=None, max_commit_delay=None
+    ):
         """Commit mutations to the database.
 
         :type return_commit_stats: bool
@@ -160,6 +162,11 @@ class Batch(_BatchBase):
                 If a dict is provided, it must be of the same form as the protobuf
                 message :class:`~google.cloud.spanner_v1.types.RequestOptions`.
 
+        :type max_commit_delay: :class:`datetime.timedelta`
+        :param max_commit_delay:
+                (Optional) The amount of latency this request is willing to incur
+                in order to improve throughput.
+
         :rtype: datetime
         :returns: timestamp of the committed changes.
         """
@@ -188,6 +195,7 @@ class Batch(_BatchBase):
             mutations=self._mutations,
             single_use_transaction=txn_options,
             return_commit_stats=return_commit_stats,
+            max_commit_delay=max_commit_delay,
             request_options=request_options,
         )
         with trace_call("CloudSpanner.Commit", self._session, trace_attributes):

{google-cloud-spanner-3.42.0 → google-cloud-spanner-3.43.0}/google/cloud/spanner_v1/database.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""User friendly container for Cloud Spanner Database."""
+"""User-friendly container for Cloud Spanner Database."""
 
 import copy
 import functools
@@ -42,6 +42,8 @@ from google.cloud.spanner_admin_database_v1 import UpdateDatabaseDdlRequest
 from google.cloud.spanner_admin_database_v1.types import DatabaseDialect
 from google.cloud.spanner_dbapi.partition_helper import BatchTransactionId
 from google.cloud.spanner_v1 import ExecuteSqlRequest
+from google.cloud.spanner_v1 import Type
+from google.cloud.spanner_v1 import TypeCode
 from google.cloud.spanner_v1 import TransactionSelector
 from google.cloud.spanner_v1 import TransactionOptions
 from google.cloud.spanner_v1 import RequestOptions
@@ -334,8 +336,21 @@ class Database(object):
         :rtype: :class:`google.cloud.spanner_admin_database_v1.types.DatabaseDialect`
         :returns: the dialect of the database
         """
+        if self._database_dialect == DatabaseDialect.DATABASE_DIALECT_UNSPECIFIED:
+            self.reload()
         return self._database_dialect
 
+    @property
+    def default_schema_name(self):
+        """Default schema name for this database.
+
+        :rtype: str
+        :returns: "" for GoogleSQL and "public" for PostgreSQL
+        """
+        if self.database_dialect == DatabaseDialect.POSTGRESQL:
+            return "public"
+        return ""
+
     @property
     def database_role(self):
         """User-assigned database_role for sessions created by the pool.
@@ -633,8 +648,6 @@ class Database(object):
         if params is not None:
             from google.cloud.spanner_v1.transaction import Transaction
 
-            if param_types is None:
-                raise ValueError("Specify 'param_types' when passing 'params'.")
             params_pb = Transaction._make_params_pb(params, param_types)
         else:
             params_pb = {}
@@ -721,7 +734,7 @@ class Database(object):
         """
         return SnapshotCheckout(self, **kw)
 
-    def batch(self, request_options=None):
+    def batch(self, request_options=None, max_commit_delay=None):
         """Return an object which wraps a batch.
 
         The wrapper *must* be used as a context manager, with the batch
@@ -734,10 +747,16 @@ class Database(object):
                 If a dict is provided, it must be of the same form as the protobuf
                 message :class:`~google.cloud.spanner_v1.types.RequestOptions`.
 
+        :type max_commit_delay: :class:`datetime.timedelta`
+        :param max_commit_delay:
+                (Optional) The amount of latency this request is willing to incur
+                in order to improve throughput. Value must be between 0ms and
+                500ms.
+
         :rtype: :class:`~google.cloud.spanner_v1.database.BatchCheckout`
         :returns: new wrapper
         """
-        return BatchCheckout(self, request_options)
+        return BatchCheckout(self, request_options, max_commit_delay)
 
     def mutation_groups(self):
         """Return an object which wraps a mutation_group.
@@ -796,9 +815,13 @@ class Database(object):
 
         :type kw: dict
         :param kw: (Optional) keyword arguments to be passed to ``func``.
-                   If passed, "timeout_secs" will be removed and used to
+                   If passed,
+                   "timeout_secs" will be removed and used to
                    override the default retry timeout which defines maximum timestamp
                    to continue retrying the transaction.
+                   "max_commit_delay" will be removed and used to set the
+                   max_commit_delay for the request. Value must be between
+                   0ms and 500ms.
 
         :rtype: Any
         :returns: The return value of ``func``.
@@ -951,20 +974,40 @@ class Database(object):
         """
         return Table(table_id, self)
 
-    def list_tables(self):
+    def list_tables(self, schema="_default"):
         """List tables within the database.
 
+        :type schema: str
+        :param schema: The schema to search for tables, or None for all schemas. Use the special string "_default" to
+                       search for tables in the default schema of the database.
+
         :type: Iterable
         :returns:
             Iterable of :class:`~google.cloud.spanner_v1.table.Table`
             resources within the current database.
         """
+        if "_default" == schema:
+            schema = self.default_schema_name
+
         with self.snapshot() as snapshot:
-            if self._database_dialect == DatabaseDialect.POSTGRESQL:
-                where_clause = "WHERE TABLE_SCHEMA = 'public'"
+            if schema is None:
+                results = snapshot.execute_sql(
+                    sql=_LIST_TABLES_QUERY.format(""),
+                )
             else:
-                where_clause = "WHERE SPANNER_STATE = 'COMMITTED'"
-            results = snapshot.execute_sql(_LIST_TABLES_QUERY.format(where_clause))
+                if self._database_dialect == DatabaseDialect.POSTGRESQL:
+                    where_clause = "WHERE TABLE_SCHEMA = $1"
+                    param_name = "p1"
+                else:
+                    where_clause = (
+                        "WHERE TABLE_SCHEMA = @schema AND SPANNER_STATE = 'COMMITTED'"
+                    )
+                    param_name = "schema"
+                results = snapshot.execute_sql(
+                    sql=_LIST_TABLES_QUERY.format(where_clause),
+                    params={param_name: schema},
+                    param_types={param_name: Type(code=TypeCode.STRING)},
+                )
             for row in results:
                 yield self.table(row[0])
 
@@ -1035,9 +1078,14 @@ class BatchCheckout(object):
             (Optional) Common options for the commit request.
             If a dict is provided, it must be of the same form as the protobuf
             message :class:`~google.cloud.spanner_v1.types.RequestOptions`.
+
+    :type max_commit_delay: :class:`datetime.timedelta`
+    :param max_commit_delay:
+            (Optional) The amount of latency this request is willing to incur
+            in order to improve throughput.
     """
 
-    def __init__(self, database, request_options=None):
+    def __init__(self, database, request_options=None, max_commit_delay=None):
         self._database = database
         self._session = self._batch = None
         if request_options is None:
@@ -1046,6 +1094,7 @@ class BatchCheckout(object):
             self._request_options = RequestOptions(request_options)
         else:
             self._request_options = request_options
+        self._max_commit_delay = max_commit_delay
 
     def __enter__(self):
         """Begin ``with`` block."""
@@ -1062,6 +1111,7 @@ class BatchCheckout(object):
                 self._batch.commit(
                     return_commit_stats=self._database.log_commit_stats,
                     request_options=self._request_options,
+                    max_commit_delay=self._max_commit_delay,
                 )
         finally:
             if self._database.log_commit_stats and self._batch.commit_stats:

{google-cloud-spanner-3.42.0 → google-cloud-spanner-3.43.0}/google/cloud/spanner_v1/gapic_version.py

@@ -13,4 +13,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-__version__ = "3.42.0"  # {x-release-please-version}
+__version__ = "3.43.0"  # {x-release-please-version}

{google-cloud-spanner-3.42.0 → google-cloud-spanner-3.43.0}/google/cloud/spanner_v1/session.py

@@ -363,6 +363,8 @@ class Session(object):
                    to continue retrying the transaction.
                    "commit_request_options" will be removed and used to set the
                    request options for the commit request.
+                   "max_commit_delay" will be removed and used to set the max commit delay for the request.
+                   "transaction_tag" will be removed and used to set the transaction tag for the request.
 
         :rtype: Any
         :returns: The return value of ``func``.
@@ -372,6 +374,7 @@ class Session(object):
         """
         deadline = time.time() + kw.pop("timeout_secs", DEFAULT_RETRY_TIMEOUT_SECS)
         commit_request_options = kw.pop("commit_request_options", None)
+        max_commit_delay = kw.pop("max_commit_delay", None)
         transaction_tag = kw.pop("transaction_tag", None)
         attempts = 0
 
@@ -400,6 +403,7 @@ class Session(object):
                 txn.commit(
                     return_commit_stats=self._database.log_commit_stats,
                     request_options=commit_request_options,
+                    max_commit_delay=max_commit_delay,
                 )
             except Aborted as exc:
                 del self._transaction

{google-cloud-spanner-3.42.0 → google-cloud-spanner-3.43.0}/google/cloud/spanner_v1/snapshot.py

@@ -410,8 +410,6 @@ class _SnapshotBase(_SessionWrapper):
                 raise ValueError("Transaction ID pending.")
 
         if params is not None:
-            if param_types is None:
-                raise ValueError("Specify 'param_types' when passing 'params'.")
             params_pb = Struct(
                 fields={key: _make_value_pb(value) for key, value in params.items()}
             )
@@ -646,8 +644,6 @@ class _SnapshotBase(_SessionWrapper):
             raise ValueError("Transaction not started.")
 
         if params is not None:
-            if param_types is None:
-                raise ValueError("Specify 'param_types' when passing 'params'.")
             params_pb = Struct(
                 fields={key: _make_value_pb(value) for (key, value) in params.items()}
             )

{google-cloud-spanner-3.42.0 → google-cloud-spanner-3.43.0}/google/cloud/spanner_v1/table.py

@@ -43,13 +43,26 @@ class Table(object):
     :param database: The database that owns the table.
     """
 
-    def __init__(self, table_id, database):
+    def __init__(self, table_id, database, schema_name=None):
+        if schema_name is None:
+            self._schema_name = database.default_schema_name
+        else:
+            self._schema_name = schema_name
         self._table_id = table_id
         self._database = database
 
         # Calculated properties.
         self._schema = None
 
+    @property
+    def schema_name(self):
+        """The schema name of the table used in SQL.
+
+        :rtype: str
+        :returns: The table schema name.
+        """
+        return self._schema_name
+
     @property
     def table_id(self):
         """The ID of the table used in SQL.
@@ -59,6 +72,30 @@ class Table(object):
         """
         return self._table_id
 
+    @property
+    def qualified_table_name(self):
+        """The qualified name of the table used in SQL.
+
+        :rtype: str
+        :returns: The qualified table name.
+        """
+        if self.schema_name == self._database.default_schema_name:
+            return self._quote_identifier(self.table_id)
+        return "{}.{}".format(
+            self._quote_identifier(self.schema_name),
+            self._quote_identifier(self.table_id),
+        )
+
+    def _quote_identifier(self, identifier):
+        """Quotes the given identifier using the rules of the dialect of the database of this table.
+
+        :rtype: str
+        :returns: The quoted identifier.
+        """
+        if self._database.database_dialect == DatabaseDialect.POSTGRESQL:
+            return '"{}"'.format(identifier)
+        return "`{}`".format(identifier)
+
     def exists(self):
         """Test whether this table exists.
 
@@ -77,22 +114,27 @@ class Table(object):
         :rtype: bool
         :returns: True if the table exists, else false.
         """
-        if (
-            self._database.database_dialect
-            == DatabaseDialect.DATABASE_DIALECT_UNSPECIFIED
-        ):
-            self._database.reload()
         if self._database.database_dialect == DatabaseDialect.POSTGRESQL:
             results = snapshot.execute_sql(
-                _EXISTS_TEMPLATE.format("WHERE TABLE_NAME = $1"),
-                params={"p1": self.table_id},
-                param_types={"p1": Type(code=TypeCode.STRING)},
+                sql=_EXISTS_TEMPLATE.format(
+                    "WHERE TABLE_SCHEMA=$1 AND TABLE_NAME = $2"
+                ),
+                params={"p1": self.schema_name, "p2": self.table_id},
+                param_types={
+                    "p1": Type(code=TypeCode.STRING),
+                    "p2": Type(code=TypeCode.STRING),
+                },
             )
         else:
             results = snapshot.execute_sql(
-                _EXISTS_TEMPLATE.format("WHERE TABLE_NAME = @table_id"),
-                params={"table_id": self.table_id},
-                param_types={"table_id": Type(code=TypeCode.STRING)},
+                sql=_EXISTS_TEMPLATE.format(
+                    "WHERE TABLE_SCHEMA = @schema_name AND TABLE_NAME = @table_id"
+                ),
+                params={"schema_name": self.schema_name, "table_id": self.table_id},
+                param_types={
+                    "schema_name": Type(code=TypeCode.STRING),
+                    "table_id": Type(code=TypeCode.STRING),
+                },
             )
         return next(iter(results))[0]
 
@@ -117,7 +159,7 @@ class Table(object):
         :rtype: list of :class:`~google.cloud.spanner_v1.types.StructType.Field`
         :returns: The table schema.
         """
-        query = _GET_SCHEMA_TEMPLATE.format(self.table_id)
+        query = _GET_SCHEMA_TEMPLATE.format(self.qualified_table_name)
         results = snapshot.execute_sql(query)
         # Start iterating to force the schema to download.
         try: