hare-orm 0.9.0__py3-none-any.whl

hare/sql/terms/term.py

@@ -0,0 +1,334 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, cast
+
+from hare.sql.builder_methods import BuilderMethods
+from hare.sql.constants import DEFAULT_SQL_CONTEXT
+from hare.sql.enums import Arithmetic, Equality, Matching
+from hare.sql.sql_context import SqlContext
+from hare.sql.terms.node import TNode
+
+if TYPE_CHECKING:
+    from typing import Self
+
+    from hare.sql.builder.queries.query_builder import QueryBuilder
+    from hare.sql.builder.tables.table import Table
+    from hare.sql.terms.json import JSON
+    from hare.sql.terms.negative import Negative
+    from hare.sql.terms.values.literal_value import LiteralValue
+    from hare.sql.terms.values.null_value import NullValue
+    from hare.sql.terms.values.value_wrapper import ValueWrapper
+from hare.sql.terms.node import Node
+
+
+class Term(Node):
+    """The base of the terms of a statement - what its SQL is written of, combined by operators."""
+
+    is_aggregate: bool | None = False
+    #: Whether the term writes its subquery without correlation itself where the database has no
+    #: correlated subqueries (``Features.supports_correlated_subqueries``) - an ``EXISTS``.
+    rewrites_inner_correlation = False
+    #: Whether the term is a query built apart from the statement it is written into - its query is
+    #: ``get_nested_query()``.
+    holds_nested_query = False
+    #: Whether the term's value is a ``sensitive=True`` field's - its parameter is never shown
+    #: (``QueryParameters``).
+    sensitive = False
+
+    @staticmethod
+    def get_combined_is_aggregate(values: list[bool | None]) -> bool | None:
+        """Returns the ``is_aggregate`` of an expression made of several terms: each term is an
+        aggregate (True), is not (False) or fits either way (None, a constant).
+
+        Args:
+            values: The terms' ``is_aggregate`` values.
+
+        Returns:
+            True when every term that isn't None is an aggregate, False when one of them isn't,
+            None when all of them are None.
+        """
+        decided = [value for value in values if value is not None]
+        if decided:
+            return all(decided)
+        return None
+
+    def __init__(self, alias: str | None = None) -> None:
+        self.alias = alias
+
+    def __copy__(self) -> Self:
+        # A shallow __dict__ copy without copy.copy()'s generic path - a hot path.
+        new_term = type(self).__new__(type(self))
+        new_term.__dict__.update(self.__dict__)
+        return new_term
+
+    @BuilderMethods.builder
+    def as_(self, alias: str) -> Self:
+        self.alias = alias
+        return self
+
+    @property
+    def tables_(self) -> set[Table]:
+        from hare.sql import Table
+
+        return set(self.find_(Table))
+
+    def fields_(self) -> set[field_terms.Field]:
+        return set(self.find_(field_terms.Field))
+
+    @staticmethod
+    def wrap_constant(
+        value: Any, wrapper_class: type[Term] | None = None
+    ) -> TNode | LiteralValue | array_terms.Array | tuple_terms.Tuple | ValueWrapper:
+        """Wraps raw inputs such as numbers so they can be used in Criterions and Operator.
+
+        For example, the expression F('abc')+1 stores the integer part in a ValueWrapper object.
+
+        Args:
+            value: Any value.
+            wrapper_class: A hare.sql class which wraps a constant value so it can be handled as
+                a component of the query.
+
+        Returns:
+            Raw string, number, or decimal values are returned in a ValueWrapper. Fields and
+            other parts of the querybuilder are returned as inputted.
+        """
+        if isinstance(value, Node):
+            return cast("TNode", value)
+        if value is None:
+            return null_value_terms.NullValue()
+        if isinstance(value, list):
+            return array_terms.Array(*value)
+        if isinstance(value, tuple):
+            return tuple_terms.Tuple(*value)
+
+        # Need to default here to avoid the recursion. ValueWrapper extends this class.
+        wrapper_class = wrapper_class or value_wrapper_terms.ValueWrapper
+        return wrapper_class(value)  # type:ignore[return-value]
+
+    @staticmethod
+    def wrap_json(
+        value: Term | QueryBuilder | str | int | bool | dict[str, Any] | list[Any] | None,
+        wrapper_class: type[ValueWrapper] | None = None,
+    ) -> Term | QueryBuilder | NullValue | ValueWrapper | JSON:
+        """A value as a term of a JSON expression - a term as it is, None as ``NULL``, a text or a number as a
+        value, a dict or a list as a JSON value.
+
+        Args:
+            value: The value.
+            wrapper_class: The class wrapping a plain value.
+
+        Returns:
+            The term.
+        """
+        # Imported here: the modules import each other.
+        from hare.sql.builder.queries.query_builder import QueryBuilder
+        from hare.sql.terms.json import JSON
+        from hare.sql.terms.values.null_value import NullValue
+        from hare.sql.terms.values.value_wrapper import ValueWrapper
+
+        if isinstance(value, (Term, QueryBuilder)):
+            return value
+        if value is None:
+            return NullValue()
+        if isinstance(value, (str, int, bool)):
+            wrapper_class = wrapper_class or ValueWrapper
+            return wrapper_class(value)
+
+        return JSON(value)
+
+    def replace_table(self, current_table: Table | None, new_table: Table | None) -> Self:
+        """Replaces all occurrences of the specified table with the new table.
+
+        Useful when reusing fields across queries. The base implementation returns self because
+        not all terms have a table property.
+
+        Args:
+            current_table: The table to be replaced.
+            new_table: The table to replace with.
+
+        Returns:
+            Self.
+        """
+        return self
+
+    def eq(self, other: Any) -> criteria_terms.BasicCriterion:
+        return self == other
+
+    def isnull(self) -> criteria_terms.NullCriterion:
+
+        return criteria_terms.NullCriterion(self)
+
+    def notnull(self) -> criteria_terms.Not:
+        return self.isnull().negate()
+
+    def is_not_true(self) -> criteria_terms.IsNotTrueCriterion:
+
+        return criteria_terms.IsNotTrueCriterion(self)
+
+    def is_distinct_from(self, other: Any) -> criteria_terms.IsDistinctFromCriterion:
+
+        return criteria_terms.IsDistinctFromCriterion(self, self.wrap_constant(other))
+
+    def gt(self, other: Any) -> criteria_terms.BasicCriterion:
+        return self > other
+
+    def gte(self, other: Any) -> criteria_terms.BasicCriterion:
+        return self >= other
+
+    def lt(self, other: Any) -> criteria_terms.BasicCriterion:
+        return self < other
+
+    def lte(self, other: Any) -> criteria_terms.BasicCriterion:
+        return self <= other
+
+    def ne(self, other: Any) -> criteria_terms.BasicCriterion:
+        return self != other
+
+    def like(self, expression: str) -> criteria_terms.BasicCriterion:
+
+        return criteria_terms.BasicCriterion(Matching.LIKE, self, self.wrap_constant(expression))
+
+    def regex(self, pattern: str) -> criteria_terms.BasicCriterion:
+
+        return criteria_terms.BasicCriterion(Matching.REGEX, self, self.wrap_constant(pattern))
+
+    def between(self, lower: Any, upper: Any) -> criteria_terms.BetweenCriterion:
+
+        return criteria_terms.BetweenCriterion(self, self.wrap_constant(lower), self.wrap_constant(upper))
+
+    def isin(self, arg: list[Any] | tuple[Any, ...] | set[Any] | Term) -> criteria_terms.ContainsCriterion:
+
+        if isinstance(arg, (list, tuple, set)):
+            return criteria_terms.ContainsCriterion(self, tuple_terms.Tuple(*arg))
+        return criteria_terms.ContainsCriterion(self, arg)
+
+    def notin(self, arg: list[Any] | tuple[Any, ...] | set[Any] | Term) -> criteria_terms.ContainsCriterion:
+        return self.isin(arg).negate()
+
+    def negate(self) -> criteria_terms.Not:
+
+        return criteria_terms.Not(self)
+
+    def __invert__(self) -> criteria_terms.Not:
+
+        return criteria_terms.Not(self)
+
+    def __pos__(self) -> Self:
+        return self
+
+    def __neg__(self) -> Negative:
+        return negative_terms.Negative(self)
+
+    def __add__(self, other: Any) -> arithmetic_terms.ArithmeticExpression:
+
+        return arithmetic_terms.ArithmeticExpression(Arithmetic.ADD, self, self.wrap_constant(other))
+
+    def __sub__(self, other: Any) -> arithmetic_terms.ArithmeticExpression:
+
+        return arithmetic_terms.ArithmeticExpression(Arithmetic.SUB, self, self.wrap_constant(other))
+
+    def __mul__(self, other: Any) -> arithmetic_terms.ArithmeticExpression:
+
+        return arithmetic_terms.ArithmeticExpression(Arithmetic.MUL, self, self.wrap_constant(other))
+
+    def __truediv__(self, other: Any) -> arithmetic_terms.ArithmeticExpression:
+
+        return arithmetic_terms.ArithmeticExpression(Arithmetic.DIV, self, self.wrap_constant(other))
+
+    def __pow__(self, other: Any) -> function_terms.Pow:
+        return function_terms.Pow(self, other)
+
+    def __mod__(self, other: Any) -> function_terms.Mod:
+
+        return function_terms.Mod(self, other)
+
+    def __radd__(self, other: Any) -> arithmetic_terms.ArithmeticExpression:
+
+        return arithmetic_terms.ArithmeticExpression(Arithmetic.ADD, self.wrap_constant(other), self)
+
+    def __rsub__(self, other: Any) -> arithmetic_terms.ArithmeticExpression:
+
+        return arithmetic_terms.ArithmeticExpression(Arithmetic.SUB, self.wrap_constant(other), self)
+
+    def __rmul__(self, other: Any) -> arithmetic_terms.ArithmeticExpression:
+
+        return arithmetic_terms.ArithmeticExpression(Arithmetic.MUL, self.wrap_constant(other), self)
+
+    def __rtruediv__(self, other: Any) -> arithmetic_terms.ArithmeticExpression:
+
+        return arithmetic_terms.ArithmeticExpression(Arithmetic.DIV, self.wrap_constant(other), self)
+
+    def __eq__(self, other: Any) -> criteria_terms.BasicCriterion | criteria_terms.NullCriterion:  # type:ignore[override]
+        # `field = NULL`/`field <> NULL` are always NULL (never TRUE) in SQL - a criterion built
+        # that way matches nothing, silently. `field == None`/`field != None` must render as
+        # IS NULL/IS NOT NULL instead.
+
+        if other is None:
+            return self.isnull()
+        return criteria_terms.BasicCriterion(Equality.EQ, self, self.wrap_constant(other))
+
+    def __ne__(self, other: Any) -> criteria_terms.BasicCriterion | criteria_terms.Not:  # type:ignore[override]
+
+        if other is None:
+            return self.isnull().negate()
+        return criteria_terms.BasicCriterion(Equality.NE, self, self.wrap_constant(other))
+
+    def __gt__(self, other: Any) -> criteria_terms.BasicCriterion:
+
+        return criteria_terms.BasicCriterion(Equality.GT, self, self.wrap_constant(other))
+
+    def __ge__(self, other: Any) -> criteria_terms.BasicCriterion:
+
+        return criteria_terms.BasicCriterion(Equality.GTE, self, self.wrap_constant(other))
+
+    def __lt__(self, other: Any) -> criteria_terms.BasicCriterion:
+
+        return criteria_terms.BasicCriterion(Equality.LT, self, self.wrap_constant(other))
+
+    def __le__(self, other: Any) -> criteria_terms.BasicCriterion:
+
+        return criteria_terms.BasicCriterion(Equality.LTE, self, self.wrap_constant(other))
+
+    def __getitem__(self, item: slice) -> criteria_terms.BetweenCriterion:
+        if not isinstance(item, slice):
+            raise TypeError("Field' object is not subscriptable")
+        return self.between(item.start, item.stop)
+
+    def __str__(self) -> str:
+        return self.get_sql(DEFAULT_SQL_CONTEXT)
+
+    def __hash__(self) -> int:
+        # Term.__eq__ builds a criterion, so the hash is of the rendered SQL - cached, as a builder
+        # returns copies and never changes an instance.
+        cached = self.__dict__.get("_hash_cache")
+        if cached is not None:
+            return cached
+        sql_context = DEFAULT_SQL_CONTEXT.copy(with_alias=True)
+        computed = hash(self.get_sql(sql_context))
+        self.__dict__["_hash_cache"] = computed
+        return computed
+
+    def get_sql(self, sql_context: SqlContext) -> str:
+        """The term's SQL.
+
+        Args:
+            sql_context: How the SQL is written - the dialect, quoting, aliases.
+
+        Returns:
+            The SQL.
+        """
+        raise NotImplementedError()
+
+
+# After Term is defined: these packages build on it, and Term's operators build their
+# terms - read off the modules when an operator runs.
+from hare.sql.terms import (  # noqa: E402
+    arithmetic_expression as arithmetic_terms,
+    array as array_terms,
+    criteria as criteria_terms,
+    field as field_terms,
+    functions as function_terms,
+    negative as negative_terms,
+    tuple as tuple_terms,
+)
+from hare.sql.terms.values import null_value as null_value_terms, value_wrapper as value_wrapper_terms  # noqa: E402

