DefPixel-PostgreSQL 0.1.6__91-py3-none-any.whl

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

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+
+from ..Compiler import (
+	Compiler,
+	quote,
+)
+from ..Function import Function
+from ..Schema import Schema
+from ..Sequence import Sequence
+
+__all__ = (
+	'NextVal',
+	'CurrVal',
+)
+
+
+class SequenceFunction(Function):
+	name = ''
+
+	def __init__(
+		self,
+		sequence,
+		schema=None,
+	):
+		if not isinstance(sequence, (Sequence, str)):
+			raise TypeError('sequence must be a Sequence or a sequence name')
+		if isinstance(schema, Schema):
+			schema = schema.name
+		if schema is not None and not isinstance(schema, str):
+			raise TypeError('schema must be a Schema or a schema name')
+		quote(str(sequence))
+		if schema is not None:
+			quote(schema)
+		self.sequence = sequence
+		self.schema = schema
+		return
+
+	def compile(self, compiler: Compiler) -> str:
+		schema = self.schema
+		if schema is None and isinstance(self.sequence, Sequence):
+			schema = self.sequence.schema
+		name = quote(str(self.sequence))
+		if schema is not None:
+			name = '{}.{}'.format(quote(schema), name)
+		return '{}({})'.format(self.name, compiler.bind(name, 'REGCLASS'))
+
+
+class NextVal(SequenceFunction):
+	"""NEXTVAL of a sequence; a Sequence declared on a table uses the table schema by default."""
+	name = 'NEXTVAL'
+
+
+class CurrVal(SequenceFunction):
+	"""CURRVAL of a sequence in the current session."""
+	name = 'CURRVAL'

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

@@ -0,0 +1,91 @@
+# -*- coding: utf-8 -*-
+
+from .Common import (
+	Count,
+	Sum,
+	Average,
+	Min,
+	Max,
+	AggregateToArray,
+	RowNumber,
+	Rank,
+	DenseRank,
+)
+from .DateTime import (
+	Now,
+	DatePartType,
+	DatePart,
+	Year,
+	Month,
+	Day,
+	Hour,
+	Minute,
+	Second,
+	MilliSecond,
+	MicroSecond,
+	Quarter,
+	Week,
+	DayOfWeek,
+	DayOfWeekISO,
+	DayOfYear,
+	Timezone,
+	TimezoneHour,
+	TimezoneMinute,
+	TimezoneHourMinute,
+	Millennium,
+	Century,
+	Decade,
+	Epoch,
+)
+from .Sequence import (
+	NextVal,
+	CurrVal,
+)
+from .JavaScriptObjectNotation import (
+	AggregateToJSON,
+	AggregateToJSONB,
+	ToJSON,
+	ToJSONB,
+)
+
+__all__ = (
+	'Count',
+	'Sum',
+	'Average',
+	'Min',
+	'Max',
+	'AggregateToArray',
+	'RowNumber',
+	'Rank',
+	'DenseRank',
+	'Now',
+	'DatePartType',
+	'DatePart',
+	'Year',
+	'Month',
+	'Day',
+	'Hour',
+	'Minute',
+	'Second',
+	'MilliSecond',
+	'MicroSecond',
+	'Quarter',
+	'Week',
+	'DayOfWeek',
+	'DayOfWeekISO',
+	'DayOfYear',
+	'Timezone',
+	'TimezoneHour',
+	'TimezoneMinute',
+	'TimezoneHourMinute',
+	'Millennium',
+	'Century',
+	'Decade',
+	'Epoch',
+	'NextVal',
+	'CurrVal',
+	'AggregateToJSON',
+	'AggregateToJSONB',
+	'ToJSON',
+	'ToJSONB',
+)

DefPixel/DataAccessObject/Implements/PostgreSQL/Index.py

