[PYTHON-1124] Fail fast if prepared id mismatch. See CASSANDRA-15252

Author: TheRealFalcon

CHANGELOG.rst

@@ -8,6 +8,7 @@ Features
 * ssl context and cloud support for Eventlet (PYTHON-1162)
 * Cloud Twisted support (PYTHON-1163)
 * Add additional_write_policy and read_repair to system schema parsing (PYTHON-1048)
+* Handle prepared id mismatch when repreparing on the fly (PYTHON-1124)
 * Remove *read_repair_chance table options (PYTHON-1140)
 * Flexible version parsing (PYTHON-1174)
 * [GRAPH] Ability to execute Fluent Graph queries asynchronously (PYTHON-1129)

cassandra/cluster.py

@@ -19,6 +19,7 @@
 from __future__ import absolute_import
 
 import atexit
+from binascii import hexlify
 from collections import defaultdict
 from concurrent.futures import ThreadPoolExecutor, FIRST_COMPLETED, wait as wait_futures
 from copy import copy
@@ -4559,6 +4560,15 @@ def _execute_after_prepare(self, host, connection, pool, response):
         if isinstance(response, ResultMessage):
             if response.kind == RESULT_KIND_PREPARED:
                 if self.prepared_statement:
+                    if self.prepared_statement.query_id != response.query_id:
+                        self._set_final_exception(DriverException(
+                            "ID mismatch while trying to reprepare (expected {expected}, got {got}). "
+                            "This prepared statement won't work anymore. "
+                            "This usually happens when you run a 'USE...' "
+                            "query after the statement was prepared.".format(
+                                expected=hexlify(self.prepared_statement.query_id), got=hexlify(response.query_id)
+                            )
+                        ))
                     self.prepared_statement.result_metadata = response.column_metadata
                     new_metadata_id = response.result_metadata_id
                     if new_metadata_id is not None:

tests/integration/standard/test_prepared_statements.py

@@ -19,7 +19,7 @@
     import unittest2 as unittest
 except ImportError:
     import unittest  # noqa
-from cassandra import InvalidRequest
+from cassandra import InvalidRequest, DriverException
 
 from cassandra import ConsistencyLevel, ProtocolVersion
 from cassandra.cluster import Cluster
@@ -397,6 +397,22 @@ def test_raise_error_on_prepared_statement_execution_dropped_table(self):
         with self.assertRaises(InvalidRequest):
             self.session.execute(prepared, [0])
 
+    def test_fail_if_different_query_id_on_reprepare(self):
+        """ PYTHON-1124 and CASSANDRA-15252 """
+        keyspace = "test_fail_if_different_query_id_on_reprepare"
+        self.session.execute(
+            "CREATE KEYSPACE IF NOT EXISTS {} WITH replication = "
+            "{{'class': 'SimpleStrategy', 'replication_factor': 1}}".format(keyspace)
+        )
+        self.session.execute("CREATE TABLE IF NOT EXISTS {}.foo(k int PRIMARY KEY)".format(keyspace))
+        prepared = self.session.prepare("SELECT * FROM {}.foo WHERE k=?".format(keyspace))
+        self.session.execute("DROP TABLE {}.foo".format(keyspace))
+        self.session.execute("CREATE TABLE {}.foo(k int PRIMARY KEY)".format(keyspace))
+        self.session.execute("USE {}".format(keyspace))
+        with self.assertRaises(DriverException) as e:
+            self.session.execute(prepared, [0])
+        self.assertIn("ID mismatch", str(e.exception))
+
 
 @greaterthanorequalcass40
 class PreparedStatementInvalidationTest(BasicSharedKeyspaceUnitTestCase):

tests/unit/test_response_future.py

@@ -563,19 +563,22 @@ def test_prepared_query_not_found_bad_keyspace(self):
         self.assertRaises(ValueError, rf.result)
 
     def test_repeat_orig_query_after_succesful_reprepare(self):
+        query_id = b'abc123'  # Just a random binary string so we don't hit id mismatch exception
         session = self.make_session()
         rf = self.make_response_future(session)
 
         response = Mock(spec=ResultMessage,
                         kind=RESULT_KIND_PREPARED,
                         result_metadata_id='foo')
         response.results = (None, None, None, None, None)
+        response.query_id = query_id
 
         rf._query = Mock(return_value=True)
         rf._execute_after_prepare('host', None, None, response)
         rf._query.assert_called_once_with('host')
 
         rf.prepared_statement = Mock()
+        rf.prepared_statement.query_id = query_id
         rf._query = Mock(return_value=True)
         rf._execute_after_prepare('host', None, None, response)
         rf._query.assert_called_once_with('host')