refactor(): interpolate type discriminator instead of binding it as a positional parameter

type/design_document is a class-level constant (equivalent to a table name) and
should not consume a positional parameter slot. Interpolating it gives each model
class its own query fingerprint for prepared-statement caching, consistent with
how bucket.name is treated. Applies to all three callsites: n1ql.rb, relation.rb,
and has_many.rb.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: pimpin

lib/couchbase-orm/n1ql.rb

@@ -100,12 +100,7 @@ def build_where(keys, values, params: nil)
                             .reject { |key, value| key.nil? && value.nil? }
                             .map { |key, value| build_match(key, value, params: params) }
                             .join(" AND ")
-                if params
-                    type_placeholder = bind(design_document, params)
-                    "type=#{type_placeholder} #{"AND " + where unless where.blank?}"
-                else
-                    "type=\"#{design_document}\" #{"AND " + where unless where.blank?}"
-                end
+                "type=\"#{design_document}\" #{"AND " + where unless where.blank?}"
             end
 
             # order-by-clause ::= ORDER BY ordering-term [ ',' ordering-term ]*

lib/couchbase-orm/relation.rb

@@ -193,7 +193,7 @@ def build_order
             end
 
             def build_where_with_params(params)
-                build_conds_with_params([[:type, @model.design_document]] + @where, params)
+                build_conds_with_params([[nil, "type = #{@model.quote(@model.design_document)}"]] + @where, params)
             end
 
             def build_conds_with_params(conds, params)

lib/couchbase-orm/utilities/has_many.rb

