MB-70998 Fix issues with auto prepare

Several issues were identified with Auto Prepare functionality
while working on plan stability.

1. With auto-prepared plan, we do not attempt to reprepare if
plan verification fails, instead, we should proceed to normal
processing as if the auto-prepared statement were not there.
However, current code still returns the prepared statement to
the caller and attempt to execute that prepared statement fails
resulting in an error for the statement.

The fix for this part is to detect verification failure and
return a nil for prepared statement.

2. If a statement has references to query parameters, e.g.
named parameter and/or positional parameter, auto prepare
should skip attempting to prepare such a statement. However,
current code would skip auto prepare of a statement if there
are any named/positional parameters defined in the environment,
even if the statement itself does not reference any of the
query parameters.

The fix for this part is to check for actual query parameter
references in the statement, instead of just query parameters
defined in the environment.

3. Auto prepare currently takes DDL statements, which is
unnecessary. We backport the functionality from plan stability
to skip DDL statements for auto prepare.

Change-Id: I443a52c9eab520a45706a77f06cb840d034b2208
Reviewed-on: https://review.couchbase.org/c/query/+/241858
Tested-by: Sitaram Vemulapalli <sitaram.vemulapalli@couchbase.com>
Well-Formed: Restriction Checker
Reviewed-by: Sitaram Vemulapalli <sitaram.vemulapalli@couchbase.com>

Author: miaobingjie

algebra/algebra.go

@@ -68,7 +68,7 @@ type Statement interface {
 	/*
 		Returns the parameter count, for AutoPrepare and other purposes
 	*/
-	Params() int
+	ParamsCount() int
 
 	/*
 		Returns the optimizer hints

algebra/base.go

@@ -76,7 +76,7 @@ func (this *statementBase) SetParamsCount(params int) {
 /*
 does it have parameters?
 */
-func (this *statementBase) Params() int {
+func (this *statementBase) ParamsCount() int {
 	return this.paramCount
 }
 

algebra/statement_util.go

@@ -0,0 +1,28 @@
+//  Copyright 2026-Present Couchbase, Inc.
+//
+//  Use of this software is governed by the Business Source License included
+//  in the file licenses/BSL-Couchbase.txt.  As of the Change Date specified
+//  in that file, in accordance with the Business Source License, use of this
+//  software will be governed by the Apache License, Version 2.0, included in
+//  the file licenses/APL2.txt.
+
+package algebra
+
+/*
+ * With auto prepare, determine whether a statement can skip being prepared
+ */
+func CanSkipAutoPrepare(stmt Statement) bool {
+	switch stmt.(type) {
+	case *InferKeyspace, *InferExpression, *Explain, *ExplainFunction, *Prepare, *Execute,
+		*UpdateStatistics,
+		*CreateIndex, *DropIndex, *BuildIndexes, *AlterIndex, *CreatePrimaryIndex,
+		*CreateScope, *DropScope,
+		*CreateCollection, *DropCollection, *FlushCollection,
+		*GrantRole, *RevokeRole,
+		*CreateFunction, *DropFunction, *ExecuteFunction,
+		*StartTransaction, *CommitTransaction, *RollbackTransaction, *Savepoint, *TransactionIsolation,
+		*CreateSequence, *DropSequence, *AlterSequence:
+		return true
+	}
+	return false
+}

prepareds/prepareds.go

@@ -423,7 +423,7 @@ func AddAutoPreparePlan(stmt algebra.Statement, prepared *plan.Prepared) bool {
 
 	// we also don't cache anything that might depend on placeholders
 	// (you should be using prepared statements for that anyway!)
-	if stmt.Params() > 0 {
+	if stmt.ParamsCount() > 0 {
 		return false
 	}
 
@@ -628,7 +628,11 @@ func (prepareds *preparedCache) getPrepared(preparedName string, queryContext st
 		// without blocking the whole prepared cacheline
 		// locking will occur at adding time: both requests will insert,
 		// the last wins
-		if (!good || prepared.PreparedTime().IsZero()) && !metaCheck {
+		if metaCheck {
+			if !good {
+				prepared = nil
+			}
+		} else if !good || prepared.PreparedTime().IsZero() {
 			prepared, err = reprepare(prepared, nil, phaseTime, log)
 			if err == nil {
 				err = AddPrepared(prepared)

server/server.go

@@ -1474,7 +1474,7 @@ func (this *Server) getPrepared(request Request, context *execution.Context) (*p
 	positionalArgs := request.PositionalArgs()
 	dsContext := context
 	autoExecute := request.AutoExecute() == value.TRUE
-	if len(namedArgs) > 0 || len(positionalArgs) > 0 || autoExecute {
+	if autoExecute {
 		autoPrepare = false
 	}
 
@@ -1504,6 +1504,14 @@ func (this *Server) getPrepared(request Request, context *execution.Context) (*p
 			return nil, errors.NewParseSyntaxError(err, "")
 		}
 
+		if autoPrepare {
+			if stmt.ParamsCount() > 0 {
+				autoPrepare = false
+			} else if algebra.CanSkipAutoPrepare(stmt) {
+				autoPrepare = false
+			}
+		}
+
 		isPrepare := false
 		if _, ok := stmt.(*algebra.Prepare); ok {
 			isPrepare = true