hare/sql/terms/term_identity_text.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from enum import Enum
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from hare.sql.sql_context import SqlContext
+    from hare.sql.terms.term import Term
+
+
+class TermIdentityText:
+    """The text a term with no SQL in a dialect is written as where the text only names and
+    compares it (``SqlContext.names_dialect_terms``) - its class and each setting, so two terms
+    differing in any of them differ in it too. Never run."""
+
+    #: The attributes a term's identity leaves out - how it is written, not what it computes.
+    IGNORED_ATTRIBUTES = frozenset({"alias", "schema"})
+
+    @staticmethod
+    def get_sql(term: Term, sql_context: SqlContext) -> str:
+        """The term's identity text.
+
+        Args:
+            term: The term.
+            sql_context: The context the term is written in.
+
+        Returns:
+            ``ClassName(setting=value, ...)``, each nested term by its own SQL.
+        """
+        settings = [
+            f"{name}={text}"
+            for name, value in sorted(vars(term).items())
+            if not name.startswith("_") and name not in TermIdentityText.IGNORED_ATTRIBUTES
+            if (text := TermIdentityText.get_value_text(value, sql_context)) is not None
+        ]
+        return f"{type(term).__name__}({', '.join(settings)})"
+
+    @staticmethod
+    def get_value_text(value: Any, sql_context: SqlContext) -> str | None:
+        """A setting's text - a term by its SQL, a sequence by its items, a plain value by its
+        ``repr()``.
+
+        Args:
+            value: The setting.
+            sql_context: The context the term is written in.
+
+        Returns:
+            The text, None for an object of no stable text (a field instance).
+        """
+        if isinstance(value, Enum):
+            return repr(value.value)
+        if value is None or isinstance(value, (bool, int, float, str)):
+            return repr(value)
+        if isinstance(value, (list, tuple)):
+            item_texts = [TermIdentityText.get_value_text(item, sql_context) for item in value]
+            return "[" + ", ".join(text for text in item_texts if text is not None) + "]"
+        get_sql = getattr(value, "get_sql", None)
+        if callable(get_sql):
+            return str(get_sql(sql_context.copy(with_alias=False)))
+        return None

