TestDataX 0.1.3__tar.gz → 0.2.1__tar.gz

{testdatax-0.1.3 → testdatax-0.2.1}/PKG-INFO

@@ -1,8 +1,9 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: TestDataX
-Version: 0.1.3
+Version: 0.2.1
 Summary: A flexible test data generation toolkit
 License: MIT
+License-File: LICENSE
 Author: JamesPBrett
 Requires-Python: >=3.11,<4.0
 Classifier: License :: OSI Approved :: MIT License
@@ -10,10 +11,10 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: faker (>=33.1.0,<34.0.0)
 Requires-Dist: mimesis (>=18.0.0,<19.0.0)
 Requires-Dist: mysql-connector-python (>=9.1.0,<10.0.0)
-Requires-Dist: orjson (>=3.10.12,<4.0.0)
 Requires-Dist: pandas (>=2.2.3,<3.0.0)
 Requires-Dist: pyarrow (>=18.1.0,<19.0.0)
 Requires-Dist: pydantic (>=2.10.4,<3.0.0)
@@ -22,8 +23,6 @@ Description-Content-Type: text/markdown
 
 # TestDataX
 
-# TestDataX
-
 ![Build Status](https://github.com/JamesPBrett/testdatax/actions/workflows/publish.yml/badge.svg)
 [![codecov](https://codecov.io/gh/JamesPBrett/testdatax/branch/main/graph/badge.svg?token=6VX62CI6U9)](https://codecov.io/gh/JamesPBrett/testdatax)
 ![Python Version](https://img.shields.io/badge/python-3.11%2B-blue)
@@ -42,7 +41,7 @@ pip install testdatax
 
 # Generate sample data
 testdatax --rows 1000 --format json --output data.json
-
+```
 
 ## Features
 
@@ -118,7 +117,7 @@ testdatax -o mstest.sql -f mssql -r 1000
 
 Generate Oracle with default row count (1000), table_name as 'oracle':
 ```bash
-datagen -o oracle.sql -f oracle -r 1000
+testdatax -o oracle.sql -f oracle -r 1000
 ```
 
 Each command consists of:
@@ -224,6 +223,11 @@ The schema file defines the structure and constraints of your generated data. Ea
 }
 ```
 
+> **Note:** `start_date`/`end_date` bound the generated range (inclusive).
+> `format` applies a `strftime` pattern to date/datetime values in the **CSV and
+> JSON** outputs only; the SQL, Parquet and ORC exporters keep native date types
+> and ignore `format`.
+
 #### Enum Fields
 ```json
 {

{testdatax-0.1.3 → testdatax-0.2.1}/README.md

@@ -1,7 +1,5 @@
 # TestDataX
 
-# TestDataX
-
 ![Build Status](https://github.com/JamesPBrett/testdatax/actions/workflows/publish.yml/badge.svg)
 [![codecov](https://codecov.io/gh/JamesPBrett/testdatax/branch/main/graph/badge.svg?token=6VX62CI6U9)](https://codecov.io/gh/JamesPBrett/testdatax)
 ![Python Version](https://img.shields.io/badge/python-3.11%2B-blue)
@@ -20,7 +18,7 @@ pip install testdatax
 
 # Generate sample data
 testdatax --rows 1000 --format json --output data.json
-
+```
 
 ## Features
 
@@ -96,7 +94,7 @@ testdatax -o mstest.sql -f mssql -r 1000
 
 Generate Oracle with default row count (1000), table_name as 'oracle':
 ```bash
-datagen -o oracle.sql -f oracle -r 1000
+testdatax -o oracle.sql -f oracle -r 1000
 ```
 
 Each command consists of:
@@ -202,6 +200,11 @@ The schema file defines the structure and constraints of your generated data. Ea
 }
 ```
 
+> **Note:** `start_date`/`end_date` bound the generated range (inclusive).
+> `format` applies a `strftime` pattern to date/datetime values in the **CSV and
+> JSON** outputs only; the SQL, Parquet and ORC exporters keep native date types
+> and ignore `format`.
+
 #### Enum Fields
 ```json
 {

{testdatax-0.1.3 → testdatax-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "TestDataX"
-version = "0.1.3"
+version = "0.2.1"
 description = "A flexible test data generation toolkit"
 authors = ["JamesPBrett"]
 license = "MIT"
@@ -12,7 +12,6 @@ python = "^3.11"
 typer = "^0.15.1"
 faker = "^33.1.0"
 pydantic = "^2.10.4"
-orjson = "^3.10.12"
 pyarrow = "^18.1.0"
 pandas = "^2.2.3"
 mysql-connector-python = "^9.1.0"
@@ -39,13 +38,11 @@ types-psutil = "^6.1.0.20241221"
 commitizen = "^3.13.0"
 python-semantic-release = "^9.17.0"
 
-[build-system]
-requires = ["poetry-core"]
-build-backend = "poetry.core.masonry.api"
 
 [tool.poetry.scripts]
 testdatax = "src.cli:app"
 
+
 [tool.ruff]
 # Same as Black
 line-length = 88
@@ -85,6 +82,7 @@ exclude = [
 [tool.ruff.lint.isort]
 known-first-party = ["src"]
 
+
 [tool.black]
 line-length = 88
 target-version = ['py311']
@@ -128,6 +126,7 @@ ignore_missing_imports = true
 module = "src.providers.mimesis_provider"
 warn_return_any = false
 
+
 [tool.coverage.run]
 source = ["src"]
 branch = true
@@ -141,15 +140,17 @@ exclude_lines = [
     "pass",
 ]
 
+
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 python_files = ["test_*.py"]
 python_classes = ["Test*"]
 python_functions = ["test_*"]
 
+
 [tool.commitizen]
 name = "cz_conventional_commits"
-version = "0.1.0"
+version = "0.1.3"
 tag_format = "v$version"
 version_files = [
     "src/__init__.py:__version__",
@@ -223,3 +224,9 @@ allowed_tags = [
     "chore",    # Maintenance tasks
     "refactor", # Code changes without fixing bugs or adding features
 ]
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+

{testdatax-0.1.3 → testdatax-0.2.1}/src/__init__.py

@@ -1,6 +1,6 @@
 """TestDataX package initialization."""
 
-__version__ = "0.1.3"
+__version__ = "0.2.1"
 
 from src.cli import app  # noqa
 

{testdatax-0.1.3 → testdatax-0.2.1}/src/cli.py

@@ -102,16 +102,30 @@ def generate(
                             f"{min_value}, {max_value}"
                         )
 
+                # Accept "precision" as an alias for "right_digits"; use an
+                # explicit None check so an intentional 0 is not dropped.
+                right_digits = field_def.get("right_digits")
+                if right_digits is None:
+                    right_digits = field_def.get("precision")
+
                 field_schema = FieldSchema(
                     name=name,
                     type=field_type,
                     enum_values=field_def.get("values"),
                     min_value=min_value,
                     max_value=max_value,
-                    right_digits=field_def.get("right_digits"),
+                    right_digits=right_digits,
                     value_provider=field_def.get("provider_field")
                     or field_def.get("faker"),
                     pattern=field_def.get("pattern"),
+                    nullable=field_def.get("nullable", False),
+                    unique=field_def.get("unique", False),
+                    weights=field_def.get("weights"),
+                    min_length=field_def.get("min_length"),
+                    max_length=field_def.get("max_length"),
+                    start_date=field_def.get("start_date"),
+                    end_date=field_def.get("end_date"),
+                    format=field_def.get("format"),
                 )
                 fields.append(field_schema.model_dump())
             else:
@@ -163,9 +177,10 @@ def generate(
         raise typer.Exit(code=1) from e
     except Exception as e:
         typer.echo(f"Error: {str(e)}", err=True)
-        typer.echo(f"Exception type: {type(e).__name__}", err=True)
-        typer.echo(f"Exception args: {e.args}", err=True)
-        typer.echo(f"Traceback: {traceback.format_exc()}", err=True)
+        if debug:
+            typer.echo(f"Exception type: {type(e).__name__}", err=True)
+            typer.echo(f"Exception args: {e.args}", err=True)
+            typer.echo(f"Traceback: {traceback.format_exc()}", err=True)
         raise typer.Exit(code=1) from e
 
 

{testdatax-0.1.3 → testdatax-0.2.1}/src/exporters/csv_exporter.py

@@ -7,7 +7,7 @@ import pandas as pd
 from .base_exporter import BaseExporter
 from .utils.chunker import DataChunker
 from .utils.constants import CHUNK_SIZE_CSV
-from .utils.formatters import CSVFormatter
+from .utils.formatters import CSVFormatter, extract_formats
 
 logger = logging.getLogger(__name__)
 
@@ -76,11 +76,12 @@ class CsvExporter(BaseExporter):
             else:
                 fieldnames = list(data[0].keys())
 
+            formats = extract_formats(schema)
             first_chunk = True
-            formatted_rows = []
             for chunk in self.chunker.chunk_data(data):
-                formatted_chunk = [self.formatter.format_row(row) for row in chunk]
-                formatted_rows.extend(formatted_chunk)
+                formatted_chunk = [
+                    self.formatter.format_row(row, formats) for row in chunk
+                ]
                 df = pd.DataFrame(formatted_chunk, columns=fieldnames)
 
                 # Write the data to CSV in chunks

{testdatax-0.1.3 → testdatax-0.2.1}/src/exporters/json_exporter.py

@@ -5,7 +5,7 @@ from typing import Any
 from .base_exporter import BaseExporter
 from .utils.chunker import DataChunker
 from .utils.constants import CHUNK_SIZE_JSON
-from .utils.formatters import JSONFormatter
+from .utils.formatters import JSONFormatter, extract_formats
 
 logger = logging.getLogger(__name__)
 
@@ -62,16 +62,23 @@ class JsonExporter(BaseExporter):
                         raise ValueError(
                             f"Field '{field}' in schema is not present in data."
                         )
-            # Format the data and write it in chunks to the output file
-            all_formatted_rows = []
-            for chunk in self.chunker.chunk_data(data):
-                formatted_chunk = [self.formatter.format_row(row) for row in chunk]
-                all_formatted_rows.extend(formatted_chunk)
 
-            # Write the complete file with proper formatting using json.dumps
+            # Stream a valid JSON array to disk one chunk at a time so the whole
+            # dataset is never held in memory at once.
+            formats = extract_formats(schema)
             with open(output_path, "w", encoding="utf-8") as f:
-                json_str = json.dumps(all_formatted_rows, indent=4)
-                f.write(json_str)
+                f.write("[")
+                first = True
+                for chunk in self.chunker.chunk_data(data):
+                    for row in chunk:
+                        formatted = self.formatter.format_row(row, formats)
+                        block = json.dumps(formatted, indent=4)
+                        indented = "\n".join(
+                            "    " + line for line in block.splitlines()
+                        )
+                        f.write(("\n" if first else ",\n") + indented)
+                        first = False
+                f.write("\n]" if not first else "]")
 
             logger.info(f"Successfully exported {len(data)} rows to {output_path}.")
 

{testdatax-0.1.3 → testdatax-0.2.1}/src/exporters/mssql_exporter.py

@@ -1,10 +1,12 @@
 import decimal
 from datetime import date, datetime
+from pathlib import Path
 from typing import Any
 from uuid import UUID
 
 from .base_exporter import BaseExporter
 from .utils.constants import DEFAULT_SCHEMA
+from .utils.sql import escape_ansi_quotes, quote_mssql_ident
 
 MSSQL_TYPE_MAPPING = {
     "string": "NVARCHAR(255)",  # Unicode string support
@@ -25,6 +27,16 @@ MSSQL_TYPE_MAPPING = {
 class MssqlExporter(BaseExporter):
     """Exports data to MSSQL compatible SQL file."""
 
+    @staticmethod
+    def _escape(value: str) -> str:
+        """Escape a string for a T-SQL single-quoted literal (quote doubling)."""
+        return escape_ansi_quotes(value)
+
+    @staticmethod
+    def _quote_ident(name: str) -> str:
+        """Quote a T-SQL identifier (table or column name) with brackets."""
+        return quote_mssql_ident(name)
+
     def _format_value(
         self,
         value: (
@@ -69,7 +81,7 @@ class MssqlExporter(BaseExporter):
         if value is None:
             return "NULL"
         elif isinstance(value, (str | UUID)):
-            return "'" + str(value).replace("'", "\\'").replace("\n", "\\n") + "'"
+            return "'" + self._escape(str(value)) + "'"
         elif isinstance(value, (datetime | date)):
             return f"'{value.isoformat()}'"
         elif isinstance(value, bool):
@@ -141,14 +153,16 @@ class MssqlExporter(BaseExporter):
                 and field_def.get("type") == "enum"
                 and "values" in field_def
             ):
-                values = "','".join(field_def["values"])
-                check_constraints.append(f"CHECK ({field_name} IN ('{values}'))")
+                values = "','".join(self._escape(v) for v in field_def["values"])
+                check_constraints.append(
+                    f"CHECK ({self._quote_ident(field_name)} IN ('{values}'))"
+                )
 
-            columns.append(f"    {field_name} {sql_type} NULL")
+            columns.append(f"    {self._quote_ident(field_name)} {sql_type} NULL")
 
         # Combine columns and check constraints
         return (
-            f"CREATE TABLE {table_name} (\n"
+            f"CREATE TABLE {self._quote_ident(table_name)} (\n"
             + ",\n".join(columns)
             + (
                 (",\n    " + ",\n    ".join(check_constraints))
@@ -177,9 +191,10 @@ class MssqlExporter(BaseExporter):
             'INSERT INTO users (id, name) VALUES (1, "test");'
 
         """
-        columns = ", ".join(row.keys())
+        columns = ", ".join(self._quote_ident(c) for c in row.keys())
         values = ", ".join(self._format_value(v) for v in row.values())
-        return f"INSERT INTO {table_name} ({columns}) VALUES ({values});"
+        table = self._quote_ident(table_name)
+        return f"INSERT INTO {table} ({columns}) VALUES ({values});"
 
     def export(
         self, data: list[dict[str, Any]], output_path: str, schema: dict | None = None
@@ -188,7 +203,7 @@ class MssqlExporter(BaseExporter):
         if not data:
             return
 
-        table_name = output_path.split("/")[-1].split(".")[0]
+        table_name = Path(output_path).name.split(".")[0]
 
         with open(output_path, "w") as f:
             # Always write CREATE TABLE using DEFAULT_SCHEMA if no schema provided

{testdatax-0.1.3 → testdatax-0.2.1}/src/exporters/mysql_exporter.py

@@ -1,10 +1,12 @@
 import decimal
 from datetime import date, datetime
+from pathlib import Path
 from typing import Any
 from uuid import UUID
 
 from .base_exporter import BaseExporter
 from .utils.constants import DEFAULT_SCHEMA
+from .utils.sql import escape_mysql_literal, quote_mysql_ident
 
 MYSQL_TYPE_MAPPING = {
     "string": "VARCHAR(255)",
@@ -25,6 +27,16 @@ MYSQL_TYPE_MAPPING = {
 class MysqlExporter(BaseExporter):
     """Exports data to MySQL compatible SQL file."""
 
+    @staticmethod
+    def _escape(value: str) -> str:
+        """Escape a string for a MySQL single-quoted literal."""
+        return escape_mysql_literal(value)
+
+    @staticmethod
+    def _quote_ident(name: str) -> str:
+        """Quote a MySQL identifier (table or column name)."""
+        return quote_mysql_ident(name)
+
     def _format_value(
         self,
         value: (
@@ -69,7 +81,7 @@ class MysqlExporter(BaseExporter):
         if value is None:
             return "NULL"
         elif isinstance(value, (str | UUID)):
-            return "'" + str(value).replace("'", "\\'").replace("\n", "\\n") + "'"
+            return "'" + self._escape(str(value)) + "'"
         elif isinstance(value, (datetime | date)):
             return f"'{value.isoformat()}'"
         elif isinstance(value, bool):
@@ -138,11 +150,15 @@ class MysqlExporter(BaseExporter):
                 and field_def.get("type") == "enum"
                 and "values" in field_def
             ):
-                values = "','".join(field_def["values"])
+                values = "','".join(self._escape(v) for v in field_def["values"])
                 sql_type = f"ENUM('{values}')"
-            columns.append(f"    {field_name} {sql_type} NULL")
+            columns.append(f"    {self._quote_ident(field_name)} {sql_type} NULL")
 
-        return f"CREATE TABLE {table_name} (\n" + ",\n".join(columns) + "\n);\n\n"
+        return (
+            f"CREATE TABLE {self._quote_ident(table_name)} (\n"
+            + ",\n".join(columns)
+            + "\n);\n\n"
+        )
 
     def _create_insert_stmt(
         self, row: dict[str, Any], table_name: str = "output"
@@ -163,9 +179,10 @@ class MysqlExporter(BaseExporter):
             'INSERT INTO users (id, name) VALUES (1, "test");'
 
         """
-        columns = ", ".join(row.keys())
+        columns = ", ".join(self._quote_ident(c) for c in row.keys())
         values = ", ".join(self._format_value(v) for v in row.values())
-        return f"INSERT INTO {table_name} ({columns}) VALUES ({values});"
+        table = self._quote_ident(table_name)
+        return f"INSERT INTO {table} ({columns}) VALUES ({values});"
 
     def export(
         self, data: list[dict[str, Any]], output_path: str, schema: dict | None = None
@@ -174,7 +191,7 @@ class MysqlExporter(BaseExporter):
         if not data:
             return
 
-        table_name = output_path.split("/")[-1].split(".")[0]
+        table_name = Path(output_path).name.split(".")[0]
 
         with open(output_path, "w") as f:
             # Always write CREATE TABLE using DEFAULT_SCHEMA if no schema provided

{testdatax-0.1.3 → testdatax-0.2.1}/src/exporters/oracle_exporter.py

@@ -1,10 +1,12 @@
 import decimal
 from datetime import date, datetime
+from pathlib import Path
 from typing import Any
 from uuid import UUID
 
 from .base_exporter import BaseExporter
 from .utils.constants import DEFAULT_SCHEMA
+from .utils.sql import escape_ansi_quotes, quote_ansi_ident
 
 ORACLE_TYPE_MAPPING = {
     "string": "VARCHAR2(255)",  # Oracle's Unicode string type
@@ -25,6 +27,16 @@ ORACLE_TYPE_MAPPING = {
 class OracleExporter(BaseExporter):
     """Exports data to ORACLE compatible SQL file."""
 
+    @staticmethod
+    def _escape(value: str) -> str:
+        """Escape a string for an Oracle single-quoted literal (quote doubling)."""
+        return escape_ansi_quotes(value)
+
+    @staticmethod
+    def _quote_ident(name: str) -> str:
+        """Quote an Oracle identifier (table or column name) with double quotes."""
+        return quote_ansi_ident(name)
+
     def _format_value(
         self,
         value: (
@@ -69,7 +81,7 @@ class OracleExporter(BaseExporter):
         if value is None:
             return "NULL"
         elif isinstance(value, (str)):
-            return "'" + str(value).replace("'", "''") + "'"  # uses '' for escaping
+            return "'" + self._escape(str(value)) + "'"  # uses '' for escaping
         elif isinstance(value, UUID):
             return f"'{str(value)}'"
         elif isinstance(value, datetime):
@@ -148,14 +160,16 @@ class OracleExporter(BaseExporter):
                 and field_def.get("type") == "enum"
                 and "values" in field_def
             ):
-                values = "','".join(field_def["values"])
-                check_constraints.append(f"CHECK ({field_name} IN ('{values}'))")
+                values = "','".join(self._escape(v) for v in field_def["values"])
+                check_constraints.append(
+                    f"CHECK ({self._quote_ident(field_name)} IN ('{values}'))"
+                )
 
-            columns.append(f"    {field_name} {sql_type} NULL")
+            columns.append(f"    {self._quote_ident(field_name)} {sql_type} NULL")
 
         # Combine columns and check constraints
         return (
-            f"CREATE TABLE {table_name} (\n"
+            f"CREATE TABLE {self._quote_ident(table_name)} (\n"
             + ",\n".join(columns)
             + (
                 (",\n    " + ",\n    ".join(check_constraints))
@@ -184,9 +198,10 @@ class OracleExporter(BaseExporter):
             'INSERT INTO users (id, name) VALUES (1, "test");'
 
         """
-        columns = ", ".join(row.keys())
+        columns = ", ".join(self._quote_ident(c) for c in row.keys())
         values = ", ".join(self._format_value(v) for v in row.values())
-        return f"INSERT INTO {table_name} ({columns}) VALUES ({values});"
+        table = self._quote_ident(table_name)
+        return f"INSERT INTO {table} ({columns}) VALUES ({values});"
 
     def export(
         self, data: list[dict[str, Any]], output_path: str, schema: dict | None = None
@@ -195,7 +210,7 @@ class OracleExporter(BaseExporter):
         if not data:
             return
 
-        table_name = output_path.split("/")[-1].split(".")[0]
+        table_name = Path(output_path).name.split(".")[0]
 
         with open(output_path, "w") as f:
             # Always write CREATE TABLE using DEFAULT_SCHEMA if no schema provided

{testdatax-0.1.3 → testdatax-0.2.1}/src/exporters/utils/constants.py

@@ -11,6 +11,12 @@ CHUNK_SIZE_CSV = CHUNK_SIZE
 CHUNK_SIZE_PARQUET = CHUNK_SIZE
 CHUNK_SIZE_ORC = CHUNK_SIZE
 
+# Probability that a nullable field emits NULL instead of a value
+NULL_PROBABILITY = 0.1
+
+# Maximum attempts to generate a unique value before giving up
+MAX_UNIQUE_RETRIES = 1000
+
 # ORC compression types
 OrcCompression = Literal["UNCOMPRESSED", "SNAPPY", "ZLIB", "LZ4", "ZSTD"]
 OrcStrategy = Literal["SPEED", "COMPRESSION"]

{testdatax-0.1.3 → testdatax-0.2.1}/src/exporters/utils/formatters.py

@@ -6,6 +6,20 @@ from decimal import Decimal
 from typing import Any
 
 
+def extract_formats(schema: dict | None) -> dict[str, str]:
+    """Extract per-column ``strftime`` formats from a schema definition.
+
+    Only complex (dict) field definitions carrying a ``format`` key are included.
+    """
+    if not schema:
+        return {}
+    return {
+        name: field_def["format"]
+        for name, field_def in schema.items()
+        if isinstance(field_def, dict) and field_def.get("format")
+    }
+
+
 class BaseFormatter:
     """Base class for handling data type formatting across exporters."""
 
@@ -68,22 +82,28 @@ class BaseFormatter:
         pass
 
     def format_row(
-        self, row: dict[str, Any], **kwargs: dict[str, str | int | float]
+        self, row: dict[str, Any], formats: dict[str, str] | None = None
     ) -> dict[str, Any]:
-        """Format the provided rows with the correct format_value.
+        """Format the provided row with the correct format_value.
 
         Args:
             row: Dictionary containing row data
-            **kwargs: Additional format-specific parameters
+            formats: Optional per-column ``strftime`` formats applied to
+                date/datetime values before normal value formatting.
 
         Returns:
             Formatted row dictionary
 
         """
+        formats = formats or {}
         formatted_row: dict[str, Any] = {}
         for key, value in row.items():
             try:
-                formatted_row[key] = self.format_value(value)
+                fmt = formats.get(key)
+                if fmt and isinstance(value, (date | datetime)):
+                    formatted_row[key] = value.strftime(fmt)
+                else:
+                    formatted_row[key] = self.format_value(value)
             except Exception as e:
                 formatted_row[key] = f"ERROR: {str(e)}"
         return formatted_row

testdatax-0.2.1/src/exporters/utils/sql.py

@@ -0,0 +1,38 @@
+"""Shared SQL string-escaping helpers for the SQL exporters."""
+
+
+def escape_ansi_quotes(value: str) -> str:
+    """Escape an ANSI single-quoted SQL literal by doubling embedded quotes.
+
+    Used by dialects without backslash escaping (MSSQL, Oracle).
+    """
+    return value.replace("'", "''")
+
+
+def escape_mysql_literal(value: str) -> str:
+    """Escape a MySQL single-quoted literal.
+
+    The backslash is escaped first so a value containing a backslash cannot
+    terminate the literal early, then single quotes and newlines are escaped.
+    """
+    return value.replace("\\", "\\\\").replace("'", "\\'").replace("\n", "\\n")
+
+
+def quote_mysql_ident(name: str) -> str:
+    """Quote a MySQL identifier with backticks, doubling embedded backticks."""
+    return "`" + name.replace("`", "``") + "`"
+
+
+def quote_mssql_ident(name: str) -> str:
+    """Quote a T-SQL identifier with brackets, doubling embedded ``]``."""
+    return "[" + name.replace("]", "]]") + "]"
+
+
+def quote_ansi_ident(name: str) -> str:
+    """Quote an ANSI/Oracle identifier with double quotes, doubling embedded ``"``.
+
+    Note: Oracle treats a double-quoted identifier as case-sensitive, so the
+    generated DDL and DML deliberately reference every identifier quoted to stay
+    self-consistent.
+    """
+    return '"' + name.replace('"', '""') + '"'