DefPixel-PostgreSQL 0.1.5__83-py3-none-any.whl

DefPixel/DataAccessObject/Implements/PostgreSQL/Exprs/JavaScriptObjectNotation.py

@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*-
+
+from typing import Optional
+
+from ..Column import Column
+from ..Compiler import (
+	Compilable,
+	Compiler,
+	typename,
+)
+from ..Expr import Expr
+
+__all__ = (
+	'Of',
+)
+
+
+class Of(Expr):
+	"""(json -> key)[::type]; str keys select object members and int keys select array elements."""
+
+	def __init__(
+		self,
+		col,
+		arg,
+		type=None,
+	):
+		if isinstance(col, str):
+			col = Column(col)
+		if not isinstance(col, Compilable):
+			raise TypeError('Of requires a column or SQL expression')
+		if isinstance(arg, bool) or not isinstance(arg, (str, int, Compilable)):
+			raise TypeError('Of keys must be str, int, or SQL expressions')
+		self.col = col
+		self.arg = arg
+		self.type: Optional[str] = None
+		if type is not None:
+			self.cast(type)
+		return
+
+	def cast(self, type) -> 'Of':
+		self.type = typename(type)
+		return self
+
+	def compile(self, compiler: Compiler) -> str:
+		if isinstance(self.arg, Compilable):
+			arg = compiler.compile(self.arg)
+		else:
+			arg = compiler.bind(self.arg, 'TEXT' if isinstance(self.arg, str) else 'INTEGER')
+		return '({}->{}){}'.format(
+			compiler.compile(self.col),
+			arg,
+			'::{}'.format(self.type) if self.type else '',
+		)

DefPixel/DataAccessObject/Implements/PostgreSQL/Exprs/Operator.py

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+
+from ..Compiler import (
+	Compilable,
+	Compiler,
+)
+from ..Expr import Expr
+
+__all__ = (
+	'And',
+	'Or',
+	'conditions',
+)
+
+
+def conditions(args, name: str = 'Conditions') -> tuple:
+	"""Validate that every condition is a SQL expression."""
+	for arg in args:
+		if not isinstance(arg, Compilable):
+			raise TypeError('{} must be SQL expressions'.format(name))
+	return tuple(args)
+
+
+class Logical(Expr):
+	operator = ''
+
+	def __init__(self, *args):
+		if not args:
+			raise ValueError('{} requires at least one condition'.format(self.__class__.__name__))
+		self.args = conditions(args)
+		return
+
+	def compile(self, compiler: Compiler) -> str:
+		return '({})'.format(' {} '.format(self.operator).join(compiler.compile(arg) for arg in self.args))
+
+
+class And(Logical):
+	operator = 'AND'
+
+
+class Or(Logical):
+	operator = 'OR'

DefPixel/DataAccessObject/Implements/PostgreSQL/Exprs/String.py

@@ -0,0 +1,48 @@
+# -*- coding: utf-8 -*-
+
+from ..Compiler import Compiler
+from ..Expr import Expr
+
+__all__ = (
+	'Like',
+	'LikeStartWith',
+	'LikeEndWith',
+)
+
+
+class Pattern(Expr):
+	prefix = ''
+	suffix = ''
+
+	def __init__(
+		self,
+		col,
+		other: str,
+	):
+		if not isinstance(other, str):
+			raise TypeError('LIKE patterns must be strings')
+		self.col = col
+		self.other = other
+		return
+
+	def compile(self, compiler: Compiler) -> str:
+		return '{} LIKE {}'.format(
+			compiler.compile(self.col),
+			compiler.bind('{}{}{}'.format(self.prefix, self.other, self.suffix)),
+		)
+
+
+class Like(Pattern):
+	"""col LIKE '%other%'; wildcard characters in other keep their LIKE meaning."""
+	prefix = '%'
+	suffix = '%'
+
+
+class LikeStartWith(Pattern):
+	"""col LIKE 'other%'."""
+	suffix = '%'
+
+
+class LikeEndWith(Pattern):
+	"""col LIKE '%other'."""
+	prefix = '%'

