feat!: include sqlmesh in version check (#2125)

* feat!: include sqlmesh in version check

* update check logic

Author: eakmanrq

sqlmesh/core/state_sync/base.py

@@ -42,6 +42,10 @@ class Versions(PydanticModel):
     def minor_sqlglot_version(self) -> t.Tuple[int, int]:
         return major_minor(self.sqlglot_version)
 
+    @property
+    def minor_sqlmesh_version(self) -> t.Tuple[int, int]:
+        return major_minor(self.sqlmesh_version)
+
     @field_validator("sqlglot_version", "sqlmesh_version", mode="before")
     @classmethod
     def _package_version_validator(cls, v: t.Any) -> str:
@@ -178,6 +182,8 @@ def get_versions(self, validate: bool = True) -> Versions:
         Returns:
             The versions object.
         """
+        from sqlmesh._version import __version__ as SQLMESH_VERSION
+
         versions = self._get_versions()
 
         if validate:
@@ -204,27 +210,32 @@ def raise_error(
                     f"{lib} (local) is using version '{local}' which is behind '{remote}' (remote).{upgrade_suggestion}"
                 )
 
-            if SCHEMA_VERSION < versions.schema_version:
+            if SCHEMA_VERSION != versions.schema_version:
                 raise_error(
                     "SQLMesh",
                     SCHEMA_VERSION,
                     versions.schema_version,
                     remote_package_version=versions.sqlmesh_version,
+                    ahead=SCHEMA_VERSION > versions.schema_version,
                 )
 
-            if major_minor(SQLGLOT_VERSION) < major_minor(versions.sqlglot_version):
+            if major_minor(SQLGLOT_VERSION) != major_minor(versions.sqlglot_version):
                 raise_error(
                     "SQLGlot",
                     SQLGLOT_VERSION,
                     versions.sqlglot_version,
                     remote_package_version=versions.sqlglot_version,
+                    ahead=major_minor(SQLGLOT_VERSION) > major_minor(versions.sqlglot_version),
                 )
 
-            if SCHEMA_VERSION > versions.schema_version:
-                raise_error("SQLMesh", SCHEMA_VERSION, versions.schema_version, ahead=True)
-
-            if major_minor(SQLGLOT_VERSION) > major_minor(versions.sqlglot_version):
-                raise_error("SQLGlot", SQLGLOT_VERSION, versions.sqlglot_version, ahead=True)
+            if major_minor(SQLMESH_VERSION) != major_minor(versions.sqlmesh_version):
+                raise_error(
+                    "SQLMesh",
+                    SQLMESH_VERSION,
+                    versions.sqlmesh_version,
+                    remote_package_version=versions.sqlmesh_version,
+                    ahead=major_minor(SQLMESH_VERSION) > major_minor(versions.sqlmesh_version),
+                )
 
         return versions
 

sqlmesh/core/state_sync/engine_adapter.py

@@ -898,7 +898,11 @@ def migrate(self, default_catalog: t.Optional[str], skip_backup: bool = False) -
         versions = self.get_versions(validate=False)
         migrations = MIGRATIONS[versions.schema_version :]
 
-        if not migrations and major_minor(SQLGLOT_VERSION) == versions.minor_sqlglot_version:
+        if (
+            not migrations
+            and major_minor(SQLGLOT_VERSION) == versions.minor_sqlglot_version
+            and major_minor(SQLMESH_VERSION) == versions.minor_sqlmesh_version
+        ):
             return
 
         if not skip_backup:

tests/core/test_state_sync.py

@@ -1205,7 +1205,7 @@ def test_unpause_snapshots_remove_intervals(
     ]
 
 
-def test_get_version(state_sync: EngineAdapterStateSync) -> None:
+def test_version_schema(state_sync: EngineAdapterStateSync) -> None:
     from sqlmesh import __version__ as SQLMESH_VERSION
 
     # fresh install should not raise
@@ -1250,29 +1250,65 @@ def test_get_version(state_sync: EngineAdapterStateSync) -> None:
         state_sync.get_versions()
     state_sync.get_versions(validate=False)
 
+
+def test_version_sqlmesh(state_sync: EngineAdapterStateSync) -> None:
+    from sqlmesh import __version__ as SQLMESH_VERSION
+    from sqlmesh import __version_tuple__ as SQLMESH_VERSION_TUPLE
+
+    # patch version sqlmesh doesn't matter
+    major, minor, patch, *_ = SQLMESH_VERSION_TUPLE
+    sqlmesh_version_patch_bump = f"{major}.{minor}.{int(patch) + 1}"
+    state_sync._update_versions(sqlmesh_version=sqlmesh_version_patch_bump)
+    state_sync.get_versions(validate=False)
+
+    # sqlmesh version is behind
+    sqlmesh_version_minor_bump = f"{major}.{int(minor) + 1}.{patch}"
+    error = (
+        rf"SQLMesh \(local\) is using version '{SQLMESH_VERSION}' which is behind '{sqlmesh_version_minor_bump}' \(remote\). "
+        rf"""Please upgrade SQLMesh \('pip install --upgrade "sqlmesh=={sqlmesh_version_minor_bump}"' command\)."""
+    )
+    state_sync._update_versions(sqlmesh_version=sqlmesh_version_minor_bump)
+    with pytest.raises(SQLMeshError, match=error):
+        state_sync.get_versions()
+    state_sync.get_versions(validate=False)
+
+    # sqlmesh version is ahead
+    sqlmesh_version_minor_decrease = f"{major}.{int(minor) - 1}.{patch}"
+    error = rf"SQLMesh \(local\) is using version '{SQLMESH_VERSION}' which is ahead of '{sqlmesh_version_minor_decrease}'"
+    state_sync._update_versions(sqlmesh_version=sqlmesh_version_minor_decrease)
+    with pytest.raises(SQLMeshError, match=error):
+        state_sync.get_versions()
+    state_sync.get_versions(validate=False)
+
+
+def test_version_sqlglot(state_sync: EngineAdapterStateSync) -> None:
     # patch version sqlglot doesn't matter
     major, minor, patch, *_ = SQLGLOT_VERSION.split(".")
     sqlglot_version = f"{major}.{minor}.{int(patch) + 1}"
     state_sync._update_versions(sqlglot_version=sqlglot_version)
     state_sync.get_versions(validate=False)
 
-    # sqlglot version is behind, always raise
+    # sqlglot version is behind
     sqlglot_version = f"{major}.{int(minor) + 1}.{patch}"
     error = (
         rf"SQLGlot \(local\) is using version '{SQLGLOT_VERSION}' which is behind '{sqlglot_version}' \(remote\). "
         rf"""Please upgrade SQLGlot \('pip install --upgrade "sqlglot=={sqlglot_version}"' command\)."""
     )
     state_sync._update_versions(sqlglot_version=sqlglot_version)
+    with pytest.raises(SQLMeshError, match=error):
+        state_sync.get_versions()
     state_sync.get_versions(validate=False)
 
-    # sqlglot version is ahead, only raise with validate is true
+    # sqlglot version is ahead
     sqlglot_version = f"{major}.{int(minor) - 1}.{patch}"
     error = rf"SQLGlot \(local\) is using version '{SQLGLOT_VERSION}' which is ahead of '{sqlglot_version}'"
     state_sync._update_versions(sqlglot_version=sqlglot_version)
     with pytest.raises(SQLMeshError, match=error):
         state_sync.get_versions()
     state_sync.get_versions(validate=False)
 
+
+def test_empty_versions() -> None:
     for empty_versions in (
         Versions(),
         Versions(schema_version=None, sqlglot_version=None, sqlmesh_version=None),