DefPixel 0.1.0__3-py3-none-any.whl

DefPixel/DataAccessObject/Configuration.py

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+
+from abc import ABCMeta, abstractmethod
+
+__all__ = (
+	'Configuration'
+)
+
+
+class Configuration(metaclass=ABCMeta):
+	"""Configuration Interface"""
+
+	@abstractmethod
+	def __init__(self, *args, **kwargs):
+		raise NotImplementedError('{} must be implemented __init__'.format(self.__class__.__name__))

DefPixel/DataAccessObject/Connection.py

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+
+from .Configuration import Configuration
+
+from abc import ABCMeta, abstractmethod
+
+__all__ = (
+	'Connection'
+)
+
+
+class Connection(metaclass=ABCMeta):
+	"""Connection Interface"""
+
+	@abstractmethod
+	def __init__(self, conf: Configuration):
+		raise NotImplementedError('{} must be implemented __init__ method'.format(self.__class__.__name__))
+
+	@abstractmethod
+	def connect(self):
+		raise NotImplementedError('{} must be implemented connect method'.format(self.__class__.__name__))
+
+	@abstractmethod
+	def close(self):
+		raise NotImplementedError('{} must be implemented close method'.format(self.__class__.__name__))

DefPixel/DataAccessObject/Implements/Sqlite/Configuration.py

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+
+from DefPixel.DataAccessObject import Configuration as BaseConfiguration
+
+__all__ = (
+	'Configuration'
+)
+
+
+class Configuration(BaseConfiguration):
+	"""Configuration Class for Sqlite"""
+
+	def __init__(self, path: str, autocommit: bool = False):
+		self.path = path
+		self.autocommit = autocommit
+		return

DefPixel/DataAccessObject/Implements/Sqlite/Connection.py

@@ -0,0 +1,96 @@
+# -*- coding: utf-8 -*-
+
+from sqlite3 import (
+	Row,
+	connect,
+)
+from DefPixel.DataAccessObject import Connection as BaseConnection
+from DefPixel.DataAccessObject.Properties.Database import (
+	Database,
+	Run,
+)
+from .Cursor import Cursor
+from .Session import Session
+
+__all__ = (
+	'Connection',
+)
+
+
+class Connection(BaseConnection, Database, Run):
+	"""SQLite connection with explicit lifecycle and transaction management."""
+
+	def __init__(self, conf):
+		self.conf = conf
+		self.connection = None
+		return
+
+	def connect(self):
+		if self.connection is not None:
+			raise RuntimeError('The SQLite connection is already open')
+		self.connection = connect(
+			self.conf.path,
+			isolation_level=None if self.conf.autocommit else 'DEFERRED',
+			check_same_thread=False,
+		)
+		self.connection.row_factory = Row
+		return
+
+	def active(self):
+		if self.connection is None:
+			raise RuntimeError('The SQLite connection is not open')
+		return self.connection
+
+	def close(self):
+		if self.connection is not None:
+			self.connection.close()
+			self.connection = None
+		return
+
+	def begin(self):
+		self.active().execute('BEGIN')
+		return
+
+	def execute(
+		self,
+		sql,
+		*args,
+	):
+		return self.cursor().execute(sql, *args)
+
+	def executes(
+		self,
+		sql,
+		*args,
+	):
+		return self.cursor().executes(sql, *args)
+
+	def run(
+		self,
+		executor,
+		filter=None,
+		fetch=None,
+	):
+		cursor = self.cursor()
+		try:
+			return cursor.run(
+				executor,
+				filter=filter,
+				fetch=fetch,
+			)
+		finally:
+			cursor.close()
+
+	def cursor(self):
+		return Cursor(self.active().cursor())
+
+	def session(self):
+		return Session(self.active())
+
+	def commit(self):
+		self.active().commit()
+		return
+
+	def rollback(self):
+		self.active().rollback()
+		return

DefPixel/DataAccessObject/Implements/Sqlite/Constraint.py

@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+
+__all__ = (
+	'Constraint'
+)
+
+
+class Constraint:
+	"""Base marker for SQLite constraint declarations."""

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

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+
+from ..Constraint import Constraint
+
+__all__ = (
+	'ForeignKey'
+)
+
+
+class ForeignKey(Constraint):
+	def __init__(self, cols, reference, referenceCols):
+		self.cols = cols if isinstance(cols, (tuple, list)) else [cols]
+		self.reference = reference
+		self.referenceCols = referenceCols if isinstance(referenceCols, (tuple, list)) else [referenceCols]
+		return
+	

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

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+
+from ..Constraint import Constraint
+
+__all__ = (
+	'PrimaryKey'
+)
+
+
+class PrimaryKey(Constraint):
+	def __init__(self, cols, autoincrement=False):
+		self.cols = cols if isinstance(cols, (tuple, list)) else [cols]
+		self.autoincrement = autoincrement
+		return
+	

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

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+
+from ..Constraint import Constraint
+
+from typing import Union, Sequence
+
+__all__ = (
+	'Unique'
+)
+
+
+class Unique(Constraint):
+	def __init__(
+		self, 
+		name: str,
+		colexprs: Union[str, Sequence[str]],
+		expr: str = None,
+		notexists: bool = None,
+	):
+		self.name = name
+		self.colexprs = colexprs if isinstance(colexprs, (tuple, list)) else [colexprs]
+		self.expr = expr
+		self.notexists = notexists 
+		return
+	

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

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

