avoid multiple prepares per host with multiple sessions

aholmberg · aholmberg · commit cd8eaed39e43 · 2014-01-15T10:55:09.000-06:00
diff --git a/driver-core/src/main/java/com/datastax/driver/core/Cluster.java b/driver-core/src/main/java/com/datastax/driver/core/Cluster.java
@@ -1106,14 +1106,10 @@ public void ensurePoolsSizing() {
             }
         }
 
-        // Prepare a query on all nodes
-        // Note that this *assumes* the query is valid.
-        public void prepare(PreparedStatement stmt, InetAddress toExclude) throws InterruptedException {
+        public void addPrepared(PreparedStatement stmt) {
             if (preparedQueries.putIfAbsent(stmt.id, stmt) != null)
                 logger.warn("Re-preparing already prepared query {}. Please note that preparing the same query more than once is "
                           + "generally an anti-pattern and will likely affect performance. Consider preparing the statement only once.", stmt.getQueryString());
-            for (SessionManager s : sessions)
-                s.prepare(stmt.getQueryString(), toExclude);
         }
 
         private void prepareAllQueries(Host host) throws InterruptedException {
diff --git a/driver-core/src/main/java/com/datastax/driver/core/SessionManager.java b/driver-core/src/main/java/com/datastax/driver/core/SessionManager.java
@@ -144,8 +144,9 @@ private PreparedStatement toPreparedStatement(String query, Connection.Future fu
                         case PREPARED:
                             ResultMessage.Prepared pmsg = (ResultMessage.Prepared)rm;
                             PreparedStatement stmt = PreparedStatement.fromMessage(pmsg, cluster.getMetadata(), query, poolsState.keyspace);
+                            cluster.manager.addPrepared(stmt);
                             try {
-                                cluster.manager.prepare(stmt, future.getAddress());
+                                prepare(stmt.getQueryString(), future.getAddress());
                             } catch (InterruptedException e) {
                                 Thread.currentThread().interrupt();
                                 // This method doesn't propagate interruption, at least not for now. However, if we've

Original file line number	Diff line number	Diff line change
`@@ -1106,14 +1106,10 @@ public void ensurePoolsSizing() {`
`1106`	`1106`	`}`
`1107`	`1107`	`}`
`1108`	`1108`
`1109`		`- // Prepare a query on all nodes`
`1110`		`- // Note that this assumes the query is valid.`
`1111`		`- public void prepare(PreparedStatement stmt, InetAddress toExclude) throws InterruptedException {`
	`1109`	`+ public void addPrepared(PreparedStatement stmt) {`
`1112`	`1110`	`if (preparedQueries.putIfAbsent(stmt.id, stmt) != null)`
`1113`	`1111`	`logger.warn("Re-preparing already prepared query {}. Please note that preparing the same query more than once is "`
`1114`	`1112`	`+ "generally an anti-pattern and will likely affect performance. Consider preparing the statement only once.", stmt.getQueryString());`
`1115`		`- for (SessionManager s : sessions)`
`1116`		`- s.prepare(stmt.getQueryString(), toExclude);`
`1117`	`1113`	`}`
`1118`	`1114`
`1119`	`1115`	`private void prepareAllQueries(Host host) throws InterruptedException {`