DefPixel 0.1.0__3-py3-none-any.whl

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

@@ -0,0 +1,109 @@
+# -*- coding: utf-8 -*-
+
+from DefPixel.DataAccessObject.Properties.Database import (
+	Executor,
+	Fetch,
+)
+
+from ..Mapping import (
+	identifier,
+	inspect_model,
+)
+
+__all__ = (
+	'Select',
+)
+
+
+class Select(Executor, Fetch):
+	"""Select query for an explicitly mapped dataclass."""
+
+	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):
+		self.joins = args
+		return self
+
+	def where(self, *args):
+		self.conds = args
+		return self
+
+	def groupBy(self, *args):
+		self.grps = args
+		return self
+
+	def having(self, *args):
+		self.havs = args
+		return self
+
+	def orderBy(self, *args):
+		self.ords = args
+		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')
+		if size is None and offset:
+			raise ValueError('offset requires size')
+		self.size = size
+		self.offset = offset
+		return self
+
+	def values(self, *args):
+		self.vals = args
+		return self
+
+	@property
+	def query(self):
+		columns = self.vals or tuple(self.mapping.columns.values())
+		sql = 'SELECT {} FROM {}'.format(
+			', '.join(str(value) for value in columns),
+			identifier(self.mapping.name),
+		)
+		if self.joins:
+			sql += ' ' + ' '.join(str(value) for value in self.joins)
+		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(str(value) for value in values))
+		if self.size is not None:
+			sql += ' LIMIT {} OFFSET {}'.format(self.size, self.offset)
+		return sql
+
+	@property
+	def args(self):
+		return ()
+
+	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/Sqlite/Executors/Update.py

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+
+from .Insert import Insert
+from ..Mapping import identifier
+
+__all__ = (
+	'Update',
+)
+
+
+class Update(Insert):
+	"""Update query preserving set and where chaining."""
+
+	def __init__(self, o):
+		super().__init__(o)
+		self.conds = ()
+		return
+
+	def set(self, **kwargs):
+		return self.values(**kwargs)
+
+	def where(self, *args):
+		self.conds = args
+		return self
+
+	@property
+	def query(self):
+		if not self.kwargs:
+			raise ValueError('No columns are specified for update')
+		return 'UPDATE {} SET {}{} RETURNING *'.format(
+			identifier(self.mapping.name),
+			', '.join('{}=?'.format(identifier(key)) for key in self.kwargs),
+			' WHERE ' + ' AND '.join(str(cond) for cond in self.conds) if self.conds else '',
+		)

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

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

DefPixel/DataAccessObject/Implements/Sqlite/Expr.py

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+
+from abc import (
+	ABC,
+	ABCMeta,
+	abstractmethod,
+)
+from datetime import datetime
+from math import isfinite
+
+__all__ = (
+	'Expr'
+)
+
+
+class Expr(ABC, metaclass=ABCMeta):
+	"""Filter Interface"""
+
+	def encode(self, o):
+		return self.literal(o)
+
+	@staticmethod
+	def literal(value):
+		if value is None:
+			return 'NULL'
+		if isinstance(value, str):
+			return "'{}'".format(value.replace("'", "''"))
+		if isinstance(value, datetime):
+			return Expr.literal(value.isoformat())
+		if isinstance(value, bytes):
+			return "X'{}'".format(value.hex())
+		if isinstance(value, bool):
+			return '1' if value else '0'
+		if isinstance(value, (int, float)):
+			if isinstance(value, float) and not isfinite(value):
+				raise ValueError('SQL literals require finite numbers')
+			return str(value)
+		raise TypeError('Unsupported SQL literal type: {}'.format(type(value).__name__))
+
+	@abstractmethod
+	def __str__(self):
+		raise NotImplementedError('{} must be implemented __str__'.format(self.__class__.__name__))

DefPixel/DataAccessObject/Implements/Sqlite/Exprs/Alias.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+
+from ..Expr import Expr
+from ..Type import Type
+
+__all__ = (
+	'Alias'
+)
+
+
+class Alias(Expr):
+	def __init__(self, col: Type, name: str):
+		self.col = col
+		self.name = name
+		return
+	def __str__(self):
+		return '{} AS {}'.format(
+			str(self.col),
+			self.name,
+		)

DefPixel/DataAccessObject/Implements/Sqlite/Exprs/Is.py

