criteria-pattern 0.1.1__tar.gz

criteria_pattern-0.1.1/.gitignore

@@ -0,0 +1,12 @@
+# linting files
+.coverage
+
+# cache files/folders
+**cache**
+
+# build and distribution files/folders
+**dist**
+**build**
+
+# environment folders
+**.venv**

criteria_pattern-0.1.1/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) (2024-2025) adriamontoto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

criteria_pattern-0.1.1/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.4
+Name: criteria-pattern
+Version: 0.1.1
+Summary: The Criteria Pattern is a Python package that simplifies and standardizes criteria based filtering, validation and selection.
+Project-URL: Homepage, https://github.com/adriamontoto/criteria-pattern
+Project-URL: Repository, https://github.com/adriamontoto/criteria-pattern
+Project-URL: Issues, https://github.com/adriamontoto/criteria-pattern/issues
+Author: Adria Montoto
+License-Expression: MIT
+License-File: LICENSE.md
+Keywords: criteria,development,filtering,pattern,python,selection,tools,utilities,validation
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: value-object-pattern>=0.2.0
+Description-Content-Type: text/markdown
+
+<a name="readme-top"></a>
+
+# 🤏🏻 Criteria Pattern
+
+<p align="center">
+    <a href="https://github.com/adriamontoto/criteria-pattern/actions/workflows/ci.yaml?event=push&branch=master" target="_blank">
+        <img src="https://github.com/adriamontoto/criteria-pattern/actions/workflows/ci.yaml/badge.svg?event=push&branch=master" alt="CI Pipeline">
+    </a>
+    <a href="https://coverage-badge.samuelcolvin.workers.dev/redirect/adriamontoto/criteria-pattern" target="_blank">
+        <img src="https://coverage-badge.samuelcolvin.workers.dev/adriamontoto/criteria-pattern.svg" alt="Coverage Pipeline">
+    </a>
+    <a href="https://pypi.org/project/criteria-pattern" target="_blank">
+        <img src="https://img.shields.io/pypi/v/criteria-pattern?color=%2334D058&label=pypi%20package" alt="Package Version">
+    </a>
+    <a href="https://pypi.org/project/criteria-pattern/" target="_blank">
+        <img src="https://img.shields.io/pypi/pyversions/criteria-pattern.svg?color=%2334D058" alt="Supported Python Versions">
+    </a>
+</p>
+
+The **Criteria Pattern** is a Python 🐍 package that simplifies and standardizes criteria based filtering 🤏🏻, validation and selection. This package provides a set of prebuilt 👷🏻 objects and utilities that you can drop into your existing projects and not have to implement yourself.
+
+These utilities 🛠️ are useful when you need complex filtering logic. It also enforces 👮🏻 best practices so all your filtering processes follow a uniform standard.
+
+Easy to install and integrate, this is a must have for any Python developer looking to simplify their workflow, enforce design patterns and use the full power of modern ORMs and SQL 🗄️ in their projects 🚀.
+<br><br>
+
+## Table of Contents
+
+- [📥 Installation](#installation)
+- [💻 Utilization](#utilization)
+- [🤝 Contributing](#contributing)
+- [🔑 License](#license)
+
+<p align="right">
+    <a href="#readme-top">🔼 Back to top</a>
+</p><br><br>
+
+<a name="installation"></a>
+
+## 📥 Installation
+
+You can install **Criteria Pattern** using `pip`:
+
+```bash
+pip install criteria-pattern
+```
+
+<p align="right">
+    <a href="#readme-top">🔼 Back to top</a>
+</p><br><br>
+
+<a name="utilization"></a>
+
+## 💻 Utilization
+
+```python
+from criteria_pattern import Criteria, Filter, FilterOperator
+from criteria_pattern.converter import SqlConverter
+
+is_adult = Criteria(filters=[Filter('age', FilterOperator.GREATER_OR_EQUAL, 18)])
+email_is_gmail = Criteria(filters=[Filter('email', FilterOperator.ENDS_WITH, '@gmail.com')])
+email_is_yahoo = Criteria(filters=[Filter('email', FilterOperator.ENDS_WITH, '@yahoo.com')])
+
+query, parameters = SqlConverter.convert(criteria=is_adult & (email_is_gmail | email_is_yahoo), table='user')
+print(query)
+print(parameters)
+# >>> SELECT * FROM user WHERE (age >= %(parameter_0)s AND (email LIKE '%%' || %(parameter_1)s OR email LIKE '%%' || %(parameter_2)s));
+# >>> {'parameter_0': 18, 'parameter_1': '@gmail.com', 'parameter_2': '@yahoo.com'}
+```
+
+<p align="right">
+    <a href="#readme-top">🔼 Back to top</a>
+</p><br><br>
+
+<a name="contributing"></a>
+
+## 🤝 Contributing
+
+We love community help! Before you open an issue or pull request, please read:
+
+- [`🤝 How to Contribute`](https://github.com/adriamontoto/criteria-pattern/blob/master/.github/CONTRIBUTING.md)
+- [`🧭 Code of Conduct`](https://github.com/adriamontoto/criteria-pattern/blob/master/.github/CODE_OF_CONDUCT.md)
+- [`🔐 Security Policy`](https://github.com/adriamontoto/criteria-pattern/blob/master/.github/SECURITY.md)
+
+_Thank you for helping make **🤏🏻 Criteria Pattern** package awesome! 🌟_
+
+<p align="right">
+    <a href="#readme-top">🔼 Back to top</a>
+</p><br><br>
+
+<a name="license"></a>
+
+## 🔑 License
+
+This project is licensed under the terms of the [`MIT license`](https://github.com/adriamontoto/criteria-pattern/blob/master/LICENSE.md).
+
+<p align="right">
+    <a href="#readme-top">🔼 Back to top</a>
+</p>

criteria_pattern-0.1.1/README.md

@@ -0,0 +1,99 @@
+<a name="readme-top"></a>
+
+# 🤏🏻 Criteria Pattern
+
+<p align="center">
+    <a href="https://github.com/adriamontoto/criteria-pattern/actions/workflows/ci.yaml?event=push&branch=master" target="_blank">
+        <img src="https://github.com/adriamontoto/criteria-pattern/actions/workflows/ci.yaml/badge.svg?event=push&branch=master" alt="CI Pipeline">
+    </a>
+    <a href="https://coverage-badge.samuelcolvin.workers.dev/redirect/adriamontoto/criteria-pattern" target="_blank">
+        <img src="https://coverage-badge.samuelcolvin.workers.dev/adriamontoto/criteria-pattern.svg" alt="Coverage Pipeline">
+    </a>
+    <a href="https://pypi.org/project/criteria-pattern" target="_blank">
+        <img src="https://img.shields.io/pypi/v/criteria-pattern?color=%2334D058&label=pypi%20package" alt="Package Version">
+    </a>
+    <a href="https://pypi.org/project/criteria-pattern/" target="_blank">
+        <img src="https://img.shields.io/pypi/pyversions/criteria-pattern.svg?color=%2334D058" alt="Supported Python Versions">
+    </a>
+</p>
+
+The **Criteria Pattern** is a Python 🐍 package that simplifies and standardizes criteria based filtering 🤏🏻, validation and selection. This package provides a set of prebuilt 👷🏻 objects and utilities that you can drop into your existing projects and not have to implement yourself.
+
+These utilities 🛠️ are useful when you need complex filtering logic. It also enforces 👮🏻 best practices so all your filtering processes follow a uniform standard.
+
+Easy to install and integrate, this is a must have for any Python developer looking to simplify their workflow, enforce design patterns and use the full power of modern ORMs and SQL 🗄️ in their projects 🚀.
+<br><br>
+
+## Table of Contents
+
+- [📥 Installation](#installation)
+- [💻 Utilization](#utilization)
+- [🤝 Contributing](#contributing)
+- [🔑 License](#license)
+
+<p align="right">
+    <a href="#readme-top">🔼 Back to top</a>
+</p><br><br>
+
+<a name="installation"></a>
+
+## 📥 Installation
+
+You can install **Criteria Pattern** using `pip`:
+
+```bash
+pip install criteria-pattern
+```
+
+<p align="right">
+    <a href="#readme-top">🔼 Back to top</a>
+</p><br><br>
+
+<a name="utilization"></a>
+
+## 💻 Utilization
+
+```python
+from criteria_pattern import Criteria, Filter, FilterOperator
+from criteria_pattern.converter import SqlConverter
+
+is_adult = Criteria(filters=[Filter('age', FilterOperator.GREATER_OR_EQUAL, 18)])
+email_is_gmail = Criteria(filters=[Filter('email', FilterOperator.ENDS_WITH, '@gmail.com')])
+email_is_yahoo = Criteria(filters=[Filter('email', FilterOperator.ENDS_WITH, '@yahoo.com')])
+
+query, parameters = SqlConverter.convert(criteria=is_adult & (email_is_gmail | email_is_yahoo), table='user')
+print(query)
+print(parameters)
+# >>> SELECT * FROM user WHERE (age >= %(parameter_0)s AND (email LIKE '%%' || %(parameter_1)s OR email LIKE '%%' || %(parameter_2)s));
+# >>> {'parameter_0': 18, 'parameter_1': '@gmail.com', 'parameter_2': '@yahoo.com'}
+```
+
+<p align="right">
+    <a href="#readme-top">🔼 Back to top</a>
+</p><br><br>
+
+<a name="contributing"></a>
+
+## 🤝 Contributing
+
+We love community help! Before you open an issue or pull request, please read:
+
+- [`🤝 How to Contribute`](https://github.com/adriamontoto/criteria-pattern/blob/master/.github/CONTRIBUTING.md)
+- [`🧭 Code of Conduct`](https://github.com/adriamontoto/criteria-pattern/blob/master/.github/CODE_OF_CONDUCT.md)
+- [`🔐 Security Policy`](https://github.com/adriamontoto/criteria-pattern/blob/master/.github/SECURITY.md)
+
+_Thank you for helping make **🤏🏻 Criteria Pattern** package awesome! 🌟_
+
+<p align="right">
+    <a href="#readme-top">🔼 Back to top</a>
+</p><br><br>
+
+<a name="license"></a>
+
+## 🔑 License
+
+This project is licensed under the terms of the [`MIT license`](https://github.com/adriamontoto/criteria-pattern/blob/master/LICENSE.md).
+
+<p align="right">
+    <a href="#readme-top">🔼 Back to top</a>
+</p>

criteria_pattern-0.1.1/criteria_pattern/__init__.py

@@ -0,0 +1,11 @@
+__version__ = '0.1.1'
+
+from .models import Criteria, Filter, FilterOperator, Order, OrderDirection
+
+__all__ = (
+    'Criteria',
+    'Filter',
+    'FilterOperator',
+    'Order',
+    'OrderDirection',
+)

criteria_pattern-0.1.1/criteria_pattern/converter/__init__.py

@@ -0,0 +1,3 @@
+from .sql_converter import SqlConverter
+
+__all__ = ('SqlConverter',)

criteria_pattern-0.1.1/criteria_pattern/converter/sql_converter.py

@@ -0,0 +1,387 @@
+"""
+Raw SQL converter module.
+"""
+
+from collections.abc import Mapping, Sequence
+from typing import Any, assert_never
+
+from criteria_pattern import Criteria, FilterOperator, OrderDirection
+from criteria_pattern.exceptions import InvalidColumnError, InvalidTableError
+from criteria_pattern.models.criteria import AndCriteria, NotCriteria, OrCriteria
+
+
+class SqlConverter:
+    """
+    Raw SQL converter.
+
+    Example:
+    ```python
+    from criteria_pattern import Criteria, Filter, FilterOperator
+    from criteria_pattern.converter import SqlConverter
+
+    is_adult = Criteria(filters=[Filter('age', FilterOperator.GREATER_OR_EQUAL, 18)])
+    email_is_gmail = Criteria(filters=[Filter('email', FilterOperator.ENDS_WITH, '@gmail.com')])
+    email_is_yahoo = Criteria(filters=[Filter('email', FilterOperator.ENDS_WITH, '@yahoo.com')])
+
+    query, parameters = SqlConverter.convert(criteria=is_adult & (email_is_gmail | email_is_yahoo), table='user')
+    print(query)
+    print(parameters)
+    # >>> SELECT * FROM user WHERE (age >= %(parameter_0)s AND (email LIKE '%%' || %(parameter_1)s OR email LIKE '%%' || %(parameter_2)s));
+    # >>> {'parameter_0': 18, 'parameter_1': '@gmail.com', 'parameter_2': '@yahoo.com'}
+    ```
+    """  # noqa: E501
+
+    @classmethod
+    def convert(
+        cls,
+        criteria: Criteria,
+        table: str,
+        columns: Sequence[str] | None = None,
+        columns_mapping: Mapping[str, str] | None = None,
+        check_table_injection: bool = False,
+        check_column_injection: bool = False,
+        check_criteria_injection: bool = False,
+        valid_tables: Sequence[str] | None = None,
+        valid_columns: Sequence[str] | None = None,
+    ) -> tuple[str, dict[str, Any]]:
+        """
+        Convert the Criteria object to a raw SQL query.
+
+        Args:
+            criteria (Criteria): Criteria to convert.
+            table (str): Name of the table to query.
+            columns (Sequence[str], optional): Columns of the table to select. Default to *. Default to *.
+            columns_mapping (Mapping[str, str], optional): Mapping of column names to aliases. Default to empty dict.
+            check_criteria_injection (bool, optional): Raise an error if the criteria field is not in the list of valid
+            columns. Default to False.
+            check_table_injection (bool, optional): Raise an error if the table is not in the list of valid tables.
+            Default to False.
+            check_column_injection (bool, optional): Raise an error if the column is not in the list of valid columns.
+            Default to False.
+            valid_tables (Sequence[str], optional): List of valid tables to query. Default to empty list.
+            valid_columns (Sequence[str], optional): List of valid columns to select. Default to empty list.
+
+        Raises:
+            InvalidTableError: If the table is not in the list of valid tables (only if check_table_injection=True).
+            InvalidColumnError: If the column is not in the list of valid columns (only if check_column_injection=True).
+
+        Returns:
+            tuple[str, dict[str, Any]]: The raw SQL query string and the query parameters.
+
+        Example:
+        ```python
+        from criteria_pattern import Criteria, Filter, FilterOperator
+        from criteria_pattern.converter import SqlConverter
+
+        is_adult = Criteria(filters=[Filter('age', FilterOperator.GREATER_OR_EQUAL, 18)])
+        email_is_gmail = Criteria(filters=[Filter('email', FilterOperator.ENDS_WITH, '@gmail.com')])
+        email_is_yahoo = Criteria(filters=[Filter('email', FilterOperator.ENDS_WITH, '@yahoo.com')])
+
+        query, parameters = SqlConverter.convert(criteria=is_adult & (email_is_gmail | email_is_yahoo), table='user')
+        print(query)
+        print(parameters)
+        # >>> SELECT * FROM user WHERE (age >= %(parameter_0)s AND (email LIKE '%%' || %(parameter_1)s OR email LIKE '%%' || %(parameter_2)s));
+        # >>> {'parameter_0': 18, 'parameter_1': '@gmail.com', 'parameter_2': '@yahoo.com'}
+        ```
+        """  # noqa: E501
+        columns = columns or ['*']
+        columns_mapping = columns_mapping or {}
+        valid_tables = valid_tables or []
+        valid_columns = valid_columns or []
+
+        if check_table_injection:
+            cls._validate_table(table=table, valid_tables=valid_tables)
+
+        if check_column_injection:
+            cls._validate_columns(columns=columns, columns_mapping=columns_mapping, valid_columns=valid_columns)
+
+        if check_criteria_injection:
+            cls._validate_criteria(criteria=criteria, valid_columns=valid_columns)
+
+        query = f'SELECT {", ".join(columns)} FROM {table}'  # noqa: S608  # nosec
+        parameters: dict[str, Any] = {}
+
+        if criteria.has_filters():
+            where_clause, parameters = cls._process_filters(criteria=criteria, columns_mapping=columns_mapping)
+            query += f' WHERE {where_clause}'
+
+        if criteria.has_orders():
+            order_clause = cls._process_orders(criteria=criteria, columns_mapping=columns_mapping)
+            query += f' ORDER BY {order_clause}'
+
+        return f'{query};', parameters
+
+    @classmethod
+    def _validate_table(cls, table: str, valid_tables: Sequence[str]) -> None:
+        """
+        Validate the table name to prevent SQL injection.
+
+        Args:
+            table (str): Name of the table to query.
+            valid_tables (Sequence[str]): List of valid tables to query.
+
+        Raises:
+            InvalidTableError: If the table is not in the list of valid tables.
+        """
+        if table not in valid_tables:
+            raise InvalidTableError(table=table, valid_tables=valid_tables)
+
+    @classmethod
+    def _validate_columns(
+        cls,
+        columns: Sequence[str],
+        columns_mapping: Mapping[str, str],
+        valid_columns: Sequence[str],
+    ) -> None:
+        """
+        Validate the column names to prevent SQL injection.
+
+        Args:
+            columns (Sequence[str]): Columns of the table to select.
+            columns_mapping (Mapping[str, str]): Mapping of column names to aliases.
+            valid_columns (Sequence[str]): List of valid columns to select.
+
+        Raises:
+            InvalidColumnError: If the column is not in the list of valid columns.
+        """
+        for column in columns:
+            if column not in valid_columns:
+                raise InvalidColumnError(column=column, valid_columns=valid_columns)
+
+        for column in columns_mapping.values():
+            if column not in valid_columns:
+                raise InvalidColumnError(column=column, valid_columns=valid_columns)
+
+    @classmethod
+    def _validate_criteria(cls, criteria: Criteria, valid_columns: Sequence[str]) -> None:
+        """
+        Validate the Criteria object to prevent SQL injection.
+
+        Args:
+            criteria (Criteria): Criteria to validate.
+            valid_columns (Sequence[str]): List of valid columns to select.
+
+        Raises:
+            InvalidColumnError: If the column is not in the list of valid columns.
+        """
+        for filter in criteria.filters:
+            if filter.field not in valid_columns:
+                raise InvalidColumnError(column=filter.field, valid_columns=valid_columns)
+
+        for order in criteria.orders:
+            if order.field not in valid_columns:
+                raise InvalidColumnError(column=order.field, valid_columns=valid_columns)
+
+    @classmethod
+    def _process_filters(cls, criteria: Criteria, columns_mapping: Mapping[str, str]) -> tuple[str, dict[str, Any]]:
+        """
+        Process the Criteria object to return an SQL WHERE clause.
+
+        Args:
+            criteria (Criteria): Criteria to process.
+            columns_mapping (Mapping[str, str]): Mapping of column names to aliases.
+
+        Returns:
+            tuple[str, dict[str, Any]]: Processed filter string for SQL WHERE clause and parameters for the SQL query.
+        """
+        return cls._process_filters_recursive(criteria=criteria, columns_mapping=columns_mapping)
+
+    @classmethod
+    def _process_filters_recursive(  # noqa: C901
+        cls,
+        criteria: Criteria,
+        columns_mapping: Mapping[str, str],
+        parameters_counter: int = 0,
+    ) -> tuple[str, dict[str, Any]]:
+        """
+        Process the Criteria object to return an SQL WHERE clause.
+
+        Args:
+            criteria (Criteria): Criteria to process.
+            columns_mapping (Mapping[str, str]): Mapping of column names to aliases.
+            parameters_counter (int): Counter for parameter names to ensure uniqueness.
+
+        Returns:
+            tuple[str, dict[str, Any]]: Processed filter string for SQL WHERE clause and parameters for the SQL query.
+        """
+        filters = ''
+        parameters: dict[str, Any] = {}
+
+        if isinstance(criteria, AndCriteria):
+            left_conditions, left_parameters = cls._process_filters_recursive(
+                criteria=criteria.left,
+                columns_mapping=columns_mapping,
+                parameters_counter=parameters_counter,
+            )
+            parameters_counter += len(left_parameters)
+            parameters.update(left_parameters)
+
+            right_conditions, right_parameters = cls._process_filters_recursive(
+                criteria=criteria.right,
+                columns_mapping=columns_mapping,
+                parameters_counter=parameters_counter,
+            )
+            parameters_counter += len(right_parameters)
+            parameters.update(right_parameters)
+
+            filters += f'({left_conditions} AND {right_conditions})'
+
+            return filters, parameters
+
+        if isinstance(criteria, OrCriteria):
+            left_conditions, left_parameters = cls._process_filters_recursive(
+                criteria=criteria.left,
+                columns_mapping=columns_mapping,
+                parameters_counter=parameters_counter,
+            )
+            parameters_counter += len(left_parameters)
+            parameters.update(left_parameters)
+
+            right_conditions, right_parameters = cls._process_filters_recursive(
+                criteria=criteria.right,
+                columns_mapping=columns_mapping,
+                parameters_counter=parameters_counter,
+            )
+            parameters_counter += len(right_parameters)
+            parameters.update(right_parameters)
+
+            filters += f'({left_conditions} OR {right_conditions})'
+
+            return filters, parameters
+
+        if isinstance(criteria, NotCriteria):
+            not_conditions, not_parameters = cls._process_filters_recursive(
+                criteria=criteria.criteria,
+                columns_mapping=columns_mapping,
+                parameters_counter=parameters_counter,
+            )
+            parameters_counter += len(not_parameters)
+            parameters.update(not_parameters)
+
+            filters += f'NOT ({not_conditions})'
+
+            return filters, parameters
+
+        for filter in criteria.filters:
+            filter_field = columns_mapping.get(filter.field, filter.field)
+            parameter_name = f'parameter_{parameters_counter}'
+            parameters[parameter_name] = filter.value
+            placeholder = f'%({parameter_name})s'
+            parameters_counter += 1
+
+            match filter.operator:
+                case FilterOperator.EQUAL:
+                    filters += f'{filter_field} = {placeholder}'
+
+                case FilterOperator.NOT_EQUAL:
+                    filters += f'{filter_field} != {placeholder}'
+
+                case FilterOperator.GREATER:
+                    filters += f'{filter_field} > {placeholder}'
+
+                case FilterOperator.GREATER_OR_EQUAL:
+                    filters += f'{filter_field} >= {placeholder}'
+
+                case FilterOperator.LESS:
+                    filters += f'{filter_field} < {placeholder}'
+
+                case FilterOperator.LESS_OR_EQUAL:
+                    filters += f'{filter_field} <= {placeholder}'
+
+                case FilterOperator.LIKE:
+                    filters += f'{filter_field} LIKE {placeholder}'
+
+                case FilterOperator.NOT_LIKE:
+                    filters += f'{filter_field} NOT LIKE {placeholder}'
+
+                case FilterOperator.CONTAINS:
+                    filters += f"{filter_field} LIKE '%%' || {placeholder} || '%%'"
+
+                case FilterOperator.NOT_CONTAINS:
+                    filters += f"{filter_field} NOT LIKE '%%' || {placeholder} || '%%'"
+
+                case FilterOperator.STARTS_WITH:
+                    filters += f"{filter_field} LIKE {placeholder} || '%%'"
+
+                case FilterOperator.NOT_STARTS_WITH:
+                    filters += f"{filter_field} NOT LIKE {placeholder} || '%%'"
+
+                case FilterOperator.ENDS_WITH:
+                    filters += f"{filter_field} LIKE '%%' || {placeholder}"
+
+                case FilterOperator.NOT_ENDS_WITH:
+                    filters += f"{filter_field} NOT LIKE '%%' || {placeholder}"
+
+                case FilterOperator.BETWEEN:
+                    parameters.pop(parameter_name)
+                    parameters_counter -= 1
+
+                    start_parameter_name = f'parameter_{parameters_counter}'
+                    end_parameter_name = f'parameter_{parameters_counter + 1}'
+                    parameters[start_parameter_name] = filter.value[0]
+                    parameters[end_parameter_name] = filter.value[1]
+                    start_placeholder = f'%({start_parameter_name})s'
+                    end_placeholder = f'%({end_parameter_name})s'
+                    parameters_counter += 2
+
+                    filters += f'{filter_field} BETWEEN {start_placeholder} AND {end_placeholder}'
+
+                case FilterOperator.NOT_BETWEEN:
+                    parameters.pop(parameter_name)
+                    parameters_counter -= 1
+
+                    start_parameter_name = f'parameter_{parameters_counter}'
+                    end_parameter_name = f'parameter_{parameters_counter + 1}'
+                    parameters[start_parameter_name] = filter.value[0]
+                    parameters[end_parameter_name] = filter.value[1]
+                    start_placeholder = f'%({start_parameter_name})s'
+                    end_placeholder = f'%({end_parameter_name})s'
+                    parameters_counter += 2
+
+                    filters += f'{filter_field} NOT BETWEEN {start_placeholder} AND {end_placeholder}'
+
+                case FilterOperator.IS_NULL:
+                    parameters.pop(parameter_name)
+                    parameters_counter -= 1
+
+                    filters += f'{filter_field} IS NULL'
+
+                case FilterOperator.IS_NOT_NULL:
+                    parameters.pop(parameter_name)
+                    parameters_counter -= 1
+
+                    filters += f'{filter_field} IS NOT NULL'
+
+                case _:  # pragma: no cover
+                    assert_never(filter.operator)
+
+        return filters, parameters
+
+    @classmethod
+    def _process_orders(cls, criteria: Criteria, columns_mapping: Mapping[str, str]) -> str:
+        """
+        Process the Criteria object to return an SQL ORDER BY clause.
+
+        Args:
+            criteria (Criteria): Criteria to process.
+            columns_mapping (Mapping[str, str]): Mapping of column names to aliases.
+
+        Returns:
+            str: Processed order string for SQL ORDER BY clause.
+        """
+        orders = ''
+
+        for order in criteria.orders:
+            order_field = columns_mapping.get(order.field, order.field)
+
+            match order.direction:
+                case OrderDirection.ASC:
+                    orders += f'{order_field} ASC, '
+
+                case OrderDirection.DESC:
+                    orders += f'{order_field} DESC, '
+
+                case _:  # pragma: no cover
+                    assert_never(order.direction)
+
+        return orders.rstrip(', ')

criteria_pattern-0.1.1/criteria_pattern/exceptions/__init__.py

@@ -0,0 +1,9 @@
+from .invalid_column_error import InvalidColumnError
+from .invalid_table_error import InvalidTableError
+from .sql_converter_error import SqlConverterError
+
+__all__ = (
+    'InvalidColumnError',
+    'InvalidTableError',
+    'SqlConverterError',
+)