def result_processor(self, dialect, coltype=None):
chemical_dialect = DialectManager.get_chemical_dialect(dialect)
def process(value):
if value is not None:
return chemical_dialect.process_result(value, self)
else:
return value
return process
def _get_function(element, compiler, params, within_column_clause):
"""For elements of type BaseFunction, the database specific function data
is looked up and a executable sqlalchemy.sql.expression.Function object
is returned.
"""
from razi.dialect import DialectManager
chemical_dialect = DialectManager.get_chemical_dialect(compiler.dialect)
function_data = chemical_dialect.get_function(element.__class__)
if isinstance(function_data, list):
"""if we have a list of function names, create cascaded Function objects
for all function names in the list::
['FUNC2', 'PKG1.FUNC1'] --> FUNC2(PKG1.FUNC1(..))
"""
function = None
for name in reversed(function_data):
packages = name.split('.')
if function is None:
"""for the innermost function use the passed-in parameters as argument,
otherwise use the prior created function
"""
args = params
else:
args = [function]
function = Function(packages.pop(-1),
packagenames=packages,
*args
)
return function
elif isinstance(function_data, types.FunctionType):
"""if we have a function, call this function with the parameters and
return the created Function object
"""
if hasattr(element, 'flags'):
# when element is a BaseFunction
flags = element.flags
else:
flags = {}
return function_data(params, within_column_clause, **flags)
else:
packages = function_data.split('.')
return Function(packages.pop(-1),
packagenames=packages,
*params
)
def __compile_base_function(element, compiler, **kw):
params = [parse_clause(argument, compiler)
for argument in element.arguments]
from razi.dialect import DialectManager
chemical_dialect = DialectManager.get_chemical_dialect(compiler.dialect)
if chemical_dialect.is_member_function(element.__class__):
chemical = params.pop(0)
function_name = chemical_dialect.get_function(element.__class__)
if isinstance(function_name, str):
"""If the function is defined as String (e.g.
"oracle_functions.dims : 'Get_Dims'"), we construct the function
call in the query ourselves. This is because SQLAlchemy,
at this point of the compile process, does not add parenthesis for
functions without arguments when using Oracle.
Otherwise let SQLAlchemy build the query. Note that this won't work
for Oracle with functions without parameters."""
return "%s.%s(%s)" % (
compiler.process(chemical),
function_name,
", ".join([compiler.process(e) for e in params])
)
else:
function = _get_function(element, compiler, params,
kw.get('within_columns_clause', False))
return "%s.%s" % (
compiler.process(chemical), compiler.process(function)
)
elif chemical_dialect.is_property(element.__class__):
chemical = params.pop(0)
function_name = chemical_dialect.get_function(element.__class__)
return "%s.%s" % (compiler.process(chemical), function_name)
else:
function = _get_function(element, compiler, params,
kw.get('within_columns_clause', False))
return compiler.process(function)
def __compile_dialect_specific_function(element, compiler, **kw):
from razi.dialect import DialectManager
chemical_dialect = DialectManager.get_chemical_dialect(compiler.dialect)
function = chemical_dialect.get_function(element.__class__)
args = list(element.arguments)
return compiler.process(function(compiler, element, *args))
def _compile_chemtype(type_, compiler, **kwargs):
chemical_dialect = DialectManager.get_chemical_dialect(compiler.dialect)
return chemical_dialect.db_column_type(type_)