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

DefPixel/DataAccessObject/Implements/PostgreSQL/Constraints/ForeignKey.py

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+
+from typing import Optional
+
+from ..Compiler import identifier
+from ..Constraint import Constraint
+from .Columns import columns
+
+__all__ = (
+	'ForeignKey',
+)
+
+ACTIONS = (
+	'NO ACTION',
+	'RESTRICT',
+	'CASCADE',
+	'SET NULL',
+	'SET DEFAULT',
+)
+
+
+def action(name: str, value: Optional[str]) -> Optional[str]:
+	if value is None:
+		return None
+	if not isinstance(value, str) or ' '.join(value.upper().split()) not in ACTIONS:
+		raise ValueError('{} must be one of: {}'.format(name, ', '.join(ACTIONS)))
+	return ' '.join(value.upper().split())
+
+
+class ForeignKey(Constraint):
+	"""Named foreign key; reference is a mapped model or a table name."""
+
+	def __init__(
+		self,
+		name: str,
+		cols,
+		reference=None,
+		referenceCols=None,
+		onDelete: Optional[str] = None,
+		onUpdate: Optional[str] = None,
+	):
+		super().__init__(name)
+		if reference is None:
+			raise ValueError('ForeignKey requires a reference')
+		if isinstance(reference, str):
+			identifier(reference)
+		elif not isinstance(reference, type):
+			raise TypeError('ForeignKey reference must be a mapped model or a table name')
+		self.cols = columns(cols)
+		self.reference = reference
+		self.referenceCols = columns(referenceCols, 'referenceCols')
+		if len(self.cols) != len(self.referenceCols):
+			raise ValueError('Foreign key column counts do not match')
+		self.onDelete = action('onDelete', onDelete)
+		self.onUpdate = action('onUpdate', onUpdate)
+		return

DefPixel/DataAccessObject/Implements/PostgreSQL/Constraints/PrimaryKey.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+
+from ..Constraint import Constraint
+from .Columns import columns
+
+__all__ = (
+	'PrimaryKey',
+)
+
+
+class PrimaryKey(Constraint):
+	"""Named primary key constraint."""
+
+	def __init__(
+		self,
+		name: str,
+		cols,
+	):
+		super().__init__(name)
+		self.cols = columns(cols)
+		return

DefPixel/DataAccessObject/Implements/PostgreSQL/Constraints/Unique.py

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+
+from ..Constraint import Constraint
+from .Columns import columns
+
+__all__ = (
+	'Unique',
+)
+
+
+class Unique(Constraint):
+	"""Named unique constraint; null=True treats NULL values as equal (NULLS NOT DISTINCT)."""
+
+	def __init__(
+		self,
+		name: str,
+		cols,
+		null: bool = False,
+	):
+		super().__init__(name)
+		if not isinstance(null, bool):
+			raise TypeError('null must be a bool')
+		self.cols = columns(cols)
+		self.null = null
+		return

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

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+
+from .PrimaryKey import PrimaryKey
+from .ForeignKey import ForeignKey
+from .Unique import Unique
+from .Check import Check
+
+__all__ = (
+	'PrimaryKey',
+	'ForeignKey',
+	'Unique',
+	'Check',
+)

DefPixel/DataAccessObject/Implements/PostgreSQL/Context.py

@@ -0,0 +1,48 @@
+# -*- coding: utf-8 -*-
+
+from typing import (
+	Any,
+	Dict,
+	List,
+	Optional,
+)
+
+from DefPixel.DataAccessObject.Properties.Database import Context as BaseContext
+
+__all__ = (
+	'Context',
+)
+
+
+class Context(BaseContext):
+	"""Result of a PostgreSQL execution; reading rows advances the cursor."""
+
+	def __init__(
+		self,
+		cursor,
+		query: Optional[str] = None,
+	):
+		self.cursor = cursor
+		self.statement = query
+		return
+
+	def rows(self) -> List[Dict[str, Any]]:
+		if self.cursor.description is None:
+			return []
+		return [dict(row) for row in self.cursor.fetchall()]
+
+	def row(self) -> Optional[Dict[str, Any]]:
+		if self.cursor.description is None:
+			return None
+		row = self.cursor.fetchone()
+		return dict(row) if row is not None else None
+
+	def count(self) -> int:
+		"""Return the driver rowcount: affected or returned rows, or -1 when not applicable."""
+		return self.cursor.rowcount
+
+	@property
+	def query(self) -> str:
+		if self.statement is None:
+			raise RuntimeError('The executed query is not available in this context')
+		return self.statement