@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+
+from ..Expr import Expr
+from ..Type import Type
+
+__all__ = (
+	'IsNull',
+	'IsNotNull',
+)
+
+
+class IsNull(Expr):
+	def __init__(self, col: Type):
+		self.col = col
+		return
+	def __str__(self):
+		return '{} IS NULL'.format(
+			str(self.col),
+		)
+
+
+class IsNotNull(Expr):
+	def __init__(self, col: Type):
+		self.col = col
+		return
+	def __str__(self):
+		return '{} IS NOT NULL'.format(
+			str(self.col),
+		)

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

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+
+from .Alias import Alias
+from .Is import (
+	IsNull,
+	IsNotNull,
+)
+
+__all__ = (
+	'Alias',
+	'IsNull',
+	'IsNotNull',
+)

DefPixel/DataAccessObject/Implements/Sqlite/Filters/Compare.py

@@ -0,0 +1,149 @@
+# -*- coding: utf-8 -*-
+
+from ..Expr import Expr
+
+from ..Type import Type
+from ..Function import Function
+
+from typing import Union, Any
+
+__all__ = (
+	'Equal',
+	'NotEqual',
+	'GreaterThan',
+	'GreaterThanOrEqual',
+	'LessThanOrEqual',
+	'LessThan',
+)
+
+
+class Equal(Expr):
+	"""SQL equality expression."""
+
+	def __init__(
+		self,
+		col: Union[str, Type, Function],
+		other: Union[Any, Type, Function],
+	) -> None:
+		self.col = col
+		self.other = other
+		if isinstance(self.other, Type):
+			self.other = str(self.other)
+		elif isinstance(self.other, Function):
+			self.other = str(self.other)
+		else:
+			self.other = self.encode(self.other)
+		return
+
+	def __str__(self):
+		return '{} = {}'.format(str(self.col), self.other)
+
+
+class NotEqual(Expr):
+	"""SQL inequality expression."""
+
+	def __init__(
+		self,
+		col: Union[str, Type, Function],
+		other: Union[Any, Type, Function],
+	) -> None:
+		self.col = col
+		self.other = other
+		if isinstance(self.other, Type):
+			self.other = str(self.other)
+		elif isinstance(self.other, Function):
+			self.other = str(self.other)
+		else:
+			self.other = self.encode(self.other)
+		return
+
+	def __str__(self):
+		return '{} != {}'.format(str(self.col), self.other)
+
+
+class GreaterThanOrEqual(Expr):
+	"""SQL greater-than-or-equal expression."""
+
+	def __init__(
+		self,
+		col: Union[str, Type, Function],
+		other: Union[Any, Type, Function],
+	) -> None:
+		self.col = col
+		self.other = other
+		if isinstance(self.other, Type):
+			self.other = str(self.other)
+		elif isinstance(self.other, Function):
+			self.other = str(self.other)
+		else:
+			self.other = self.encode(self.other)
+		return
+
+	def __str__(self):
+		return '{} >= {}'.format(str(self.col), self.other)
+
+
+class GreaterThan(Expr):
+	"""SQL greater-than expression."""
+
+	def __init__(
+		self,
+		col: Union[str, Type, Function],
+		other: Union[Any, Type, Function],
+	) -> None:
+		self.col = col
+		self.other = other
+		if isinstance(self.other, Type):
+			self.other = str(self.other)
+		elif isinstance(self.other, Function):
+			self.other = str(self.other)
+		else:
+			self.other = self.encode(self.other)
+		return
+
+	def __str__(self):
+		return '{} > {}'.format(str(self.col), self.other)
+
+
+class LessThanOrEqual(Expr):
+	"""SQL less-than-or-equal expression."""
+
+	def __init__(
+		self,
+		col: Union[str, Type, Function],
+		other: Union[Any, Type, Function],
+	) -> None:
+		self.col = col
+		self.other = other
+		if isinstance(self.other, Type):
+			self.other = str(self.other)
+		elif isinstance(self.other, Function):
+			self.other = str(self.other)
+		else:
+			self.other = self.encode(self.other)
+		return
+
+	def __str__(self):
+		return '{} <= {}'.format(str(self.col), self.other)
+	
+
+class LessThan(Expr):
+	"""SQL less-than expression."""
+
+	def __init__(
+		self,
+		col: Union[str, Type, Function],
+		other: Union[Any, Type, Function],
+	) -> None:
+		self.col = col
+		self.other = other
+		if isinstance(self.other, Type):
+			self.other = str(self.other)
+		elif isinstance(self.other, Function):
+			self.other = str(self.other)
+		else:
+			self.other = self.encode(self.other)
+		return
+
+	def __str__(self):
+		return '{} < {}'.format(str(self.col), self.other)

