Feat!: POSITION and all their variants for all dialects (#4606)

* Feat!: POSITION for all dialects

* Feat: add clickhouse parsing test

* cleanup

* mypy fix

* Comments addressed

* more tests and default params for strposition_sql

* test fix

* cleanup

* another cleanup

* more comments addressed

Author: pruzko

sqlglot/dialects/bigquery.py

@@ -26,7 +26,7 @@
     timestrtotime_sql,
     ts_or_ds_add_cast,
     unit_to_var,
-    str_position_sql,
+    strposition_sql,
 )
 from sqlglot.helper import seq_get, split_num_words
 from sqlglot.tokens import TokenType
@@ -934,7 +934,11 @@ class Generator(generator.Generator):
                 "DETERMINISTIC" if e.name == "IMMUTABLE" else "NOT DETERMINISTIC"
             ),
             exp.String: rename_func("STRING"),
-            exp.StrPosition: str_position_sql,
+            exp.StrPosition: lambda self, e: (
+                strposition_sql(
+                    self, e, func_name="INSTR", supports_position=True, supports_occurrence=True
+                )
+            ),
             exp.StrToDate: _str_to_datetime_sql,
             exp.StrToTime: _str_to_datetime_sql,
             exp.TimeAdd: date_add_interval_sql("TIME", "ADD"),

sqlglot/dialects/clickhouse.py

@@ -16,6 +16,7 @@
     build_json_extract_path,
     rename_func,
     sha256_sql,
+    strposition_sql,
     var_map_sql,
     timestamptrunc_sql,
     unit_to_var,
@@ -997,8 +998,12 @@ class Generator(generator.Generator):
             exp.RegexpLike: lambda self, e: self.func("match", e.this, e.expression),
             exp.Rand: rename_func("randCanonical"),
             exp.StartsWith: rename_func("startsWith"),