hare/sql/terms/tuple.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from collections.abc import Iterator
+from typing import TYPE_CHECKING, Any
+
+from hare.sql.builder_methods import BuilderMethods
+from hare.sql.sql_context import SqlContext
+from hare.sql.terms.criteria.criterion import Criterion
+from hare.sql.terms.node import TNode
+from hare.sql.terms.term import Term
+
+if TYPE_CHECKING:
+    from typing import Self
+
+    from hare.sql.builder.tables.table import Table
+
+
+class Tuple(Criterion):
+    """A row of values - ``(a, b, ...)``."""
+
+    def __init__(self, *values: Any) -> None:
+        super().__init__()
+        self.values = [self.wrap_constant(value) for value in values]
+
+    def nodes_(self) -> Iterator[TNode]:
+        yield self  # type:ignore[misc]
+        for value in self.values:
+            yield from value.nodes_()
+
+    def get_sql(self, sql_context: SqlContext) -> str:
+        sql = "({})".format(",".join(term.get_sql(sql_context) for term in self.values))
+        return sql_context.format_alias_sql(sql, self.alias)
+
+    @property
+    def is_aggregate(self) -> bool | None:  # type:ignore[override]
+        return Term.get_combined_is_aggregate([value.is_aggregate for value in self.values])
+
+    @BuilderMethods.builder
+    def replace_table(self, current_table: Table | None, new_table: Table | None) -> Self:
+        """Replaces all occurrences of the specified table with the new table.
+
+        Useful when reusing fields across queries.
+
+        Args:
+            current_table: The table to be replaced.
+            new_table: The table to replace with.
+
+        Returns:
+            A copy of the field with the tables replaced.
+        """
+        self.values = [value.replace_table(current_table, new_table) for value in self.values]
+        return self

