feat(duckdb): INSTALL extension

Author: betodealmeida

sqlglot/dialects/duckdb.py

@@ -338,6 +338,8 @@ class Tokenizer(tokens.Tokenizer):
             "DATETIME": TokenType.TIMESTAMPNTZ,
             "DETACH": TokenType.DETACH,
             "EXCLUDE": TokenType.EXCEPT,
+            "FORCE": TokenType.FORCE,
+            "INSTALL": TokenType.INSTALL,
             "LOGICAL": TokenType.BOOLEAN,
             "ONLY": TokenType.ONLY,
             "PIVOT_WIDER": TokenType.PIVOT,
@@ -494,6 +496,8 @@ class Parser(parser.Parser):
             **parser.Parser.STATEMENT_PARSERS,
             TokenType.ATTACH: lambda self: self._parse_attach_detach(),
             TokenType.DETACH: lambda self: self._parse_attach_detach(is_attach=False),
+            TokenType.FORCE: lambda self: self._parse_force(),
+            TokenType.INSTALL: lambda self: self._parse_install(),
             TokenType.SHOW: lambda self: self._parse_show(),
         }
 
@@ -631,6 +635,26 @@ def _parse_attach_option() -> exp.AttachOption:
         def _parse_show_duckdb(self, this: str) -> exp.Show:
             return self.expression(exp.Show, this=this)
 
+        def _parse_force(self) -> exp.Install:
+            # FORCE can only be followed by INSTALL in DuckDB
+            if not self._match(TokenType.INSTALL):
+                self.raise_error("Expected INSTALL after FORCE")
+
+            return self._parse_install(force=True)
+
+        def _parse_install(self, force: bool = False) -> exp.Install:
+            # Parse extension name (can be a string path or identifier)
+            this = self._parse_string() or self._parse_id_var()
+
+            # Parse optional FROM clause
+            from_ = None
+            if self._match(TokenType.FROM):
+                from_ = self._parse_string() or self._parse_id_var()
+                if not from_:
+                    self.raise_error("Expected repository name after FROM")
+
+            return self.expression(exp.Install, this=this, from_=from_, force=force)
+
         def _parse_primary(self) -> t.Optional[exp.Expression]:
             if self._match_pair(TokenType.HASH, TokenType.NUMBER):
                 return exp.PositionalColumn(this=exp.Literal.number(self._prev.text))