-            exp.StrPosition: lambda self, e: self.func(
-                "position", e.this, e.args.get("substr"), e.args.get("position")
+            exp.StrPosition: lambda self, e: strposition_sql(
+                self,
+                e,
+                func_name="POSITION",
+                supports_position=True,
+                use_ansi_position=False,
             ),
             exp.TimeToStr: lambda self, e: self.func(
                 "formatDateTime", e.this, self.format_time(e), e.args.get("zone")

sqlglot/dialects/dialect.py

@@ -1067,36 +1067,46 @@ def property_sql(self: Generator, expression: exp.Property) -> str:
     return f"{self.property_name(expression, string_key=True)}={self.sql(expression, 'value')}"
 
 
-def str_position_sql(
+def strposition_sql(
     self: Generator,
     expression: exp.StrPosition,
-    generate_instance: bool = False,
-    str_position_func_name: str = "STRPOS",
+    func_name: str = "STRPOS",
+    supports_position: bool = False,
+    supports_occurrence: bool = False,
+    use_ansi_position: bool = True,
 ) -> str:
-    this = self.sql(expression, "this")
-    substr = self.sql(expression, "substr")
-    position = self.sql(expression, "position")
-    instance = expression.args.get("instance") if generate_instance else None
-    position_offset = ""
-
-    if position:
-        # Normalize third 'pos' argument into 'SUBSTR(..) + offset' across dialects
-        this = self.func("SUBSTR", this, position)
-        position_offset = f" + {position} - 1"
-
-    strpos_sql = self.func(str_position_func_name, this, substr, instance)
-
-    if position_offset:
-        zero = exp.Literal.number(0)
-        # If match is not found (returns 0) the position offset should not be applied
-        case = exp.If(
-            this=exp.EQ(this=strpos_sql, expression=zero),
-            true=zero,
-            false=strpos_sql + position_offset,
-        )
-        strpos_sql = self.sql(case)
+    string = expression.this
+    substr = expression.args.get("substr")
+    position = expression.args.get("position")
+    occurrence = expression.args.get("occurrence")
+    zero = exp.Literal.number(0)
+    one = exp.Literal.number(1)
+
+    if supports_occurrence and occurrence and supports_position and not position:
+        position = one
+
+    if position and not supports_position:
+        string = exp.Substring(this=string, start=position)
+
+    if func_name == "POSITION" and use_ansi_position:
+        func = exp.Anonymous(this=func_name, expressions=[exp.In(this=substr, field=string)])
+    else:
+        args = [substr, string] if func_name in ("LOCATE", "CHARINDEX") else [string, substr]
+        if supports_position:
+            args.append(position)
+        if occurrence:
+            if supports_occurrence:
+                args.append(occurrence)
+            else:
+                self.unsupported(f"{func_name} does not support the occurrence parameter.")
+        func = exp.Anonymous(this=func_name, expressions=args)
+
+    if position and not supports_position:
+        func_with_offset = exp.Sub(this=func + position, expression=one)
+        func_wrapped = exp.If(this=func.eq(zero), true=zero, false=func_with_offset)
+        return self.sql(func_wrapped)
 
-    return strpos_sql
+    return self.sql(func)
 
 
 def struct_extract_sql(self: Generator, expression: exp.StructExtract) -> str:
@@ -1269,18 +1279,6 @@ def no_datetime_sql(self: Generator, expression: exp.Datetime) -> str:
     return self.sql(exp.cast(exp.Add(this=this, expression=expr), exp.DataType.Type.TIMESTAMP))
 
 
-def locate_to_strposition(args: t.List) -> exp.Expression:
-    return exp.StrPosition(
-        this=seq_get(args, 1), substr=seq_get(args, 0), position=seq_get(args, 2)
-    )
-
-
-def strposition_to_locate_sql(self: Generator, expression: exp.StrPosition) -> str:
-    return self.func(
-        "LOCATE", expression.args.get("substr"), expression.this, expression.args.get("position")
-    )
-
-
 def left_to_substring_sql(self: Generator, expression: exp.Left) -> str:
     return self.sql(
         exp.Substring(

sqlglot/dialects/drill.py

@@ -8,7 +8,7 @@
     build_formatted_time,
     no_trycast_sql,
     rename_func,
-    str_position_sql,
+    strposition_sql,
     timestrtotime_sql,
 )
 from sqlglot.dialects.mysql import date_add_sql
@@ -136,12 +136,12 @@ class Generator(generator.Generator):
             ),
             exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}",
             exp.RegexpLike: rename_func("REGEXP_MATCHES"),
-            exp.StrPosition: str_position_sql,
             exp.StrToDate: _str_to_date,
             exp.Pow: rename_func("POW"),
             exp.Select: transforms.preprocess(
                 [transforms.eliminate_distinct_on, transforms.eliminate_semi_and_anti_joins]
             ),
+            exp.StrPosition: strposition_sql,
             exp.StrToTime: lambda self, e: self.func("TO_TIMESTAMP", e.this, self.format_time(e)),
             exp.TimeStrToDate: lambda self, e: self.sql(exp.cast(e.this, exp.DataType.Type.DATE)),
             exp.TimeStrToTime: timestrtotime_sql,

sqlglot/dialects/duckdb.py

@@ -24,7 +24,7 @@
     no_timestamp_sql,
     pivot_column_names,
     rename_func,
-    str_position_sql,
+    strposition_sql,
     str_to_time_sql,
     timestamptrunc_sql,
     timestrtotime_sql,
@@ -618,7 +618,7 @@ class Generator(generator.Generator):
             exp.SHA2: sha256_sql,
             exp.Split: rename_func("STR_SPLIT"),
             exp.SortArray: _sort_array_sql,
-            exp.StrPosition: str_position_sql,
+            exp.StrPosition: strposition_sql,
             exp.StrToUnix: lambda self, e: self.func(
                 "EPOCH", self.func("STRPTIME", e.this, self.format_time(e))
             ),

sqlglot/dialects/hive.py

@@ -15,7 +15,6 @@
     if_sql,
     is_parse_json,
     left_to_substring_sql,
-    locate_to_strposition,
     max_or_greatest,
     min_or_least,
     no_ilike_sql,
@@ -25,7 +24,7 @@
     regexp_replace_sql,
     rename_func,
     right_to_substring_sql,
-    strposition_to_locate_sql,
+    strposition_sql,
     struct_extract_sql,
     time_format,
     timestrtotime_sql,
@@ -305,7 +304,6 @@ class Parser(parser.Parser):
             "GET_JSON_OBJECT": exp.JSONExtractScalar.from_arg_list,
             "LAST": _build_with_ignore_nulls(exp.Last),
             "LAST_VALUE": _build_with_ignore_nulls(exp.LastValue),
-            "LOCATE": locate_to_strposition,
             "MAP": parser.build_var_map,
             "MONTH": lambda args: exp.Month(this=exp.TsOrDsToDate.from_arg_list(args)),
             "PERCENTILE": exp.Quantile.from_arg_list,
@@ -562,7 +560,9 @@ class Generator(generator.Generator):
                     transforms.any_to_exists,
                 ]
             ),
-            exp.StrPosition: strposition_to_locate_sql,
+            exp.StrPosition: lambda self, e: strposition_sql(
+                self, e, func_name="LOCATE", supports_position=True
+            ),
             exp.StrToDate: _str_to_date_sql,
             exp.StrToTime: _str_to_time_sql,
             exp.StrToUnix: _str_to_unix_sql,

