Remove dialect arg from init_example_project

Author: treysp

sqlmesh/cli/example_project.py

@@ -3,7 +3,7 @@
 from pathlib import Path
 from dataclasses import dataclass
 
-from sqlglot import Dialect
+from sqlmesh.cli.main import ENGINE_TYPE_DISPLAY_ORDER
 from sqlmesh.integrations.dlt import generate_dlt_models_and_settings
 from sqlmesh.utils.date import yesterday_ds
 from sqlmesh.utils.errors import SQLMeshError
@@ -39,17 +39,15 @@ def _gen_config(
       database: db.db"""
     )
 
-    engine = "mssql" if engine_type == "tsql" else engine_type
-
     if not settings and template != ProjectTemplate.DBT:
         doc_link = "https://sqlmesh.readthedocs.io/en/stable/integrations/engines{engine_link}"
         engine_link = ""
 
-        if engine in CONNECTION_CONFIG_TO_TYPE:
+        if engine_type in CONNECTION_CONFIG_TO_TYPE:
             required_fields = []
             non_required_fields = []
 
-            for name, field in CONNECTION_CONFIG_TO_TYPE[engine].model_fields.items():
+            for name, field in CONNECTION_CONFIG_TO_TYPE[engine_type].model_fields.items():
                 field_name = field.alias or name
                 if field_name in ("dialect", "display_name"):
                     continue
@@ -65,7 +63,7 @@ def _gen_config(
                 option_str = f"      {'# ' if not required else ''}{field_name}: {default_value}\n"
 
                 # specify the DuckDB database field so quickstart runs out of the box
-                if engine == "duckdb" and field_name == "database":
+                if engine_type == "duckdb" and field_name == "database":
                     option_str = "      database: db.db\n"
                     required = True
 
@@ -76,7 +74,7 @@ def _gen_config(
 
             connection_settings = "".join(required_fields + non_required_fields)
 
-            engine_link = f"/{engine}/#connection-options"
+            engine_link = f"/{engine_type}/#connection-options"
 
         connection_settings = (
             "      # For more information on configuring the connection to your execution engine, visit:\n"
@@ -87,16 +85,16 @@ def _gen_config(
     default_configs = {
         ProjectTemplate.DEFAULT: f"""# --- Gateway Connection ---
 gateways:
-  {engine}:
+  {engine_type}:
     connection:
 {connection_settings}
-default_gateway: {engine}
+default_gateway: {engine_type}
 
 # --- Model Defaults ---
 # https://sqlmesh.readthedocs.io/en/stable/reference/model_configuration/#model-defaults
 
 model_defaults:
-  dialect: {DIALECT_TO_TYPE[engine]}
+  dialect: {DIALECT_TO_TYPE[engine_type]}
   start: {start or yesterday_ds()} # Start date for backfill history
   cron: '@daily'    # Run models daily at 12am UTC (can override per model)
 
@@ -276,7 +274,6 @@ def _gen_example_objects(schema_name: str) -> ExampleObjects:
 
 def init_example_project(
     path: t.Union[str, Path],
-    dialect: t.Optional[str],
     engine_type: t.Optional[str],
     template: ProjectTemplate = ProjectTemplate.DEFAULT,
     pipeline: t.Optional[str] = None,
@@ -299,9 +296,17 @@ def init_example_project(
         )
 
     if not engine_type and template != ProjectTemplate.DBT:
-        if not dialect:
-            raise SQLMeshError("Please provide a default SQL dialect for your project's models.")
-        Dialect.get_or_raise(dialect)
+        raise SQLMeshError(
+            "Missing `engine` argument to `sqlmesh init`. Please specify a SQL engine for your project."
+        )
+
+    if engine_type not in ENGINE_TYPE_DISPLAY_ORDER:
+        engine_strings = "'" + "', '".join(ENGINE_TYPE_DISPLAY_ORDER) + "'"
+        raise SQLMeshError(
+            f"Invalid engine '{engine_type}'. Please specify one of {engine_strings}."
+        )
+
+    dialect = DIALECT_TO_TYPE[engine_type]
 
     models: t.Set[t.Tuple[str, str]] = set()
     settings = None
@@ -316,11 +321,7 @@ def init_example_project(
                 "Please provide a DLT pipeline with the `--dlt-pipeline` flag to generate a SQLMesh project from DLT."
             )
 
-    # config generation chooses engine based on ConnectionConfig.type_
-    # - if user passes a SQL dialect, we always generate the engine whose type_ == dialect
-    #   - example: if users passes `postgres` we will always choose `postgres` engine and never `gcp_postgres`
-    # - if user interactively chooses an engine, we will pass the correct ConnectionConfig.type_
-    _create_config(config_path, engine_type or dialect, settings, start, template, cli_mode)
+    _create_config(config_path, engine_type, settings, start, template, cli_mode)
     if template == ProjectTemplate.DBT:
         return config_path
 

sqlmesh/cli/main.py

@@ -161,7 +161,7 @@ def cli(
 
 
 @cli.command("init")
-@click.argument("sql_dialect", required=False)
+@click.argument("engine", required=False)
 @click.option(
     "-t",
     "--template",
@@ -183,7 +183,7 @@ def cli(
 @cli_analytics
 def init(
     ctx: click.Context,
-    sql_dialect: t.Optional[str] = None,
+    engine: t.Optional[str] = None,
     template: t.Optional[str] = None,
     dlt_pipeline: t.Optional[str] = None,
     dlt_path: t.Optional[str] = None,
@@ -201,11 +201,10 @@ def init(
                 f"Invalid project template value '{template}'. Please specify one of {template_strings}."
             )
 
-    if sql_dialect or project_template == ProjectTemplate.DBT:
+    if engine or project_template == ProjectTemplate.DBT:
         init_example_project(
             path=ctx.obj,
-            dialect=sql_dialect,
-            engine_type=None,
+            engine_type=engine,
             template=project_template or ProjectTemplate.DEFAULT,
             pipeline=dlt_pipeline,
             dlt_path=dlt_path,
@@ -222,7 +221,6 @@ def init(
 
     config_path = init_example_project(
         path=ctx.obj,
-        dialect=None,
         template=project_template,
         engine_type=engine_type,
         cli_mode=cli_mode or InitCliMode.DEFAULT,

sqlmesh/magics.py

@@ -25,14 +25,15 @@
 from IPython.utils.process import arg_split
 from rich.jupyter import JupyterRenderable
 from sqlmesh.cli.example_project import ProjectTemplate, init_example_project
+from sqlmesh.cli.main import ENGINE_TYPE_DISPLAY_ORDER
 from sqlmesh.core import analytics
 from sqlmesh.core.config import load_configs
 from sqlmesh.core.console import create_console, set_console, configure_console
 from sqlmesh.core.context import Context
 from sqlmesh.core.dialect import format_model_expressions, parse
 from sqlmesh.core.model import load_sql_based_model
 from sqlmesh.core.test import ModelTestMetadata
-from sqlmesh.utils import sqlglot_dialects, yaml, Verbosity, optional_import
+from sqlmesh.utils import yaml, Verbosity, optional_import
 from sqlmesh.utils.errors import MagicError, MissingContextException, SQLMeshError
 
 logger = logging.getLogger(__name__)
@@ -159,9 +160,9 @@ def context(self, line: str) -> None:
     @magic_arguments()
     @argument("path", type=str, help="The path where the new SQLMesh project should be created.")
     @argument(
-        "sql_dialect",
+        "engine",
         type=str,
-        help=f"Default model SQL dialect. Supported values: {sqlglot_dialects()}.",
+        help=f"Project SQL engine. Supported values: '{', '.join(ENGINE_TYPE_DISPLAY_ORDER)}'.",  # type: ignore
     )
     @argument(
         "--template",
@@ -191,8 +192,7 @@ def init(self, line: str) -> None:
             raise MagicError(f"Invalid project template '{args.template}'")
         init_example_project(
             path=args.path,
-            dialect=args.sql_dialect,
-            engine_type=None,
+            engine_type=args.engine,
             template=project_template,
             pipeline=args.dlt_pipeline,
             dlt_path=args.dlt_path,

tests/cli/test_cli.py

@@ -47,7 +47,7 @@ def create_example_project(temp_dir) -> None:
         - Creating the SQLMesh example project in the temp_dir directory
         - Overwriting the config.yaml file so the duckdb database file will be created in the temp_dir directory
     """
-    init_example_project(temp_dir, "duckdb")
+    init_example_project(temp_dir, engine_type="duckdb")
     with open(temp_dir / "config.yaml", "w", encoding="utf-8") as f:
         f.write(
             f"""gateways:

tests/cli/test_integration_cli.py

@@ -47,7 +47,7 @@ def _invoke(sqlmesh_args: t.List[str], **kwargs: t.Any) -> subprocess.CompletedP
 
 @pytest.fixture
 def duckdb_example_project(tmp_path: Path) -> Path:
-    init_example_project(tmp_path, dialect="duckdb")
+    init_example_project(tmp_path, engine_type="duckdb")
     config_path = tmp_path / "config.yaml"
 
     # we need state to persist between invocations

tests/core/engine_adapter/integration/test_integration_bigquery.py

@@ -210,7 +210,7 @@ def test_information_schema_view_external_model(ctx: TestContext, tmp_path: Path
     model_name = ctx.table("test")
     dependency = f"`{'.'.join(part.name for part in information_schema_tables.parts)}`"
 
-    init_example_project(tmp_path, dialect="bigquery", template=ProjectTemplate.EMPTY)
+    init_example_project(tmp_path, engine_type="bigquery", template=ProjectTemplate.EMPTY)
     with open(tmp_path / "models" / "test.sql", "w", encoding="utf-8") as f:
         f.write(
             f"""

tests/core/state_sync/test_export_import.py

@@ -74,7 +74,7 @@ def test_export_empty_state(tmp_path: Path, state_sync: StateSync) -> None:
 def test_export_entire_project(
     tmp_path: Path, example_project_config: Config, state_sync: StateSync
 ) -> None:
-    init_example_project(path=tmp_path, dialect="duckdb")
+    init_example_project(path=tmp_path, engine_type="duckdb")
     context = Context(paths=tmp_path, config=example_project_config, state_sync=state_sync)
 
     # prod
@@ -159,7 +159,7 @@ def test_export_specific_environment(
     tmp_path: Path, example_project_config: Config, state_sync: StateSync
 ) -> None:
     output_file = tmp_path / "state_dump.json"
-    init_example_project(path=tmp_path, dialect="duckdb")
+    init_example_project(path=tmp_path, engine_type="duckdb")
     context = Context(paths=tmp_path, config=example_project_config, state_sync=state_sync)
 
     # create prod
@@ -231,7 +231,7 @@ def test_export_local_state(
     tmp_path: Path, example_project_config: Config, state_sync: StateSync
 ) -> None:
     output_file = tmp_path / "state_dump.json"
-    init_example_project(path=tmp_path, dialect="duckdb")
+    init_example_project(path=tmp_path, engine_type="duckdb")
     context = Context(paths=tmp_path, config=example_project_config, state_sync=state_sync)
 
     # create prod
@@ -385,7 +385,7 @@ def test_import_local_state_fails(
     tmp_path: Path, example_project_config: Config, state_sync: StateSync
 ) -> None:
     output_file = tmp_path / "state_dump.json"
-    init_example_project(path=tmp_path, dialect="duckdb")
+    init_example_project(path=tmp_path, engine_type="duckdb")
     context = Context(paths=tmp_path, config=example_project_config, state_sync=state_sync)
 
     export_state(state_sync, output_file, context.snapshots)
@@ -400,7 +400,7 @@ def test_import_partial(
     tmp_path: Path, example_project_config: Config, state_sync: StateSync
 ) -> None:
     output_file = tmp_path / "state_dump.json"
-    init_example_project(path=tmp_path, dialect="duckdb")
+    init_example_project(path=tmp_path, engine_type="duckdb")
     context = Context(paths=tmp_path, config=example_project_config, state_sync=state_sync)
 
     # create prod
@@ -453,7 +453,7 @@ def test_import_partial(
 def test_roundtrip(tmp_path: Path, example_project_config: Config, state_sync: StateSync) -> None:
     state_file = tmp_path / "state_dump.json"
 
-    init_example_project(path=tmp_path, dialect="duckdb")
+    init_example_project(path=tmp_path, engine_type="duckdb")
     context = Context(paths=tmp_path, config=example_project_config, state_sync=state_sync)
 
     # populate initial state
@@ -525,7 +525,7 @@ def test_roundtrip(tmp_path: Path, example_project_config: Config, state_sync: S
 def test_roundtrip_includes_auto_restatements(
     tmp_path: Path, example_project_config: Config, state_sync: StateSync
 ) -> None:
-    init_example_project(path=tmp_path, dialect="duckdb")
+    init_example_project(path=tmp_path, engine_type="duckdb")
 
     # add a model with auto restatements
     (tmp_path / c.MODELS / "new_model.sql").write_text("""

tests/core/test_context.py

@@ -2092,7 +2092,7 @@ def test_audit():
 
 
 def test_prompt_if_uncategorized_snapshot(mocker: MockerFixture, tmp_path: Path) -> None:
-    init_example_project(tmp_path, dialect="duckdb")
+    init_example_project(tmp_path, engine_type="duckdb")
 
     config = Config(
         model_defaults=ModelDefaultsConfig(dialect="duckdb"),

tests/core/test_integration.py

@@ -4003,7 +4003,7 @@ def fail_auto_restatement(evaluator, start: exp.Expression, **kwargs: t.Any) ->
 
 
 def test_plan_twice_with_star_macro_yields_no_diff(tmp_path: Path):
-    init_example_project(tmp_path, dialect="duckdb")
+    init_example_project(tmp_path, engine_type="duckdb")
 
     star_model_definition = """
         MODEL (
@@ -6334,13 +6334,13 @@ def plan_with_output(ctx: Context, environment: str):
     assert "Differences from the `prod` environment" in output.stdout
 
     assert (
-        """MODEL (                                                                        
-   name test.a,                                                                 
-+  owner test,                                                                  
-   kind FULL                                                                    
- )                                                                              
- SELECT                                                                         
--  5 AS col                                                                     
+        """MODEL (
+   name test.a,
++  owner test,
+   kind FULL
+ )
+ SELECT
+-  5 AS col
 +  10 AS col"""
         in output.stdout
     )

tests/core/test_loader.py

@@ -68,7 +68,7 @@ def test_duplicate_model_names_different_kind(tmp_path: Path, sample_models):
     else:
         model_2, model_3 = models[0], None
 
-    init_example_project(tmp_path, dialect="duckdb")
+    init_example_project(tmp_path, engine_type="duckdb")
     config = Config(model_defaults=ModelDefaultsConfig(dialect="duckdb"))
 
     path_1: Path = tmp_path / model_1["path"]
@@ -98,7 +98,7 @@ def duplicate_model_path(fpath):
         return Path(fpath).parent / ("duplicate" + Path(fpath).suffix)
 
     model = sample_models[0]
-    init_example_project(tmp_path, dialect="duckdb")
+    init_example_project(tmp_path, engine_type="duckdb")
     config = Config(model_defaults=ModelDefaultsConfig(dialect="duckdb"))
 
     path_1: Path = tmp_path / model["path"]
@@ -118,7 +118,7 @@ def duplicate_model_path(fpath):
 @pytest.mark.registry_isolation
 def test_duplicate_python_model_names_raise_error(tmp_path: Path) -> None:
     """Test python models with duplicate model names raises ConfigError if the functions are not identical."""
-    init_example_project(tmp_path, dialect="duckdb")
+    init_example_project(tmp_path, engine_type="duckdb")
     config = Config(model_defaults=ModelDefaultsConfig(dialect="duckdb"))
     model_name = "test_schema.test_model"
 
@@ -167,7 +167,7 @@ def execute(
 @pytest.mark.slow
 def test_duplicate_python_model_names_no_error(tmp_path: Path) -> None:
     """Test python models with duplicate model names raises no error if the functions are identical."""
-    init_example_project(tmp_path, dialect="duckdb")
+    init_example_project(tmp_path, engine_type="duckdb")
     config = Config(model_defaults=ModelDefaultsConfig(dialect="duckdb"))
     model_name = "test_schema.test_model"