Feat: add ability to create dialect plugins (#6627)

Author: vgvoleg

README.md

@@ -588,3 +588,29 @@ x + interval '1' month
 **Official Dialects** are maintained by the core SQLGlot team with higher priority for bug fixes and feature additions.
 
 **Community Dialects** are developed and maintained primarily through community contributions. These are fully functional but may receive lower priority for issue resolution compared to officially supported dialects. We welcome and encourage community contributions to improve these dialects.
+
+### Creating a Dialect Plugin
+
+If your database isn't supported, you can create a plugin that registers a custom dialect via entry points. Create a package with your dialect class and register it in `setup.py`:
+
+```python
+from setuptools import setup
+
+setup(
+    name="mydb-sqlglot-dialect",
+    entry_points={
+        "sqlglot.dialects": [
+            "mydb = my_package.dialect:MyDB",
+        ],
+    },
+)
+```
+
+The dialect will be automatically discovered and can be used like any built-in dialect:
+
+```python
+from sqlglot import transpile
+transpile("SELECT * FROM t", read="mydb", write="postgres")
+```
+
+See the [Custom Dialects](#custom-dialects) section for implementation details.

sqlglot/dialects/dialect.py

@@ -27,6 +27,8 @@
 from sqlglot.trie import new_trie
 from sqlglot.typing import EXPRESSION_METADATA
 
+from importlib.metadata import entry_points
+
 DATE_ADD_OR_DIFF = t.Union[
     exp.DateAdd,
     exp.DateDiff,
@@ -66,6 +68,8 @@
     "\\\\": "\\",
 }
 
+PLUGIN_GROUP_NAME = "sqlglot.dialects"
+
 
 class Dialects(str, Enum):
     """Dialects supported by SQLGLot."""
@@ -153,12 +157,54 @@ def _try_load(cls, key: str | Dialects) -> None:
         if isinstance(key, Dialects):
             key = key.value
 
-        # This import will lead to a new dialect being loaded, and hence, registered.
-        # We check that the key is an actual sqlglot module to avoid blindly importing
-        # files. Custom user dialects need to be imported at the top-level package, in
-        # order for them to be registered as soon as possible.
+        # 1. Try standard sqlglot modules first
         if key in DIALECT_MODULE_NAMES:
+            module = importlib.import_module(f"sqlglot.dialects.{key}")
+            # If module was already imported, the class may not be in _classes
+            # Find and register the dialect class from the module
+            if key not in cls._classes:
+                for attr_name in dir(module):
+                    attr = getattr(module, attr_name, None)
+                    if (
+                        isinstance(attr, type)
+                        and issubclass(attr, Dialect)
+                        and attr.__name__.lower() == key
+                    ):
+                        cls._classes[key] = attr
+                        break
+            return
+
+        # 2. Try entry points (for plugins)
+        try:
+            all_eps = entry_points()
+            # Python 3.10+ has select() method, older versions use dict-like access
+            if hasattr(all_eps, "select"):
+                eps = all_eps.select(group=PLUGIN_GROUP_NAME, name=key)
+            else:
+                # For older Python versions, entry_points() returns a dict-like object
+                group_eps = all_eps.get(PLUGIN_GROUP_NAME, [])  # type: ignore
+                eps = [ep for ep in group_eps if ep.name == key]  # type: ignore
+
+            for entry_point in eps:
+                dialect_class = entry_point.load()
+                # Verify it's a Dialect subclass
+                # issubclass() returns False if not a subclass, TypeError only if not a class at all
+                if isinstance(dialect_class, type) and issubclass(dialect_class, Dialect):
+                    # Register the dialect using the entry point name (key)
+                    # The metaclass may have registered it by class name, but we need it by entry point name
+                    if key not in cls._classes:
+                        cls._classes[key] = dialect_class
+                    return
+        except ImportError:
+            # entry_point.load() failed (bad plugin - module/class doesn't exist)
+            pass
+
+        # 3. Try direct import (for backward compatibility)
+        # This allows namespace packages or explicit imports to work
+        try:
             importlib.import_module(f"sqlglot.dialects.{key}")
+        except ImportError:
+            pass
 
     @classmethod
     def __getitem__(cls, key: str) -> t.Type[Dialect]:
@@ -947,7 +993,9 @@ def get_or_raise(cls, dialect: DialectType) -> Dialect:
 
             result = cls.get(dialect_name.strip())
             if not result:
-                suggest_closest_match_and_fail("dialect", dialect_name, list(DIALECT_MODULE_NAMES))
+                # Include both built-in dialects and any loaded dialects for better error messages
+                all_dialects = set(DIALECT_MODULE_NAMES) | set(cls._classes.keys())
+                suggest_closest_match_and_fail("dialect", dialect_name, all_dialects)
 
             assert result is not None
             return result(**kwargs)

tests/test_dialect_entry_points.py

@@ -0,0 +1,64 @@
+import unittest
+from unittest.mock import Mock, patch
+
+from sqlglot import Dialect
+from sqlglot.dialects.dialect import Dialect as DialectBase
+
+
+class FakeDialect(DialectBase):
+    pass
+
+
+class TestDialectEntryPoints(unittest.TestCase):
+    def setUp(self):
+        Dialect._classes.clear()
+
+    def tearDown(self):
+        Dialect._classes.clear()
+
+    def test_entry_point_plugin_discovery_modern_api(self):
+        fake_entry_point = Mock()
+        fake_entry_point.name = "fakedb"
+        fake_entry_point.load.return_value = FakeDialect
+
+        mock_selectable = Mock()
+        mock_selectable.select.return_value = [fake_entry_point]
+
+        mock_entry_points = Mock(return_value=mock_selectable)
+
+        with patch("sqlglot.dialects.dialect.entry_points", mock_entry_points):
+            dialect = Dialect.get("fakedb")
+
+        self.assertIsNotNone(dialect)
+        self.assertEqual(dialect, FakeDialect)
+        fake_entry_point.load.assert_called_once()
+        mock_selectable.select.assert_called_once_with(group="sqlglot.dialects", name="fakedb")
+
+    def test_entry_point_plugin_discovery_legacy_api(self):
+        fake_entry_point = Mock()
+        fake_entry_point.name = "fakedb"
+        fake_entry_point.load.return_value = FakeDialect
+
+        mock_dict = Mock(spec=["get"])
+        mock_dict.get.return_value = [fake_entry_point]
+
+        mock_entry_points = Mock(return_value=mock_dict)
+
+        with patch("sqlglot.dialects.dialect.entry_points", mock_entry_points):
+            dialect = Dialect.get("fakedb")
+
+        self.assertIsNotNone(dialect)
+        self.assertEqual(dialect, FakeDialect)
+        fake_entry_point.load.assert_called_once()
+        mock_dict.get.assert_called_once_with("sqlglot.dialects", [])
+
+    def test_entry_point_plugin_not_found(self):
+        mock_selectable = Mock()
+        mock_selectable.select.return_value = []
+
+        mock_entry_points = Mock(return_value=mock_selectable)
+
+        with patch("sqlglot.dialects.dialect.entry_points", mock_entry_points):
+            dialect = Dialect.get("nonexistent")
+
+        self.assertIsNone(dialect)