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

DefPixel/DataAccessObject/Implements/PostgreSQL/Executors/Query.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+
+from abc import abstractmethod
+from typing import (
+	Any,
+	Dict,
+)
+
+from ..Compiler import (
+	Compilable,
+	Compiler,
+)
+
+__all__ = (
+	'Query',
+)
+
+
+class Query(Compilable):
+	"""Executor base whose query and args come from one deterministic compilation."""
+
+	@abstractmethod
+	def compile(self, compiler: Compiler) -> str:
+		raise NotImplementedError('{} must be implemented compile'.format(self.__class__.__name__))
+
+	def statement(self):
+		compiler = Compiler()
+		query = self.compile(compiler)
+		return query, compiler.args
+
+	@property
+	def query(self) -> str:
+		return self.statement()[0]
+
+	@property
+	def args(self) -> Dict[str, Any]:
+		return self.statement()[1]

DefPixel/DataAccessObject/Implements/PostgreSQL/Executors/Select.py

@@ -0,0 +1,122 @@
+# -*- coding: utf-8 -*-
+
+from DefPixel.DataAccessObject.Properties.Database import (
+	Executor,
+	Fetch,
+)
+from ..Column import Column
+from ..Compiler import (
+	Compilable,
+	Compiler,
+)
+from ..Exprs.Operator import conditions
+from ..Joins import Join
+from ..Mapping import inspect_model
+from .Query import Query
+
+__all__ = (
+	'Select',
+)
+
+
+def expressions(args, name: str) -> tuple:
+	result = []
+	for arg in args:
+		if isinstance(arg, str):
+			arg = Column(arg)
+		if not isinstance(arg, Compilable):
+			raise TypeError('{} must be column names or SQL expressions'.format(name))
+		result.append(arg)
+	return tuple(result)
+
+
+class Select(Query, Executor, Fetch):
+	"""SELECT query for a mapped table or view."""
+
+	def __init__(self, o):
+		self.mapping = inspect_model(o)
+		self.joins = ()
+		self.conds = ()
+		self.grps = ()
+		self.havs = ()
+		self.ords = ()
+		self.vals = ()
+		self.offset = 0
+		self.size = None
+		return
+
+	def join(self, *args):
+		for arg in args:
+			if not isinstance(arg, Join):
+				raise TypeError('join requires Join objects')
+		self.joins = args
+		return self
+
+	def where(self, *args):
+		self.conds = conditions(args)
+		return self
+
+	def group(self, *args):
+		self.grps = expressions(args, 'Groups')
+		return self
+
+	def having(self, *args):
+		self.havs = conditions(args)
+		return self
+
+	def order(self, *args):
+		self.ords = expressions(args, 'Orders')
+		return self
+
+	def limit(
+		self,
+		size=None,
+		offset=0,
+	):
+		if size is not None and (type(size) is not int or size < 0):
+			raise ValueError('size must be a nonnegative integer')
+		if type(offset) is not int or offset < 0:
+			raise ValueError('offset must be a nonnegative integer')
+		self.size = size
+		self.offset = offset
+		return self
+
+	def values(self, *args):
+		self.vals = expressions(args, 'Values')
+		return self
+
+	def compile(self, compiler: Compiler) -> str:
+		columns = self.vals or tuple(self.mapping.columns.values())
+		sql = 'SELECT {} FROM {}'.format(
+			', '.join(compiler.compile(value) for value in columns),
+			self.mapping.target,
+		)
+		for join in self.joins:
+			sql += ' ' + compiler.compile(join)
+		for keyword, values, separator in (
+			('WHERE', self.conds, ' AND '),
+			('GROUP BY', self.grps, ', '),
+			('HAVING', self.havs, ' AND '),
+			('ORDER BY', self.ords, ', '),
+		):
+			if values:
+				sql += ' {} {}'.format(keyword, separator.join(compiler.compile(value) for value in values))
+		if self.size is not None:
+			sql += ' LIMIT {}'.format(self.size)
+		if self.offset:
+			sql += ' OFFSET {}'.format(self.offset)
+		return sql
+
+	def fetch(
+		self,
+		cursor,
+		filter=None,
+		fetch=None,
+	):
+		mapping = inspect_model(fetch) if fetch is not None else None
+		result = []
+		for row in cursor.rows():
+			if filter is not None:
+				row = filter(row)
+			result.append(mapping.restore(row) if mapping is not None else row)
+		return result if result else None

