Core: Add MultiStringParser to match a collection of strings

src/sqlfluff/core/parser/__init__.py

@@ -31,7 +31,12 @@
     OptionallyBracketed,
     Conditional,
 )
-from sqlfluff.core.parser.parsers import StringParser, NamedParser, RegexParser
+from sqlfluff.core.parser.parsers import (
+    StringParser,
+    NamedParser,
+    RegexParser,
+    MultiStringParser,
+)
 from sqlfluff.core.parser.markers import PositionMarker
 from sqlfluff.core.parser.lexer import Lexer, StringLexer, RegexLexer
 from sqlfluff.core.parser.parser import Parser
@@ -65,6 +70,7 @@
     "OptionallyBracketed",
     "Conditional",
     "StringParser",
+    "MultiStringParser",
     "NamedParser",
     "RegexParser",
     "PositionMarker",

src/sqlfluff/core/parser/parsers.py

@@ -4,7 +4,7 @@
 """
 
 import regex
-from typing import Type, Optional, List, Tuple, Union
+from typing import Collection, Type, Optional, List, Tuple, Union
 
 from sqlfluff.core.parser.context import ParseContext
 from sqlfluff.core.parser.matchable import Matchable
@@ -100,6 +100,47 @@ def match(
         return MatchResult.from_unmatched(segments)
 
 
+class MultiStringParser(StringParser):
+    """An object which matches and returns raw segments on a collection of strings."""
+
+    def __init__(
+        self,
+        templates: Collection[str],
+        raw_class: Type[RawSegment],
+        name: Optional[str] = None,
+        type: Optional[str] = None,
+        optional: bool = False,
+        **segment_kwargs,
+    ):
+        self.templates = {template.upper() for template in templates}
+        super().__init__(
+            template="",
+            raw_class=raw_class,
+            name=name,
+            type=type,
+            optional=optional,
+            **segment_kwargs,
+        )
+        # Delete attribute which is replaced by `self.templates` for this `Parser``
+        del self.template
+
+    def simple(self, parse_context: "ParseContext") -> Optional[List[str]]:
+        """Return simple options for this matcher.
+
+        Because string matchers are not case sensitive we can
+        just return the templates here.
+        """
+        return list(self.templates)
+
+    def _is_first_match(self, segment: BaseSegment):
+        """Does the segment provided match according to the current rules."""
+        # Is the target a match and IS IT CODE.
+        # The latter stops us accidentally matching comments.
+        if segment.is_code and segment.raw.upper() in self.templates:
+            return True
+        return False
+
+
 class NamedParser(StringParser):
     """An object which matches and returns raw segments based on names."""
 

src/sqlfluff/dialects/dialect_ansi.py

@@ -48,6 +48,7 @@
     StringParser,
     SymbolSegment,
     WhitespaceSegment,
+    MultiStringParser,
 )
 from sqlfluff.core.parser.segments.base import BracketedSegment
 from sqlfluff.dialects.dialect_ansi_keywords import (
@@ -273,8 +274,8 @@
     ),
     # The following functions can be called without parentheses per ANSI specification
     BareFunctionSegment=SegmentGenerator(
-        lambda dialect: RegexParser(
-            r"^(" + r"|".join(dialect.sets("bare_functions")) + r")$",
+        lambda dialect: MultiStringParser(
+            dialect.sets("bare_functions"),
             CodeSegment,
             name="bare_function",
             type="bare_function",
@@ -318,16 +319,16 @@
     ),
     # Ansi Intervals
     DatetimeUnitSegment=SegmentGenerator(
-        lambda dialect: RegexParser(
-            r"^(" + r"|".join(dialect.sets("datetime_units")) + r")$",
+        lambda dialect: MultiStringParser(
+            dialect.sets("datetime_units"),
             CodeSegment,
             name="date_part",
             type="date_part",
         )
     ),
     DatePartFunctionName=SegmentGenerator(
-        lambda dialect: RegexParser(
-            r"^(" + r"|".join(dialect.sets("date_part_function_name")) + r")$",
+        lambda dialect: MultiStringParser(
+            dialect.sets("date_part_function_name"),
             CodeSegment,
             name="function_name_identifier",
             type="function_name_identifier",

src/sqlfluff/dialects/dialect_bigquery.py

@@ -35,6 +35,7 @@
     StringLexer,
     StringParser,
     SymbolSegment,
+    MultiStringParser,
 )
 from sqlfluff.core.parser.segments.base import BracketedSegment
 from sqlfluff.dialects.dialect_bigquery_keywords import (
@@ -160,8 +161,8 @@
         ),
     ),
     ExtendedDatetimeUnitSegment=SegmentGenerator(
-        lambda dialect: RegexParser(
-            r"^(" + r"|".join(dialect.sets("extended_datetime_units")) + r")$",
+        lambda dialect: MultiStringParser(
+            dialect.sets("extended_datetime_units"),
             CodeSegment,
             name="date_part",
             type="date_part",

src/sqlfluff/dialects/dialect_exasol.py

@@ -29,6 +29,7 @@
     StringParser,
     RegexParser,
     NewlineSegment,
+    MultiStringParser,
 )
 from sqlfluff.core.dialects import load_raw_dialect
 from sqlfluff.core.parser.segments.generator import SegmentGenerator
@@ -170,16 +171,16 @@
         "escaped_identifier", SymbolSegment, type="identifier"
     ),
     SessionParameterSegment=SegmentGenerator(
-        lambda dialect: RegexParser(
-            r"^(" + r"|".join(dialect.sets("session_parameters")) + r")$",
+        lambda dialect: MultiStringParser(
+            dialect.sets("session_parameters"),
             CodeSegment,
             name="session_parameter",
             type="session_parameter",
         )
     ),
     SystemParameterSegment=SegmentGenerator(
-        lambda dialect: RegexParser(
-            r"^(" + r"|".join(dialect.sets("system_parameters")) + r")$",
+        lambda dialect: MultiStringParser(
+            dialect.sets("system_parameters"),
             CodeSegment,
             name="system_parameter",
             type="system_parameter",

test/core/parser/parser_test.py

@@ -0,0 +1,28 @@
+"""The Test file for Parsers (Matchable Classes)."""
+
+from sqlfluff.core.parser import (
+    KeywordSegment,
+    MultiStringParser,
+)
+from sqlfluff.core.parser.context import RootParseContext
+
+
+def test__parser__multistringparser__match(generate_test_segments):
+    """Test the MultiStringParser matchable."""
+    parser = MultiStringParser(["foo", "bar"], KeywordSegment)
+    with RootParseContext(dialect=None) as ctx:
+        # Check directly
+        seg_list = generate_test_segments(["foo", "fo"])
+        # Matches when it should
+        assert parser.match(seg_list[:1], parse_context=ctx).matched_segments == (
+            KeywordSegment("foo", seg_list[0].pos_marker),
+        )
+        # Doesn't match when it shouldn't
+        assert parser.match(seg_list[1:], parse_context=ctx).matched_segments == tuple()
+
+
+def test__parser__multistringparser__simple():
+    """Test the MultiStringParser matchable."""
+    parser = MultiStringParser(["foo", "bar"], KeywordSegment)
+    with RootParseContext(dialect=None) as ctx:
+        assert parser.simple(ctx)