def __init__(self, const, include_options=False):
self.const = const
self.name = const.name
(
self.source_schema, self.source_table,
self.source_columns, self.target_schema, self.target_table,
self.target_columns,
onupdate, ondelete,
deferrable, initially) = _fk_spec(const)
self.sig = (
self.source_schema, self.source_table, tuple(self.source_columns),
self.target_schema, self.target_table, tuple(self.target_columns)
)
if include_options:
self.sig += (
(None if onupdate.lower() == 'no action'
else onupdate.lower())
if onupdate else None,
(None if ondelete.lower() == 'no action'
else ondelete.lower())
if ondelete else None,
# convert initially + deferrable into one three-state value
"initially_deferrable"
if initially and initially.lower() == "deferred"
else "deferrable" if deferrable
else "not deferrable"
)
def __init__(self, const, include_options=False):
self.const = const
self.name = const.name
(
self.source_schema, self.source_table,
self.source_columns, self.target_schema, self.target_table,
self.target_columns,
onupdate, ondelete,
deferrable, initially) = _fk_spec(const)
self.sig = (
self.source_schema, self.source_table, tuple(self.source_columns),
self.target_schema, self.target_table, tuple(self.target_columns)
)
if include_options:
self.sig += (
(None if onupdate.lower() == 'no action'
else onupdate.lower())
if onupdate else None,
(None if ondelete.lower() == 'no action'
else ondelete.lower())
if ondelete else None,
# convert initially + deferrable into one three-state value
"initially_deferrable"
if initially and initially.lower() == "deferred"
else "deferrable" if deferrable
else "not deferrable"
)
def _assert_fk_diff(
self, diff, type_, source_table, source_columns,
target_table, target_columns, name=None, conditional_name=None,
source_schema=None):
# the public API for ForeignKeyConstraint was not very rich
# in 0.7, 0.8, so here we use the well-known but slightly
# private API to get at its elements
(fk_source_schema, fk_source_table,
fk_source_columns, fk_target_schema, fk_target_table,
fk_target_columns) = _fk_spec(diff[1])
eq_(diff[0], type_)
eq_(fk_source_table, source_table)
eq_(fk_source_columns, source_columns)
eq_(fk_target_table, target_table)
eq_(fk_source_schema, source_schema)
eq_([elem.column.name for elem in diff[1].elements],
target_columns)
if conditional_name is not None:
if config.requirements.no_fk_names.enabled:
eq_(diff[1].name, None)
elif conditional_name == 'servergenerated':
fks = Inspector.from_engine(self.bind).\
get_foreign_keys(source_table)
server_fk_name = fks[0]['name']
eq_(diff[1].name, server_fk_name)
else:
eq_(diff[1].name, conditional_name)
else:
eq_(diff[1].name, name)
def _assert_fk_diff(
self,
diff,
type_,
source_table,
source_columns,
target_table,
target_columns,
name=None,
conditional_name=None,
source_schema=None,
onupdate=None,
ondelete=None,
initially=None,
deferrable=None,
):
# the public API for ForeignKeyConstraint was not very rich
# in 0.7, 0.8, so here we use the well-known but slightly
# private API to get at its elements
(
fk_source_schema,
fk_source_table,
fk_source_columns,
fk_target_schema,
fk_target_table,
fk_target_columns,
fk_onupdate,
fk_ondelete,
fk_deferrable,
fk_initially,
) = _fk_spec(diff[1])
eq_(diff[0], type_)
eq_(fk_source_table, source_table)
eq_(fk_source_columns, source_columns)
eq_(fk_target_table, target_table)
eq_(fk_source_schema, source_schema)
eq_(fk_onupdate, onupdate)
eq_(fk_ondelete, ondelete)
eq_(fk_initially, initially)
eq_(fk_deferrable, deferrable)
eq_([elem.column.name for elem in diff[1].elements], target_columns)
if conditional_name is not None:
if config.requirements.no_fk_names.enabled:
eq_(diff[1].name, None)
elif conditional_name == "servergenerated":
fks = Inspector.from_engine(self.bind).get_foreign_keys(
source_table
)
server_fk_name = fks[0]["name"]
eq_(diff[1].name, server_fk_name)
else:
eq_(diff[1].name, conditional_name)
else:
eq_(diff[1].name, name)
def __init__(self, const):
self.const = const
self.name = const.name
self.source_schema, self.source_table, \
self.source_columns, self.target_schema, self.target_table, \
self.target_columns = _fk_spec(const)
self.sig = (self.source_schema, self.source_table,
tuple(self.source_columns), self.target_schema,
self.target_table, tuple(self.target_columns))
def __init__(self, const):
self.const = const
self.name = const.name
self.source_schema, self.source_table, \
self.source_columns, self.target_schema, self.target_table, \
self.target_columns = _fk_spec(const)
self.sig = (
self.source_schema, self.source_table, tuple(self.source_columns),
self.target_schema, self.target_table, tuple(self.target_columns)
)
def __init__(self,
const: "ForeignKeyConstraint",
include_options: bool = False) -> None:
self.const = const
self.name = const.name
(
self.source_schema,
self.source_table,
self.source_columns,
self.target_schema,
self.target_table,
self.target_columns,
onupdate,
ondelete,
deferrable,
initially,
) = _fk_spec(const)
self.sig: Tuple[Any, ...] = (
self.source_schema,
self.source_table,
tuple(self.source_columns),
self.target_schema,
self.target_table,
tuple(self.target_columns),
)
if include_options:
self.sig += (
(None if onupdate.lower() == "no action" else onupdate.lower())
if onupdate else None,
(None if ondelete.lower() == "no action" else ondelete.lower())
if ondelete else None,
# convert initially + deferrable into one three-state value
"initially_deferrable"
if initially and initially.lower() == "deferred" else
"deferrable" if deferrable else "not deferrable",
)