@@ -96,8 +96,8 @@ def build_index_n1ql(klass, remote_class, remote_method, through_key, foreign_ke
                 klass.class_eval do
                   n1ql remote_method, emit_key: 'id', query_fn: proc { |bucket, values, options|
                     raise ArgumentError, "values[0] must not be blank" if values[0].blank?
-                    n1ql_query = "SELECT raw #{through_key} FROM `#{bucket.name}` where type = $1 and #{foreign_key} = $2"
-                    params = [design_document, values[0]]
+                    n1ql_query = "SELECT raw #{through_key} FROM `#{bucket.name}` where type = \"#{design_document}\" and #{foreign_key} = $1"
+                    params = [values[0]]
                     cluster.query(n1ql_query, Couchbase::Options::Query.new(
                       positional_parameters: params,
                       scan_consistency: options.instance_variable_get(:@scan_consistency)

spec/n1ql_spec.rb

@@ -174,7 +174,7 @@ class N1QLTest < CouchbaseOrm::Base
         N1QLTest.by_rating_reverse()
         expect(CouchbaseOrm.logger).to have_received(:debug).at_least(:once) do |&block|
             msg = block ? block.call : nil
-            msg == "N1QL query: select raw meta().id from `#{CouchbaseOrm::Connection.bucket.name}` where type=$1  order by name DESC  params: [\"n1_ql_test\"] return 0 rows with scan_consistency: #{described_class::DEFAULT_SCAN_CONSISTENCY}"
+            msg == "N1QL query: select raw meta().id from `#{CouchbaseOrm::Connection.bucket.name}` where type=\"n1_ql_test\"  order by name DESC  params: [] return 0 rows with scan_consistency: #{described_class::DEFAULT_SCAN_CONSISTENCY}"
         end
     end
 
@@ -185,14 +185,14 @@ class N1QLTest < CouchbaseOrm::Base
         N1QLTest.by_rating_reverse()
         expect(CouchbaseOrm.logger).to have_received(:debug).at_least(:once) do |&block|
             msg = block ? block.call : nil
-            msg == "N1QL query: select raw meta().id from `#{CouchbaseOrm::Connection.bucket.name}` where type=$1  order by name DESC  params: [\"n1_ql_test\"] return 0 rows with scan_consistency: not_bounded"
+            msg == "N1QL query: select raw meta().id from `#{CouchbaseOrm::Connection.bucket.name}` where type=\"n1_ql_test\"  order by name DESC  params: [] return 0 rows with scan_consistency: not_bounded"
         end
 
         CouchbaseOrm::N1ql.config(default_n1ql_config)
         N1QLTest.by_rating_reverse()
         expect(CouchbaseOrm.logger).to have_received(:debug).at_least(:once) do |&block|
             msg = block ? block.call : nil
-            msg == "N1QL query: select raw meta().id from `#{CouchbaseOrm::Connection.bucket.name}` where type=$1  order by name DESC  params: [\"n1_ql_test\"] return 0 rows with scan_consistency: #{described_class::DEFAULT_SCAN_CONSISTENCY}"
+            msg == "N1QL query: select raw meta().id from `#{CouchbaseOrm::Connection.bucket.name}` where type=\"n1_ql_test\"  order by name DESC  params: [] return 0 rows with scan_consistency: #{described_class::DEFAULT_SCAN_CONSISTENCY}"
         end
     end
 

spec/relation_spec.rb

@@ -314,49 +314,48 @@ def self.active
         it "should return parameterized query with to_n1ql_with_params" do
             relation = RelationModel.where(active: true, name: "Jane")
             n1ql, params = relation.send(:to_n1ql_with_params)
-            expect(n1ql).to include("type = $1")
-            expect(n1ql).to include("active = $2")
-            expect(n1ql).to include("name = $3")
-            expect(n1ql).not_to include("\"relation_model\"")
+            expect(n1ql).to include("type = 'relation_model'")
+            expect(n1ql).to include("active = $1")
+            expect(n1ql).to include("name = $2")
             expect(n1ql).not_to include("'Jane'")
-            expect(params).to eq(["relation_model", true, "Jane"])
+            expect(params).to eq([true, "Jane"])
         end
 
         it "should parameterize NOT conditions" do
             relation = RelationModel.not(active: true)
             n1ql, params = relation.send(:to_n1ql_with_params)
-            expect(n1ql).to include("active != $2")
-            expect(params).to eq(["relation_model", true])
+            expect(n1ql).to include("active != $1")
+            expect(params).to eq([true])
         end
 
         it "should parameterize range conditions" do
             relation = RelationModel.where(age: 10..30)
             n1ql, params = relation.send(:to_n1ql_with_params)
-            expect(n1ql).to include("age >= $2")
-            expect(n1ql).to include("age <= $3")
-            expect(params).to eq(["relation_model", 10, 30])
+            expect(n1ql).to include("age >= $1")
+            expect(n1ql).to include("age <= $2")
+            expect(params).to eq([10, 30])
         end
 
         it "should parameterize hash operator conditions" do
             relation = RelationModel.where(age: { _gte: 18, _lt: 65 })
             n1ql, params = relation.send(:to_n1ql_with_params)
-            expect(n1ql).to include("age >= $2")
-            expect(n1ql).to include("age < $3")
-            expect(params).to eq(["relation_model", 18, 65])
+            expect(n1ql).to include("age >= $1")
+            expect(n1ql).to include("age < $2")
+            expect(params).to eq([18, 65])
         end
 
         it "should pass through string conditions without parameterization" do
             relation = RelationModel.where("active = true")
             n1ql, params = relation.send(:to_n1ql_with_params)
             expect(n1ql).to include("(active = true)")
-            expect(params).to eq(["relation_model"])
+            expect(params).to eq([])
         end
 
         it "should parameterize array IN conditions" do
             relation = RelationModel.where(name: ["Alice", "Bob"])
             n1ql, params = relation.send(:to_n1ql_with_params)
-            expect(n1ql).to include("name IN $2")
-            expect(params).to eq(["relation_model", ["Alice", "Bob"]])
+            expect(n1ql).to include("name IN $1")
+            expect(params).to eq([["Alice", "Bob"]])
         end
     end