A reactive notebook for Python — run reproducible experiments, query with SQL, execute as a script, deploy as an app, and version with git. Stored as pure Python. All in a modern, AI-native editor.
Python artificial-intelligencedagdata-sciencedata-visualizationdataflowdeveloper-toolsmachine-learningnotebookspipelinepythonreactivesqlweb-app
quote brackets, and get offset map for column number positioning (#6542)
Shahmir Varqhabe6cdf6c0423
diff --git a/marimo/_sql/parse.py b/marimo/_sql/parse.pyindex d82ca684bf..db30d155dd 100644--- a/marimo/_sql/parse.py+++ b/marimo/_sql/parse.py@@ -1,5 +1,6 @@# Copyright 2025 Marimo. All rights reserved.+import refrom typing import Literal, Optional, Unionimport msgspec@@ -109,6 +110,12 @@ def _parse_sql_duckdb(else JSON_SERIALIZE_LEGACY_QUERY)+ idx_to_offset_dict: dict[int, int] = {}+ try:+ query, idx_to_offset_dict = replace_brackets_with_quotes(query)+ except Exception as e:+ LOGGER.debug(f"Error sanitizing SQL query: {e}")+relation = duckdb.execute(json_serialize_query, [query])fetch_result = relation.fetchone()if fetch_result is None:@@ -128,7 +135,26 @@ def _parse_sql_duckdb(position = int(parsed_error.position or 0)subquery = query[:position]line_number = subquery.count("\n") + 1- column_number = position - subquery.rfind("\n") - 1++ last_newline_idx = subquery.rfind("\n")+ column_number = position - last_newline_idx - 1++ # Adjust column_number to account for any added quotes from bracket replacements+ # SELECT {id} FRO users+ # ^ error position should be here+ # SELECT {id} FRO users+ # ^ user sees this+ # So in this case, we subtract the offset from the column position.+ # If the error is before the brackets, we don't need to add the offset because it just increases the string length+ # Column position will be the same as the user sees.+ error_line_start = last_newline_idx + 1+ cumulative_offset = 0+ for idx, offset in idx_to_offset_dict.items():+ # Only count replacements that are on the same line as the error+ # and come before the error position+ if error_line_start <= idx < position:+ cumulative_offset += offset+ column_number -= cumulative_offsetsql_parse_result = SqlParseResult(success=False,@@ -142,3 +168,52 @@ def _parse_sql_duckdb(],)return sql_parse_result, None+++def replace_brackets_with_quotes(sql: str) -> tuple[str, dict[int, int]]:+ """+ Replaces unquoted curly bracket expressions (e.g., {id}) with quoted strings (e.g., '{id}'),+ ignoring brackets already inside single or double quotes.++ Returns the modified SQL and a record mapping the index of each replaced bracket to the+ number of characters added (for offset tracking).++ Args:+ sql (str): The SQL string to process.++ Returns:+ tuple[str, dict[int, int]]: A tuple containing:+ - The modified SQL string+ - A dictionary mapping original bracket positions to the number of characters added (0-based)++ Example:+ replace_brackets_with_quotes("SELECT {id}, '{name}' FROM users")+ # => ("SELECT '{id}', '{name}' FROM users", {7: 2})+ """+ QUOTE_LENGTH = 2 # Length of the added quotes around brackets++ offset_record: dict[int, int] = {}++ # Pattern to match quoted strings or unquoted brackets+ # Groups: 1=double quoted, 2=single quoted, 3=bracket+ pattern = r'("(?:[^"\\]|\\.)*")|(\'(?:[^\'\\]|\\.)*\')|(\{[^}]*\})'++ def replacement_func(match: re.Match[str]) -> str:+ double_quoted = match.group(1)+ single_quoted = match.group(2)+ bracket = match.group(3)++ # If it's a quoted string, return it as-is+ if double_quoted or single_quoted:+ return match.group(0)++ # If it's a bracket, quote it and record the offset+ if bracket:+ offset_record[match.start()] = QUOTE_LENGTH+ return f"'{bracket}'"++ return match.group(0)++ replaced_sql = re.sub(pattern, replacement_func, sql)++ return replaced_sql, offset_recorddiff --git a/tests/_sql/test_sql_parse.py b/tests/_sql/test_sql_parse.pyindex 52bb1c4050..e03eee5c29 100644--- a/tests/_sql/test_sql_parse.py+++ b/tests/_sql/test_sql_parse.py@@ -2,10 +2,17 @@from __future__ import annotations+from textwrap import dedent+import pytestfrom marimo._dependencies.dependencies import DependencyManager-from marimo._sql.parse import SqlParseError, SqlParseResult, parse_sql+from marimo._sql.parse import (+ SqlParseError,+ SqlParseResult,+ parse_sql,+ replace_brackets_with_quotes,+)HAS_DUCKDB = DependencyManager.duckdb.has()@@ -222,20 +229,29 @@ class TestDuckDBInvalidQueries:class TestErrorPositionCalculation:"""Test that error positions (line and column) are calculated correctly."""- def test_single_line_error_position(self):- """Test position calculation for single-line queries."""- query = "SELECT * FRM table" # Error at position of "FRM"-- result, error = parse_sql(query, "duckdb")+ def assert_line_column(+ self,+ result: SqlParseResult | None,+ parse_error: str | None,+ expected_line: int,+ expected_column: int,+ ):assert result is not None- assert error is None+ assert parse_error is Noneassert result.success is Falseassert len(result.errors) == 1-error = result.errors[0]- assert error.line == 1- assert error.column == 13++ assert error.line == expected_line+ assert error.column == expected_column++ def test_single_line_error_position(self):+ """Test position calculation for single-line queries."""+ query = "SELECT * FRM table" # Error at position of "FRM"++ result, error = parse_sql(query, "duckdb")+ self.assert_line_column(result, error, 1, 13)@pytest.mark.xfail(reason="DuckDB does not raise errors for this case")def test_multiline_error_position(self):@@ -245,14 +261,7 @@ class TestErrorPositionCalculation:FRM users""" # Error on line 3result, error = parse_sql(query, "duckdb")- assert result is not None-- assert result.success is False- assert len(result.errors) == 1-- error = result.errors[0]- assert error.line == 3- assert error.column == 0+ self.assert_line_column(result, error, 3, 0)def test_error_at_beginning_of_line(self):"""Test position calculation when error is at beginning of line."""@@ -260,14 +269,7 @@ class TestErrorPositionCalculation:FRM table"""result, error = parse_sql(query, "duckdb")- assert result is not None-- assert result.success is False- assert len(result.errors) == 1-- error = result.errors[0]- assert error.line == 2- assert error.column == 4+ self.assert_line_column(result, error, 2, 4)def test_error_with_leading_whitespace(self):"""Test position calculation with leading whitespace."""@@ -304,6 +306,130 @@ FRM table"""assert error.line == 3assert error.column >= 0+ def test_error_position_after_offset(self):+ """Test position calculation with offset."""+ query = """SELECT id FRM users"""+ result, error = parse_sql(query, "duckdb")++ expected_line = 1+ expected_column = 14+ self.assert_line_column(result, error, expected_line, expected_column)++ query_with_brackets = "SELECT {id} FRM users"+ result, error = parse_sql(query_with_brackets, "duckdb")+ # Add 2 for the brackets+ self.assert_line_column(+ result, error, expected_line, expected_column + 2+ )++ # Multiple brackets+ query_with_multiple_vars = "SELECT id, name FRM users"+ result, error = parse_sql(query_with_multiple_vars, "duckdb")++ expected_line = 1+ expected_column = 20+ self.assert_line_column(result, error, expected_line, expected_column)++ query_multiple_vars_brackets = "SELECT {id}, {name} FRM users"+ result, error = parse_sql(query_multiple_vars_brackets, "duckdb")+ self.assert_line_column(+ result,+ error,+ expected_line,+ expected_column + (2 * 2), # 2 for each bracket+ )++ def test_offset_after_position(self):+ query = "SELECT * FRM users WHERE id = id"+ result, error = parse_sql(query, "duckdb")+ expected_column = 13+ expected_line = 1+ self.assert_line_column(result, error, expected_line, expected_column)++ query_with_brackets = "SELECT * FRM users WHERE id = {id}"+ result, error = parse_sql(query_with_brackets, "duckdb")+ # No change since the error is before the brackets+ self.assert_line_column(result, error, expected_line, expected_column)++ # Multiple variables with brackets+ query_multiple_vars_brackets = (+ "SELECT * FRM users WHERE id = id and name = name"+ )+ result, error = parse_sql(query_multiple_vars_brackets, "duckdb")+ self.assert_line_column(result, error, expected_line, expected_column)++ query_multiple_vars_brackets_with_brackets = (+ "SELECT * FRM users WHERE id = {id} and name = {name}"+ )+ result, error = parse_sql(+ query_multiple_vars_brackets_with_brackets, "duckdb"+ )+ self.assert_line_column(result, error, expected_line, expected_column)++ def test_mixed_position_brackets(self):+ query = "SELECT id FRM users WHERE name = name"+ result, error = parse_sql(query, "duckdb")+ expected_line = 1+ expected_column = 14+ self.assert_line_column(result, error, expected_line, expected_column)++ query_with_brackets = "SELECT {id} FRM users WHERE name = {name}"+ result, error = parse_sql(query_with_brackets, "duckdb")++ self.assert_line_column(+ result,+ error,+ expected_line,+ # Only accounts for brackets before the errors+ expected_column + 2,+ )++ def test_multiline_brackets_before_error(self):+ query = """SELECT id+FRM users"""+ result, error = parse_sql(query, "duckdb")+ expected_line = 2+ expected_column = 4+ self.assert_line_column(result, error, expected_line, expected_column)++ query_with_brackets = """SELECT {id}+FRM users"""+ result, error = parse_sql(query_with_brackets, "duckdb")+ self.assert_line_column(result, error, expected_line, expected_column)++ @pytest.mark.xfail(+ reason="There is an incorrect calculation for column position"+ )+ def test_brackets_on_error_line(self):+ # Brackets on error line+ query_error_line = """SELECT name,+id FRM users"""+ result, error = parse_sql(query_error_line, "duckdb")+ expected_line = 2+ expected_column = 7+ self.assert_line_column(result, error, expected_line, expected_column)++ query_error_line_with_brackets = """SELECT {name},+{id} FRM users"""+ result, error = parse_sql(query_error_line_with_brackets, "duckdb")+ self.assert_line_column(+ result, error, expected_line, expected_column + 2+ )++ def test_multiline_brackets_after_error(self):+ query = """SELECT *+FRM users WHERE name = name"""+ result, error = parse_sql(query, "duckdb")+ expected_line = 2+ expected_column = 4+ self.assert_line_column(result, error, expected_line, expected_column)++ query_with_brackets = """SELECT *+FRM users WHERE name = {name}"""+ result, error = parse_sql(query_with_brackets, "duckdb")+ # No change since the error is after the brackets+ self.assert_line_column(result, error, expected_line, expected_column)+@pytest.mark.skipif(not HAS_DUCKDB, reason="DuckDB not installed")class TestEdgeCases:@@ -429,3 +555,205 @@ def test_fails_gracefully_no_duckdb():result, error = parse_sql("SELECT 1", "duckdb")assert result is Noneassert error is not None+++class TestReplaceBracketsWithQuotes:+ """Test the replace_brackets_with_quotes function."""++ def test_basic_replacement(self):+ """Test basic bracket replacement."""+ sql = "SELECT {id} FROM users"+ result_sql, offset_record = replace_brackets_with_quotes(sql)++ assert result_sql == "SELECT '{id}' FROM users"+ assert offset_record == {7: 2}++ def test_already_quoted_single(self):+ """Test that already single-quoted brackets are not modified."""+ sql = "SELECT {id}, '{name}' FROM users"+ result_sql, offset_record = replace_brackets_with_quotes(sql)++ assert result_sql == "SELECT '{id}', '{name}' FROM users"+ assert offset_record == {7: 2}++ def test_already_quoted_double(self):+ """Test that already double-quoted brackets are not modified."""+ sql = 'SELECT {id}, "{name}" FROM users'+ result_sql, offset_record = replace_brackets_with_quotes(sql)++ assert result_sql == "SELECT '{id}', \"{name}\" FROM users"+ assert offset_record == {7: 2}++ def test_multiple_brackets(self):+ """Test multiple unquoted brackets."""+ sql = "SELECT {id}, {name}, {age} FROM users"+ result_sql, offset_record = replace_brackets_with_quotes(sql)++ assert result_sql == "SELECT '{id}', '{name}', '{age}' FROM users"+ assert offset_record == {7: 2, 13: 2, 21: 2}++ def test_mixed_quoted_and_unquoted(self):+ """Test mix of quoted and unquoted brackets."""+ sql = "SELECT {id}, '{name}', {age}, \"{city}\" FROM users"+ result_sql, offset_record = replace_brackets_with_quotes(sql)++ assert (+ result_sql+ == "SELECT '{id}', '{name}', '{age}', \"{city}\" FROM users"+ )+ assert offset_record == {7: 2, 23: 2}++ def test_no_brackets(self):+ """Test SQL with no brackets."""+ sql = "SELECT id, name FROM users"+ result_sql, offset_record = replace_brackets_with_quotes(sql)++ assert result_sql == "SELECT id, name FROM users"+ assert offset_record == {}++ def test_empty_brackets(self):+ """Test SQL with empty brackets."""+ sql = "SELECT {} FROM users"+ result_sql, offset_record = replace_brackets_with_quotes(sql)++ assert result_sql == "SELECT '{}' FROM users"+ assert offset_record == {7: 2}++ def test_multiple_bracket_in_quotes(self):+ sql = "SELECT '{id} {name}' FROM users"+ result_sql, offset_record = replace_brackets_with_quotes(sql)++ assert result_sql == "SELECT '{id} {name}' FROM users"+ assert offset_record == {}++ def test_escaped_quotes_in_strings(self):+ """Test that escaped quotes in strings are handled correctly."""+ sql = "SELECT 'O\\'Brien', {id} FROM users"+ result_sql, offset_record = replace_brackets_with_quotes(sql)++ assert result_sql == "SELECT 'O\\'Brien', '{id}' FROM users"+ assert offset_record == {19: 2}++ def test_complex_nested_quotes(self):+ """Test complex nested quote scenarios."""+ sql = "SELECT '{id}', \"{name}\", {status} FROM users WHERE name = 'John\\'s'"+ result_sql, offset_record = replace_brackets_with_quotes(sql)++ assert (+ result_sql+ == "SELECT '{id}', \"{name}\", '{status}' FROM users WHERE name = 'John\\'s'"+ )+ assert offset_record == {25: 2}++ def test_multiline(self):+ """Test multiline query."""+ sql = """+ SELECT+ {id}, {name}, {age}+ FROM users+ WHERE name = 'John\\'s'+ """+ result_sql, offset_record = replace_brackets_with_quotes(sql)++ assert (+ result_sql+ == """+ SELECT+ '{id}', '{name}', '{age}'+ FROM users+ WHERE name = 'John\\'s'+ """+ )+ assert offset_record == {24: 2, 30: 2, 38: 2}++ sql = """SELECT+{id}+FROM users"""+ result_sql, offset_record = replace_brackets_with_quotes(sql)++ assert (+ result_sql+ == """SELECT+'{id}'+FROM users"""+ )+ assert offset_record == {7: 2}++ sql = dedent("""+ SELECT+ {id}+ FROM users+ """)+ result_sql, offset_record = replace_brackets_with_quotes(sql)++ assert result_sql == dedent("""+ SELECT+ '{id}'+ FROM users+ """)+ assert offset_record == {12: 2}++ def test_insert_json(self):+ query = "INSERT INTO users VALUES (1, '{\"id\": 1}')"+ result_sql, offset_record = replace_brackets_with_quotes(query)++ assert result_sql == "INSERT INTO users VALUES (1, '{\"id\": 1}')"+ assert offset_record == {}++ def test_brackets_inside_quotes(self):+ # Brackets inside single quotes should not be replaced+ query = "SELECT '{id}' FROM users"+ result_sql, offset_record = replace_brackets_with_quotes(query)+ assert result_sql == "SELECT '{id}' FROM users"+ assert offset_record == {}++ # Brackets inside double quotes should not be replaced+ query = 'SELECT "{id}" FROM users'+ result_sql, offset_record = replace_brackets_with_quotes(query)+ assert result_sql == 'SELECT "{id}" FROM users'+ assert offset_record == {}++ def test_multiple_brackets_on_same_line(self):+ query = "SELECT {id}, {name}, {age} FROM users"+ result_sql, offset_record = replace_brackets_with_quotes(query)+ assert result_sql == "SELECT '{id}', '{name}', '{age}' FROM users"+ assert offset_record == {7: 2, 13: 2, 21: 2}++ @pytest.mark.xfail(reason="Nested brackets are not supported")+ def test_nested_brackets(self):+ query = "SELECT {id_{nested}} FROM users"+ result_sql, offset_record = replace_brackets_with_quotes(query)+ assert result_sql == "SELECT '{id_{nested}}' FROM users"+ assert offset_record == {7: 2}++ def test_brackets_with_escaped_quotes(self):+ # Brackets inside a quoted string with escaped quotes+ query = "SELECT '{id}\\'s' FROM users"+ result_sql, offset_record = replace_brackets_with_quotes(query)+ assert result_sql == "SELECT '{id}\\'s' FROM users"+ assert offset_record == {}++ def test_brackets_at_start_and_end(self):+ query = "{id} FROM users WHERE name = {name}"+ result_sql, offset_record = replace_brackets_with_quotes(query)+ assert result_sql == "'{id}' FROM users WHERE name = '{name}'"+ assert offset_record == {0: 2, 29: 2}++ def test_brackets_with_special_characters(self):+ query = "SELECT {id_1$-foo} FROM users"+ result_sql, offset_record = replace_brackets_with_quotes(query)+ assert result_sql == "SELECT '{id_1$-foo}' FROM users"+ assert offset_record == {7: 2}++ def test_brackets_in_comment(self):+ # Brackets in SQL comments should be replaced, as comments are not parsed+ query = "SELECT id -- {comment}\nFROM users"+ result_sql, offset_record = replace_brackets_with_quotes(query)+ assert result_sql == "SELECT id -- '{comment}'\nFROM users"+ assert offset_record == {13: 2}++ def test_adjacent_brackets(self):+ query = "SELECT {id}{name}{age} FROM users"+ result_sql, offset_record = replace_brackets_with_quotes(query)+ assert result_sql == "SELECT '{id}''{name}''{age}' FROM users"+ assert offset_record == {7: 2, 11: 2, 17: 2}