sqlnbfmt 0.1.0__tar.gz

sqlnbfmt-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Qing Ye
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sqlnbfmt-0.1.0/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.1
+Name: sqlnbfmt
+Version: 0.1.0
+Summary: A tool to format SQL code in Jupyter notebooks.
+Author-email: Qing <qingye779@gmail.com>
+License: MIT
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: astor>=0.8.1
+Requires-Dist: nbformat>=5.10.4
+Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: sqlglot>=25.27.0
+
+# sqlnbfmt
+A SQL formatter for Jupyter Notebooks

sqlnbfmt-0.1.0/README.md

@@ -0,0 +1,2 @@
+# sqlnbfmt
+A SQL formatter for Jupyter Notebooks

sqlnbfmt-0.1.0/pyproject.toml

@@ -0,0 +1,34 @@
+[project]
+name = "sqlnbfmt"
+version = "0.1.0"
+description = "A tool to format SQL code in Jupyter notebooks."
+authors = [
+  { name = "Qing", email = "qingye779@gmail.com" }
+]
+license = { text = "MIT" }
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "astor>=0.8.1",
+    "nbformat>=5.10.4",
+    "pyyaml>=6.0.2",
+    "sqlglot>=25.27.0",
+]
+
+[tool.uv]
+dev-dependencies = [
+    "pytest-cov>=5.0.0",
+    "pytest>=8.3.3",
+]
+
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project.scripts]
+sqlnbfmt = "sqlnbfmt.formatter:main"
+
+[tool.pytest.ini_options]
+markers = [
+    "integration: mark a test as an integration test."
+]

sqlnbfmt-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sqlnbfmt-0.1.0/sqlnbfmt/formatter.py

