def ddl_compare(self, **kwargs):
"""
This function returns the DDL/DML statements based on the
comparison status.
:param kwargs:
:return:
"""
src_params = kwargs.get('source_params')
tgt_params = kwargs.get('target_params')
source = kwargs.get('source')
target = kwargs.get('target')
comp_status = kwargs.get('comp_status')
diff = ''
if comp_status == 'source_only':
diff = self.get_sql_from_index_diff(sid=src_params['sid'],
did=src_params['did'],
scid=src_params['scid'],
tid=src_params['tid'],
idx=source['oid'],
create_mode=True)
elif comp_status == 'target_only':
diff = self.delete(gid=1,
sid=tgt_params['sid'],
did=tgt_params['did'],
scid=tgt_params['scid'],
tid=tgt_params['tid'],
idx=target['oid'],
only_sql=True)
elif comp_status == 'different':
diff_dict = directory_diff(source,
target,
ignore_keys=self.keys_to_ignore,
difference={})
required_create_keys = ['columns']
create_req = IndexesView._check_for_create_req(
required_create_keys, diff_dict)
if create_req:
diff = self.get_sql_from_index_diff(sid=src_params['sid'],
did=src_params['did'],
scid=src_params['scid'],
tid=src_params['tid'],
idx=source['oid'],
create_mode=True,
drop_req=True)
else:
diff = self.get_sql_from_index_diff(sid=tgt_params['sid'],
did=tgt_params['did'],
scid=tgt_params['scid'],
tid=tgt_params['tid'],
idx=target['oid'],
data=diff_dict)
return diff
def ddl_compare(self, **kwargs):
"""
This function returns the DDL/DML statements based on the
comparison status.
:param kwargs:
:return:
"""
src_params = kwargs.get('source_params')
tgt_params = kwargs.get('target_params')
source = kwargs.get('source')
target = kwargs.get('target')
comp_status = kwargs.get('comp_status')
diff = ''
if comp_status == 'source_only':
diff = self.get_sql_from_diff(gid=src_params['gid'],
sid=src_params['sid'],
did=src_params['did'],
scid=src_params['scid'],
tid=src_params['tid'],
plid=source['oid'])
elif comp_status == 'target_only':
diff = self.delete(gid=1,
sid=tgt_params['sid'],
did=tgt_params['did'],
scid=tgt_params['scid'],
tid=tgt_params['tid'],
plid=target['oid'],
only_sql=True)
elif comp_status == 'different':
diff_dict = directory_diff(
source, target, difference={}
)
if 'event' in diff_dict or 'type' in diff_dict:
delete_sql = self.get_sql_from_diff(gid=1,
sid=tgt_params['sid'],
did=tgt_params['did'],
scid=tgt_params['scid'],
tid=tgt_params['tid'],
plid=target['oid'],
drop_req=True)
diff = self.get_sql_from_diff(gid=src_params['gid'],
sid=src_params['sid'],
did=src_params['did'],
scid=src_params['scid'],
tid=src_params['tid'],
plid=source['oid'])
return delete_sql + diff
diff = self.get_sql_from_diff(gid=tgt_params['gid'],
sid=tgt_params['sid'],
did=tgt_params['did'],
scid=tgt_params['scid'],
tid=tgt_params['tid'],
plid=target['oid'],
data=diff_dict)
return '\n' + diff
def ddl_compare(self, **kwargs):
"""
This function returns the DDL/DML statements based on the
comparison status.
:param kwargs:
:return:
"""
src_params = kwargs.get('source_params')
tgt_params = kwargs.get('target_params')
source = kwargs.get('source')
target = kwargs.get('target')
target_schema = kwargs.get('target_schema')
comp_status = kwargs.get('comp_status')
diff = ''
if comp_status == 'source_only':
diff = self.get_sql_from_diff(gid=src_params['gid'],
sid=src_params['sid'],
did=src_params['did'],
scid=src_params['scid'],
tid=src_params['tid'],
oid=source['oid'],
diff_schema=target_schema)
elif comp_status == 'target_only':
diff = self.get_sql_from_diff(gid=tgt_params['gid'],
sid=tgt_params['sid'],
did=tgt_params['did'],
scid=tgt_params['scid'],
tid=tgt_params['tid'],
oid=target['oid'],
drop_sql=True)
elif comp_status == 'different':
diff_dict = directory_diff(source,
target,
ignore_keys=self.keys_to_ignore,
difference={})
parse_acl(source, target, diff_dict)
diff = self.get_sql_from_diff(gid=tgt_params['gid'],
sid=tgt_params['sid'],
did=tgt_params['did'],
scid=tgt_params['scid'],
tid=tgt_params['tid'],
oid=target['oid'],
source_schema=source['schema'],
diff_schema=target_schema,
data=diff_dict)
return diff
def ddl_compare(self, **kwargs):
"""
This function returns the DDL/DML statements based on the
comparison status.
:param kwargs:
:return:
"""
src_params = kwargs.get('source_params')
tgt_params = kwargs.get('target_params')
source = kwargs.get('source')
target = kwargs.get('target')
target_schema = kwargs.get('target_schema')
comp_status = kwargs.get('comp_status')
diff = ''
if comp_status == 'source_only':
diff = self.get_sql_from_index_diff(sid=src_params['sid'],
did=src_params['did'],
scid=src_params['scid'],
tid=src_params['tid'],
idx=source['oid'],
diff_schema=target_schema)
elif comp_status == 'target_only':
diff = self.delete(gid=1,
sid=tgt_params['sid'],
did=tgt_params['did'],
scid=tgt_params['scid'],
tid=tgt_params['tid'],
idx=target['oid'],
only_sql=True)
elif comp_status == 'different':
diff_dict = directory_diff(source,
target,
ignore_keys=self.keys_to_ignore,
difference={})
required_create_keys = ['columns']
create_req = False
for key in required_create_keys:
if key in diff_dict:
if key == 'columns' and (
('added' in diff_dict[key]
and len(diff_dict[key]['added']) > 0) or
('changed' in diff_dict[key]
and len(diff_dict[key]['changed']) > 0) or
('deleted' in diff_dict[key]
and len(diff_dict[key]['deleted']) > 0)):
create_req = True
elif key != 'columns':
create_req = True
if create_req:
diff = self.get_sql_from_index_diff(sid=tgt_params['sid'],
did=tgt_params['did'],
scid=tgt_params['scid'],
tid=tgt_params['tid'],
idx=target['oid'],
diff_schema=target_schema,
drop_req=True)
else:
diff = self.get_sql_from_index_diff(sid=tgt_params['sid'],
did=tgt_params['did'],
scid=tgt_params['scid'],
tid=tgt_params['tid'],
idx=target['oid'],
data=diff_dict)
return diff
def ddl_compare(self, **kwargs):
"""
This function will compare object properties and
return the difference of SQL
"""
source = ''
target = ''
diff = ''
comp_status = kwargs.get('comp_status')
only_diff = False
generate_script = False
source_params = {
'gid': 1,
'sid': kwargs.get('source_sid'),
'did': kwargs.get('source_did'),
'scid': kwargs.get('source_scid'),
'oid': kwargs.get('source_oid')
}
target_params = {
'gid': 1,
'sid': kwargs.get('target_sid'),
'did': kwargs.get('target_did'),
'scid': kwargs.get('target_scid'),
'oid': kwargs.get('target_oid')
}
if 'source_tid' in kwargs:
source_params['tid'] = kwargs['source_tid']
only_diff = True
if 'target_tid' in kwargs:
target_params['tid'] = kwargs['target_tid']
only_diff = True
if 'generate_script' in kwargs and kwargs['generate_script']:
generate_script = True
source_params_adv = copy.deepcopy(source_params)
target_params_adv = copy.deepcopy(target_params)
del source_params_adv['gid']
del target_params_adv['gid']
status, target_schema = self.get_schema(kwargs.get('target_sid'),
kwargs.get('target_did'),
kwargs.get('target_scid'))
if not status:
return internal_server_error(errormsg=target_schema)
if comp_status == SchemaDiffModel.COMPARISON_STATUS['source_only']:
if not generate_script:
source = self.get_sql_from_diff(**source_params)
source_params.update({'diff_schema': target_schema})
diff = self.get_sql_from_diff(**source_params)
elif comp_status == SchemaDiffModel.COMPARISON_STATUS['target_only']:
if not generate_script:
target = self.get_sql_from_diff(**target_params)
target_params.update({'drop_sql': True})
diff = self.get_sql_from_diff(**target_params)
elif comp_status == SchemaDiffModel.COMPARISON_STATUS['different']:
source = self.fetch_objects_to_compare(**source_params_adv)
target = self.fetch_objects_to_compare(**target_params_adv)
if not (source or target):
return None
diff_dict = directory_diff(source,
target,
ignore_keys=self.keys_to_ignore,
difference={})
diff_dict.update(self.parce_acl(source, target))
if not generate_script:
source = self.get_sql_from_diff(**source_params)
target = self.get_sql_from_diff(**target_params)
target_params.update({'data': diff_dict})
diff = self.get_sql_from_diff(**target_params)
else:
source = self.get_sql_from_diff(**source_params)
target = self.get_sql_from_diff(**target_params)
if only_diff:
return diff
return {'source_ddl': source, 'target_ddl': target, 'diff_ddl': diff}
def ddl_compare(self, **kwargs):
"""
This function will compare index properties and
return the difference of SQL
"""
src_sid = kwargs.get('source_sid')
src_did = kwargs.get('source_did')
src_scid = kwargs.get('source_scid')
src_tid = kwargs.get('source_tid')
src_oid = kwargs.get('source_oid')
tar_sid = kwargs.get('target_sid')
tar_did = kwargs.get('target_did')
tar_scid = kwargs.get('target_scid')
tar_tid = kwargs.get('target_tid')
tar_oid = kwargs.get('target_oid')
comp_status = kwargs.get('comp_status')
source = ''
target = ''
diff = ''
status, target_schema = self.get_schema(tar_sid, tar_did, tar_scid)
if not status:
return internal_server_error(errormsg=target_schema)
if comp_status == SchemaDiffModel.COMPARISON_STATUS['source_only']:
diff = self.get_sql_from_index_diff(sid=src_sid,
did=src_did,
scid=src_scid,
tid=src_tid,
idx=src_oid,
diff_schema=target_schema)
elif comp_status == SchemaDiffModel.COMPARISON_STATUS['target_only']:
diff = self.delete(gid=1,
sid=tar_sid,
did=tar_did,
scid=tar_scid,
tid=tar_tid,
idx=tar_oid,
only_sql=True)
else:
source = self.fetch_objects_to_compare(sid=src_sid,
did=src_did,
scid=src_scid,
tid=src_tid,
oid=src_oid)
target = self.fetch_objects_to_compare(sid=tar_sid,
did=tar_did,
scid=tar_scid,
tid=tar_tid,
oid=tar_oid)
if not (source or target):
return None
diff_dict = directory_diff(source,
target,
ignore_keys=self.keys_to_ignore,
difference={})
required_create_keys = ['columns']
create_req = False
for key in required_create_keys:
if key in diff_dict:
if key == 'columns' and (
('added' in diff_dict[key]
and len(diff_dict[key]['added']) > 0) or
('changed' in diff_dict[key]
and len(diff_dict[key]['changed']) > 0) or
('deleted' in diff_dict[key]
and len(diff_dict[key]['deleted']) > 0)):
create_req = True
elif key != 'columns':
create_req = True
if create_req:
diff = self.get_sql_from_index_diff(sid=tar_sid,
did=tar_did,
scid=tar_scid,
tid=tar_tid,
idx=tar_oid,
diff_schema=target_schema,
drop_req=True)
else:
diff = self.get_sql_from_index_diff(sid=tar_sid,
did=tar_did,
scid=tar_scid,
tid=tar_tid,
idx=tar_oid,
data=diff_dict)
return diff
def ddl_compare(self, **kwargs):
"""
This function will compare properties of 2 tables and
return the source DDL, target DDL and Difference of them.
"""
src_sid = kwargs.get('source_sid')
src_did = kwargs.get('source_did')
src_scid = kwargs.get('source_scid')
src_oid = kwargs.get('source_oid')
tar_sid = kwargs.get('target_sid')
tar_did = kwargs.get('target_did')
tar_scid = kwargs.get('target_scid')
tar_oid = kwargs.get('target_oid')
comp_status = kwargs.get('comp_status')
generate_script = False
if 'generate_script' in kwargs and kwargs['generate_script']:
generate_script = True
source = ''
target = ''
diff = ''
ignore_sub_modules = ['column', 'constraints']
src_server_type, tar_server_type = self.get_server_type(
src_sid, tar_sid)
status, target_schema = self.get_schema(tar_sid, tar_did, tar_scid)
if not status:
return internal_server_error(errormsg=target_schema)
if comp_status == SchemaDiffModel.COMPARISON_STATUS['source_only']:
if not generate_script:
source = self.get_sql_from_table_diff(sid=src_sid,
did=src_did,
scid=src_scid,
tid=src_oid,
json_resp=False)
diff = self.get_sql_from_table_diff(sid=src_sid,
did=src_did,
scid=src_scid,
tid=src_oid,
diff_schema=target_schema,
json_resp=False)
elif comp_status == SchemaDiffModel.COMPARISON_STATUS['target_only']:
if not generate_script:
target = self.get_sql_from_table_diff(sid=tar_sid,
did=tar_did,
scid=tar_scid,
tid=tar_oid,
json_resp=False)
diff = self.get_drop_sql(sid=tar_sid,
did=tar_did,
scid=tar_scid,
tid=tar_oid)
elif comp_status == SchemaDiffModel.COMPARISON_STATUS['different']:
source = self.fetch_tables(
sid=src_sid,
did=src_did,
scid=src_scid,
tid=src_oid,
keys_to_remove=self.keys_to_remove_ddl_comp)
target = self.fetch_tables(
sid=tar_sid,
did=tar_did,
scid=tar_scid,
tid=tar_oid,
keys_to_remove=self.keys_to_remove_ddl_comp)
if self.manager.version < 100000:
ignore_sub_modules.append('partition')
if self.manager.version < 120000:
ignore_sub_modules.append('compound_trigger')
# In case of error return None
if not (source or target):
return None
diff_dict = directory_diff(
source,
target,
ignore_keys=self.keys_to_ignore_ddl_comp,
difference={})
# Column comparison
col_diff = self.table_col_ddl_comp(source, target)
diff_dict.update(col_diff)
# Constraint comparison
pk_diff = self.constraint_ddl_comp(source, target, diff_dict)
diff_dict.update(pk_diff)
diff_dict.update(self.parce_acl(source, target))
if not generate_script:
source = self.get_sql_from_table_diff(sid=src_sid,
did=src_did,
scid=src_scid,
tid=src_oid,
json_resp=False)
target = self.get_sql_from_table_diff(sid=tar_sid,
did=tar_did,
scid=tar_scid,
tid=tar_oid,
json_resp=False)
diff = self.get_sql_from_table_diff(sid=tar_sid,
did=tar_did,
scid=tar_scid,
tid=tar_oid,
diff_data=diff_dict,
json_resp=False)
for module in self.blueprint.submodules:
if module.NODE_TYPE not in ignore_sub_modules:
module_view = SchemaDiffRegistry.get_node_view(
module.NODE_TYPE)
if module_view.blueprint.server_type and (
src_server_type
not in module_view.blueprint.server_type
and tar_server_type
not in module_view.blueprint.server_type):
continue
if module_view.blueprint.server_type and (
(src_server_type in module_view.blueprint.server_type
and tar_server_type
not in module_view.blueprint.server_type) or
(src_server_type
not in module_view.blueprint.server_type
and tar_server_type
in module_view.blueprint.server_type)):
continue
result = module_view.compare(source_sid=src_sid,
source_did=src_did,
source_scid=src_scid,
source_tid=src_oid,
target_sid=tar_sid,
target_did=tar_did,
target_scid=tar_scid,
target_tid=tar_oid)
if result and module.NODE_TYPE != 'partition':
child_diff = ''
for res in result:
if res['status'] == \
SchemaDiffModel.COMPARISON_STATUS[
'different']:
source_oid = res['source_oid']
target_oid = res['target_oid']
else:
source_oid = res['oid']
target_oid = res['oid']
if res['status'] != \
SchemaDiffModel.COMPARISON_STATUS[
'identical']:
child_diff = module_view.ddl_compare(
source_sid=src_sid,
source_did=src_did,
source_scid=src_scid,
source_oid=source_oid,
source_tid=src_oid,
target_sid=tar_sid,
target_did=tar_did,
target_scid=tar_scid,
target_tid=tar_oid,
target_oid=target_oid,
comp_status=res['status'])
if child_diff:
diff += '\n' + child_diff
elif result:
# For partition module
identical = False
source_only = False
target_only = False
different = False
for res in result:
if res['status'] == \
SchemaDiffModel.COMPARISON_STATUS[
'identical']:
identical = True
elif res['status'] == \
SchemaDiffModel.COMPARISON_STATUS[
'source_only']:
source_only = True
elif res['status'] == \
SchemaDiffModel.COMPARISON_STATUS[
'target_only']:
target_only = True
else:
different = True
if identical:
pass
elif (source_only or target_only) and not different:
for res in result:
source_oid = res['oid']
target_oid = res['oid']
child_diff = module_view.ddl_compare(
source_sid=src_sid,
source_did=src_did,
source_scid=src_scid,
source_oid=source_oid,
source_tid=src_oid,
target_sid=tar_sid,
target_did=tar_did,
target_scid=tar_scid,
target_tid=tar_oid,
target_oid=target_oid,
comp_status=res['status'])
if child_diff:
diff += child_diff
else:
diff = self.get_sql_from_table_diff(
sid=src_sid,
did=src_did,
scid=src_scid,
tid=src_oid,
diff_schema=target_schema,
json_resp=False,
schema_diff_table=True)
else:
source = self.get_sql_from_table_diff(sid=src_sid,
did=src_did,
scid=src_scid,
tid=src_oid,
json_resp=False)
target = self.get_sql_from_table_diff(sid=tar_sid,
did=tar_did,
scid=tar_scid,
tid=tar_oid,
json_resp=False)
return {'source_ddl': source, 'target_ddl': target, 'diff_ddl': diff}
