We are currently solving the following issue within our repository. Here is the issue text:
--- BEGIN ISSUE ---
Incorrect error message or implementation for datetime formatting?
### Describe the bug

when starting a SQL query with timezone aware date times, you get an error message like:

`Supports only timezone aware datatype, got 2024-04-29 13:30:34.573187+00:00`

The SDK code involved is

```python
     39 if value.tzinfo is not None:
     40     print(type(value))
---> 41     raise TypeError(f"Supports only timezone aware datatype, got {value}. {type(value)}")
     43 return f"TIMESTAMP '{value.isoformat(sep=' ', timespec='milliseconds')}'"
```
Where it checks for the existence of timezone info. And enter the if clause, if there is one.

However the error message say it support _only_ timezone aware dates.

### How to Reproduce

``` python
import awswrangler as wr
from datetime import timezone, datetime

wr.athena.start_query_execution(
  database='ddd',
  sql=f"""DELETE FROM ddd.t
                WHERE event_date >= :start 
         """,
    params={
        "start": datetime.now(timezone.utc),
    })
``````


### Expected behavior

To either have an error message like: 

`Supports only timezone naive datatype, got 2024-04-29 13:30:34.573187+00:00`

or: 

to correctly format timetamps with timezone info.

### Your project

Private

### Screenshots

_No response_

### OS

Mac

### Python version

3.11

### AWS SDK for pandas version

seen on main branch and ('3.4.2')

### Additional context

_No response_

--- END ISSUE ---

Below are some code segments, each from a relevant file. One or more of these files may contain bugs.
--- BEGIN FILES ---
Path: `awswrangler/_sql_formatter.py`
Content:
```
1 """Formatting logic for SQL parameters."""
2 
3 from __future__ import annotations
4 
5 import datetime
6 import decimal
7 import re
8 from abc import ABC, abstractmethod
9 from typing import Any, Callable, Sequence
10 
11 from typing_extensions import Literal
12 
13 from awswrangler import exceptions
14 
15 _EngineTypeLiteral = Literal["presto", "hive", "partiql"]
16 
17 
18 class _Engine(ABC):
19     def __init__(self, engine_name: _EngineTypeLiteral) -> None:
20         self.engine_name = engine_name
21 
22     def format_null(self, value: None = None) -> str:
23         return "NULL"
24 
25     @abstractmethod
26     def format_string(self, value: str) -> str:
27         pass
28 
29     def format_bool(self, value: bool) -> str:
30         return str(value).upper()
31 
32     def format_integer(self, value: int) -> str:
33         return str(value)
34 
35     def format_float(self, value: float) -> str:
36         return f"{value:f}"
37 
38     def format_decimal(self, value: decimal.Decimal) -> str:
39         return f"DECIMAL '{value:f}'"
40 
41     def format_timestamp(self, value: datetime.datetime) -> str:
42         if value.tzinfo is not None:
43             raise TypeError(f"Supports only timezone aware datatype, got {value}.")
44 
45         return f"TIMESTAMP '{value.isoformat(sep=' ', timespec='milliseconds')}'"
46 
47     def format_date(self, value: datetime.date) -> str:
48         return f"DATE '{value.isoformat()}'"
49 
50     def format_array(self, value: Sequence[Any]) -> str:
51         return f"ARRAY [{', '.join(map(self.format, value))}]"
52 
53     def format_dict(self, value: dict[Any, Any]) -> str:
54         if not value:
55             return "MAP()"
56 
57         map_keys = list(value.keys())
58         key_type = type(map_keys[0])
59         for key in map_keys:
60             if key is None:
61                 raise TypeError("Map key cannot be null.")
62             if not isinstance(key, key_type):
63                 raise TypeError("All Map key elements must be the same type.")
64 
65         map_values = list(value.values())
66         return (
67             f"MAP(ARRAY [{', '.join(map(self.format, map_keys))}], ARRAY [{', '.join(map(self.format, map_values))}])"
68         )
69 
70     def format(self, data: Any) -> str:
71         formats_dict: dict[type[Any], Callable[[Any], str]] = {
72             bool: self.format_bool,
73             str: self.format_string,
74             int: self.format_integer,
75             datetime.datetime: self.format_timestamp,
76             datetime.date: self.format_date,
77             decimal.Decimal: self.format_decimal,
78             float: self.format_float,
79             list: self.format_array,
80             tuple: self.format_array,
81             set: self.format_array,
82             dict: self.format_dict,
83         }
84 
85         if data is None:
86             return self.format_null()
87 
88         for python_type, format_func in formats_dict.items():
89             if isinstance(data, python_type):
90                 return format_func(data)
91 
92         raise TypeError(f"Unsupported type {type(data)} in parameter.")
93 
94 
95 class _PrestoEngine(_Engine):
96     def __init__(self) -> None:
97         super().__init__("presto")
98 
99     def format_string(self, value: str) -> str:
100         return f"""'{value.replace("'", "''")}'"""
101 
102 
103 class _HiveEngine(_Engine):
104     def __init__(self) -> None:
105         super().__init__("hive")
106 
107     def format_string(self, value: str) -> str:
108         return "'{}'".format(
109             value.replace("\\", "\\\\")
110             .replace("'", "\\'")
111             .replace("\r", "\\r")
112             .replace("\n", "\\n")
113             .replace("\t", "\\t")
114         )
115 
116 
117 class _PartiQLEngine(_Engine):
118     def __init__(self) -> None:
119         super().__init__("partiql")
120 
121     def format_null(self, value: None = None) -> str:
122         return "null"
123 
124     def format_string(self, value: str) -> str:
125         return f"""'{value.replace("'", "''")}'"""
126 
127     def format_bool(self, value: bool) -> str:
128         return "1" if value else "0"
129 
130     def format_decimal(self, value: decimal.Decimal) -> str:
131         return f"'{value}'"
132 
133     def format_timestamp(self, value: datetime.datetime) -> str:
134         if value.tzinfo is not None:
135             raise TypeError(f"Supports only timezone aware datatype, got {value}.")
136 
137         return f"'{value.isoformat()}'"
138 
139     def format_date(self, value: datetime.date) -> str:
140         return f"'{value.isoformat()}'"
141 
142     def format_array(self, value: Sequence[Any]) -> str:
143         raise NotImplementedError(f"format_array not implemented for engine={self.engine_name}.")
144 
145     def format_dict(self, value: dict[Any, Any]) -> str:
146         raise NotImplementedError(f"format_dict not implemented for engine={self.engine_name}.")
147 
148 
149 def _format_parameters(params: dict[str, Any], engine: _Engine) -> dict[str, Any]:
150     processed_params = {}
151 
152     for k, v in params.items():
153         processed_params[k] = engine.format(data=v)
154 
155     return processed_params
156 
157 
158 _PATTERN = re.compile(r":([A-Za-z0-9_]+)(?![A-Za-z0-9_])")
159 
160 
161 def _create_engine(engine_type: _EngineTypeLiteral) -> _Engine:
162     if engine_type == "hive":
163         return _HiveEngine()
164 
165     if engine_type == "presto":
166         return _PrestoEngine()
167 
168     if engine_type == "partiql":
169         return _PartiQLEngine()
170 
171     raise exceptions.InvalidArgumentValue(f"Unknown engine type: {engine_type}")
172 
173 
174 def _process_sql_params(sql: str, params: dict[str, Any] | None, engine_type: _EngineTypeLiteral = "presto") -> str:
175     if params is None:
176         params = {}
177 
178     engine = _create_engine(engine_type)
179     processed_params = _format_parameters(params, engine=engine)
180 
181     def replace(match: re.Match) -> str:  # type: ignore[type-arg]
182         key = match.group(1)
183 
184         if key not in processed_params:
185             # do not replace anything if the parameter is not provided
186             return str(match.group(0))
187 
188         return str(processed_params[key])
189 
190     sql = _PATTERN.sub(replace, sql)
191 
192     return sql
193
```
--- END FILES ---

Please first localize the bug based on the issue statement, and then generate a patch according to the `git diff` format fenced by three backticks.

Here is an example:

```diff
diff --git a/examples/server_async.py b/examples/server_async.py
--- a/examples/server_async.py
+++ b/examples/server_async.py
@@ -313,4 +313,4 @@
 
 
 if __name__ == "__main__":
