aws_advanced_ruby_driver_wrapper 1.0.1 → 1.1.0

data/lib/aws_advanced_ruby_driver_wrapper/utils/parser/mysql_statement_analyzer.rb

@@ -14,6 +14,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+require_relative 'mysql_text'
 require_relative 'query_analysis'
 require_relative 'query_type'
 
@@ -63,18 +64,17 @@ module AwsAdvancedRubyDriverWrapper
 
         INSERT_COLUMNS = /#{INSERT_START}#{IDENTIFIER_NC}\s*\(([^)]+)\)/i
         # The body of a SET clause, ended at the WHERE that follows it, at the statement terminator, or
-        # at the end of the text. Matched against a copy with every quoted literal blanked (see
-        # +mask_quoted_literals+), so a +WHERE+ or +;+ that is only part of a string value does not end
-        # the clause early; the offsets it reports still index the original text.
+        # at the end of the text. Matched against a copy with every quoted literal and comment blanked
+        # (see +mask_non_code+), so a +WHERE+ or +;+ that is only part of a string value or a comment
+        # does not end the clause early; the offsets it reports still index the original text.
         SET_CLAUSE     = /\bSET\b([^;]+?)(?:\bWHERE\b|\z)/im
         VALUES_CLAUSE  = /\A\s*VALUES?\s*/i
         ON_DUPLICATE   = /\AON\s+DUPLICATE\s+KEY\s+UPDATE\b/i
         ASSIGNMENT     = /\A#{IDENTIFIER_CAP}\s*=\s*(.+)\z/m
         NULL_VALUE     = /\ANULL\z/i
-        QUOTES         = ["'", '"', '`'].freeze
         # The body of a WHERE clause, ended at the first trailing-clause keyword or at the end of the
-        # text. Like SET_CLAUSE, matched against a quote-blanked copy so a keyword that is only part of
-        # a string value - +WHERE note = 'a ORDER BY b'+ - does not end the clause early.
+        # text. Like SET_CLAUSE, matched against a blanked copy so a keyword that is only part of a
+        # string value or a comment - +WHERE note = 'a ORDER BY b'+ - does not end the clause early.
         WHERE_CLAUSE   = /
           \bWHERE\b([^;]+?)
           (?:\bGROUP\s+BY\b|\bHAVING\b|\bORDER\s+BY\b|\bLIMIT\b|
@@ -107,12 +107,10 @@ module AwsAdvancedRubyDriverWrapper
         CREATE_KEYWORD = /\ACREATE\b/
         DROP_KEYWORD   = /\ADROP\b/
 
-        # Whitespace and comments in front of a statement. Query instrumentation and ORMs prepend a
-        # comment routinely, and it says nothing about what the statement does.
-        # Wrapped in an atomic group, and matching whitespace one character at a time rather than in
-        # +\s++ runs, so that leading whitespace and comments cannot be re-partitioned on backtracking
-        # - which would be quadratic on input like "/* /* /* ...".
-        LEADING_NOISE  = %r{\A(?>(?:\s|/\*.*?\*/|--[^\n]*|#[^\n]*)+)}m
+        # Whitespace in front of a statement, which includes what any comment in front of it was
+        # blanked to (see +analyze+). Query instrumentation and ORMs prepend a comment routinely, and
+        # it says nothing about what the statement does.
+        LEADING_NOISE  = /\A\s+/
         CTE_START      = /\AWITH\s+(?:RECURSIVE\s+)?/i
         CTE_NAME       = /\A#{IDENTIFIER_NC}\s*/
         CTE_AS         = /\AAS\s+(?:(?:NOT\s+)?MATERIALIZED\s*)?/i
@@ -128,9 +126,15 @@ module AwsAdvancedRubyDriverWrapper
 
         module_function
 
-        def analyze(sql)
+        # @param server_version [Integer, nil] the version of the server the statement is sent to, as
+        #   MySQL numbers it, which decides whether a versioned +/*!+ comment is part of the statement
+        def analyze(sql, server_version: nil)
           return QueryAnalysis.unknown unless sql.is_a?(String) && !sql.strip.empty?
 
+          # A comment can sit anywhere whitespace can - between a keyword and its table, inside a
+          # column list, next to a placeholder - so every pattern below reads the text with its
+          # comments blanked out, and every scan of it below looks for literals alone.
+          sql = MysqlText.blank_comments(sql, server_version: server_version)
           body, preceding_parameters = statement_body(sql)
           return QueryAnalysis.unknown if body.nil?
 
@@ -210,8 +214,7 @@ module AwsAdvancedRubyDriverWrapper
             tables: tables.freeze,
             write_columns: [].freeze,
             where_columns: where_cols.freeze,
-            for_update: FOR_UPDATE.match?(sql),
-            parameterized: sql.include?('?')
+            for_update: FOR_UPDATE.match?(sql)
           )
         end
 
@@ -225,7 +228,6 @@ module AwsAdvancedRubyDriverWrapper
             write_columns: bound.freeze,
             where_columns: [].freeze,
             for_update: false,
-            parameterized: sql.include?('?'),
             unbound_write_columns: unbound.freeze,
             write_columns_complete: complete
           )
@@ -245,7 +247,6 @@ module AwsAdvancedRubyDriverWrapper
             write_columns: set_cols.freeze,
             where_columns: where_cols.freeze,
             for_update: false,
-            parameterized: sql.include?('?'),
             unbound_write_columns: unbound.freeze,
             write_columns_complete: complete
           )
@@ -279,7 +280,6 @@ module AwsAdvancedRubyDriverWrapper
             write_columns: [].freeze,
             where_columns: extract_where_columns(sql, first_index),
             for_update: false,
-            parameterized: sql.include?('?'),
             unbound_write_columns: unbound.freeze,
             write_columns_complete: false
           )