DefPixel/DataAccessObject/Implements/PostgreSQL/Cursor.py

@@ -0,0 +1,123 @@
+# -*- coding: utf-8 -*-
+
+from collections.abc import (
+	Mapping,
+	Sequence,
+)
+from typing import (
+	Any,
+	Dict,
+	List,
+	Optional,
+)
+
+from DefPixel.DataAccessObject.Properties.Database import (
+	Cursor as BaseCursor,
+	Executor,
+	Executors,
+	Fetch,
+	Run,
+)
+from .Context import Context
+from .Mapping import inspect_model
+
+__all__ = (
+	'Cursor',
+)
+
+
+def parameters(
+	args: tuple,
+	kwargs: dict,
+):
+	"""Return positional or named parameters; never both."""
+	if args and kwargs:
+		raise ValueError('Positional and named parameters cannot be used together')
+	if kwargs:
+		return kwargs
+	if args:
+		return args
+	return None
+
+
+def kind(params: Any) -> str:
+	if isinstance(params, Mapping):
+		return 'named'
+	if isinstance(params, Sequence) and not isinstance(params, (str, bytes, bytearray)):
+		return 'positional'
+	raise TypeError('Each parameter set must be a sequence or a mapping')
+
+
+class Cursor(BaseCursor, Run):
+	"""PostgreSQL cursor supporting direct SQL and ORM execution."""
+
+	def __init__(self, cursor):
+		self.cursor = cursor
+		return
+
+	def execute(
+		self,
+		sql: str,
+		*args,
+		**kwargs,
+	) -> Context:
+		self.cursor.execute(sql, parameters(args, kwargs))
+		return Context(self.cursor, sql)
+
+	def executes(
+		self,
+		sql: str,
+		*args,
+	) -> Context:
+		kinds = {kind(params) for params in args}
+		if len(kinds) > 1:
+			raise ValueError('Positional and named parameter sets cannot be mixed')
+		self.cursor.executemany(sql, args)
+		return Context(self.cursor, sql)
+
+	def run(
+		self,
+		executor,
+		filter=None,
+		fetch=None,
+	):
+		if fetch is not None:
+			inspect_model(fetch)
+		if isinstance(executor, Executor):
+			self.cursor.execute(executor.query, executor.args)
+			if isinstance(executor, Fetch):
+				return executor.fetch(
+					self,
+					filter=filter,
+					fetch=fetch,
+				)
+			return None
+		if isinstance(executor, Executors):
+			result = []
+			for statement in executor:
+				if not isinstance(statement, Executor):
+					raise TypeError('Executors must yield Executor objects')
+				value = self.run(
+					statement,
+					filter=filter,
+					fetch=fetch,
+				)
+				if isinstance(value, list):
+					result.extend(value)
+				elif value is not None:
+					result.append(value)
+			return result
+		raise TypeError('run requires an Executor or Executors object')
+
+	def rows(self) -> List[Dict[str, Any]]:
+		return Context(self.cursor).rows()
+
+	def row(self) -> Optional[Dict[str, Any]]:
+		return Context(self.cursor).row()
+
+	def count(self) -> int:
+		return self.cursor.rowcount
+
+	def close(self):
+		self.cursor.close()
+		return

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