hare/sql/terms/values/__init__.py

@@ -0,0 +1 @@
+from __future__ import annotations

hare/sql/terms/values/literal_value.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from typing import Any
+
+from hare.sql.sql_context import SqlContext
+from hare.sql.terms.term import Term
+
+
+class LiteralValue(Term):
+    """A value written into the SQL as it is."""
+
+    # A constant, like ValueWrapper - abstains from the aggregate vote, so ROUND(AVG(x), 1) is
+    # still an aggregate.
+    is_aggregate = None
+
+    def __init__(self, value: Any, alias: str | None = None) -> None:
+        super().__init__(alias)
+        self._value = value
+
+    def get_sql(self, sql_context: SqlContext) -> str:
+        return sql_context.format_alias_sql(self._value, self.alias)

hare/sql/terms/values/null_value.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from hare.sql.terms.values.literal_value import LiteralValue
+
+
+class NullValue(LiteralValue):
+    """``NULL``."""
+
+    def __init__(self, alias: str | None = None) -> None:
+        super().__init__("NULL", alias)

hare/sql/terms/values/old_row_value.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from hare.sql.terms.term import Term
+
+if TYPE_CHECKING:
+    from hare.sql.sql_context import SqlContext
+
+
+class OldRowValue(Term):
+    """A column of a written row as it was before the write, in its ``RETURNING`` - each dialect
+    writes its own SQL.
+
+    Args:
+        column_name: The column.
+        alias: The name the value is returned under.
+    """
+
+    def __init__(self, column_name: str, alias: str | None = None) -> None:
+        super().__init__(alias)
+        self.column_name = column_name
+
+    def get_sql(self, sql_context: SqlContext) -> str:
+        sql = sql_context.dialect.clauses.get_old_row_value_sql(sql_context.quote(self.column_name))
+        if sql_context.with_alias:
+            return sql_context.format_alias_sql(sql, self.alias)
+        return sql