@@ -303,8 +303,7 @@ module AwsAdvancedRubyDriverWrapper
             tables: table ? [table].freeze : [].freeze,
             write_columns: [].freeze,
             where_columns: where_cols.freeze,
-            for_update: false,
-            parameterized: sql.include?('?')
+            for_update: false
           )
         end
 
@@ -315,8 +314,7 @@ module AwsAdvancedRubyDriverWrapper
             tables: table ? [table].freeze : [].freeze,
             write_columns: [].freeze,
             where_columns: [].freeze,
-            for_update: false,
-            parameterized: false
+            for_update: false
           )
         end
 
@@ -327,8 +325,7 @@ module AwsAdvancedRubyDriverWrapper
             tables: table ? [table].freeze : [].freeze,
             write_columns: [].freeze,
             where_columns: [].freeze,
-            for_update: false,
-            parameterized: false
+            for_update: false
           )
         end
 
@@ -372,9 +369,10 @@ module AwsAdvancedRubyDriverWrapper
             complete = false unless values.length == columns.length
             columns.each_with_index do |column_name, position|
               value = values[position]
-              if value == '?'
+              code = code_of(value.to_s)
+              if code == '?'
                 bound << ColumnInfo.new(table_name: table_name, column_name: column_name, parameter_index: index)
-              elsif !NULL_VALUE.match?(value.to_s)
+              elsif !NULL_VALUE.match?(code)
                 unbound << ColumnInfo.new(table_name: table_name, column_name: column_name)
               end
               index += placeholder_count(value.to_s)
@@ -391,7 +389,7 @@ module AwsAdvancedRubyDriverWrapper
         # @param first_index [Integer] the number the statement's first bind parameter has
         # @return [Array(Array<ColumnInfo>, Array<ColumnInfo>, Boolean)] as extract_insert_columns
         def extract_set_columns(sql, table_name, first_index)
-          match = SET_CLAUSE.match(mask_quoted_literals(sql))
+          match = SET_CLAUSE.match(mask_non_code(sql))
           return [[], [], false] unless match
 
           # The offsets come from the masked copy; the clause read from them is the original text.
@@ -440,10 +438,11 @@ module AwsAdvancedRubyDriverWrapper
             end
 
             value = match[2].strip
+            code = code_of(value)
             column = ColumnInfo.new(table_name: table_name, column_name: column_name_of(match[1]), parameter_index: index)
-            if value == '?'
+            if code == '?'
               bound << column
-            elsif !NULL_VALUE.match?(value)
+            elsif !NULL_VALUE.match?(code)
               unbound << column.with(parameter_index: nil)
             end
             index += placeholder_count(value)
@@ -462,14 +461,18 @@ module AwsAdvancedRubyDriverWrapper
         #
         # @param first_index [Integer] the number the statement's first bind parameter has
         def extract_where_columns(sql, first_index = 1)