DefPixel/DataAccessObject/Implements/Sqlite/Context.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+
+from DefPixel.DataAccessObject.Properties.Database import Context as BaseContext
+
+__all__ = (
+	'Context',
+)
+
+
+class Context(BaseContext):
+	"""Context exposing SQLite execution results."""
+
+	def __init__(
+		self,
+		cursor,
+		query=None,
+	):
+		self.cursor = cursor
+		self.statement = query
+		return
+
+	def rows(self):
+		return [dict(row) for row in self.cursor.fetchall()]
+
+	def row(self):
+		row = self.cursor.fetchone()
+		return dict(row) if row is not None else None
+
+	def count(self):
+		return self.cursor.connection.total_changes
+
+	@property
+	def query(self):
+		if self.statement is None:
+			raise RuntimeError('The executed query is not available in this context')
+		return self.statement

DefPixel/DataAccessObject/Implements/Sqlite/Cursor.py

@@ -0,0 +1,87 @@
+# -*- coding: utf-8 -*-
+
+from DefPixel.DataAccessObject.Properties.Database import (
+	Cursor as BaseCursor,
+	Executor,
+	Executors,
+	Fetch,
+	Run,
+)
+from .Context import Context
+from .Mapping import inspect_model
+
+__all__ = (
+	'Cursor',
+)
+
+
+class Cursor(BaseCursor, Run):
+	"""SQLite cursor supporting direct SQL and ORM execution."""
+
+	def __init__(self, cursor):
+		self.cursor = cursor
+		return
+
+	def execute(
+		self,
+		sql,
+		*args,
+	):
+		self.cursor.execute(sql, args)
+		return Context(self.cursor, sql)
+
+	def executes(
+		self,
+		sql,
+		*args,
+	):
+		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):
+		return [dict(row) for row in self.cursor.fetchall()]
+
+	def row(self):
+		row = self.cursor.fetchone()
+		return dict(row) if row is not None else None
+
+	def count(self):
+		raise RuntimeError('SQLite query result row counts are not supported')
+
+	def close(self):
+		self.cursor.close()
+		return

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