sqlglot/dialects/mysql.py

@@ -12,7 +12,6 @@
     build_formatted_time,
     isnull_to_is_null,
     length_or_char_length_sql,
-    locate_to_strposition,
     max_or_greatest,
     min_or_least,
     no_ilike_sql,
@@ -23,7 +22,7 @@
     build_date_delta,
     build_date_delta_with_interval,
     rename_func,
-    strposition_to_locate_sql,
+    strposition_sql,
     unit_to_var,
     trim_sql,
     timestrtotime_sql,
@@ -311,7 +310,6 @@ class Parser(parser.Parser):
             "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))),
             "MONTHNAME": lambda args: exp.TimeToStr(
@@ -750,7 +748,9 @@ class Generator(generator.Generator):
                     transforms.unnest_generate_date_array_using_recursive_cte,
                 ]
             ),
-            exp.StrPosition: strposition_to_locate_sql,
+            exp.StrPosition: lambda self, e: strposition_sql(
+                self, e, func_name="LOCATE", supports_position=True
+            ),
             exp.StrToDate: _str_to_date_sql,
             exp.StrToTime: _str_to_date_sql,
             exp.Stuff: rename_func("INSERT"),

sqlglot/dialects/oracle.py

@@ -9,7 +9,7 @@
     build_formatted_time,
     no_ilike_sql,
     rename_func,
-    str_position_sql,
+    strposition_sql,
     to_number_with_nls_param,
     trim_sql,
 )
@@ -300,8 +300,10 @@ class Generator(generator.Generator):
                     transforms.eliminate_qualify,
                 ]
             ),
-            exp.StrPosition: lambda self, e: str_position_sql(
-                self, e, str_position_func_name="INSTR"
+            exp.StrPosition: lambda self, e: (
+                strposition_sql(
+                    self, e, func_name="INSTR", supports_position=True, supports_occurrence=True
+                )
             ),
             exp.StrToTime: lambda self, e: self.func("TO_TIMESTAMP", e.this, self.format_time(e)),
             exp.StrToDate: lambda self, e: self.func("TO_DATE", e.this, self.format_time(e)),

sqlglot/dialects/postgres.py

@@ -32,7 +32,7 @@
     timestrtotime_sql,
     trim_sql,
     ts_or_ds_add_cast,
-    str_position_sql,
+    strposition_sql,
 )
 from sqlglot.helper import is_int, seq_get
 from sqlglot.parser import binary_range_parser
@@ -584,7 +584,7 @@ class Generator(generator.Generator):
                 ]
             ),
             exp.SHA2: sha256_sql,
-            exp.StrPosition: str_position_sql,
+            exp.StrPosition: lambda self, e: strposition_sql(self, e, func_name="POSITION"),
             exp.StrToDate: lambda self, e: self.func("TO_DATE", e.this, self.format_time(e)),
             exp.StrToTime: lambda self, e: self.func("TO_TIMESTAMP", e.this, self.format_time(e)),
             exp.StructExtract: struct_extract_sql,

sqlglot/dialects/presto.py

@@ -21,8 +21,8 @@
     rename_func,
     right_to_substring_sql,
     sha256_sql,
+    strposition_sql,
     struct_extract_sql,
-    str_position_sql,
     timestamptrunc_sql,
     timestrtotime_sql,
     ts_or_ds_add_cast,
@@ -291,7 +291,7 @@ class Parser(parser.Parser):
             "SET_AGG": exp.ArrayUniqueAgg.from_arg_list,
             "SPLIT_TO_MAP": exp.StrToMap.from_arg_list,
             "STRPOS": lambda args: exp.StrPosition(
-                this=seq_get(args, 0), substr=seq_get(args, 1), instance=seq_get(args, 2)
+                this=seq_get(args, 0), substr=seq_get(args, 1), occurrence=seq_get(args, 2)
             ),
             "TO_CHAR": _build_to_char,
             "TO_UNIXTIME": exp.TimeToUnix.from_arg_list,
@@ -428,7 +428,7 @@ class Generator(generator.Generator):
                 ]
             ),
             exp.SortArray: _no_sort_array,
-            exp.StrPosition: lambda self, e: str_position_sql(self, e, generate_instance=True),
+            exp.StrPosition: lambda self, e: strposition_sql(self, e, supports_occurrence=True),
             exp.StrToDate: lambda self, e: f"CAST({_str_to_time_sql(self, e)} AS DATE)",
             exp.StrToMap: rename_func("SPLIT_TO_MAP"),
             exp.StrToTime: _str_to_time_sql,