-          match = WHERE_CLAUSE.match(mask_quoted_literals(sql))
+          masked = mask_non_code(sql)
+          match = WHERE_CLAUSE.match(masked)
           return [].freeze unless match
 
           # The offsets come from the masked copy; the clause read from them is the original text.
+          # Its placeholders are counted on the masked copy, so that a question mark inside a string
+          # value is not taken for one.
           where_body = sql[match.begin(1)...match.end(1)]
-          return [].freeze unless where_body.include?('?')
+          masked_body = masked[match.begin(1)...match.end(1)]
+          return [].freeze unless masked_body.include?('?')
 
-          base = first_index + placeholder_count(sql[0...match.begin(1)])
+          base = first_index + masked[0...match.begin(1)].count('?')
 
           cols = []
           pos = 0
@@ -477,10 +480,10 @@ module AwsAdvancedRubyDriverWrapper
             pos = m.end(0)
             # Groups: 1=BETWEEN col, 2=BETWEEN sentinel, 3=+col OP ?+, 4=+? OP col+, 5=IN col, 6=LIKE col
             col = strip_quotes((m[1] || m[3] || m[4] || m[5] || m[6]).to_s)
-            index = base + placeholder_count(where_body[0...m.begin(0)])
+            index = base + masked_body[0...m.begin(0)].count('?')
             # One entry per bound parameter the predicate consumes: one for +=+ or +LIKE+, two for a
             # +BETWEEN+, and one per placeholder for an +IN (?, ?, ...)+.
-            placeholder_count(m[0]).times do |offset|
+            masked_body[m.begin(0)...m.end(0)].count('?').times do |offset|
               cols << ColumnInfo.new(table_name: nil, column_name: col, parameter_index: index + offset)
             end
           end
@@ -547,7 +550,7 @@ module AwsAdvancedRubyDriverWrapper
 
           depth = 0
           closed_at = nil
-          unclosed_quote = each_unquoted_char(group) do |char, index|
+          unclosed = MysqlText.each_code_char(group, comments: false) do |char, index|
             next if closed_at
 
             # No else: only parentheses affect the depth, so every other character is ignored.
@@ -558,18 +561,18 @@ module AwsAdvancedRubyDriverWrapper
               closed_at = index if depth.zero?
             end
           end
-          return [nil, nil] if unclosed_quote || closed_at.nil?
+          return [nil, nil] if unclosed || closed_at.nil?
 
           [group[1...closed_at], group[(closed_at + 1)..]]
         end
 
-        # Splits a comma separated list, ignoring commas inside quotes or nested parentheses.
+        # Splits a comma separated list, ignoring commas inside quotes, comments or nested parentheses.
         #
-        # @return [Array<String>, nil] nil when the quotes or parentheses do not balance
+        # @return [Array<String>, nil] nil when the quotes, comments or parentheses do not balance
         def split_top_level(text)
           depth = 0
           boundaries = []
-          unclosed_quote = each_unquoted_char(text) do |char, index|
+          unclosed = MysqlText.each_code_char(text, comments: false) do |char, index|
             # No else: only parentheses and top-level commas matter, so every other character is ignored.
             case char
             when '(' then depth += 1
@@ -577,7 +580,7 @@ module AwsAdvancedRubyDriverWrapper
             when ',' then boundaries << index if depth.zero?
             end
           end
-          return nil if unclosed_quote || !depth.zero?
+          return nil if unclosed || !depth.zero?
 
           from = 0
           parts = boundaries.map do |at|
@@ -589,51 +592,27 @@ module AwsAdvancedRubyDriverWrapper
         end
 
         # How many bind parameters a value expression consumes. A question mark inside a quoted
-        # literal is not one of them.
+        # literal is not one of them, and neither was one inside a comment, which +analyze+ blanked.
         def placeholder_count(text)
           count = 0
-          each_unquoted_char(text) { |char, _index| count += 1 if char == '?' }
+          MysqlText.each_code_char(text, comments: false) { |char, _index| count += 1 if char == '?' }
           count
         end
 
