1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
|
import itertools
from ..operations import ops
def _to_migration_script(autogen_context, migration_script, diffs):
_to_upgrade_op(
autogen_context,
diffs,
migration_script.upgrade_ops,
)
_to_downgrade_op(
autogen_context,
diffs,
migration_script.downgrade_ops,
)
def _to_upgrade_op(autogen_context, diffs, upgrade_ops):
return _to_updown_op(autogen_context, diffs, upgrade_ops, "upgrade")
def _to_downgrade_op(autogen_context, diffs, downgrade_ops):
return _to_updown_op(autogen_context, diffs, downgrade_ops, "downgrade")
def _to_updown_op(autogen_context, diffs, op_container, type_):
if not diffs:
return
if type_ == 'downgrade':
diffs = reversed(diffs)
dest = [op_container.ops]
for (schema, tablename), subdiffs in _group_diffs_by_table(diffs):
subdiffs = list(subdiffs)
if tablename is not None:
table_ops = []
op = ops.ModifyTableOps(tablename, table_ops, schema=schema)
dest[-1].append(op)
dest.append(table_ops)
for diff in subdiffs:
_produce_command(autogen_context, diff, dest[-1], type_)
if tablename is not None:
dest.pop(-1)
def _produce_command(autogen_context, diff, op_list, updown):
if isinstance(diff, tuple):
_produce_adddrop_command(updown, diff, op_list, autogen_context)
else:
_produce_modify_command(updown, diff, op_list, autogen_context)
def _produce_adddrop_command(updown, diff, op_list, autogen_context):
cmd_type = diff[0]
adddrop, cmd_type = cmd_type.split("_")
cmd_args = diff[1:]
_commands = {
"table": (ops.DropTableOp.from_table, ops.CreateTableOp.from_table),
"column": (
ops.DropColumnOp.from_column_and_tablename,
ops.AddColumnOp.from_column_and_tablename),
"index": (ops.DropIndexOp.from_index, ops.CreateIndexOp.from_index),
"constraint": (
ops.DropConstraintOp.from_constraint,
ops.AddConstraintOp.from_constraint),
"fk": (
ops.DropConstraintOp.from_constraint,
ops.CreateForeignKeyOp.from_constraint)
}
cmd_callables = _commands[cmd_type]
if (
updown == "upgrade" and adddrop == "add"
) or (
updown == "downgrade" and adddrop == "remove"
):
op_list.append(cmd_callables[1](*cmd_args))
else:
op_list.append(cmd_callables[0](*cmd_args))
def _produce_modify_command(updown, diffs, op_list, autogen_context):
sname, tname, cname = diffs[0][1:4]
kw = {}
_arg_struct = {
"modify_type": ("existing_type", "modify_type"),
"modify_nullable": ("existing_nullable", "modify_nullable"),
"modify_default": ("existing_server_default", "modify_server_default"),
}
for diff in diffs:
diff_kw = diff[4]
for arg in ("existing_type",
"existing_nullable",
"existing_server_default"):
if arg in diff_kw:
kw.setdefault(arg, diff_kw[arg])
old_kw, new_kw = _arg_struct[diff[0]]
if updown == "upgrade":
kw[new_kw] = diff[-1]
kw[old_kw] = diff[-2]
else:
kw[new_kw] = diff[-2]
kw[old_kw] = diff[-1]
if "modify_nullable" in kw:
kw.pop("existing_nullable", None)
if "modify_server_default" in kw:
kw.pop("existing_server_default", None)
op_list.append(
ops.AlterColumnOp(
tname, cname, schema=sname,
**kw
)
)
def _group_diffs_by_table(diffs):
_adddrop = {
"table": lambda diff: (None, None),
"column": lambda diff: (diff[0], diff[1]),
"index": lambda diff: (diff[0].table.schema, diff[0].table.name),
"constraint": lambda diff: (diff[0].table.schema, diff[0].table.name),
"fk": lambda diff: (diff[0].parent.schema, diff[0].parent.name)
}
def _derive_table(diff):
if isinstance(diff, tuple):
cmd_type = diff[0]
adddrop, cmd_type = cmd_type.split("_")
return _adddrop[cmd_type](diff[1:])
else:
sname, tname = diff[0][1:3]
return sname, tname
return itertools.groupby(diffs, _derive_table)
|
