24024
af7c11d7f9
- 新增图像生成接口，支持试用、积分和自定义API Key模式 - 实现生成图片结果异步上传至MinIO存储，带重试机制 - 优化积分预扣除和异常退还逻辑，保障用户积分准确 - 添加获取生成历史记录接口，支持时间范围和分页 - 提供本地字典配置接口，支持模型、比例、提示模板和尺寸 - 实现图片批量上传接口，支持S3兼容对象存储 feat(admin): 增加管理员角色管理与权限分配接口 - 实现角色列表查询、角色创建、更新及删除功能 - 增加权限列表查询接口 - 实现用户角色分配接口，便于统一管理用户权限 - 增加系统字典增删查改接口，支持分类过滤和排序 - 权限控制全面覆盖管理接口，保证安全访问 feat(auth): 完善用户登录注册及权限相关接口与页面 - 实现手机号验证码发送及校验功能，保障注册安全 - 支持手机号注册、登录及退出接口，集成日志记录 - 增加修改密码功能，验证原密码后更新 - 提供动态导航菜单接口，基于权限展示不同菜单 - 实现管理界面路由及日志、角色、字典管理页面访问权限控制 - 添加系统日志查询接口，支持关键词和等级筛选 feat(app): 初始化Flask应用并配置蓝图与数据库 - 创建应用程序工厂，加载配置，初始化数据库和Redis客户端 - 注册认证、API及管理员蓝图，整合路由 - 根路由渲染主页模板 - 应用上下文中自动创建数据库表，保证运行环境准备完毕 feat(database): 提供数据库创建与迁移支持脚本 - 新增数据库创建脚本，支持自动检测是否已存在 - 添加数据库表初始化脚本，支持创建和删除所有表 - 实现RBAC权限初始化，包含基础权限和角色创建 - 新增字段手动修复脚本，添加用户API Key和积分字段 - 强制迁移脚本支持清理连接和修复表结构，初始化默认数据及角色分配 feat(config): 新增系统配置参数 - 配置数据库、Redis、Session和MinIO相关参数 - 添加AI接口地址及试用Key配置 - 集成阿里云短信服务配置及开发模式相关参数 feat(extensions): 初始化数据库、Redis和MinIO客户端 - 创建全局SQLAlchemy数据库实例和Redis客户端 - 配置基于boto3的MinIO兼容S3客户端 chore(logs): 添加示例系统日志文件 - 记录用户请求、验证码发送成功与失败的日志信息
1032 lines
32 KiB
Python
1032 lines
32 KiB
Python
# dialects/postgresql/ranges.py
|
|
# Copyright (C) 2013-2025 the SQLAlchemy authors and contributors
|
|
# <see AUTHORS file>
|
|
#
|
|
# This module is part of SQLAlchemy and is released under
|
|
# the MIT License: https://www.opensource.org/licenses/mit-license.php
|
|
|
|
from __future__ import annotations
|
|
|
|
import dataclasses
|
|
from datetime import date
|
|
from datetime import datetime
|
|
from datetime import timedelta
|
|
from decimal import Decimal
|
|
from typing import Any
|
|
from typing import cast
|
|
from typing import Generic
|
|
from typing import List
|
|
from typing import Optional
|
|
from typing import overload
|
|
from typing import Sequence
|
|
from typing import Tuple
|
|
from typing import Type
|
|
from typing import TYPE_CHECKING
|
|
from typing import TypeVar
|
|
from typing import Union
|
|
|
|
from .operators import ADJACENT_TO
|
|
from .operators import CONTAINED_BY
|
|
from .operators import CONTAINS
|
|
from .operators import NOT_EXTEND_LEFT_OF
|
|
from .operators import NOT_EXTEND_RIGHT_OF
|
|
from .operators import OVERLAP
|
|
from .operators import STRICTLY_LEFT_OF
|
|
from .operators import STRICTLY_RIGHT_OF
|
|
from ... import types as sqltypes
|
|
from ...sql import operators
|
|
from ...sql.type_api import TypeEngine
|
|
from ...util import py310
|
|
from ...util.typing import Literal
|
|
|
|
if TYPE_CHECKING:
|
|
from ...sql.elements import ColumnElement
|
|
from ...sql.type_api import _TE
|
|
from ...sql.type_api import TypeEngineMixin
|
|
|
|
_T = TypeVar("_T", bound=Any)
|
|
|
|
_BoundsType = Literal["()", "[)", "(]", "[]"]
|
|
|
|
if py310:
|
|
dc_slots = {"slots": True}
|
|
dc_kwonly = {"kw_only": True}
|
|
else:
|
|
dc_slots = {}
|
|
dc_kwonly = {}
|
|
|
|
|
|
@dataclasses.dataclass(frozen=True, **dc_slots)
|
|
class Range(Generic[_T]):
|
|
"""Represent a PostgreSQL range.
|
|
|
|
E.g.::
|
|
|
|
r = Range(10, 50, bounds="()")
|
|
|
|
The calling style is similar to that of psycopg and psycopg2, in part
|
|
to allow easier migration from previous SQLAlchemy versions that used
|
|
these objects directly.
|
|
|
|
:param lower: Lower bound value, or None
|
|
:param upper: Upper bound value, or None
|
|
:param bounds: keyword-only, optional string value that is one of
|
|
``"()"``, ``"[)"``, ``"(]"``, ``"[]"``. Defaults to ``"[)"``.
|
|
:param empty: keyword-only, optional bool indicating this is an "empty"
|
|
range
|
|
|
|
.. versionadded:: 2.0
|
|
|
|
"""
|
|
|
|
lower: Optional[_T] = None
|
|
"""the lower bound"""
|
|
|
|
upper: Optional[_T] = None
|
|
"""the upper bound"""
|
|
|
|
if TYPE_CHECKING:
|
|
bounds: _BoundsType = dataclasses.field(default="[)")
|
|
empty: bool = dataclasses.field(default=False)
|
|
else:
|
|
bounds: _BoundsType = dataclasses.field(default="[)", **dc_kwonly)
|
|
empty: bool = dataclasses.field(default=False, **dc_kwonly)
|
|
|
|
if not py310:
|
|
|
|
def __init__(
|
|
self,
|
|
lower: Optional[_T] = None,
|
|
upper: Optional[_T] = None,
|
|
*,
|
|
bounds: _BoundsType = "[)",
|
|
empty: bool = False,
|
|
):
|
|
# no __slots__ either so we can update dict
|
|
self.__dict__.update(
|
|
{
|
|
"lower": lower,
|
|
"upper": upper,
|
|
"bounds": bounds,
|
|
"empty": empty,
|
|
}
|
|
)
|
|
|
|
def __bool__(self) -> bool:
|
|
return not self.empty
|
|
|
|
@property
|
|
def isempty(self) -> bool:
|
|
"A synonym for the 'empty' attribute."
|
|
|
|
return self.empty
|
|
|
|
@property
|
|
def is_empty(self) -> bool:
|
|
"A synonym for the 'empty' attribute."
|
|
|
|
return self.empty
|
|
|
|
@property
|
|
def lower_inc(self) -> bool:
|
|
"""Return True if the lower bound is inclusive."""
|
|
|
|
return self.bounds[0] == "["
|
|
|
|
@property
|
|
def lower_inf(self) -> bool:
|
|
"""Return True if this range is non-empty and lower bound is
|
|
infinite."""
|
|
|
|
return not self.empty and self.lower is None
|
|
|
|
@property
|
|
def upper_inc(self) -> bool:
|
|
"""Return True if the upper bound is inclusive."""
|
|
|
|
return self.bounds[1] == "]"
|
|
|
|
@property
|
|
def upper_inf(self) -> bool:
|
|
"""Return True if this range is non-empty and the upper bound is
|
|
infinite."""
|
|
|
|
return not self.empty and self.upper is None
|
|
|
|
@property
|
|
def __sa_type_engine__(self) -> AbstractSingleRange[_T]:
|
|
return AbstractSingleRange()
|
|
|
|
def _contains_value(self, value: _T) -> bool:
|
|
"""Return True if this range contains the given value."""
|
|
|
|
if self.empty:
|
|
return False
|
|
|
|
if self.lower is None:
|
|
return self.upper is None or (
|
|
value < self.upper
|
|
if self.bounds[1] == ")"
|
|
else value <= self.upper
|
|
)
|
|
|
|
if self.upper is None:
|
|
return ( # type: ignore
|
|
value > self.lower
|
|
if self.bounds[0] == "("
|
|
else value >= self.lower
|
|
)
|
|
|
|
return ( # type: ignore
|
|
value > self.lower
|
|
if self.bounds[0] == "("
|
|
else value >= self.lower
|
|
) and (
|
|
value < self.upper
|
|
if self.bounds[1] == ")"
|
|
else value <= self.upper
|
|
)
|
|
|
|
def _get_discrete_step(self) -> Any:
|
|
"Determine the “step” for this range, if it is a discrete one."
|
|
|
|
# See
|
|
# https://www.postgresql.org/docs/current/rangetypes.html#RANGETYPES-DISCRETE
|
|
# for the rationale
|
|
|
|
if isinstance(self.lower, int) or isinstance(self.upper, int):
|
|
return 1
|
|
elif isinstance(self.lower, datetime) or isinstance(
|
|
self.upper, datetime
|
|
):
|
|
# This is required, because a `isinstance(datetime.now(), date)`
|
|
# is True
|
|
return None
|
|
elif isinstance(self.lower, date) or isinstance(self.upper, date):
|
|
return timedelta(days=1)
|
|
else:
|
|
return None
|
|
|
|
def _compare_edges(
|
|
self,
|
|
value1: Optional[_T],
|
|
bound1: str,
|
|
value2: Optional[_T],
|
|
bound2: str,
|
|
only_values: bool = False,
|
|
) -> int:
|
|
"""Compare two range bounds.
|
|
|
|
Return -1, 0 or 1 respectively when `value1` is less than,
|
|
equal to or greater than `value2`.
|
|
|
|
When `only_value` is ``True``, do not consider the *inclusivity*
|
|
of the edges, just their values.
|
|
"""
|
|
|
|
value1_is_lower_bound = bound1 in {"[", "("}
|
|
value2_is_lower_bound = bound2 in {"[", "("}
|
|
|
|
# Infinite edges are equal when they are on the same side,
|
|
# otherwise a lower edge is considered less than the upper end
|
|
if value1 is value2 is None:
|
|
if value1_is_lower_bound == value2_is_lower_bound:
|
|
return 0
|
|
else:
|
|
return -1 if value1_is_lower_bound else 1
|
|
elif value1 is None:
|
|
return -1 if value1_is_lower_bound else 1
|
|
elif value2 is None:
|
|
return 1 if value2_is_lower_bound else -1
|
|
|
|
# Short path for trivial case
|
|
if bound1 == bound2 and value1 == value2:
|
|
return 0
|
|
|
|
value1_inc = bound1 in {"[", "]"}
|
|
value2_inc = bound2 in {"[", "]"}
|
|
step = self._get_discrete_step()
|
|
|
|
if step is not None:
|
|
# "Normalize" the two edges as '[)', to simplify successive
|
|
# logic when the range is discrete: otherwise we would need
|
|
# to handle the comparison between ``(0`` and ``[1`` that
|
|
# are equal when dealing with integers while for floats the
|
|
# former is lesser than the latter
|
|
|
|
if value1_is_lower_bound:
|
|
if not value1_inc:
|
|
value1 += step
|
|
value1_inc = True
|
|
else:
|
|
if value1_inc:
|
|
value1 += step
|
|
value1_inc = False
|
|
if value2_is_lower_bound:
|
|
if not value2_inc:
|
|
value2 += step
|
|
value2_inc = True
|
|
else:
|
|
if value2_inc:
|
|
value2 += step
|
|
value2_inc = False
|
|
|
|
if value1 < value2:
|
|
return -1
|
|
elif value1 > value2:
|
|
return 1
|
|
elif only_values:
|
|
return 0
|
|
else:
|
|
# Neither one is infinite but are equal, so we
|
|
# need to consider the respective inclusive/exclusive
|
|
# flag
|
|
|
|
if value1_inc and value2_inc:
|
|
return 0
|
|
elif not value1_inc and not value2_inc:
|
|
if value1_is_lower_bound == value2_is_lower_bound:
|
|
return 0
|
|
else:
|
|
return 1 if value1_is_lower_bound else -1
|
|
elif not value1_inc:
|
|
return 1 if value1_is_lower_bound else -1
|
|
elif not value2_inc:
|
|
return -1 if value2_is_lower_bound else 1
|
|
else:
|
|
return 0
|
|
|
|
def __eq__(self, other: Any) -> bool:
|
|
"""Compare this range to the `other` taking into account
|
|
bounds inclusivity, returning ``True`` if they are equal.
|
|
"""
|
|
|
|
if not isinstance(other, Range):
|
|
return NotImplemented
|
|
|
|
if self.empty and other.empty:
|
|
return True
|
|
elif self.empty != other.empty:
|
|
return False
|
|
|
|
slower = self.lower
|
|
slower_b = self.bounds[0]
|
|
olower = other.lower
|
|
olower_b = other.bounds[0]
|
|
supper = self.upper
|
|
supper_b = self.bounds[1]
|
|
oupper = other.upper
|
|
oupper_b = other.bounds[1]
|
|
|
|
return (
|
|
self._compare_edges(slower, slower_b, olower, olower_b) == 0
|
|
and self._compare_edges(supper, supper_b, oupper, oupper_b) == 0
|
|
)
|
|
|
|
def contained_by(self, other: Range[_T]) -> bool:
|
|
"Determine whether this range is a contained by `other`."
|
|
|
|
# Any range contains the empty one
|
|
if self.empty:
|
|
return True
|
|
|
|
# An empty range does not contain any range except the empty one
|
|
if other.empty:
|
|
return False
|
|
|
|
slower = self.lower
|
|
slower_b = self.bounds[0]
|
|
olower = other.lower
|
|
olower_b = other.bounds[0]
|
|
|
|
if self._compare_edges(slower, slower_b, olower, olower_b) < 0:
|
|
return False
|
|
|
|
supper = self.upper
|
|
supper_b = self.bounds[1]
|
|
oupper = other.upper
|
|
oupper_b = other.bounds[1]
|
|
|
|
if self._compare_edges(supper, supper_b, oupper, oupper_b) > 0:
|
|
return False
|
|
|
|
return True
|
|
|
|
def contains(self, value: Union[_T, Range[_T]]) -> bool:
|
|
"Determine whether this range contains `value`."
|
|
|
|
if isinstance(value, Range):
|
|
return value.contained_by(self)
|
|
else:
|
|
return self._contains_value(value)
|
|
|
|
__contains__ = contains
|
|
|
|
def overlaps(self, other: Range[_T]) -> bool:
|
|
"Determine whether this range overlaps with `other`."
|
|
|
|
# Empty ranges never overlap with any other range
|
|
if self.empty or other.empty:
|
|
return False
|
|
|
|
slower = self.lower
|
|
slower_b = self.bounds[0]
|
|
supper = self.upper
|
|
supper_b = self.bounds[1]
|
|
olower = other.lower
|
|
olower_b = other.bounds[0]
|
|
oupper = other.upper
|
|
oupper_b = other.bounds[1]
|
|
|
|
# Check whether this lower bound is contained in the other range
|
|
if (
|
|
self._compare_edges(slower, slower_b, olower, olower_b) >= 0
|
|
and self._compare_edges(slower, slower_b, oupper, oupper_b) <= 0
|
|
):
|
|
return True
|
|
|
|
# Check whether other lower bound is contained in this range
|
|
if (
|
|
self._compare_edges(olower, olower_b, slower, slower_b) >= 0
|
|
and self._compare_edges(olower, olower_b, supper, supper_b) <= 0
|
|
):
|
|
return True
|
|
|
|
return False
|
|
|
|
def strictly_left_of(self, other: Range[_T]) -> bool:
|
|
"Determine whether this range is completely to the left of `other`."
|
|
|
|
# Empty ranges are neither to left nor to the right of any other range
|
|
if self.empty or other.empty:
|
|
return False
|
|
|
|
supper = self.upper
|
|
supper_b = self.bounds[1]
|
|
olower = other.lower
|
|
olower_b = other.bounds[0]
|
|
|
|
# Check whether this upper edge is less than other's lower end
|
|
return self._compare_edges(supper, supper_b, olower, olower_b) < 0
|
|
|
|
__lshift__ = strictly_left_of
|
|
|
|
def strictly_right_of(self, other: Range[_T]) -> bool:
|
|
"Determine whether this range is completely to the right of `other`."
|
|
|
|
# Empty ranges are neither to left nor to the right of any other range
|
|
if self.empty or other.empty:
|
|
return False
|
|
|
|
slower = self.lower
|
|
slower_b = self.bounds[0]
|
|
oupper = other.upper
|
|
oupper_b = other.bounds[1]
|
|
|
|
# Check whether this lower edge is greater than other's upper end
|
|
return self._compare_edges(slower, slower_b, oupper, oupper_b) > 0
|
|
|
|
__rshift__ = strictly_right_of
|
|
|
|
def not_extend_left_of(self, other: Range[_T]) -> bool:
|
|
"Determine whether this does not extend to the left of `other`."
|
|
|
|
# Empty ranges are neither to left nor to the right of any other range
|
|
if self.empty or other.empty:
|
|
return False
|
|
|
|
slower = self.lower
|
|
slower_b = self.bounds[0]
|
|
olower = other.lower
|
|
olower_b = other.bounds[0]
|
|
|
|
# Check whether this lower edge is not less than other's lower end
|
|
return self._compare_edges(slower, slower_b, olower, olower_b) >= 0
|
|
|
|
def not_extend_right_of(self, other: Range[_T]) -> bool:
|
|
"Determine whether this does not extend to the right of `other`."
|
|
|
|
# Empty ranges are neither to left nor to the right of any other range
|
|
if self.empty or other.empty:
|
|
return False
|
|
|
|
supper = self.upper
|
|
supper_b = self.bounds[1]
|
|
oupper = other.upper
|
|
oupper_b = other.bounds[1]
|
|
|
|
# Check whether this upper edge is not greater than other's upper end
|
|
return self._compare_edges(supper, supper_b, oupper, oupper_b) <= 0
|
|
|
|
def _upper_edge_adjacent_to_lower(
|
|
self,
|
|
value1: Optional[_T],
|
|
bound1: str,
|
|
value2: Optional[_T],
|
|
bound2: str,
|
|
) -> bool:
|
|
"""Determine whether an upper bound is immediately successive to a
|
|
lower bound."""
|
|
|
|
# Since we need a peculiar way to handle the bounds inclusivity,
|
|
# just do a comparison by value here
|
|
res = self._compare_edges(value1, bound1, value2, bound2, True)
|
|
if res == -1:
|
|
step = self._get_discrete_step()
|
|
if step is None:
|
|
return False
|
|
if bound1 == "]":
|
|
if bound2 == "[":
|
|
return value1 == value2 - step # type: ignore
|
|
else:
|
|
return value1 == value2
|
|
else:
|
|
if bound2 == "[":
|
|
return value1 == value2
|
|
else:
|
|
return value1 == value2 - step # type: ignore
|
|
elif res == 0:
|
|
# Cover cases like [0,0] -|- [1,] and [0,2) -|- (1,3]
|
|
if (
|
|
bound1 == "]"
|
|
and bound2 == "["
|
|
or bound1 == ")"
|
|
and bound2 == "("
|
|
):
|
|
step = self._get_discrete_step()
|
|
if step is not None:
|
|
return True
|
|
return (
|
|
bound1 == ")"
|
|
and bound2 == "["
|
|
or bound1 == "]"
|
|
and bound2 == "("
|
|
)
|
|
else:
|
|
return False
|
|
|
|
def adjacent_to(self, other: Range[_T]) -> bool:
|
|
"Determine whether this range is adjacent to the `other`."
|
|
|
|
# Empty ranges are not adjacent to any other range
|
|
if self.empty or other.empty:
|
|
return False
|
|
|
|
slower = self.lower
|
|
slower_b = self.bounds[0]
|
|
supper = self.upper
|
|
supper_b = self.bounds[1]
|
|
olower = other.lower
|
|
olower_b = other.bounds[0]
|
|
oupper = other.upper
|
|
oupper_b = other.bounds[1]
|
|
|
|
return self._upper_edge_adjacent_to_lower(
|
|
supper, supper_b, olower, olower_b
|
|
) or self._upper_edge_adjacent_to_lower(
|
|
oupper, oupper_b, slower, slower_b
|
|
)
|
|
|
|
def union(self, other: Range[_T]) -> Range[_T]:
|
|
"""Compute the union of this range with the `other`.
|
|
|
|
This raises a ``ValueError`` exception if the two ranges are
|
|
"disjunct", that is neither adjacent nor overlapping.
|
|
"""
|
|
|
|
# Empty ranges are "additive identities"
|
|
if self.empty:
|
|
return other
|
|
if other.empty:
|
|
return self
|
|
|
|
if not self.overlaps(other) and not self.adjacent_to(other):
|
|
raise ValueError(
|
|
"Adding non-overlapping and non-adjacent"
|
|
" ranges is not implemented"
|
|
)
|
|
|
|
slower = self.lower
|
|
slower_b = self.bounds[0]
|
|
supper = self.upper
|
|
supper_b = self.bounds[1]
|
|
olower = other.lower
|
|
olower_b = other.bounds[0]
|
|
oupper = other.upper
|
|
oupper_b = other.bounds[1]
|
|
|
|
if self._compare_edges(slower, slower_b, olower, olower_b) < 0:
|
|
rlower = slower
|
|
rlower_b = slower_b
|
|
else:
|
|
rlower = olower
|
|
rlower_b = olower_b
|
|
|
|
if self._compare_edges(supper, supper_b, oupper, oupper_b) > 0:
|
|
rupper = supper
|
|
rupper_b = supper_b
|
|
else:
|
|
rupper = oupper
|
|
rupper_b = oupper_b
|
|
|
|
return Range(
|
|
rlower, rupper, bounds=cast(_BoundsType, rlower_b + rupper_b)
|
|
)
|
|
|
|
def __add__(self, other: Range[_T]) -> Range[_T]:
|
|
return self.union(other)
|
|
|
|
def difference(self, other: Range[_T]) -> Range[_T]:
|
|
"""Compute the difference between this range and the `other`.
|
|
|
|
This raises a ``ValueError`` exception if the two ranges are
|
|
"disjunct", that is neither adjacent nor overlapping.
|
|
"""
|
|
|
|
# Subtracting an empty range is a no-op
|
|
if self.empty or other.empty:
|
|
return self
|
|
|
|
slower = self.lower
|
|
slower_b = self.bounds[0]
|
|
supper = self.upper
|
|
supper_b = self.bounds[1]
|
|
olower = other.lower
|
|
olower_b = other.bounds[0]
|
|
oupper = other.upper
|
|
oupper_b = other.bounds[1]
|
|
|
|
sl_vs_ol = self._compare_edges(slower, slower_b, olower, olower_b)
|
|
su_vs_ou = self._compare_edges(supper, supper_b, oupper, oupper_b)
|
|
if sl_vs_ol < 0 and su_vs_ou > 0:
|
|
raise ValueError(
|
|
"Subtracting a strictly inner range is not implemented"
|
|
)
|
|
|
|
sl_vs_ou = self._compare_edges(slower, slower_b, oupper, oupper_b)
|
|
su_vs_ol = self._compare_edges(supper, supper_b, olower, olower_b)
|
|
|
|
# If the ranges do not overlap, result is simply the first
|
|
if sl_vs_ou > 0 or su_vs_ol < 0:
|
|
return self
|
|
|
|
# If this range is completely contained by the other, result is empty
|
|
if sl_vs_ol >= 0 and su_vs_ou <= 0:
|
|
return Range(None, None, empty=True)
|
|
|
|
# If this range extends to the left of the other and ends in its
|
|
# middle
|
|
if sl_vs_ol <= 0 and su_vs_ol >= 0 and su_vs_ou <= 0:
|
|
rupper_b = ")" if olower_b == "[" else "]"
|
|
if (
|
|
slower_b != "["
|
|
and rupper_b != "]"
|
|
and self._compare_edges(slower, slower_b, olower, rupper_b)
|
|
== 0
|
|
):
|
|
return Range(None, None, empty=True)
|
|
else:
|
|
return Range(
|
|
slower,
|
|
olower,
|
|
bounds=cast(_BoundsType, slower_b + rupper_b),
|
|
)
|
|
|
|
# If this range starts in the middle of the other and extends to its
|
|
# right
|
|
if sl_vs_ol >= 0 and su_vs_ou >= 0 and sl_vs_ou <= 0:
|
|
rlower_b = "(" if oupper_b == "]" else "["
|
|
if (
|
|
rlower_b != "["
|
|
and supper_b != "]"
|
|
and self._compare_edges(oupper, rlower_b, supper, supper_b)
|
|
== 0
|
|
):
|
|
return Range(None, None, empty=True)
|
|
else:
|
|
return Range(
|
|
oupper,
|
|
supper,
|
|
bounds=cast(_BoundsType, rlower_b + supper_b),
|
|
)
|
|
|
|
assert False, f"Unhandled case computing {self} - {other}"
|
|
|
|
def __sub__(self, other: Range[_T]) -> Range[_T]:
|
|
return self.difference(other)
|
|
|
|
def intersection(self, other: Range[_T]) -> Range[_T]:
|
|
"""Compute the intersection of this range with the `other`.
|
|
|
|
.. versionadded:: 2.0.10
|
|
|
|
"""
|
|
if self.empty or other.empty or not self.overlaps(other):
|
|
return Range(None, None, empty=True)
|
|
|
|
slower = self.lower
|
|
slower_b = self.bounds[0]
|
|
supper = self.upper
|
|
supper_b = self.bounds[1]
|
|
olower = other.lower
|
|
olower_b = other.bounds[0]
|
|
oupper = other.upper
|
|
oupper_b = other.bounds[1]
|
|
|
|
if self._compare_edges(slower, slower_b, olower, olower_b) < 0:
|
|
rlower = olower
|
|
rlower_b = olower_b
|
|
else:
|
|
rlower = slower
|
|
rlower_b = slower_b
|
|
|
|
if self._compare_edges(supper, supper_b, oupper, oupper_b) > 0:
|
|
rupper = oupper
|
|
rupper_b = oupper_b
|
|
else:
|
|
rupper = supper
|
|
rupper_b = supper_b
|
|
|
|
return Range(
|
|
rlower,
|
|
rupper,
|
|
bounds=cast(_BoundsType, rlower_b + rupper_b),
|
|
)
|
|
|
|
def __mul__(self, other: Range[_T]) -> Range[_T]:
|
|
return self.intersection(other)
|
|
|
|
def __str__(self) -> str:
|
|
return self._stringify()
|
|
|
|
def _stringify(self) -> str:
|
|
if self.empty:
|
|
return "empty"
|
|
|
|
l, r = self.lower, self.upper
|
|
l = "" if l is None else l # type: ignore
|
|
r = "" if r is None else r # type: ignore
|
|
|
|
b0, b1 = cast("Tuple[str, str]", self.bounds)
|
|
|
|
return f"{b0}{l},{r}{b1}"
|
|
|
|
|
|
class MultiRange(List[Range[_T]]):
|
|
"""Represents a multirange sequence.
|
|
|
|
This list subclass is an utility to allow automatic type inference of
|
|
the proper multi-range SQL type depending on the single range values.
|
|
This is useful when operating on literal multi-ranges::
|
|
|
|
import sqlalchemy as sa
|
|
from sqlalchemy.dialects.postgresql import MultiRange, Range
|
|
|
|
value = literal(MultiRange([Range(2, 4)]))
|
|
|
|
select(tbl).where(tbl.c.value.op("@")(MultiRange([Range(-3, 7)])))
|
|
|
|
.. versionadded:: 2.0.26
|
|
|
|
.. seealso::
|
|
|
|
- :ref:`postgresql_multirange_list_use`.
|
|
"""
|
|
|
|
@property
|
|
def __sa_type_engine__(self) -> AbstractMultiRange[_T]:
|
|
return AbstractMultiRange()
|
|
|
|
|
|
class AbstractRange(sqltypes.TypeEngine[_T]):
|
|
"""Base class for single and multi Range SQL types."""
|
|
|
|
render_bind_cast = True
|
|
|
|
__abstract__ = True
|
|
|
|
@overload
|
|
def adapt(self, cls: Type[_TE], **kw: Any) -> _TE: ...
|
|
|
|
@overload
|
|
def adapt(
|
|
self, cls: Type[TypeEngineMixin], **kw: Any
|
|
) -> TypeEngine[Any]: ...
|
|
|
|
def adapt(
|
|
self,
|
|
cls: Type[Union[TypeEngine[Any], TypeEngineMixin]],
|
|
**kw: Any,
|
|
) -> TypeEngine[Any]:
|
|
"""Dynamically adapt a range type to an abstract impl.
|
|
|
|
For example ``INT4RANGE().adapt(_Psycopg2NumericRange)`` should
|
|
produce a type that will have ``_Psycopg2NumericRange`` behaviors
|
|
and also render as ``INT4RANGE`` in SQL and DDL.
|
|
|
|
"""
|
|
if (
|
|
issubclass(cls, (AbstractSingleRangeImpl, AbstractMultiRangeImpl))
|
|
and cls is not self.__class__
|
|
):
|
|
# two ways to do this are: 1. create a new type on the fly
|
|
# or 2. have AbstractRangeImpl(visit_name) constructor and a
|
|
# visit_abstract_range_impl() method in the PG compiler.
|
|
# I'm choosing #1 as the resulting type object
|
|
# will then make use of the same mechanics
|
|
# as if we had made all these sub-types explicitly, and will
|
|
# also look more obvious under pdb etc.
|
|
# The adapt() operation here is cached per type-class-per-dialect,
|
|
# so is not much of a performance concern
|
|
visit_name = self.__visit_name__
|
|
return type( # type: ignore
|
|
f"{visit_name}RangeImpl",
|
|
(cls, self.__class__),
|
|
{"__visit_name__": visit_name},
|
|
)()
|
|
else:
|
|
return super().adapt(cls)
|
|
|
|
class comparator_factory(TypeEngine.Comparator[Range[Any]]):
|
|
"""Define comparison operations for range types."""
|
|
|
|
def contains(self, other: Any, **kw: Any) -> ColumnElement[bool]:
|
|
"""Boolean expression. Returns true if the right hand operand,
|
|
which can be an element or a range, is contained within the
|
|
column.
|
|
|
|
kwargs may be ignored by this operator but are required for API
|
|
conformance.
|
|
"""
|
|
return self.expr.operate(CONTAINS, other)
|
|
|
|
def contained_by(self, other: Any) -> ColumnElement[bool]:
|
|
"""Boolean expression. Returns true if the column is contained
|
|
within the right hand operand.
|
|
"""
|
|
return self.expr.operate(CONTAINED_BY, other)
|
|
|
|
def overlaps(self, other: Any) -> ColumnElement[bool]:
|
|
"""Boolean expression. Returns true if the column overlaps
|
|
(has points in common with) the right hand operand.
|
|
"""
|
|
return self.expr.operate(OVERLAP, other)
|
|
|
|
def strictly_left_of(self, other: Any) -> ColumnElement[bool]:
|
|
"""Boolean expression. Returns true if the column is strictly
|
|
left of the right hand operand.
|
|
"""
|
|
return self.expr.operate(STRICTLY_LEFT_OF, other)
|
|
|
|
__lshift__ = strictly_left_of
|
|
|
|
def strictly_right_of(self, other: Any) -> ColumnElement[bool]:
|
|
"""Boolean expression. Returns true if the column is strictly
|
|
right of the right hand operand.
|
|
"""
|
|
return self.expr.operate(STRICTLY_RIGHT_OF, other)
|
|
|
|
__rshift__ = strictly_right_of
|
|
|
|
def not_extend_right_of(self, other: Any) -> ColumnElement[bool]:
|
|
"""Boolean expression. Returns true if the range in the column
|
|
does not extend right of the range in the operand.
|
|
"""
|
|
return self.expr.operate(NOT_EXTEND_RIGHT_OF, other)
|
|
|
|
def not_extend_left_of(self, other: Any) -> ColumnElement[bool]:
|
|
"""Boolean expression. Returns true if the range in the column
|
|
does not extend left of the range in the operand.
|
|
"""
|
|
return self.expr.operate(NOT_EXTEND_LEFT_OF, other)
|
|
|
|
def adjacent_to(self, other: Any) -> ColumnElement[bool]:
|
|
"""Boolean expression. Returns true if the range in the column
|
|
is adjacent to the range in the operand.
|
|
"""
|
|
return self.expr.operate(ADJACENT_TO, other)
|
|
|
|
def union(self, other: Any) -> ColumnElement[bool]:
|
|
"""Range expression. Returns the union of the two ranges.
|
|
Will raise an exception if the resulting range is not
|
|
contiguous.
|
|
"""
|
|
return self.expr.operate(operators.add, other)
|
|
|
|
def difference(self, other: Any) -> ColumnElement[bool]:
|
|
"""Range expression. Returns the union of the two ranges.
|
|
Will raise an exception if the resulting range is not
|
|
contiguous.
|
|
"""
|
|
return self.expr.operate(operators.sub, other)
|
|
|
|
def intersection(self, other: Any) -> ColumnElement[Range[_T]]:
|
|
"""Range expression. Returns the intersection of the two ranges.
|
|
Will raise an exception if the resulting range is not
|
|
contiguous.
|
|
"""
|
|
return self.expr.operate(operators.mul, other)
|
|
|
|
|
|
class AbstractSingleRange(AbstractRange[Range[_T]]):
|
|
"""Base for PostgreSQL RANGE types.
|
|
|
|
These are types that return a single :class:`_postgresql.Range` object.
|
|
|
|
.. seealso::
|
|
|
|
`PostgreSQL range functions <https://www.postgresql.org/docs/current/static/functions-range.html>`_
|
|
|
|
""" # noqa: E501
|
|
|
|
__abstract__ = True
|
|
|
|
def _resolve_for_literal(self, value: Range[Any]) -> Any:
|
|
spec = value.lower if value.lower is not None else value.upper
|
|
|
|
if isinstance(spec, int):
|
|
# pg is unreasonably picky here: the query
|
|
# "select 1::INTEGER <@ '[1, 4)'::INT8RANGE" raises
|
|
# "operator does not exist: integer <@ int8range" as of pg 16
|
|
if _is_int32(value):
|
|
return INT4RANGE()
|
|
else:
|
|
return INT8RANGE()
|
|
elif isinstance(spec, (Decimal, float)):
|
|
return NUMRANGE()
|
|
elif isinstance(spec, datetime):
|
|
return TSRANGE() if not spec.tzinfo else TSTZRANGE()
|
|
elif isinstance(spec, date):
|
|
return DATERANGE()
|
|
else:
|
|
# empty Range, SQL datatype can't be determined here
|
|
return sqltypes.NULLTYPE
|
|
|
|
|
|
class AbstractSingleRangeImpl(AbstractSingleRange[_T]):
|
|
"""Marker for AbstractSingleRange that will apply a subclass-specific
|
|
adaptation"""
|
|
|
|
|
|
class AbstractMultiRange(AbstractRange[Sequence[Range[_T]]]):
|
|
"""Base for PostgreSQL MULTIRANGE types.
|
|
|
|
these are types that return a sequence of :class:`_postgresql.Range`
|
|
objects.
|
|
|
|
"""
|
|
|
|
__abstract__ = True
|
|
|
|
def _resolve_for_literal(self, value: Sequence[Range[Any]]) -> Any:
|
|
if not value:
|
|
# empty MultiRange, SQL datatype can't be determined here
|
|
return sqltypes.NULLTYPE
|
|
first = value[0]
|
|
spec = first.lower if first.lower is not None else first.upper
|
|
|
|
if isinstance(spec, int):
|
|
# pg is unreasonably picky here: the query
|
|
# "select 1::INTEGER <@ '{[1, 4),[6,19)}'::INT8MULTIRANGE" raises
|
|
# "operator does not exist: integer <@ int8multirange" as of pg 16
|
|
if all(_is_int32(r) for r in value):
|
|
return INT4MULTIRANGE()
|
|
else:
|
|
return INT8MULTIRANGE()
|
|
elif isinstance(spec, (Decimal, float)):
|
|
return NUMMULTIRANGE()
|
|
elif isinstance(spec, datetime):
|
|
return TSMULTIRANGE() if not spec.tzinfo else TSTZMULTIRANGE()
|
|
elif isinstance(spec, date):
|
|
return DATEMULTIRANGE()
|
|
else:
|
|
# empty Range, SQL datatype can't be determined here
|
|
return sqltypes.NULLTYPE
|
|
|
|
|
|
class AbstractMultiRangeImpl(AbstractMultiRange[_T]):
|
|
"""Marker for AbstractMultiRange that will apply a subclass-specific
|
|
adaptation"""
|
|
|
|
|
|
class INT4RANGE(AbstractSingleRange[int]):
|
|
"""Represent the PostgreSQL INT4RANGE type."""
|
|
|
|
__visit_name__ = "INT4RANGE"
|
|
|
|
|
|
class INT8RANGE(AbstractSingleRange[int]):
|
|
"""Represent the PostgreSQL INT8RANGE type."""
|
|
|
|
__visit_name__ = "INT8RANGE"
|
|
|
|
|
|
class NUMRANGE(AbstractSingleRange[Decimal]):
|
|
"""Represent the PostgreSQL NUMRANGE type."""
|
|
|
|
__visit_name__ = "NUMRANGE"
|
|
|
|
|
|
class DATERANGE(AbstractSingleRange[date]):
|
|
"""Represent the PostgreSQL DATERANGE type."""
|
|
|
|
__visit_name__ = "DATERANGE"
|
|
|
|
|
|
class TSRANGE(AbstractSingleRange[datetime]):
|
|
"""Represent the PostgreSQL TSRANGE type."""
|
|
|
|
__visit_name__ = "TSRANGE"
|
|
|
|
|
|
class TSTZRANGE(AbstractSingleRange[datetime]):
|
|
"""Represent the PostgreSQL TSTZRANGE type."""
|
|
|
|
__visit_name__ = "TSTZRANGE"
|
|
|
|
|
|
class INT4MULTIRANGE(AbstractMultiRange[int]):
|
|
"""Represent the PostgreSQL INT4MULTIRANGE type."""
|
|
|
|
__visit_name__ = "INT4MULTIRANGE"
|
|
|
|
|
|
class INT8MULTIRANGE(AbstractMultiRange[int]):
|
|
"""Represent the PostgreSQL INT8MULTIRANGE type."""
|
|
|
|
__visit_name__ = "INT8MULTIRANGE"
|
|
|
|
|
|
class NUMMULTIRANGE(AbstractMultiRange[Decimal]):
|
|
"""Represent the PostgreSQL NUMMULTIRANGE type."""
|
|
|
|
__visit_name__ = "NUMMULTIRANGE"
|
|
|
|
|
|
class DATEMULTIRANGE(AbstractMultiRange[date]):
|
|
"""Represent the PostgreSQL DATEMULTIRANGE type."""
|
|
|
|
__visit_name__ = "DATEMULTIRANGE"
|
|
|
|
|
|
class TSMULTIRANGE(AbstractMultiRange[datetime]):
|
|
"""Represent the PostgreSQL TSRANGE type."""
|
|
|
|
__visit_name__ = "TSMULTIRANGE"
|
|
|
|
|
|
class TSTZMULTIRANGE(AbstractMultiRange[datetime]):
|
|
"""Represent the PostgreSQL TSTZRANGE type."""
|
|
|
|
__visit_name__ = "TSTZMULTIRANGE"
|
|
|
|
|
|
_max_int_32 = 2**31 - 1
|
|
_min_int_32 = -(2**31)
|
|
|
|
|
|
def _is_int32(r: Range[int]) -> bool:
|
|
return (r.lower is None or _min_int_32 <= r.lower <= _max_int_32) and (
|
|
r.upper is None or _min_int_32 <= r.upper <= _max_int_32
|
|
)
|