-        # The text with the contents of every quoted literal, and the quote marks themselves, replaced
-        # by spaces. Length and every offset are left unchanged, so a clause boundary found here with a
-        # pattern slices the original text exactly, while a keyword or terminator that was only part of
-        # a string value is no longer there to be found.
-        def mask_quoted_literals(text)
+        # The text with every quoted literal, quotes included, replaced by spaces, on top of the
+        # comments +analyze+ blanked. Length and every offset are left unchanged, so a clause boundary
+        # found here with a pattern slices the original text exactly, while a keyword or terminator
+        # that was only part of a string value or a comment is no longer there to be found.
+        def mask_non_code(text)
           masked = ' ' * text.length
-          each_unquoted_char(text) { |char, index| masked[index] = char }
+          MysqlText.each_code_char(text, comments: false) { |char, index| masked[index] = char }
           masked
         end
 
-        # Walks the text once, yielding every character that is not inside a quoted literal along
-        # with its index. Backslash escapes are skipped, and a doubled quote reads as one closing and
-        # one opening quote, which leaves the state right either way.
-        #
-        # @return [String, nil] the quote character still open when the text ran out, nil when the
-        #   text ended outside a quoted literal
-        def each_unquoted_char(text)
-          index = 0
-          quote = nil
-
-          while index < text.length
-            char = text[index]
-            if quote
-              if char == '\\' && quote != '`'
-                index += 2
-                next
-              end
-
-              quote = nil if char == quote
-            elsif QUOTES.include?(char)
-              quote = char
-            else
-              yield(char, index)
-            end
-            index += 1
-          end
-
-          quote
+        # A value expression with its literals taken out and the space a blanked comment left trimmed,
+        # so that a comment next to a lone placeholder or NULL does not hide what the value is.
+        def code_of(value)
+          mask_non_code(value).strip
         end
       end
     end

