import sqlalchemy as sa
from re import sub
from sqlalchemy.ext.compiler import compiles
from sqlalchemy.sql import expression
from sqlalchemy.util.langhelpers import public_factory
class Replace(expression.Insert):
pass
sa.replace = public_factory(Replace, ".expression.replace")
@compiles(Replace, 'sqlite')
def compile_replace(replace, compiler, **kw):
stmt = compiler.sql_compiler.visit_insert(replace)
return sub(r'^INSERT', 'INSERT OR REPLACE', stmt)
return self.prop.supports_yaml
@property
def supports_dict(self):
return self.prop.supports_dict
@property
def on_serialize(self):
return self.prop.on_serialize
@property
def on_deserialize(self):
return self.prop.on_deserialize
relationship = public_factory(RelationshipProperty, ".orm.relationship")
class Table(SA_Table):
"""Represents a table in a database. Inherits from
:class:`sqlalchemy.schema.Table <sqlalchemy:sqlalchemy.schema.Table>`
"""
# pylint: disable=too-many-ancestors, W0223
def __init__(self, *args, **kwargs):
"""Construct a new ``Table`` object.
.. warning::
This method is analogous to the original SQLAlchemy
def _clone(self):
return MatchClause(self.values[:], self.fields.copy())
class Select(sqlalchemy.sql.expression.Select):
_options = None
@_generative
def match(self, *args, **kwargs):
clause_already_exists = [False]
def replace(node):
if isinstance(node, MatchClause):
clause_already_exists[0] = True
node.extend(args, kwargs)
return node
self._whereclause = replacement_traverse(self._whereclause, {}, replace)
if not clause_already_exists[0]:
self.append_whereclause(MatchClause(args, kwargs))
@_generative
def options(self, **kwargs):
if self._options is None:
self._options = OptionsClause(kwargs)
else:
self._options.extend(kwargs)
select = public_factory(Select, '.expression.extract')