Ensure that the 'CREATE SCHEMA' statement should be present in the generated script if the schema is not present in the target database. Fixes #5816

web/pgadmin/tools/schema_diff/__init__.py

@@ -464,8 +464,10 @@ def compare(trans_id, source_sid, source_did, target_sid, target_did):
             schema_result['target_only']) + len(
             schema_result['in_both_database'])
 
-        node_percent = round(100 / (total_schema * len(
-            SchemaDiffRegistry.get_registered_nodes())))
+        node_percent = 0
+        if total_schema > 0:
+            node_percent = round(100 / (total_schema * len(
+                SchemaDiffRegistry.get_registered_nodes())))
         total_percent = 0
 
         # Compare Database objects
@@ -494,7 +496,8 @@ def compare(trans_id, source_sid, source_did, target_sid, target_did):
                         diff_model_obj=diff_model_obj,
                         total_percent=total_percent,
                         node_percent=node_percent,
-                        ignore_whitespaces=ignore_whitespaces)
+                        ignore_whitespaces=ignore_whitespaces,
+                        is_schema_source_only=True)
 
                 comparison_result = \
                     comparison_result + comparison_schema_result
@@ -741,6 +744,12 @@ def compare_schema_objects(**kwargs):
     total_percent = kwargs.get('total_percent')
     node_percent = kwargs.get('node_percent')
     ignore_whitespaces = kwargs.get('ignore_whitespaces')
+    is_schema_source_only = kwargs.get('is_schema_source_only', False)
+    source_schema_name = None
+    if is_schema_source_only:
+        driver = get_driver(PG_DEFAULT_DRIVER)
+        source_schema_name = driver.qtIdent(None, schema_name)
+
     comparison_result = []
 
     all_registered_nodes = SchemaDiffRegistry.get_registered_nodes()
@@ -762,7 +771,8 @@ def compare_schema_objects(**kwargs):
                                target_did=target_did,
                                target_scid=target_scid,
                                group_name=gettext(schema_name),
-                               ignore_whitespaces=ignore_whitespaces)
+                               ignore_whitespaces=ignore_whitespaces,
+                               source_schema_name=source_schema_name)
 
             if res is not None:
                 comparison_result = comparison_result + res

web/pgadmin/tools/schema_diff/compare.py

@@ -61,6 +61,7 @@ class SchemaDiffObjectCompare:
 
         group_name = kwargs.get('group_name')
         ignore_whitespaces = kwargs.get('ignore_whitespaces')
+        source_schema_name = kwargs.get('source_schema_name', None)
         source = {}
         target = {}
 
@@ -91,7 +92,8 @@ class SchemaDiffObjectCompare:
                                     node_label=self.blueprint.collection_label,
                                     group_name=group_name,
                                     ignore_whitespaces=ignore_whitespaces,
-                                    ignore_keys=self.keys_to_ignore)
+                                    ignore_keys=self.keys_to_ignore,
+                                    source_schema_name=source_schema_name)
 
     def ddl_compare(self, **kwargs):
         """

web/pgadmin/tools/schema_diff/directory_compare.py

@@ -20,19 +20,21 @@ list_keys_array = ['name', 'colname', 'argid', 'token', 'option', 'conname',
                    'fsrvoption', 'umoption']
 
 
-def _get_source_list(added, source_dict, node, source_params, view_object,
-                     node_label, group_name):
+def _get_source_list(**kwargs):
     """
     Get only source list.
-    :param added: added dict list.
-    :param source_dict: source dict.
-    :param node: node type.
-    :param source_params: source parameters.
-    :param view_object: view object for get sql.
-    :param node_label: node label.
-    :param group_name: group name
+    :param kwargs
     :return: list of source dict.
     """
+    added = kwargs.get('added')
+    source_dict = kwargs.get('source_dict')
+    node = kwargs.get('node')
+    source_params = kwargs.get('source_params')
+    view_object = kwargs.get('view_object')
+    node_label = kwargs.get('node_label')
+    group_name = kwargs.get('group_name')
+    source_schema_name = kwargs.get('source_schema_name')
+
     global count
     source_only = []
     for item in added:
@@ -77,7 +79,8 @@ def _get_source_list(added, source_dict, node, source_params, view_object,
             'target_ddl': '',
             'diff_ddl': diff_ddl,
             'group_name': group_name,
-            'dependencies': source_dependencies
+            'dependencies': source_dependencies,
+            'source_schema_name': source_schema_name
         })
         count += 1
 
@@ -220,9 +223,8 @@ def _get_identical_and_different_list(intersect_keys, source_dict, target_dict,
     target_params = kwargs['target_params']
     group_name = kwargs['group_name']
     for key in intersect_keys:
-        source_object_id, target_object_id = get_source_target_oid(source_dict,
-                                                                   target_dict,
-                                                                   key)
+        source_object_id, target_object_id = \
+            get_source_target_oid(source_dict, target_dict, key)
 
         # Recursively Compare the two dictionary
         if are_dictionaries_identical(dict1[key], dict2[key],
@@ -337,6 +339,7 @@ def compare_dictionaries(**kwargs):
     node_label = kwargs.get('node_label')
     ignore_whitespaces = kwargs.get('ignore_whitespaces')
     ignore_keys = kwargs.get('ignore_keys', None)
+    source_schema_name = kwargs.get('source_schema_name')
 
     dict1 = copy.deepcopy(source_dict)
     dict2 = copy.deepcopy(target_dict)
@@ -352,8 +355,13 @@ def compare_dictionaries(**kwargs):
     # Keys that are available in source and missing in target.
 
     added = dict1_keys - dict2_keys
-    source_only = _get_source_list(added, source_dict, node, source_params,
-                                   view_object, node_label, group_name)
+
+    source_only = _get_source_list(added=added, source_dict=source_dict,
+                                   node=node, source_params=source_params,
+                                   view_object=view_object,
+                                   node_label=node_label,
+                                   group_name=group_name,
+                                   source_schema_name=source_schema_name)
 
     target_only = []
     # Keys that are available in target and missing in source.

web/pgadmin/tools/schema_diff/static/js/schema_diff_ui.js

@@ -260,6 +260,15 @@ export default class SchemaDiffUI {
         let data = self.grid.getData().getItem(sel_rows[row]);
         if(!_.isUndefined(data.diff_ddl)) {
           if (!(data.dependLevel in script_array)) script_array[data.dependLevel] = [];
+          // Check whether the selected object belongs to source only schema
+          // if yes then we will have to add create schema statement before
+          // creating any other object.
+          if (!_.isUndefined(data.source_schema_name) && !_.isNull(data.source_schema_name)) {
+            let schema_query = '\nCREATE SCHEMA IF NOT EXISTS ' + data.source_schema_name + ';\n';
+            if (script_array[data.dependLevel].indexOf(schema_query) == -1) {
+              script_array[data.dependLevel].push(schema_query);
+            }
+          }
           script_array[data.dependLevel].push(data.diff_ddl);
         }
       }