@@ -0,0 +1,115 @@
+# -*- coding: utf-8 -*-
+
+from dataclasses import MISSING
+from DefPixel.DataAccessObject.Properties.Database import Executors
+from ..Constraints import (
+	ForeignKey,
+	PrimaryKey,
+	Unique,
+)
+from ..Function import Function
+from ..Index import Index
+from ..Mapping import (
+	Statement,
+	identifier,
+	inspect_model,
+)
+from ..Expr import Expr
+
+__all__ = (
+	'Create',
+)
+
+
+class Create(Executors):
+	"""Provide table, view, and index creation as individual execution statements."""
+
+	def __init__(
+		self,
+		o,
+		notexist=True,
+	):
+		mapping = inspect_model(o)
+		self.executors = []
+		if mapping.kind == 'view':
+			self.executors.append(Statement(
+				'CREATE VIEW {}{} AS {}'.format(
+					'IF NOT EXISTS ' if notexist else '',
+					identifier(mapping.name),
+					mapping.executor.query,
+				),
+			))
+			return
+		def column_name(name):
+			if name in mapping.columns:
+				return identifier(mapping.columns[name].key)
+			if name in {spec.key for spec in mapping.columns.values()}:
+				return identifier(name)
+			raise ValueError('Constraint column is not mapped: {}'.format(name))
+		keys = [item for item in mapping.constraints if isinstance(item, PrimaryKey)]
+		if len(keys) > 1:
+			raise ValueError('Multiple primary key definitions are not allowed')
+		auto = keys[0] if keys and keys[0].autoincrement else None
+		if auto is not None and len(auto.cols) != 1:
+			raise ValueError('AUTOINCREMENT requires a single INTEGER primary key')
+		definitions = []
+		for spec in mapping.columns.values():
+			definition = '{} {}'.format(identifier(spec.key), spec.typestr)
+			if auto is not None and column_name(auto.cols[0]) == identifier(spec.key):
+				if spec.typestr != 'INTEGER':
+					raise ValueError('AUTOINCREMENT requires an INTEGER column')
+				definition += ' PRIMARY KEY AUTOINCREMENT'
+			if not spec.null:
+				definition += ' NOT NULL'
+			if spec.coldef is not MISSING:
+				value = spec.coldef
+				if isinstance(value, Function):
+					definition += ' DEFAULT ({})'.format(value)
+				else:
+					definition += ' DEFAULT {}'.format(Expr.literal(spec.encode(value)))
+			definitions.append(definition)
+		for constraint in mapping.constraints:
+			if isinstance(constraint, PrimaryKey):
+				if auto is None:
+					definitions.append('PRIMARY KEY({})'.format(
+						', '.join(column_name(name) for name in constraint.cols),
+					))
+			elif isinstance(constraint, ForeignKey):
+				if len(constraint.cols) != len(constraint.referenceCols):
+					raise ValueError('Foreign key column counts do not match')
+				definitions.append('FOREIGN KEY({}) REFERENCES {}({})'.format(
+					', '.join(column_name(name) for name in constraint.cols),
+					identifier(constraint.reference),
+					', '.join(identifier(name) for name in constraint.referenceCols),
+				))
+			elif not isinstance(constraint, Unique):
+				raise TypeError('Unsupported SQLite constraint')
+		self.executors.append(Statement(
+			'CREATE TABLE {}{}({})'.format(
+				'IF NOT EXISTS ' if notexist else '',
+				identifier(mapping.name),
+				', '.join(definitions),
+			),
+		))
+		for index in tuple(
+			value for value in mapping.constraints if isinstance(value, Unique)
+		) + mapping.indexes:
+			if not isinstance(index, (Index, Unique)):
+				raise TypeError('Unsupported SQLite index')
+			self.executors.append(Statement(
+				'CREATE {}INDEX {}{} ON {}({}){}'.format(
+					'UNIQUE ' if isinstance(index, Unique) else '',
+					'IF NOT EXISTS ' if index.notexists else '',
+					identifier(index.name),
+					identifier(mapping.name),
+					', '.join(
+						column_name(value) if isinstance(value, str) else str(value)
+						for value in index.colexprs
+					),
+					' WHERE {}'.format(index.expr) if index.expr else '',
+				),
+			))
+		return
+
+	def __iter__(self):
+		return iter(self.executors)

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

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+
+from DefPixel.DataAccessObject.Properties.Database import Executor
+from ..Mapping import (
+	identifier,
+	inspect_model,
+)
+
+__all__ = (
+	'Delete',
+)
+
+
+class Delete(Executor):
+	"""Delete query using an explicit table mapping."""
+
+	def __init__(self, o):
+		self.mapping = inspect_model(o, 'table')
+		self.conds = ()
+		return
+
+	def where(self, *args):
+		self.conds = args
+		return self
+
+	@property
+	def query(self):
+		return 'DELETE FROM {}{}'.format(
+			identifier(self.mapping.name),
+			' WHERE ' + ' AND '.join(str(cond) for cond in self.conds) if self.conds else '',
+		)
+
+	@property
+	def args(self):
+		return ()

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

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+
+from DefPixel.DataAccessObject.Properties.Database import Executors
+from ..Mapping import (
+	Statement,
+	identifier,
+	inspect_model,
+)
+
+__all__ = (
+	'Drop',
+)
+
+
+class Drop(Executors):
+	"""SQLite drops associated indexes when a table is dropped."""
+
+	def __init__(
+		self,
+		o,
+		exist=True,
+	):
+		mapping = inspect_model(o)
+		self.executors = [Statement(
+			'DROP {} {}{}'.format(
+				mapping.kind.upper(),
+				'IF EXISTS ' if exist else '',
+				identifier(mapping.name),
+			),
+		)]
+		return
+
+	def __iter__(self):
+		return iter(self.executors)

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

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+
+from .Select import Select
+
+__all__ = (
+	'Get',
+)
+
+
+class Get(Select):
+	"""Return the first result while preserving the existing Get interface."""
+
+	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/Sqlite/Executors/Insert.py

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+
+from DefPixel.DataAccessObject.Properties.Database import (
+	Executor,
+	Fetch,
+)
+from ..Mapping import (
+	identifier,
+	inspect_model,
+)
+
+__all__ = (
+	'Insert',
+)
+
+
+class Insert(Executor, Fetch):
+	"""Map field names to columns and bind validated values."""
+
+	def __init__(self, o):
+		self.mapping = inspect_model(o, 'table')
+		self.kwargs = {}
+		return
+
+	def values(self, **kwargs):
+		self.kwargs.update(self.mapping.values(kwargs))
+		return self
+
+	@property
+	def query(self):
+		if not self.kwargs:
+			return 'INSERT INTO {} DEFAULT VALUES RETURNING *'.format(
+				identifier(self.mapping.name),
+			)
+		return 'INSERT INTO {}({}) VALUES({}) RETURNING *'.format(
+			identifier(self.mapping.name),
+			', '.join(identifier(key) for key in self.kwargs),
+			', '.join(['?'] * len(self.kwargs)),
+		)
+
+	@property
+	def args(self):
+		return tuple(self.kwargs.values())
+
+	def fetch(
+		self,
+		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