data/lib/aws_advanced_ruby_driver_wrapper/utils/parser/mysql_text.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+#  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License").
+#  You may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+module AwsAdvancedRubyDriverWrapper
+  module Utils
+    module Parser
+      # Reads MySQL statement text the way the server's lexer separates code from what is not code:
+      # quoted literals and comments. Anything that counts the +?+ placeholders of a statement has to
+      # skip both, since a +?+ inside either is not a placeholder, and miscounting one binds a value
+      # to the wrong column.
+      module MysqlText
+        # The quote characters a literal can be wrapped in. A backtick quotes an identifier rather than
+        # a value, but is included so a +?+ inside a backtick-quoted name is not miscounted either.
+        QUOTES = ["'", '"', '`'].freeze
+        # What a block comment that never closes is reported as by {each_code_char}.
+        UNCLOSED_COMMENT = '/*'
+
+        # The server version from which MySQL reads a six-digit version in a +/*!+ comment.
+        SIX_DIGIT_VERSIONS_FROM = 80_100
+
+        module_function
+
+        # Yields every character that is code, along with its index, skipping quoted literals and
+        # comments (see {each_segment}).
+        #
+        # @param server_version [Integer, nil] see {each_segment}
+        # @param comments [Boolean] see {each_segment}
+        # @return [String, nil] the quote character, or {UNCLOSED_COMMENT}, still open when the text
+        #   ran out; nil when the text ended in code or in a line comment
+        def each_code_char(text, server_version: nil, comments: true)
+          each_segment(text, server_version: server_version, comments: comments) do |kind, from, to|
+            (from...to).each { |index| yield(text[index], index) } if kind == :code
+          end
+        end
+
+        # The text with every comment replaced by spaces, and its literals left as they are. Length and
+        # every offset are unchanged, so a pattern that has to see quoted names, which a comment can
+        # sit between, can be matched against it and its offsets used on the original text.
+        #
+        # What is left is to be read for its literals alone (+comments: false+), not scanned for
+        # comments again: blanking +0--/**/?+ leaves +0--    ?+, where the dashes now look like the
+        # start of a comment the server never saw.
+        #
+        # @param server_version [Integer, nil] see {each_segment}
+        def blank_comments(text, server_version: nil)
+          blanked = text.dup
+          each_segment(text, server_version: server_version) do |kind, from, to|
+            blanked[from...to] = ' ' * (to - from) if kind == :comment
+          end
+          blanked
+        end
+
+        # Walks the text once, yielding each run of code, quoted literal or comment as its kind and the
+        # range of indices it covers. A literal or block comment that never closes runs to the end.
+        #
+        # Inside a literal a backslash escapes the next character, except inside a backtick, and a
+        # doubled quote reads as one closing and one opening quote, which leaves the state right
+        # either way. A comment is +/* ... */+, +#+ to the end of the line, or +--+ to the end of the
+        # line when whitespace or a control character follows the dashes, as MySQL requires; without
+        # it the dashes are two minus signs.
+        #
+        # A +/*! ... */+ comment holds code that MySQL runs, so only its opening +/*!+ and its closing
+        # +*/+ are comment and what is between them is read as code. When the +!+ is followed by a
+        # version, +/*!80023 ... */+, MySQL runs the code only on a server of that version or later,
+        # and on an older one the whole of it is a comment. Which of the two it is depends on the
+        # server the statement is sent to, so the comment is read as code when that is not known.
+        #
+        # @param server_version [Integer, nil] the version of the server the statement is sent to, as
+        #   MySQL numbers it (8.0.39 is 80039), or nil when it is not known
+        # @param comments [Boolean] whether to look for comments at all; false for text whose comments
+        #   have already been blanked (see {blank_comments}), so that only literals are skipped
+        # @yieldparam kind [Symbol] +:code+, +:literal+ or +:comment+
+        # @return [String, nil] as {each_code_char}
+        def each_segment(text, server_version: nil, comments: true)
+          index = 0
+          code_from = 0
+          executable_open = false
+
+          while index < text.length
+            kind, finish = if comments
+                             segment_at(text, index, server_version, executable_open)
+                           elsif QUOTES.include?(text[index])
+                             [:literal, literal_end(text, index)]
+                           end
+            if kind.nil?
+              index += 1
+              next
+            end
+
+            case kind
+            when :executable_open then executable_open = true
+            when :executable_close then executable_open = false
+            end
+            yield(:code, code_from, index) if code_from < index
+            yield(kind == :literal ? :literal : :comment, index, finish || text.length)
+            return kind == :literal ? text[index] : UNCLOSED_COMMENT if finish.nil?
+
+            index = code_from = finish
+          end
+
+          yield(:code, code_from, index) if code_from < index
+          executable_open ? UNCLOSED_COMMENT : nil
+        end
+
+        # What starts at +index+, if it is not code.
+        #
+        # @return [Array(Symbol, Integer), nil] its kind and the index just past it, which is nil when it
+        #   never ends; nil when the character is code
+        def segment_at(text, index, server_version, executable_open)
+          char = text[index]
+          if QUOTES.include?(char)
+            [:literal, literal_end(text, index)]
+          elsif text[index, 3] == '/*!'
+            executable_comment(text, index, server_version)
+          elsif executable_open && text[index, 2] == '*/'
+            [:executable_close, index + 2]
+          elsif text[index, 2] == '/*'
+            close = text.index('*/', index + 2)
+            [:comment, close && (close + 2)]
+          elsif char == '#' || dash_comment?(text, index)
+            [:comment, text.index("\n", index) || text.length]
+          end
+        end
+
+        # A +/*!+ comment: its opener and version when MySQL runs what it holds, or the whole of it when
+        # the version it names is newer than the server's.
+        def executable_comment(text, index, server_version)
+          version, digits = comment_version(text, index + 3, server_version)
+          return [:executable_open, index + 3 + digits] unless version && server_version && version > server_version
+
+          [:comment, skipped_comment_end(text, index + 3 + digits)]
+        end
+
+        # The version a +/*!+ comment names, read as MySQL reads it: six digits followed by whitespace
+        # on a server that takes six, otherwise five digits, and no version at all with fewer. The end
+        # of the comment right after six digits is not whitespace, so MySQL reads five of them then.
+        #
+        # @return [Array(Integer, Integer), Array(nil, Integer)] the version, or nil, and how many
+        #   digits it took up
+        def comment_version(text, from, server_version)
+          six = text[from, 7].to_s
+          if server_version.to_i >= SIX_DIGIT_VERSIONS_FROM && six.match?(/\A\d{6}(?:\s|\z)/)
+            [six[0, 6].to_i, 6]
+          elsif text[from, 5].to_s.match?(/\A\d{5}\z/)
+            [text[from, 5].to_i, 5]
+          else
+            [nil, 0]
+          end
+        end
+
+        # Where a +/*!+ comment MySQL does not run ends. MySQL lets one comment be nested inside one of
+        # these, so the first +*/+ after a nested +/*+ closes the nested one rather than this one.
+        #
+        # @return [Integer, nil] the index just past its close, or nil when it never closes
+        def skipped_comment_end(text, from)
+          nested = false
+          index = from
+
+          while index < text.length
+            pair = text[index, 2]
+            if pair == '*/'
+              return index + 2 unless nested
+
+              nested = false
+              index += 2
+            elsif pair == '/*' && !nested
+              nested = true
+              index += 2
+            else
+              index += 1
+            end
+          end
+
+          nil
+        end
+
+        # @return [Integer, nil] the index just past the quote that closes the literal opened at
+        #   +start+, or nil when it is never closed
+        def literal_end(text, start)
+          quote = text[start]
+          index = start + 1
+
+          while index < text.length
+            char = text[index]
+            return index + 1 if char == quote
+
+            index += char == '\\' && quote != '`' ? 2 : 1
+          end
+
+          nil
+        end
+
+        def dash_comment?(text, index)
+          return false unless text[index, 2] == '--'
+
+          following = text[index + 2]
+          following.nil? || following.match?(/[\s[:cntrl:]]/)
+        end
+      end
+    end
+  end
+end