DefPixel/DataAccessObject/Implements/PostgreSQL/Exprs/__init__.py

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+
+from .Common import (
+	Alias,
+	TypeTo,
+	If,
+	IfNull,
+	IfNotNull,
+	Switch,
+	Query,
+)
+from .Condition import (
+	In,
+	NotIn,
+	Is,
+	IsNull,
+	IsNotNull,
+	IsTrue,
+	IsNotTrue,
+	IsFalse,
+	IsNotFalse,
+	IsUnknown,
+	IsNotUnknown,
+)
+from .Operator import (
+	And,
+	Or,
+)
+from .Compare import (
+	EqualTo,
+	NotEqualTo,
+	GreaterThan,
+	GreaterEqualTo,
+	LessThan,
+	LessEqualTo,
+)
+from .String import (
+	Like,
+	LikeStartWith,
+	LikeEndWith,
+)
+from .JavaScriptObjectNotation import Of
+
+__all__ = (
+	'Alias',
+	'TypeTo',
+	'If',
+	'IfNull',
+	'IfNotNull',
+	'Switch',
+	'Query',
+	'In',
+	'NotIn',
+	'Is',
+	'IsNull',
+	'IsNotNull',
+	'IsTrue',
+	'IsNotTrue',
+	'IsFalse',
+	'IsNotFalse',
+	'IsUnknown',
+	'IsNotUnknown',
+	'And',
+	'Or',
+	'EqualTo',
+	'NotEqualTo',
+	'GreaterThan',
+	'GreaterEqualTo',
+	'LessThan',
+	'LessEqualTo',
+	'Like',
+	'LikeStartWith',
+	'LikeEndWith',
+	'Of',
+)

DefPixel/DataAccessObject/Implements/PostgreSQL/Function.py

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+
+from .Compiler import Compilable
+
+__all__ = (
+	'Function',
+)
+
+
+class Function(Compilable):
+	"""SQL function that compiles into a fragment and bound parameters."""

DefPixel/DataAccessObject/Implements/PostgreSQL/Functions/Common.py

@@ -0,0 +1,142 @@
+# -*- coding: utf-8 -*-
+
+from ..Column import Column
+from ..Compiler import (
+	Compilable,
+	Compiler,
+)
+from ..Exprs.Operator import conditions
+from ..Function import Function
+
+__all__ = (
+	'Count',
+	'Sum',
+	'Average',
+	'Min',
+	'Max',
+	'AggregateToArray',
+	'RowNumber',
+	'Rank',
+	'DenseRank',
+)
+
+
+def argument(col):
+	if isinstance(col, str):
+		return Column(col)
+	if not isinstance(col, Compilable):
+		raise TypeError('Function arguments must be column names or SQL expressions')
+	return col
+
+
+def where(compiler: Compiler, conds) -> str:
+	if not conds:
+		return ''
+	return ' FILTER (WHERE {})'.format(' AND '.join(compiler.compile(cond) for cond in conds))
+
+
+class Aggregate(Function):
+	name = ''
+
+	def __init__(
+		self,
+		col,
+		distinct: bool = False,
+	):
+		self.col = argument(col)
+		self.distinct = bool(distinct)
+		self.conds = ()
+		return
+
+	def where(self, *args):
+		self.conds = conditions(args)
+		return self
+
+	def compile(self, compiler: Compiler) -> str:
+		return '{}({}{}){}'.format(
+			self.name,
+			'DISTINCT ' if self.distinct else '',
+			compiler.compile(self.col),
+			where(compiler, self.conds),
+		)
+
+
+class Count(Aggregate):
+	name = 'COUNT'
+
+
+class Sum(Aggregate):
+	name = 'SUM'
+
+
+class Average(Aggregate):
+	name = 'AVG'
+
+
+class Min(Function):
+	name = 'MIN'
+
+	def __init__(self, col):
+		self.col = argument(col)
+		return
+
+	def compile(self, compiler: Compiler) -> str:
+		return '{}({})'.format(self.name, compiler.compile(self.col))
+
+
+class Max(Min):
+	name = 'MAX'
+
+
+class AggregateToArray(Function):
+	def __init__(
+		self,
+		col,
+		distinct: bool = False,
+	):
+		self.col = argument(col)
+		self.distinct = bool(distinct)
+		return
+
+	def compile(self, compiler: Compiler) -> str:
+		return 'ARRAY_AGG({}{})'.format(
+			'DISTINCT ' if self.distinct else '',
+			compiler.compile(self.col),
+		)
+
+
+class Window(Function):
+	name = ''
+
+	def __init__(self, *args):
+		self.orders = conditions(args, 'Orders')
+		self.partitions = ()
+		return
+
+	def order(self, *args):
+		self.orders = conditions(args, 'Orders')
+		return self
+
+	def partition(self, *args):
+		self.partitions = tuple(argument(arg) for arg in args)
+		return self
+
+	def compile(self, compiler: Compiler) -> str:
+		clauses = []
+		if self.partitions:
+			clauses.append('PARTITION BY {}'.format(', '.join(compiler.compile(arg) for arg in self.partitions)))
+		if self.orders:
+			clauses.append('ORDER BY {}'.format(', '.join(compiler.compile(arg) for arg in self.orders)))
+		return '{}() OVER({})'.format(self.name, ' '.join(clauses))
+
+
+class RowNumber(Window):
+	name = 'ROW_NUMBER'
+
+
+class Rank(Window):
+	name = 'RANK'
+
+
+class DenseRank(Window):
+	name = 'DENSE_RANK'