DefPixel/DataAccessObject/Implements/PostgreSQL/Executors/Update.py

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+
+from DefPixel.DataAccessObject.Properties.Database import (
+	Executor,
+	Fetch,
+)
+from ..Compiler import (
+	Compiler,
+	identifier,
+	valuetype,
+)
+from ..Exprs.Operator import conditions
+from ..Mapping import inspect_model
+from .Insert import first
+from .Query import Query
+
+__all__ = (
+	'Update',
+)
+
+
+class Update(Query, Executor, Fetch):
+	"""UPDATE ... SET ... [WHERE ...] RETURNING *; fetch returns the first updated row."""
+
+	def __init__(self, o):
+		self.mapping = inspect_model(o, 'table')
+		self.kwargs = {}
+		self.conds = ()
+		return
+
+	def set(self, **kwargs):
+		self.kwargs.update(self.mapping.values(kwargs))
+		return self
+
+	def where(self, *args):
+		self.conds = conditions(args)
+		return self
+
+	def compile(self, compiler: Compiler) -> str:
+		if not self.kwargs:
+			raise ValueError('No columns are specified for update')
+		return 'UPDATE {} SET {}{} RETURNING *'.format(
+			self.mapping.target,
+			', '.join(
+				'{}={}'.format(identifier(key), compiler.bind(value, valuetype(spec)))
+				for key, (spec, value) in self.kwargs.items()
+			),
+			' WHERE {}'.format(' AND '.join(compiler.compile(cond) for cond in self.conds)) if self.conds else '',
+		)
+
+	def fetch(
+		self,
+		cursor,
+		filter=None,
+		fetch=None,
+	):
+		return first(cursor, filter, fetch)

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

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+
+from .Create import Create
+from .Drop import Drop
+from .Insert import Insert
+from .Update import Update
+from .Delete import Delete
+from .Select import Select
+from .Get import Get
+
+__all__ = (
+	'Create',
+	'Drop',
+	'Insert',
+	'Update',
+	'Delete',
+	'Select',
+	'Get',
+)

DefPixel/DataAccessObject/Implements/PostgreSQL/Expr.py

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

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

