Feat!: improve transpilation of CHAR[ACTER]_LENGTH (#4555)

* CHAR_LENGTH for postgres

* len(x) fixed

* postgress fixed

* len removed from postgres

* psql add length(x, ecoding) and test

Author: pruzko

sqlglot/dialects/mysql.py

@@ -295,8 +295,6 @@ class Parser(parser.Parser):
 
         FUNCTIONS = {
             **parser.Parser.FUNCTIONS,
-            "CHAR_LENGTH": exp.Length.from_arg_list,
-            "CHARACTER_LENGTH": exp.Length.from_arg_list,
             "CONVERT_TZ": lambda args: exp.ConvertTimezone(
                 source_tz=seq_get(args, 1), target_tz=seq_get(args, 2), timestamp=seq_get(args, 0)
             ),
@@ -311,6 +309,7 @@ class Parser(parser.Parser):
             "FORMAT": exp.NumberToStr.from_arg_list,
             "FROM_UNIXTIME": build_formatted_time(exp.UnixToTime, "mysql"),
             "ISNULL": isnull_to_is_null,
+            "LENGTH": lambda args: exp.Length(this=seq_get(args, 0), binary=True),
             "LOCATE": locate_to_strposition,
             "MAKETIME": exp.TimeFromParts.from_arg_list,
             "MONTH": lambda args: exp.Month(this=exp.TsOrDsToDate(this=seq_get(args, 0))),
@@ -731,7 +730,6 @@ class Generator(generator.Generator):
             e: f"""GROUP_CONCAT({self.sql(e, "this")} SEPARATOR {self.sql(e, "separator") or "','"})""",
             exp.ILike: no_ilike_sql,
             exp.JSONExtractScalar: arrow_json_extract_sql,
-            exp.Length: rename_func("CHAR_LENGTH"),
             exp.LogicalOr: rename_func("MAX"),
             exp.LogicalAnd: rename_func("MIN"),
             exp.Max: max_or_greatest,
@@ -1265,3 +1263,7 @@ def attimezone_sql(self, expression: exp.AtTimeZone) -> str:
 
         def isascii_sql(self, expression: exp.IsAscii) -> str:
             return f"REGEXP_LIKE({self.sql(expression.this)}, '^[[:ascii:]]*$')"
+
+        def length_sql(self, expression: exp.Length) -> str:
+            length_func = "LENGTH" if expression.args.get("binary") else "CHAR_LENGTH"
+            return self.func(length_func, expression.this)

sqlglot/dialects/postgres.py

@@ -377,6 +377,7 @@ class Parser(parser.Parser):
             "GENERATE_SERIES": _build_generate_series,
             "JSON_EXTRACT_PATH": build_json_extract_path(exp.JSONExtract),
             "JSON_EXTRACT_PATH_TEXT": build_json_extract_path(exp.JSONExtractScalar),
+            "LENGTH": lambda args: exp.Length(this=seq_get(args, 0), encoding=seq_get(args, 1)),
             "MAKE_TIME": exp.TimeFromParts.from_arg_list,
             "MAKE_TIMESTAMP": exp.TimestampFromParts.from_arg_list,
             "NOW": exp.CurrentTimestamp.from_arg_list,

sqlglot/expressions.py

@@ -6153,7 +6153,7 @@ class Right(Func):
 
 
 class Length(Func):
-    arg_types = {"this": True, "binary": False}
+    arg_types = {"this": True, "binary": False, "encoding": False}
     _sql_names = ["LENGTH", "LEN"]
 
 

sqlglot/parser.py

@@ -188,6 +188,8 @@ class Parser(metaclass=_Parser):
             this=seq_get(args, 0), nulls_excluded=dialect.ARRAY_AGG_INCLUDES_NULLS is None or None
         ),
         "CHAR": lambda args: exp.Chr(expressions=args),
+        "CHAR_LENGTH": exp.Length.from_arg_list,
+        "CHARACTER_LENGTH": exp.Length.from_arg_list,
         "CHR": lambda args: exp.Chr(expressions=args),
         "COUNT": lambda args: exp.Count(this=seq_get(args, 0), expressions=args[1:], big_int=True),
         "CONCAT": lambda args, dialect: exp.Concat(

tests/dialects/test_mysql.py

@@ -725,6 +725,7 @@ def test_mysql(self):
                     write={
                         "duckdb": "SELECT LENGTH('foo')",
                         "mysql": "SELECT CHAR_LENGTH('foo')",
+                        "postgres": "SELECT LENGTH('foo')",
                     },
                 )
 

tests/dialects/test_postgres.py

@@ -49,6 +49,10 @@ def test_postgres(self):
         self.validate_identity("CAST(x AS DATERANGE)")
         self.validate_identity("CAST(x AS DATEMULTIRANGE)")
         self.validate_identity("x$")
+        self.validate_identity("LENGTH(x)")
+        self.validate_identity("LENGTH(x, utf8)")
+        self.validate_identity("CHAR_LENGTH(x)", "LENGTH(x)")
+        self.validate_identity("CHARACTER_LENGTH(x)", "LENGTH(x)")
         self.validate_identity("SELECT ARRAY[1, 2, 3]")
         self.validate_identity("SELECT ARRAY(SELECT 1)")
         self.validate_identity("STRING_AGG(x, y)")