DefPixel/DataAccessObject/Implements/PostgreSQL/Functions/DateTime.py

@@ -0,0 +1,219 @@
+# -*- coding: utf-8 -*-
+
+from enum import Enum
+
+from ..Column import Column
+from ..Compiler import (
+	Compilable,
+	Compiler,
+)
+from ..Function import Function
+
+__all__ = (
+	'Now',
+	'DatePartType',
+	'DatePart',
+	'Year',
+	'Month',
+	'Day',
+	'Hour',
+	'Minute',
+	'Second',
+	'MilliSecond',
+	'MicroSecond',
+	'Quarter',
+	'Week',
+	'DayOfWeek',
+	'DayOfWeekISO',
+	'DayOfYear',
+	'Timezone',
+	'TimezoneHour',
+	'TimezoneMinute',
+	'TimezoneHourMinute',
+	'Millennium',
+	'Century',
+	'Decade',
+	'Epoch',
+)
+
+
+class Now(Function):
+	def compile(self, compiler: Compiler) -> str:
+		return 'NOW()'
+
+
+class DatePartType(str, Enum):
+	Year = 'YEAR'
+	Month = 'MONTH'
+	Day = 'DAY'
+	Hour = 'HOUR'
+	Minute = 'MINUTE'
+	Second = 'SECOND'
+	MilliSecond = 'MILLISECOND'
+	MicroSecond = 'MICROSECOND'
+	Quarter = 'QUARTER'
+	Week = 'WEEK'
+	DayOfWeek = 'DOW'
+	DayOfWeekISO = 'ISODOW'
+	DayOfYear = 'DOY'
+	Timezone = 'TIMEZONE'
+	TimezoneHour = 'TIMEZONE_HOUR'
+	TimezoneMinute = 'TIMEZONE_MINUTE'
+	TimezoneHourMinute = 'TIMEZONE_HOUR_MINUTE'
+	Millennium = 'MILLENNIUM'
+	Century = 'CENTURY'
+	Decade = 'DECADE'
+	Epoch = 'EPOCH'
+
+	def __str__(self) -> str:
+		return self.value
+
+
+class DatePart(Function):
+	"""DATE_PART('part', expr)."""
+
+	def __init__(
+		self,
+		part,
+		expr,
+	):
+		if isinstance(part, str) and not isinstance(part, DatePartType):
+			part = DatePartType(part.upper())
+		if not isinstance(part, DatePartType):
+			raise TypeError('part must be a DatePartType or its name')
+		if isinstance(expr, str):
+			expr = Column(expr)
+		if not isinstance(expr, Compilable):
+			raise TypeError('DatePart requires a column name or SQL expression')
+		self.part = part
+		self.expr = expr
+		return
+
+	def compile(self, compiler: Compiler) -> str:
+		return "DATE_PART('{}', {})".format(self.part.value, compiler.compile(self.expr))
+
+
+class Year(DatePart):
+	def __init__(self, expr):
+		super().__init__(DatePartType.Year, expr)
+		return
+
+
+class Month(DatePart):
+	def __init__(self, expr):
+		super().__init__(DatePartType.Month, expr)
+		return
+
+
+class Day(DatePart):
+	def __init__(self, expr):
+		super().__init__(DatePartType.Day, expr)
+		return
+
+
+class Hour(DatePart):
+	def __init__(self, expr):
+		super().__init__(DatePartType.Hour, expr)
+		return
+
+
+class Minute(DatePart):
+	def __init__(self, expr):
+		super().__init__(DatePartType.Minute, expr)
+		return
+
+
+class Second(DatePart):
+	def __init__(self, expr):
+		super().__init__(DatePartType.Second, expr)
+		return
+
+
+class MilliSecond(DatePart):
+	def __init__(self, expr):
+		super().__init__(DatePartType.MilliSecond, expr)
+		return
+
+
+class MicroSecond(DatePart):
+	def __init__(self, expr):
+		super().__init__(DatePartType.MicroSecond, expr)
+		return
+
+
+class Quarter(DatePart):
+	def __init__(self, expr):
+		super().__init__(DatePartType.Quarter, expr)
+		return
+
+
+class Week(DatePart):
+	def __init__(self, expr):
+		super().__init__(DatePartType.Week, expr)
+		return
+
+
+class DayOfWeek(DatePart):
+	def __init__(self, expr):
+		super().__init__(DatePartType.DayOfWeek, expr)
+		return
+
+
+class DayOfWeekISO(DatePart):
+	def __init__(self, expr):
+		super().__init__(DatePartType.DayOfWeekISO, expr)
+		return
+
+
+class DayOfYear(DatePart):
+	def __init__(self, expr):
+		super().__init__(DatePartType.DayOfYear, expr)
+		return
+
+
+class Timezone(DatePart):
+	def __init__(self, expr):
+		super().__init__(DatePartType.Timezone, expr)
+		return
+
+
+class TimezoneHour(DatePart):
+	def __init__(self, expr):
+		super().__init__(DatePartType.TimezoneHour, expr)
+		return
+
+
+class TimezoneMinute(DatePart):
+	def __init__(self, expr):
+		super().__init__(DatePartType.TimezoneMinute, expr)
+		return
+
+
+class TimezoneHourMinute(DatePart):
+	def __init__(self, expr):
+		super().__init__(DatePartType.TimezoneHourMinute, expr)
+		return
+
+
+class Millennium(DatePart):
+	def __init__(self, expr):
+		super().__init__(DatePartType.Millennium, expr)
+		return
+
+
+class Century(DatePart):
+	def __init__(self, expr):
+		super().__init__(DatePartType.Century, expr)
+		return
+
+
+class Decade(DatePart):
+	def __init__(self, expr):
+		super().__init__(DatePartType.Decade, expr)
+		return
+
+
+class Epoch(DatePart):
+	def __init__(self, expr):
+		super().__init__(DatePartType.Epoch, expr)
+		return