data/lib/aws_advanced_ruby_driver_wrapper/utils/parser/pg_statement_analyzer.rb

@@ -81,18 +81,19 @@ module AwsAdvancedRubyDriverWrapper
 
         # Dispatches a parsed statement hash to the appropriate extract_* method.
         # @param stmt [Hash] top-level statement hash from pg_query
-        # @param parameterized [Boolean]
+        # @param parameterized [Boolean] whether the statement has bind parameters; a WHERE clause is
+        #   only read for the columns it compares against them when it does
         # @return [QueryAnalysis]
         def extract_from_stmt(stmt, parameterized)
           case stmt
           in { select_stmt: inner_stmt } then extract_select(inner_stmt, parameterized)
-          in { insert_stmt: inner_stmt } then extract_insert(inner_stmt, parameterized)
+          in { insert_stmt: inner_stmt } then extract_insert(inner_stmt)
           in { update_stmt: inner_stmt } then extract_update(inner_stmt, parameterized)
           in { delete_stmt: inner_stmt } then extract_delete(inner_stmt, parameterized)
           in { create_stmt: inner_stmt } then extract_create(inner_stmt)
           in { drop_stmt: inner_stmt }   then extract_drop(inner_stmt)
           in { copy_stmt: inner_stmt }   then extract_copy(inner_stmt, parameterized)
-          in { merge_stmt: inner_stmt }  then extract_merge(inner_stmt, parameterized)
+          in { merge_stmt: inner_stmt }  then extract_merge(inner_stmt)
           in { prepare_stmt: inner_stmt } then extract_prepare(inner_stmt, parameterized)
           else QueryAnalysis.unknown
           end
@@ -121,7 +122,6 @@ module AwsAdvancedRubyDriverWrapper
             write_columns: analyses.flat_map(&:write_columns).freeze,
             where_columns: [].freeze,
             for_update: false,
-            parameterized: parameterized,
             unbound_write_columns: analyses.flat_map(&:unbound_write_columns).freeze,
             write_columns_complete: analyses.all?(&:write_columns_complete)
           )
@@ -133,7 +133,7 @@ module AwsAdvancedRubyDriverWrapper
         # that only deletes stores nothing. A value written with something other than a bind parameter
         # is reported unbound, and an INSERT clause without a column list is reported as not
         # enumerable, so a write that cannot be read fails closed rather than every MERGE being refused.
-        def extract_merge(stmt, parameterized)
+        def extract_merge(stmt)
           table = stmt.dig(:relation, :relname)
           bound = []
           unbound = []
@@ -166,7 +166,6 @@ module AwsAdvancedRubyDriverWrapper
             write_columns: bound.freeze,
             where_columns: [].freeze,
             for_update: false,
-            parameterized: parameterized,
             unbound_write_columns: unbound.freeze,
             write_columns_complete: complete
           )
@@ -197,12 +196,11 @@ module AwsAdvancedRubyDriverWrapper
             tables: tables.freeze,
             write_columns: [].freeze,
             where_columns: where_cols.freeze,