@@ -0,0 +1,181 @@
+# -*- coding: utf-8 -*-
+
+from typing import List
+
+from DefPixel.DataAccessObject.Properties.Database import Executors
+
+from ..Column import Column
+from ..Compiler import (
+	Compilable,
+	Compiler,
+	identifier,
+	qualified,
+	typename,
+)
+from ..Constraints import (
+	Check,
+	ForeignKey,
+	PrimaryKey,
+	Unique,
+)
+from ..Index import (
+	Index,
+	IndexOperation,
+)
+from ..Mapping import (
+	Mapping,
+	Statement,
+	inspect_model,
+)
+from ..Schema import Schema
+from ..Sequence import Sequence
+from ..Type import Type
+
+__all__ = (
+	'Create',
+)
+
+
+def ddl() -> Compiler:
+	return Compiler(literal=True, qualify=False)
+
+
+def reference(mapping, col) -> str:
+	if isinstance(col, Type):
+		return identifier(col.key)
+	if isinstance(col, Column):
+		return col.compile(ddl())
+	if mapping is not None:
+		return identifier(mapping.key(col))
+	return identifier(col)
+
+
+def column(spec: Type) -> str:
+	default = spec.default()
+	return '{} {}{}{}'.format(
+		identifier(spec.key),
+		typename(spec),
+		' NOT NULL' if not spec.null else '',
+		' DEFAULT {}'.format(default) if default is not None else '',
+	)
+
+
+def constraint(mapping: Mapping, item) -> str:
+	name = identifier(item.name)
+	if isinstance(item, PrimaryKey):
+		return 'CONSTRAINT {} PRIMARY KEY({})'.format(name, ', '.join(reference(mapping, col) for col in item.cols))
+	if isinstance(item, Unique):
+		return 'CONSTRAINT {} UNIQUE{}({})'.format(
+			name,
+			' NULLS NOT DISTINCT' if item.null else '',
+			', '.join(reference(mapping, col) for col in item.cols),
+		)
+	if isinstance(item, Check):
+		return 'CONSTRAINT {} CHECK({})'.format(name, ddl().compile(item.expr))
+	if isinstance(item, ForeignKey):
+		if isinstance(item.reference, str):
+			target, other = identifier(item.reference), None
+		else:
+			other = inspect_model(item.reference, 'table')
+			target = other.target
+		return 'CONSTRAINT {} FOREIGN KEY({}) REFERENCES {}({}){}{}'.format(
+			name,
+			', '.join(reference(mapping, col) for col in item.cols),
+			target,
+			', '.join(reference(other, col) for col in item.referenceCols),
+			' ON UPDATE {}'.format(item.onUpdate) if item.onUpdate else '',
+			' ON DELETE {}'.format(item.onDelete) if item.onDelete else '',
+		)
+	raise TypeError('Unsupported constraint: {}'.format(type(item).__name__))
+
+
+def sequence(item: Sequence) -> str:
+	return 'CREATE SEQUENCE {}{} AS {} INCREMENT BY {} {} {}{}'.format(
+		'IF NOT EXISTS ' if item.notexists else '',
+		qualified(item.name, item.schema),
+		typename(item.type),
+		item.increment,
+		'NO MINVALUE' if item.min is None else 'MINVALUE {}'.format(item.min),
+		'NO MAXVALUE' if item.max is None else 'MAXVALUE {}'.format(item.max),
+		'' if item.start is None else ' START WITH {}'.format(item.start),
+	)
+
+
+def extension(item: Index) -> str:
+	return (
+		"DO $$ BEGIN IF NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname = '{0}') THEN "
+		"RAISE EXCEPTION 'The {0} extension is required for index {1}; run CREATE EXTENSION {0} first'; "
+		"END IF; END $$"
+	).format(item.extension, item.name.replace("'", "''").replace('%', '%%').replace('$', ''))
+
+
+def index(mapping: Mapping, item: Index) -> str:
+	compiler = ddl()
+	exprs = []
+	for expr in item.exprs:
+		if isinstance(expr, str):
+			exprs.append(identifier(mapping.key(expr) if expr in mapping.columns else expr))
+		elif (
+			isinstance(expr, (Type, IndexOperation))
+			or isinstance(expr, Column) and expr.typecast is None
+		):
+			exprs.append(compiler.compile(expr))
+		else:
+			exprs.append('({})'.format(compiler.compile(expr)))
+	return 'CREATE {}INDEX {}{} ON {}{}({}){}'.format(
+		'UNIQUE ' if item.unique else '',
+		'IF NOT EXISTS ' if item.notexists else '',
+		identifier(item.name),
+		mapping.target,
+		' USING {}'.format(item.using.value) if item.using else '',
+		', '.join(exprs),
+		' WHERE {}'.format(' AND '.join(compiler.compile(cond) for cond in item.conds)) if item.conds else '',
+	)
+
+
+class Create(Executors):
+	"""DDL statements that create a mapped table or view, or a Schema."""
+
+	def __init__(
+		self,
+		o,
+		notexist: bool = True,
+	):
+		self.o = o
+		self.notexist = bool(notexist)
+		self.executors = self.statements()
+		return
+
+	def statements(self) -> List[Statement]:
+		if isinstance(self.o, Schema):
+			return [Statement('CREATE SCHEMA {}{}{}'.format(
+				'IF NOT EXISTS ' if self.notexist else '',
+				identifier(self.o.name),
+				' AUTHORIZATION {}'.format(identifier(self.o.username)) if self.o.username else '',
+			))]
+		mapping = inspect_model(self.o)
+		if mapping.kind == 'view':
+			executor = mapping.executor
+			if not isinstance(executor, Compilable):
+				raise TypeError('View definitions require a PostgreSQL query Executor')
+			return [Statement('CREATE {}VIEW {} AS {}'.format(
+				'OR REPLACE ' if self.notexist else '',
+				mapping.target,
+				executor.compile(Compiler(literal=True)),
+			))]
+		statements = [Statement(sequence(item)) for item in mapping.sequences]
+		definitions = [column(spec) for spec in mapping.columns.values()]
+		definitions.extend(constraint(mapping, item) for item in mapping.constraints)
+		statements.append(Statement('CREATE TABLE {}{}({})'.format(
+			'IF NOT EXISTS ' if self.notexist else '',
+			mapping.target,
+			', '.join(definitions),
+		)))
+		for item in mapping.indexes:
+			if item.extension:
+				statements.append(Statement(extension(item)))
+			statements.append(Statement(index(mapping, item)))
+		return statements
+
+	def __iter__(self):
+		return iter(self.executors)

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

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+
+from DefPixel.DataAccessObject.Properties.Database import Executor
+
+from ..Compiler import Compiler
+from ..Exprs.Operator import conditions
+from ..Mapping import inspect_model
+from .Query import Query
+
+__all__ = (
+	'Delete',
+)
+
+
+class Delete(Query, Executor):
+	"""DELETE FROM ... [WHERE ...]."""
+
+	def __init__(self, o):
+		self.mapping = inspect_model(o, 'table')
+		self.conds = ()
+		return
+
+	def where(self, *args):
+		self.conds = conditions(args)
+		return self
+
+	def compile(self, compiler: Compiler) -> str:
+		return 'DELETE FROM {}{}'.format(
+			self.mapping.target,
+			' WHERE {}'.format(' AND '.join(compiler.compile(cond) for cond in self.conds)) if self.conds else '',
+		)

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

