def use_simple_names():
get_col_name = lambda el, *args, **kwargs: str(el.element.name)
try:
yield compiles(sql.compiler._CompileLabel)(get_col_name)
except:
pass
finally:
deregister(sql.compiler._CompileLabel)
def bulk_save_objects_with_replace(self, objects):
'''
Like Session.bulk_save_objects, but replaces any whose primary key is
already present. Only works on SQLite.
'''
# https://stackoverflow.com/questions/2218304/sqlalchemy-insert-ignore
# This is a bit hacky, because the deregister call will remove *all*
# visitors, not the one we just registered. But I don't see a better
# way right now.
def _prefix_insert_with_replace(insert, compiler, **kw):
return compiler.visit_insert(insert.prefix_with('OR REPLACE'),
**kw)
compiles(Insert)(_prefix_insert_with_replace)
try:
self.bulk_save_objects(objects)
finally:
deregister(Insert)
def compiles_many(func=None, to=None, types=()):
if not func:
return partial(compiles_many, to=to, types=types)
return reduce(lambda f, t: compiles(t, to)(f), types, func)
def _compiles_sqlite(cls, fn):
def _compile_sqlite(element, compiler, **kw):
return "{}({})".format(fn, compiler.process(element.clauses, **kw))
compiles(globals()[cls], "sqlite")(_compile_sqlite)
def _compiles_default(cls):
def _compile_default(element, compiler, **kw):
return "{}({})".format(cls, compiler.process(element.clauses, **kw))
compiles(globals()[cls])(_compile_default)
def __init__(self, expr):
self.expr = expression._literal_as_binds(expr)
@compiles(array, 'postgresql')
return False
class array_agg(expression.ColumnElement):
type = StaticArray()
def __init__(self, expr, order_by=None):
self.expr = expression._literal_as_binds(expr)
if order_by is not None:
self.order_by = expression._literal_as_binds(order_by)
else:
self.order_by = None
@compiles(array_agg, 'postgresql')
def _compile_array_agg_postgresql(element, compiler, **kw):
buf = StringIO()
buf.write('array(select x from unnest(array_agg(')
buf.write(compiler.process(element.expr))
if element.order_by is not None:
buf.write(' ORDER BY ')
buf.write(compiler.process(element.order_by))
buf.write(')) x WHERE x IS NOT NULL)')
return buf.getvalue()
class array(expression.ColumnElement):
type = StaticArray()
def __init__(self, expr):
"TimeStamp": types.DATETIME,
}
# The below is copy/pasted from https://github.com/sqlalchemy-redshift/sqlalchemy-redshift
# (file sqlalchemy_redshift/dialect.py) to enable use of alembic
# with a 3rd-party SQLAlchemy Dialect
try:
import alembic
except ImportError:
pass
else:
from packaging.version import Version
from alembic.ddl import postgresql
from alembic.ddl.base import RenameTable
compiles(RenameTable, "fauna")(postgresql.visit_rename_table)
if Version(alembic.__version__) >= Version("1.0.6"):
from alembic.ddl.base import ColumnComment
compiles(ColumnComment, "fauna")(postgresql.visit_column_comment)
class FaunaImpl(postgresql.PostgresqlImpl):
"""Fauna implementation for use by Alembic."""
__dialect__ = "fauna"
class FaunaExecutionContext(default.DefaultExecutionContext): # pylint: disable=abstract-method
"""Context for the execution of a query or multiple queries."""
@property
mod_dict = globals()
class pi(GenericFunction):
type = Float
def _compile_trigd_default(trig):
def compilefunc(element, compiler, **kw):
arg, = element.clauses
return compiler.process(trig(arg * pi()), **kw)
return compilefunc
def _compile_trigd_postgresql(element, compiler, **kw):
return compiler.visit_function(element)
for name in ['cos', 'sin', 'tan']:
mod_dict[name] = type(name, (ReturnTypeFromArgs, ), {})
__all__.append(name)
named = f'{name}d'
mod_dict[named] = type(named, (ReturnTypeFromArgs, ), {})
compiles(mod_dict[named])(_compile_trigd_default(mod_dict[name]))
compiles(mod_dict[named], 'postgresql')(_compile_trigd_postgresql)
del mod_dict, GenericFunction, ReturnTypeFromArgs, \
_compile_trigd_default, _compile_trigd_postgresql
__all__ = tuple(__all__)
def compiles_many(func=None, to=None, types=()):
if not func:
return partial(compiles_many, to=to, types=types)
return reduce(lambda f, t: compiles(t, to)(f), types, func)
def _make_proxy(self, selectable, name=None):
return self.column._make_proxy(selectable, name)
@compiles(RawColumn)
class CompoundSparqlStatement(SparqlMappingStatement):
def __init__(self, clauses):
super(CompoundSparqlStatement, self).__init__(clauses[0])
self.clauses = clauses
self.supports_execution = all((c.supports_execution for c in clauses))
if self.supports_execution:
self._execution_options = clauses[0]._execution_options
def _compile(self, compiler, **kwargs):
return "\n".join(
(compiler.process(clause, **kwargs) for clause in self.clauses))
compiles(CompoundSparqlStatement)(CompoundSparqlStatement._compile)
class WrapSparqlStatement(SparqlStatement):
def __init__(self, statement):
super(WrapSparqlStatement, self).__init__(statement.nsm)
self.statement = statement
self.supports_execution = statement.supports_execution
if self.supports_execution:
self._execution_options = statement._execution_options
def _compile(self, compiler, **kwargs):
known_prefixes = set()
if isinstance(self.nsm, VirtuosoNamespaceManager):
known_prefixes = set(self.nsm.v_prefixes.values())
prefixes = [
def _compiles(cls, fn):
def _compile(element, compiler, **kw):
return "{}({})".format(fn, compiler.process(element.clauses, **kw))
compiles(globals()[cls], "sqlite")(_compile)
from sqlalchemy.ext.compiler import compiles
try:
from alembic.ddl import postgresql
except ImportError:
pass
else:
from alembic.ddl.base import AlterColumn, RenameTable
compiles(AlterColumn, 'greenplum')(postgresql.visit_column_type)
compiles(RenameTable, 'greenplum')(postgresql.visit_rename_table)
class GreenplumImpl(postgresql.PostgresqlImpl):
__dialect__ = 'greenplum'
transactional_ddl = True
from sqlalchemy.ext.compiler import compiles
from sqlalchemy.sql.expression import (
BinaryExpression, BooleanClauseList, Delete
)
from sqlalchemy.types import VARCHAR, NullType
from .commands import CopyCommand, UnloadFromSelect
from .compat import string_types
try:
from alembic.ddl import postgresql
except ImportError:
pass
else:
from alembic.ddl.base import RenameTable
compiles(RenameTable, 'redshift')(postgresql.visit_rename_table)
class RedshiftImpl(postgresql.PostgresqlImpl):
__dialect__ = 'redshift'
__all__ = ['CopyCommand', 'UnloadFromSelect', 'RedshiftDialect']
# Regex for parsing and identity constraint out of adsrc, e.g.:
# "identity"(445178, 0, '1,1'::text)
IDENTITY_RE = re.compile(r"""
"identity" \(
(?P<current>-?\d+)
,\s
(?P<base>-?\d+)
,\s
Encoding, CreateLibraryCommand, AlterTableAppendCommand,
RefreshMaterializedView)
from .ddl import (CreateMaterializedView, DropMaterializedView,
get_table_attributes)
sa_version = Version(sa.__version__)
try:
import alembic
except ImportError:
pass
else:
from alembic.ddl import postgresql
from alembic.ddl.base import RenameTable
compiles(RenameTable, 'redshift')(postgresql.visit_rename_table)
if Version(alembic.__version__) >= Version('1.0.6'):
from alembic.ddl.base import ColumnComment
compiles(ColumnComment, 'redshift')(postgresql.visit_column_comment)
class RedshiftImpl(postgresql.PostgresqlImpl):
__dialect__ = 'redshift'
# "Each dialect provides the full set of typenames supported by that backend
# with its __all__ collection
# https://docs.sqlalchemy.org/en/13/core/type_basics.html#vendor-specific-types
__all__ = ('SMALLINT', 'INTEGER', 'BIGINT', 'DECIMAL', 'REAL', 'BOOLEAN',
'CHAR', 'DATE', 'TIMESTAMP', 'VARCHAR', 'DOUBLE_PRECISION',
'TIMESTAMPTZ', 'CopyCommand', 'UnloadFromSelect', 'RedshiftDialect',
from sqlalchemy.engine import reflection
from sqlalchemy.ext.compiler import compiles
from sqlalchemy.sql.expression import (BinaryExpression, BooleanClauseList,
Delete)
from sqlalchemy.types import VARCHAR, NullType
from .commands import CopyCommand, UnloadFromSelect
from .compat import string_types
try:
from alembic.ddl import postgresql
except ImportError:
pass
else:
from alembic.ddl.base import RenameTable
compiles(RenameTable, 'redshift')(postgresql.visit_rename_table)
class RedshiftImpl(postgresql.PostgresqlImpl):
__dialect__ = 'redshift'
__all__ = ['CopyCommand', 'UnloadFromSelect', 'RedshiftDialect']
# Regex for parsing and identity constraint out of adsrc, e.g.:
# "identity"(445178, 0, '1,1'::text)
IDENTITY_RE = re.compile(
r"""
"identity" \(
(?P<current>-?\d+)
,\s
(?P<base>-?\d+)
class RdfLiteralStmt(ClauseElement):
def __init__(self, literal, nsm=None):
self.nsm = nsm
self.literal = literal
def __bool__(self):
# Avoid many tedious "is not None"
return True
def _compile(self, compiler, **kwargs):
nsm = kwargs.get('nsm', self.nsm)
return self.literal.n3(nsm)
compiles(RdfLiteralStmt)(RdfLiteralStmt._compile)
class Mapping(object):
def __init__(self, name, nsm=None):
self.name = name
self.nsm = nsm
def patterns_iter(self):
return ()
@staticmethod
def resolve_argument(arg, classes):
if isinstance(
arg,
(InstrumentedAttribute, ClauseElement, GroundedClassAlias)):