@@ -0,0 +1,409 @@
+import ast
+import logging
+import re
+import sys
+import uuid
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Set, Optional, Dict, Union, Tuple, List
+
+import nbformat
+import yaml
+from sqlglot import parse_one, parse, errors
+from sqlglot.errors import TokenError
+
+
+@dataclass
+class FormattingConfig:
+    """Configuration for SQL formatting."""
+
+    sql_keywords: Set[str]
+    function_names: Set[str]
+    sql_decorators: Set[str]
+    single_line_threshold: int = 80
+    indent_width: int = 4
+
+
+class SQLFormattingError(Exception):
+    """Custom exception for SQL formatting errors."""
+    pass
+
+
+def setup_logging(level: str = "INFO") -> logging.Logger:
+    """Sets up logging with the specified level."""
+    logger = logging.getLogger('formatter')
+    logger.setLevel(level.upper())
+    if not logger.handlers:
+        handler = logging.StreamHandler(sys.stdout)
+        formatter = logging.Formatter("[%(levelname)s] %(message)s")
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+    return logger
+
+
+def load_config(config_path: Union[str, Path] = "config.yaml") -> FormattingConfig:
+    """Loads configuration from a YAML file."""
+    config_file = Path(config_path)
+    if not config_file.is_file():
+        raise FileNotFoundError(f"Configuration file '{config_file}' not found.")
+
+    try:
+        with open(config_file) as file:
+            config = yaml.safe_load(file)
+            return FormattingConfig(
+                sql_keywords=set(config.get("sql_keywords", [])),
+                function_names=set(config.get("function_names", [])),
+                sql_decorators=set(config.get("sql_decorators", [])),
+                single_line_threshold=config.get("formatting_options", {}).get(
+                    "single_line_threshold", 80
+                ),
+                indent_width=config.get("formatting_options", {}).get(
+                    "indent_width", 4
+                ),
+            )
+    except yaml.YAMLError as e:
+        raise yaml.YAMLError(f"Error parsing the configuration file: {e}")
+
+
+def format_sql_code(
+    sql_code: str,
+    dialect: Optional[str],
+    config: FormattingConfig,
+    placeholders: Optional[Dict[str, str]] = None,
+    force_single_line: bool = False,
+    ignore_placeholders: bool = False,
+) -> str:
+    """Formats SQL code using sqlglot's native formatting capabilities while preserving placeholders."""
+    try:
+        logger = logging.getLogger('formatter')
+
+        if not sql_code.strip():
+            return sql_code
+
+        temp_sql = sql_code
+        placeholder_mapping = {}
+
+        # Handle placeholders for expressions
+        if placeholders and not ignore_placeholders:
+            for expr_placeholder, expr in placeholders.items():
+                marker = f"'__EXPR_PLACEHOLDER_{uuid.uuid4()}__'"
+                temp_sql = temp_sql.replace(expr_placeholder, marker)
+                placeholder_mapping[marker.strip("'")] = expr_placeholder
+                logger.debug(f"Replaced placeholder {expr_placeholder} with marker {marker}")
+
+        # Automatically replace common placeholders (%s and ?) with unique markers
+        if not ignore_placeholders:
+            auto_placeholders = {'%s', '?'}
+            for placeholder in auto_placeholders:
+                unique_id = str(uuid.uuid4())
+                marker = f"'__AUTO_PLACEHOLDER_{unique_id}__'"
+                temp_sql = temp_sql.replace(placeholder, marker)
+                placeholder_mapping[marker.strip("'")] = placeholder
+                logger.debug(f"Auto-replaced placeholder {placeholder} with marker {marker}")
+
+        temp_sql = temp_sql.strip()
+
+        # Prevent multiple statements
+        statements = parse(temp_sql, read=dialect)
+        if len(statements) > 1:
+            raise SQLFormattingError("Multiple SQL statements are not supported.")
+
+        # Parse SQL
+        parsed = statements[0]
+
+        # Generate formatted SQL with uppercase keywords and proper quoting
+        formatted_sql = parsed.sql(
+            pretty=not force_single_line,
+            indent=config.indent_width,
+            dialect=dialect,
+        )
+
+        # Condense to single line if necessary
+        if force_single_line or (
+            config.single_line_threshold
+            and len(formatted_sql.replace('\n', ' ')) <= config.single_line_threshold
+        ):
+            formatted_sql = " ".join(formatted_sql.split())
+
+        # Restore placeholders
+        if placeholder_mapping:
+            for marker, original_placeholder in placeholder_mapping.items():
+                formatted_sql = formatted_sql.replace(f"'{marker}'", original_placeholder)
+                logger.debug(f"Restored marker '{marker}' to placeholder {original_placeholder}")
+
+        # Logging
+        logger.debug(f"Original SQL:\n{sql_code}")
+        logger.debug(f"Formatted SQL:\n{formatted_sql}")
+
+        return formatted_sql
+
+    except errors.ParseError as e:
+        logger.warning(f"SQL parsing failed: {e}. Returning original SQL code.")
+        return sql_code  # Return the original SQL code unmodified
+    except TokenError as te:
+        logger.warning(f"Tokenization failed: {te}. Returning original SQL code.")
+        return sql_code  # Return the original SQL code unmodified
+    except Exception as e:
+        raise SQLFormattingError(f"Unexpected error during SQL formatting: {e}") from e
+
+
+class SQLStringFormatter(ast.NodeTransformer):
+    """AST NodeTransformer that formats SQL strings."""
+
+    def __init__(
+        self, config: FormattingConfig, dialect: Optional[str], logger: logging.Logger
+    ):
+        super().__init__()
+        self.config = config
+        self.dialect = dialect
+        self.logger = logger
+        self.changed = False
+
+    def is_likely_sql(self, code: str) -> bool:
+        """Enhanced SQL detection with better heuristics."""
+        if not code or len(code.strip()) < 10:
+            return False
+
+        if re.match(r"^\s*(/|[a-zA-Z]:\\|https?://|<!DOCTYPE|<html)", code.strip()):
+            return False
+
+        upper_code = code.upper()
+        keyword_count = sum(
+            1
+            for keyword in self.config.sql_keywords
+            if re.search(rf"\b{re.escape(keyword)}\b", upper_code)
+        )
+
+        has_sql_pattern = bool(
+            re.search(
+                r"\bSELECT\b.*\bFROM\b|\bUPDATE\b.*\bSET\b|\bINSERT\b.*\bINTO\b|\bDELETE\b.*\bFROM\b",
+                upper_code,
+                re.DOTALL,
+            )
+        )
+
+        return keyword_count >= 2 or has_sql_pattern
+
+    def extract_fstring_parts(self, node: ast.JoinedStr) -> Tuple[str, Dict[str, str]]:
+        """Extracts parts of an f-string, preserving expressions."""
+        sql_parts = []
+        placeholders = {}
+
+        for value in node.values:
+            if isinstance(value, ast.Constant):
+                sql_parts.append(value.value)
+            elif isinstance(value, ast.FormattedValue):
+                expr = ast.unparse(value.value).strip()
+                placeholder = f"__EXPR_PLACEHOLDER_{uuid.uuid4()}__"
+                sql_parts.append(placeholder)
+                placeholders[placeholder] = f"{{{expr}}}"
+
+        return "".join(sql_parts), placeholders
+
+    def format_sql_node(
+        self, node: Union[ast.Constant, ast.JoinedStr], force_single_line: bool = False
+    ) -> Optional[ast.AST]:
+        """Formats SQL code in AST nodes."""
+        try:
+            if isinstance(node, ast.Constant) and isinstance(node.value, str):
+                if not self.is_likely_sql(node.value):
+                    return None
+                formatted_sql = format_sql_code(
+                    node.value,
+                    self.dialect,
+                    self.config,
+                    force_single_line=force_single_line,
+                )
+                if formatted_sql != node.value:
+                    self.changed = True
+                    return ast.Constant(value=formatted_sql)
+
+            elif isinstance(node, ast.JoinedStr):
+                sql_str, placeholders = self.extract_fstring_parts(node)
+                if not self.is_likely_sql(sql_str):
+                    return None
+                formatted_sql = format_sql_code(
+                    sql_str,
+                    self.dialect,
+                    self.config,
+                    placeholders=placeholders,
+                    force_single_line=force_single_line,
+                )
+                if formatted_sql != sql_str:
+                    self.changed = True
+                    # Reconstruct the f-string
+                    new_values = []
+                    pattern = re.compile('|'.join(re.escape(k) for k in placeholders.keys()))
+                    idx = 0
+                    while idx < len(formatted_sql):
+                        match = pattern.search(formatted_sql, idx)
+                        if match:
+                            if match.start() > idx:
+                                new_values.append(ast.Constant(value=formatted_sql[idx:match.start()]))
+                            expr_placeholder = match.group()
+                            expr_str = placeholders[expr_placeholder]
+                            expr_ast = ast.parse(expr_str).body[0].value
+                            new_values.append(ast.FormattedValue(
+                                value=expr_ast,
+                                conversion=-1,
+                                format_spec=None
+                            ))
+                            idx = match.end()
+                        else:
+                            new_values.append(ast.Constant(value=formatted_sql[idx:]))
+                            break
+                    return ast.JoinedStr(values=new_values)
+            return None
+        except SQLFormattingError as e:
+            self.logger.warning(f"SQL formatting skipped: {e}")
+            return None
+
+    def visit_Constant(self, node: ast.Constant) -> ast.AST:
+        """Handles string constants."""
+        formatted_node = self.format_sql_node(node)
+        return formatted_node or node
+
+    def visit_JoinedStr(self, node: ast.JoinedStr) -> ast.AST:
+        """Handles f-strings."""
+        formatted_node = self.format_sql_node(node)
+        return formatted_node or node
+
+    def visit_Assign(self, node: ast.Assign) -> ast.AST:
+        """Handles assignments."""
+        self.generic_visit(node)
+        return node
+
+    def visit_Call(self, node: ast.Call) -> ast.AST:
+        """Handles function calls."""
+        func_name = self.get_full_func_name(node.func)
+        if any(name in func_name for name in self.config.function_names):
+            for idx, arg in enumerate(node.args):
+                if isinstance(arg, (ast.Constant, ast.JoinedStr)):
+                    formatted_node = self.format_sql_node(arg)
+                    if formatted_node:
+                        node.args[idx] = formatted_node
+            for keyword in node.keywords:
+                if isinstance(keyword.value, (ast.Constant, ast.JoinedStr)):
+                    formatted_node = self.format_sql_node(keyword.value)
+                    if formatted_node:
+                        keyword.value = formatted_node
+        self.generic_visit(node)
+        return node
+
+    @staticmethod
+    def get_full_func_name(node: ast.AST) -> str:
+        """Gets the full function name from an AST node."""
+        parts = []
+        while isinstance(node, ast.Attribute):
+            parts.append(node.attr)
+            node = node.value
+        if isinstance(node, ast.Name):
+            parts.append(node.id)
+        return ".".join(reversed(parts))
+
+
+def process_notebook(
+    notebook_path: Path,
+    config: FormattingConfig,
+    dialect: Optional[str],
+    logger: logging.Logger
+) -> bool:
+    """Processes a Jupyter notebook, formatting SQL code within code cells."""
+    try:
+        nb = nbformat.read(notebook_path, as_version=4)
+        changed = False
+        failed = False  # Flag to track failures
+
+        for idx, cell in enumerate(nb.cells):
+            if cell.cell_type != "code":
+                continue
+
+            original_source = cell.source
+
+            # Handle magic SQL cells
+            if cell.source.lstrip().startswith("%%sql"):
+                stripped_source = cell.source.lstrip()
+                lines = stripped_source.split('\n', 1)
+                magic_command = lines[0]
+                sql_code = lines[1] if len(lines) > 1 else ''
+                try:
+                    formatted_sql = format_sql_code(
+                        sql_code, dialect, config, ignore_placeholders=True
+                    )
+                    cell.source = f"{magic_command}\n{formatted_sql}"
+                    if cell.source != original_source:
+                        changed = True
+                except SQLFormattingError as e:
+                    logger.warning(f"Failed to format magic SQL in cell {idx}: {e}")
+                    failed = True
+                continue
+
+            # Process regular code cells
+            try:
+                tree = ast.parse(cell.source)
+                formatter = SQLStringFormatter(config, dialect, logger)
+                new_tree = formatter.visit(tree)
+                if formatter.changed:
+                    cell.source = ast.unparse(new_tree)
+                    changed = True
+            except SyntaxError as e:
+                logger.warning(f"Syntax error in cell {idx}: {e}")
+                failed = True
+            except Exception as e:
+                logger.error(f"Error processing cell {idx}: {e}")
+                failed = True
+
+        if changed and not failed:
+            nbformat.write(nb, notebook_path)
+            logger.info(f"Updated notebook: {notebook_path}")
+            return True
+        elif failed:
+            logger.error(f"Notebook processing failed for: {notebook_path}")
+            return False
+        else:
+            logger.info(f"No changes made to notebook: {notebook_path}")
+            return True
+
+    except Exception as e:
+        logger.error(f"Error processing notebook {notebook_path}: {e}")
+        return False
+
+
+def main():
+    """Main entry point for the SQL formatter."""
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Format SQL code in Jupyter notebooks")
+    parser.add_argument(
+        "notebooks", nargs="+", type=Path, help="Notebook paths to process"
+    )
+    parser.add_argument(
+        "--config", type=Path, default="config.yaml", help="Configuration file path"
+    )
+    parser.add_argument(
+        "--dialect", type=str, help="SQL dialect (e.g., mysql, postgres)"
+    )
+    parser.add_argument(
+        "--log-level",
+        choices=["DEBUG", "INFO", "WARNING", "ERROR"],
+        default="INFO",
+        help="Logging level",
+    )
+
+    args = parser.parse_args()
+    logger = setup_logging(args.log_level)
+
+    try:
+        config = load_config(args.config)
+        all_succeeded = True
+
+        for notebook in args.notebooks:
+            success = process_notebook(notebook, config, args.dialect, logger)
+            if not success:
+                all_succeeded = False
+
+        sys.exit(0 if all_succeeded else 1)
+
+    except Exception as e:
+        logger.error(f"Fatal error: {e}")
+        sys.exit(1)