hare/sql/terms/values/row_value_list.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from hare.sql.sql_context import SqlContext
+from hare.sql.terms.tuple import Tuple
+
+
+class RowValueList(Tuple):
+    """The rows a row value is compared with by ``IN`` - ``((1, 2), (3, 4))``; a dialect that takes no
+    list of row values there writes its own form."""
+
+    def get_sql(self, sql_context: SqlContext) -> str:
+        renderer = sql_context.dialect.renderers.get(type(self))
+        if renderer is not None:
+            return renderer(self, sql_context)
+        return super().get_sql(sql_context)

hare/sql/terms/values/value_wrapper.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+import json
+import uuid
+from datetime import date, time
+from decimal import Decimal
+from enum import Enum
+from typing import TYPE_CHECKING, Any
+
+from hare.dialects.base.literals.constants import SQL_LONG_INT_MESSAGE
+from hare.exceptions import ValidationError
+from hare.sql.enums import DatePart
+from hare.sql.sql_context import SqlContext
+
+if TYPE_CHECKING:
+    from typing import Self
+
+from hare.sql.terms.term import Term
+
+
+class ValueWrapper(Term):
+    """A Python value of a statement - a bound parameter, or a literal written into the SQL."""
+
+    is_aggregate = None
+    #: The wrapper a copy was made from (``as_()``, ``replace_table()``) - its parameter comes from
+    #: that wrapper, so a value bound through the original's reference reaches the copy too. None
+    #: for a wrapper that is no copy.
+    parameter_source: ValueWrapper | None = None
+
+    def __init__(self, value: Any, alias: str | None = None, allow_parametrize: bool = True) -> None:
+        """A wrapper for a constant value such as a string or number.
+
+        Args:
+            value: The value to be wrapped.
+            alias: An optional alias for the value.
+            allow_parametrize: Whether the value should be replaced with a parameter in the
+                query if a parameterizer is used.
+        """
+        super().__init__(alias)
+        self.value = value
+        self.allow_parametrize = allow_parametrize
+
+    def __copy__(self) -> Self:
+        copied_wrapper = super().__copy__()
+        copied_wrapper.parameter_source = self.parameter_source or self
+        return copied_wrapper
+
+    def get_value_sql(self, sql_context: SqlContext) -> str:
+        literals = sql_context.dialect.literals
+        value = self.value
+        if literals.writes_bound_values and value is not None and not isinstance(value, Enum | Term):
+            # As the dialect's client binds the value - a view's query keeps its values so.
+            return literals.get_literal_sql(value)
+        return self.get_formatted_value(value, sql_context)
+
+    @classmethod
+    def get_formatted_value(cls, value: Any, sql_context: SqlContext) -> str:
+        """A Python value as a literal of the SQL - the dialect's string literal for a text.
+
+        Args:
+            value: The value.
+            sql_context: How the SQL is written.
+
+        Returns:
+            The literal.
+        """
+        # Ordered by frequency. An Enum is checked before str: a str-mixin member renders as
+        # "Class.member". A text is the dialect's string literal - a dialect may read a backslash in
+        # one as an escape.
+        if isinstance(value, Enum):
+            if isinstance(value, DatePart):
+                return value.value
+            return cls.get_formatted_value(value.value, sql_context)
+        if isinstance(value, str):
+            return sql_context.dialect.literals.get_string_literal_sql(value)
+        if isinstance(value, bool):
+            return sql_context.dialect.literals.get_boolean_literal_sql(value)
+        if value is None:
+            return "null"
+        if isinstance(value, Term):
+            return value.get_sql(sql_context)
+        if isinstance(value, (date, time)):
+            return cls.get_formatted_value(value.isoformat(), sql_context)
+        if isinstance(value, uuid.UUID):
+            return cls.get_formatted_value(str(value), sql_context)
+        if isinstance(value, (dict, list)):
+            return sql_context.dialect.literals.get_string_literal_sql(json.dumps(value))
+        if isinstance(value, (int, float, Decimal)):
+            try:
+                return str(value)
+            except ValueError:
+                # An int longer than Python writes as text.
+                raise ValidationError(SQL_LONG_INT_MESSAGE) from None
+        if isinstance(value, (bytes, bytearray, memoryview)):
+            return cls.get_formatted_binary_value(bytes(value), sql_context)
+        raise TypeError(f"Can't render a {type(value).__name__} value as an SQL literal")
+
+    @staticmethod
+    def get_formatted_binary_value(value: bytes, sql_context: SqlContext) -> str:
+        """Renders bytes as the dialect's hexadecimal binary literal.
+
+        Args:
+            value: The bytes.
+            sql_context: The SQL rendering context.
+
+        Returns:
+            The literal.
+        """
+        return sql_context.dialect.literals.get_bytes_literal_sql(value)
+
+    def get_sql(
+        self,
+        sql_context: SqlContext,
+    ) -> str:
+        parameterizer = sql_context.parameterizer
+        if parameterizer is None or not parameterizer.should_parameterize(self.value) or not self.allow_parametrize:
+            if parameterizer is not None:
+                parameterizer.record_literal(self.parameter_source or self)
+            sql = self.get_value_sql(sql_context)
+            return sql_context.format_alias_sql(sql, self.alias)
+
+        parameter = parameterizer.create_parameter(
+            self.value, self.parameter_source or self, reuse=sql_context.dialect.parameters.numbers_parameters
+        )
+        parameter_sql = parameter.get_sql(sql_context)
+        if isinstance(self.value, bool):
+            # A bare parameter has no context to type it (a CASE of literals) - cast explicitly.
+            parameter_sql = sql_context.dialect.parameters.get_cast_parameter_sql(parameter_sql, self.value)
+        return sql_context.format_alias_sql(parameter_sql, self.alias)

hare/sql/types/__init__.py

@@ -0,0 +1 @@
+from __future__ import annotations

hare/sql/types/sql_type.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from hare.sql.sql_context import SqlContext
+
+
+class SqlType:
+    """A SQL type named by itself in the SQL text (``VARCHAR``)."""
+
+    def __init__(self, name: str) -> None:
+        self.name = name
+
+    def get_sql(self, sql_context: SqlContext) -> str:
+        return f"{self.name}"