-            for_update: for_update,
-            parameterized: parameterized
+            for_update: for_update
           )
         end
 
-        def extract_insert(stmt, parameterized)
+        def extract_insert(stmt)
           table = stmt.dig(:relation, :relname)
           declared = Array(stmt[:cols]).filter_map { |column_entry| column_entry.dig(:res_target, :name) }
           value_rows = Array(stmt.dig(:select_stmt, :select_stmt, :values_lists))
@@ -215,7 +213,6 @@ module AwsAdvancedRubyDriverWrapper
             write_columns: (bound + upsert_bound).freeze,
             where_columns: [].freeze,
             for_update: false,
-            parameterized: parameterized,
             unbound_write_columns: (unbound + upsert_unbound).freeze,
             write_columns_complete: complete
           )
@@ -232,7 +229,6 @@ module AwsAdvancedRubyDriverWrapper
             write_columns: set_cols.freeze,
             where_columns: where_cols.freeze,
             for_update: false,
-            parameterized: parameterized,
             unbound_write_columns: unbound.freeze
           )
         end
@@ -305,8 +301,7 @@ module AwsAdvancedRubyDriverWrapper
             tables: table ? [table].freeze : [].freeze,
             write_columns: [].freeze,
             where_columns: where_cols.freeze,
-            for_update: false,
-            parameterized: parameterized
+            for_update: false
           )
         end
 
@@ -317,8 +312,7 @@ module AwsAdvancedRubyDriverWrapper
             tables: table ? [table].freeze : [].freeze,
             write_columns: [].freeze,
             where_columns: [].freeze,
-            for_update: false,
-            parameterized: false
+            for_update: false
           )
         end
 
@@ -332,8 +326,7 @@ module AwsAdvancedRubyDriverWrapper
             tables: tables.freeze,
             write_columns: [].freeze,
             where_columns: [].freeze,
-            for_update: false,
-            parameterized: false
+            for_update: false
           )
         end
 
@@ -355,7 +348,7 @@ module AwsAdvancedRubyDriverWrapper
             return extract_from_stmt(query, parameterized) if query.is_a?(Hash) && !query.empty?
 
             return QueryAnalysis.new(query_type: QueryType::SELECT, tables: tables, write_columns: [].freeze,
-                                     where_columns: [].freeze, for_update: false, parameterized: false)
+                                     where_columns: [].freeze, for_update: false)
           end
 
           declared = Array(stmt[:attlist]).filter_map { |column_entry| column_entry.dig(:string, :sval) }
@@ -365,7 +358,6 @@ module AwsAdvancedRubyDriverWrapper
             write_columns: [].freeze,
             where_columns: [].freeze,
             for_update: false,
-            parameterized: false,
             unbound_write_columns: declared.map { |name| ColumnInfo.new(table_name: table, column_name: name) }.freeze,
             write_columns_complete: declared.any?
           )
@@ -492,7 +484,6 @@ module AwsAdvancedRubyDriverWrapper
             write_columns: [].freeze,
             where_columns: [].freeze,
             for_update: false,
-            parameterized: sql.match?(/\$\d+/), # fallback only; AST unavailable here
             write_columns_complete: false
           )
         end

data/lib/aws_advanced_ruby_driver_wrapper/utils/parser/query_analysis.rb

@@ -29,8 +29,8 @@ module AwsAdvancedRubyDriverWrapper
       # at all, which is what an INSERT with no column list, an +INSERT ... SELECT+, and a statement
       # that would not parse all look like.
       QueryAnalysis = Data.define(:query_type, :tables, :write_columns, :where_columns, :for_update,
-                                  :parameterized, :unbound_write_columns, :write_columns_complete) do
-        def initialize(query_type:, tables:, write_columns:, where_columns:, for_update:, parameterized:,
+                                  :unbound_write_columns, :write_columns_complete) do
+        def initialize(query_type:, tables:, write_columns:, where_columns:, for_update:,
                        unbound_write_columns: [].freeze, write_columns_complete: true)
           super
         end
@@ -44,7 +44,6 @@ module AwsAdvancedRubyDriverWrapper
             write_columns: [].freeze,
             where_columns: [].freeze,
             for_update: false,
-            parameterized: false,
             write_columns_complete: false
           )
         end