@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*-
+
+from typing import List
+
+from DefPixel.DataAccessObject.Properties.Database import Executors
+
+from ..Compiler import (
+	identifier,
+	qualified,
+)
+from ..Mapping import (
+	Statement,
+	inspect_model,
+)
+from ..Schema import Schema
+
+__all__ = (
+	'Drop',
+)
+
+
+class Drop(Executors):
+	"""DDL statements that drop a mapped table or view, or a Schema."""
+
+	def __init__(
+		self,
+		o,
+		exist: bool = True,
+		cascade: bool = False,
+	):
+		self.o = o
+		self.exist = bool(exist)
+		self.cascade = bool(cascade)
+		self.executors = self.statements()
+		return
+
+	def statements(self) -> List[Statement]:
+		exists = 'IF EXISTS ' if self.exist else ''
+		mode = ' CASCADE' if self.cascade else ' RESTRICT'
+		if isinstance(self.o, Schema):
+			return [Statement('DROP SCHEMA {}{}{}'.format(exists, identifier(self.o.name), mode))]
+		mapping = inspect_model(self.o)
+		if mapping.kind == 'view':
+			return [Statement('DROP VIEW {}{}{}'.format(exists, mapping.target, mode))]
+		statements = [Statement('DROP TABLE {}{}{}'.format(exists, mapping.target, mode))]
+		statements.extend(
+			Statement('DROP SEQUENCE {}{}{}'.format(exists, qualified(item.name, item.schema), mode))
+			for item in mapping.sequences
+		)
+		return statements
+
+	def __iter__(self):
+		return iter(self.executors)

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

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+
+from .Select import Select
+
+__all__ = (
+	'Get',
+)
+
+
+class Get(Select):
+	"""Select that returns the first result or None."""
+
+	def fetch(
+		self,
+		cursor,
+		filter=None,
+		fetch=None,
+	):
+		rows = super().fetch(
+			cursor,
+			filter=filter,
+			fetch=fetch,
+		)
+		return rows[0] if rows else None

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