sqlnbfmt-0.1.0/sqlnbfmt.egg-info/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.1
+Name: sqlnbfmt
+Version: 0.1.0
+Summary: A tool to format SQL code in Jupyter notebooks.
+Author-email: Qing <qingye779@gmail.com>
+License: MIT
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: astor>=0.8.1
+Requires-Dist: nbformat>=5.10.4
+Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: sqlglot>=25.27.0
+
+# sqlnbfmt
+A SQL formatter for Jupyter Notebooks

sqlnbfmt-0.1.0/sqlnbfmt.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+sqlnbfmt/__init__.py
+sqlnbfmt/formatter.py
+sqlnbfmt.egg-info/PKG-INFO
+sqlnbfmt.egg-info/SOURCES.txt
+sqlnbfmt.egg-info/dependency_links.txt
+sqlnbfmt.egg-info/entry_points.txt
+sqlnbfmt.egg-info/requires.txt
+sqlnbfmt.egg-info/top_level.txt
+tests/test_formatter.py

sqlnbfmt-0.1.0/sqlnbfmt.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sqlnbfmt-0.1.0/sqlnbfmt.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sqlnbfmt = sqlnbfmt.formatter:main

sqlnbfmt-0.1.0/sqlnbfmt.egg-info/requires.txt

@@ -0,0 +1,4 @@
+astor>=0.8.1
+nbformat>=5.10.4
+pyyaml>=6.0.2
+sqlglot>=25.27.0

