plume 0.1.0 → 0.3.0

data/lib/plume/normalize.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Plume
+	# Constants turned into `?` parameters, so the same query with different values comes out the
+	# same - for grouping a log the way pg_stat_statements does, or for keeping values out of it.
+	# Numbers, strings and blobs are replaced, a sign in front of a number with them. NULL, TRUE,
+	# FALSE and CURRENT_* are not, since `IS ?` would not mean `IS NULL`. Neither is an integer
+	# standing alone in ORDER BY or GROUP BY, which SQLite takes for a column's position.
+	# Only SELECT, INSERT, UPDATE and DELETE (and EXPLAIN of them) are normalized, other statements
+	# are left as they were: their constants are schema, not data
+	module Normalize
+		extend self
+
+		STATEMENTS = [SelectStatement, InsertStatement, UpdateStatement, DeleteStatement].freeze
+
+		# The SQL with each constant swapped for `?` in place, everything else - spacing, case,
+		# comments - kept as written
+		def text(sql)
+			src = sql.b
+			spans = Parser.new(sql).parse.flat_map { |statement| constants(statement).map(&:location) }
+			out = +""
+			at = 0
+			spans.sort_by(&:first).each do |beg, fin|
+				out << src.byteslice(at, beg - at) << "?"
+				at = fin
+			end
+			out << src.byteslice(at, src.bytesize - at)
+			out.force_encoding(sql.encoding)
+		end
+
+		# A copy of the tree with each constant replaced by a `?` Variable
+		def tree(node)
+			targets = Set.new(constants(node)).compare_by_identity
+			node.transform { |n| targets.include?(n) ? Variable.new(name: "?") : n }
+		end
+
+		# The nodes to replace: literals, or a sign with the literal under it
+		def constants(statement)
+			root = (ExplainStatement === statement) ? statement.statement : statement
+			return [] unless STATEMENTS.any? { |klass| klass === root }
+
+			found = []
+			# By identity: hashing a node hashes its whole subtree
+			positional = Set.new.compare_by_identity
+			root.walk_with_slots do |node, parent, prop|
+				case node
+				when OrderingTerm
+					positional << node if SelectStatement === parent && prop == :orderings
+				when UnaryExpression
+					found << node if (node.operator in :NEGATE | :IDENTITY) && value?(node.operand)
+				when LiteralExpression
+					next if UnaryExpression === parent && (parent.operator in :NEGATE | :IDENTITY)
+					next if Integer === node.value && (positional.include?(parent) || (SelectCore === parent && prop == :groupings))
+
+					found << node if value?(node)
+				end
+			end
+			found
+		end
+
+		private
+
+		def value?(node) = LiteralExpression === node && (node.value in Numeric | String)
+	end
+end

data/lib/plume/parameters.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Plume
+	# The bind parameters of one statement, numbered the way SQLite numbers them: `?` takes the
+	# next number, `?N` takes N, and a name keeps the number it first got. `count` and `names`
+	# are what `sqlite3_bind_parameter_count` and `sqlite3_bind_parameter_name` would answer
+	class Parameters
+		include Enumerable
+
+		# One place a parameter appears. `name` is nil for a bare `?`
+		Parameter = Data.define(:number, :name, :node)
+
+		attr_reader :count, :names
+
+		def initialize(statement)
+			slots = {}
+			@count = 0
+			@parameters = variables(statement).map do |variable|
+				name = variable.name
+				number =
+					if name == "?"
+						@count += 1
+					elsif (n = name[/\A\?(\d+)\z/, 1]&.to_i)
+						slots[n] ||= name
+						@count = n if n > @count
+						n
+					elsif (n = slots.key(name))
+						n
+					else
+						slots[@count += 1] = name
+						@count
+					end
+				Parameter.new(number:, name: (name == "?") ? nil : name, node: variable)
+			end.freeze
+			@names = Array.new(@count) { |i| slots[i + 1] }.freeze
+		end
+
+		def each(&) = @parameters.each(&)
+
+		def size = @parameters.size
+
+		# The number a name was given, as `sqlite3_bind_parameter_index` answers it
+		def index(name) = @names.index(name)&.+(1)
+
+		private
+
+		# SQLite numbers them as it reads them, which is not always the order of the tree
+		def variables(statement)
+			statement.each_node.grep(Variable).each_with_index.sort_by { |v, i| [v.location&.first || 0, i] }.map(&:first)
+		end
+	end
+end