lakehouse_engine.utils.sql_parser_utils

  1"""Module to parse sql files."""
  2
  3from typing import Union
  4
  5from lakehouse_engine.core.definitions import SQLParser
  6
  7
  8class SQLParserUtils(object):
  9    """Parser utilities class."""
 10
 11    def split_sql_commands(
 12        self,
 13        sql_commands: str,
 14        delimiter: str,
 15        advanced_parser: bool,
 16    ) -> list[str]:
 17        """Read the sql commands of a file to choose how to split them.
 18
 19        Args:
 20            sql_commands: commands to be split.
 21            delimiter: delimiter to split the sql commands.
 22            advanced_parser: boolean to define if we need to use a complex split.
 23
 24        Returns:
 25            List with the sql commands.
 26        """
 27        if advanced_parser:
 28            self.sql_commands: str = sql_commands
 29            self.delimiter: str = delimiter
 30            self.separated_sql_commands: list[str] = []
 31            self.split_index: int = 0
 32            return self._split_sql_commands()
 33        else:
 34            return sql_commands.split(delimiter)
 35
 36    def _split_sql_commands(self) -> list[str]:
 37        """Read the sql commands of a file to split them based on a delimiter.
 38
 39        Returns:
 40            List with the sql commands.
 41        """
 42        single_quotes: int = 0
 43        double_quotes: int = 0
 44        one_line_comment: int = 0
 45        multiple_line_comment: int = 0
 46
 47        for index, char in enumerate(self.sql_commands):
 48            if char == SQLParser.SINGLE_QUOTES.value and self._character_validation(
 49                value=[double_quotes, one_line_comment, multiple_line_comment]
 50            ):
 51                single_quotes = self._update_value(
 52                    value=single_quotes,
 53                    condition=self._character_validation(
 54                        value=self._get_substring(first_char=index - 1, last_char=index)
 55                    ),
 56                    operation="+-",
 57                )
 58            elif char == SQLParser.DOUBLE_QUOTES.value and self._character_validation(
 59                value=[single_quotes, one_line_comment, multiple_line_comment]
 60            ):
 61                double_quotes = self._update_value(
 62                    value=double_quotes,
 63                    condition=self._character_validation(
 64                        value=self._get_substring(first_char=index - 1, last_char=index)
 65                    ),
 66                    operation="+-",
 67                )
 68            elif char == SQLParser.SINGLE_TRACE.value and self._character_validation(
 69                value=[double_quotes, single_quotes, multiple_line_comment]
 70            ):
 71                one_line_comment = self._update_value(
 72                    value=one_line_comment,
 73                    condition=(
 74                        self._get_substring(first_char=index, last_char=index + 2)
 75                        == SQLParser.DOUBLE_TRACES.value
 76                    ),
 77                    operation="+",
 78                )
 79            elif (
 80                char == SQLParser.SLASH.value or char == SQLParser.STAR.value
 81            ) and self._character_validation(
 82                value=[double_quotes, single_quotes, one_line_comment]
 83            ):
 84                multiple_line_comment = self._update_value(
 85                    value=multiple_line_comment,
 86                    condition=self._get_substring(first_char=index, last_char=index + 2)
 87                    in SQLParser.MULTIPLE_LINE_COMMENT.value,
 88                    operation="+-",
 89                )
 90
 91            one_line_comment = self._update_value(
 92                value=one_line_comment,
 93                condition=char == SQLParser.PARAGRAPH.value,
 94                operation="-",
 95            )
 96
 97            self._validate_command_is_closed(
 98                index=index,
 99                dependencies=self._character_validation(
100                    value=[
101                        single_quotes,
102                        double_quotes,
103                        one_line_comment,
104                        multiple_line_comment,
105                    ]
106                ),
107            )
108
109        return self.separated_sql_commands
110
111    def _get_substring(self, first_char: int = None, last_char: int = None) -> str:
112        """Get the substring based on the indexes passed as arguments.
113
114        Args:
115            first_char: represents the first index of the string.
116            last_char: represents the last index of the string.
117
118        Returns:
119            The substring based on the indexes passed as arguments.
120        """
121        return self.sql_commands[first_char:last_char]
122
123    def _validate_command_is_closed(self, index: int, dependencies: int) -> None:
124        """Validate based on the delimiter if we have the closing of a sql command.
125
126        Args:
127            index: index of the character in a string.
128            dependencies: represents an int to validate if we are outside of quotes,...
129        """
130        if (
131            self._get_substring(first_char=index, last_char=index + len(self.delimiter))
132            == self.delimiter
133            and dependencies
134        ):
135            self._add_new_command(
136                sql_command=self._get_substring(
137                    first_char=self.split_index, last_char=index
138                )
139            )
140            self.split_index = index + len(self.delimiter)
141
142        if self._get_substring(
143            first_char=index, last_char=index + len(self.delimiter)
144        ) != self.delimiter and index + len(self.delimiter) == len(self.sql_commands):
145            self._add_new_command(
146                sql_command=self._get_substring(
147                    first_char=self.split_index, last_char=len(self.sql_commands)
148                )
149            )
150
151    def _character_validation(self, value: Union[str, list]) -> bool:
152        """Validate if character is the opening/closing/inside of a comment.
153
154        Args:
155            value: represent the value associated to different validated
156            types or a character to be analyzed.
157
158        Returns:
159            Boolean that indicates if character found is the opening
160            or closing of a comment, is inside of quotes, comments,...
161        """
162        if value.__class__.__name__ == "list":
163            return sum(value) == 0
164        else:
165            return value != SQLParser.BACKSLASH.value
166
167    def _add_new_command(self, sql_command: str) -> None:
168        """Add a newly found command to list of sql commands to execute.
169
170        Args:
171            sql_command: command to be added to list.
172        """
173        self.separated_sql_commands.append(str(sql_command))
174
175    def _update_value(self, value: int, operation: str, condition: bool = False) -> int:
176        """Update value associated to different types of comments or quotes.
177
178        Args:
179            value: value to be updated
180            operation: operation that we want to perform on the value.
181            condition: validate if we have a condition associated to the value.
182
183        Returns:
184            A integer that represents the updated value.
185        """
186        if condition and operation == "+-":
187            value = value + 1 if value == 0 else value - 1
188        elif condition and operation == "+":
189            value = value + 1 if value == 0 else value
190        elif condition and operation == "-":
191            value = value - 1 if value == 1 else value
192
193        return value