sqlnbfmt-0.1.0/sqlnbfmt.egg-info/top_level.txt

@@ -0,0 +1 @@
+sqlnbfmt

sqlnbfmt-0.1.0/tests/test_formatter.py

@@ -0,0 +1,406 @@
+# tests/test_formatter.py
+
+import ast
+import pytest
+import re
+import nbformat
+import logging
+from pathlib import Path
+from typing import Optional
+
+from sqlnbfmt.formatter import (
+    format_sql_code,
+    process_notebook,
+    FormattingConfig,
+    SQLFormattingError
+)
+from sqlglot import errors
+from sqlglot.errors import TokenError
+
+# Helper function to normalize SQL for comparison
+def normalize_sql(sql: str) -> str:
+    sql = re.sub(r'\s+', ' ', sql)      # Replace multiple spaces with a single space
+    sql = re.sub(r'\(\s+', '(', sql)    # Remove space after '('
+    sql = re.sub(r'\s+\)', ')', sql)    # Remove space before ')'
+    sql = re.sub(r'\s*,\s*', ', ', sql) # Normalize commas and surrounding spaces
+    return sql.strip().upper()
+
+# Setup logging for tests
+def setup_logging(level: str) -> logging.Logger:
+    logger = logging.getLogger('formatter')
+    logger.setLevel(level.upper())
+    if not logger.handlers:
+        handler = logging.StreamHandler()
+        formatter = logging.Formatter('%(levelname)s:%(name)s:%(message)s')
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+    return logger
+
+# Fixtures
+@pytest.fixture
+def sample_config():
+    return FormattingConfig(
+        sql_keywords={'SELECT', 'ORDER BY', 'JOIN', 'GROUP BY', 'FROM', 'WHERE'},
+        function_names={'execute_sql', 'run_query'},
+        sql_decorators={'@sql'},
+        single_line_threshold=80,
+        indent_width=4
+    )
+
+# Test 1: Basic Reformatting
+def test_format_sql_code_basic_reformatting(sample_config):
+    """
+    Test that basic SQL queries are reformatted with proper indentation and uppercase keywords.
+    """
+    sql = """
+    select col1, col2 from table where condition order by col1 desc
+    """
+    formatted = format_sql_code(sql, None, sample_config)
+    expected = "SELECT col1, col2 FROM table WHERE condition ORDER BY col1 DESC"
+    assert normalize_sql(expected) == normalize_sql(formatted)
+
+# Test 2: Malicious Input Handling
+def test_format_sql_code_malicious_input(sample_config):
+    """
+    Test that the formatter handles malicious SQL inputs without executing them.
+    Specifically, it should raise an error for multiple SQL statements.
+    """
+    sql = "SELECT * FROM users; DROP TABLE users;"
+    # The formatter should raise an error for multiple statements
+    with pytest.raises(SQLFormattingError):
+        format_sql_code(sql, None, sample_config)
+
+# Test 3: Escape Characters in Strings
+def test_format_sql_code_escape_characters(sample_config):
+    """
+    Test that escape characters in SQL strings are handled correctly.
+    """
+    # Correct SQL escaping uses two single quotes to escape
+    sql = "SELECT * FROM table WHERE name = 'O''Connor'"
+    formatted = format_sql_code(sql, None, sample_config)
+    expected = "SELECT * FROM table WHERE name = 'O''Connor'"
+    assert normalize_sql(expected) == normalize_sql(formatted)
+
+# Test 4: Special Characters in Identifiers
+def test_format_sql_code_special_characters(sample_config):
+    """
+    Test that SQL identifiers containing special characters are properly quoted.
+    """
+    sql = """
+    SELECT @column1, `#column2`, $column3
+    FROM table
+    WHERE condition = '@value'
+    """
+    # In MySQL, '#' denotes a comment, so '`#column2`' should be quoted to avoid being treated as a comment
+    formatted = format_sql_code(sql, "mysql", sample_config)
+    expected = "SELECT @column1, `#column2`, $column3 FROM `table` WHERE `condition` = '@value'"
+    assert normalize_sql(expected) == normalize_sql(formatted)
+
+# Test 5: Reserved Keywords as Identifiers
+def test_format_sql_code_reserved_keywords(sample_config):
+    """
+    Test that SQL reserved keywords are correctly quoted when used as identifiers.
+    """
+    sql = "SELECT `group`, `order` FROM `table` WHERE `select` > 10"
+    # Reserved keywords should be quoted to avoid parsing errors
+    formatted = format_sql_code(sql, "mysql", sample_config)
+    expected = "SELECT `group`, `order` FROM `table` WHERE `select` > 10"
+    assert normalize_sql(expected) == normalize_sql(formatted)
+
+# Test 6: Process Notebook with Various SQL Scenarios
+def test_process_notebook(tmp_path, sample_config):
+    """
+    Test processing a notebook containing a single SQL code cell.
+    """
+    # Create a sample notebook
+    nb = nbformat.v4.new_notebook()
+    nb.cells.append(nbformat.v4.new_code_cell("execute_sql('SELECT * FROM table')"))
+    notebook_path = tmp_path / "sample_notebook.ipynb"
+    nbformat.write(nb, notebook_path)
+
+    logger = setup_logging("DEBUG")
+    result = process_notebook(notebook_path, sample_config, None, logger)
+    assert isinstance(result, bool)
+    assert result is True  # Assuming processing succeeds
+
+    # Read the processed notebook and verify changes
+    nb_processed = nbformat.read(notebook_path, as_version=4)
+    code_cells = [cell for cell in nb_processed.cells if cell.cell_type == "code"]
+
+    # Verify first code cell
+    first_cell = code_cells[0]
+    expected = "execute_sql('SELECT * FROM table')"
+    assert normalize_sql(expected) == normalize_sql(first_cell.source.strip())
+
+# Test 7: Process Real-World Notebook with Complex SQL Queries
+def test_process_real_world_notebook(tmp_path, sample_config):
+    """
+    Integration test with a real-world-like notebook containing complex SQL queries.
+    """
+    # Create a more complex notebook
+    nb = nbformat.v4.new_notebook()
+    nb.cells.extend([
+        nbformat.v4.new_markdown_cell("# Real-World SQL Formatting Test"),
+        nbformat.v4.new_code_cell('''
+execute_sql("""
+SELECT a.col1, b.col2
+FROM table_a a
+JOIN table_b b ON a.id = b.a_id
+WHERE a.status = 'active'
+ORDER BY a.created_at DESC
+""")
+        '''),
+        nbformat.v4.new_code_cell('''
+%%sql
+SELECT
+    user_id,
+    COUNT(*) AS login_count
+FROM logins
+WHERE login_date > '2023-01-01'
+GROUP BY user_id
+ORDER BY login_count DESC
+        '''),
+    ])
+    notebook_path = tmp_path / "real_world_notebook.ipynb"
+    nbformat.write(nb, notebook_path)
+
+    logger = setup_logging("DEBUG")
+    result = process_notebook(notebook_path, sample_config, None, logger)
+    assert isinstance(result, bool)
+    assert result is True  # Assuming processing succeeds
+
+    # Read the processed notebook and verify changes
+    nb_processed = nbformat.read(notebook_path, as_version=4)
+    code_cells = [cell for cell in nb_processed.cells if cell.cell_type == "code"]
+
+    # Helper function to extract SQL from function calls using AST
+    def extract_sql_from_execute(cell_source: str) -> Optional[str]:
+        try:
+            tree = ast.parse(cell_source)
+            for node in ast.walk(tree):
+                if isinstance(node, ast.Call) and getattr(node.func, 'id', '') == 'execute_sql':
+                    # Assuming the first argument is the SQL code
+                    if node.args:
+                        arg = node.args[0]
+                        if isinstance(arg, (ast.Constant, ast.Constant)):
+                            return arg.value.strip()
+                        elif isinstance(arg, ast.JoinedStr):
+                            # Handle f-strings
+                            sql_parts = []
+                            for value in arg.values:
+                                if isinstance(value, (ast.Constant, ast.Constant)):
+                                    sql_parts.append(value.s if isinstance(value, ast.Constant) else value.value)
+                                else:
+                                    sql_parts.append("{expression}")
+                            return ''.join(sql_parts).strip()
+            return None
+        except Exception as e:
+            print(f"Error parsing cell source: {e}")
+            return None
+
+    # Helper function to extract SQL from magic commands
+    def extract_sql_from_magic(cell_source: str) -> Optional[str]:
+        match = re.match(r'%%sql\s*\n([\s\S]*)', cell_source, re.DOTALL | re.IGNORECASE)
+        if match:
+            return match.group(1).strip()
+        return None
+
+    # Verify first code cell (execute_sql)
+    first_cell = code_cells[0]
+    formatted_sql = extract_sql_from_execute(first_cell.source)
+    assert formatted_sql is not None, "SQL not found in execute_sql call."
+
+    expected = (
+        "SELECT a.col1, b.col2 FROM table_a AS a "
+        "JOIN table_b AS b ON a.id = b.a_id WHERE a.status = 'active' "
+        "ORDER BY a.created_at DESC"
+    )
+    assert normalize_sql(expected) == normalize_sql(formatted_sql)
+
+    # Verify second code cell (%%sql magic)
+    second_cell = code_cells[1]
+    formatted_sql_magic = extract_sql_from_magic(second_cell.source)
+    expected_magic = (
+        "SELECT user_id, COUNT(*) AS login_count FROM logins "
+        "WHERE login_date > '2023-01-01' GROUP BY user_id "
+        "ORDER BY login_count DESC"
+    )
+    assert normalize_sql(expected_magic) == normalize_sql(formatted_sql_magic)
+
+# Test 9: Logging Messages at Various Levels
+def test_logging_messages_various_levels(sample_config, caplog):
+    """
+    Test that logging messages are correctly emitted at different log levels.
+
+    Verifies that DEBUG messages are captured when the logger is set to DEBUG,
+    and not captured when set to INFO.
+    """
+    sql = "SELECT * FROM table"
+    logger = setup_logging("DEBUG")
+    with caplog.at_level(logging.DEBUG, logger="formatter"):
+        format_sql_code(sql, None, sample_config)
+        assert "Original SQL:" in caplog.text
+        assert "Formatted SQL:" in caplog.text
+
+    caplog.clear()  # Clear previous logs
+
+    logger = setup_logging("INFO")
+    with caplog.at_level(logging.INFO, logger="formatter"):
+        format_sql_code(sql, None, sample_config)
+        # DEBUG messages should not appear
+        assert "Original SQL:" not in caplog.text
+        assert "Formatted SQL:" not in caplog.text
+
+# Test 10: Subqueries Formatting
+def test_format_sql_code_with_subqueries(sample_config):
+    """
+    Test formatting SQL queries that contain subqueries.
+
+    Ensures that nested SELECT statements are formatted correctly.
+    """
+    sql = """
+    SELECT
+        a.id,
+        (SELECT COUNT(*) FROM orders o WHERE o.user_id = a.id) AS order_count
+    FROM users a
+    WHERE a.active = TRUE
+    ORDER BY order_count DESC
+    """
+    formatted = format_sql_code(sql, None, sample_config)
+    expected_subquery = "(SELECT COUNT(*) FROM orders AS o WHERE o.user_id = a.id) AS order_count"
+    assert normalize_sql(expected_subquery) in normalize_sql(formatted)
+
+# Test 11: Various Indentation Widths
+def test_format_sql_code_various_indentation(sample_config):
+    """
+    Test that the formatter applies different indentation widths correctly.
+
+    Ensures that the indent_width configuration option is respected.
+    """
+    # Change indent_width to 2
+    sample_config.indent_width = 2
+    sql = """
+    SELECT
+      column1,
+      column2
+    FROM table
+    WHERE condition
+    ORDER BY column1 DESC
+    """
+    formatted = format_sql_code(sql, None, sample_config)
+    expected = (
+        "SELECT\n"
+        "  column1,\n"
+        "  column2\n"
+        "FROM table\n"
+        "WHERE condition\n"
+        "ORDER BY column1 DESC"
+    )
+    assert normalize_sql(expected) == normalize_sql(formatted)
+
+# Test 12: Multiple Formatting Options
+def test_format_sql_code_multiple_options(sample_config):
+    """
+    Test that multiple formatting options work together correctly.
+
+    Ensures that both indent_width and single_line_threshold are honored.
+    """
+    sample_config.indent_width = 2
+    sample_config.single_line_threshold = 50
+    sql = "SELECT col1, col2 FROM table WHERE condition ORDER BY col1 DESC"
+    formatted = format_sql_code(sql, None, sample_config)
+    # Should be single line due to low threshold
+    expected = "SELECT col1, col2 FROM table WHERE condition ORDER BY col1 DESC"
+    assert normalize_sql(expected) == normalize_sql(formatted)
+
+# Test 13: Common Table Expressions (CTEs) Formatting
+def test_format_sql_code_with_ctes(sample_config):
+    """
+    Test that SQL queries with Common Table Expressions (CTEs) are formatted correctly.
+    """
+    sql = """
+    WITH recent_orders AS (
+        SELECT user_id, COUNT(*) AS order_count
+        FROM orders
+        WHERE order_date >= DATE_SUB(CURDATE(), INTERVAL 30 DAY)
+        GROUP BY user_id
+    ), top_customers AS (
+        SELECT u.id, u.name, ro.order_count
+        FROM users u
+        JOIN recent_orders ro ON u.id = ro.user_id
+        WHERE ro.order_count > 5
+    )
+    SELECT tc.id, tc.name, tc.order_count
+    FROM top_customers tc
+    ORDER BY tc.order_count DESC
+    """
+    formatted = format_sql_code(sql, "mysql", sample_config)
+    expected = (
+        "WITH recent_orders AS ("
+        "SELECT user_id, COUNT(*) AS order_count FROM orders "
+        "WHERE order_date >= DATE_SUB(CURDATE(), INTERVAL '30' DAY) GROUP BY user_id"
+        "), top_customers AS ("
+        "SELECT u.id, u.name, ro.order_count FROM users AS u "
+        "JOIN recent_orders AS ro ON u.id = ro.user_id WHERE ro.order_count > 5"
+        ") "
+        "SELECT tc.id, tc.name, tc.order_count FROM top_customers AS tc ORDER BY tc.order_count DESC"
+    )
+    assert normalize_sql(expected) == normalize_sql(formatted)
+
+# Test 14: Different SQL Dialects
+def test_format_sql_code_different_dialects(sample_config):
+    """
+    Test that SQL formatting respects different SQL dialects.
+    """
+    sql = 'SELECT * FROM "my_table" WHERE "status" = \'active\''
+    formatted_pg = format_sql_code(sql, "postgres", sample_config)
+    expected_pg = 'SELECT * FROM "my_table" WHERE "status" = \'active\''
+    assert normalize_sql(expected_pg) == normalize_sql(formatted_pg)
+
+    formatted_sqlite = format_sql_code(sql, "sqlite", sample_config)
+    expected_sqlite = 'SELECT * FROM "my_table" WHERE "status" = \'active\''
+    assert normalize_sql(expected_sqlite) == normalize_sql(formatted_sqlite)
+
+# Test 15: Window Functions Formatting
+def test_format_sql_code_with_window_functions(sample_config):
+    """
+    Test that SQL queries with window functions are formatted correctly.
+    """
+    sql = """
+    SELECT
+        user_id,
+        login_date,
+        COUNT(*) OVER (PARTITION BY user_id ORDER BY login_date) AS cumulative_logins
+    FROM logins
+    """
+    formatted = format_sql_code(sql, "mysql", sample_config)
+    expected = (
+        "SELECT user_id, login_date, COUNT(*) OVER (PARTITION BY user_id ORDER BY login_date) AS cumulative_logins FROM logins"
+    )
+    assert normalize_sql(expected) == normalize_sql(formatted)
+
+# Test 16: Placeholder Preservation
+def test_format_sql_code_with_placeholders(sample_config):
+    """
+    Test that SQL queries with placeholders are preserved correctly.
+    """
+    sql = "SELECT * FROM users WHERE id = %s AND status = ?"
+    formatted = format_sql_code(sql, "mysql", sample_config)
+    expected = "SELECT * FROM users WHERE id = %s AND status = ?"
+    assert normalize_sql(expected) == normalize_sql(formatted)
+
+# Test 17: Handling Comments
+def test_format_sql_code_preserve_comments(sample_config):
+    """
+    Test that SQL comments are preserved in the formatted output.
+    """
+    sql = """
+    -- This is a comment
+    SELECT * FROM users -- Inline comment
+    """
+    formatted = format_sql_code(sql, None, sample_config)
+    expected = """
+    /* This is a comment */
+    SELECT * FROM users /* Inline comment */
+    """
+    assert normalize_sql(expected) == normalize_sql(formatted)