@@ -0,0 +1,180 @@
+# -*- coding: utf-8 -*-
+
+from dataclasses import MISSING
+
+from ..Compiler import (
+	Compilable,
+	Compiler,
+	identifier,
+	typename,
+)
+from ..Expr import Expr
+
+__all__ = (
+	'Alias',
+	'TypeTo',
+	'If',
+	'IfNull',
+	'IfNotNull',
+	'Switch',
+	'Query',
+)
+
+
+def term(compiler: Compiler, value) -> str:
+	"""Compile a value, rendering None as the NULL keyword."""
+	if value is None:
+		return 'NULL'
+	return compiler.compile(value)
+
+
+class Alias(Expr):
+	"""expr AS "name"."""
+
+	def __init__(
+		self,
+		col,
+		name: str,
+	):
+		identifier(name)
+		self.col = col
+		self.name = name
+		return
+
+	def compile(self, compiler: Compiler) -> str:
+		return '{} AS {}'.format(term(compiler, self.col), identifier(self.name))
+
+
+class TypeTo(Expr):
+	"""expr::type."""
+
+	def __init__(
+		self,
+		col,
+		type,
+	):
+		typename(type)
+		self.col = col
+		self.type = type
+		return
+
+	def compile(self, compiler: Compiler) -> str:
+		if isinstance(self.col, Compilable):
+			return '({})::{}'.format(compiler.compile(self.col), typename(self.type))
+		if self.col is None:
+			return 'NULL::{}'.format(typename(self.type))
+		return compiler.bind(self.col, self.type)
+
+
+class Conditional(Expr):
+	def __init__(
+		self,
+		cond,
+		thenexpr=None,
+		elseexpr=MISSING,
+	):
+		self.cond = cond
+		self.thenexpr = thenexpr
+		self.elseexpr = elseexpr
+		return
+
+	def then_(self, expr):
+		self.thenexpr = expr
+		return self
+
+	def else_(self, expr):
+		self.elseexpr = expr
+		return self
+
+
+class If(Conditional):
+	"""CASE WHEN cond THEN then [ELSE else] END."""
+
+	def __init__(
+		self,
+		cond,
+		thenexpr=None,
+		elseexpr=MISSING,
+	):
+		if not isinstance(cond, Compilable):
+			raise TypeError('If requires a SQL condition')
+		super().__init__(cond, thenexpr, elseexpr)
+		return
+
+	def compile(self, compiler: Compiler) -> str:
+		return 'CASE WHEN {} THEN {}{} END'.format(
+			compiler.compile(self.cond),
+			term(compiler, self.thenexpr),
+			'' if self.elseexpr is MISSING else ' ELSE {}'.format(term(compiler, self.elseexpr)),
+		)
+
+
+class IfNull(Conditional):
+	"""CASE WHEN expr IS NULL THEN then ELSE else-or-expr END."""
+
+	predicate = 'IS NULL'
+
+	def compile(self, compiler: Compiler) -> str:
+		return 'CASE WHEN {} {} THEN {} ELSE {} END'.format(
+			compiler.compile(self.cond),
+			self.predicate,
+			term(compiler, self.thenexpr),
+			compiler.compile(self.cond) if self.elseexpr is MISSING else term(compiler, self.elseexpr),
+		)
+
+
+class IfNotNull(IfNull):
+	"""CASE WHEN expr IS NOT NULL THEN then ELSE else-or-expr END."""
+
+	predicate = 'IS NOT NULL'
+
+
+class Switch(Expr):
+	"""CASE WHEN cond THEN value ... [ELSE other] END built from (cond, value) pairs."""
+
+	def __init__(self, *args):
+		self.args = []
+		self.elseexpr = MISSING
+		for arg in args:
+			if not isinstance(arg, (tuple, list)) or len(arg) != 2:
+				raise TypeError('Switch arguments must be (condition, value) pairs')
+			self.case(*arg)
+		return
+
+	def case(
+		self,
+		cond,
+		thenexpr=None,
+	):
+		if not isinstance(cond, Compilable):
+			raise TypeError('Switch cases require SQL conditions')
+		self.args.append((cond, thenexpr))
+		return self
+
+	def other(self, elseexpr=None):
+		self.elseexpr = elseexpr
+		return self
+
+	def compile(self, compiler: Compiler) -> str:
+		if not self.args:
+			return 'NULL'
+		return 'CASE {}{} END'.format(
+			' '.join(
+				'WHEN {} THEN {}'.format(compiler.compile(cond), term(compiler, value))
+				for cond, value in self.args
+			),
+			'' if self.elseexpr is MISSING else ' ELSE {}'.format(term(compiler, self.elseexpr)),
+		)
+
+
+class Query(Expr):
+	"""Parenthesized subquery whose parameters join the outer query."""
+
+	def __init__(self, executor):
+		if not isinstance(executor, Compilable):
+			raise TypeError('Query requires a PostgreSQL Select executor')
+		self.executor = executor
+		return
+
+	def compile(self, compiler: Compiler) -> str:
+		return '({})'.format(self.executor.compile(compiler))

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

@@ -0,0 +1,87 @@
+# -*- coding: utf-8 -*-
+
+from ..Compiler import Compiler
+from ..Expr import Expr
+from ..Types.JavaScriptObjectNotation import JavaScriptObjectNotation
+from .JavaScriptObjectNotation import Of
+
+__all__ = (
+	'EqualTo',
+	'NotEqualTo',
+	'GreaterThan',
+	'GreaterEqualTo',
+	'LessThan',
+	'LessEqualTo',
+)
+
+
+def is_json_type(expr):
+	if isinstance(expr, JavaScriptObjectNotation):
+		return expr
+	if isinstance(expr, Of) and expr.type is None:
+		return is_json_type(expr.col)
+	return None
+
+
+class Compare(Expr):
+	operator = ''
+	null = None
+
+	def __init__(
+		self,
+		col,
+		other,
+	):
+		self.col = col
+		self.other = other
+		return
+
+	def compile(self, compiler: Compiler) -> str:
+		json_type = is_json_type(self.col) or is_json_type(self.other)
+		if json_type is not None and isinstance(self.col, list):
+			col = compiler.bind(json_type.adapt(self.col))
+		else:
+			col = compiler.compile(self.col)
+		if isinstance(self.col, Expr):
+			col = '({})'.format(col)
+		if self.other is None and self.null is not None:
+			return '{} {}'.format(col, self.null)
+		if json_type is not None and isinstance(self.other, list):
+			other = compiler.bind(json_type.adapt(self.other))
+		else:
+			other = compiler.compile(self.other)
+		if isinstance(self.other, Expr):
+			other = '({})'.format(other)
+		return '{} {} {}'.format(
+			col,
+			self.operator,
+			other,
+		)
+
+
+class EqualTo(Compare):
+	"""col = other; None compiles to IS NULL."""
+	operator = '='
+	null = 'IS NULL'
+
+
+class NotEqualTo(Compare):
+	"""col != other; None compiles to IS NOT NULL."""
+	operator = '!='
+	null = 'IS NOT NULL'
+
+
+class GreaterThan(Compare):
+	operator = '>'
+
+
+class GreaterEqualTo(Compare):
+	operator = '>='
+
+
+class LessThan(Compare):
+	operator = '<'
+
+
+class LessEqualTo(Compare):
+	operator = '<='

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