DefPixel/DataAccessObject/Implements/PostgreSQL/Functions/JavaScriptObjectNotation.py

@@ -0,0 +1,100 @@
+# -*- coding: utf-8 -*-
+
+from collections.abc import Mapping
+
+from ..Compiler import (
+	Compilable,
+	Compiler,
+)
+from ..Exprs.Operator import conditions
+from ..Function import Function
+from .Common import where
+
+__all__ = (
+	'AggregateToJSON',
+	'AggregateToJSONB',
+	'ToJSON',
+	'ToJSONB',
+)
+
+
+def value(compiler: Compiler, value) -> str:
+	"""Compile a JSON object value with a type PostgreSQL can resolve in variadic arguments."""
+	if value is None:
+		return 'NULL'
+	if isinstance(value, Compilable):
+		return compiler.compile(value)
+	if isinstance(value, str):
+		return compiler.bind(value, 'TEXT')
+	if isinstance(value, Mapping):
+		return compiler.bind(dict(value), 'JSONB')
+	return compiler.bind(value)
+
+
+class BuildObject(Function):
+	function = ''
+
+	def __init__(self, format):
+		if not isinstance(format, Mapping) or not format:
+			raise TypeError('format must be a nonempty mapping')
+		for key in format:
+			if not isinstance(key, str):
+				raise TypeError('JSON object keys must be strings')
+		self.kwargs = dict(format)
+		return
+
+	def build(self, compiler: Compiler) -> str:
+		return '{}({})'.format(
+			self.function,
+			', '.join(
+				'{}, {}'.format(compiler.bind(key, 'TEXT'), value(compiler, item))
+				for key, item in self.kwargs.items()
+			),
+		)
+
+	def compile(self, compiler: Compiler) -> str:
+		return self.build(compiler)
+
+
+class ToJSON(BuildObject):
+	"""JSON_BUILD_OBJECT(key, value, ...)."""
+	function = 'JSON_BUILD_OBJECT'
+
+
+class ToJSONB(BuildObject):
+	"""JSONB_BUILD_OBJECT(key, value, ...)."""
+	function = 'JSONB_BUILD_OBJECT'
+
+
+class AggregateToJSON(BuildObject):
+	"""JSON_AGG(JSONB_BUILD_OBJECT(...)) with an optional FILTER."""
+
+	function = 'JSONB_BUILD_OBJECT'
+	aggregate = 'JSON_AGG'
+
+	def __init__(
+		self,
+		format,
+		distinct: bool = False,
+	):
+		super().__init__(format)
+		self.distinct = bool(distinct)
+		self.conds = ()
+		return
+
+	def where(self, *args):
+		self.conds = conditions(args)
+		return self
+
+	def compile(self, compiler: Compiler) -> str:
+		return '{}({}{}){}'.format(
+			self.aggregate,
+			'DISTINCT ' if self.distinct else '',
+			self.build(compiler),
+			where(compiler, self.conds),
+		)
+
+
+class AggregateToJSONB(AggregateToJSON):
+	"""JSONB_AGG([DISTINCT] JSONB_BUILD_OBJECT(...)) with an optional FILTER."""
+	aggregate = 'JSONB_AGG'