@@ -0,0 +1,98 @@
+# -*- coding: utf-8 -*-
+
+from DefPixel.DataAccessObject.Properties.Database import (
+	Executor,
+	Fetch,
+)
+from ..Column import Column
+from ..Compiler import (
+	Compiler,
+	identifier,
+	valuetype,
+)
+from ..Mapping import inspect_model
+from ..Type import Type
+from .Query import Query
+
+__all__ = (
+	'Insert',
+)
+
+
+def first(
+	cursor,
+	filter=None,
+	fetch=None,
+):
+	rows = cursor.rows()
+	if not rows:
+		return None
+	row = rows[0]
+	if filter is not None:
+		row = filter(row)
+	if fetch is not None:
+		return inspect_model(fetch).restore(row)
+	return row
+
+
+class Insert(Query, Executor, Fetch):
+	"""INSERT ... RETURNING * with optional ON CONFLICT DO NOTHING or DO UPDATE SET."""
+
+	def __init__(self, o):
+		self.mapping = inspect_model(o, 'table')
+		self.kwargs = {}
+		self.ons = ()
+		self.onkwargs = {}
+		return
+
+	def values(self, **kwargs):
+		self.kwargs.update(self.mapping.values(kwargs))
+		return self
+
+	def on(self, *args):
+		ons = []
+		for arg in args:
+			if isinstance(arg, Type):
+				ons.append(arg.key)
+			elif isinstance(arg, Column):
+				ons.append(arg.name)
+			elif isinstance(arg, str):
+				ons.append(self.mapping.key(arg))
+			else:
+				raise TypeError('Conflict targets must be column names, Column objects, or column specifications')
+		self.ons = tuple(ons)
+		return self
+
+	def set(self, **kwargs):
+		self.onkwargs.update(self.mapping.values(kwargs))
+		return self
+
+	def compile(self, compiler: Compiler) -> str:
+		if self.onkwargs and not self.ons:
+			raise ValueError('set() requires on() conflict targets')
+		if self.kwargs:
+			sql = 'INSERT INTO {}({}) VALUES({})'.format(
+				self.mapping.target,
+				', '.join(identifier(key) for key in self.kwargs),
+				', '.join(compiler.bind(value, valuetype(spec)) for spec, value in self.kwargs.values()),
+			)
+		else:
+			sql = 'INSERT INTO {} DEFAULT VALUES'.format(self.mapping.target)
+		if self.ons:
+			sql += ' ON CONFLICT ({}) DO '.format(', '.join(identifier(key) for key in self.ons))
+			if self.onkwargs:
+				sql += 'UPDATE SET {}'.format(', '.join(
+					'{}={}'.format(identifier(key), compiler.bind(value, valuetype(spec)))
+					for key, (spec, value) in self.onkwargs.items()
+				))
+			else:
+				sql += 'NOTHING'
+		return sql + ' RETURNING *'
+
+	def fetch(
+		self,
+		cursor,
+		filter=None,
+		fetch=None,
+	):
+		return first(cursor, filter, fetch)