@@ -0,0 +1,155 @@
+# -*- coding: utf-8 -*-
+
+from collections.abc import Sequence
+
+from ..Compiler import (
+	Compilable,
+	Compiler,
+	typename,
+	valuetype,
+)
+from ..Expr import Expr
+from ..Type import Type
+
+__all__ = (
+	'In',
+	'NotIn',
+	'Is',
+	'IsNull',
+	'IsNotNull',
+	'IsTrue',
+	'IsNotTrue',
+	'IsFalse',
+	'IsNotFalse',
+	'IsUnknown',
+	'IsNotUnknown',
+)
+
+
+class Membership(Expr):
+	operator = ''
+	array = ''
+
+	def __init__(
+		self,
+		col,
+		args=None,
+	):
+		self.col = col
+		if args is None:
+			self.args = []
+		elif isinstance(args, Sequence) and not isinstance(args, (str, bytes, bytearray)):
+			self.args = list(args)
+		else:
+			self.args = [args]
+		return
+
+	def where(self, arg):
+		self.args.append(arg)
+		return self
+
+	def compile(self, compiler: Compiler) -> str:
+		col = compiler.compile(self.col)
+		if isinstance(self.col, Expr):
+			col = '({})'.format(col)
+		from .Common import Query
+		if len(self.args) == 1 and isinstance(self.args[0], Query):
+			return '{} {} {}'.format(col, self.operator, compiler.compile(self.args[0]))
+		if any(isinstance(arg, Compilable) for arg in self.args):
+			return '{} {} ({})'.format(
+				col,
+				self.operator,
+				', '.join(compiler.compile(arg) for arg in self.args),
+			)
+		cast = None
+		if isinstance(self.col, Type):
+			if typename(self.col, escape=False).endswith(']'):
+				if not self.args:
+					return 'FALSE' if self.operator == 'IN' else 'TRUE'
+				return '{} {} ({})'.format(
+					col,
+					self.operator,
+					', '.join(compiler.bind(arg, valuetype(self.col)) for arg in self.args),
+				)
+			cast = '{}[]'.format(valuetype(self.col))
+		return '{} {}({})'.format(col, self.array, compiler.bind(list(self.args), cast))
+
+
+class In(Membership):
+	"""col IN values; plain values are bound as one array parameter (= ANY)."""
+	operator = 'IN'
+	array = '= ANY'
+
+
+class NotIn(Membership):
+	"""col NOT IN values; plain values are bound as one array parameter (<> ALL)."""
+	operator = 'NOT IN'
+	array = '<> ALL'
+
+
+KEYWORDS = {
+	None: 'NULL',
+	True: 'TRUE',
+	False: 'FALSE',
+}
+
+
+class Is(Expr):
+	"""col IS other, where other is None, True, or False."""
+
+	def __init__(
+		self,
+		col,
+		other,
+	):
+		if not any(other is key for key in KEYWORDS):
+			raise TypeError('Is requires None, True, or False')
+		self.col = col
+		self.other = other
+		return
+
+	def compile(self, compiler: Compiler) -> str:
+		return '{} IS {}'.format(compiler.compile(self.col), KEYWORDS[self.other])
+
+
+class Predicate(Expr):
+	predicate = ''
+
+	def __init__(self, col):
+		self.col = col
+		return
+
+	def compile(self, compiler: Compiler) -> str:
+		return '{} {}'.format(compiler.compile(self.col), self.predicate)
+
+
+class IsNull(Predicate):
+	predicate = 'IS NULL'
+
+
+class IsNotNull(Predicate):
+	predicate = 'IS NOT NULL'
+
+
+class IsTrue(Predicate):
+	predicate = 'IS TRUE'
+
+
+class IsNotTrue(Predicate):
+	predicate = 'IS NOT TRUE'
+
+
+class IsFalse(Predicate):
+	predicate = 'IS FALSE'
+
+
+class IsNotFalse(Predicate):
+	predicate = 'IS NOT FALSE'
+
+
+class IsUnknown(Predicate):
+	predicate = 'IS UNKNOWN'
+
+
+class IsNotUnknown(Predicate):
+	predicate = 'IS NOT UNKNOWN'