@@ -944,6 +968,13 @@ def lambda_sql(
         def show_sql(self, expression: exp.Show) -> str:
             return f"SHOW {expression.name}"
 
+        def install_sql(self, expression: exp.Install) -> str:
+            force = "FORCE " if expression.args.get("force") else ""
+            this = self.sql(expression, "this")
+            from_ = expression.args.get("from_")
+            from_clause = f" FROM {self.sql(from_)}" if from_ else ""
+            return f"{force}INSTALL {this}{from_clause}"
+
         def fromiso8601timestamp_sql(self, expression: exp.FromISO8601Timestamp) -> str:
             return self.sql(exp.cast(expression.this, exp.DataType.Type.TIMESTAMPTZ))
 

sqlglot/expressions.py

@@ -1571,6 +1571,11 @@ class Detach(Expression):
     arg_types = {"this": True, "exists": False}
 
 
+# https://duckdb.org/docs/sql/statements/load_and_install.html
+class Install(Expression):
+    arg_types = {"this": True, "from_": False, "force": False}
+
+
 # https://duckdb.org/docs/guides/meta/summarize.html
 class Summarize(Expression):
     arg_types = {"this": True, "table": False}

sqlglot/tokens.py

@@ -306,6 +306,7 @@ class TokenType(AutoName):
     INDEX = auto()
     INNER = auto()
     INSERT = auto()
+    INSTALL = auto()
     INTERSECT = auto()
     INTERVAL = auto()
     INTO = auto()

tests/dialects/test_duckdb.py

@@ -1733,6 +1733,87 @@ def test_reset(self):
         self.validate_identity("RESET LOCAL threads", check_command_warning=True)
         self.validate_identity("RESET SESSION default_collation", check_command_warning=True)
 
+    def test_install(self):
+        # Test basic INSTALL command
+        self.validate_identity("INSTALL httpfs")
+        self.validate_identity("INSTALL spatial")
+
+        # Test INSTALL with string literals (file paths)
+        self.validate_identity("INSTALL 'path/to/extension.duckdb_extension'")
+        self.validate_identity("INSTALL '/absolute/path/to/extension.duckdb_extension'")
+
+        # Test INSTALL with FROM clause
+        self.validate_identity("INSTALL httpfs FROM community")
+        self.validate_identity("INSTALL spatial FROM community")
+        self.validate_identity("INSTALL h3 FROM community")
+        self.validate_identity("INSTALL spatial FROM core_nightly")
+
+        # Test INSTALL with FROM clause using string literals (URLs)
+        self.validate_identity("INSTALL spatial FROM 'http://nightly-extensions.duckdb.org'")
+        self.validate_identity("INSTALL httpfs FROM 'https://extensions.duckdb.org'")
+
+        # Test FORCE INSTALL command
+        self.validate_identity("FORCE INSTALL httpfs")
+        self.validate_identity("FORCE INSTALL spatial")
+
+        # Test FORCE INSTALL with FROM clause
+        self.validate_identity("FORCE INSTALL httpfs FROM community")
+        self.validate_identity("FORCE INSTALL spatial FROM community")
+        self.validate_identity("FORCE INSTALL spatial FROM 'http://nightly-extensions.duckdb.org'")
+
+        # Test parsing and generation of Install expression
+        install_expr = parse_one("INSTALL httpfs", dialect="duckdb")
+        self.assertIsInstance(install_expr, exp.Install)
+        self.assertEqual(install_expr.args["this"].name, "httpfs")
+        self.assertIsNone(install_expr.args.get("from_"))
+        self.assertFalse(install_expr.args.get("force", False))
+
+        # Test parsing with FROM clause
+        install_with_from = parse_one("INSTALL spatial FROM community", dialect="duckdb")
+        self.assertIsInstance(install_with_from, exp.Install)
+        self.assertEqual(install_with_from.args["this"].name, "spatial")
+        self.assertEqual(install_with_from.args["from_"].name, "community")
+        self.assertFalse(install_with_from.args.get("force", False))
+
+        # Test parsing FORCE INSTALL
+        force_install = parse_one("FORCE INSTALL httpfs", dialect="duckdb")
+        self.assertIsInstance(force_install, exp.Install)
+        self.assertEqual(force_install.args["this"].name, "httpfs")
+        self.assertIsNone(force_install.args.get("from_"))
+        self.assertTrue(force_install.args.get("force", False))
+
+        # Test FORCE INSTALL with FROM
+        force_install_from = parse_one("FORCE INSTALL spatial FROM community", dialect="duckdb")
+        self.assertIsInstance(force_install_from, exp.Install)
+        self.assertEqual(force_install_from.args["this"].name, "spatial")
+        self.assertEqual(force_install_from.args["from_"].name, "community")
+        self.assertTrue(force_install_from.args.get("force", False))
+
+        # Test string path parsing
+        install_path = parse_one("INSTALL 'path/to/ext.duckdb_extension'", dialect="duckdb")
+        self.assertIsInstance(install_path, exp.Install)
+        self.assertEqual(install_path.args["this"].this, "path/to/ext.duckdb_extension")
+
+        # Test cross-dialect compatibility (should not parse as Install in other dialects)
+        # In other dialects, INSTALL should not be recognized as a special command
+        try:
+            non_duckdb_result = parse_one("INSTALL httpfs", dialect="postgres")
+            # Should parse as something else, not Install
+            self.assertNotIsInstance(non_duckdb_result, exp.Install)
+        except Exception:
+            # Or fail to parse entirely, which is also acceptable
+            pass
+
+        # Test error cases
+        with self.assertRaises(ParseError):
+            parse_one("INSTALL", dialect="duckdb")  # Missing extension name
+
+        with self.assertRaises(ParseError):
+            parse_one("FORCE", dialect="duckdb")  # FORCE without INSTALL
+
+        with self.assertRaises(ParseError):
+            parse_one("INSTALL httpfs FROM", dialect="duckdb")  # FROM without repository
+
     def test_map_struct(self):
         self.validate_identity("MAP {1: 'a', 2: 'b'}")
         self.validate_identity("MAP {'1': 'a', '2': 'b'}")

tests/test_expressions.py

@@ -1262,3 +1262,38 @@ def test_convert_datetime_time(self):
 
         self.assertIsInstance(result, exp.TsOrDsToTime)
         self.assertEqual(result.sql(), "CAST('12:00:00' AS TIME)")
+
+    def test_install_expression(self):
+        # Test Install expression construction
+        install = exp.Install(this=exp.Identifier(this="httpfs"))
+        self.assertEqual(install.args["this"].name, "httpfs")
+        self.assertIsNone(install.args.get("from_"))
+        self.assertFalse(install.args.get("force", False))
+
+        # Test Install with FROM clause
+        install_with_from = exp.Install(
+            this=exp.Identifier(this="spatial"), from_=exp.Identifier(this="community")
+        )
+        self.assertEqual(install_with_from.args["this"].name, "spatial")
+        self.assertEqual(install_with_from.args["from_"].name, "community")
+        self.assertFalse(install_with_from.args.get("force", False))
+
+        # Test FORCE Install
+        force_install = exp.Install(this=exp.Identifier(this="httpfs"), force=True)
+        self.assertEqual(force_install.args["this"].name, "httpfs")
+        self.assertIsNone(force_install.args.get("from_"))
+        self.assertTrue(force_install.args.get("force", False))
+
+        # Test Install with string literal
+        install_path = exp.Install(this=exp.Literal.string("path/to/ext.duckdb_extension"))
+        self.assertEqual(install_path.args["this"].this, "path/to/ext.duckdb_extension")
+        self.assertTrue(install_path.args["this"].is_string)
+
+        # Test Install expression key
+        install = exp.Install(this=exp.Identifier(this="httpfs"))
+        self.assertEqual(install.key, "install")
+
+        # Test Install arg_types validation
+        self.assertEqual(exp.Install.arg_types["this"], True)  # Required
+        self.assertEqual(exp.Install.arg_types["from_"], False)  # Optional
+        self.assertEqual(exp.Install.arg_types["force"], False)  # Optional

tests/test_tokens.py

@@ -208,3 +208,53 @@ def test_token_repr(self):
             repr(Tokenizer().tokenize("foo")),
             "[<Token token_type: TokenType.VAR, text: foo, line: 1, col: 3, start: 0, end: 2, comments: []>]",
         )