-    asyncio.run(run_async_server("."), debug=True)
+    asyncio.run(run_async_server(), debug=True)
diff --git a/examples/server_sync.py b/examples/server_sync.py
--- a/examples/server_sync.py
+++ b/examples/server_sync.py
@@ -313,5 +313,5 @@
 
 
 if __name__ == "__main__":
-    server = run_sync_server(".")
+    server = run_sync_server()
     server.shutdown()

```

diff --git a/awswrangler/_sql_formatter.py b/awswrangler/_sql_formatter.py
--- a/awswrangler/_sql_formatter.py
+++ b/awswrangler/_sql_formatter.py
@@ -40,7 +40,7 @@
 
     def format_timestamp(self, value: datetime.datetime) -> str:
         if value.tzinfo is not None:
-            raise TypeError(f"Supports only timezone aware datatype, got {value}.")
+            raise TypeError(f"Supports only timezone naive datatype, got {value}.")
 
         return f"TIMESTAMP '{value.isoformat(sep=' ', timespec='milliseconds')}'"
 
@@ -132,7 +132,7 @@
 
     def format_timestamp(self, value: datetime.datetime) -> str:
         if value.tzinfo is not None:
-            raise TypeError(f"Supports only timezone aware datatype, got {value}.")
+            raise TypeError(f"Supports only timezone naive datatype, got {value}.")
 
         return f"'{value.isoformat()}'"

{"golden_diff": "diff --git a/awswrangler/_sql_formatter.py b/awswrangler/_sql_formatter.py\n--- a/awswrangler/_sql_formatter.py\n+++ b/awswrangler/_sql_formatter.py\n@@ -40,7 +40,7 @@\n \n     def format_timestamp(self, value: datetime.datetime) -> str:\n         if value.tzinfo is not None:\n-            raise TypeError(f\"Supports only timezone aware datatype, got {value}.\")\n+            raise TypeError(f\"Supports only timezone naive datatype, got {value}.\")\n \n         return f\"TIMESTAMP '{value.isoformat(sep=' ', timespec='milliseconds')}'\"\n \n@@ -132,7 +132,7 @@\n \n     def format_timestamp(self, value: datetime.datetime) -> str:\n         if value.tzinfo is not None:\n-            raise TypeError(f\"Supports only timezone aware datatype, got {value}.\")\n+            raise TypeError(f\"Supports only timezone naive datatype, got {value}.\")\n \n         return f\"'{value.isoformat()}'\"\n", "issue": "Incorrect error message or implementation for datetime formatting?\n### Describe the bug\n\nwhen starting a SQL query with timezone aware date times, you get an error message like:\r\n\r\n`Supports only timezone aware datatype, got 2024-04-29 13:30:34.573187+00:00`\r\n\r\nThe SDK code involved is\r\n\r\n```python\r\n     39 if value.tzinfo is not None:\r\n     40     print(type(value))\r\n---> 41     raise TypeError(f\"Supports only timezone aware datatype, got {value}. {type(value)}\")\r\n     43 return f\"TIMESTAMP '{value.isoformat(sep=' ', timespec='milliseconds')}'\"\r\n```\r\nWhere it checks for the existence of timezone info. And enter the if clause, if there is one.\r\n\r\nHowever the error message say it support _only_ timezone aware dates.\n\n### How to Reproduce\n\n``` python\r\nimport awswrangler as wr\r\nfrom datetime import timezone, datetime\r\n\r\nwr.athena.start_query_execution(\r\n  database='ddd',\r\n  sql=f\"\"\"DELETE FROM ddd.t\r\n                WHERE event_date >= :start \r\n         \"\"\",\r\n    params={\r\n        \"start\": datetime.now(timezone.utc),\r\n    })\r\n``````\r\n\n\n### Expected behavior\n\nTo either have an error message like: \r\n\r\n`Supports only timezone naive datatype, got 2024-04-29 13:30:34.573187+00:00`\r\n\r\nor: \r\n\r\nto correctly format timetamps with timezone info.\n\n### Your project\n\nPrivate\n\n### Screenshots\n\n_No response_\n\n### OS\n\nMac\n\n### Python version\n\n3.11\n\n### AWS SDK for pandas version\n\nseen on main branch and ('3.4.2')\n\n### Additional context\n\n_No response_\n", "before_files": [{"content": "\"\"\"Formatting logic for SQL parameters.\"\"\"\n\nfrom __future__ import annotations\n\nimport datetime\nimport decimal\nimport re\nfrom abc import ABC, abstractmethod\nfrom typing import Any, Callable, Sequence\n\nfrom typing_extensions import Literal\n\nfrom awswrangler import exceptions\n\n_EngineTypeLiteral = Literal[\"presto\", \"hive\", \"partiql\"]\n\n\nclass _Engine(ABC):\n    def __init__(self, engine_name: _EngineTypeLiteral) -> None:\n        self.engine_name = engine_name\n\n    def format_null(self, value: None = None) -> str:\n        return \"NULL\"\n\n    @abstractmethod\n    def format_string(self, value: str) -> str:\n        pass\n\n    def format_bool(self, value: bool) -> str:\n        return str(value).upper()\n\n    def format_integer(self, value: int) -> str:\n        return str(value)\n\n    def format_float(self, value: float) -> str:\n        return f\"{value:f}\"\n\n    def format_decimal(self, value: decimal.Decimal) -> str:\n        return f\"DECIMAL '{value:f}'\"\n\n    def format_timestamp(self, value: datetime.datetime) -> str:\n        if value.tzinfo is not None:\n            raise TypeError(f\"Supports only timezone aware datatype, got {value}.\")\n\n        return f\"TIMESTAMP '{value.isoformat(sep=' ', timespec='milliseconds')}'\"\n\n    def format_date(self, value: datetime.date) -> str:\n        return f\"DATE '{value.isoformat()}'\"\n\n    def format_array(self, value: Sequence[Any]) -> str:\n        return f\"ARRAY [{', '.join(map(self.format, value))}]\"\n\n    def format_dict(self, value: dict[Any, Any]) -> str:\n        if not value:\n            return \"MAP()\"\n\n        map_keys = list(value.keys())\n        key_type = type(map_keys[0])\n        for key in map_keys:\n            if key is None:\n                raise TypeError(\"Map key cannot be null.\")\n            if not isinstance(key, key_type):\n                raise TypeError(\"All Map key elements must be the same type.\")\n\n        map_values = list(value.values())\n        return (\n            f\"MAP(ARRAY [{', '.join(map(self.format, map_keys))}], ARRAY [{', '.join(map(self.format, map_values))}])\"\n        )\n\n    def format(self, data: Any) -> str:\n        formats_dict: dict[type[Any], Callable[[Any], str]] = {\n            bool: self.format_bool,\n            str: self.format_string,\n            int: self.format_integer,\n            datetime.datetime: self.format_timestamp,\n            datetime.date: self.format_date,\n            decimal.Decimal: self.format_decimal,\n            float: self.format_float,\n            list: self.format_array,\n            tuple: self.format_array,\n            set: self.format_array,\n            dict: self.format_dict,\n        }\n\n        if data is None:\n            return self.format_null()\n\n        for python_type, format_func in formats_dict.items():\n            if isinstance(data, python_type):\n                return format_func(data)\n\n        raise TypeError(f\"Unsupported type {type(data)} in parameter.\")\n\n\nclass _PrestoEngine(_Engine):\n    def __init__(self) -> None:\n        super().__init__(\"presto\")\n\n    def format_string(self, value: str) -> str:\n        return f\"\"\"'{value.replace(\"'\", \"''\")}'\"\"\"\n\n\nclass _HiveEngine(_Engine):\n    def __init__(self) -> None:\n        super().__init__(\"hive\")\n\n    def format_string(self, value: str) -> str:\n        return \"'{}'\".format(\n            value.replace(\"\\\\\", \"\\\\\\\\\")\n            .replace(\"'\", \"\\\\'\")\n            .replace(\"\\r\", \"\\\\r\")\n            .replace(\"\\n\", \"\\\\n\")\n            .replace(\"\\t\", \"\\\\t\")\n        )\n\n\nclass _PartiQLEngine(_Engine):\n    def __init__(self) -> None:\n        super().__init__(\"partiql\")\n\n    def format_null(self, value: None = None) -> str:\n        return \"null\"\n\n    def format_string(self, value: str) -> str:\n        return f\"\"\"'{value.replace(\"'\", \"''\")}'\"\"\"\n\n    def format_bool(self, value: bool) -> str:\n        return \"1\" if value else \"0\"\n\n    def format_decimal(self, value: decimal.Decimal) -> str:\n        return f\"'{value}'\"\n\n    def format_timestamp(self, value: datetime.datetime) -> str:\n        if value.tzinfo is not None:\n            raise TypeError(f\"Supports only timezone aware datatype, got {value}.\")\n\n        return f\"'{value.isoformat()}'\"\n\n    def format_date(self, value: datetime.date) -> str:\n        return f\"'{value.isoformat()}'\"\n\n    def format_array(self, value: Sequence[Any]) -> str:\n        raise NotImplementedError(f\"format_array not implemented for engine={self.engine_name}.\")\n\n    def format_dict(self, value: dict[Any, Any]) -> str:\n        raise NotImplementedError(f\"format_dict not implemented for engine={self.engine_name}.\")\n\n\ndef _format_parameters(params: dict[str, Any], engine: _Engine) -> dict[str, Any]:\n    processed_params = {}\n\n    for k, v in params.items():\n        processed_params[k] = engine.format(data=v)\n\n    return processed_params\n\n\n_PATTERN = re.compile(r\":([A-Za-z0-9_]+)(?![A-Za-z0-9_])\")\n\n\ndef _create_engine(engine_type: _EngineTypeLiteral) -> _Engine:\n    if engine_type == \"hive\":\n        return _HiveEngine()\n\n    if engine_type == \"presto\":\n        return _PrestoEngine()\n\n    if engine_type == \"partiql\":\n        return _PartiQLEngine()\n\n    raise exceptions.InvalidArgumentValue(f\"Unknown engine type: {engine_type}\")\n\n\ndef _process_sql_params(sql: str, params: dict[str, Any] | None, engine_type: _EngineTypeLiteral = \"presto\") -> str:\n    if params is None:\n        params = {}\n\n    engine = _create_engine(engine_type)\n    processed_params = _format_parameters(params, engine=engine)\n\n    def replace(match: re.Match) -> str:  # type: ignore[type-arg]\n        key = match.group(1)\n\n        if key not in processed_params:\n            # do not replace anything if the parameter is not provided\n            return str(match.group(0))\n\n        return str(processed_params[key])\n\n    sql = _PATTERN.sub(replace, sql)\n\n    return sql\n", "path": "awswrangler/_sql_formatter.py"}], "after_files": [{"content": "\"\"\"Formatting logic for SQL parameters.\"\"\"\n\nfrom __future__ import annotations\n\nimport datetime\nimport decimal\nimport re\nfrom abc import ABC, abstractmethod\nfrom typing import Any, Callable, Sequence\n\nfrom typing_extensions import Literal\n\nfrom awswrangler import exceptions\n\n_EngineTypeLiteral = Literal[\"presto\", \"hive\", \"partiql\"]\n\n\nclass _Engine(ABC):\n    def __init__(self, engine_name: _EngineTypeLiteral) -> None:\n        self.engine_name = engine_name\n\n    def format_null(self, value: None = None) -> str:\n        return \"NULL\"\n\n    @abstractmethod\n    def format_string(self, value: str) -> str:\n        pass\n\n    def format_bool(self, value: bool) -> str:\n        return str(value).upper()\n\n    def format_integer(self, value: int) -> str:\n        return str(value)\n\n    def format_float(self, value: float) -> str:\n        return f\"{value:f}\"\n\n    def format_decimal(self, value: decimal.Decimal) -> str:\n        return f\"DECIMAL '{value:f}'\"\n\n    def format_timestamp(self, value: datetime.datetime) -> str:\n        if value.tzinfo is not None:\n            raise TypeError(f\"Supports only timezone naive datatype, got {value}.\")\n\n        return f\"TIMESTAMP '{value.isoformat(sep=' ', timespec='milliseconds')}'\"\n\n    def format_date(self, value: datetime.date) -> str:\n        return f\"DATE '{value.isoformat()}'\"\n\n    def format_array(self, value: Sequence[Any]) -> str:\n        return f\"ARRAY [{', '.join(map(self.format, value))}]\"\n\n    def format_dict(self, value: dict[Any, Any]) -> str:\n        if not value:\n            return \"MAP()\"\n\n        map_keys = list(value.keys())\n        key_type = type(map_keys[0])\n        for key in map_keys:\n            if key is None:\n                raise TypeError(\"Map key cannot be null.\")\n            if not isinstance(key, key_type):\n                raise TypeError(\"All Map key elements must be the same type.\")\n\n        map_values = list(value.values())\n        return (\n            f\"MAP(ARRAY [{', '.join(map(self.format, map_keys))}], ARRAY [{', '.join(map(self.format, map_values))}])\"\n        )\n\n    def format(self, data: Any) -> str:\n        formats_dict: dict[type[Any], Callable[[Any], str]] = {\n            bool: self.format_bool,\n            str: self.format_string,\n            int: self.format_integer,\n            datetime.datetime: self.format_timestamp,\n            datetime.date: self.format_date,\n            decimal.Decimal: self.format_decimal,\n            float: self.format_float,\n            list: self.format_array,\n            tuple: self.format_array,\n            set: self.format_array,\n            dict: self.format_dict,\n        }\n\n        if data is None:\n            return self.format_null()\n\n        for python_type, format_func in formats_dict.items():\n            if isinstance(data, python_type):\n                return format_func(data)\n\n        raise TypeError(f\"Unsupported type {type(data)} in parameter.\")\n\n\nclass _PrestoEngine(_Engine):\n    def __init__(self) -> None:\n        super().__init__(\"presto\")\n\n    def format_string(self, value: str) -> str:\n        return f\"\"\"'{value.replace(\"'\", \"''\")}'\"\"\"\n\n\nclass _HiveEngine(_Engine):\n    def __init__(self) -> None:\n        super().__init__(\"hive\")\n\n    def format_string(self, value: str) -> str:\n        return \"'{}'\".format(\n            value.replace(\"\\\\\", \"\\\\\\\\\")\n            .replace(\"'\", \"\\\\'\")\n            .replace(\"\\r\", \"\\\\r\")\n            .replace(\"\\n\", \"\\\\n\")\n            .replace(\"\\t\", \"\\\\t\")\n        )\n\n\nclass _PartiQLEngine(_Engine):\n    def __init__(self) -> None:\n        super().__init__(\"partiql\")\n\n    def format_null(self, value: None = None) -> str:\n        return \"null\"\n\n    def format_string(self, value: str) -> str:\n        return f\"\"\"'{value.replace(\"'\", \"''\")}'\"\"\"\n\n    def format_bool(self, value: bool) -> str:\n        return \"1\" if value else \"0\"\n\n    def format_decimal(self, value: decimal.Decimal) -> str:\n        return f\"'{value}'\"\n\n    def format_timestamp(self, value: datetime.datetime) -> str:\n        if value.tzinfo is not None:\n            raise TypeError(f\"Supports only timezone naive datatype, got {value}.\")\n\n        return f\"'{value.isoformat()}'\"\n\n    def format_date(self, value: datetime.date) -> str:\n        return f\"'{value.isoformat()}'\"\n\n    def format_array(self, value: Sequence[Any]) -> str:\n        raise NotImplementedError(f\"format_array not implemented for engine={self.engine_name}.\")\n\n    def format_dict(self, value: dict[Any, Any]) -> str:\n        raise NotImplementedError(f\"format_dict not implemented for engine={self.engine_name}.\")\n\n\ndef _format_parameters(params: dict[str, Any], engine: _Engine) -> dict[str, Any]:\n    processed_params = {}\n\n    for k, v in params.items():\n        processed_params[k] = engine.format(data=v)\n\n    return processed_params\n\n\n_PATTERN = re.compile(r\":([A-Za-z0-9_]+)(?![A-Za-z0-9_])\")\n\n\ndef _create_engine(engine_type: _EngineTypeLiteral) -> _Engine:\n    if engine_type == \"hive\":\n        return _HiveEngine()\n\n    if engine_type == \"presto\":\n        return _PrestoEngine()\n\n    if engine_type == \"partiql\":\n        return _PartiQLEngine()\n\n    raise exceptions.InvalidArgumentValue(f\"Unknown engine type: {engine_type}\")\n\n\ndef _process_sql_params(sql: str, params: dict[str, Any] | None, engine_type: _EngineTypeLiteral = \"presto\") -> str:\n    if params is None:\n        params = {}\n\n    engine = _create_engine(engine_type)\n    processed_params = _format_parameters(params, engine=engine)\n\n    def replace(match: re.Match) -> str:  # type: ignore[type-arg]\n        key = match.group(1)\n\n        if key not in processed_params:\n            # do not replace anything if the parameter is not provided\n            return str(match.group(0))\n\n        return str(processed_params[key])\n\n    sql = _PATTERN.sub(replace, sql)\n\n    return sql\n", "path": "awswrangler/_sql_formatter.py"}]}