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')