+
+    def test_duckdb_install_tokens(self):
+        from sqlglot.dialects import DuckDB
+
+        tokenizer = DuckDB.Tokenizer()
+
+        # Test INSTALL token
+        tokens = tokenizer.tokenize("INSTALL httpfs")
+        self.assertEqual(tokens[0].token_type, TokenType.INSTALL)
+        self.assertEqual(tokens[0].text, "INSTALL")
+        self.assertEqual(tokens[1].token_type, TokenType.VAR)
+        self.assertEqual(tokens[1].text, "httpfs")
+
+        # Test FORCE token
+        tokens = tokenizer.tokenize("FORCE INSTALL httpfs")
+        self.assertEqual(tokens[0].token_type, TokenType.FORCE)
+        self.assertEqual(tokens[0].text, "FORCE")
+        self.assertEqual(tokens[1].token_type, TokenType.INSTALL)
+        self.assertEqual(tokens[1].text, "INSTALL")
+        self.assertEqual(tokens[2].token_type, TokenType.VAR)
+        self.assertEqual(tokens[2].text, "httpfs")
+
+        # Test INSTALL with FROM
+        tokens = tokenizer.tokenize("INSTALL spatial FROM community")
+        self.assertEqual(tokens[0].token_type, TokenType.INSTALL)
+        self.assertEqual(tokens[0].text, "INSTALL")
+        self.assertEqual(tokens[1].token_type, TokenType.VAR)
+        self.assertEqual(tokens[1].text, "spatial")
+        self.assertEqual(tokens[2].token_type, TokenType.FROM)
+        self.assertEqual(tokens[2].text, "FROM")
+        self.assertEqual(tokens[3].token_type, TokenType.VAR)
+        self.assertEqual(tokens[3].text, "community")
+
+        # Test INSTALL with string literal
+        tokens = tokenizer.tokenize("INSTALL 'path/to/ext.duckdb_extension'")
+        self.assertEqual(tokens[0].token_type, TokenType.INSTALL)
+        self.assertEqual(tokens[0].text, "INSTALL")
+        self.assertEqual(tokens[1].token_type, TokenType.STRING)
+        self.assertEqual(tokens[1].text, "path/to/ext.duckdb_extension")
+
+        # Test case insensitivity
+        tokens = tokenizer.tokenize("install httpfs")
+        self.assertEqual(tokens[0].token_type, TokenType.INSTALL)
+        self.assertEqual(tokens[0].text, "install")
+
+        tokens = tokenizer.tokenize("force install httpfs")
+        self.assertEqual(tokens[0].token_type, TokenType.FORCE)
+        self.assertEqual(tokens[0].text, "force")
+        self.assertEqual(tokens[1].token_type, TokenType.INSTALL)
+        self.assertEqual(tokens[1].text, "install")