sql-assignment-generator 0.0.13__tar.gz → 0.0.15__tar.gz

{sql_assignment_generator-0.0.13 → sql_assignment_generator-0.0.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql_assignment_generator
-Version: 0.0.13
+Version: 0.0.15
 Summary: This project generates SQL assignments based on common mistakes made by learners.
 Project-URL: Repository, https://github.com/DavidePonzini/sql_assignment_generator
 Project-URL: Documentation, https://sql-assignment-generator.readthedocs.io/en/latest/index.html

{sql_assignment_generator-0.0.13 → sql_assignment_generator-0.0.15}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sql_assignment_generator"
-version = "0.0.13"
+version = "0.0.15"
 authors = [
   { name="Davide Ponzini", email="davide.ponzini95@gmail.com" },
 ]

{sql_assignment_generator-0.0.13 → sql_assignment_generator-0.0.15}/requirements.txt

@@ -2,7 +2,7 @@ dav_tools>=0.4.22
 # progress>=1.6
 pydantic>=2.10.4
 sql-error-taxonomy>=1.0.2
-sqlscope>=1.0.7
+sqlscope>=1.0.8
 sqlglot
 dotenv
 openai

{sql_assignment_generator-0.0.13 → sql_assignment_generator-0.0.15}/src/sql_assignment_generator/__init__.py

@@ -20,10 +20,15 @@ from sql_error_taxonomy import SqlErrors
 
 def generate_assignment(
         errors: list[tuple[SqlErrors, DifficultyLevel]],
-        domain: str | None = None,
+        sql_dialect: str = 'postgres',
         *,
+        language: str = 'en',
+        domain: str | None = None,
+        dataset_str: str | None = None,
         shuffle_exercises: bool = False,
         naming_func: Callable[[SqlErrors, DifficultyLevel], str] = lambda error, difficulty: f'{error.name} - {difficulty.name}',
+        max_dataset_attempts: int = 3,
+        max_exercise_attempts: int = 3,
         max_unique_attempts: int = 3,
         max_workers: int | None = None
     ) -> Assignment:
@@ -36,9 +41,14 @@ def generate_assignment(
 
     Args:
         errors (list[tuple[SqlErrors, DifficultyLevel]]): A list of (error, difficulty) pairs.
+        sql_dialect (str): The SQL dialect to use for generating the dataset and exercises (e.g., 'postgres', 'mysql').
         domain (str | None): The domain for the assignments. If None, a random domain will be selected.
+        language (str): The language for the assignment generation (e.g., 'en' for English).
+        dataset_str (str | None): Optional SQL string to use as the dataset. If provided, it will be used instead of generating a new dataset.
         shuffle_exercises (bool): Whether to shuffle exercises to prevent ordering bias (shuffles input order).
         naming_func (Callable[[SqlErrors, DifficultyLevel], str]): Generates exercise titles.
+        max_dataset_attempts (int): Maximum retries for generating a valid dataset before skipping.
+        max_exercise_attempts (int): Maximum retries for generating a valid exercise before skipping.
         max_unique_attempts (int): Maximum retries to avoid duplicate solutions per (error, difficulty).
         max_workers (int | None): Thread pool size. If None, uses ThreadPoolExecutor default.
 
@@ -57,9 +67,6 @@ def generate_assignment(
     if not supported_errors:
         raise ValueError('No supported errors provided for assignment generation.')
 
-    if domain is None:
-        domain = random_domain()
-
     if shuffle_exercises:
         random.shuffle(errors)
     
@@ -67,22 +74,45 @@ def generate_assignment(
     dav_tools.messages.info(f'Starting assignment generation for {len(supported_errors)} exercises (out of {len(errors)} requested)')
 
     # convert SqlErrors -> SqlErrorRequirements, keeping difficulty levels
-    requirements: list[tuple[SqlErrors, SqlErrorRequirements, DifficultyLevel]] = [(error, ERROR_REQUIREMENTS_MAP[error], difficulty) for error, difficulty in supported_errors]
-
-    # initialize requirements and extra details
-    dataset_requirements: list[SchemaConstraint] = []
-    for _, req, difficulty in requirements:
-        dataset_requirements.extend(req.dataset_constraints(difficulty))
-
-    dataset_extra_details: list[str] = [
-        req.dataset_extra_details()
-        for _, req, _ in requirements
+    requirements: list[tuple[SqlErrors, SqlErrorRequirements, DifficultyLevel]] = [
+        (
+            error,
+            ERROR_REQUIREMENTS_MAP[error](language=language),
+            difficulty
+        )
+        for error, difficulty in supported_errors
     ]
-    dataset_extra_details = [detail for detail in dataset_extra_details if detail.strip()]  # filter out empty details
-    dataset_extra_details = list(set(dataset_extra_details))  # deduplicate details
 
-    dav_tools.messages.info(f'Generating dataset for domain: {domain}')
-    dataset = Dataset.generate(domain, dataset_requirements, dataset_extra_details)
+    if not dataset_str:
+        # No dataset string provided, so we need to generate a dataset based on the requirements of the exercises.
+        if domain is None:
+            domain = random_domain(language=language)
+
+        dataset_requirements: list[SchemaConstraint] = []
+        for _, req, difficulty in requirements:
+            dataset_requirements.extend(req.dataset_constraints(difficulty))
+
+        dataset_extra_details: list[str] = [
+            req.dataset_extra_details().get(language=language)
+            for _, req, _ in requirements
+        ]
+        dataset_extra_details = [detail for detail in dataset_extra_details if detail.strip()]  # filter out empty details
+        dataset_extra_details = list(set(dataset_extra_details))  # deduplicate details
+
+        dav_tools.messages.info(f'Generating dataset for domain: {domain}')
+        dataset = Dataset.generate(
+            domain=domain,
+            sql_dialect=sql_dialect,
+            constraints=dataset_requirements,
+            extra_details=dataset_extra_details,
+            language=language,
+            max_attempts=max_dataset_attempts,
+        )
+    else:
+        dataset = Dataset.from_sql(
+            sql_str=dataset_str,
+            sql_dialect=sql_dialect
+        )
 
     generated_solutions_hashes: set[str] = set()
     hashes_lock = threading.Lock()
@@ -105,7 +135,17 @@ def generate_assignment(
 
         for attempt in range(max_unique_attempts):
             try:
-                generated_exercise = Exercise.generate(error, difficulty, constraints, extra_details, dataset=dataset, title=title)
+                generated_exercise = Exercise.generate(
+                    error=error,
+                    difficulty=difficulty,
+                    constraints=constraints,
+                    extra_details=extra_details,
+                    sql_dialect=sql_dialect,
+                    dataset=dataset,
+                    title=title,
+                    max_attempts=max_exercise_attempts,
+                    language=language
+                )
             except ExerciseGenerationError:
                 with log_lock:
                     dav_tools.messages.warning(f'{title}: Skipping exercise generation for {error.name} due to validation failures.')
@@ -137,12 +177,25 @@ def generate_assignment(
 
     if max_workers == 1:
         for idx, (error, requirement, difficulty) in enumerate(requirements):
-            i, ex = _worker(idx, error, difficulty, requirement.exercise_constraints(difficulty), requirement.exercise_extra_details())
+            i, ex = _worker(
+                idx=idx,
+                error=error,
+                difficulty=difficulty,
+                constraints=requirement.exercise_constraints(difficulty),
+                extra_details=requirement.exercise_extra_details().get(language=language)
+            )
             ordered_results[i] = ex
     else:
         with ThreadPoolExecutor(max_workers=max_workers) as executor:
             futures = [
-                executor.submit(_worker, idx, error, difficulty, requirement.exercise_constraints(difficulty), requirement.exercise_extra_details())
+                executor.submit(
+                    _worker,
+                    idx=idx,
+                    error=error,
+                    difficulty=difficulty,
+                    constraints=requirement.exercise_constraints(difficulty),
+                    extra_details=requirement.exercise_extra_details().get(language=language)
+                )
                 for idx, (error, requirement, difficulty) in enumerate(requirements)
             ]
             for fut in as_completed(futures):

{sql_assignment_generator-0.0.13 → sql_assignment_generator-0.0.15}/src/sql_assignment_generator/assignments/dataset/dataset.py

@@ -1,145 +1,198 @@
-from collections.abc import Sequence
-from dataclasses import dataclass
-import dav_tools
-import sqlglot
-from sqlscope import Catalog, build_catalog_from_sql
-
-from . import strings
-from ...constraints.schema import SchemaConstraint
-from ... import llm
-from ...constraints import SchemaConstraint, schema as schema_constraints
-from ...exceptions import SQLParsingError, ConstraintValidationError, DatasetGenerationError
-
-
-@dataclass
-class Dataset:
-    '''A SQL dataset related to a specific domain, including schema creation and data insertion commands.'''
-
-    create_commands: list[str]
-    '''SQL commands to create the database schema.'''
-
-    insert_commands: list[str]
-    '''SQL commands to insert data into the database.'''
-
-    domain: str
-    '''The domain associated with the dataset.'''
-
-    _catalog_cache: Catalog | None = None
-    '''Cached SQLScope Catalog for the dataset.'''
-
-    _catalog_cache_commands_hash: int | None = None
-    '''Hash of the CREATE TABLE commands used to build the cached Catalog.'''
-
-    @property
-    def catalog(self) -> Catalog:
-        '''
-        Build and return a SQLScope Catalog from the dataset's SQL commands.
-        The result is cached for handling multiple accesses efficiently.
-        Cache is properly invalidated if the CREATE TABLE commands change.
-        '''
-        if self._catalog_cache is None or self._catalog_cache_commands_hash != hash(tuple(self.create_commands)):
-            full_sql = '\n'.join(self.create_commands)
-            self._catalog_cache = build_catalog_from_sql(full_sql)
-            self._catalog_cache_commands_hash = hash(tuple(self.create_commands))
-        
-        return self._catalog_cache
-    
-    def to_sql_no_context(self) -> str:
-        '''Generate the SQL commands to create and populate the dataset without schema context.'''
-
-        create_cmds = '\n'.join(self.create_commands)
-        insert_cmds = '\n'.join(self.insert_commands)
-
-        return f'''{create_cmds}\n\n{insert_cmds}'''
-
-    def to_sql(self, schema: str) -> str:
-        '''Generate the SQL commands to create and populate the dataset within the specified schema.'''
-
-        # Normalize schema name
-        schema = schema.lower().replace(' ', '_')
-
-        create_cmds = '\n\n'.join(self.create_commands)
-        insert_cmds = '\n\n'.join(self.insert_commands)
-
-        return strings.to_sql_format(schema=schema, create_cmds=create_cmds, insert_cmds=insert_cmds)
-    
-    @staticmethod
-    def generate(domain: str,
-                 constraints: Sequence[SchemaConstraint],
-                 extra_details: list[str] = [],
-                 *,
-                 max_attempts: int = 5
-        ) -> 'Dataset':
-        '''Generate a SQL dataset based on the specified parameters.'''
-
-        # merge similar constraints
-        constraints = schema_constraints.merge_constraints(constraints)
-
-        prompt_text = strings.prompt_generate(
-            domain=domain,
-            extra_details=extra_details,
-            constraints=constraints
-        )
-
-        # query LLM to generate dataset
-        messages = llm.Message()
-        messages.add_message_user(prompt_text)
-        
-        for attempt in range(max_attempts):
-            try:
-                answer = llm.generate_answer(messages, json_format=llm.models.Schema) 
-                assert isinstance(answer, llm.models.Schema), "The response is not in the expected JSON format."
-
-                # parse CREATE TABLEs
-                parsed_tables = []
-                for create_table in answer.schema_tables:
-                    try:
-                        parsed = sqlglot.parse_one(create_table, read="postgres")
-                        parsed_tables.append(parsed)
-                    except Exception as e:
-                        raise SQLParsingError(f"Syntax error in CREATE TABLE generated: {e}", create_table)
-                create_commands = [f'{cmd.sql(pretty=True, dialect="postgres")};' for cmd in parsed_tables]
-
-                # parse INSERT INTOs
-                parsed_inserts = []
-                for create_table in answer.insert_commands:
-                    try:
-                        parsed = sqlglot.parse_one(create_table, read="postgres")
-                        parsed_inserts.append(parsed)
-                    except Exception as e:
-                        raise SQLParsingError(f"Syntax error in INSERT COMMANDS generated: {e}", create_table)
-                insert_commands = [f'{cmd.sql(pretty=True, dialect="postgres")};' for cmd in parsed_inserts]
-
-                catalog = build_catalog_from_sql('; '.join(cmd.sql() for cmd in parsed_tables))
-
-                # check if constraints are satisfied
-                errors = []
-                for constraint in constraints:
-                    try:
-                        constraint.validate(catalog, parsed_tables, parsed_inserts)
-                    except ConstraintValidationError as e:
-                        errors.append(str(e))
-                        continue
-
-                # no errors, return dataset
-                if not errors:
-                    result = Dataset(
-                        create_commands=create_commands,
-                        insert_commands=insert_commands,
-                        domain=domain
-                    )
-                    # fill cache, since we already have the catalog
-                    result._catalog_cache = catalog
-                    result._catalog_cache_commands_hash = hash(tuple(create_commands))
-                    
-                    return result
-                
-                dav_tools.messages.error(f'Validation failed for attempt {attempt + 1}. Missing requirements: {", ".join(errors)}')
-                
-                messages.add_message_user(strings.feedback_constraint_violations(errors))
-
-            except SQLParsingError as e:
-                dav_tools.messages.error(f"Error during generation (Attempt {attempt + 1}): {e}")
-                messages.add_message_user(f"SQL code is not syntactically valid: {str(e)}. Please regenerate valid SQL.")
-        
+from collections.abc import Sequence
+from dataclasses import dataclass
+import dav_tools
+import sqlglot
+from sqlglot import exp
+from sqlscope import Catalog, build_catalog_from_sql
+
+from . import strings
+from ...constraints.schema import SchemaConstraint
+from ... import llm
+from ...constraints import SchemaConstraint, schema as schema_constraints
+from ...exceptions import SQLParsingError, ConstraintValidationError, DatasetGenerationError
+from ...translatable_text import TranslatableText
+
+
+@dataclass
+class Dataset:
+    '''A SQL dataset related to a specific domain, including schema creation and data insertion commands.'''
+
+    create_commands: list[str]
+    '''SQL commands to create the database schema.'''
+
+    insert_commands: list[str]
+    '''SQL commands to insert data into the database.'''
+
+    domain: str
+    '''The domain associated with the dataset.'''
+
+    _catalog_cache: Catalog | None = None
+    '''Cached SQLScope Catalog for the dataset.'''
+
+    _catalog_cache_commands_hash: int | None = None
+    '''Hash of the CREATE TABLE commands used to build the cached Catalog.'''
+
+    @property
+    def catalog(self) -> Catalog:
+        '''
+        Build and return a SQLScope Catalog from the dataset's SQL commands.
+        The result is cached for handling multiple accesses efficiently.
+        Cache is properly invalidated if the CREATE TABLE commands change.
+        '''
+        if self._catalog_cache is None or self._catalog_cache_commands_hash != hash(tuple(self.create_commands)):
+            full_sql = '\n'.join(self.create_commands)
+            self._catalog_cache = build_catalog_from_sql(full_sql)
+            self._catalog_cache_commands_hash = hash(tuple(self.create_commands))
+        
+        return self._catalog_cache
+    
+    def to_sql_no_context(self) -> str:
+        '''Generate the SQL commands to create and populate the dataset without schema context.'''
+
+        create_cmds = '\n'.join(self.create_commands)
+        insert_cmds = '\n'.join(self.insert_commands)
+
+        return f'''{create_cmds}\n\n{insert_cmds}'''
+
+    def to_sql(self, schema: str) -> str:
+        '''Generate the SQL commands to create and populate the dataset within the specified schema.'''
+
+        # Normalize schema name
+        schema = schema.lower().replace(' ', '_')
+
+        create_cmds = '\n\n'.join(self.create_commands)
+        insert_cmds = '\n\n'.join(self.insert_commands)
+
+        return strings.to_sql_format(schema=schema, create_cmds=create_cmds, insert_cmds=insert_cmds)
+    
+    @staticmethod
+    def from_sql(sql_str: str, sql_dialect: str) -> 'Dataset':
+        '''Create a Dataset instance from a raw SQL string containing CREATE TABLE and INSERT INTO commands.'''
+    
+        try:
+            parsed = sqlglot.parse(sql_str, read=sql_dialect)
+            create_commands = []
+            insert_commands = []
+
+            for statement in parsed:
+                if isinstance(statement, exp.Create):
+                    if statement.kind is not None and statement.kind.upper() != 'TABLE':
+                        continue  # skip non-table creation statements, e.g. CREATE SCHEMA
+                    create_commands.append(f'{statement.sql()};')
+                elif isinstance(statement, exp.Insert):
+                    insert_commands.append(f'{statement.sql()};')
+
+            if not create_commands:
+                raise ValueError("No CREATE TABLE commands found in the provided SQL string.")
+        except Exception as e:
+            raise SQLParsingError(f"Error parsing SQL string: {e}", sql_str)
+
+        return Dataset(
+            create_commands=create_commands,
+            insert_commands=insert_commands,
+            domain="CUSTOM_DATASET"
+        )
+        
+    @staticmethod
+    def generate(
+        domain: str,
+        sql_dialect: str,
+        constraints: Sequence[SchemaConstraint],
+        extra_details: list[str] = [],
+        *,
+        language: str,
+        max_attempts: int = 5
+    ) -> 'Dataset':
+        '''Generate a SQL dataset based on the specified parameters.'''
+
+        # merge similar constraints
+        constraints = schema_constraints.merge_constraints(constraints)
+
+        prompt_text = strings.prompt_generate(
+            domain=domain,
+            extra_details=extra_details,
+            constraints=constraints,
+            sql_dialect=sql_dialect,
+            language=language,
+        )
+
+        # query LLM to generate dataset
+        messages = llm.Message()
+        messages.add_message_user(prompt_text)
+        
+        for attempt in range(max_attempts):
+            messages.print_chat()
+            try:
+                answer = llm.generate_answer(messages, json_format=llm.models.Schema) 
+                assert isinstance(answer, llm.models.Schema), "The response is not in the expected JSON format."
+
+                # parse CREATE TABLEs
+                parsed_tables = []
+                for create_table in answer.schema_tables:
+                    try:
+                        parsed = sqlglot.parse_one(create_table, read=sql_dialect)
+                        parsed_tables.append(parsed)
+                    except Exception as e:
+                        raise SQLParsingError(
+                            TranslatableText(
+                                f"Syntax error in CREATE TABLE generated: {e}",
+                                it=f"Errore di sintassi nella CREATE TABLE generata: {e}"
+                            ).get(language),
+                            create_table
+                        )
+                create_commands = [f'{cmd.sql(pretty=True, dialect=sql_dialect)};' for cmd in parsed_tables]
+
+                # parse INSERT INTOs
+                parsed_inserts = []
+                for create_table in answer.insert_commands:
+                    try:
+                        parsed = sqlglot.parse_one(create_table, read=sql_dialect)
+                        parsed_inserts.append(parsed)
+                    except Exception as e:
+                        raise SQLParsingError(
+                            TranslatableText(
+                                f"Syntax error in INSERT COMMANDS generated: {e}",
+                                it=f"Errore di sintassi nei comandi INSERT generati: {e}"
+                            ).get(language),
+                            create_table
+                        )
+                insert_commands = [f'{cmd.sql(pretty=True, dialect=sql_dialect)};' for cmd in parsed_inserts]
+
+                catalog = build_catalog_from_sql('; '.join(cmd.sql() for cmd in parsed_tables))
+
+                # check if constraints are satisfied
+                errors = []
+                for constraint in constraints:
+                    try:
+                        constraint.validate(catalog, parsed_tables, parsed_inserts)
+                    except ConstraintValidationError as e:
+                        errors.append(e.get(language=language))
+                        continue
+
+                # no errors, return dataset
+                if not errors:
+                    result = Dataset(
+                        create_commands=create_commands,
+                        insert_commands=insert_commands,
+                        domain=domain
+                    )
+                    # fill cache, since we already have the catalog
+                    result._catalog_cache = catalog
+                    result._catalog_cache_commands_hash = hash(tuple(create_commands))
+                    
+                    return result
+                
+                dav_tools.messages.error(f'Validation failed for attempt {attempt + 1}. Missing requirements: {", ".join(errors)}')
+                
+                messages.add_message_user(strings.feedback_constraint_violations(errors, language=language))
+
+            except SQLParsingError as e:
+                dav_tools.messages.error(f"Error during generation (Attempt {attempt + 1}): {e}")
+                messages.add_message_user(
+                    TranslatableText(
+                        f"Generated SQL code is not syntactically valid: {str(e)}. Please regenerate valid SQL.",
+                        it=f"Il codice SQL generato non è sintatticamente valido: {str(e)}. Per favore, rigenera un SQL valido."
+                    ).get(language)
+                )
+        
         raise DatasetGenerationError(f'Failed to generate a valid dataset after {max_attempts} attempts.')

sql_assignment_generator-0.0.15/src/sql_assignment_generator/assignments/dataset/strings.py

@@ -0,0 +1,105 @@
+from typing import Sequence
+from ...constraints import SchemaConstraint
+from ...translatable_text import TranslatableText
+
+def to_sql_format(schema: str, create_cmds: str, insert_cmds: str) -> str:
+    return f'''BEGIN;
+
+DROP SCHEMA IF EXISTS {schema} CASCADE;
+CREATE SCHEMA {schema};
+SET search_path TO {schema};
+
+{create_cmds}
+
+{insert_cmds}
+
+COMMIT;'''
+
+
+def prompt_generate(
+        domain: str,
+        extra_details: list[str],
+        constraints: Sequence[SchemaConstraint],
+        *,
+        sql_dialect: str,
+        language: str
+    ) -> str:
+    formatted_constraints = '\n'.join(f'- {c.description.get(language)}' for c in constraints)
+   
+    # remove empty extra details        
+    extra_details = [detail for detail in extra_details if detail.strip() != '']
+    # dataset characteristics str
+    if len(extra_details) > 0:
+        extra_details_str = TranslatableText(
+            "The dataset must have the following characteristics:\n",
+            it="Il dataset deve avere le seguenti caratteristiche:\n"
+        ).get(language)
+        for detail in extra_details:
+            extra_details_str += f"- {detail}\n"
+    else:
+        extra_details_str = ''
+    
+    return TranslatableText(
+        f'''
+Generate a {sql_dialect} SQL dataset about the following domain: "{domain}".
+{extra_details_str}
+
+MANDATORY CONSTRAINTS:
+- FOREIGN KEY attributes should have the REFERENCES keyword inline (e.g. "col TYPE REFERENCES table_name(column_name)").
+- VARCHAR columns should not have a length specified (e.g. use "col VARCHAR" instead of "col VARCHAR(255)").
+{formatted_constraints}
+
+MANDATORY OUTPUT (JSON) - each line in both lists must correspond to a single table:
+{{
+    "schema_tables": [
+        "CREATE TABLE t1(...);",
+        "CREATE TABLE t2(...);"
+    ],
+    "insert_commands": [
+        "INSERT INTO t1(...) VALUES(val_1, val_2, ...), (...), (val_n, val_n+1, ...);",
+        "INSERT INTO t2(...) VALUES(val_1, val_2, ...), (...), (val_n, val_n+1, ...);"
+    ]
+}}
+
+INSERT INTO statements must have following format (Multi-row insert): 
+INSERT INTO tableName(<all columns except SERIAL/AUTO_INCREMENT>) VALUES 
+    (val_1, val_2, ...),
+    (val_n, val_n+1, ...);
+
+For each table, insert at least 5 rows of data.
+Skip any SERIAL/AUTO_INCREMENT columns in the INSERT statements.
+''',
+        it=f'''Genera un dataset SQL {sql_dialect} sul seguente dominio: "{domain}".
+{extra_details_str}
+
+CONSTRAINT OBBLIGATORIE:
+- Gli attributi FOREIGN KEY devono avere la keyword REFERENCES inline (es. "col TYPE REFERENCES table_name(column_name)").
+- Le colonne VARCHAR non devono avere una lunghezza specificata (es. usa "col VARCHAR" invece di "col VARCHAR(255)").
+{formatted_constraints}
+
+OUTPUT OBBLIGATORIO (JSON) - ogni riga in entrambe le liste deve corrispondere a una singola tabella:
+{{
+    "schema_tables": [
+        "CREATE TABLE t1(...);",
+        "CREATE TABLE t2(...);"
+    ],
+    "insert_commands": [
+        "INSERT INTO t1(...) VALUES(val_1, val_2, ...), (...), (val_n, val_n+1, ...);",
+        "INSERT INTO t2(...) VALUES(val_1, val_2, ...), (...), (val_n, val_n+1, ...);"
+    ]
+}}
+
+Le istruzioni INSERT INTO devono avere il seguente formato (Multi-row insert):
+INSERT INTO tableName(<tutte le colonne tranne SERIAL/AUTO_INCREMENT>) VALUES
+    (val_1, val_2, ...),
+    (val_n, val_n+1, ...);
+
+Per ogni tabella, inserisci almeno 5 righe di dati.
+''',
+    ).get(language)
+
+def feedback_constraint_violations(errors: list[str], * , language: str) -> str:
+    return TranslatableText(
+        f"The previous JSON output was rejected because the SQL violated these constraints: {', '.join(errors)}\n Regenerate the JSON correcting the SQL to satisfy all mandatory constraints.",
+        it=f"Il precedente output JSON è stato rifiutato perché il SQL ha violato queste constraint: {', '.join(errors)}\n Rigenera il JSON correggendo il SQL per soddisfare tutte le constraint obbligatorie."
+    ).get(language)