@@ -0,0 +1,135 @@
+# -*- coding: utf-8 -*-
+
+from collections.abc import Sequence
+from enum import Enum
+from re import fullmatch
+from typing import Optional
+
+from .Column import Column
+from .Compiler import (
+	Compilable,
+	Compiler,
+	identifier,
+)
+from .Expr import Expr
+from .Type import Type
+
+__all__ = (
+	'IndexType',
+	'Index',
+	'IndexUnique',
+	'IndexOperation',
+)
+
+
+class IndexType(str, Enum):
+	BTree = 'BTREE'
+	Hash = 'HASH'
+	GeneralizedSearchTree = 'GIST'
+	SpacePartitionedGeneralizedSearchTree = 'SPGIST'
+	GeneralizedInvertedIndex = 'GIN'
+	BlockRangeIndex = 'BRIN'
+	Bloom = 'BLOOM'
+	ReverseUnorderedMatching = 'RUM'
+
+	def __str__(self) -> str:
+		return self.value
+
+
+EXTENSIONS = {
+	IndexType.Bloom: 'bloom',
+	IndexType.ReverseUnorderedMatching: 'rum',
+}
+
+
+def expression(value):
+	if isinstance(value, str):
+		identifier(value)
+		return value
+	if not isinstance(value, Compilable):
+		raise TypeError('Index expressions must be column names or SQL expressions')
+	return value
+
+
+class Index:
+	"""Index declaration with optional access method and partial-index condition."""
+
+	def __init__(
+		self,
+		name: str,
+		exprs,
+		unique: bool = False,
+		using: Optional[IndexType] = None,
+		notexists: bool = True,
+	):
+		identifier(name)
+		if isinstance(exprs, Sequence) and not isinstance(exprs, str):
+			exprs = list(exprs)
+		else:
+			exprs = [exprs]
+		if not exprs:
+			raise ValueError('An index requires at least one expression')
+		if using is not None:
+			using = IndexType(using)
+		self.name = name
+		self.exprs = [expression(expr) for expr in exprs]
+		self.unique = bool(unique)
+		self.using = using
+		self.notexists = bool(notexists)
+		self.conds = ()
+		return
+
+	def where(self, *args) -> 'Index':
+		for arg in args:
+			if not isinstance(arg, Compilable):
+				raise TypeError('Index conditions must be SQL expressions')
+		self.conds = args
+		return self
+
+	@property
+	def extension(self) -> Optional[str]:
+		return EXTENSIONS.get(self.using)
+
+
+class IndexUnique(Index):
+	"""Unique index declaration."""
+
+	def __init__(
+		self,
+		name: str,
+		exprs,
+		using: Optional[IndexType] = None,
+		notexists: bool = True,
+	):
+		super().__init__(
+			name=name,
+			exprs=exprs,
+			unique=True,
+			using=using,
+			notexists=notexists,
+		)
+		return
+
+
+class IndexOperation(Expr):
+	"""Index element with an operator class, for example GIN_TRGM_OPS."""
+
+	def __init__(
+		self,
+		col,
+		operator: str,
+	):
+		if not isinstance(operator, str) or not fullmatch(r'[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)?', operator):
+			raise ValueError('Operator class names must be plain SQL names')
+		self.col = Column(col) if isinstance(col, str) else expression(col)
+		self.operator = operator
+		return
+
+	def compile(self, compiler: Compiler) -> str:
+		col = compiler.compile(self.col)
+		if not (
+			isinstance(self.col, Column) and self.col.typecast is None
+			or isinstance(self.col, Type) and not compiler.qualify
+		):
+			col = '({})'.format(col)
+		return '{} {}'.format(col, self.operator)

DefPixel/DataAccessObject/Implements/PostgreSQL/Joins/FullOuter.py

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+
+from .Join import Join
+
+__all__ = (
+	'FullOuter',
+)
+
+
+class FullOuter(Join):
+	"""FULL OUTER JOIN."""
+
+	def __init__(self, table, *args):
+		super().__init__('FULL OUTER', table, *args)
+		return

DefPixel/DataAccessObject/Implements/PostgreSQL/Joins/Inner.py

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+
+from .Join import Join
+
+__all__ = (
+	'Inner',
+)
+
+
+class Inner(Join):
+	"""INNER JOIN."""
+
+	def __init__(self, table, *args):
+		super().__init__('INNER', table, *args)
+		return

DefPixel/DataAccessObject/Implements/PostgreSQL/Joins/Join.py

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+
+from ..Compiler import Compiler
+from ..Expr import Expr
+from ..Exprs.Operator import conditions
+from ..Mapping import inspect_model
+
+__all__ = (
+	'Join',
+)
+
+
+class Join(Expr):
+	"""JOIN of a mapped table or view with ON conditions."""
+
+	KINDS = ('INNER', 'LEFT OUTER', 'RIGHT OUTER', 'FULL OUTER')
+
+	def __init__(self, expr: str, table, *args):
+		if expr not in self.KINDS:
+			raise ValueError('Join type must be one of: {}'.format(', '.join(self.KINDS)))
+		self.expr = expr
+		self.mapping = inspect_model(table)
+		self.args = list(conditions(args))
+		return
+
+	def on(self, *args):
+		self.args = list(conditions(args))
+		return self
+
+	def where(self, expr):
+		self.args.extend(conditions((expr,)))
+		return self
+
+	def compile(self, compiler: Compiler) -> str:
+		if not self.args:
+			raise ValueError('A join requires at least one ON condition')
+		return '{} JOIN {} ON {}'.format(
+			self.expr,
+			self.mapping.target,
+			' AND '.join(compiler.compile(arg) for arg in self.args),
+		)

DefPixel/DataAccessObject/Implements/PostgreSQL/Joins/LeftOuter.py

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+
+from .Join import Join
+
+__all__ = (
+	'LeftOuter',
+)
+
+
+class LeftOuter(Join):
+	"""LEFT OUTER JOIN."""
+
+	def __init__(self, table, *args):
+		super().__init__('LEFT OUTER', table, *args)
+		return

DefPixel/DataAccessObject/Implements/PostgreSQL/Joins/RightOuter.py

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+
+from .Join import Join
+
+__all__ = (
+	'RightOuter',
+)
+
+
+class RightOuter(Join):
+	"""RIGHT OUTER JOIN."""
+
+	def __init__(self, table, *args):
+		super().__init__('RIGHT OUTER', table, *args)
+		return

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

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+
+from .Join import Join
+from .Inner import Inner
+from .LeftOuter import LeftOuter
+from .RightOuter import RightOuter
+from .FullOuter import FullOuter
+
+__all__ = (
+	'Join',
+	'Inner',
+	'LeftOuter',
+	'RightOuter',
+	'FullOuter',
+)