DefPixel/DataAccessObject/Implements/Sqlite/Filters/Operator.py

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+
+from ..Expr import Expr
+
+__all__ = (
+	'And',
+	'Or',
+)
+
+
+class And(Expr):
+	def __init__(self, *args) -> None:
+		self.args = args
+		return
+
+	def __str__(self):
+		return ' AND '.join([str(arg) for arg in self.args])
+
+
+class Or(Expr):
+	def __init__(self, *args) -> None:
+		self.args = args
+		return
+
+	def __str__(self):
+		return ' OR '.join([str(arg) for arg in self.args])

DefPixel/DataAccessObject/Implements/Sqlite/Filters/String.py

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+
+from ..Expr import Expr
+from ..Type import Type
+
+__all__ = (
+	'Like'
+)
+
+
+class Like(Expr):
+	"""SQL LIKE expression."""
+
+	def __init__(self, col: Type, other) -> None:
+		self.col = col
+		self.other = other
+		return
+
+	def __str__(self):
+		return '{} LIKE {}'.format(
+			str(self.col),
+			self.encode(self.other),
+		)

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

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+
+from .Operator import (
+	And,
+	Or,
+)
+from .Compare import (
+	Equal,
+	NotEqual,
+	GreaterThan,
+	GreaterThanOrEqual,
+	LessThan,
+	LessThanOrEqual,
+)
+from .String import (
+	Like,
+)
+
+
+__all__ = (
+	'And',
+	'Or',
+	'Equal',
+	'NotEqual',
+	'Like',
+	'GreaterThan',
+	'GreaterThanOrEqual',
+	'LessThan',
+	'LessThanOrEqual',
+)

DefPixel/DataAccessObject/Implements/Sqlite/Function.py

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

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

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+
+from ..Function import Function
+from ..Type import Type
+
+__all__ = (
+	'Count',
+	'Sum',
+	'Average',
+)
+
+
+class Count(Function):
+	def __init__(self, col: Type):
+		self.col = col
+		return
+	def __str__(self):
+		return 'COUNT({})'.format(str(self.col))
+	
+
+class Sum(Function):
+	def __init__(self, col: Type):
+		self.col = col
+		return
+	def __str__(self):
+		return 'SUM({})'.format(str(self.col))
+
+
+class Average(Function):
+	def __init__(self, col: Type):
+		self.col = col
+		return
+	def __str__(self):
+		return 'AVG({})'.format(str(self.col))

DefPixel/DataAccessObject/Implements/Sqlite/Functions/Condition.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+
+from ..Function import Function
+from ..Type import Type
+from ..Expr import Expr
+
+__all__ = (
+	'IfNull'
+)
+
+
+class IfNull(Function):
+	def __init__(self, attr: Type, value: any):
+		self.attr = attr
+		self.value = value
+		return
+	def __str__(self):
+		return 'IFNULL({}, {})'.format(
+			str(self.attr),
+			self.value if isinstance(self.value, (Type, Function)) else Expr.literal(self.value),
+		)

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

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+
+from .Common import (
+	Sum,
+	Count,
+	Average,
+)
+
+from .Condition import IfNull
+
+__all__ = (
+	'Sum',
+	'Count',
+	'Average',
+	'IfNull',
+)

DefPixel/DataAccessObject/Implements/Sqlite/Index.py

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

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

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+
+from .Join import Join
+
+from DefPixel.DataAccessObject.Properties import Dataclass
+
+from typing import Type
+
+__all__ = (
+	'FullOuter'
+)
+
+
+class FullOuter(Join):
+	"""Full Outer Join Class"""
+
+	def __init__(self, table: Type[Dataclass], *args) -> None:
+		super(FullOuter, self).__init__('FULL OUTER', table, *args)
+		return

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

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+
+from .Join import Join
+
+from DefPixel.DataAccessObject.Properties import Dataclass
+
+from typing import Type
+
+__all__ = (
+	'Inner'
+)
+
+
+class Inner(Join):
+	"""Inner Join Class"""
+
+	def __init__(self, table: Type[Dataclass], *args) -> None:
+		super(Inner, self).__init__('INNER', table, *args)
+		return

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

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+
+from ..Expr import Expr
+
+from ..Mapping import (
+	identifier,
+	inspect_model,
+)
+
+from typing import Type
+
+__all__ = (
+	'Join'
+)
+
+
+class Join(Expr):
+	"""Join Class"""
+
+	def __init__(self, expr: str, table: Type, *args) -> None:
+		self.expr = expr
+		self.table = inspect_model(table)
+		self.args = args
+		return
+
+	def __str__(self):
+		return '{} JOIN {} ON {}'.format(
+			self.expr,
+			identifier(self.table.name),
+			' AND '.join([str(arg) for arg in self.args]),
+		)