// Copyright 2023-Present Datadog, Inc. https://www.datadoghq.com/
// SPDX-License-Identifier: Apache-2.0
use serde::{Deserialize, Serialize};
#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
#[non_exhaustive]
pub enum DbmsKind {
#[default]
Generic,
Mssql,
Mysql,
Postgresql,
Oracle,
}
/// See `DbmsKind` for the list of supported DBMS.
pub struct UnknownDBMSError;
impl TryFrom<&str> for DbmsKind {
type Error = UnknownDBMSError;
fn try_from(value: &str) -> Result<Self, Self::Error> {
let res = match value.to_lowercase().as_str() {
"" => Self::Generic,
"mssql" => Self::Mssql,
"mysql" => Self::Mysql,
"postgresql" => Self::Postgresql,
"oracle" => Self::Oracle,
_ => return Err(UnknownDBMSError),
};
Ok(res)
}
}
#[allow(deprecated)]
#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "snake_case")]
#[non_exhaustive]
pub enum SqlObfuscationMode {
#[default]
#[deprecated = "kept for compatibility with agent's obfuscator but has unintuitive behavior"]
#[serde(alias = "")]
Unspecified,
NormalizeOnly,
ObfuscateOnly,
ObfuscateAndNormalize,
}
/// Configuration for SQL obfuscation
#[derive(Debug, Default, Clone, Deserialize)]
#[allow(
clippy::struct_excessive_bools,
reason = "public config schema, should not be refactored"
)]
pub struct SqlObfuscateConfig {
pub replace_digits: bool,
pub keep_sql_alias: bool,
pub dollar_quoted_func: bool,
pub keep_null: bool,
pub keep_boolean: bool,
pub keep_positional_parameter: bool,
pub keep_trailing_semicolon: bool,
pub keep_identifier_quotation: bool,
pub replace_bind_parameter: bool,
pub remove_space_between_parentheses: bool,
pub keep_json_path: bool,
pub obfuscation_mode: SqlObfuscationMode,
}
const fn is_whitespace(b: u8) -> bool {
matches!(b, b' ' | b'\t' | b'\n' | b'\r' | 0x0B | 0x0C)
}
const fn is_ident_start(b: u8) -> bool {
b.is_ascii_alphabetic() || b == b'_' || b > 127
}
const fn is_ident_char(b: u8) -> bool {
// Go's scanIdentifier includes '.*$' as continuation chars in addition to alnum/_.
// '@' is in Go's isLetter (isLeadingLetter) so it continues identifiers too.
// '.' is handled separately (qualifier), but '*', '$', '@' are included here.
b.is_ascii_alphanumeric()
|| b == b'_'
|| b == b'$'
|| b == b'#'
|| b == b'*'
|| b == b'@'
|| b > 127
}
/// Replace trailing digit sequences in identifier with `?`
/// e.g., `sales_2019_07_01` → sales_?_?_?
/// item1001 → item?
/// ddh19 → ddh?
fn apply_replace_digits(ident: &str) -> String {
let bytes = ident.as_bytes();
let mut result = String::with_capacity(ident.len());
let mut i = 0;
while i < bytes.len() {
if bytes[i].is_ascii_digit() {
while i < bytes.len() && bytes[i].is_ascii_digit() {
i += 1;
}
result.push('?');
} else {
// Push char as UTF-8
let c = ident[i..].chars().next().unwrap_or(' ');
result.push(c);
i += c.len_utf8();
}
}
result
}
/// Returns the index just past the closing `'` of a quoted string starting at `start`.
fn find_quoted_string_end(bytes: &[u8], start: usize) -> Option<usize> {
if bytes.get(start) != Some(&b'\'') {
return None;
}
// First: try short close (no backslash escape) — standard SQL uses '' only
let short_end = {
let mut i = start + 1;
let mut result = None;
while i < bytes.len() {
if bytes[i] == b'\'' {
if i + 1 < bytes.len() && bytes[i + 1] == b'\'' {
i += 2; // '' escape
continue;
} else {
result = Some(i + 1);
break;
}
}
i += 1;
}
result
};
// Use the short close if what follows is a SQL word boundary (not alphanumeric/underscore),
// meaning the string truly ends there. If followed by alphanumeric, the \' was likely
// an escape and the string continues — try greedy (with backslash escape).
let short_at_boundary = short_end.is_some_and(|end| {
!bytes
.get(end)
.is_some_and(|&c| c.is_ascii_alphanumeric() || c == b'_')
});
if short_at_boundary {
return short_end;
}
// Greedy: use backslash escape to find a longer match
let mut i = start + 1;
let mut escaped = false;
while i < bytes.len() {
if escaped {
escaped = false;
} else if bytes[i] == b'\\' {
escaped = true;
} else if bytes[i] == b'\'' {
if i + 1 < bytes.len() && bytes[i + 1] == b'\'' {
i += 1; // '' escape inside greedy scan
} else {
return Some(i + 1);
}
}
i += 1;
}
// Greedy found nothing; fall back to short_end (even if not at word boundary)
short_end
}
/// Find the end of a dollar-quoted string $tag$...$tag$
/// Returns (`inner_start`, `inner_end`, `outer_end`) or None if not a valid dollar quote
fn find_dollar_quote_end(bytes: &[u8], start: usize) -> Option<(usize, usize, usize)> {
let n = bytes.len();
if start >= n || bytes[start] != b'$' {
return None;
}
// Collect the tag: $<tag>$ — Go allows spaces and other chars in tags
let mut tag_end = start + 1;
while tag_end < n && bytes[tag_end] != b'$' {
if bytes[tag_end] == b'\n' {
return None; // tags don't span lines
}
tag_end += 1;
}
if tag_end >= n {
return None;
}
// tag is bytes[start..=tag_end], e.g. $func$ or $$
let tag = &bytes[start..=tag_end];
let inner_start = tag_end + 1;
// Search for closing tag
let mut i = inner_start;
while i + tag.len() <= n {
if bytes[i] == b'$' && bytes[i..].starts_with(tag) {
return Some((inner_start, i, i + tag.len()));
}
i += 1;
}
None
}
struct Tokenizer<'a> {
s: &'a str,
bytes: &'a [u8],
pos: usize,
result: String,
dbms: DbmsKind,
config: &'a SqlObfuscateConfig,
// For alias stripping: length of result before we emitted the most recent ' AS' segment
before_as_len: Option<usize>,
// After SAVEPOINT keyword, next token should become ?
pending_savepoint: bool,
// True when the last emitted non-space char was a standalone placeholder '?'
// (as opposed to '?' from replace_digits inside an identifier name)
last_was_placeholder: bool,
// When keep_json_path=true, set after -> or ->> to keep next literal as-is
pending_json_path: bool,
// True when the last emitted operator was a standalone = (assignment/comparison)
// Used to detect value context for double-quoted strings
last_was_assign: bool,
}
impl<'a> Tokenizer<'a> {
fn new(s: &'a str, config: &'a SqlObfuscateConfig, dbms: DbmsKind) -> Self {
Self {
s,
bytes: s.as_bytes(),
pos: 0,
result: String::with_capacity(s.len()),
dbms,
config,
before_as_len: None,
pending_savepoint: false,
last_was_placeholder: false,
pending_json_path: false,
last_was_assign: false,
}
}
fn peek(&self, offset: usize) -> Option<u8> {
self.bytes.get(self.pos + offset).copied()
}
const fn at_end(&self) -> bool {
self.pos >= self.bytes.len()
}
const fn is_normalize_only(&self) -> bool {
matches!(
self.config.obfuscation_mode,
SqlObfuscationMode::NormalizeOnly
)
}
const fn is_obfuscate_only(&self) -> bool {
matches!(
self.config.obfuscation_mode,
SqlObfuscationMode::ObfuscateOnly
)
}
#[allow(deprecated)]
const fn is_unspecified_obfuscate_mode(&self) -> bool {
matches!(
self.config.obfuscation_mode,
SqlObfuscationMode::Unspecified
)
}
fn last_char(&self) -> Option<u8> {
self.result.as_bytes().last().copied()
}
fn last_nonspace_char(&self) -> Option<u8> {
self.result
.as_bytes()
.iter()
.rev()
.find(|&&b| b != b' ')
.copied()
}
/// Push a space if result doesn't already end with one (and result is non-empty).
/// Does NOT add space after `.` (qualifier separator).
/// When actually pushing a space, resets `last_was_placeholder` — equivalent to Go's
/// `groupingFilter.Reset()` on any non-comma, non-paren, non-FilteredGroupable token.
fn space(&mut self) {
if !self.result.is_empty()
&& self.last_char() != Some(b' ')
&& !(self.last_char() == Some(b'.') && {
// Only suppress space after '.' when it acts as a qualifier separator
// (preceded by an identifier character like "table.column").
// For standalone '.' at the start or after operators, add the space.
let len = self.result.len();
if len < 2 {
false
} else {
let before_dot = self.result.as_bytes()[len - 2];
before_dot.is_ascii_alphanumeric()
|| before_dot == b'_'
|| before_dot == b'"'
|| before_dot == b']'
|| before_dot == b'#'
|| before_dot == b'?'
|| before_dot > 127 // Non-ASCII identifier chars
}
})
&& !(self.last_char() == Some(b'(')
&& (self.config.remove_space_between_parentheses || self.is_obfuscate_only()))
{
// Reset last_was_placeholder when transitioning past a non-placeholder token
// (e.g., operator or identifier). When last non-space char is '?', preserve
// the group state so that commas stripped after a literal don't break grouping.
if self.last_nonspace_char() != Some(b'?') {
self.last_was_placeholder = false;
}
self.result.push(' ');
} else if self.last_char() == Some(b' ')
&& !matches!(self.last_nonspace_char(), Some(b'?' | b'('))
{
// Result already ends in space (e.g. after an operator like '!') and we still need
// to reset placeholder state. Do NOT reset after '(' — Go's groupingFilter lets
// last_was_placeholder persist through '(' tokens.
self.last_was_placeholder = false;
}
}
/// Emit a token, adding a space before it if needed.
fn emit(&mut self, token: &str) {
self.space();
self.result.push_str(token);
self.last_was_placeholder = false;
self.last_was_assign = false;
}
/// Emit a single char token, adding a space before if needed.
fn emit_char(&mut self, c: char) {
self.space();
self.result.push(c);
self.last_was_placeholder = c == '?';
self.last_was_assign = false;
}
/// Emit a literal-replacement '?' with consecutive-duplicate suppression.
/// In legacy mode, Go's groupingFilter suppresses consecutive `FilteredGroupable` tokens
/// (groupFilter > 1). If `last_was_placeholder` is already true, suppress this one.
fn emit_placeholder(&mut self) {
if self.is_unspecified_obfuscate_mode() && self.last_was_placeholder {
// Suppress consecutive placeholder (Go groupFilter > 1 rule)
return;
}
self.emit_char('?');
}
fn skip_whitespace(&mut self) {
while !self.at_end() && is_whitespace(self.bytes[self.pos]) {
self.pos += 1;
}
// Also skip Unicode whitespace (e.g. U+2003 EM SPACE) — Go uses unicode.IsSpace
while !self.at_end() && self.bytes[self.pos] > 127 {
if let Some(c) = self.s[self.pos..].chars().next() {
if c.is_whitespace() {
self.pos += c.len_utf8();
// There may be ASCII whitespace after, loop again
while !self.at_end() && is_whitespace(self.bytes[self.pos]) {
self.pos += 1;
}
continue;
}
}
break;
}
}
fn skip_line_comment(&mut self) {
while !self.at_end() && self.bytes[self.pos] != b'\n' {
self.pos += 1;
}
}
fn skip_block_comment(&mut self) {
// We've already consumed '/*', now find '*/'
while self.pos + 1 < self.bytes.len() {
if self.bytes[self.pos] == b'*' && self.bytes[self.pos + 1] == b'/' {
self.pos += 2;
return;
}
self.pos += 1;
}
// Malformed - skip to end
self.pos = self.bytes.len();
}
/// Handle a single-quoted string: emit '?'
fn handle_single_quote(&mut self) {
let str_start = self.pos;
if let Some(end) = find_quoted_string_end(self.bytes, self.pos) {
self.pos = end;
} else {
// Unterminated string: consume to end of input, emit ?
self.pos = self.bytes.len();
}
if self.pending_json_path || self.is_normalize_only() {
self.pending_json_path = false;
// Keep the string as-is (don't quantize)
let raw = &self.s[str_start..self.pos].to_string();
if !self.maybe_consume_alias_next() {
self.emit(raw);
}
return;
}
if !self.maybe_consume_alias_next() {
self.emit_placeholder();
}
}
/// Called when we're about to emit a real token after 'AS'.
/// If we're in alias-stripping mode, truncate result to before 'AS' and return true (skip
/// token).
fn maybe_consume_alias_next(&mut self) -> bool {
if let Some(before_len) = self.before_as_len.take() {
// Truncate result to remove the ' AS' we emitted
self.result.truncate(before_len);
return true; // caller should skip emitting the token
}
false
}
/// Emit an identifier token (handles NULL/bool/AS).
fn emit_identifier(&mut self, ident: &str) {
let lower = ident.to_ascii_lowercase();
// If we're in pending_savepoint state, the next token becomes ?
if self.pending_savepoint {
self.pending_savepoint = false;
if self.maybe_consume_alias_next() {
return;
}
self.emit_placeholder();
return;
}
// Handle NULL
if !self.config.keep_null && !self.is_normalize_only() && lower == "null" {
if self.maybe_consume_alias_next() {
return;
}
self.emit_placeholder();
return;
}
// Handle boolean literals
if !self.config.keep_boolean
&& !self.is_normalize_only()
&& (lower == "true" || lower == "false")
{
if self.maybe_consume_alias_next() {
return;
}
self.emit_placeholder();
return;
}
// Handle AS keyword for alias stripping
// Alias stripping applies in legacy mode and normalize modes, but NOT in obfuscate_only
// (go-sqllexer obfuscator does not strip aliases)
if !self.config.keep_sql_alias
&& !self.is_normalize_only()
&& !self.is_obfuscate_only()
&& lower == "as"
{
// Don't consume alias here - emit AS but remember where to truncate
// Trim trailing space from result if any
if self.last_char() == Some(b' ') {
self.result.pop();
}
let before_len = self.result.len();
self.space();
self.result.push_str(ident);
self.before_as_len = Some(before_len);
// Go's groupingFilter resets when it sees AS (non-groupable, non-paren, non-comma).
// Reset last_was_placeholder so the comma after `alias` is not stripped.
self.last_was_placeholder = false;
return;
}
// SQL control-flow keywords should NOT be consumed as aliases
// (e.g., `CREATE PROCEDURE TestProc AS BEGIN ...` — BEGIN is not an alias)
// The `AS` is already in self.result; just clear before_as_len to keep it.
// Go's discardFilter discards the token after AS unconditionally (except '[' which triggers
// MSSQL bracketed identifier mode). However, SQL block-start keywords like BEGIN should not
// be consumed as aliases (e.g., CREATE PROCEDURE ... AS BEGIN).
// We keep the exclusion list minimal: only true SQL block-starters that cannot be aliases.
if self.before_as_len.is_some()
&& matches!(
lower.as_str(),
"begin"
| "end"
| "select"
| "insert"
| "update"
| "delete"
| "from"
| "where"
| "join"
| "on"
| "set"
| "values"
| "into"
| "group"
| "order"
| "having"
| "union"
| "intersect"
| "except"
| "limit"
| "offset"
| "with"
| "create"
| "drop"
| "alter"
| "truncate"
)
{
self.before_as_len = None;
}
if self.maybe_consume_alias_next() {
return;
}
// After emitting SAVEPOINT, the next identifier/literal becomes ?
if lower == "savepoint" {
self.pending_savepoint = true;
}
let out = if self.config.replace_digits {
apply_replace_digits(ident)
} else {
ident.to_string()
};
self.emit(&out);
}
/// After emitting a backtick/double-quote identifier, check if followed by '.' and another
/// quoted ident.
fn handle_dot_after_quoted_ident(&mut self) {
if !self.at_end() && self.bytes[self.pos] == b'.' {
let next = self.bytes.get(self.pos + 1).copied();
// In obfuscate_only mode, preserve input spacing (no spaces around dots)
if self.is_obfuscate_only() {
self.result.push('.');
self.pos += 1;
return;
}
match next {
Some(b'`' | b'"' | b'[') => {
self.result.push_str(" . ");
self.pos += 1; // skip '.'
}
Some(b'*') => {
self.result.push_str(".*");
self.pos += 2;
}
Some(c) if is_ident_start(c) => {
self.result.push_str(" . ");
self.pos += 1; // skip '.'
}
_ => {
self.result.push('.');
self.pos += 1;
}
}
}
}
/// After emitting a bracket identifier, check if followed by '.' and another bracket ident.
fn handle_dot_after_bracket_ident(&mut self) {
if !self.at_end() && self.bytes[self.pos] == b'.' {
let next = self.bytes.get(self.pos + 1).copied();
if next == Some(b'[') {
self.result.push_str(" . ");
} else {
self.result.push('.');
}
self.pos += 1;
}
}
/// Consume and emit the rest of a numeric literal starting at current pos.
fn consume_number(&mut self) {
self.consume_number_inner(false);
}
fn consume_number_inner(&mut self, seen_dot: bool) {
// Consume digits, '.', 'e'/'E', optional sign after 'e', suffix letters.
// `seen_dot`: true when caller already consumed the leading '.', so don't allow another.
// This mirrors Go's scanNumber(seenDecimalPoint) which goes straight to `exponent`
// without looping back to `fraction`, leaving a second '.' as a separate token.
let mut saw_dot = seen_dot;
let mut saw_exp = false;
while !self.at_end() {
let b = self.bytes[self.pos];
match b {
b'0'..=b'9' => {
self.pos += 1;
}
b'.' if !saw_dot => {
saw_dot = true;
self.pos += 1;
}
b'e' | b'E' if !saw_exp => {
saw_exp = true;
self.pos += 1;
// optional sign
if !self.at_end() && matches!(self.bytes[self.pos], b'+' | b'-') {
self.pos += 1;
}
}
// Note: letter suffixes like 'f'/'d'/'l' are NOT consumed here.
// Go's old SQL tokenizer does not treat them as numeric suffixes,
// so "0D" parses as number "0" + identifier "D".
_ => break,
}
}
}
#[allow(clippy::too_many_lines, reason = "FIXME: split this function")]
fn process(&mut self) {
while !self.at_end() {
let b = self.bytes[self.pos];
match b {
// Whitespace: normalize to single space
b if is_whitespace(b) => {
self.pos += 1;
self.skip_whitespace();
// Don't push space if we're in alias-stripping mode (waiting for next token)
if self.before_as_len.is_none() {
self.space();
}
}
// Line comment: -- ... (also // like Go's old tokenizer)
b'-' if self.peek(1) == Some(b'-') => {
self.pos += 2;
self.skip_line_comment();
}
b'/' if self.peek(1) == Some(b'/') => {
self.pos += 2;
self.skip_line_comment();
}
// MySQL-style comment: # ...
// In Go's old tokenizer, # is ALWAYS a comment unless DBMS is SQL Server.
b'#' => {
let next = self.peek(1);
let is_sqlserver = matches!(self.dbms, DbmsKind::Mssql);
match next {
Some(b)
if is_sqlserver
&& (b.is_ascii_alphanumeric() || b == b'_' || b == b'#') =>
{
// SQL Server temp table identifier like #temp or ##global
let start = self.pos;
while !self.at_end() && is_ident_char(self.bytes[self.pos]) {
self.pos += 1;
}
let ident = &self.s[start..self.pos];
if self.maybe_consume_alias_next() {
continue;
}
let out = if self.config.replace_digits {
apply_replace_digits(ident)
} else {
ident.to_string()
};
self.emit(&out);
}
// PostgreSQL JSON operators: #>, #>>, #-
Some(b'>') if matches!(self.dbms, DbmsKind::Postgresql) => {
if self.maybe_consume_alias_next() {
continue;
}
if self.peek(2) == Some(b'>') {
self.emit("#>>");
self.pos += 3;
} else {
self.emit("#>");
self.pos += 2;
}
self.space();
}
Some(b'-') if matches!(self.dbms, DbmsKind::Postgresql) => {
if self.maybe_consume_alias_next() {
continue;
}
self.emit("#-");
self.pos += 2;
self.space();
}
_ => {
// MySQL-style comment: skip to end of line
self.pos += 1;
self.skip_line_comment();
}
}
}
// Block comment: /* ... */
b'/' if self.peek(1) == Some(b'*') => {
self.pos += 2;
self.skip_block_comment();
}
// Semicolon
b';' => {
self.pos += 1;
// In old tokenizer mode (obfuscation_mode=""), Go ALWAYS strips semicolons.
// Go's discardFilter marks ';' as filterable-groupable, so the next '?'
// gets grouped/dropped. Set last_was_placeholder to replicate this.
if self.is_obfuscate_only()
|| (!self.is_unspecified_obfuscate_mode()
&& self.config.keep_trailing_semicolon)
{
if self.maybe_consume_alias_next() {
continue;
}
self.result.push(';');
} else if self.is_unspecified_obfuscate_mode() {
// Mark as "filterable groupable" so next ? is grouped (Go behavior)
self.last_was_placeholder = true;
}
}
// Opening paren
b'(' => {
if self.before_as_len.is_some() && !self.is_unspecified_obfuscate_mode() {
// In obfuscate_and_normalize mode: keep AS before ( (CTE body)
self.before_as_len = None;
} else if self.before_as_len.is_some() {
// Legacy mode: Go discards the token immediately after AS, including '('.
// Strip AS from result and skip '(' (matching Go's discardFilter behavior).
self.maybe_consume_alias_next();
self.pos += 1;
self.skip_whitespace();
continue; // skip emitting '('
}
self.pending_savepoint = false;
self.space();
self.result.push('(');
self.pos += 1;
// In old-tokenizer mode (obfuscation_mode=""), Go always adds a space after '('
// regardless of remove_space_between_parentheses. Only suppress in new modes.
let add_space = if self.is_unspecified_obfuscate_mode() {
!self.is_obfuscate_only()
} else {
!self.config.remove_space_between_parentheses && !self.is_obfuscate_only()
};
if add_space {
self.skip_whitespace();
self.result.push(' ');
}
}
// Closing paren
b')' => {
if self.maybe_consume_alias_next() {
continue;
}
// In old-tokenizer mode, Go always adds spaces before ')'
let add_close_space = if self.is_unspecified_obfuscate_mode() {
!self.is_obfuscate_only()
} else {
!self.config.remove_space_between_parentheses && !self.is_obfuscate_only()
};
if add_close_space {
// Add space before ) if needed (not after '(' or already spaced)
if !matches!(self.last_char(), Some(b'(' | b' ') | None) {
self.result.push(' ');
}
}
self.result.push(')');
self.pos += 1;
// NOTE: do NOT clear last_was_placeholder here.
// Go's groupingFilter doesn't reset on ')' either, which means
// a comma after `? )` (CTE body ending with a placeholder) is stripped.
}
// Comma
b',' => {
if self.maybe_consume_alias_next() {
continue;
}
self.pos += 1;
// Go behavior: commas that follow a standalone placeholder ? are stripped
// Go's groupingFilter comma stripping: when groupFilter > 0 and token == ',',
// discard it. This only applies in legacy mode (obfuscation_mode == "").
// go-sqllexer modes (obfuscate_only, etc.) do NOT strip commas.
if self.last_was_placeholder && self.is_unspecified_obfuscate_mode() {
// Remove any trailing space too
while self.last_char() == Some(b' ') {
self.result.pop();
}
continue;
}
// Remove any trailing space before comma (input may have `token ,`)
if self.last_char() == Some(b' ') {
self.result.pop();
}
self.result.push(',');
// Space after comma handled by next token's space() call
}
// Single-quoted string
b'\'' => {
self.handle_single_quote();
}
// Backtick identifier (MySQL-style, handle doubled backtick escaping)
b'`' => {
self.pos += 1;
let mut ident_buf = String::new();
loop {
if self.at_end() {
break;
}
if self.bytes[self.pos] == b'`' {
if self.bytes.get(self.pos + 1) == Some(&b'`') {
// Escaped backtick
ident_buf.push('`');
self.pos += 2;
} else {
self.pos += 1; // skip closing backtick
break;
}
} else {
let c = self.s[self.pos..].chars().next().unwrap_or(' ');
ident_buf.push(c);
self.pos += c.len_utf8();
}
}
// Empty/whitespace-only backtick identifiers must keep their delimiters
// to avoid producing invalid SQL (matches Go's scanString behavior).
let out = if ident_buf.chars().all(char::is_whitespace) {
format!("`{ident_buf}`")
} else if self.config.replace_digits {
apply_replace_digits(&ident_buf)
} else {
ident_buf.clone()
};
if self.maybe_consume_alias_next() {
// The alias token is consumed
} else {
self.emit(&out);
self.handle_dot_after_quoted_ident();
}
}
// Double-quoted identifier
b'"' => {
self.pos += 1;
// Scan double-quoted identifier, decoding "" escape sequences to single "
let mut ident_buf = String::new();
while !self.at_end() {
if self.bytes[self.pos] == b'"' {
if self.bytes.get(self.pos + 1) == Some(&b'"') {
ident_buf.push('"'); // "" → one "
self.pos += 2;
} else {
break;
}
} else {
let ch = self.s[self.pos..].chars().next().unwrap_or('\0');
ident_buf.push(ch);
self.pos += ch.len_utf8();
}
}
let ident_owned = ident_buf;
let ident = ident_owned.as_str();
if !self.at_end() {
self.pos += 1; // skip closing quote
}
// If last token was = (assignment/comparison), treat double-quoted string
// as a value (quantize), not as an identifier.
let is_string_value = self.last_was_assign;
// If pending SAVEPOINT or empty/whitespace content, treat as literal → ?
if self.pending_savepoint
|| (!ident.is_empty() && ident.chars().all(char::is_whitespace))
|| (!self.is_normalize_only() && is_string_value)
{
self.pending_savepoint = false;
if self.maybe_consume_alias_next() {
// consumed
} else {
self.emit_placeholder();
self.handle_dot_after_quoted_ident();
}
} else if (self.config.keep_identifier_quotation
&& !self.is_unspecified_obfuscate_mode())
|| self.is_obfuscate_only()
{
// Keep original double-quote syntax (go-sqllexer obfuscate_only keeps
// quotes) In old tokenizer mode,
// keep_identifier_quotation is ignored (like Go).
let quoted = format!("\"{ident}\"");
if self.maybe_consume_alias_next() {
// consumed
} else {
self.emit("ed);
self.handle_dot_after_quoted_ident();
}
} else {
// For empty identifiers, keep quotes (empty ident without quotes = invalid
// SQL) Go's replaceFilter never applies
// replace_digits to DoubleQuotedString tokens (only
// ID/TableName), so we never digit-replace quoted identifier content.
let out = if ident.is_empty() {
format!("\"{ident}\"")
} else {
ident.to_string()
};
if self.maybe_consume_alias_next() {
// consumed
} else {
self.emit(&out);
self.handle_dot_after_quoted_ident();
}
}
}
// Square bracket identifier [...]
b'[' => {
if matches!(self.dbms, DbmsKind::Mssql) {
self.pos += 1;
let id_start = self.pos;
while !self.at_end() && self.bytes[self.pos] != b']' {
self.pos += 1;
}
let ident = &self.s[id_start..self.pos];
if !self.at_end() {
self.pos += 1; // skip ']'
}
if self.maybe_consume_alias_next() {
// consumed
} else {
let out = if self.config.replace_digits {
apply_replace_digits(ident)
} else {
ident.to_string()
};
self.emit(&out);
self.handle_dot_after_bracket_ident();
}
} else {
// Non-mssql: emit [ as operator, let content be tokenized normally
// But if in alias mode, consume the whole [...] block as the alias
if self.before_as_len.is_some() {
self.pos += 1; // skip '['
while !self.at_end() && self.bytes[self.pos] != b']' {
self.pos += 1;
}
if !self.at_end() {
self.pos += 1; // skip ']'
}
self.maybe_consume_alias_next();
} else {
self.space();
self.result.push('[');
self.pos += 1;
self.skip_whitespace();
self.space();
}
}
}
b']' => {
if self.maybe_consume_alias_next() {
continue;
}
if !matches!(self.last_char(), Some(b'[' | b' ') | None) {
self.space();
}
self.result.push(']');
self.pos += 1;
// If followed by '.', emit ' . ' for chained bracket access
if !self.at_end() && self.bytes[self.pos] == b'.' {
self.result.push_str(" . ");
self.pos += 1; // skip '.'
}
}
// Dollar sign: positional param, dollar-quoted string, or identifier
b'$' => {
let next = self.peek(1);
match next {
// Positional param: $1, $2, $?, $09
Some(b) if b.is_ascii_digit() || b == b'?' => {
let token_start = self.pos;
self.pos += 1; // skip '$'
// Go's scanPreparedStatement calls scanNumber which only scans
// decimal digits (not all alphanumeric). Letters like 'C' in "$2C"
// are NOT part of the positional param.
while !self.at_end()
&& (self.bytes[self.pos].is_ascii_digit()
|| self.bytes[self.pos] == b'?')
{
self.pos += 1;
}
// Go's scanNumber follows the fraction path: a trailing '.' (and any
// following digits) is consumed as part of the number, e.g. "$0." → "?"
if !self.at_end() && self.bytes[self.pos] == b'.' {
self.pos += 1; // consume '.'
while !self.at_end() && self.bytes[self.pos].is_ascii_digit() {
self.pos += 1;
}
}
if self.maybe_consume_alias_next() {
continue;
}
// In old-tokenizer mode (obfuscation_mode=Unspecified), Go always
// replaces positional parameters regardless
// of keep_positional_parameter.
// Only respect keep_positional_parameter in new lexer modes.
let keep = (self.config.keep_positional_parameter
&& !self.is_unspecified_obfuscate_mode())
|| self.is_normalize_only()
|| self.is_obfuscate_only();
if keep {
self.emit(&self.s[token_start..self.pos]);
} else {
self.emit_placeholder();
}
}
// Dollar-quoted string: $tag$...$tag$ or $$...$$
_ if next == Some(b'$')
|| next.is_some_and(|c| c.is_ascii_alphabetic() || c == b'_') =>
{
let start = self.pos;
if let Some((inner_start, inner_end, outer_end)) =
find_dollar_quote_end(self.bytes, start)
{
if self.maybe_consume_alias_next() {
self.pos = outer_end;
continue;
}
if self.is_normalize_only() {
// In normalize mode: process inner content with same config
let tag_str = &self.s[start..inner_start];
let inner = &self.s[inner_start..inner_end];
let close_tag = &self.s[inner_end..outer_end];
let normalized_inner =
obfuscate_sql(inner, self.config, self.dbms);
self.space();
self.result.push_str(tag_str);
self.result.push_str(&normalized_inner);
self.result.push_str(close_tag);
} else if self.config.dollar_quoted_func {
// Obfuscate the content inside dollar quotes
let tag_str = &self.s[start..inner_start];
let inner = &self.s[inner_start..inner_end];
let close_tag = &self.s[inner_end..outer_end];
let obfuscated_inner =
obfuscate_sql(inner, self.config, self.dbms);
// If inner collapses to just '?' (trivial content), emit ?
// directly
if obfuscated_inner.trim() == "?" {
self.emit_placeholder();
} else {
self.space();
self.result.push_str(tag_str);
self.result.push_str(&obfuscated_inner);
self.result.push_str(close_tag);
}
} else {
// Replace whole thing with ?
self.emit_placeholder();
}
self.pos = outer_end;
} else {
// Not a valid dollar quote, check if it's an identifier starting
// with $
self.pos += 1; // skip '$'
let id_start_pos = self.pos;
while !self.at_end()
&& (is_ident_char(self.bytes[self.pos])
|| self.bytes[self.pos] == b'$')
{
self.pos += 1;
}
let ident = &self.s[id_start_pos - 1..self.pos]; // include '$'
if self.maybe_consume_alias_next() {
continue;
}
self.emit(ident);
}
let _ = b; // suppress unused warning
}
_ => {
// $identifier like $action - keep as-is
let start = self.pos;
self.pos += 1; // skip '$'
while !self.at_end()
&& (is_ident_char(self.bytes[self.pos])
|| self.bytes[self.pos] == b'$')
{
self.pos += 1;
}
let token = &self.s[start..self.pos];
if self.maybe_consume_alias_next() {
continue;
}
self.emit(token);
}
}
}
// Hex literal: 0x...
b'0' if matches!(self.peek(1), Some(b'x' | b'X')) => {
self.pos += 2; // skip '0x'
while !self.at_end() && self.bytes[self.pos].is_ascii_hexdigit() {
self.pos += 1;
}
if self.maybe_consume_alias_next() {
continue;
}
self.emit_placeholder();
}
// Hex literal: X'...' or x'...'
b'X' | b'x' if self.peek(1) == Some(b'\'') => {
self.pos += 1; // skip 'X'/'x'
if let Some(end) = find_quoted_string_end(self.bytes, self.pos) {
self.pos = end;
} else {
self.pos += 1;
}
if self.maybe_consume_alias_next() {
continue;
}
self.emit_placeholder();
}
// % bind param: %s, %d, %b, %i, %(name)s
b'%' => {
let next = self.peek(1);
match next {
Some(b)
if b.is_ascii_alphabetic() || b == b'_' || b == b'@' || b == b'#' =>
{
// Any ASCII letter/underscore/@/# after % is a format parameter
// (Go's scanFormatParameter handles all isLetter chars)
self.pos += 2;
if self.maybe_consume_alias_next() {
continue;
}
self.emit_placeholder();
}
Some(b'(') => {
self.pos += 2; // skip '%('
while !self.at_end() && self.bytes[self.pos] != b')' {
self.pos += 1;
}
if !self.at_end() {
self.pos += 1;
} // skip ')'
// Skip the format character
if !self.at_end() && self.bytes[self.pos].is_ascii_alphabetic() {
self.pos += 1;
}
if self.maybe_consume_alias_next() {
continue;
}
self.emit_placeholder();
}
Some(b) if b > 127 => {
// Non-ASCII byte: check if it starts a Unicode letter.
// Go's old SQL tokenizer treats %<letter> as a format parameter
// (Variable token) which gets obfuscated to '?'.
let next_char = self.s[self.pos + 1..].chars().next();
if let Some(nc) = next_char.filter(|c| c.is_alphabetic() || *c == '_') {
let skip = 1 + nc.len_utf8();
self.pos += skip;
if self.maybe_consume_alias_next() {
continue;
}
self.emit_placeholder();
} else {
if self.maybe_consume_alias_next() {
continue;
}
self.space();
self.result.push('%');
self.pos += 1;
self.space();
}
}
_ => {
// Just a % sign - emit as operator
if self.maybe_consume_alias_next() {
continue;
}
self.space();
self.result.push('%');
self.pos += 1;
self.space();
}
}
}
// Number starting with '.'
// Only treat .digit as a float literal if NOT preceded by an identifier char.
// When preceded by an identifier, '.2' is a qualifier (Go's scanIdentifier includes
// '.')
b'.' if self.peek(1).is_some_and(|b| b.is_ascii_digit())
&& !self
.last_char()
.is_some_and(|b| is_ident_char(b) || b == b'"' || b == b'`') =>
{
let num_start = self.pos;
self.pos += 1; // skip '.'
// Go's scanNumber(seenDecimalPoint=true) doesn't loop back to fraction,
// so a second '.' is NOT consumed (e.g. ".0.x" → number ".0" + dot + "x")
self.consume_number_inner(true);
if self.maybe_consume_alias_next() {
continue;
}
if self.is_normalize_only() {
let raw = self.s[num_start..self.pos].to_string();
self.emit(&raw);
} else {
self.emit_placeholder();
}
}
// Plain dot (qualifier separator)
// When preceded by an identifier and followed by digits, Go's scanIdentifier
// includes '.' in the identifier (see ContainsRune(".*$",...)).
// We need to handle ident.digit as a single identifier-like token.
b'.' => {
let after_dot_is_digit = self.peek(1).is_some_and(|b| b.is_ascii_digit());
let preceded_by_ident = self
.last_char()
.is_some_and(|b| is_ident_char(b) || b == b'"' || b == b'`');
if after_dot_is_digit && preceded_by_ident {
// handled below
} else if !after_dot_is_digit && !preceded_by_ident {
// Standalone dot not after identifier: needs space (Go adds space before
// every token)
if self.maybe_consume_alias_next() {
continue;
}
self.space();
self.result.push('.');
self.pos += 1;
continue;
}
if after_dot_is_digit && preceded_by_ident {
// Scan the rest of the identifier (including .digit parts) as one unit
let start = self.pos; // start at '.'
self.pos += 1; // skip '.'
while !self.at_end()
&& (is_ident_char(self.bytes[self.pos]) || self.bytes[self.pos] == b'.')
{
if self.bytes[self.pos] == b'.' {
if self
.peek(1)
.is_some_and(|b| b.is_ascii_digit() || is_ident_char(b))
{
self.pos += 1;
} else {
break;
}
} else {
self.pos += 1;
}
}
let suffix = &self.s[start..self.pos];
// Apply replace_digits if configured, otherwise emit as-is
let out = if self.config.replace_digits {
apply_replace_digits(suffix)
} else {
suffix.to_string()
};
// Append directly to result (already have the identifier prefix)
self.result.push_str(&out);
} else {
self.result.push('.');
self.pos += 1;
}
}
// Numeric literal
b'0'..=b'9' => {
let num_start = self.pos;
self.consume_number();
if self.maybe_consume_alias_next() {
continue;
}
if self.pending_json_path || self.is_normalize_only() {
self.pending_json_path = false;
let raw = self.s[num_start..self.pos].to_string();
self.emit(&raw);
} else {
self.emit_placeholder();
}
}
// Curly braces { ... }
b'{' => {
if self.maybe_consume_alias_next() {
continue;
}
// Peek at content after { and optional whitespace
let mut peek_pos = self.pos + 1;
while peek_pos < self.bytes.len() && is_whitespace(self.bytes[peek_pos]) {
peek_pos += 1;
}
// ODBC stored proc: {call ...} — keep outer braces, tokenize content normally
let is_call = peek_pos + 4 <= self.bytes.len()
&& self.bytes[peek_pos..peek_pos + 4].eq_ignore_ascii_case(b"call")
&& (peek_pos + 4 >= self.bytes.len()
|| !self.bytes[peek_pos + 4].is_ascii_alphanumeric());
if is_call {
self.space();
self.result.push('{');
self.pos += 1;
self.skip_whitespace();
self.result.push(' ');
} else {
// Cassandra maps, {fn ...}, etc. → scan to matching } and emit ?
let mut depth = 1usize;
self.pos += 1; // skip '{'
while !self.at_end() && depth > 0 {
match self.bytes[self.pos] {
b'{' => {
depth += 1;
self.pos += 1;
}
b'}' => {
depth -= 1;
self.pos += 1;
}
b'\'' => {
if let Some(end) = find_quoted_string_end(self.bytes, self.pos)
{
self.pos = end;
} else {
self.pos += 1;
}
}
_ => {
self.pos += 1;
}
}
}
self.emit_placeholder();
}
}
b'}' => {
if self.maybe_consume_alias_next() {
continue;
}
// Unmatched closing brace — emit as operator
self.space();
self.result.push('}');
self.pos += 1;
}
// @ - named params (@name, @1, @@var) - keep as-is
b'@' => {
if self.peek(1) == Some(b'@') {
// @@global_var
let start = self.pos;
self.pos += 2; // skip '@@'
while !self.at_end() && is_ident_char(self.bytes[self.pos]) {
self.pos += 1;
}
let token = &self.s[start..self.pos];
if self.maybe_consume_alias_next() {
continue;
}
self.emit(token);
} else if self.peek(1).is_some_and(|b| {
b.is_ascii_alphanumeric()
|| b == b'_'
|| b == b'#'
|| b == b'$'
|| b == b'*'
}) {
// @name, @1, @#name, @$name, @*name — all valid Go ident chars (ASCII)
let start = self.pos;
self.pos += 1; // skip '@'
while !self.at_end() && is_ident_char(self.bytes[self.pos]) {
self.pos += 1;
}
let token = self.s[start..self.pos].to_string();
if self.maybe_consume_alias_next() {
continue;
}
// Go's old tokenizer keeps @ prefix and only applies replace_digits.
// In new modes (obfuscation_mode!=""), respect replace_bind_parameter.
if self.config.replace_digits && token.chars().any(|c| c.is_ascii_digit()) {
let replaced = apply_replace_digits(&token);
self.emit(&replaced);
} else if self.config.replace_bind_parameter
&& !self.is_unspecified_obfuscate_mode()
{
self.emit_placeholder();
} else {
self.emit(&token);
}
} else if self.peek(1).is_some_and(|b| b > 127) {
// @unicodeLetter — Go's isAlphaNumeric includes Unicode letters
let next_char = self.s[self.pos + 1..].chars().next();
if next_char.is_some_and(|c| c.is_alphabetic() || c == '_') {
let start = self.pos;
self.pos += 1; // skip '@'
while !self.at_end() {
if self.bytes[self.pos] == b'#' || self.bytes[self.pos] == b'@' {
self.pos += 1;
continue;
}
let rest = &self.s[self.pos..];
match rest.chars().next() {
Some(c) if c.is_alphanumeric() || c == '_' => {
self.pos += c.len_utf8();
}
_ => break,
}
}
let token = self.s[start..self.pos].to_string();
if self.maybe_consume_alias_next() {
continue;
}
if self.config.replace_digits {
self.emit(&apply_replace_digits(&token));
} else {
self.emit(&token);
}
} else {
if self.maybe_consume_alias_next() {
continue;
}
self.space();
self.result.push('@');
self.pos += 1;
self.last_was_placeholder = false;
self.result.push(' ');
}
} else if self.peek(1) == Some(b'>') {
// @> operator
if self.maybe_consume_alias_next() {
continue;
}
self.emit("@>");
self.pos += 2;
self.result.push(' ');
} else {
// @ as standalone operator
if self.maybe_consume_alias_next() {
continue;
}
self.space();
self.result.push('@');
self.pos += 1;
self.last_was_placeholder = false;
self.result.push(' ');
}
}
// Colon: ::, :=, :name, or standalone
b':' => {
match self.peek(1) {
Some(b':') => {
// :: PostgreSQL cast
if self.maybe_consume_alias_next() {
continue;
}
self.space();
self.result.push_str("::");
self.pos += 2;
self.last_was_placeholder = false;
self.result.push(' ');
}
Some(b'=') => {
// := assignment
if self.maybe_consume_alias_next() {
continue;
}
self.space();
self.result.push_str(":=");
self.pos += 2;
self.last_was_placeholder = false;
self.result.push(' ');
}
Some(b)
if b.is_ascii_alphanumeric() || b == b'_' || b == b'#' || b == b'@' =>
{
// :name bind parameter - keep as-is; '#' is valid in Go identifiers;
// '@' is isLeadingLetter in Go
let start = self.pos;
self.pos += 1; // skip ':'
// Go's scanBindVar loops while isLetter || isDigit || ch == '.'
while !self.at_end()
&& (is_ident_char(self.bytes[self.pos])
|| self.bytes[self.pos] == b'.')
{
self.pos += 1;
}
let token = &self.s[start..self.pos];
if self.maybe_consume_alias_next() {
continue;
}
self.emit(token);
// If the bind var ends with '.', push a trailing space so that
// the next token doesn't get its space suppressed by space()'s
// qualifier-separator logic (which checks last_char == '.').
if token.ends_with('.') {
self.result.push(' ');
}
}
Some(b) if b > 127 => {
// Non-ASCII byte: check if it starts a Unicode letter.
// Go's normalizer emits ':' and a following IDENT without a space
// in bind-variable context. Treat ':unicodeword' as a single token.
let next_char = self.s[self.pos + 1..].chars().next();
if next_char.is_some_and(|c| c.is_alphabetic() || c == '_') {
let start = self.pos;
self.pos += 1; // skip ':'
while !self.at_end() {
// '#' and '@' are valid Go identifier chars (isLetter includes
// them). '.' is also valid:
// Go's scanBindVar loops while isLetter || isDigit || ch == '.'
if self.bytes[self.pos] == b'#'
|| self.bytes[self.pos] == b'@'
|| self.bytes[self.pos] == b'.'
{
self.pos += 1;
continue;
}
let rest = &self.s[self.pos..];
match rest.chars().next() {
Some(c) if c.is_alphanumeric() || c == '_' => {
self.pos += c.len_utf8();
}
_ => break,
}
}
let token = &self.s[start..self.pos];
if self.maybe_consume_alias_next() {
continue;
}
self.emit(token);
// If the bind var ends with '.', push a trailing space so that
// the next token doesn't get its space suppressed by space()'s
// qualifier-separator logic (which checks last_char == '.').
if token.ends_with('.') {
self.result.push(' ');
}
} else {
if self.maybe_consume_alias_next() {
continue;
}
self.space();
self.result.push(':');
self.pos += 1;
self.last_was_placeholder = false;
self.result.push(' ');
}
}
_ => {
// Standalone : (e.g., autovacuum:)
if self.maybe_consume_alias_next() {
continue;
}
self.space();
self.result.push(':');
self.pos += 1;
self.last_was_placeholder = false;
self.result.push(' ');
}
}
}
// Minus: --, ->, ->>, or operator, or signed number
b'-' => {
match self.peek(1) {
Some(b'-') => {
// Already handled above, but just in case
self.pos += 2;
self.skip_line_comment();
}
Some(b'>') if self.peek(2) == Some(b'>') => {
// ->> operator
if self.maybe_consume_alias_next() {
continue;
}
self.emit("->>");
self.pos += 3;
self.result.push(' ');
if self.config.keep_json_path {
self.pending_json_path = true;
}
}
Some(b'>') => {
// -> operator
if self.maybe_consume_alias_next() {
continue;
}
self.emit("->");
self.pos += 2;
self.result.push(' ');
if self.config.keep_json_path {
self.pending_json_path = true;
}
}
Some(b) if b.is_ascii_digit() => {
// Go's old tokenizer ALWAYS scans -digit as a negative number
// regardless of preceding context (tkn.lastChar check is only on next
// char).
{
self.pos += 1; // skip '-'
self.consume_number();
if self.maybe_consume_alias_next() {
continue;
}
self.emit_placeholder();
}
}
Some(b'.')
if self.peek(2).is_some()
&& !self.peek(2).is_some_and(|d| d.is_ascii_digit()) =>
{
// '-' followed by '.' followed by a non-digit non-EOF char:
// Go's tokenizer peeks at '.' then backtracks; because off advances
// past '.', bytes() captures '-.' as a
// single token. Emit '-.' together.
// When '.' is at EOF, Go's advance() doesn't change off (EndChar path),
// so bytes() only returns '-' — handled by the fallthrough `_` arm.
//
// Additionally, Go's advance() for the peek also advances off past the
// non-digit char ('v' in '-.v5'), making it the first byte of the NEXT
// token's bytes() output. Replicate that off-leak inline:
if self.maybe_consume_alias_next() {
continue;
}
self.space();
self.result.push_str("-.");
self.pos += 2;
self.last_was_placeholder = false;
self.result.push(' ');
// Handle the off-leak: the char at pos was advanced past by Go's peek.
// It becomes the first byte of the next token in Go's model.
if !self.at_end() {
let c_len =
self.s[self.pos..].chars().next().map_or(1, char::len_utf8);
let after_c = self.pos + c_len;
if after_c < self.bytes.len()
&& self.bytes[after_c].is_ascii_digit()
{
// Leaked char + following digits = Number in Go → '?'
self.pos = after_c;
self.consume_number();
self.emit_placeholder();
} else {
// Leaked char becomes the bytes of a '.' token in Go → emit
// as-is
let n = c_len.min(self.bytes.len() - self.pos);
let leaked = self.s[self.pos..self.pos + n].to_owned();
self.pos += n;
self.result.push_str(&leaked);
self.result.push(' ');
}
}
}
Some(b'.') if self.peek(2).is_some_and(|d| d.is_ascii_digit()) => {
// -.digit: Go ALWAYS treats this as a signed float number,
// regardless of the preceding token context.
self.pos += 2; // skip '-.'
self.consume_number();
if self.maybe_consume_alias_next() {
continue;
}
self.emit_placeholder();
}
_ => {
if self.maybe_consume_alias_next() {
continue;
}
self.space();
self.result.push('-');
self.pos += 1;
self.last_was_placeholder = false;
self.result.push(' ');
}
}
}
// Plus: signed number or operator
b'+' => {
// Go's old SQL tokenizer does NOT consume '+' as part of a signed number.
// '+' always stays as a separate operator token (unlike '-').
if self.maybe_consume_alias_next() {
continue;
}
self.space();
self.result.push('+');
self.pos += 1;
self.last_was_placeholder = false;
self.result.push(' ');
}
// ? - keep as-is (already a placeholder, or JSONB operator)
b'?' => {
let next = self.peek(1);
match next {
Some(b'|') if self.peek(2) != Some(b'|') => {
// ?| operator (but NOT ?|| which is ? followed by || concatenation)
if self.maybe_consume_alias_next() {
continue;
}
self.emit("?|");
self.pos += 2;
self.result.push(' ');
}
Some(b'&') => {
// ?& operator
if self.maybe_consume_alias_next() {
continue;
}
self.emit("?&");
self.pos += 2;
self.result.push(' ');
}
_ => {
// Raw ? in input:
// - For postgresql: treat as JSONB operator (not FilteredGroupable).
// Don't set last_was_placeholder, so consecutive literals aren't
// suppressed.
// - For other dbms: treat as bind parameter (FilteredGroupable). Use
// emit_placeholder so consecutive ?s are suppressed in legacy mode.
if self.maybe_consume_alias_next() {
continue;
}
if matches!(self.dbms, DbmsKind::Postgresql) {
self.space();
self.result.push('?');
self.last_was_assign = false;
// last_was_placeholder intentionally NOT set to true for PG JSONB ?
} else {
self.emit_placeholder();
}
self.pos += 1;
}
}
}
// < operator and <@ / <> / <= operators
b'<' => {
let next = self.peek(1);
if self.maybe_consume_alias_next() {
continue;
}
match next {
// <@ containment operator: always PG operator when dbms=postgresql,
// but when non-PG and followed by identifier, treat as < @ident
Some(b'@') => {
let next2_is_ident = self
.peek(2)
.is_some_and(|c| c.is_ascii_alphanumeric() || c == b'_');
if matches!(self.dbms, DbmsKind::Postgresql) || !next2_is_ident {
self.emit("<@");
self.pos += 2;
} else {
// Non-PG dbms with <@name → emit < then @name handled separately
self.space();
self.result.push('<');
self.pos += 1;
}
}
Some(b'>') => {
self.emit("<>");
self.pos += 2;
}
Some(b'=') => {
self.emit("<=");
self.pos += 2;
}
_ => {
self.space();
self.result.push('<');
self.pos += 1;
self.last_was_placeholder = false;
}
}
self.result.push(' ');
}
// > and >= operators
b'>' => {
if self.maybe_consume_alias_next() {
continue;
}
if self.peek(1) == Some(b'=') {
self.emit(">=");
self.pos += 2;
} else {
self.space();
self.result.push('>');
self.pos += 1;
self.last_was_placeholder = false;
}
self.result.push(' ');
}
// = operator
b'=' => {
if self.maybe_consume_alias_next() {
continue;
}
self.space();
self.result.push('=');
self.pos += 1;
self.last_was_placeholder = false;
self.result.push(' ');
self.last_was_assign = true;
}
// ! and !=, !~, !~*
b'!' => {
if self.maybe_consume_alias_next() {
continue;
}
if self.peek(1) == Some(b'=') {
self.emit("!=");
self.pos += 2;
} else if self.peek(1) == Some(b'~') {
if self.peek(2) == Some(b'*') {
self.emit("!~*");
self.pos += 3;
} else {
self.emit("!~");
self.pos += 2;
}
} else {
self.space();
self.result.push('!');
self.pos += 1;
self.last_was_placeholder = false;
}
self.result.push(' ');
}
// | and ||
b'|' => {
if self.maybe_consume_alias_next() {
continue;
}
// Emit single | (Go tokenizes || as two separate | tokens, each with spaces)
self.space();
self.result.push('|');
self.pos += 1;
self.last_was_placeholder = false;
self.result.push(' ');
}
// & operator
b'&' => {
if self.maybe_consume_alias_next() {
continue;
}
self.space();
self.result.push('&');
self.pos += 1;
self.last_was_placeholder = false;
self.result.push(' ');
}
// ~ ^ operators (and ~* compound)
b'~' => {
if self.maybe_consume_alias_next() {
continue;
}
if self.peek(1) == Some(b'*') {
self.emit("~*");
self.pos += 2;
} else {
self.space();
self.result.push('~');
self.pos += 1;
self.last_was_placeholder = false;
}
self.result.push(' ');
}
b'^' => {
if self.maybe_consume_alias_next() {
continue;
}
self.space();
self.result.push('^');
self.pos += 1;
self.last_was_placeholder = false;
self.result.push(' ');
}
// * operator (or SELECT *)
b'*' => {
if self.maybe_consume_alias_next() {
continue;
}
self.space();
self.result.push('*');
self.pos += 1;
self.last_was_placeholder = false;
self.result.push(' ');
}
// / operator (not /*, which is handled above)
b'/' => {
if self.maybe_consume_alias_next() {
continue;
}
self.space();
self.result.push('/');
self.pos += 1;
self.last_was_placeholder = false;
self.result.push(' ');
}
// Unicode whitespace (e.g. U+2003 EM SPACE): Go uses unicode.IsSpace
b if b > 127
&& self.s[self.pos..]
.chars()
.next()
.is_some_and(char::is_whitespace) =>
{
let c = self.s[self.pos..].chars().next().unwrap_or(' ');
self.pos += c.len_utf8();
self.skip_whitespace();
if self.before_as_len.is_none() {
self.space();
}
}
// Identifier or keyword
_ if is_ident_start(b) || b > 127 => {
let start = self.pos;
// Go's scanIdentifier includes '.' and '$' in identifiers
while !self.at_end() {
let b = self.bytes[self.pos];
if b > 127 {
// Non-ASCII: check if this char is Unicode whitespace — if so, stop.
// Go's scanIdentifier stops at unicode.IsSpace chars.
let c = self.s[self.pos..].chars().next();
if c.is_some_and(char::is_whitespace) {
break;
}
self.pos += c.map_or(1, char::len_utf8);
} else if is_ident_char(b) || b == b'.' {
self.pos += 1;
} else {
break;
}
}
let token = &self.s[start..self.pos];
self.emit_identifier(token);
// If identifier ends with '.', push space so next token is separated
// (Go includes trailing '.' in identifier but still spaces next token)
if token.ends_with('.') && !self.at_end() {
self.result.push(' ');
}
}
// Unknown: emit as-is
_ => {
let c = self.s[self.pos..].chars().next().unwrap_or(' ');
if self.maybe_consume_alias_next() {
self.pos += c.len_utf8();
continue;
}
self.result.push(c);
self.pos += c.len_utf8();
}
}
}
}
fn finalize(mut self) -> String {
// Trim trailing whitespace
while self.result.ends_with(' ') {
self.result.pop();
}
self.result
}
}
/// Try to match a `( ?, ?, ..., ? )` or `[ ?, ?, ..., ? ]` pattern starting at `i`.
/// Returns Some(k) where k is the index after the closing bracket if matched, else None.
const fn try_match_pure_group(bytes: &[u8], open: u8, close: u8, i: usize) -> Option<usize> {
let n = bytes.len();
if i >= n || bytes[i] != open {
return None;
}
let mut k = i + 1;
if k < n && bytes[k] == b' ' {
k += 1;
}
if k >= n || bytes[k] != b'?' {
return None;
}
k += 1;
loop {
if k < n && bytes[k] == b' ' {
k += 1;
}
if k >= n {
return None;
}
if bytes[k] == close {
return Some(k + 1);
}
// Accept either `?, ?` or `? ?` (commas may have been stripped)
if bytes[k] == b',' {
k += 1;
if k < n && bytes[k] == b' ' {
k += 1;
}
}
if k < n && bytes[k] == b'?' {
k += 1;
} else {
return None;
}
}
}
/// Collapse `( ?, ?, ..., ? )` into `( ? )`, `[ ?, ?, ..., ? ]` into `[ ? ]`,
/// multi-row `VALUES ( ? ) , ( ? ) , ...` into `VALUES ( ? )`, and `LIMIT ?, ?` into `LIMIT ?`.
fn collapse_grouped_values(s: &str, obfuscation_mode: SqlObfuscationMode) -> String {
let bytes = s.as_bytes();
let n = bytes.len();
let mut result = String::with_capacity(n);
let mut i = 0;
while i < n {
// Try ( ?, ... )
if bytes[i] == b'(' {
if let Some(end) = try_match_pure_group(bytes, b'(', b')', i) {
result.push_str("( ? )");
i = end;
continue;
}
}
// Try [ ?, ... ]
if bytes[i] == b'[' {
if let Some(end) = try_match_pure_group(bytes, b'[', b']', i) {
result.push_str("[ ? ]");
i = end;
continue;
}
}
// Push next character correctly (multi-byte UTF-8 safe)
if bytes[i] < 128 {
result.push(bytes[i] as char);
i += 1;
} else {
let c = s[i..].chars().next().unwrap_or('\u{FFFD}');
result.push(c);
i += c.len_utf8();
}
}
let result = collapse_multi_values(&result);
#[allow(deprecated)]
if matches!(obfuscation_mode, SqlObfuscationMode::Unspecified) {
// FIXME: this being only collapsed on the deprecated mode is unintuitive but follows the
// weird behavior of the agent's obfuscator Collapse `LIMIT ?, ?` → `LIMIT ?`
// (MySQL/SQLite LIMIT offset, count syntax)
collapse_limit_two_args(&result)
} else {
result
}
}
/// Collapse `VALUES ( ? ) , ( ? ) , ...` → `VALUES ( ? )`.
/// Also handles comma-less groups `VALUES ( ? ) ( ? )` (when commas were stripped by placeholder
/// logic).
fn collapse_multi_values(s: &str) -> String {
// Pattern: "VALUES ( ? )" followed by one or more " , ( ? )" or " ( ? )" groups
let mut result = String::with_capacity(s.len());
let mut remaining = s;
while let Some(c) = remaining.chars().next() {
const VALUES_KW: &str = "VALUES";
const VALUES_TAIL: &str = " ( ? )";
const VALUES_FULL: &str = "VALUES ( ? )";
// Match "VALUES" case-insensitively, and then match the exact tail " ( ? )"
let matches_values_pattern = remaining.get(..VALUES_FULL.len()).is_some_and(|head| {
head.get(..VALUES_KW.len())
.is_some_and(|kw| kw.eq_ignore_ascii_case(VALUES_KW))
&& head
.get(VALUES_KW.len()..)
.is_some_and(|tail| tail == VALUES_TAIL)
});
if matches_values_pattern {
// Preceding context: must be start or space/'(' or '\n'
let prev_ok =
result.is_empty() || matches!(result.chars().last(), Some(' ' | '(' | '\n'));
if prev_ok {
// Keep the original casing as it appeared in `remaining`
result.push_str(&remaining[..VALUES_FULL.len()]);
remaining = &remaining[VALUES_FULL.len()..];
// Consume trailing groups
loop {
if let Some(rest) = remaining.strip_prefix(", ( ? )") {
remaining = rest;
} else if let Some(rest) = remaining.strip_prefix(" ( ? )") {
remaining = rest;
} else if let Some(rest) = remaining.strip_prefix(" ()") {
remaining = rest;
} else {
break;
}
}
continue;
}
}
result.push(c);
remaining = &remaining[c.len_utf8()..];
}
result
}
/// Collapse `LIMIT ?, ?` → `LIMIT ?`
fn collapse_limit_two_args(s: &str) -> String {
const PREFIX: &[u8] = b"LIMIT ?";
// Scan for "LIMIT ?, ?" pattern (all ASCII keywords, UTF-8 safe via char iteration)
let mut result = String::with_capacity(s.len());
let mut remaining = s;
while !remaining.is_empty() {
// Check for LIMIT (case-insensitive) + " ?, ?" or " ? ?"
if remaining.len() >= 9 {
let rb = remaining.as_bytes();
if rb[..PREFIX.len()].eq_ignore_ascii_case(PREFIX) {
// Check " ?, ?" or " ? ?"
let skip =
if remaining.len() >= 10 && rb[7] == b',' && rb[8] == b' ' && rb[9] == b'?' {
Some(10) // "LIMIT ?, ?"
} else if rb[7] == b' ' && rb[8] == b'?' {
Some(9) // "LIMIT ? ?" (comma already stripped)
} else {
None
};
if let Some(skip_len) = skip {
// Word boundary: previous char in result should be space or start
let prev_ok = result.is_empty()
|| matches!(result.as_bytes().last(), Some(b' ' | b'(' | b'\n'));
if prev_ok {
result.push_str(&remaining[..7]); // "LIMIT ?"
remaining = &remaining[skip_len..];
continue;
}
}
}
}
let c = remaining.chars().next().unwrap_or(' ');
result.push(c);
remaining = &remaining[c.len_utf8()..];
}
result
}
/// Obfuscates a SQL string using a proper tokenizer.
#[must_use]
pub fn obfuscate_sql(s: &str, config: &SqlObfuscateConfig, dbms: DbmsKind) -> String {
if s.is_empty() {
return String::new();
}
let mut tokenizer = Tokenizer::new(s, config, dbms);
tokenizer.process();
let raw = tokenizer.finalize();
// collapse_grouped_values applies in legacy mode and obfuscate_and_normalize mode.
// In obfuscate_only and normalize_only modes, values are NOT collapsed.
#[allow(deprecated)]
let should_collapse = matches!(
config.obfuscation_mode,
SqlObfuscationMode::Unspecified | SqlObfuscationMode::ObfuscateAndNormalize
);
if should_collapse {
collapse_grouped_values(&raw, config.obfuscation_mode)
} else {
raw
}
}
/// Obfuscates a SQL string with default configuration.
#[must_use]
pub fn obfuscate_sql_string(s: &str) -> String {
obfuscate_sql(s, &SqlObfuscateConfig::default(), DbmsKind::Generic)
}
/// SQL obfuscation with Go-compatible whitespace normalization for use in JSON plan obfuscation.
/// Applies `obfuscate_sql_string` then additional normalizations for JSON plan SQL.
// FIXME: remove these tiny wrappers they provide no value, keep the public api 1 function which
// takes a config
#[must_use]
pub fn obfuscate_sql_string_normalized(s: &str) -> String {
let obfuscated = obfuscate_sql_string(s);
normalize_plan_sql(&obfuscated)
}
fn normalize_plan_sql(s: &str) -> String {
let mut result = String::with_capacity(s.len());
let mut chars = s.chars().peekable();
while let Some(c) = chars.next() {
match c {
'`' => {
// Strip backticks: collect identifier content up to closing backtick
let identifier: String = chars.by_ref().take_while(|&c| c != '`').collect();
result.push_str(&identifier);
// If followed by `.` then another backtick identifier, replace `.` with ` . `
if chars.peek() == Some(&'.') {
chars.next(); // consume `.`
result.push_str(if chars.peek() == Some(&'`') {
" . "
} else {
"."
});
}
}
'(' => {
result.push('(');
if chars.peek().is_some_and(|&c| c != ' ') {
result.push(' ');
}
}
')' => {
if result.as_bytes().last().is_some_and(|&b| b != b' ') {
result.push(' ');
}
result.push(')');
}
':' if chars.peek() == Some(&':') => {
chars.next(); // consume second `:`
if result.as_bytes().last().is_some_and(|&b| b != b' ') {
result.push(' ');
}
result.push_str("::");
if chars.peek().is_some_and(|&c| c != ' ') {
result.push(' ');
}
}
_ => result.push(c),
}
}
result
}
#[cfg(test)]
mod tests {
use super::{DbmsKind, SqlObfuscateConfig, SqlObfuscationMode};
use std::fmt::Write;
#[test]
fn test_sql_obfuscation() {
let mut panic = None;
let err = CASES
.iter()
.enumerate()
.filter_map(|(i, (input, output))| {
let err =
match std::panic::catch_unwind(|| test_sql_obfuscation_case(input, output)) {
Ok(r) => r,
Err(p) => {
panic = Some(p);
eprintln!("panicked case {i}\n\tinput: {input}\n\n");
return None;
}
}
.err()?;
Some(format!("failed case {i}\n\terr: {err}\n"))
})
.collect::<String>();
if !err.is_empty() {
if panic.is_none() {
panic!("{err}")
} else {
eprintln!("{err}");
}
}
if let Some(p) = panic {
std::panic::resume_unwind(p);
}
}
fn test_sql_obfuscation_case(input: &str, output: &str) -> anyhow::Result<()> {
let got = super::obfuscate_sql_string(input);
if output != got {
anyhow::bail!("expected {output:?}\n\tgot: {got:?}")
}
Ok(())
}
#[test]
fn test_sql_obfuscation_normalized() {
let mut panic = None;
let err = NORMALIZED_CASES
.iter()
.enumerate()
.filter_map(|(i, (input, output))| {
let err = match std::panic::catch_unwind(|| {
test_sql_obfuscation_normalized_case(input, output)
}) {
Ok(r) => r,
Err(p) => {
panic = Some(p);
eprintln!("panicked normalized case {i}\n\tinput: {input}\n\n");
return None;
}
}
.err()?;
Some(format!("failed normalized case {i}\n\terr: {err}\n"))
})
.collect::<String>();
if !err.is_empty() {
if panic.is_none() {
panic!("{err}")
} else {
eprintln!("{err}");
}
}
if let Some(p) = panic {
std::panic::resume_unwind(p);
}
}
fn test_sql_obfuscation_normalized_case(input: &str, output: &str) -> anyhow::Result<()> {
let got = super::obfuscate_sql_string_normalized(input);
if output != got {
anyhow::bail!("expected {output:?}\n\tgot: {got:?}")
}
Ok(())
}
#[test]
fn test_keep_identifier_quotation() {
let config = SqlObfuscateConfig {
keep_identifier_quotation: true,
..Default::default()
};
let got = super::obfuscate_sql(
r#"SELECT * FROM "users" WHERE id = 1 AND name = 'test'"#,
&config,
DbmsKind::Generic,
);
// In old tokenizer mode, keep_identifier_quotation is ignored (Go does too).
let expected = "SELECT * FROM users WHERE id = ? AND name = ?";
assert_eq!(got, expected, "keep_identifier_quotation: got {got:?}");
}
#[test]
fn test_remove_space_between_parentheses() {
let config = SqlObfuscateConfig {
remove_space_between_parentheses: true,
..Default::default()
};
let got = super::obfuscate_sql(
"SELECT * FROM users WHERE id = ? AND (name = 'test' OR name = 'test2')",
&config,
DbmsKind::Generic,
);
// In old-tokenizer mode, Go ignores remove_space_between_parentheses and always adds spaces
let expected = "SELECT * FROM users WHERE id = ? AND ( name = ? OR name = ? )";
assert_eq!(
got, expected,
"remove_space_between_parentheses: got {got:?}"
);
}
#[test]
fn test_keep_positional_parameter() {
// When keep_positional_parameter=true, $1/$2 should be kept as-is
let config = SqlObfuscateConfig {
keep_positional_parameter: true,
..Default::default()
};
let got = super::obfuscate_sql(
"SELECT * FROM users WHERE id = ? AND name = $1 and id = $2",
&config,
DbmsKind::Generic,
);
// In old-tokenizer mode (obfuscation_mode=""), positional params are always replaced
// regardless of keep_positional_parameter (matches Go's old tokenizer behavior).
let expected = "SELECT * FROM users WHERE id = ? AND name = ? and id = ?";
assert_eq!(
got, expected,
"keep_positional_parameter: got {got:?}, expected {expected:?}"
);
}
const NORMALIZED_CASES: &[(&str, &str)] = &[
// 'value'::type fix (in obfuscate_sql_string)
("'60'::double precision", "? :: double precision"),
("'dogfood'::text", "? :: text"),
("'15531'::tid", "? :: tid"),
("(query <> 'dogfood'::text)", "( query <> ? :: text )"),
// normalize_plan_sql — parens spacing
("(foo != ?)", "( foo != ? )"),
("((a >= ?) AND (b < ?))", "( ( a >= ? ) AND ( b < ? ) )"),
// normalize_plan_sql — :: spacing
("?::double precision", "? :: double precision"),
("(query <> ?::text)", "( query <> ? :: text )"),
// normalize_plan_sql — backtick stripping
("`id`", "id"),
(
"(`sbtest`.`sbtest1`.`id` between ? and ?)",
"( sbtest . sbtest1 . id between ? and ? )",
),
// full pipeline (obfuscate_sql_string_normalized)
(
"(`sbtest`.`sbtest1`.`id` between 5016 and 5115)",
"( sbtest . sbtest1 . id between ? and ? )",
),
("(query <> 'dogfood'::text)", "( query <> ? :: text )"),
("'60'::double precision", "? :: double precision"),
];
const CASES: &[(&str, &str)] = &[
("", ""),
(" ", ""),
(" ", ""),
("罿", "罿"),
("罿潯", "罿潯"),
("罿潯罿潯罿潯罿潯罿潯", "罿潯罿潯罿潯罿潯罿潯"),
("'abc1287681964'", "?"),
("-- comment", ""),
("---", ""),
("1 - 2", "? - ?"),
(
"SELECT * FROM TABLE WHERE userId = 'abc1287681964'",
"SELECT * FROM TABLE WHERE userId = ?",
),
// Standard SQL uses '' to escape quotes, not backslash
(
"SELECT * FROM TABLE WHERE userId = 'it''s a string'",
"SELECT * FROM TABLE WHERE userId = ?",
),
(
"SELECT * FROM TABLE WHERE userId IN ('a', 'b', 'c')",
"SELECT * FROM TABLE WHERE userId IN ( ? )",
),
(
"SELECT * FROM TABLE WHERE userId = 'abc1287681964' ORDER BY FOO DESC",
"SELECT * FROM TABLE WHERE userId = ? ORDER BY FOO DESC",
),
// Backslash followed by ' at a SQL word boundary (space follows): string closes there
// 'backslash\' closes at the ' after \, because ' is followed by space (SQL boundary)
(
"SELECT * FROM foo LEFT JOIN bar ON 'backslash\\' = foo.b WHERE foo.name = 'String'",
"SELECT * FROM foo LEFT JOIN bar ON ? = foo.b WHERE foo.name = ?",
),
(
"SELECT * FROM foo LEFT JOIN bar ON 'backslash\\' = foo.b LEFT JOIN bar2 ON 'backslash2\\' = foo.b2 WHERE foo.name = 'String'",
"SELECT * FROM foo LEFT JOIN bar ON ? = foo.b LEFT JOIN bar2 ON ? = foo.b2 WHERE foo.name = ?",
),
// Backslash followed by ' before more string content (alphanumeric follows): acts as escape
// 'embedded \'quote\' in string' is ONE string because ' after \ is followed by 'q'
(
"SELECT * FROM foo LEFT JOIN bar ON 'embedded \\'quote\\' in string' = foo.b WHERE foo.name = 'String'",
"SELECT * FROM foo LEFT JOIN bar ON ? = foo.b WHERE foo.name = ?",
),
(
"SELECT * FROM TABLE JOIN SOMETHING ON TABLE.foo = SOMETHING.bar",
"SELECT * FROM TABLE JOIN SOMETHING ON TABLE.foo = SOMETHING.bar",
),
(
"CREATE TABLE \"VALUE\"",
"CREATE TABLE VALUE",
),
(
"INSERT INTO \"VALUE\" (\"column\") VALUES (\'ljahklshdlKASH\')",
"INSERT INTO VALUE ( column ) VALUES ( ? )",
),
(
"INSERT INTO \"VALUE\" (\"col1\",\"col2\",\"col3\") VALUES (\'blah\',12983,X'ff')",
"INSERT INTO VALUE ( col1, col2, col3 ) VALUES ( ? )",
),
(
"INSERT INTO \"VALUE\" (\"col1\", \"col2\", \"col3\") VALUES (\'blah\',12983,X'ff')",
"INSERT INTO VALUE ( col1, col2, col3 ) VALUES ( ? )",
),
(
"INSERT INTO VALUE (col1,col2,col3) VALUES (\'blah\',12983,X'ff')",
"INSERT INTO VALUE ( col1, col2, col3 ) VALUES ( ? )",
),
(
"INSERT INTO VALUE (col1,col2,col3) VALUES (12983,X'ff',\'blah\')",
"INSERT INTO VALUE ( col1, col2, col3 ) VALUES ( ? )",
),
(
"INSERT INTO VALUE (col1,col2,col3) VALUES (X'ff',\'blah\',12983)",
"INSERT INTO VALUE ( col1, col2, col3 ) VALUES ( ? )",
),
(
"INSERT INTO VALUE (col1,col2,col3) VALUES ('a',\'b\',1)",
"INSERT INTO VALUE ( col1, col2, col3 ) VALUES ( ? )",
),
(
"INSERT INTO VALUE (col1, col2, col3) VALUES ('a',\'b\',1)",
"INSERT INTO VALUE ( col1, col2, col3 ) VALUES ( ? )",
),
(
"INSERT INTO VALUE ( col1, col2, col3 ) VALUES ('a',\'b\',1)",
"INSERT INTO VALUE ( col1, col2, col3 ) VALUES ( ? )",
),
(
"INSERT INTO VALUE (col1,col2,col3) VALUES ('a', \'b\' ,1)",
"INSERT INTO VALUE ( col1, col2, col3 ) VALUES ( ? )",
),
(
"INSERT INTO VALUE (col1, col2, col3) VALUES ('a', \'b\', 1)",
"INSERT INTO VALUE ( col1, col2, col3 ) VALUES ( ? )",
),
(
"INSERT INTO VALUE ( col1, col2, col3 ) VALUES ('a', \'b\', 1)",
"INSERT INTO VALUE ( col1, col2, col3 ) VALUES ( ? )",
),
(
"INSERT INTO VALUE (col1,col2,col3) VALUES (X'ff',\'罿潯罿潯罿潯罿潯罿潯\',12983)",
"INSERT INTO VALUE ( col1, col2, col3 ) VALUES ( ? )",
),
(
"INSERT INTO VALUE (col1,col2,col3) VALUES (X'ff',\'罿\',12983)",
"INSERT INTO VALUE ( col1, col2, col3 ) VALUES ( ? )",
),
// AS resets groupFilter: comma after alias IS kept (verified against Go)
(
"SELECT 3 AS NUCLEUS_TYPE,A0.ID,A0.\"NAME\" FROM \"VALUE\" A0",
"SELECT ?, A0.ID, A0. NAME FROM VALUE A0",
),
(
"SELECT COUNT(*) FROM TABLE_1 JOIN table_2 ON TABLE_1.foo = table_2.bar where col1 > .9999",
"SELECT COUNT ( * ) FROM TABLE_1 JOIN table_2 ON TABLE_1.foo = table_2.bar where col1 > ?",
),
(
"SELECT COUNT(*) FROM TABLE_1 JOIN table_2 ON TABLE_1.foo = table_2.bar where col1 > 0.9999",
"SELECT COUNT ( * ) FROM TABLE_1 JOIN table_2 ON TABLE_1.foo = table_2.bar where col1 > ?",
),
(
"SELECT COUNT(*) FROM TABLE_1 JOIN table_2 ON TABLE_1.foo = table_2.bar where col1 > -0.9999",
"SELECT COUNT ( * ) FROM TABLE_1 JOIN table_2 ON TABLE_1.foo = table_2.bar where col1 > ?",
),
(
"SELECT COUNT(*) FROM TABLE_1 JOIN table_2 ON TABLE_1.foo = table_2.bar where col1 > -1e6",
"SELECT COUNT ( * ) FROM TABLE_1 JOIN table_2 ON TABLE_1.foo = table_2.bar where col1 > ?",
),
(
"SELECT COUNT(*) FROM TABLE_1 JOIN table_2 ON TABLE_1.foo = table_2.bar where col1 > +1e6",
"SELECT COUNT ( * ) FROM TABLE_1 JOIN table_2 ON TABLE_1.foo = table_2.bar where col1 > + ?",
),
(
"SELECT COUNT(*) FROM TABLE_1 JOIN table_2 ON TABLE_1.foo = table_2.bar where col1 > +255",
"SELECT COUNT ( * ) FROM TABLE_1 JOIN table_2 ON TABLE_1.foo = table_2.bar where col1 > + ?",
),
(
"SELECT COUNT(*) FROM TABLE_1 JOIN table_2 ON TABLE_1.foo = table_2.bar where col1 > +6.34F",
"SELECT COUNT ( * ) FROM TABLE_1 JOIN table_2 ON TABLE_1.foo = table_2.bar where col1 > + ? F",
),
(
"SELECT COUNT(*) FROM TABLE_1 JOIN table_2 ON TABLE_1.foo = table_2.bar where col1 > +6f",
"SELECT COUNT ( * ) FROM TABLE_1 JOIN table_2 ON TABLE_1.foo = table_2.bar where col1 > + ? f",
),
(
"SELECT COUNT(*) FROM TABLE_1 JOIN table_2 ON TABLE_1.foo = table_2.bar where col1 > +0.5D",
"SELECT COUNT ( * ) FROM TABLE_1 JOIN table_2 ON TABLE_1.foo = table_2.bar where col1 > + ? D",
),
(
"SELECT COUNT(*) FROM TABLE_1 JOIN table_2 ON TABLE_1.foo = table_2.bar where col1 > -1d",
"SELECT COUNT ( * ) FROM TABLE_1 JOIN table_2 ON TABLE_1.foo = table_2.bar where col1 > ? d",
),
(
"SELECT COUNT(*) FROM TABLE_1 JOIN table_2 ON TABLE_1.foo = table_2.bar where col1 > x'ff'",
"SELECT COUNT ( * ) FROM TABLE_1 JOIN table_2 ON TABLE_1.foo = table_2.bar where col1 > ?",
),
(
"SELECT COUNT(*) FROM TABLE_1 JOIN table_2 ON TABLE_1.foo = table_2.bar where col1 > X'ff'",
"SELECT COUNT ( * ) FROM TABLE_1 JOIN table_2 ON TABLE_1.foo = table_2.bar where col1 > ?",
),
(
"SELECT COUNT(*) FROM TABLE_1 JOIN table_2 ON TABLE_1.foo = table_2.bar where col1 > 0xff",
"SELECT COUNT ( * ) FROM TABLE_1 JOIN table_2 ON TABLE_1.foo = table_2.bar where col1 > ?",
),
(
"SELECT COUNT(*) FROM TABLE_1 JOIN table_2 ON TABLE_1.foo = table_2.bar where col1 <> \'\'",
"SELECT COUNT ( * ) FROM TABLE_1 JOIN table_2 ON TABLE_1.foo = table_2.bar where col1 <> ?",
),
(
"SELECT COUNT(*) FROM TABLE_1 JOIN table_2 ON TABLE_1.foo = table_2.bar where col1 <> \' \'",
"SELECT COUNT ( * ) FROM TABLE_1 JOIN table_2 ON TABLE_1.foo = table_2.bar where col1 <> ?",
),
(
"SELECT COUNT(*) FROM TABLE_1 JOIN table_2 ON TABLE_1.foo = table_2.bar where col1 <> \' \'",
"SELECT COUNT ( * ) FROM TABLE_1 JOIN table_2 ON TABLE_1.foo = table_2.bar where col1 <> ?",
),
// Standard SQL strings with spaces and regular content
(
"SELECT COUNT(*) FROM TABLE_1 JOIN table_2 ON TABLE_1.foo = table_2.bar where col1 <> ' x '",
"SELECT COUNT ( * ) FROM TABLE_1 JOIN table_2 ON TABLE_1.foo = table_2.bar where col1 <> ?",
),
(
"SELECT COUNT(*) FROM TABLE_1 JOIN table_2 ON TABLE_1.foo = table_2.bar where col1 <> ' x x'",
"SELECT COUNT ( * ) FROM TABLE_1 JOIN table_2 ON TABLE_1.foo = table_2.bar where col1 <> ?",
),
(
"SELECT COUNT(*) FROM TABLE_1 JOIN table_2 ON TABLE_1.foo = table_2.bar where col1 <> \'5,123\'",
"SELECT COUNT ( * ) FROM TABLE_1 JOIN table_2 ON TABLE_1.foo = table_2.bar where col1 <> ?",
),
// comma after ? is stripped: NOT NULL, next_col → NOT ? next_col
(
"CREATE TABLE S_H2 (id INTEGER not NULL, PRIMARY KEY ( id ))",
"CREATE TABLE S_H2 ( id INTEGER not ? PRIMARY KEY ( id ) )",
),
(
"CREATE TABLE S_H2 ( id INTEGER not NULL, PRIMARY KEY ( id ) )",
"CREATE TABLE S_H2 ( id INTEGER not ? PRIMARY KEY ( id ) )",
),
(
"SELECT * FROM TABLE WHERE name = 'O''Brady'",
"SELECT * FROM TABLE WHERE name = ?",
),
(
"INSERT INTO visits VALUES (2, 8, '2013-01-02', 'rabies shot')",
"INSERT INTO visits VALUES ( ? )",
),
(
"SELECT * FROM TABLE WHERE userId = ',' and foo=foo.bar",
"SELECT * FROM TABLE WHERE userId = ? and foo = foo.bar",
),
(
"SELECT * FROM TABLE WHERE userId = ','||foo.bar",
"SELECT * FROM TABLE WHERE userId = ? | | foo.bar",
),
// :named bind params kept as-is
(
"SELECT * FROM t WHERE y IN (:protocols) AND x IN (:sites)",
"SELECT * FROM t WHERE y IN ( :protocols ) AND x IN ( :sites )",
),
// multi-row VALUES collapse (quantizer_33)
(
"INSERT INTO user (id, username) VALUES ('Fred','Smith'), ('John','Smith'), ('Michael','Smith'), ('Robert','Smith');",
"INSERT INTO user ( id, username ) VALUES ( ? )",
),
// backtick identifier with regular ident after dot (quantizer_43)
(
"INSERT INTO `qual-aa`.issues (alert0, alert1) VALUES (NULL, NULL)",
"INSERT INTO qual-aa . issues ( alert0, alert1 ) VALUES ( ? )",
),
// !+2 sign handling: + after ! should be an operator (table_finder_23)
(
"select !+2",
"select ! + ?",
),
// keep_positional_parameter handled in test_sql_obfuscation_config below
// 5*s1: multiplication, not sign prefix (quantizer_49 style)
(
"SELECT 5*s1 FROM t4",
"SELECT ? * s1 FROM t4",
),
(
"(SELECT 5*s1 FROM t4 UNION SELECT 77 FROM t5)",
"( SELECT ? * s1 FROM t4 UNION SELECT ? FROM t5 )",
),
// Full quantizer_49 relevant fragment (ROW with = subquery)
(
"WHERE ROW(5*t2.s1,77)=(SELECT 5*s1 FROM t4 UNION SELECT 77 FROM (SELECT * FROM t5))",
"WHERE ROW ( ? * t2.s1, ? ) = ( SELECT ? * s1 FROM t4 UNION SELECT ? FROM ( SELECT * FROM t5 ) )",
),
// comma after ? is stripped (quantizer_10 style)
(
"UPDATE user_dash_pref SET json_prefs = %(json_prefs)s, modified = '2015-08-27' WHERE user_id = %(user_id)s AND url = %(url)s",
"UPDATE user_dash_pref SET json_prefs = ? modified = ? WHERE user_id = ? AND url = ?",
),
// comma after ? in SET list (metadata_create_trigger style)
(
"UPDATE t SET a = 1, b = 2, c = 3",
"UPDATE t SET a = ? b = ? c = ?",
),
// comma after ? in function call (quantizer_81 style): comma after first ? arg stripped
(
"SELECT set_config('foo', bar, FALSE)",
"SELECT set_config ( ? bar, ? )",
),
// fuzzing_792557810: colon followed by unicode letter should not add space
(":ჸ", ":ჸ"),
// fuzzing_1113621604: % followed by unicode letter is a format parameter → ?
("%ჸ", "?"),
// fuzzing_4250509562: % followed by any ASCII letter is a format parameter → ?
("%C", "?"),
// fuzzing_1492599371: standalone dot followed by unicode ident needs space
(".ჸ", ". ჸ"),
// sql_fuzzing: 0!(2 grouping — operator resets lp, so '2' after '(' gets '?'
("0!(2", "? ! ( ?"),
// sql_fuzzing_3326675327: '(' does NOT reset lp — '$0' grouped with leading '?'
("0(($0", "? ( ("),
// fuzzing_4233627642: digit followed by letter suffix — letter is separate IDENT
("0D", "? D"),
// sql_fuzzing_4064530249: @ followed by unicode ident → no space (bind param)
("@ᏤᏤ", "@ᏤᏤ"),
// fuzzing_4138960753: unicode ident immediately followed by * is one token
("ჸ*", "ჸ*"),
// sql_fuzzing: standalone .* → ". *" but table.* → "table.*"
(".*", ". *"),
("table.*", "table.*"),
// fuzzing test: ( followed by unicode ident should have space
("(ჷ", "( ჷ"),
("2%$2", "? % ?"),
];
#[test]
fn test_normalize_only() {
let config = SqlObfuscateConfig {
obfuscation_mode: SqlObfuscationMode::NormalizeOnly,
..Default::default()
};
let cases = &[
// Simple: keep numbers as-is
(
"SELECT * FROM users WHERE id = 1",
"SELECT * FROM users WHERE id = 1",
),
// Keep strings as-is
(
"SELECT * FROM users WHERE id = 1 AND name = 'test'",
"SELECT * FROM users WHERE id = 1 AND name = 'test'",
),
// Strip comments, normalize whitespace
(
"-- comment\n/* comment */\nSELECT id as id, name as n FROM users123 WHERE id in (1,2,3)",
"SELECT id as id, name as n FROM users123 WHERE id in ( 1, 2, 3 )",
),
// WITH CTE: keep AS
(
"WITH users AS (SELECT * FROM people) SELECT * FROM users",
"WITH users AS ( SELECT * FROM people ) SELECT * FROM users",
),
// Keep positional params as-is
(
"SELECT * FROM users WHERE id = 1 AND address = $1 and id = $2 AND deleted IS NULL AND active is TRUE",
"SELECT * FROM users WHERE id = 1 AND address = $1 and id = $2 AND deleted IS NULL AND active is TRUE",
),
// keep_trailing_semicolon ignored — semicolon stripped in normalize mode (same as obfuscate)
// Actually in normalize mode: keep semicolon when keep_trailing_semicolon=true
// Here with default (false): strip semicolon
(
"SELECT * FROM users WHERE id = 1;",
"SELECT * FROM users WHERE id = 1",
),
];
for (input, expected) in cases {
let got = super::obfuscate_sql(input, &config, DbmsKind::Generic);
assert_eq!(got, *expected, "normalize_only input={input:?}");
}
}
#[test]
fn test_normalize_only_keep_trailing_semi() {
let config = SqlObfuscateConfig {
obfuscation_mode: SqlObfuscationMode::NormalizeOnly,
keep_trailing_semicolon: true,
..Default::default()
};
let got = super::obfuscate_sql(
"SELECT * FROM users WHERE id = 1 AND name = 'test';",
&config,
DbmsKind::Generic,
);
let expected = "SELECT * FROM users WHERE id = 1 AND name = 'test';";
assert_eq!(
got, expected,
"normalize_only+keep_trailing_semicolon: {got:?}"
);
}
#[test]
fn test_normalize_only_keep_identifier_quotation() {
let config = SqlObfuscateConfig {
obfuscation_mode: SqlObfuscationMode::NormalizeOnly,
keep_identifier_quotation: true,
..Default::default()
};
let got = super::obfuscate_sql(
r#"SELECT * FROM "users" WHERE id = 1 AND name = 'test'"#,
&config,
DbmsKind::Generic,
);
let expected = r#"SELECT * FROM "users" WHERE id = 1 AND name = 'test'"#;
assert_eq!(
got, expected,
"normalize_only+keep_identifier_quotation: {got:?}"
);
}
#[test]
fn test_with_cte_stripping() {
// In legacy mode (obfuscation_mode=""), WITH T1 AS (SELECT...) → WITH T1 SELECT...
let config = SqlObfuscateConfig::default();
let cases = &[
// Single CTE - strip AS and opening paren, keep closing )
(
"WITH sales AS (SELECT x FROM t WHERE id = 1) SELECT * FROM sales",
"WITH sales SELECT x FROM t WHERE id = ? ) SELECT * FROM sales",
),
// Two CTEs - comma between CTEs stripped too
(
"WITH T1 AS (SELECT a FROM t1 WHERE id = 1), T2 AS (SELECT b FROM t2) SELECT * FROM T1",
"WITH T1 SELECT a FROM t1 WHERE id = ? ) T2 SELECT b FROM t2 ) SELECT * FROM T1",
),
];
for (input, expected) in cases {
let got = super::obfuscate_sql(input, &config, DbmsKind::Generic);
assert_eq!(got, *expected, "with_cte_stripping input={input:?}");
}
}
#[test]
fn test_double_quoted_string_value_quantize() {
// Double-quoted strings in value context (after =) should be quantized
let config = SqlObfuscateConfig::default();
let cases = &[
// After = in SET clause
(
r#"update Orders set created = "2019-05-24 00:26:17", gross = 30.28"#,
"update Orders set created = ? gross = ?",
),
// After = in SET clause, identifier-like value
(
r#"update Orders set payment_type = "eventbrite""#,
"update Orders set payment_type = ?",
),
// Table identifier (after FROM) — keep
(
r#"SELECT * FROM "users" WHERE id = 1"#,
r"SELECT * FROM users WHERE id = ?",
),
];
for (input, expected) in cases {
let got = super::obfuscate_sql(input, &config, DbmsKind::Generic);
assert_eq!(got, *expected, "double_quoted_value input={input:?}");
}
}
#[test]
fn test_normalize_only_dollar_func() {
// In normalize_only mode, dollar-quoted strings are normalized (not quantized)
let config = SqlObfuscateConfig {
obfuscation_mode: SqlObfuscationMode::NormalizeOnly,
..Default::default()
};
let got = super::obfuscate_sql(
"SELECT $func$INSERT INTO table VALUES ('a', 1, 2)$func$ FROM users",
&config,
DbmsKind::Generic,
);
let expected = "SELECT $func$INSERT INTO table VALUES ( 'a', 1, 2 )$func$ FROM users";
assert_eq!(got, expected, "normalize_only dollar_func: {got:?}");
}
#[test]
fn test_dollar_quoted_func_trivial_collapse() {
// When dollar_quoted_func=true and inner content obfuscates to a single ?, collapse to ?
let config = SqlObfuscateConfig {
dollar_quoted_func: true,
replace_digits: true,
..Default::default()
};
let got = super::obfuscate_sql(
"SELECT * FROM users123 WHERE id = $tag$1$tag$",
&config,
DbmsKind::Generic,
);
let expected = "SELECT * FROM users? WHERE id = ?";
assert_eq!(
got, expected,
"dollar_quoted_func trivial collapse: {got:?}"
);
}
#[test]
fn test_obfuscate_only_keeps_quotes_and_semi() {
// In obfuscate_only mode: keep double-quoted identifiers, keep $?, keep trailing ;
let config = SqlObfuscateConfig {
obfuscation_mode: SqlObfuscationMode::ObfuscateOnly,
..Default::default()
};
let got = super::obfuscate_sql(
r#"SELECT "table"."field" FROM "table" WHERE "table"."otherfield" = $? AND "table"."thirdfield" = $?;"#,
&config,
DbmsKind::Generic,
);
let expected = r#"SELECT "table"."field" FROM "table" WHERE "table"."otherfield" = $? AND "table"."thirdfield" = $?;"#;
assert_eq!(got, expected, "obfuscate_only keeps quotes/$/semi: {got:?}");
}
#[test]
fn test_obfuscate_only_dollar_quoted_func_no_collapse() {
// In obfuscate_only+dollar_quoted_func: VALUES inside func are NOT collapsed
let config = SqlObfuscateConfig {
obfuscation_mode: SqlObfuscationMode::ObfuscateOnly,
dollar_quoted_func: true,
..Default::default()
};
let got = super::obfuscate_sql(
"SELECT $func$INSERT INTO table VALUES ('a', 1, 2)$func$ FROM users",
&config,
DbmsKind::Generic,
);
let expected = "SELECT $func$INSERT INTO table VALUES (?, ?, ?)$func$ FROM users";
assert_eq!(
got, expected,
"obfuscate_only dollar_quoted_func no collapse: {got:?}"
);
}
#[test]
fn test_normalize_only_procedure() {
let config = SqlObfuscateConfig {
obfuscation_mode: SqlObfuscationMode::NormalizeOnly,
..Default::default()
};
let got = super::obfuscate_sql(
"CREATE PROCEDURE TestProc AS BEGIN UPDATE users SET name = 'test' WHERE id = 1 END",
&config,
DbmsKind::Generic,
);
let expected =
"CREATE PROCEDURE TestProc AS BEGIN UPDATE users SET name = 'test' WHERE id = 1 END";
assert_eq!(got, expected, "normalize_only+procedure: {got:?}");
}
#[test]
fn test_q41() {
let config = SqlObfuscateConfig::default();
let input = "SELECT * FROM public.table ( array [ ROW ( array [ 'magic', 'foo',";
// First check raw (pre-collapse) output
let mut tok = super::Tokenizer::new(input, &config, DbmsKind::Generic);
tok.process();
let raw = tok.finalize();
eprintln!("RAW: {raw:?}");
let got = super::obfuscate_sql(input, &config, DbmsKind::Generic);
let expected = "SELECT * FROM public.table ( array [ ROW ( array [ ?";
assert_eq!(got, expected, "q41: {got:?}");
}
// --- Integration test cases added for faster iteration ---
#[test]
fn test_pg_json_operators_7() {
// JSONB ? operator followed by string literal — both should be kept as ?
let got = super::obfuscate_sql(
"select * from users where user.custom ? 'foo'",
&SqlObfuscateConfig::default(),
DbmsKind::Postgresql,
);
let expected = "select * from users where user.custom ? ?";
assert_eq!(got, expected, "pg_json_7: {got:?}");
}
#[test]
fn test_quantizer_90() {
// Inline comment /*!obfuscation*/ should be stripped; consecutive literals after = reset
let config = SqlObfuscateConfig::default();
let got = super::obfuscate_sql(
"SELECT * FROM dbo.Items WHERE id = 1 or /*!obfuscation*/ 1 = 1",
&config,
DbmsKind::Generic,
);
let expected = "SELECT * FROM dbo.Items WHERE id = ? or ? = ?";
assert_eq!(got, expected, "q90: {got:?}");
}
#[test]
fn test_cassandra_nested_dates() {
// Consecutive ? placeholders inside nested function calls should be suppressed
let config = SqlObfuscateConfig::default();
let got = super::obfuscate_sql(
"SELECT TO_DATE(TO_CHAR(TO_DATE(bar.h,?),?),?) FROM t",
&config,
DbmsKind::Generic,
);
let expected = "SELECT TO_DATE ( TO_CHAR ( TO_DATE ( bar.h, ? ) ) ) FROM t";
assert_eq!(got, expected, "cassandra_nested_dates: {got:?}");
}
#[test]
fn test_cassandra_pipe_concat() {
// || concatenation — Go tokenizes as two separate | tokens with spaces
let config = SqlObfuscateConfig::default();
let got = super::obfuscate_sql("SELECT a ||?|| b FROM t", &config, DbmsKind::Generic);
let expected = "SELECT a | | ? | | b FROM t";
assert_eq!(got, expected, "cassandra_pipe: {got:?}");
}
// Test cases from the agent repo
const SUITE_CASES: &[(&str, &str)] = &[
// sql_keep_alias_off
("SELECT username AS person FROM users WHERE id=4", "SELECT username FROM users WHERE id = ?"),
// sql_autovacuum_0
("autovacuum: VACUUM ANALYZE fake.table", "autovacuum : VACUUM ANALYZE fake.table"),
// sql_autovacuum_1
("autovacuum: VACUUM ANALYZE fake.table_downtime", "autovacuum : VACUUM ANALYZE fake.table_downtime"),
// sql_autovacuum_2
("autovacuum: VACUUM fake.big_table (to prevent wraparound)", "autovacuum : VACUUM fake.big_table ( to prevent wraparound )"),
// sql_dollar_quoted_func_off
("SELECT $func$INSERT INTO table VALUES ('a', 1, 2)$func$ FROM users", "SELECT ? FROM users"),
// sql_metadata_multiline_comment_select_insert
("\n/* Multi-line comment */\nSELECT * FROM clients WHERE (clients.first_name = 'Andy') LIMIT 1 BEGIN INSERT INTO owners (created_at, first_name, locked, orders_count, updated_at) VALUES ('2011-08-30 05:22:57', 'Andy', 1, NULL, '2011-08-30 05:22:57') COMMIT", "SELECT * FROM clients WHERE ( clients.first_name = ? ) LIMIT ? BEGIN INSERT INTO owners ( created_at, first_name, locked, orders_count, updated_at ) VALUES ( ? ) COMMIT"),
// sql_metadata_multiline_comment_select_insert_lowercase_limit
("\n/* Multi-line comment */\nSELECT * FROM clients WHERE (clients.first_name = 'Andy') limit 1 BEGIN INSERT INTO owners (created_at, first_name, locked, orders_count, updated_at) VALUES ('2011-08-30 05:22:57', 'Andy', 1, NULL, '2011-08-30 05:22:57') COMMIT", "SELECT * FROM clients WHERE ( clients.first_name = ? ) limit ? BEGIN INSERT INTO owners ( created_at, first_name, locked, orders_count, updated_at ) VALUES ( ? ) COMMIT"),
// sql_metadata_single_line_comments_grant
("\n-- Single line comment\n-- Another single line comment\n-- Another another single line comment\nGRANT USAGE, DELETE ON SCHEMA datadog TO datadog", "GRANT USAGE, DELETE ON SCHEMA datadog TO datadog"),
// sql_metadata_no_collect
("\n/*\nMulti-line comment\nwith line breaks\n*/\n/* Two multi-line comments with\nline breaks */\nSELECT clients.* FROM clients INNER JOIN posts ON posts.author_id = author.id AND posts.published = 't'", "SELECT clients.* FROM clients INNER JOIN posts ON posts.author_id = author.id AND posts.published = ?"),
// sql_metadata_create_trigger
("CREATE TRIGGER dogwatcher SELECT ON w1 BEFORE (UPDATE d1 SET (c1, c2, c3) = (c1 + 1, c2 + 1, c3 + 1))", "CREATE TRIGGER dogwatcher SELECT ON w1 BEFORE ( UPDATE d1 SET ( c1, c2, c3 ) = ( c1 + ? c2 + ? c3 + ? ) )"),
// sql_metadata_table_value_constructor
("\n-- Testing table value constructor SQL expression\nSELECT * FROM (VALUES (1, 'dog')) AS d (id, animal)", "SELECT * FROM ( VALUES ( ? ) ) ( id, animal )"),
// sql_metadata_alter_table
("ALTER TABLE table DROP COLUMN column", "ALTER TABLE table DROP COLUMN column"),
// sql_metadata_revoke
("REVOKE ALL ON SCHEMA datadog FROM datadog", "REVOKE ALL ON SCHEMA datadog FROM datadog"),
// sql_metadata_truncate
("TRUNCATE TABLE datadog", "TRUNCATE TABLE datadog"),
// sql_metadata_explicit_table
("\n-- Testing explicit table SQL expression\nWITH T1 AS (SELECT PNO , PNAME , COLOR , WEIGHT , CITY FROM P WHERE CITY = 'London'),\nT2 AS (SELECT PNO, PNAME, COLOR, WEIGHT, CITY, 2 * WEIGHT AS NEW_WEIGHT, 'Oslo' AS NEW_CITY FROM T1),\nT3 AS ( SELECT PNO , PNAME, COLOR, NEW_WEIGHT AS WEIGHT, NEW_CITY AS CITY FROM T2),\nT4 AS ( TABLE P EXCEPT CORRESPONDING TABLE T1)\nTABLE T4 UNION CORRESPONDING TABLE T3", "WITH T1 SELECT PNO, PNAME, COLOR, WEIGHT, CITY FROM P WHERE CITY = ? ) T2 SELECT PNO, PNAME, COLOR, WEIGHT, CITY, ? * WEIGHT, ? FROM T1 ), T3 SELECT PNO, PNAME, COLOR, NEW_WEIGHT, NEW_CITY FROM T2 ), T4 TABLE P EXCEPT CORRESPONDING TABLE T1 ) TABLE T4 UNION CORRESPONDING TABLE T3"),
// sql_utf8_catalan_1
("SELECT Codi , Nom_CA AS Nom, Descripció_CAT AS Descripció FROM ProtValAptitud WHERE Vigent=1 ORDER BY Ordre, Codi", "SELECT Codi, Nom_CA, Descripció_CAT FROM ProtValAptitud WHERE Vigent = ? ORDER BY Ordre, Codi"),
// sql_utf8_catalan_2
(" SELECT dbo.Treballadors_ProtCIE_AntecedentsPatologics.IdTreballadorsProtCIE_AntecedentsPatologics, dbo.ProtCIE.Codi As CodiProtCIE, Treballadors_ProtCIE_AntecedentsPatologics.Año, dbo.ProtCIE.Nom_ES, dbo.ProtCIE.Nom_CA FROM dbo.Treballadors_ProtCIE_AntecedentsPatologics WITH (NOLOCK) INNER JOIN dbo.ProtCIE WITH (NOLOCK) ON dbo.Treballadors_ProtCIE_AntecedentsPatologics.CodiProtCIE = dbo.ProtCIE.Codi WHERE Treballadors_ProtCIE_AntecedentsPatologics.IdTreballador = 12345 ORDER BY Treballadors_ProtCIE_AntecedentsPatologics.Año DESC, dbo.ProtCIE.Codi ", "SELECT dbo.Treballadors_ProtCIE_AntecedentsPatologics.IdTreballadorsProtCIE_AntecedentsPatologics, dbo.ProtCIE.Codi, Treballadors_ProtCIE_AntecedentsPatologics.Año, dbo.ProtCIE.Nom_ES, dbo.ProtCIE.Nom_CA FROM dbo.Treballadors_ProtCIE_AntecedentsPatologics WITH ( NOLOCK ) INNER JOIN dbo.ProtCIE WITH ( NOLOCK ) ON dbo.Treballadors_ProtCIE_AntecedentsPatologics.CodiProtCIE = dbo.ProtCIE.Codi WHERE Treballadors_ProtCIE_AntecedentsPatologics.IdTreballador = ? ORDER BY Treballadors_ProtCIE_AntecedentsPatologics.Año DESC, dbo.ProtCIE.Codi"),
// sql_utf8_catalan_3
("select top 100 percent IdTrebEmpresa as [IdTrebEmpresa], CodCli as [Client], NOMEMP as [Nom Client], Baixa as [Baixa], CASE WHEN IdCentreTreball IS NULL THEN '-' ELSE CONVERT(VARCHAR(8),IdCentreTreball) END as [Id Centre], CASE WHEN NOMESTAB IS NULL THEN '-' ELSE NOMESTAB END as [Nom Centre], TIPUS as [Tipus Lloc], CASE WHEN IdLloc IS NULL THEN '-' ELSE CONVERT(VARCHAR(8),IdLloc) END as [Id Lloc], CASE WHEN NomLlocComplert IS NULL THEN '-' ELSE NomLlocComplert END as [Lloc Treball], CASE WHEN DesLloc IS NULL THEN '-' ELSE DesLloc END as [Descripció], IdLlocTreballUnic as [Id Únic] From ( SELECT '-' AS TIPUS, dbo.Treb_Empresa.IdTrebEmpresa, dbo.Treb_Empresa.IdTreballador, dbo.Treb_Empresa.CodCli, dbo.Clients.NOMEMP, dbo.Treb_Empresa.Baixa, dbo.Treb_Empresa.IdCentreTreball, dbo.Cli_Establiments.NOMESTAB, null AS IdLloc, null AS NomLlocComplert, dbo.Treb_Empresa.DataInici, dbo.Treb_Empresa.DataFi, CASE WHEN dbo.Treb_Empresa.DesLloc IS NULL THEN '' ELSE dbo.Treb_Empresa.DesLloc END DesLloc, dbo.Treb_Empresa.IdLlocTreballUnic FROM dbo.Clients WITH (NOLOCK) INNER JOIN dbo.Treb_Empresa WITH (NOLOCK) ON dbo.Clients.CODCLI = dbo.Treb_Empresa.CodCli LEFT OUTER JOIN dbo.Cli_Establiments WITH (NOLOCK) ON dbo.Cli_Establiments.Id_ESTAB_CLI = dbo.Treb_Empresa.IdCentreTreball AND dbo.Cli_Establiments.CODCLI = dbo.Treb_Empresa.CodCli WHERE dbo.Treb_Empresa.IdTreballador = 64376 AND Treb_Empresa.IdTecEIRLLlocTreball IS NULL AND IdMedEIRLLlocTreball IS NULL AND IdLlocTreballTemporal IS NULL UNION ALL SELECT 'AV. RIESGO' AS TIPUS, dbo.Treb_Empresa.IdTrebEmpresa, dbo.Treb_Empresa.IdTreballador, dbo.Treb_Empresa.CodCli, dbo.Clients.NOMEMP, dbo.Treb_Empresa.Baixa, dbo.Treb_Empresa.IdCentreTreball, dbo.Cli_Establiments.NOMESTAB, dbo.Treb_Empresa.IdTecEIRLLlocTreball AS IdLloc, dbo.fn_NomLlocComposat(dbo.Treb_Empresa.IdTecEIRLLlocTreball) AS NomLlocComplert, dbo.Treb_Empresa.DataInici, dbo.Treb_Empresa.DataFi, CASE WHEN dbo.Treb_Empresa.DesLloc IS NULL THEN '' ELSE dbo.Treb_Empresa.DesLloc END DesLloc, dbo.Treb_Empresa.IdLlocTreballUnic FROM dbo.Clients WITH (NOLOCK) INNER JOIN dbo.Treb_Empresa WITH (NOLOCK) ON dbo.Clients.CODCLI = dbo.Treb_Empresa.CodCli LEFT OUTER JOIN dbo.Cli_Establiments WITH (NOLOCK) ON dbo.Cli_Establiments.Id_ESTAB_CLI = dbo.Treb_Empresa.IdCentreTreball AND dbo.Cli_Establiments.CODCLI = dbo.Treb_Empresa.CodCli WHERE (dbo.Treb_Empresa.IdTreballador = 64376) AND (NOT (dbo.Treb_Empresa.IdTecEIRLLlocTreball IS NULL)) UNION ALL SELECT 'EXTERNA' AS TIPUS, dbo.Treb_Empresa.IdTrebEmpresa, dbo.Treb_Empresa.IdTreballador, dbo.Treb_Empresa.CodCli, dbo.Clients.NOMEMP, dbo.Treb_Empresa.Baixa, dbo.Treb_Empresa.IdCentreTreball, dbo.Cli_Establiments.NOMESTAB, dbo.Treb_Empresa.IdMedEIRLLlocTreball AS IdLloc, dbo.fn_NomMedEIRLLlocComposat(dbo.Treb_Empresa.IdMedEIRLLlocTreball) AS NomLlocComplert, dbo.Treb_Empresa.DataInici, dbo.Treb_Empresa.DataFi, CASE WHEN dbo.Treb_Empresa.DesLloc IS NULL THEN '' ELSE dbo.Treb_Empresa.DesLloc END DesLloc, dbo.Treb_Empresa.IdLlocTreballUnic FROM dbo.Clients WITH (NOLOCK) INNER JOIN dbo.Treb_Empresa WITH (NOLOCK) ON dbo.Clients.CODCLI = dbo.Treb_Empresa.CodCli LEFT OUTER JOIN dbo.Cli_Establiments WITH (NOLOCK) ON dbo.Cli_Establiments.Id_ESTAB_CLI = dbo.Treb_Empresa.IdCentreTreball AND dbo.Cli_Establiments.CODCLI = dbo.Treb_Empresa.CodCli WHERE (dbo.Treb_Empresa.IdTreballador = 64376) AND (Treb_Empresa.IdTecEIRLLlocTreball IS NULL) AND (NOT (dbo.Treb_Empresa.IdMedEIRLLlocTreball IS NULL)) UNION ALL SELECT 'TEMPORAL' AS TIPUS, dbo.Treb_Empresa.IdTrebEmpresa, dbo.Treb_Empresa.IdTreballador, dbo.Treb_Empresa.CodCli, dbo.Clients.NOMEMP, dbo.Treb_Empresa.Baixa, dbo.Treb_Empresa.IdCentreTreball, dbo.Cli_Establiments.NOMESTAB, dbo.Treb_Empresa.IdLlocTreballTemporal AS IdLloc, dbo.Lloc_Treball_Temporal.NomLlocTreball AS NomLlocComplert, dbo.Treb_Empresa.DataInici, dbo.Treb_Empresa.DataFi, CASE WHEN dbo.Treb_Empresa.DesLloc IS NULL THEN '' ELSE dbo.Treb_Empresa.DesLloc END DesLloc, dbo.Treb_Empresa.IdLlocTreballUnic FROM dbo.Clients WITH (NOLOCK) INNER JOIN dbo.Treb_Empresa WITH (NOLOCK) ON dbo.Clients.CODCLI = dbo.Treb_Empresa.CodCli INNER JOIN dbo.Lloc_Treball_Temporal WITH (NOLOCK) ON dbo.Treb_Empresa.IdLlocTreballTemporal = dbo.Lloc_Treball_Temporal.IdLlocTreballTemporal LEFT OUTER JOIN dbo.Cli_Establiments WITH (NOLOCK) ON dbo.Cli_Establiments.Id_ESTAB_CLI = dbo.Treb_Empresa.IdCentreTreball AND dbo.Cli_Establiments.CODCLI = dbo.Treb_Empresa.CodCli WHERE dbo.Treb_Empresa.IdTreballador = 64376 AND Treb_Empresa.IdTecEIRLLlocTreball IS NULL AND IdMedEIRLLlocTreball IS NULL ) as taula Where 1=0 ", "select top ? percent IdTrebEmpresa, CodCli, NOMEMP, Baixa, CASE WHEN IdCentreTreball IS ? THEN ? ELSE CONVERT ( VARCHAR ( ? ) IdCentreTreball ) END, CASE WHEN NOMESTAB IS ? THEN ? ELSE NOMESTAB END, TIPUS, CASE WHEN IdLloc IS ? THEN ? ELSE CONVERT ( VARCHAR ( ? ) IdLloc ) END, CASE WHEN NomLlocComplert IS ? THEN ? ELSE NomLlocComplert END, CASE WHEN DesLloc IS ? THEN ? ELSE DesLloc END, IdLlocTreballUnic From ( SELECT ?, dbo.Treb_Empresa.IdTrebEmpresa, dbo.Treb_Empresa.IdTreballador, dbo.Treb_Empresa.CodCli, dbo.Clients.NOMEMP, dbo.Treb_Empresa.Baixa, dbo.Treb_Empresa.IdCentreTreball, dbo.Cli_Establiments.NOMESTAB, ?, ?, dbo.Treb_Empresa.DataInici, dbo.Treb_Empresa.DataFi, CASE WHEN dbo.Treb_Empresa.DesLloc IS ? THEN ? ELSE dbo.Treb_Empresa.DesLloc END DesLloc, dbo.Treb_Empresa.IdLlocTreballUnic FROM dbo.Clients WITH ( NOLOCK ) INNER JOIN dbo.Treb_Empresa WITH ( NOLOCK ) ON dbo.Clients.CODCLI = dbo.Treb_Empresa.CodCli LEFT OUTER JOIN dbo.Cli_Establiments WITH ( NOLOCK ) ON dbo.Cli_Establiments.Id_ESTAB_CLI = dbo.Treb_Empresa.IdCentreTreball AND dbo.Cli_Establiments.CODCLI = dbo.Treb_Empresa.CodCli WHERE dbo.Treb_Empresa.IdTreballador = ? AND Treb_Empresa.IdTecEIRLLlocTreball IS ? AND IdMedEIRLLlocTreball IS ? AND IdLlocTreballTemporal IS ? UNION ALL SELECT ?, dbo.Treb_Empresa.IdTrebEmpresa, dbo.Treb_Empresa.IdTreballador, dbo.Treb_Empresa.CodCli, dbo.Clients.NOMEMP, dbo.Treb_Empresa.Baixa, dbo.Treb_Empresa.IdCentreTreball, dbo.Cli_Establiments.NOMESTAB, dbo.Treb_Empresa.IdTecEIRLLlocTreball, dbo.fn_NomLlocComposat ( dbo.Treb_Empresa.IdTecEIRLLlocTreball ), dbo.Treb_Empresa.DataInici, dbo.Treb_Empresa.DataFi, CASE WHEN dbo.Treb_Empresa.DesLloc IS ? THEN ? ELSE dbo.Treb_Empresa.DesLloc END DesLloc, dbo.Treb_Empresa.IdLlocTreballUnic FROM dbo.Clients WITH ( NOLOCK ) INNER JOIN dbo.Treb_Empresa WITH ( NOLOCK ) ON dbo.Clients.CODCLI = dbo.Treb_Empresa.CodCli LEFT OUTER JOIN dbo.Cli_Establiments WITH ( NOLOCK ) ON dbo.Cli_Establiments.Id_ESTAB_CLI = dbo.Treb_Empresa.IdCentreTreball AND dbo.Cli_Establiments.CODCLI = dbo.Treb_Empresa.CodCli WHERE ( dbo.Treb_Empresa.IdTreballador = ? ) AND ( NOT ( dbo.Treb_Empresa.IdTecEIRLLlocTreball IS ? ) ) UNION ALL SELECT ?, dbo.Treb_Empresa.IdTrebEmpresa, dbo.Treb_Empresa.IdTreballador, dbo.Treb_Empresa.CodCli, dbo.Clients.NOMEMP, dbo.Treb_Empresa.Baixa, dbo.Treb_Empresa.IdCentreTreball, dbo.Cli_Establiments.NOMESTAB, dbo.Treb_Empresa.IdMedEIRLLlocTreball, dbo.fn_NomMedEIRLLlocComposat ( dbo.Treb_Empresa.IdMedEIRLLlocTreball ), dbo.Treb_Empresa.DataInici, dbo.Treb_Empresa.DataFi, CASE WHEN dbo.Treb_Empresa.DesLloc IS ? THEN ? ELSE dbo.Treb_Empresa.DesLloc END DesLloc, dbo.Treb_Empresa.IdLlocTreballUnic FROM dbo.Clients WITH ( NOLOCK ) INNER JOIN dbo.Treb_Empresa WITH ( NOLOCK ) ON dbo.Clients.CODCLI = dbo.Treb_Empresa.CodCli LEFT OUTER JOIN dbo.Cli_Establiments WITH ( NOLOCK ) ON dbo.Cli_Establiments.Id_ESTAB_CLI = dbo.Treb_Empresa.IdCentreTreball AND dbo.Cli_Establiments.CODCLI = dbo.Treb_Empresa.CodCli WHERE ( dbo.Treb_Empresa.IdTreballador = ? ) AND ( Treb_Empresa.IdTecEIRLLlocTreball IS ? ) AND ( NOT ( dbo.Treb_Empresa.IdMedEIRLLlocTreball IS ? ) ) UNION ALL SELECT ?, dbo.Treb_Empresa.IdTrebEmpresa, dbo.Treb_Empresa.IdTreballador, dbo.Treb_Empresa.CodCli, dbo.Clients.NOMEMP, dbo.Treb_Empresa.Baixa, dbo.Treb_Empresa.IdCentreTreball, dbo.Cli_Establiments.NOMESTAB, dbo.Treb_Empresa.IdLlocTreballTemporal, dbo.Lloc_Treball_Temporal.NomLlocTreball, dbo.Treb_Empresa.DataInici, dbo.Treb_Empresa.DataFi, CASE WHEN dbo.Treb_Empresa.DesLloc IS ? THEN ? ELSE dbo.Treb_Empresa.DesLloc END DesLloc, dbo.Treb_Empresa.IdLlocTreballUnic FROM dbo.Clients WITH ( NOLOCK ) INNER JOIN dbo.Treb_Empresa WITH ( NOLOCK ) ON dbo.Clients.CODCLI = dbo.Treb_Empresa.CodCli INNER JOIN dbo.Lloc_Treball_Temporal WITH ( NOLOCK ) ON dbo.Treb_Empresa.IdLlocTreballTemporal = dbo.Lloc_Treball_Temporal.IdLlocTreballTemporal LEFT OUTER JOIN dbo.Cli_Establiments WITH ( NOLOCK ) ON dbo.Cli_Establiments.Id_ESTAB_CLI = dbo.Treb_Empresa.IdCentreTreball AND dbo.Cli_Establiments.CODCLI = dbo.Treb_Empresa.CodCli WHERE dbo.Treb_Empresa.IdTreballador = ? AND Treb_Empresa.IdTecEIRLLlocTreball IS ? AND IdMedEIRLLlocTreball IS ? ) Where ? = ?"),
// sql_utf8_catalan_4
("select IdHistLabAnt as [IdHistLabAnt], IdTreballador as [IdTreballador], Empresa as [Professió], Anys as [Anys], Riscs as [Riscos], Nom_CA AS [Prot CNO], Nom_ES as [Prot CNO Altre Idioma] From ( SELECT dbo.Treb_HistAnt.IdHistLabAnt, dbo.Treb_HistAnt.IdTreballador, dbo.Treb_HistAnt.Empresa, dbo.Treb_HistAnt.Anys, dbo.Treb_HistAnt.Riscs, dbo.Treb_HistAnt.CodiProtCNO, dbo.ProtCNO.Nom_ES, dbo.ProtCNO.Nom_CA FROM dbo.Treb_HistAnt WITH (NOLOCK) LEFT OUTER JOIN dbo.ProtCNO WITH (NOLOCK) ON dbo.Treb_HistAnt.CodiProtCNO = dbo.ProtCNO.Codi Where dbo.Treb_HistAnt.IdTreballador = 12345 ) as taula ", "select IdHistLabAnt, IdTreballador, Empresa, Anys, Riscs, Nom_CA, Nom_ES From ( SELECT dbo.Treb_HistAnt.IdHistLabAnt, dbo.Treb_HistAnt.IdTreballador, dbo.Treb_HistAnt.Empresa, dbo.Treb_HistAnt.Anys, dbo.Treb_HistAnt.Riscs, dbo.Treb_HistAnt.CodiProtCNO, dbo.ProtCNO.Nom_ES, dbo.ProtCNO.Nom_CA FROM dbo.Treb_HistAnt WITH ( NOLOCK ) LEFT OUTER JOIN dbo.ProtCNO WITH ( NOLOCK ) ON dbo.Treb_HistAnt.CodiProtCNO = dbo.ProtCNO.Codi Where dbo.Treb_HistAnt.IdTreballador = ? )"),
// sql_utf8_catalan_5
("SELECT Cli_Establiments.CODCLI, Cli_Establiments.Id_ESTAB_CLI As [Código Centro Trabajo], Cli_Establiments.CODIGO_CENTRO_AXAPTA As [Código C. Axapta], Cli_Establiments.NOMESTAB As [Nombre], Cli_Establiments.ADRECA As [Dirección], Cli_Establiments.CodPostal As [Código Postal], Cli_Establiments.Poblacio as [Población], Cli_Establiments.Provincia, Cli_Establiments.TEL As [Tel], Cli_Establiments.EMAIL As [EMAIL], Cli_Establiments.PERS_CONTACTE As [Contacto], Cli_Establiments.PERS_CONTACTE_CARREC As [Cargo Contacto], Cli_Establiments.NumTreb As [Plantilla], Cli_Establiments.Localitzacio As [Localización], Tipus_Activitat.CNAE, Tipus_Activitat.Nom_ES As [Nombre Actividad], ACTIVO AS [Activo] FROM Cli_Establiments LEFT OUTER JOIN Tipus_Activitat ON Cli_Establiments.Id_ACTIVITAT = Tipus_Activitat.IdActivitat Where CODCLI = '01234' AND CENTRE_CORRECTE = 3 AND ACTIVO = 5 ORDER BY Cli_Establiments.CODIGO_CENTRO_AXAPTA ", "SELECT Cli_Establiments.CODCLI, Cli_Establiments.Id_ESTAB_CLI, Cli_Establiments.CODIGO_CENTRO_AXAPTA, Cli_Establiments.NOMESTAB, Cli_Establiments.ADRECA, Cli_Establiments.CodPostal, Cli_Establiments.Poblacio, Cli_Establiments.Provincia, Cli_Establiments.TEL, Cli_Establiments.EMAIL, Cli_Establiments.PERS_CONTACTE, Cli_Establiments.PERS_CONTACTE_CARREC, Cli_Establiments.NumTreb, Cli_Establiments.Localitzacio, Tipus_Activitat.CNAE, Tipus_Activitat.Nom_ES, ACTIVO FROM Cli_Establiments LEFT OUTER JOIN Tipus_Activitat ON Cli_Establiments.Id_ACTIVITAT = Tipus_Activitat.IdActivitat Where CODCLI = ? AND CENTRE_CORRECTE = ? AND ACTIVO = ? ORDER BY Cli_Establiments.CODIGO_CENTRO_AXAPTA"),
// sql_utf8_dollar_field
("select * from dollarField$ as df from some$dollar$filled_thing$$;", "select * from dollarField$ from some$dollar$filled_thing$$"),
// sql_utf8_backtick_jp
("select * from `構わない`;", "select * from 構わない"),
// sql_utf8_replacement_chars_1
("select * from names where name like '�����';", "select * from names where name like ?"),
// sql_utf8_replacement_chars_2
("select replacement from table where replacement = 'i�n�t�e��rspersed';", "select replacement from table where replacement = ?"),
// sql_utf8_replacement_char_3
("SELECT ('�');", "SELECT ( ? )"),
// sql_replace_digits_off_0
("REPLACE INTO sales_2019_07_01 (`itemID`, `date`, `qty`, `price`) VALUES ((SELECT itemID FROM item1001 WHERE `sku` = [sku]), CURDATE(), [qty], 0.00)", "REPLACE INTO sales_2019_07_01 ( itemID, date, qty, price ) VALUES ( ( SELECT itemID FROM item1001 WHERE sku = [ sku ] ), CURDATE ( ), [ qty ], ? )"),
// sql_replace_digits_off_1
("SELECT ddh19.name, ddt.tags FROM dd91219.host ddh19, dd21916.host_tags ddt WHERE ddh19.id = ddt.host_id AND ddh19.org_id = 2 AND ddh19.name = 'datadog'", "SELECT ddh19.name, ddt.tags FROM dd91219.host ddh19, dd21916.host_tags ddt WHERE ddh19.id = ddt.host_id AND ddh19.org_id = ? AND ddh19.name = ?"),
// sql_replace_digits_off_2
("SELECT ddu2.name, ddo.id10, ddk.app_key52 FROM dd3120.user ddu2, dd1931.orgs55 ddo, dd53819.keys ddk", "SELECT ddu2.name, ddo.id10, ddk.app_key52 FROM dd3120.user ddu2, dd1931.orgs55 ddo, dd53819.keys ddk"),
// sql_replace_digits_off_3
("SELECT daily_values1529.*, LEAST((5040000 - @runtot), value1830) AS value1830,\n(@runtot := @runtot + daily_values1529.value1830) AS total\nFROM (SELECT @runtot:=0) AS n,\ndaily_values1529 WHERE daily_values1529.subject_id = 12345 AND daily_values1592.subject_type = 'Skippity'\nAND (daily_values1529.date BETWEEN '2018-05-09' AND '2018-06-19') HAVING value >= 0 ORDER BY date", "SELECT daily_values1529.*, LEAST ( ( ? - @runtot ), value1830 ), ( @runtot := @runtot + daily_values1529.value1830 ) FROM ( SELECT @runtot := ? ), daily_values1529 WHERE daily_values1529.subject_id = ? AND daily_values1592.subject_type = ? AND ( daily_values1529.date BETWEEN ? AND ? ) HAVING value >= ? ORDER BY date"),
// sql_replace_digits_off_4
("WITH sales AS\n(SELECT sf2.*\n\tFROM gosalesdw28391.sls_order_method_dim AS md,\n\t\tgosalesdw1920.sls_product_dim391 AS pd190,\n\t\tgosalesdw3819.emp_employee_dim AS ed,\n\t\tgosalesdw3919.sls_sales_fact3819 AS sf2\n\tWHERE pd190.product_key = sf2.product_key\n\tAND pd190.product_number381 > 10000\n\tAND pd190.base_product_key > 30\n\tAND md.order_method_key = sf2.order_method_key8319\n\tAND md.order_method_code > 5\n\tAND ed.employee_key = sf2.employee_key\n\tAND ed.manager_code1 > 20),\ninventory3118 AS\n(SELECT if.*\n\tFROM gosalesdw1592.go_branch_dim AS bd3221,\n\tgosalesdw.dist_inventory_fact AS if\n\tWHERE if.branch_key = bd3221.branch_key\n\tAND bd3221.branch_code > 20)\nSELECT sales1828.product_key AS PROD_KEY,\nSUM(CAST (inventory3118.quantity_shipped AS BIGINT)) AS INV_SHIPPED3118,\nSUM(CAST (sales1828.quantity AS BIGINT)) AS PROD_QUANTITY,\nRANK() OVER ( ORDER BY SUM(CAST (sales1828.quantity AS BIGINT)) DESC) AS PROD_RANK\nFROM sales1828, inventory3118\nWHERE sales1828.product_key = inventory3118.product_key\nGROUP BY sales1828.product_key", "WITH sales SELECT sf2.* FROM gosalesdw28391.sls_order_method_dim, gosalesdw1920.sls_product_dim391, gosalesdw3819.emp_employee_dim, gosalesdw3919.sls_sales_fact3819 WHERE pd190.product_key = sf2.product_key AND pd190.product_number381 > ? AND pd190.base_product_key > ? AND md.order_method_key = sf2.order_method_key8319 AND md.order_method_code > ? AND ed.employee_key = sf2.employee_key AND ed.manager_code1 > ? ) inventory3118 SELECT if.* FROM gosalesdw1592.go_branch_dim, gosalesdw.dist_inventory_fact WHERE if.branch_key = bd3221.branch_key AND bd3221.branch_code > ? ) SELECT sales1828.product_key, SUM ( CAST ( inventory3118.quantity_shipped ) ), SUM ( CAST ( sales1828.quantity ) ), RANK ( ) OVER ( ORDER BY SUM ( CAST ( sales1828.quantity ) ) DESC ) FROM sales1828, inventory3118 WHERE sales1828.product_key = inventory3118.product_key GROUP BY sales1828.product_key"),
// sql_quantizer_0
("SELECT \"table\".\"field\" FROM \"table\" WHERE \"table\".\"otherfield\" = $? AND \"table\".\"thirdfield\" = $?;", "SELECT table . field FROM table WHERE table . otherfield = ? AND table . thirdfield = ?"),
// sql_quantizer_1
("select * from users where id = 42", "select * from users where id = ?"),
// sql_quantizer_2
("select * from users where float = .43422", "select * from users where float = ?"),
// sql_quantizer_3
("SELECT host, status FROM ec2_status WHERE org_id = 42", "SELECT host, status FROM ec2_status WHERE org_id = ?"),
// sql_quantizer_4
("SELECT host, status FROM ec2_status WHERE org_id=42", "SELECT host, status FROM ec2_status WHERE org_id = ?"),
// sql_quantizer_5
("-- get user \n--\n select * \n from users \n where\n id = 214325346", "select * from users where id = ?"),
// sql_quantizer_6
("SELECT * FROM `host` WHERE `id` IN (42, 43) /*comment with parameters,host:localhost,url:controller#home,id:FF005:00CAA*/", "SELECT * FROM host WHERE id IN ( ? )"),
// sql_quantizer_7
("SELECT `host`.`address` FROM `host` WHERE org_id=42", "SELECT host . address FROM host WHERE org_id = ?"),
// sql_quantizer_8
("SELECT \"host\".\"address\" FROM \"host\" WHERE org_id=42", "SELECT host . address FROM host WHERE org_id = ?"),
// sql_quantizer_9
("SELECT * FROM host WHERE id IN (42, 43) /*\n\t\t\tmultiline comment with parameters,\n\t\t\thost:localhost,url:controller#home,id:FF005:00CAA\n\t\t\t*/", "SELECT * FROM host WHERE id IN ( ? )"),
// sql_quantizer_10
("UPDATE user_dash_pref SET json_prefs = %(json_prefs)s, modified = '2015-08-27 22:10:32.492912' WHERE user_id = %(user_id)s AND url = %(url)s", "UPDATE user_dash_pref SET json_prefs = ? modified = ? WHERE user_id = ? AND url = ?"),
// sql_quantizer_11
("SELECT DISTINCT host.id AS host_id FROM host JOIN host_alias ON host_alias.host_id = host.id WHERE host.org_id = %(org_id_1)s AND host.name NOT IN (%(name_1)s) AND host.name IN (%(name_2)s, %(name_3)s, %(name_4)s, %(name_5)s)", "SELECT DISTINCT host.id FROM host JOIN host_alias ON host_alias.host_id = host.id WHERE host.org_id = ? AND host.name NOT IN ( ? ) AND host.name IN ( ? )"),
// sql_quantizer_12
("SELECT org_id, metric_key FROM metrics_metadata WHERE org_id = %(org_id)s AND metric_key = ANY(array[75])", "SELECT org_id, metric_key FROM metrics_metadata WHERE org_id = ? AND metric_key = ANY ( array [ ? ] )"),
// sql_quantizer_13
("SELECT org_id, metric_key FROM metrics_metadata WHERE org_id = %(org_id)s AND metric_key = ANY(array[21, 25, 32])", "SELECT org_id, metric_key FROM metrics_metadata WHERE org_id = ? AND metric_key = ANY ( array [ ? ] )"),
// sql_quantizer_14
("SELECT articles.* FROM articles WHERE articles.id = 1 LIMIT 1", "SELECT articles.* FROM articles WHERE articles.id = ? LIMIT ?"),
// sql_quantizer_lowercase_limit
("SELECT articles.* FROM articles WHERE articles.id = 1 limit 1", "SELECT articles.* FROM articles WHERE articles.id = ? limit ?"),
// sql_quantizer_15
("SELECT articles.* FROM articles WHERE articles.id = 1 LIMIT 1, 20", "SELECT articles.* FROM articles WHERE articles.id = ? LIMIT ?"),
// sql_quantizer_16
("SELECT articles.* FROM articles WHERE articles.id = 1 LIMIT 1, 20;", "SELECT articles.* FROM articles WHERE articles.id = ? LIMIT ?"),
// sql_quantizer_limit_two_arguments_lowercase
("SELECT articles.* FROM articles WHERE articles.id = 1 LIMIT 1, 20;", "SELECT articles.* FROM articles WHERE articles.id = ? LIMIT ?"),
// sql_quantizer_17
("SELECT articles.* FROM articles WHERE articles.id = 1 LIMIT 15,20;", "SELECT articles.* FROM articles WHERE articles.id = ? LIMIT ?"),
// sql_quantizer_18
("SELECT articles.* FROM articles WHERE articles.id = 1 LIMIT 1;", "SELECT articles.* FROM articles WHERE articles.id = ? LIMIT ?"),
// sql_quantizer_19
("SELECT articles.* FROM articles WHERE (articles.created_at BETWEEN '2016-10-31 23:00:00.000000' AND '2016-11-01 23:00:00.000000')", "SELECT articles.* FROM articles WHERE ( articles.created_at BETWEEN ? AND ? )"),
// sql_quantizer_20
("SELECT articles.* FROM articles WHERE (articles.created_at BETWEEN $1 AND $2)", "SELECT articles.* FROM articles WHERE ( articles.created_at BETWEEN ? AND ? )"),
// sql_quantizer_21
("SELECT articles.* FROM articles WHERE (articles.published != true)", "SELECT articles.* FROM articles WHERE ( articles.published != ? )"),
// sql_quantizer_22
("SELECT articles.* FROM articles WHERE (title = 'guides.rubyonrails.org')", "SELECT articles.* FROM articles WHERE ( title = ? )"),
// sql_quantizer_23
("SELECT articles.* FROM articles WHERE ( title = ? ) AND ( author = ? )", "SELECT articles.* FROM articles WHERE ( title = ? ) AND ( author = ? )"),
// sql_quantizer_24
("SELECT articles.* FROM articles WHERE ( title = :title )", "SELECT articles.* FROM articles WHERE ( title = :title )"),
// sql_quantizer_25
("SELECT articles.* FROM articles WHERE ( title = @title )", "SELECT articles.* FROM articles WHERE ( title = @title )"),
// sql_quantizer_26
("SELECT date(created_at) as ordered_date, sum(price) as total_price FROM orders GROUP BY date(created_at) HAVING sum(price) > 100", "SELECT date ( created_at ), sum ( price ) FROM orders GROUP BY date ( created_at ) HAVING sum ( price ) > ?"),
// sql_quantizer_27
("SELECT * FROM articles WHERE id > 10 ORDER BY id asc LIMIT 20", "SELECT * FROM articles WHERE id > ? ORDER BY id asc LIMIT ?"),
// sql_quantizer_28
("SELECT clients.* FROM clients INNER JOIN posts ON posts.author_id = author.id AND posts.published = 't'", "SELECT clients.* FROM clients INNER JOIN posts ON posts.author_id = author.id AND posts.published = ?"),
// sql_quantizer_29
("SELECT articles.* FROM articles WHERE articles.id IN (1, 3, 5)", "SELECT articles.* FROM articles WHERE articles.id IN ( ? )"),
// sql_quantizer_30
("SELECT * FROM clients WHERE (clients.first_name = 'Andy') LIMIT 1 BEGIN INSERT INTO clients (created_at, first_name, locked, orders_count, updated_at) VALUES ('2011-08-30 05:22:57', 'Andy', 1, NULL, '2011-08-30 05:22:57') COMMIT", "SELECT * FROM clients WHERE ( clients.first_name = ? ) LIMIT ? BEGIN INSERT INTO clients ( created_at, first_name, locked, orders_count, updated_at ) VALUES ( ? ) COMMIT"),
// sql_quantizer_31
("SELECT * FROM clients WHERE (clients.first_name = 'Andy') LIMIT 15, 25 BEGIN INSERT INTO clients (created_at, first_name, locked, orders_count, updated_at) VALUES ('2011-08-30 05:22:57', 'Andy', 1, NULL, '2011-08-30 05:22:57') COMMIT", "SELECT * FROM clients WHERE ( clients.first_name = ? ) LIMIT ? BEGIN INSERT INTO clients ( created_at, first_name, locked, orders_count, updated_at ) VALUES ( ? ) COMMIT"),
// sql_quantizer_32
("SAVEPOINT \"s139956586256192_x1\"", "SAVEPOINT ?"),
// sql_quantizer_33
("INSERT INTO user (id, username) VALUES ('Fred','Smith'), ('John','Smith'), ('Michael','Smith'), ('Robert','Smith');", "INSERT INTO user ( id, username ) VALUES ( ? )"),
// sql_quantizer_34
("CREATE KEYSPACE Excelsior WITH replication = {'class': 'SimpleStrategy', 'replication_factor' : 3};", "CREATE KEYSPACE Excelsior WITH replication = ?"),
// sql_quantizer_35
("SELECT \"webcore_page\".\"id\" FROM \"webcore_page\" WHERE \"webcore_page\".\"slug\" = %s ORDER BY \"webcore_page\".\"path\" ASC LIMIT 1", "SELECT webcore_page . id FROM webcore_page WHERE webcore_page . slug = ? ORDER BY webcore_page . path ASC LIMIT ?"),
// sql_quantizer_36
("SELECT server_table.host AS host_id FROM table#.host_tags as server_table WHERE server_table.host_id = 50", "SELECT server_table.host FROM table#.host_tags WHERE server_table.host_id = ?"),
// sql_quantizer_37
("INSERT INTO delayed_jobs (attempts, created_at, failed_at, handler, last_error, locked_at, locked_by, priority, queue, run_at, updated_at) VALUES (0, '2016-12-04 17:09:59', NULL, '--- !ruby/object:Delayed::PerformableMethod\nobject: !ruby/object:Item\n store:\n - a simple string\n - an \\'escaped \\' string\n - another \\'escaped\\' string\n - 42\n string: a string with many \\\\\\\\\\'escapes\\\\\\\\\\'\nmethod_name: :show_store\nargs: []\n', NULL, NULL, NULL, 0, NULL, '2016-12-04 17:09:59', '2016-12-04 17:09:59')", "INSERT INTO delayed_jobs ( attempts, created_at, failed_at, handler, last_error, locked_at, locked_by, priority, queue, run_at, updated_at ) VALUES ( ? )"),
// sql_quantizer_38
("SELECT name, pretty_print(address) FROM people;", "SELECT name, pretty_print ( address ) FROM people"),
// sql_quantizer_39
("* SELECT * FROM fake_data(1, 2, 3);", "* SELECT * FROM fake_data ( ? )"),
// sql_quantizer_40
("CREATE FUNCTION add(integer, integer) RETURNS integer\n AS 'select $1 + $2;'\n LANGUAGE SQL\n IMMUTABLE\n RETURNS NULL ON NULL INPUT;", "CREATE FUNCTION add ( integer, integer ) RETURNS integer LANGUAGE SQL IMMUTABLE RETURNS ? ON ? INPUT"),
// sql_quantizer_41
("SELECT * FROM public.table ( array [ ROW ( array [ 'magic', 'foo',", "SELECT * FROM public.table ( array [ ROW ( array [ ?"),
// sql_quantizer_42
("SELECT pg_try_advisory_lock (123) AS t46eef3f025cc27feb31ca5a2d668a09a", "SELECT pg_try_advisory_lock ( ? )"),
// sql_quantizer_43
("INSERT INTO `qual-aa`.issues (alert0 , alert1) VALUES (NULL, NULL)", "INSERT INTO qual-aa . issues ( alert0, alert1 ) VALUES ( ? )"),
// sql_quantizer_44
("INSERT INTO user (id, email, name) VALUES (null, ?, ?)", "INSERT INTO user ( id, email, name ) VALUES ( ? )"),
// sql_quantizer_45
("select * from users where id = 214325346 # This comment continues to the end of line", "select * from users where id = ?"),
// sql_quantizer_46
("select * from users where id = 214325346 -- This comment continues to the end of line", "select * from users where id = ?"),
// sql_quantizer_47
("SELECT * FROM /* this is an in-line comment */ users;", "SELECT * FROM users"),
// sql_quantizer_48
("SELECT /*! STRAIGHT_JOIN */ col1 FROM table1", "SELECT col1 FROM table1"),
// sql_quantizer_49
("DELETE FROM t1\n\t\t\tWHERE s11 > ANY\n\t\t\t(SELECT COUNT(*) /* no hint */ FROM t2\n\t\t\tWHERE NOT EXISTS\n\t\t\t(SELECT * FROM t3\n\t\t\tWHERE ROW(5*t2.s1,77)=\n\t\t\t(SELECT 50,11*s1 FROM t4 UNION SELECT 50,77 FROM\n\t\t\t(SELECT * FROM t5) AS t5)));", "DELETE FROM t1 WHERE s11 > ANY ( SELECT COUNT ( * ) FROM t2 WHERE NOT EXISTS ( SELECT * FROM t3 WHERE ROW ( ? * t2.s1, ? ) = ( SELECT ? * s1 FROM t4 UNION SELECT ? FROM ( SELECT * FROM t5 ) ) ) )"),
// sql_quantizer_50
("SET @g = 'POLYGON((0 0,10 0,10 10,0 10,0 0),(5 5,7 5,7 7,5 7, 5 5))';", "SET @g = ?"),
// sql_quantizer_51
("SELECT daily_values.*,\n LEAST((5040000 - @runtot), value) AS value,\n (@runtot := @runtot + daily_values.value) AS total FROM (SELECT @runtot:=0) AS n, `daily_values` WHERE `daily_values`.`subject_id` = 12345 AND `daily_values`.`subject_type` = 'Skippity' AND (daily_values.date BETWEEN '2018-05-09' AND '2018-06-19') HAVING value >= 0 ORDER BY date", "SELECT daily_values.*, LEAST ( ( ? - @runtot ), value ), ( @runtot := @runtot + daily_values.value ) FROM ( SELECT @runtot := ? ), daily_values WHERE daily_values . subject_id = ? AND daily_values . subject_type = ? AND ( daily_values.date BETWEEN ? AND ? ) HAVING value >= ? ORDER BY date"),
// sql_quantizer_52
(" SELECT\n t1.userid,\n t1.fullname,\n t1.firm_id,\n t2.firmname,\n t1.email,\n t1.location,\n t1.state,\n t1.phone,\n t1.url,\n DATE_FORMAT( t1.lastmod, \"%m/%d/%Y %h:%i:%s\" ) AS lastmod,\n t1.lastmod AS lastmod_raw,\n t1.user_status,\n t1.pw_expire,\n DATE_FORMAT( t1.pw_expire, \"%m/%d/%Y\" ) AS pw_expire_date,\n t1.addr1,\n t1.addr2,\n t1.zipcode,\n t1.office_id,\n t1.default_group,\n t3.firm_status,\n t1.title\n FROM\n userdata AS t1\n LEFT JOIN lawfirm_names AS t2 ON t1.firm_id = t2.firm_id\n LEFT JOIN lawfirms AS t3 ON t1.firm_id = t3.firm_id\n WHERE\n t1.userid = 'jstein'\n\n ", "SELECT t1.userid, t1.fullname, t1.firm_id, t2.firmname, t1.email, t1.location, t1.state, t1.phone, t1.url, DATE_FORMAT ( t1.lastmod, %m/%d/%Y %h:%i:%s ), t1.lastmod, t1.user_status, t1.pw_expire, DATE_FORMAT ( t1.pw_expire, %m/%d/%Y ), t1.addr1, t1.addr2, t1.zipcode, t1.office_id, t1.default_group, t3.firm_status, t1.title FROM userdata LEFT JOIN lawfirm_names ON t1.firm_id = t2.firm_id LEFT JOIN lawfirms ON t1.firm_id = t3.firm_id WHERE t1.userid = ?"),
// sql_quantizer_53
("SELECT [b].[BlogId], [b].[Name]\nFROM [Blogs] AS [b]\nORDER BY [b].[Name]", "SELECT [ b ] . [ BlogId ], [ b ] . [ Name ] FROM [ Blogs ] ORDER BY [ b ] . [ Name ]"),
// sql_quantizer_54
("SELECT * FROM users WHERE firstname=''", "SELECT * FROM users WHERE firstname = ?"),
// sql_quantizer_55
("SELECT * FROM users WHERE firstname=' '", "SELECT * FROM users WHERE firstname = ?"),
// sql_quantizer_56
("SELECT * FROM users WHERE firstname=\"\"", "SELECT * FROM users WHERE firstname = ?"),
// sql_quantizer_57
("SELECT * FROM users WHERE lastname=\" \"", "SELECT * FROM users WHERE lastname = ?"),
// sql_quantizer_58
("SELECT * FROM users WHERE lastname=\"\t \"", "SELECT * FROM users WHERE lastname = ?"),
// sql_quantizer_59
("SELECT customer_item_list_id, customer_id FROM customer_item_list WHERE type = wishlist AND customer_id = ? AND visitor_id IS ? UNION SELECT customer_item_list_id, customer_id FROM customer_item_list WHERE type = wishlist AND customer_id IS ? AND visitor_id = \"AA0DKTGEM6LRN3WWPZ01Q61E3J7ROX7O\" ORDER BY customer_id DESC", "SELECT customer_item_list_id, customer_id FROM customer_item_list WHERE type = wishlist AND customer_id = ? AND visitor_id IS ? UNION SELECT customer_item_list_id, customer_id FROM customer_item_list WHERE type = wishlist AND customer_id IS ? AND visitor_id = ? ORDER BY customer_id DESC"),
// sql_quantizer_60
("update Orders set created = \"2019-05-24 00:26:17\", gross = 30.28, payment_type = \"eventbrite\", mg_fee = \"3.28\", fee_collected = \"3.28\", event = 59366262, status = \"10\", survey_type = 'direct', tx_time_limit = 480, invite = \"\", ip_address = \"69.215.148.82\", currency = 'USD', gross_USD = \"30.28\", tax_USD = 0.00, journal_activity_id = 4044659812798558774, eb_tax = 0.00, eb_tax_USD = 0.00, cart_uuid = \"160b450e7df511e9810e0a0c06de92f8\", changed = '2019-05-24 00:26:17' where id = ?", "update Orders set created = ? gross = ? payment_type = ? mg_fee = ? fee_collected = ? event = ? status = ? survey_type = ? tx_time_limit = ? invite = ? ip_address = ? currency = ? gross_USD = ? tax_USD = ? journal_activity_id = ? eb_tax = ? eb_tax_USD = ? cart_uuid = ? changed = ? where id = ?"),
// sql_quantizer_61
("update Attendees set email = '626837270@qq.com', first_name = \"贺新春送猪福加企鹅１０５４９４８０００领９８綵斟\", last_name = '王子１９８４４２ｃｏｍ体验猪多优惠', journal_activity_id = 4246684839261125564, changed = \"2019-05-24 00:26:22\" where id = 123", "update Attendees set email = ? first_name = ? last_name = ? journal_activity_id = ? changed = ? where id = ?"),
// sql_quantizer_62
("SELECT\r\n\t CodiFormacio\r\n\t ,DataInici\r\n\t ,DataFi\r\n\t ,Tipo\r\n\t ,CodiTecnicFormador\r\n\t ,p.nombre AS TutorNombre\r\n\t ,p.mail AS TutorMail\r\n\t ,Sessions.Direccio\r\n\t ,Sessions.NomEmpresa\r\n\t ,Sessions.Telefon\r\n FROM\r\n ----------------------------\r\n (SELECT\r\n\t CodiFormacio\r\n\t ,case\r\n\t when ModalitatSessio = '1' then 'Presencial'--Teoria\r\n\t when ModalitatSessio = '2' then 'Presencial'--Practica\r\n\t when ModalitatSessio = '3' then 'Online'--Tutoria\r\n when ModalitatSessio = '4' then 'Presencial'--Examen\r\n\t ELSE 'Presencial'\r\n\t end as Tipo\r\n\t ,ModalitatSessio\r\n\t ,DataInici\r\n\t ,DataFi\r\n ,NomEmpresa\r\n\t ,Telefon\r\n\t ,CodiTecnicFormador\r\n\t ,CASE\r\n\t WHEn EsAltres = 1 then FormacioLlocImparticioDescripcio\r\n\t else Adreca + ' - ' + CodiPostal + ' ' + Poblacio\r\n\t end as Direccio\r\n\t\r\n FROM Consultas.dbo.View_AsActiva__FormacioSessions_InfoLlocImparticio) AS Sessions\r\n ----------------------------------------\r\n LEFT JOIN Consultas.dbo.View_AsActiva_Operari AS o\r\n\t ON o.CodiOperari = Sessions.CodiTecnicFormador\r\n LEFT JOIN MainAPP.dbo.persona AS p\r\n\t ON 'preven\\' + o.codioperari = p.codi\r\n WHERE Sessions.CodiFormacio = 'F00000017898'", "SELECT CodiFormacio, DataInici, DataFi, Tipo, CodiTecnicFormador, p.nombre, p.mail, Sessions.Direccio, Sessions.NomEmpresa, Sessions.Telefon FROM ( SELECT CodiFormacio, case when ModalitatSessio = ? then ? when ModalitatSessio = ? then ? when ModalitatSessio = ? then ? when ModalitatSessio = ? then ? ELSE ? end, ModalitatSessio, DataInici, DataFi, NomEmpresa, Telefon, CodiTecnicFormador, CASE WHEn EsAltres = ? then FormacioLlocImparticioDescripcio else Adreca + ? + CodiPostal + ? + Poblacio end FROM Consultas.dbo.View_AsActiva__FormacioSessions_InfoLlocImparticio ) LEFT JOIN Consultas.dbo.View_AsActiva_Operari ON o.CodiOperari = Sessions.CodiTecnicFormador LEFT JOIN MainAPP.dbo.persona ON ? + o.codioperari = p.codi WHERE Sessions.CodiFormacio = ?"),
// sql_quantizer_63
("SELECT * FROM foo LEFT JOIN bar ON 'backslash\\' = foo.b WHERE foo.name = 'String'", "SELECT * FROM foo LEFT JOIN bar ON ? = foo.b WHERE foo.name = ?"),
// sql_quantizer_64
("SELECT * FROM foo LEFT JOIN bar ON 'backslash\\' = foo.b LEFT JOIN bar2 ON 'backslash2\\' = foo.b2 WHERE foo.name = 'String'", "SELECT * FROM foo LEFT JOIN bar ON ? = foo.b LEFT JOIN bar2 ON ? = foo.b2 WHERE foo.name = ?"),
// sql_quantizer_65
("SELECT * FROM foo LEFT JOIN bar ON 'embedded ''quote'' in string' = foo.b WHERE foo.name = 'String'", "SELECT * FROM foo LEFT JOIN bar ON ? = foo.b WHERE foo.name = ?"),
// sql_quantizer_66
("SELECT * FROM foo LEFT JOIN bar ON 'embedded \\'quote\\' in string' = foo.b WHERE foo.name = 'String'", "SELECT * FROM foo LEFT JOIN bar ON ? = foo.b WHERE foo.name = ?"),
// sql_quantizer_67
("SELECT org_id,metric_key,metric_type,interval FROM metrics_metadata WHERE org_id = ? AND metric_key = ANY(ARRAY[?,?,?,?,?])", "SELECT org_id, metric_key, metric_type, interval FROM metrics_metadata WHERE org_id = ? AND metric_key = ANY ( ARRAY [ ? ] )"),
// sql_quantizer_68
("SELECT wp_woocommerce_order_items.order_id As No_Commande\n\t\t\tFROM wp_woocommerce_order_items\n\t\t\tLEFT JOIN\n\t\t\t\t(\n\t\t\t\t\tSELECT meta_value As Prenom\n\t\t\t\t\tFROM wp_postmeta\n\t\t\t\t\tWHERE meta_key = '_shipping_first_name'\n\t\t\t\t) AS a\n\t\t\tON wp_woocommerce_order_items.order_id = a.post_id\n\t\t\tWHERE wp_woocommerce_order_items.order_id =2198", "SELECT wp_woocommerce_order_items.order_id FROM wp_woocommerce_order_items LEFT JOIN ( SELECT meta_value FROM wp_postmeta WHERE meta_key = ? ) ON wp_woocommerce_order_items.order_id = a.post_id WHERE wp_woocommerce_order_items.order_id = ?"),
// sql_quantizer_69
("SELECT a :: VARCHAR(255) FROM foo WHERE foo.name = 'String'", "SELECT a :: VARCHAR ( ? ) FROM foo WHERE foo.name = ?"),
// sql_quantizer_70
("SELECT MIN(`scoped_49a39c4cc9ae4fdda07bcf49e99f8224`.`scoped_8720d2c0e0824ec2910ab9479085839c`) AS `MIN_BECR_DATE_CREATED` FROM (SELECT `49a39c4cc9ae4fdda07bcf49e99f8224`.`submittedOn` AS `scoped_8720d2c0e0824ec2910ab9479085839c`, `49a39c4cc9ae4fdda07bcf49e99f8224`.`domain` AS `scoped_847e4dcfa1c54d72aad6dbeb231c46de`, `49a39c4cc9ae4fdda07bcf49e99f8224`.`eventConsumer` AS `scoped_7b2f7b8da15646d1b75aa03901460eb2`, `49a39c4cc9ae4fdda07bcf49e99f8224`.`eventType` AS `scoped_77a1b9308b384a9391b69d24335ba058` FROM (`SorDesignTime`.`businessEventConsumerRegistry_947a74dad4b64be9847d67f466d26f5e` AS `49a39c4cc9ae4fdda07bcf49e99f8224`) WHERE (`49a39c4cc9ae4fdda07bcf49e99f8224`.`systemData.ClientID`) = ('35c1ccc0-a83c-4812-a189-895e9d4dd223')) AS `scoped_49a39c4cc9ae4fdda07bcf49e99f8224` WHERE ((`scoped_49a39c4cc9ae4fdda07bcf49e99f8224`.`scoped_847e4dcfa1c54d72aad6dbeb231c46de`) = ('Benefits') AND ((`scoped_49a39c4cc9ae4fdda07bcf49e99f8224`.`scoped_7b2f7b8da15646d1b75aa03901460eb2`) = ('benefits') AND (`scoped_49a39c4cc9ae4fdda07bcf49e99f8224`.`scoped_77a1b9308b384a9391b69d24335ba058`) = ('DMXSync'))); ", "SELECT MIN ( scoped_49a39c4cc9ae4fdda07bcf49e99f8224 . scoped_8720d2c0e0824ec2910ab9479085839c ) FROM ( SELECT 49a39c4cc9ae4fdda07bcf49e99f8224 . submittedOn, 49a39c4cc9ae4fdda07bcf49e99f8224 . domain, 49a39c4cc9ae4fdda07bcf49e99f8224 . eventConsumer, 49a39c4cc9ae4fdda07bcf49e99f8224 . eventType FROM ( SorDesignTime . businessEventConsumerRegistry_947a74dad4b64be9847d67f466d26f5e ) WHERE ( 49a39c4cc9ae4fdda07bcf49e99f8224 . systemData.ClientID ) = ( ? ) ) WHERE ( ( scoped_49a39c4cc9ae4fdda07bcf49e99f8224 . scoped_847e4dcfa1c54d72aad6dbeb231c46de ) = ( ? ) AND ( ( scoped_49a39c4cc9ae4fdda07bcf49e99f8224 . scoped_7b2f7b8da15646d1b75aa03901460eb2 ) = ( ? ) AND ( scoped_49a39c4cc9ae4fdda07bcf49e99f8224 . scoped_77a1b9308b384a9391b69d24335ba058 ) = ( ? ) ) )"),
// sql_quantizer_71
("{call px_cu_se_security_pg.sps_get_my_accounts_count(?, ?, ?, ?)}", "{ call px_cu_se_security_pg.sps_get_my_accounts_count ( ? ) }"),
// sql_quantizer_72
("{call px_cu_se_security_pg.sps_get_my_accounts_count(1, 2, 'one', 'two')};", "{ call px_cu_se_security_pg.sps_get_my_accounts_count ( ? ) }"),
// sql_quantizer_73
("{call curly_fun('{{', '}}', '}', '}')};", "{ call curly_fun ( ? ) }"),
// sql_quantizer_74
("SELECT id, name FROM emp WHERE name LIKE {fn UCASE('Smith')}", "SELECT id, name FROM emp WHERE name LIKE ?"),
// sql_quantizer_75
("select users.custom #- '{a,b}' from users", "select users.custom"),
// sql_quantizer_76
("select users.custom #> '{a,b}' from users", "select users.custom"),
// sql_quantizer_77
("select users.custom #>> '{a,b}' from users", "select users.custom"),
// sql_quantizer_78
("SELECT a FROM foo WHERE value<@name", "SELECT a FROM foo WHERE value < @name"),
// sql_quantizer_79
("SELECT @@foo", "SELECT @@foo"),
// sql_quantizer_80
("DROP TABLE IF EXISTS django_site;\nDROP TABLE IF EXISTS knowledgebase_article;\n\nCREATE TABLE django_site (\n id integer PRIMARY KEY,\n domain character varying(100) NOT NULL,\n name character varying(50) NOT NULL,\n uuid uuid NOT NULL,\n disabled boolean DEFAULT false NOT NULL\n);\n\nCREATE TABLE knowledgebase_article (\n id integer PRIMARY KEY,\n title character varying(255) NOT NULL,\n site_id integer NOT NULL,\n CONSTRAINT knowledgebase_article_site_id_fkey FOREIGN KEY (site_id) REFERENCES django_site(id)\n);\n\nINSERT INTO django_site(id, domain, name, uuid, disabled) VALUES (1, 'foo.domain', 'Foo', 'cb4776c1-edf3-4041-96a8-e152f5ae0f91', false);\nINSERT INTO knowledgebase_article(id, title, site_id) VALUES(1, 'title', 1);", "DROP TABLE IF EXISTS django_site DROP TABLE IF EXISTS knowledgebase_article CREATE TABLE django_site ( id integer PRIMARY KEY, domain character varying ( ? ) NOT ? name character varying ( ? ) NOT ? uuid uuid NOT ? disabled boolean DEFAULT ? NOT ? ) CREATE TABLE knowledgebase_article ( id integer PRIMARY KEY, title character varying ( ? ) NOT ? site_id integer NOT ? CONSTRAINT knowledgebase_article_site_id_fkey FOREIGN KEY ( site_id ) REFERENCES django_site ( id ) ) INSERT INTO django_site ( id, domain, name, uuid, disabled ) VALUES ( ? ) INSERT INTO knowledgebase_article ( id, title, site_id ) VALUES ( ? )"),
// sql_quantizer_81
("\nSELECT set_config('foo.bar', (SELECT foo.bar FROM sometable WHERE sometable.uuid = %(some_id)s)::text, FALSE);\nSELECT\n othertable.id,\n othertable.title\nFROM othertable\nINNER JOIN sometable ON sometable.id = othertable.site_id\nWHERE\n sometable.uuid = %(some_id)s\nLIMIT 1\n;", "SELECT set_config ( ? ( SELECT foo.bar FROM sometable WHERE sometable.uuid = ? ) :: text, ? ) SELECT othertable.id, othertable.title FROM othertable INNER JOIN sometable ON sometable.id = othertable.site_id WHERE sometable.uuid = ? LIMIT ?"),
// sql_quantizer_82
("CREATE OR REPLACE FUNCTION pg_temp.sequelize_upsert(OUT created boolean, OUT primary_key text) AS $func$ BEGIN INSERT INTO \"school\" (\"id\",\"organization_id\",\"name\",\"created_at\",\"updated_at\") VALUES ('dc4e9444-d7c9-40a9-bcef-68e4cc594e61','ec647f56-f27a-49a1-84af-021ad0a19f21','Test','2021-03-31 16:30:43.915 +00:00','2021-03-31 16:30:43.915 +00:00'); created := true; EXCEPTION WHEN unique_violation THEN UPDATE \"school\" SET \"id\"='dc4e9444-d7c9-40a9-bcef-68e4cc594e61',\"organization_id\"='ec647f56-f27a-49a1-84af-021ad0a19f21',\"name\"='Test',\"updated_at\"='2021-03-31 16:30:43.915 +00:00' WHERE (\"id\" = 'dc4e9444-d7c9-40a9-bcef-68e4cc594e61'); created := false; END; $func$ LANGUAGE plpgsql; SELECT * FROM pg_temp.sequelize_upsert();", "CREATE OR REPLACE FUNCTION pg_temp.sequelize_upsert ( OUT created boolean, OUT primary_key text ) LANGUAGE plpgsql SELECT * FROM pg_temp.sequelize_upsert ( )"),
// sql_quantizer_83
("INSERT INTO table (field1, field2) VALUES (1, $$someone's string123$with other things$$)", "INSERT INTO table ( field1, field2 ) VALUES ( ? )"),
// sql_quantizer_84
("INSERT INTO table (field1) VALUES ($some tag$this text confuses$some other text$some ta not quite$some tag$)", "INSERT INTO table ( field1 ) VALUES ( ? )"),
// sql_quantizer_85
("INSERT INTO table (field1) VALUES ($tag$random \\wqejks \"sadads' text$tag$)", "INSERT INTO table ( field1 ) VALUES ( ? )"),
// sql_quantizer_86
("SELECT nspname FROM pg_class where nspname !~ '.*toIgnore.*'", "SELECT nspname FROM pg_class where nspname !~ ?"),
// sql_quantizer_87
("SELECT nspname FROM pg_class where nspname !~* '.*toIgnoreInsensitive.*'", "SELECT nspname FROM pg_class where nspname !~* ?"),
// sql_quantizer_88
("SELECT nspname FROM pg_class where nspname ~ '.*matching.*'", "SELECT nspname FROM pg_class where nspname ~ ?"),
// sql_quantizer_89
("SELECT nspname FROM pg_class where nspname ~* '.*matchingInsensitive.*'", "SELECT nspname FROM pg_class where nspname ~* ?"),
// sql_quantizer_90
("SELECT * FROM dbo.Items WHERE id = 1 or /*!obfuscation*/ 1 = 1", "SELECT * FROM dbo.Items WHERE id = ? or ? = ?"),
// sql_quantizer_91
("SELECT * FROM Items WHERE id = -1 OR id = -01 OR id = -108 OR id = -.018 OR id = -.08 OR id = -908129", "SELECT * FROM Items WHERE id = ? OR id = ? OR id = ? OR id = ? OR id = ? OR id = ?"),
// sql_quantizer_92
("USING $09 SELECT", "USING ? SELECT"),
// sql_quantizer_93
("USING - SELECT", "USING - SELECT"),
// sql_cassandra_0
("select key, status, modified from org_check_run where org_id = %s and check in (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)", "select key, status, modified from org_check_run where org_id = ? and check in ( ? )"),
// sql_cassandra_1
("select key, status, modified from org_check_run where org_id = %s and check in (%s, %s, %s)", "select key, status, modified from org_check_run where org_id = ? and check in ( ? )"),
// sql_cassandra_2
("select key, status, modified from org_check_run where org_id = %s and check in (%s , %s , %s )", "select key, status, modified from org_check_run where org_id = ? and check in ( ? )"),
// sql_cassandra_3
("select key, status, modified from org_check_run where org_id = %s and check = %s", "select key, status, modified from org_check_run where org_id = ? and check = ?"),
// sql_cassandra_4
("SELECT timestamp, processes FROM process_snapshot.minutely WHERE org_id = ? AND host = ? AND timestamp >= ? AND timestamp <= ?", "SELECT timestamp, processes FROM process_snapshot.minutely WHERE org_id = ? AND host = ? AND timestamp >= ? AND timestamp <= ?"),
// sql_cassandra_5
("SELECT count(*) AS totcount FROM (SELECT \"c1\", \"c2\",\"c3\",\"c4\",\"c5\",\"c6\",\"c7\",\"c8\", \"c9\", \"c10\",\"c11\",\"c12\",\"c13\",\"c14\", \"c15\",\"c16\",\"c17\",\"c18\", \"c19\",\"c20\",\"c21\",\"c22\",\"c23\", \"c24\",\"c25\",\"c26\", \"c27\" FROM (SELECT bar.y AS \"c2\", foo.x AS \"c3\", foo.z AS \"c4\", DECODE(foo.a, NULL,NULL, foo.a ||?|| foo.b) AS \"c5\" , foo.c AS \"c6\", bar.d AS \"c1\", bar.e AS \"c7\", bar.f AS \"c8\", bar.g AS \"c9\", TO_DATE(TO_CHAR(TO_DATE(bar.h,?),?),?) AS \"c10\", TO_DATE(TO_CHAR(TO_DATE(bar.i,?),?),?) AS \"c11\", CASE WHEN DECODE(bar.j, NULL, TRUNC(SYSDATE) - TRUNC(TO_DATE(bar.h,?))) > ? THEN ? WHEN DECODE(bar.j, NULL, TRUNC(SYSDATE) - TRUNC(TO_DATE(bar.h,?))) > ? THEN ? WHEN DECODE(bar.j, NULL, TRUNC(SYSDATE) - TRUNC(TO_DATE(bar.h,?))) > ? THEN ? WHEN DECODE(bar.j, NULL, TRUNC(SYSDATE) - TRUNC(TO_DATE(bar.h,?))) > ? THEN ? WHEN DECODE(bar.j, NULL, TRUNC(SYSDATE) - TRUNC(TO_DATE(bar.h,?))) > ? THEN ? WHEN DECODE(bar.j, NULL, TRUNC(SYSDATE) - TRUNC(TO_DATE(bar.h,?))) > ? THEN ? ELSE NULL END AS \"c12\", DECODE(bar.j, NULL, TRUNC(SYSDATE) - TRUNC(TO_DATE(bar.h,?)),NULL) as \"c13\", bar.k AS \"c14\", bar.l ||?||bar.m AS \"c15\", DECODE(bar.n, NULL, NULL,bar.n ||?||bar.o) AS \"c16\", bar.p AS \"c17\", bar.q AS \"c18\", bar.r AS \"c19\", bar.s AS \"c20\", qux.a AS \"c21\", TO_CHAR(TO_DATE(qux.b,?),?) AS \"c22\", DECODE(qux.l,NULL,NULL, qux.l ||?||qux.m) AS \"c23\", bar.a AS \"c24\", TO_CHAR(TO_DATE(bar.j,?),?) AS \"c25\", DECODE(bar.c , ?,?,?, ?, bar.c ) AS \"c26\", bar.y AS y, bar.d, bar.d AS \"c27\" FROM blort.bar , ( SELECT * FROM (SELECT a,a,l,m,b,c, RANK() OVER (PARTITION BY c ORDER BY b DESC) RNK FROM blort.d WHERE y IN (:p)) WHERE RNK = ?) qux, blort.foo WHERE bar.c = qux.c(+) AND bar.x = foo.x AND bar.y IN (:p) and bar.x IN (:x)) )\nSELECT count(*) AS totcount FROM (SELECT \"c1\", \"c2\",\"c3\",\"c4\",\"c5\",\"c6\",\"c7\",\"c8\", \"c9\", \"c10\",\"c11\",\"c12\",\"c13\",\"c14\", \"c15\",\"c16\",\"c17\",\"c18\", \"c19\",\"c20\",\"c21\",\"c22\",\"c23\", \"c24\",\"c25\",\"c26\", \"c27\" FROM (SELECT bar.y AS \"c2\", foo.x AS \"c3\", foo.z AS \"c4\", DECODE(foo.a, NULL,NULL, foo.a ||?|| foo.b) AS \"c5\" , foo.c AS \"c6\", bar.d AS \"c1\", bar.e AS \"c7\", bar.f AS \"c8\", bar.g AS \"c9\", TO_DATE(TO_CHAR(TO_DATE(bar.h,?),?),?) AS \"c10\", TO_DATE(TO_CHAR(TO_DATE(bar.i,?),?),?) AS \"c11\", CASE WHEN DECODE(bar.j, NULL, TRUNC(SYSDATE) - TRUNC(TO_DATE(bar.h,?))) > ? THEN ? WHEN DECODE(bar.j, NULL, TRUNC(SYSDATE) - TRUNC(TO_DATE(bar.h,?))) > ? THEN ? WHEN DECODE(bar.j, NULL, TRUNC(SYSDATE) - TRUNC(TO_DATE(bar.h,?))) > ? THEN ? WHEN DECODE(bar.j, NULL, TRUNC(SYSDATE) - TRUNC(TO_DATE(bar.h,?))) > ? THEN ? WHEN DECODE(bar.j, NULL, TRUNC(SYSDATE) - TRUNC(TO_DATE(bar.h,?))) > ? THEN ? WHEN DECODE(bar.j, NULL, TRUNC(SYSDATE) - TRUNC(TO_DATE(bar.h,?))) > ? THEN ? ELSE NULL END AS \"c12\", DECODE(bar.j, NULL, TRUNC(SYSDATE) - TRUNC(TO_DATE(bar.h,?)),NULL) as \"c13\", bar.k AS \"c14\", bar.l ||?||bar.m AS \"c15\", DECODE(bar.n, NULL, NULL,bar.n ||?||bar.o) AS \"c16\", bar.p AS \"c17\", bar.q AS \"c18\", bar.r AS \"c19\", bar.s AS \"c20\", qux.a AS \"c21\", TO_CHAR(TO_DATE(qux.b,?),?) AS \"c22\", DECODE(qux.l,NULL,NULL, qux.l ||?||qux.m) AS \"c23\", bar.a AS \"c24\", TO_CHAR(TO_DATE(bar.j,?),?) AS \"c25\", DECODE(bar.c , ?,?,?, ?, bar.c ) AS \"c26\", bar.y AS y, bar.d, bar.d AS \"c27\" FROM blort.bar , ( SELECT * FROM (SELECT a,a,l,m,b,c, RANK() OVER (PARTITION BY c ORDER BY b DESC) RNK FROM blort.d WHERE y IN (:p)) WHERE RNK = ?) qux, blort.foo WHERE bar.c = qux.c(+) AND bar.x = foo.x AND bar.y IN (:p) and bar.x IN (:x)) )", "SELECT count ( * ) FROM ( SELECT c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27 FROM ( SELECT bar.y, foo.x, foo.z, DECODE ( foo.a, ? foo.a | | ? | | foo.b ), foo.c, bar.d, bar.e, bar.f, bar.g, TO_DATE ( TO_CHAR ( TO_DATE ( bar.h, ? ) ) ), TO_DATE ( TO_CHAR ( TO_DATE ( bar.i, ? ) ) ), CASE WHEN DECODE ( bar.j, ? TRUNC ( SYSDATE ) - TRUNC ( TO_DATE ( bar.h, ? ) ) ) > ? THEN ? WHEN DECODE ( bar.j, ? TRUNC ( SYSDATE ) - TRUNC ( TO_DATE ( bar.h, ? ) ) ) > ? THEN ? WHEN DECODE ( bar.j, ? TRUNC ( SYSDATE ) - TRUNC ( TO_DATE ( bar.h, ? ) ) ) > ? THEN ? WHEN DECODE ( bar.j, ? TRUNC ( SYSDATE ) - TRUNC ( TO_DATE ( bar.h, ? ) ) ) > ? THEN ? WHEN DECODE ( bar.j, ? TRUNC ( SYSDATE ) - TRUNC ( TO_DATE ( bar.h, ? ) ) ) > ? THEN ? WHEN DECODE ( bar.j, ? TRUNC ( SYSDATE ) - TRUNC ( TO_DATE ( bar.h, ? ) ) ) > ? THEN ? ELSE ? END, DECODE ( bar.j, ? TRUNC ( SYSDATE ) - TRUNC ( TO_DATE ( bar.h, ? ) ) ), bar.k, bar.l | | ? | | bar.m, DECODE ( bar.n, ? bar.n | | ? | | bar.o ), bar.p, bar.q, bar.r, bar.s, qux.a, TO_CHAR ( TO_DATE ( qux.b, ? ) ), DECODE ( qux.l, ? qux.l | | ? | | qux.m ), bar.a, TO_CHAR ( TO_DATE ( bar.j, ? ) ), DECODE ( bar.c, ? bar.c ), bar.y, bar.d, bar.d FROM blort.bar, ( SELECT * FROM ( SELECT a, a, l, m, b, c, RANK ( ) OVER ( PARTITION BY c ORDER BY b DESC ) RNK FROM blort.d WHERE y IN ( :p ) ) WHERE RNK = ? ) qux, blort.foo WHERE bar.c = qux.c ( + ) AND bar.x = foo.x AND bar.y IN ( :p ) and bar.x IN ( :x ) ) ) SELECT count ( * ) FROM ( SELECT c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27 FROM ( SELECT bar.y, foo.x, foo.z, DECODE ( foo.a, ? foo.a | | ? | | foo.b ), foo.c, bar.d, bar.e, bar.f, bar.g, TO_DATE ( TO_CHAR ( TO_DATE ( bar.h, ? ) ) ), TO_DATE ( TO_CHAR ( TO_DATE ( bar.i, ? ) ) ), CASE WHEN DECODE ( bar.j, ? TRUNC ( SYSDATE ) - TRUNC ( TO_DATE ( bar.h, ? ) ) ) > ? THEN ? WHEN DECODE ( bar.j, ? TRUNC ( SYSDATE ) - TRUNC ( TO_DATE ( bar.h, ? ) ) ) > ? THEN ? WHEN DECODE ( bar.j, ? TRUNC ( SYSDATE ) - TRUNC ( TO_DATE ( bar.h, ? ) ) ) > ? THEN ? WHEN DECODE ( bar.j, ? TRUNC ( SYSDATE ) - TRUNC ( TO_DATE ( bar.h, ? ) ) ) > ? THEN ? WHEN DECODE ( bar.j, ? TRUNC ( SYSDATE ) - TRUNC ( TO_DATE ( bar.h, ? ) ) ) > ? THEN ? WHEN DECODE ( bar.j, ? TRUNC ( SYSDATE ) - TRUNC ( TO_DATE ( bar.h, ? ) ) ) > ? THEN ? ELSE ? END, DECODE ( bar.j, ? TRUNC ( SYSDATE ) - TRUNC ( TO_DATE ( bar.h, ? ) ) ), bar.k, bar.l | | ? | | bar.m, DECODE ( bar.n, ? bar.n | | ? | | bar.o ), bar.p, bar.q, bar.r, bar.s, qux.a, TO_CHAR ( TO_DATE ( qux.b, ? ) ), DECODE ( qux.l, ? qux.l | | ? | | qux.m ), bar.a, TO_CHAR ( TO_DATE ( bar.j, ? ) ), DECODE ( bar.c, ? bar.c ), bar.y, bar.d, bar.d FROM blort.bar, ( SELECT * FROM ( SELECT a, a, l, m, b, c, RANK ( ) OVER ( PARTITION BY c ORDER BY b DESC ) RNK FROM blort.d WHERE y IN ( :p ) ) WHERE RNK = ? ) qux, blort.foo WHERE bar.c = qux.c ( + ) AND bar.x = foo.x AND bar.y IN ( :p ) and bar.x IN ( :x ) ) )"),
// sql_parse_number_1234
("1234", "?"),
// sql_parse_number_-1234
("-1234", "?"),
// sql_parse_number_1234e12
("1234e12", "?"),
// sql_parse_number_0xfa
("0xfa", "?"),
// sql_parse_number_01234567
("01234567", "?"),
// sql_parse_number_09
("09", "?"),
// sql_parse_number_-01234567
("-01234567", "?"),
// sql_parse_number_-012345678
("-012345678", "?"),
];
#[test]
fn test_sql_obfuscation_suite() {
let mut errors = String::new();
for (i, (input, expected)) in SUITE_CASES.iter().enumerate() {
let got = super::obfuscate_sql_string(input);
if got != *expected {
let _ = write!(
errors,
"case {i} ({input:?}):\n expected {expected:?}\n got {got:?}\n"
);
}
}
assert!(errors.is_empty(), "{errors}");
}
// {'keep_sql_alias': True}
#[test]
#[allow(deprecated)]
fn test_suite_keep_sql_alias() {
let config = SqlObfuscateConfig {
keep_sql_alias: true,
..Default::default()
};
let cases: &[(&str, &str)] = &[
// sql_keep_alias_on
(
"SELECT username AS person FROM users WHERE id=4",
"SELECT username AS person FROM users WHERE id = ?",
),
];
let mut errors = String::new();
for (i, (input, expected)) in cases.iter().enumerate() {
let got = super::obfuscate_sql(input, &config, DbmsKind::Generic);
if got != *expected {
let _ = write!(
errors,
"case {i} ({input:?}):\n expected {expected:?}\n got {got:?}\n"
);
}
}
assert!(errors.is_empty(), "{errors}");
}
// {'dollar_quoted_func': True}
#[test]
#[allow(deprecated)]
fn test_suite_dollar_quoted_func() {
let config = SqlObfuscateConfig {
dollar_quoted_func: true,
..Default::default()
};
let cases: &[(&str, &str)] = &[
// sql_dollar_quoted_func_on
(
"SELECT $func$INSERT INTO table VALUES ('a', 1, 2)$func$ FROM users",
"SELECT $func$INSERT INTO table VALUES ( ? )$func$ FROM users",
),
];
let mut errors = String::new();
for (i, (input, expected)) in cases.iter().enumerate() {
let got = super::obfuscate_sql(input, &config, DbmsKind::Generic);
if got != *expected {
let _ = write!(
errors,
"case {i} ({input:?}):\n expected {expected:?}\n got {got:?}\n"
);
}
}
assert!(errors.is_empty(), "{errors}");
}
// {'keep_sql_alias': True, 'dollar_quoted_func': True}
#[test]
#[allow(deprecated)]
fn test_suite_keep_sql_alias_dollar_quoted_func() {
let config = SqlObfuscateConfig {
keep_sql_alias: true,
dollar_quoted_func: true,
..Default::default()
};
let cases: &[(&str, &str)] = &[
// sql_dollar_quoted_func_as
("CREATE OR REPLACE FUNCTION pg_temp.sequelize_upsert(OUT created boolean, OUT primary_key text) AS $func$ BEGIN INSERT INTO \"school\" (\"id\",\"organization_id\",\"name\",\"created_at\",\"updated_at\") VALUES ('dc4e9444-d7c9-40a9-bcef-68e4cc594e61','ec647f56-f27a-49a1-84af-021ad0a19f21','Test','2021-03-31 16:30:43.915 +00:00','2021-03-31 16:30:43.915 +00:00'); created := true; EXCEPTION WHEN unique_violation THEN UPDATE \"school\" SET \"id\"='dc4e9444-d7c9-40a9-bcef-68e4cc594e61',\"organization_id\"='ec647f56-f27a-49a1-84af-021ad0a19f21',\"name\"='Test',\"updated_at\"='2021-03-31 16:30:43.915 +00:00' WHERE (\"id\" = 'dc4e9444-d7c9-40a9-bcef-68e4cc594e61'); created := false; END; $func$ LANGUAGE plpgsql; SELECT * FROM pg_temp.sequelize_upsert();", "CREATE OR REPLACE FUNCTION pg_temp.sequelize_upsert ( OUT created boolean, OUT primary_key text ) AS $func$BEGIN INSERT INTO school ( id, organization_id, name, created_at, updated_at ) VALUES ( ? ) created := ? EXCEPTION WHEN unique_violation THEN UPDATE school SET id = ? organization_id = ? name = ? updated_at = ? WHERE ( id = ? ) created := ? END$func$ LANGUAGE plpgsql SELECT * FROM pg_temp.sequelize_upsert ( )"),
];
let mut errors = String::new();
for (i, (input, expected)) in cases.iter().enumerate() {
let got = super::obfuscate_sql(input, &config, DbmsKind::Generic);
if got != *expected {
let _ = write!(
errors,
"case {i} ({input:?}):\n expected {expected:?}\n got {got:?}\n"
);
}
}
assert!(errors.is_empty(), "{errors}");
}
// {'replace_digits': True}
#[test]
#[allow(deprecated)]
fn test_suite_replace_digits() {
let config = SqlObfuscateConfig {
replace_digits: true,
..Default::default()
};
let cases: &[(&str, &str)] = &[
// sql_metadata_complex_with_replace_digits
("\n/* Multi-line comment\nwith line breaks */\nWITH sales AS\n(SELECT sf2.*\n\tFROM gosalesdw28391.sls_order_method_dim AS md,\n\t\tgosalesdw1920.sls_product_dim391 AS pd190,\n\t\tgosalesdw3819.emp_employee_dim AS ed,\n\t\tgosalesdw3919.sls_sales_fact3819 AS sf2\n\tWHERE pd190.product_key = sf2.product_key\n\tAND pd190.product_number381 > 10000\n\tAND pd190.base_product_key > 30\n\tAND md.order_method_key = sf2.order_method_key8319\n\tAND md.order_method_code > 5\n\tAND ed.employee_key = sf2.employee_key\n\tAND ed.manager_code1 > 20),\ninventory3118 AS\n(SELECT if.*\n\tFROM gosalesdw1592.go_branch_dim AS bd3221,\n\tgosalesdw.dist_inventory_fact AS if\n\tWHERE if.branch_key = bd3221.branch_key\n\tAND bd3221.branch_code > 20)\nSELECT sales1828.product_key AS PROD_KEY,\nSUM(CAST (inventory3118.quantity_shipped AS BIGINT)) AS INV_SHIPPED3118,\nSUM(CAST (sales1828.quantity AS BIGINT)) AS PROD_QUANTITY,\nRANK() OVER ( ORDER BY SUM(CAST (sales1828.quantity AS BIGINT)) DESC) AS PROD_RANK\nFROM sales1828, inventory3118\nWHERE sales1828.product_key = inventory3118.product_key\nGROUP BY sales1828.product_key", "WITH sales SELECT sf?.* FROM gosalesdw?.sls_order_method_dim, gosalesdw?.sls_product_dim?, gosalesdw?.emp_employee_dim, gosalesdw?.sls_sales_fact? WHERE pd?.product_key = sf?.product_key AND pd?.product_number? > ? AND pd?.base_product_key > ? AND md.order_method_key = sf?.order_method_key? AND md.order_method_code > ? AND ed.employee_key = sf?.employee_key AND ed.manager_code? > ? ) inventory? SELECT if.* FROM gosalesdw?.go_branch_dim, gosalesdw.dist_inventory_fact WHERE if.branch_key = bd?.branch_key AND bd?.branch_code > ? ) SELECT sales?.product_key, SUM ( CAST ( inventory?.quantity_shipped ) ), SUM ( CAST ( sales?.quantity ) ), RANK ( ) OVER ( ORDER BY SUM ( CAST ( sales?.quantity ) ) DESC ) FROM sales?, inventory? WHERE sales?.product_key = inventory?.product_key GROUP BY sales?.product_key"),
// sql_replace_digits_on_0
("REPLACE INTO sales_2019_07_01 (`itemID`, `date`, `qty`, `price`) VALUES ((SELECT itemID FROM item1001 WHERE `sku` = [sku]), CURDATE(), [qty], 0.00)", "REPLACE INTO sales_?_?_? ( itemID, date, qty, price ) VALUES ( ( SELECT itemID FROM item? WHERE sku = [ sku ] ), CURDATE ( ), [ qty ], ? )"),
// sql_replace_digits_on_1
("SELECT ddh19.name, ddt.tags FROM dd91219.host ddh19, dd21916.host_tags ddt WHERE ddh19.id = ddt.host_id AND ddh19.org_id = 2 AND ddh19.name = 'datadog'", "SELECT ddh?.name, ddt.tags FROM dd?.host ddh?, dd?.host_tags ddt WHERE ddh?.id = ddt.host_id AND ddh?.org_id = ? AND ddh?.name = ?"),
// sql_replace_digits_on_2
("SELECT ddu2.name, ddo.id10, ddk.app_key52 FROM dd3120.user ddu2, dd1931.orgs55 ddo, dd53819.keys ddk", "SELECT ddu?.name, ddo.id?, ddk.app_key? FROM dd?.user ddu?, dd?.orgs? ddo, dd?.keys ddk"),
// sql_replace_digits_on_3
("SELECT daily_values1529.*, LEAST((5040000 - @runtot), value1830) AS value1830,\n(@runtot := @runtot + daily_values1529.value1830) AS total\nFROM (SELECT @runtot:=0) AS n,\ndaily_values1529 WHERE daily_values1529.subject_id = 12345 AND daily_values1592.subject_type = 'Skippity'\nAND (daily_values1529.date BETWEEN '2018-05-09' AND '2018-06-19') HAVING value >= 0 ORDER BY date", "SELECT daily_values?.*, LEAST ( ( ? - @runtot ), value? ), ( @runtot := @runtot + daily_values?.value? ) FROM ( SELECT @runtot := ? ), daily_values? WHERE daily_values?.subject_id = ? AND daily_values?.subject_type = ? AND ( daily_values?.date BETWEEN ? AND ? ) HAVING value >= ? ORDER BY date"),
// sql_replace_digits_on_4
("WITH\nsales AS\n(SELECT sf2.*\n\tFROM gosalesdw28391.sls_order_method_dim AS md,\n\t\tgosalesdw1920.sls_product_dim391 AS pd190,\n\t\tgosalesdw3819.emp_employee_dim AS ed,\n\t\tgosalesdw3919.sls_sales_fact3819 AS sf2\n\tWHERE pd190.product_key = sf2.product_key\n\tAND pd190.product_number381 > 10000\n\tAND pd190.base_product_key > 30\n\tAND md.order_method_key = sf2.order_method_key8319\n\tAND md.order_method_code > 5\n\tAND ed.employee_key = sf2.employee_key\n\tAND ed.manager_code1 > 20),\ninventory3118 AS\n(SELECT if.*\n\tFROM gosalesdw1592.go_branch_dim AS bd3221,\n\tgosalesdw.dist_inventory_fact AS if\n\tWHERE if.branch_key = bd3221.branch_key\n\tAND bd3221.branch_code > 20)\nSELECT sales1828.product_key AS PROD_KEY,\nSUM(CAST (inventory3118.quantity_shipped AS BIGINT)) AS INV_SHIPPED3118,\nSUM(CAST (sales1828.quantity AS BIGINT)) AS PROD_QUANTITY,\nRANK() OVER ( ORDER BY SUM(CAST (sales1828.quantity AS BIGINT)) DESC) AS PROD_RANK\nFROM sales1828, inventory3118\nWHERE sales1828.product_key = inventory3118.product_key\nGROUP BY sales1828.product_key", "WITH sales SELECT sf?.* FROM gosalesdw?.sls_order_method_dim, gosalesdw?.sls_product_dim?, gosalesdw?.emp_employee_dim, gosalesdw?.sls_sales_fact? WHERE pd?.product_key = sf?.product_key AND pd?.product_number? > ? AND pd?.base_product_key > ? AND md.order_method_key = sf?.order_method_key? AND md.order_method_code > ? AND ed.employee_key = sf?.employee_key AND ed.manager_code? > ? ) inventory? SELECT if.* FROM gosalesdw?.go_branch_dim, gosalesdw.dist_inventory_fact WHERE if.branch_key = bd?.branch_key AND bd?.branch_code > ? ) SELECT sales?.product_key, SUM ( CAST ( inventory?.quantity_shipped ) ), SUM ( CAST ( sales?.quantity ) ), RANK ( ) OVER ( ORDER BY SUM ( CAST ( sales?.quantity ) ) DESC ) FROM sales?, inventory? WHERE sales?.product_key = inventory?.product_key GROUP BY sales?.product_key"),
// sql_table_finder_replace_digits_0
("select * from users where id = 42", "select * from users where id = ?"),
// sql_table_finder_replace_digits_1
("select * from `backslashes` where id = 42", "select * from backslashes where id = ?"),
// sql_table_finder_replace_digits_2
("select * from \"double-quotes\" where id = 42", "select * from double-quotes where id = ?"),
// sql_table_finder_replace_digits_3
("SELECT host, status FROM ec2_status WHERE org_id = 42", "SELECT host, status FROM ec?_status WHERE org_id = ?"),
// sql_table_finder_replace_digits_4
("SELECT * FROM (SELECT * FROM nested_table)", "SELECT * FROM ( SELECT * FROM nested_table )"),
// sql_table_finder_replace_digits_5
(" -- get user \n--\n select * \n from users \n where\n id = 214325346 ", "select * from users where id = ?"),
// sql_table_finder_replace_digits_6
("SELECT articles.* FROM articles WHERE articles.id = 1 LIMIT 1, 20", "SELECT articles.* FROM articles WHERE articles.id = ? LIMIT ?"),
// sql_table_finder_replace_digits_7
("UPDATE user_dash_pref SET json_prefs = %(json_prefs)s, modified = '2015-08-27 22:10:32.492912' WHERE user_id = %(user_id)s AND url = %(url)s", "UPDATE user_dash_pref SET json_prefs = ? modified = ? WHERE user_id = ? AND url = ?"),
// sql_table_finder_replace_digits_8
("SELECT DISTINCT host.id AS host_id FROM host JOIN host_alias ON host_alias.host_id = host.id WHERE host.org_id = %(org_id_1)s AND host.name NOT IN (%(name_1)s) AND host.name IN (%(name_2)s, %(name_3)s, %(name_4)s, %(name_5)s)", "SELECT DISTINCT host.id FROM host JOIN host_alias ON host_alias.host_id = host.id WHERE host.org_id = ? AND host.name NOT IN ( ? ) AND host.name IN ( ? )"),
// sql_table_finder_replace_digits_9
("update Orders set created = \"2019-05-24 00:26:17\", gross = 30.28, payment_type = \"eventbrite\", mg_fee = \"3.28\", fee_collected = \"3.28\", event = 59366262, status = \"10\", survey_type = 'direct', tx_time_limit = 480, invite = \"\", ip_address = \"69.215.148.82\", currency = 'USD', gross_USD = \"30.28\", tax_USD = 0.00, journal_activity_id = 4044659812798558774, eb_tax = 0.00, eb_tax_USD = 0.00, cart_uuid = \"160b450e7df511e9810e0a0c06de92f8\", changed = '2019-05-24 00:26:17' where id = ?", "update Orders set created = ? gross = ? payment_type = ? mg_fee = ? fee_collected = ? event = ? status = ? survey_type = ? tx_time_limit = ? invite = ? ip_address = ? currency = ? gross_USD = ? tax_USD = ? journal_activity_id = ? eb_tax = ? eb_tax_USD = ? cart_uuid = ? changed = ? where id = ?"),
// sql_table_finder_replace_digits_10
("SELECT * FROM clients WHERE (clients.first_name = 'Andy') LIMIT 1 BEGIN INSERT INTO clients (created_at, first_name, locked, orders_count, updated_at) VALUES ('2011-08-30 05:22:57', 'Andy', 1, NULL, '2011-08-30 05:22:57') COMMIT", "SELECT * FROM clients WHERE ( clients.first_name = ? ) LIMIT ? BEGIN INSERT INTO clients ( created_at, first_name, locked, orders_count, updated_at ) VALUES ( ? ) COMMIT"),
// sql_table_finder_replace_digits_11
("DELETE FROM table WHERE table.a=1", "DELETE FROM table WHERE table.a = ?"),
// sql_table_finder_replace_digits_12
("SELECT wp_woocommerce_order_items.order_id FROM wp_woocommerce_order_items LEFT JOIN ( SELECT meta_value FROM wp_postmeta WHERE meta_key = ? ) ON wp_woocommerce_order_items.order_id = a.post_id WHERE wp_woocommerce_order_items.order_id = ?", "SELECT wp_woocommerce_order_items.order_id FROM wp_woocommerce_order_items LEFT JOIN ( SELECT meta_value FROM wp_postmeta WHERE meta_key = ? ) ON wp_woocommerce_order_items.order_id = a.post_id WHERE wp_woocommerce_order_items.order_id = ?"),
// sql_table_finder_replace_digits_13
("REPLACE INTO sales_2019_07_01 (`itemID`, `date`, `qty`, `price`) VALUES ((SELECT itemID FROM item1001 WHERE `sku` = [sku]), CURDATE(), [qty], 0.00)", "REPLACE INTO sales_?_?_? ( itemID, date, qty, price ) VALUES ( ( SELECT itemID FROM item? WHERE sku = [ sku ] ), CURDATE ( ), [ qty ], ? )"),
// sql_table_finder_replace_digits_14
("SELECT name FROM people WHERE person_id = -1", "SELECT name FROM people WHERE person_id = ?"),
// sql_table_finder_replace_digits_15
("select * from test where !is_good;", "select * from test where ! is_good"),
// sql_table_finder_replace_digits_16
("select * from test where ! is_good;", "select * from test where ! is_good"),
// sql_table_finder_replace_digits_17
("select * from test where !45;", "select * from test where ! ?"),
// sql_table_finder_replace_digits_18
("select * from test where !(select is_good from good_things);", "select * from test where ! ( select is_good from good_things )"),
// sql_table_finder_replace_digits_19
("select * from test where !'weird_query'", "select * from test where ! ?"),
// sql_table_finder_replace_digits_20
("select * from test where !\"weird_query\"", "select * from test where ! weird_query"),
// sql_table_finder_replace_digits_21
("select * from test where !`weird_query`", "select * from test where ! weird_query"),
// sql_table_finder_replace_digits_22
("select !- 2", "select ! - ?"),
// sql_table_finder_replace_digits_23
("select !+2", "select ! + ?"),
// sql_table_finder_replace_digits_24
("select * from test where !- 2", "select * from test where ! - ?"),
// sql_table_finder_replace_digits_25
("select count(*) as `count(*)` from test", "select count ( * ) from test"),
// sql_table_finder_replace_digits_26
("SELECT age as `age}` FROM profile", "SELECT age FROM profile"),
// sql_table_finder_replace_digits_27
("SELECT age as `age``}` FROM profile", "SELECT age FROM profile"),
// sql_table_finder_replace_digits_28
("SELECT * from users where user_id =:0_USER", "SELECT * from users where user_id = :0_USER"),
];
let mut errors = String::new();
for (i, (input, expected)) in cases.iter().enumerate() {
let got = super::obfuscate_sql(input, &config, DbmsKind::Generic);
if got != *expected {
let _ = write!(
errors,
"case {i} ({input:?}):\n expected {expected:?}\n got {got:?}\n"
);
}
}
assert!(errors.is_empty(), "{errors}");
}
// {'keep_sql_alias': True, 'dollar_quoted_func': True, 'keep_null': True, 'keep_boolean': True,
// 'keep_positional_parameter': True, 'keep_trailing_semicolon': True,
// 'keep_identifier_quotation': True, 'replace_bind_parameter': True,
// 'remove_space_between_parentheses': True, 'keep_json_path': True, 'replace_digits': True}
#[test]
#[allow(deprecated)]
fn test_suite_all_flags() {
let config = SqlObfuscateConfig {
keep_sql_alias: true,
dollar_quoted_func: true,
keep_null: true,
keep_boolean: true,
keep_positional_parameter: true,
keep_trailing_semicolon: true,
keep_identifier_quotation: true,
replace_bind_parameter: true,
remove_space_between_parentheses: true,
keep_json_path: true,
replace_digits: true,
..Default::default()
};
let cases: &[(&str, &str)] = &[
// sql_fuzzing_1230223853
("$2", "?"),
// sql_fuzzing_3056568399
("(2", "( ?"),
// sql_fuzzing_2600047278
(";ჸ", "ჸ"),
// sql_fuzzing_1323053175
(";ჸ", "ჸ"),
// sql_fuzzing_726138257
("@2", "@?"),
// sql_fuzzing_3590332207
("@C", "@C"),
// sql_fuzzing_572710742
("\"\"\"\"", "\""),
// sql_fuzzing_3189077130
("@ჸ2", "@ჸ?"),
// sql_fuzzing_832034588
("\"0\"", "0"),
];
let mut errors = String::new();
for (i, (input, expected)) in cases.iter().enumerate() {
let got = super::obfuscate_sql(input, &config, DbmsKind::Generic);
if got != *expected {
let _ = write!(
errors,
"case {i} ({input:?}):\n expected {expected:?}\n got {got:?}\n"
);
}
}
assert!(errors.is_empty(), "{errors}");
}
// {'dbms': 'mssql'}
#[test]
#[allow(deprecated)]
fn test_suite_mssql() {
let config = SqlObfuscateConfig::default();
let cases: &[(&str, &str)] = &[
// sql_single_dollar_identifier_merge
("\n\tMERGE INTO Employees AS target\n\tUSING EmployeeUpdates AS source\n\tON (target.EmployeeID = source.EmployeeID)\n\tWHEN MATCHED THEN\n\t\tUPDATE SET\n\t\t\ttarget.Name = source.Name\n\tWHEN NOT MATCHED BY TARGET THEN\n\t\tINSERT (EmployeeID, Name)\n\t\tVALUES (source.EmployeeID, source.Name)\n\tWHEN NOT MATCHED BY SOURCE THEN\n\t\tDELETE\n\tOUTPUT $action, inserted.*, deleted.*;\n\t", "MERGE INTO Employees USING EmployeeUpdates ON ( target.EmployeeID = source.EmployeeID ) WHEN MATCHED THEN UPDATE SET target.Name = source.Name WHEN NOT MATCHED BY TARGET THEN INSERT ( EmployeeID, Name ) VALUES ( source.EmployeeID, source.Name ) WHEN NOT MATCHED BY SOURCE THEN DELETE OUTPUT $action, inserted.*, deleted.*"),
// sql_dbms_sqlserver_global_temp
("select * from ##ThisIsAGlobalTempTable where id = 1", "select * from ##ThisIsAGlobalTempTable where id = ?"),
// sql_dbms_sqlserver_temp
("select * from dbo.#ThisIsATempTable where id = 1", "select * from dbo.#ThisIsATempTable where id = ?"),
// sql_dbms_sqlserver_brackets
("SELECT * from [db_users] where [id] = @1", "SELECT * from db_users where id = @1"),
];
let mut errors = String::new();
for (i, (input, expected)) in cases.iter().enumerate() {
let got = super::obfuscate_sql(input, &config, DbmsKind::Mssql);
if got != *expected {
let _ = write!(
errors,
"case {i} ({input:?}):\n expected {expected:?}\n got {got:?}\n"
);
}
}
assert!(errors.is_empty(), "{errors}");
}
// {'dbms': 'postgresql'}
#[test]
#[allow(deprecated)]
fn test_suite_postgresql() {
let config = SqlObfuscateConfig::default();
let cases: &[(&str, &str)] = &[
// sql_pg_json_operators_0
(
"select users.custom #> '{a,b}' from users",
"select users.custom #> ? from users",
),
// sql_pg_json_operators_1
(
"select users.custom #>> '{a,b}' from users",
"select users.custom #>> ? from users",
),
// sql_pg_json_operators_2
(
"select users.custom #- '{a,b}' from users",
"select users.custom #- ? from users",
),
// sql_pg_json_operators_3
(
"select users.custom -> 'foo' from users",
"select users.custom -> ? from users",
),
// sql_pg_json_operators_4
(
"select users.custom ->> 'foo' from users",
"select users.custom ->> ? from users",
),
// sql_pg_json_operators_5
(
"select * from users where user.custom @> '{a,b}'",
"select * from users where user.custom @> ?",
),
// sql_pg_json_operators_6
(
"SELECT a FROM foo WHERE value<@name",
"SELECT a FROM foo WHERE value <@ name",
),
// sql_pg_json_operators_7
(
"select * from users where user.custom ? 'foo'",
"select * from users where user.custom ? ?",
),
// sql_pg_json_operators_8
(
"select * from users where user.custom ?| array [ '1', '2' ]",
"select * from users where user.custom ?| array [ ? ]",
),
// sql_pg_json_operators_9
(
"select * from users where user.custom ?& array [ '1', '2' ]",
"select * from users where user.custom ?& array [ ? ]",
),
];
let mut errors = String::new();
for (i, (input, expected)) in cases.iter().enumerate() {
let got = super::obfuscate_sql(input, &config, DbmsKind::Postgresql);
if got != *expected {
let _ = write!(
errors,
"case {i} ({input:?}):\n expected {expected:?}\n got {got:?}\n"
);
}
}
assert!(errors.is_empty(), "{errors}");
}
// {'mode': 'normalize_only'}
#[test]
fn test_suite_normalize_only() {
let config = SqlObfuscateConfig {
obfuscation_mode: SqlObfuscationMode::NormalizeOnly,
..Default::default()
};
let cases: &[(&str, &str)] = &[
// sqllexer_norm_simple
("SELECT * FROM users WHERE id = 1", "SELECT * FROM users WHERE id = 1"),
// sqllexer_norm_dollar_func
("SELECT $func$INSERT INTO table VALUES ('a', 1, 2)$func$ FROM users", "SELECT $func$INSERT INTO table VALUES ( 'a', 1, 2 )$func$ FROM users"),
// sqllexer_norm_procedure_on
("CREATE PROCEDURE TestProc AS BEGIN SELECT * FROM users WHERE id = 1 END", "CREATE PROCEDURE TestProc AS BEGIN SELECT * FROM users WHERE id = 1 END"),
// sqllexer_norm_procedure_off
("CREATE PROCEDURE TestProc AS BEGIN UPDATE users SET name = 'test' WHERE id = 1 END", "CREATE PROCEDURE TestProc AS BEGIN UPDATE users SET name = 'test' WHERE id = 1 END"),
// sqllexer_norm_null_bool_pos
("SELECT * FROM users WHERE id = 1 AND address = $1 and id = $2 AND deleted IS NULL AND active is TRUE", "SELECT * FROM users WHERE id = 1 AND address = $1 and id = $2 AND deleted IS NULL AND active is TRUE"),
// sqllexer_norm_cte
("WITH users AS (SELECT * FROM people) SELECT * FROM users", "WITH users AS ( SELECT * FROM people ) SELECT * FROM users"),
];
let mut errors = String::new();
for (i, (input, expected)) in cases.iter().enumerate() {
let got = super::obfuscate_sql(input, &config, DbmsKind::Generic);
if got != *expected {
let _ = write!(
errors,
"case {i} ({input:?}):\n expected {expected:?}\n got {got:?}\n"
);
}
}
assert!(errors.is_empty(), "{errors}");
}
// {'mode': 'normalize_only', 'keep_sql_alias': True}
#[test]
fn test_suite_normalize_only_keep_sql_alias() {
let config = SqlObfuscateConfig {
obfuscation_mode: SqlObfuscationMode::NormalizeOnly,
keep_sql_alias: true,
..Default::default()
};
let cases: &[(&str, &str)] = &[
// sqllexer_norm_comments_alias
("\n\t\t\t-- comment\n\t\t\t/* comment */\n\t\t\tSELECT id as id, name as n FROM users123 WHERE id in (1,2,3)", "SELECT id as id, name as n FROM users123 WHERE id in ( 1, 2, 3 )"),
];
let mut errors = String::new();
for (i, (input, expected)) in cases.iter().enumerate() {
let got = super::obfuscate_sql(input, &config, DbmsKind::Generic);
if got != *expected {
let _ = write!(
errors,
"case {i} ({input:?}):\n expected {expected:?}\n got {got:?}\n"
);
}
}
assert!(errors.is_empty(), "{errors}");
}
// {'mode': 'normalize_only', 'remove_space_between_parentheses': True}
#[test]
fn test_suite_normalize_only_remove_space_between_parentheses() {
let config = SqlObfuscateConfig {
obfuscation_mode: SqlObfuscationMode::NormalizeOnly,
remove_space_between_parentheses: true,
..Default::default()
};
let cases: &[(&str, &str)] = &[
// sqllexer_norm_remove_space_parens
(
"SELECT * FROM users WHERE id = 1 AND (name = 'test' OR name = 'test2')",
"SELECT * FROM users WHERE id = 1 AND (name = 'test' OR name = 'test2')",
),
];
let mut errors = String::new();
for (i, (input, expected)) in cases.iter().enumerate() {
let got = super::obfuscate_sql(input, &config, DbmsKind::Generic);
if got != *expected {
let _ = write!(
errors,
"case {i} ({input:?}):\n expected {expected:?}\n got {got:?}\n"
);
}
}
assert!(errors.is_empty(), "{errors}");
}
// {'mode': 'normalize_only', 'keep_trailing_semicolon': True}
#[test]
fn test_suite_normalize_only_keep_trailing_semicolon() {
let config = SqlObfuscateConfig {
obfuscation_mode: SqlObfuscationMode::NormalizeOnly,
keep_trailing_semicolon: true,
..Default::default()
};
let cases: &[(&str, &str)] = &[
// sqllexer_norm_keep_trailing_semi
(
"SELECT * FROM users WHERE id = 1 AND name = 'test';",
"SELECT * FROM users WHERE id = 1 AND name = 'test';",
),
];
let mut errors = String::new();
for (i, (input, expected)) in cases.iter().enumerate() {
let got = super::obfuscate_sql(input, &config, DbmsKind::Generic);
if got != *expected {
let _ = write!(
errors,
"case {i} ({input:?}):\n expected {expected:?}\n got {got:?}\n"
);
}
}
assert!(errors.is_empty(), "{errors}");
}
// {'mode': 'normalize_only', 'keep_identifier_quotation': True}
#[test]
fn test_suite_normalize_only_keep_identifier_quotation() {
let config = SqlObfuscateConfig {
obfuscation_mode: SqlObfuscationMode::NormalizeOnly,
keep_identifier_quotation: true,
..Default::default()
};
let cases: &[(&str, &str)] = &[
// sqllexer_norm_keep_ident_quot
(
"SELECT * FROM \"users\" WHERE id = 1 AND name = 'test'",
"SELECT * FROM \"users\" WHERE id = 1 AND name = 'test'",
),
];
let mut errors = String::new();
for (i, (input, expected)) in cases.iter().enumerate() {
let got = super::obfuscate_sql(input, &config, DbmsKind::Generic);
if got != *expected {
let _ = write!(
errors,
"case {i} ({input:?}):\n expected {expected:?}\n got {got:?}\n"
);
}
}
assert!(errors.is_empty(), "{errors}");
}
// {'mode': 'obfuscate_and_normalize'}
#[test]
fn test_suite_obfuscate_and_normalize() {
let config = SqlObfuscateConfig {
obfuscation_mode: SqlObfuscationMode::ObfuscateAndNormalize,
..Default::default()
};
let cases: &[(&str, &str)] = &[
// sqllexer_obn_simple
("SELECT * FROM users WHERE id = 1", "SELECT * FROM users WHERE id = ?"),
// sqllexer_obn_dollar_func_off
("SELECT $func$INSERT INTO table VALUES ('a', 1, 2)$func$ FROM users", "SELECT ? FROM users"),
// sqllexer_obn_procedure_on
("CREATE PROCEDURE TestProc AS BEGIN SELECT * FROM users WHERE id = 1 END", "CREATE PROCEDURE TestProc AS BEGIN SELECT * FROM users WHERE id = ? END"),
// sqllexer_obn_procedure_off
("CREATE PROCEDURE TestProc AS BEGIN UPDATE users SET name = 'test' WHERE id = 1 END", "CREATE PROCEDURE TestProc AS BEGIN UPDATE users SET name = ? WHERE id = ? END"),
// sqllexer_obn_null_bool_pos_param
("SELECT * FROM users WHERE id = 1 AND address = $1 and id = $2 AND deleted IS NULL AND active is TRUE", "SELECT * FROM users WHERE id = ? AND address = ? and id = ? AND deleted IS ? AND active is ?"),
// sqllexer_obn_create_table
("CREATE TABLE IF NOT EXISTS users (id INT, name VARCHAR(255))", "CREATE TABLE IF NOT EXISTS users ( id INT, name VARCHAR ( ? ) )"),
// sqllexer_obn_replace_bind_off
("SELECT * FROM users WHERE id = @P1 AND name = @P2", "SELECT * FROM users WHERE id = @P1 AND name = @P2"),
// sqllexer_obn_pg_only
("SELECT * FROM ONLY users WHERE id = 1", "SELECT * FROM ONLY users WHERE id = ?"),
// sqllexer_obn_cte
("WITH users AS (SELECT * FROM people) SELECT * FROM users where id = 1", "WITH users AS ( SELECT * FROM people ) SELECT * FROM users where id = ?"),
// sqllexer_obn_json_path_off
("SELECT * FROM users WHERE id = 1 AND name->'first' = 'test'", "SELECT * FROM users WHERE id = ? AND name -> ? = ?"),
];
let mut errors = String::new();
for (i, (input, expected)) in cases.iter().enumerate() {
let got = super::obfuscate_sql(input, &config, DbmsKind::Generic);
if got != *expected {
let _ = write!(
errors,
"case {i} ({input:?}):\n expected {expected:?}\n got {got:?}\n"
);
}
}
assert!(errors.is_empty(), "{errors}");
}
// {'mode': 'obfuscate_and_normalize', 'replace_digits': True}
#[test]
fn test_suite_obfuscate_and_normalize_replace_digits() {
let config = SqlObfuscateConfig {
obfuscation_mode: SqlObfuscationMode::ObfuscateAndNormalize,
replace_digits: true,
..Default::default()
};
let cases: &[(&str, &str)] = &[
// sqllexer_obn_replace_digits
(
"SELECT * FROM users123 WHERE id = 1",
"SELECT * FROM users? WHERE id = ?",
),
];
let mut errors = String::new();
for (i, (input, expected)) in cases.iter().enumerate() {
let got = super::obfuscate_sql(input, &config, DbmsKind::Generic);
if got != *expected {
let _ = write!(
errors,
"case {i} ({input:?}):\n expected {expected:?}\n got {got:?}\n"
);
}
}
assert!(errors.is_empty(), "{errors}");
}
// {'mode': 'obfuscate_and_normalize', 'keep_sql_alias': True}
#[test]
fn test_suite_obfuscate_and_normalize_keep_sql_alias() {
let config = SqlObfuscateConfig {
obfuscation_mode: SqlObfuscationMode::ObfuscateAndNormalize,
keep_sql_alias: true,
..Default::default()
};
let cases: &[(&str, &str)] = &[
// sqllexer_obn_comments_alias
("\n\t\t\t-- comment\n\t\t\t/* comment */\n\t\t\tSELECT id as id, name as n FROM users123 WHERE id in (1,2,3)", "SELECT id as id, name as n FROM users123 WHERE id in ( ? )"),
];
let mut errors = String::new();
for (i, (input, expected)) in cases.iter().enumerate() {
let got = super::obfuscate_sql(input, &config, DbmsKind::Generic);
if got != *expected {
let _ = write!(
errors,
"case {i} ({input:?}):\n expected {expected:?}\n got {got:?}\n"
);
}
}
assert!(errors.is_empty(), "{errors}");
}
// {'mode': 'obfuscate_and_normalize', 'dollar_quoted_func': True}
#[test]
fn test_suite_obfuscate_and_normalize_dollar_quoted_func() {
let config = SqlObfuscateConfig {
obfuscation_mode: SqlObfuscationMode::ObfuscateAndNormalize,
dollar_quoted_func: true,
..Default::default()
};
let cases: &[(&str, &str)] = &[
// sqllexer_obn_dollar_func_on
(
"SELECT $func$INSERT INTO table VALUES ('a', 1, 2)$func$ FROM users",
"SELECT $func$INSERT INTO table VALUES ( ? )$func$ FROM users",
),
];
let mut errors = String::new();
for (i, (input, expected)) in cases.iter().enumerate() {
let got = super::obfuscate_sql(input, &config, DbmsKind::Generic);
if got != *expected {
let _ = write!(
errors,
"case {i} ({input:?}):\n expected {expected:?}\n got {got:?}\n"
);
}
}
assert!(errors.is_empty(), "{errors}");
}
// {'mode': 'obfuscate_and_normalize', 'dollar_quoted_func': True, 'replace_digits': True}
#[test]
fn test_suite_obfuscate_and_normalize_dollar_quoted_func_replace_digits() {
let config = SqlObfuscateConfig {
obfuscation_mode: SqlObfuscationMode::ObfuscateAndNormalize,
dollar_quoted_func: true,
replace_digits: true,
..Default::default()
};
let cases: &[(&str, &str)] = &[
// sqllexer_obn_dollar_func_digits
(
"SELECT * FROM users123 WHERE id = $tag$1$tag$",
"SELECT * FROM users? WHERE id = ?",
),
];
let mut errors = String::new();
for (i, (input, expected)) in cases.iter().enumerate() {
let got = super::obfuscate_sql(input, &config, DbmsKind::Generic);
if got != *expected {
let _ = write!(
errors,
"case {i} ({input:?}):\n expected {expected:?}\n got {got:?}\n"
);
}
}
assert!(errors.is_empty(), "{errors}");
}
// {'mode': 'obfuscate_and_normalize', 'remove_space_between_parentheses': True}
#[test]
fn test_suite_obfuscate_and_normalize_remove_space_between_parentheses() {
let config = SqlObfuscateConfig {
obfuscation_mode: SqlObfuscationMode::ObfuscateAndNormalize,
remove_space_between_parentheses: true,
..Default::default()
};
let cases: &[(&str, &str)] = &[
// sqllexer_obn_remove_space_parens
(
"SELECT * FROM users WHERE id = 1 AND (name = 'test' OR name = 'test2')",
"SELECT * FROM users WHERE id = ? AND (name = ? OR name = ?)",
),
];
let mut errors = String::new();
for (i, (input, expected)) in cases.iter().enumerate() {
let got = super::obfuscate_sql(input, &config, DbmsKind::Generic);
if got != *expected {
let _ = write!(
errors,
"case {i} ({input:?}):\n expected {expected:?}\n got {got:?}\n"
);
}
}
assert!(errors.is_empty(), "{errors}");
}
// {'mode': 'obfuscate_and_normalize', 'keep_null': True}
#[test]
fn test_suite_obfuscate_and_normalize_keep_null() {
let config = SqlObfuscateConfig {
obfuscation_mode: SqlObfuscationMode::ObfuscateAndNormalize,
keep_null: true,
..Default::default()
};
let cases: &[(&str, &str)] = &[
// sqllexer_obn_keep_null
(
"SELECT * FROM users WHERE id = 1 AND name IS NULL",
"SELECT * FROM users WHERE id = ? AND name IS NULL",
),
];
let mut errors = String::new();
for (i, (input, expected)) in cases.iter().enumerate() {
let got = super::obfuscate_sql(input, &config, DbmsKind::Generic);
if got != *expected {
let _ = write!(
errors,
"case {i} ({input:?}):\n expected {expected:?}\n got {got:?}\n"
);
}
}
assert!(errors.is_empty(), "{errors}");
}
// {'mode': 'obfuscate_and_normalize', 'keep_boolean': True}
#[test]
fn test_suite_obfuscate_and_normalize_keep_boolean() {
let config = SqlObfuscateConfig {
obfuscation_mode: SqlObfuscationMode::ObfuscateAndNormalize,
keep_boolean: true,
..Default::default()
};
let cases: &[(&str, &str)] = &[
// sqllexer_obn_keep_boolean
(
"SELECT * FROM users WHERE id = 1 AND name is TRUE",
"SELECT * FROM users WHERE id = ? AND name is TRUE",
),
];
let mut errors = String::new();
for (i, (input, expected)) in cases.iter().enumerate() {
let got = super::obfuscate_sql(input, &config, DbmsKind::Generic);
if got != *expected {
let _ = write!(
errors,
"case {i} ({input:?}):\n expected {expected:?}\n got {got:?}\n"
);
}
}
assert!(errors.is_empty(), "{errors}");
}
// {'mode': 'obfuscate_and_normalize', 'keep_positional_parameter': True}
#[test]
fn test_suite_obfuscate_and_normalize_keep_positional_parameter() {
let config = SqlObfuscateConfig {
obfuscation_mode: SqlObfuscationMode::ObfuscateAndNormalize,
keep_positional_parameter: true,
..Default::default()
};
let cases: &[(&str, &str)] = &[
// sqllexer_obn_keep_pos_param
(
"SELECT * FROM users WHERE id = 1 AND name = $1 and id = $2",
"SELECT * FROM users WHERE id = ? AND name = $1 and id = $2",
),
];
let mut errors = String::new();
for (i, (input, expected)) in cases.iter().enumerate() {
let got = super::obfuscate_sql(input, &config, DbmsKind::Generic);
if got != *expected {
let _ = write!(
errors,
"case {i} ({input:?}):\n expected {expected:?}\n got {got:?}\n"
);
}
}
assert!(errors.is_empty(), "{errors}");
}
// {'mode': 'obfuscate_and_normalize', 'keep_trailing_semicolon': True}
#[test]
fn test_suite_obfuscate_and_normalize_keep_trailing_semicolon() {
let config = SqlObfuscateConfig {
obfuscation_mode: SqlObfuscationMode::ObfuscateAndNormalize,
keep_trailing_semicolon: true,
..Default::default()
};
let cases: &[(&str, &str)] = &[
// sqllexer_obn_keep_trailing_semi
(
"SELECT * FROM users WHERE id = 1 AND name = 'test';",
"SELECT * FROM users WHERE id = ? AND name = ?;",
),
];
let mut errors = String::new();
for (i, (input, expected)) in cases.iter().enumerate() {
let got = super::obfuscate_sql(input, &config, DbmsKind::Generic);
if got != *expected {
let _ = write!(
errors,
"case {i} ({input:?}):\n expected {expected:?}\n got {got:?}\n"
);
}
}
assert!(errors.is_empty(), "{errors}");
}
// {'mode': 'obfuscate_and_normalize', 'keep_identifier_quotation': True}
#[test]
fn test_suite_obfuscate_and_normalize_keep_identifier_quotation() {
let config = SqlObfuscateConfig {
obfuscation_mode: SqlObfuscationMode::ObfuscateAndNormalize,
keep_identifier_quotation: true,
..Default::default()
};
let cases: &[(&str, &str)] = &[
// sqllexer_obn_keep_ident_quot
(
"SELECT * FROM \"users\" WHERE id = 1 AND name = 'test'",
"SELECT * FROM \"users\" WHERE id = ? AND name = ?",
),
];
let mut errors = String::new();
for (i, (input, expected)) in cases.iter().enumerate() {
let got = super::obfuscate_sql(input, &config, DbmsKind::Generic);
if got != *expected {
let _ = write!(
errors,
"case {i} ({input:?}):\n expected {expected:?}\n got {got:?}\n"
);
}
}
assert!(errors.is_empty(), "{errors}");
}
// {'mode': 'obfuscate_and_normalize', 'replace_bind_parameter': True}
#[test]
fn test_suite_obfuscate_and_normalize_replace_bind_parameter() {
let config = SqlObfuscateConfig {
obfuscation_mode: SqlObfuscationMode::ObfuscateAndNormalize,
replace_bind_parameter: true,
..Default::default()
};
let cases: &[(&str, &str)] = &[
// sqllexer_obn_replace_bind_on
(
"SELECT * FROM users WHERE id = @P1 AND name = @P2",
"SELECT * FROM users WHERE id = ? AND name = ?",
),
];
let mut errors = String::new();
for (i, (input, expected)) in cases.iter().enumerate() {
let got = super::obfuscate_sql(input, &config, DbmsKind::Generic);
if got != *expected {
let _ = write!(
errors,
"case {i} ({input:?}):\n expected {expected:?}\n got {got:?}\n"
);
}
}
assert!(errors.is_empty(), "{errors}");
}
// {'mode': 'obfuscate_and_normalize', 'keep_json_path': True}
#[test]
fn test_suite_obfuscate_and_normalize_keep_json_path() {
let config = SqlObfuscateConfig {
obfuscation_mode: SqlObfuscationMode::ObfuscateAndNormalize,
keep_json_path: true,
..Default::default()
};
let cases: &[(&str, &str)] = &[
// sqllexer_obn_json_path_arrow
(
"SELECT * FROM users WHERE id = 1 AND name->'first' = 'test'",
"SELECT * FROM users WHERE id = ? AND name -> 'first' = ?",
),
// sqllexer_obn_json_path_double_arrow
(
"SELECT * FROM users WHERE id = 1 AND name->>2 = 'test'",
"SELECT * FROM users WHERE id = ? AND name ->> 2 = ?",
),
];
let mut errors = String::new();
for (i, (input, expected)) in cases.iter().enumerate() {
let got = super::obfuscate_sql(input, &config, DbmsKind::Generic);
if got != *expected {
let _ = write!(
errors,
"case {i} ({input:?}):\n expected {expected:?}\n got {got:?}\n"
);
}
}
assert!(errors.is_empty(), "{errors}");
}
// {'mode': 'obfuscate_only'}
#[test]
fn test_suite_obfuscate_only() {
let config = SqlObfuscateConfig {
obfuscation_mode: SqlObfuscationMode::ObfuscateOnly,
..Default::default()
};
let cases: &[(&str, &str)] = &[
// sqllexer_obf_simple
("SELECT * FROM users WHERE id = 1", "SELECT * FROM users WHERE id = ?"),
// sqllexer_obf_dollar_question
("SELECT \"table\".\"field\" FROM \"table\" WHERE \"table\".\"otherfield\" = $? AND \"table\".\"thirdfield\" = $?;", "SELECT \"table\".\"field\" FROM \"table\" WHERE \"table\".\"otherfield\" = $? AND \"table\".\"thirdfield\" = $?;"),
// sqllexer_obf_replace_digits_off
("SELECT * FROM users123 WHERE id = 1", "SELECT * FROM users123 WHERE id = ?"),
// sqllexer_obf_dollar_quoted_func_off
("SELECT $func$INSERT INTO table VALUES ('a', 1, 2)$func$ FROM users", "SELECT ? FROM users"),
];
let mut errors = String::new();
for (i, (input, expected)) in cases.iter().enumerate() {
let got = super::obfuscate_sql(input, &config, DbmsKind::Generic);
if got != *expected {
let _ = write!(
errors,
"case {i} ({input:?}):\n expected {expected:?}\n got {got:?}\n"
);
}
}
assert!(errors.is_empty(), "{errors}");
}
// {'mode': 'obfuscate_only', 'replace_digits': True}
#[test]
fn test_suite_obfuscate_only_replace_digits() {
let config = SqlObfuscateConfig {
obfuscation_mode: SqlObfuscationMode::ObfuscateOnly,
replace_digits: true,
..Default::default()
};
let cases: &[(&str, &str)] = &[
// sqllexer_obf_replace_digits_on
(
"SELECT * FROM users123 WHERE id = 1",
"SELECT * FROM users? WHERE id = ?",
),
];
let mut errors = String::new();
for (i, (input, expected)) in cases.iter().enumerate() {
let got = super::obfuscate_sql(input, &config, DbmsKind::Generic);
if got != *expected {
let _ = write!(
errors,
"case {i} ({input:?}):\n expected {expected:?}\n got {got:?}\n"
);
}
}
assert!(errors.is_empty(), "{errors}");
}
// {'mode': 'obfuscate_only', 'dollar_quoted_func': True}
#[test]
fn test_suite_obfuscate_only_dollar_quoted_func() {
let config = SqlObfuscateConfig {
obfuscation_mode: SqlObfuscationMode::ObfuscateOnly,
dollar_quoted_func: true,
..Default::default()
};
let cases: &[(&str, &str)] = &[
// sqllexer_obf_dollar_quoted_func_on
(
"SELECT $func$INSERT INTO table VALUES ('a', 1, 2)$func$ FROM users",
"SELECT $func$INSERT INTO table VALUES (?, ?, ?)$func$ FROM users",
),
];
let mut errors = String::new();
for (i, (input, expected)) in cases.iter().enumerate() {
let got = super::obfuscate_sql(input, &config, DbmsKind::Generic);
if got != *expected {
let _ = write!(
errors,
"case {i} ({input:?}):\n expected {expected:?}\n got {got:?}\n"
);
}
}
assert!(errors.is_empty(), "{errors}");
}
// {'mode': 'obfuscate_only', 'dollar_quoted_func': True, 'replace_digits': True}
#[test]
fn test_suite_obfuscate_only_dollar_quoted_func_replace_digits() {
let config = SqlObfuscateConfig {
obfuscation_mode: SqlObfuscationMode::ObfuscateOnly,
dollar_quoted_func: true,
replace_digits: true,
..Default::default()
};
let cases: &[(&str, &str)] = &[
// sqllexer_obf_dollar_func_and_digits
(
"SELECT * FROM users123 WHERE id = $tag$1$tag$",
"SELECT * FROM users? WHERE id = ?",
),
];
let mut errors = String::new();
for (i, (input, expected)) in cases.iter().enumerate() {
let got = super::obfuscate_sql(input, &config, DbmsKind::Generic);
if got != *expected {
let _ = write!(
errors,
"case {i} ({input:?}):\n expected {expected:?}\n got {got:?}\n"
);
}
}
assert!(errors.is_empty(), "{errors}");
}
// Test that collapse_limit_two_args handles LIMIT case-insensitively.
// In the deprecated mode, the grouping filter is inactive, so
// collapse_limit_two_args is the sole mechanism for both cases.
#[test]
fn test_collapse_limit_case_insensitive() {
#[allow(deprecated)]
let config = SqlObfuscateConfig {
obfuscation_mode: SqlObfuscationMode::Unspecified,
..Default::default()
};
let got_upper =
super::obfuscate_sql("SELECT * FROM t LIMIT 5, 10", &config, DbmsKind::Generic);
assert_eq!(
got_upper, "SELECT * FROM t LIMIT ?",
"uppercase LIMIT should be collapsed: {got_upper:?}"
);
// eq_ignore_ascii_case fix: lowercase limit must also be collapsed.
let got_lower =
super::obfuscate_sql("SELECT * FROM t limit 5, 10", &config, DbmsKind::Generic);
assert_eq!(
got_lower, "SELECT * FROM t limit ?",
"lowercase limit should also be collapsed: {got_lower:?}"
);
}
}