Merge pull request #883 from khoatxp/create-db-report/refactor-java-style-code

eda.create-db-report: restructure create_db_report and clean java style code

Author: jinglinpeng

dataprep/eda/create_db_report/model/__init__.py renamed to dataprep/eda/create_db_report/db_models/__init__.py

@@ -0,0 +1,86 @@
+from .table import Table
+
+
+class ForeignKeyConstraint:
+    imported_key_cascade = 0
+    imported_key_restrict = 1
+    imported_key_set_null = 2
+    imported_key_no_action = 3
+
+    def __init__(self, child: Table, name: str, delete_rule: str, update_rule: int):
+        self.name = name
+        self.child_table = child
+        self.delete_rule = delete_rule
+        self.update_rule = update_rule
+        self.parent_columns = []
+        self.child_columns = []
+        self.parent_table = None
+
+    def add_parent_column(self, column):
+        if column is not None:
+            self.parent_columns.append(column)
+            self.parent_table = column.table
+
+    def add_child_column(self, column):
+        if column is not None:
+            self.child_columns.append(column)
+
+    def is_cascade_on_delete(self):
+        return self.delete_rule == self.imported_key_cascade
+
+    def is_restrict_delete(self):
+        return (
+            self.delete_rule == self.imported_key_no_action
+            or self.delete_rule == self.imported_key_restrict
+        )
+
+    def is_null_on_delete(self):
+        return self.delete_rule == self.imported_key_set_null
+
+    def get_delete_rule_name(self):
+        if self.delete_rule == self.imported_key_cascade:
+            return "Cascade on delete"
+        elif (
+            self.delete_rule == self.imported_key_restrict
+            or self.delete_rule == self.imported_key_no_action
+        ):
+            return "Restrict delete"
+        elif self.delete_rule == self.imported_key_set_null:
+            return "Null on delete"
+        else:
+            return ""
+
+    def get_delete_rule_description(self):
+        if self.delete_rule == self.imported_key_cascade:
+            return "Cascade on delete:\nDeletion of parent deletes child"
+        elif (
+            self.delete_rule == self.imported_key_restrict
+            or self.delete_rule == self.imported_key_no_action
+        ):
+            return "Restrict delete:\nParent cannot be deleted if children exist"
+        elif self.delete_rule == self.imported_key_set_null:
+            return "Null on delete:\nForeign key to parent set to NULL when parent deleted"
+        else:
+            return ""
+
+    def get_delete_rule_alias(self):
+        if self.delete_rule == self.imported_key_cascade:
+            return "C"
+        elif (
+            self.delete_rule == self.imported_key_restrict
+            or self.delete_rule == self.imported_key_no_action
+        ):
+            return "R"
+        elif self.delete_rule == self.imported_key_set_null:
+            return "N"
+        else:
+            return ""
+
+    @staticmethod
+    def get_all_foreign_key_constraints(tables):
+        constraints = []
+
+        for table in tables:
+            constraints.extend(table.get_foreign_keys())
+
+        return constraints

dataprep/eda/create_db_report/db_models/constraint.py

@@ -0,0 +1,24 @@
+from .db_meta import DbMeta
+
+
+class Database:
+    def __init__(self, name: str, schema: str, stats: DbMeta) -> None:
+        self.name = name
+        self.schema = schema
+        self.tables = {}
+        self.views = {}
+        for key, value in stats.__dict__.items():
+            if not hasattr(self, key):
+                setattr(self, key, value)
+
+    def add_table(self, table_name: str, table_object):
+        self.tables[table_name] = table_object
+
+    def add_view(self, view_name: str, view_object):
+        self.views[view_name] = view_object
+
+    def get_tables(self):
+        return self.tables.values()
+
+    def get_views(self):
+        return self.views.values()

dataprep/eda/create_db_report/db_models/database.py

@@ -29,4 +29,4 @@ def __init__(
         self.num_of_uk = num_of_uk
         self.num_of_pk = num_of_pk
         self.num_of_table = num_of_tables
-        self.databaseProduct = self.engine_name_dict[engine_name] + " - " + product_version
+        self.database_product = self.engine_name_dict[engine_name] + " - " + product_version

dataprep/eda/create_db_report/model/db_metadata.py renamed to dataprep/eda/create_db_report/db_models/db_meta.py

@@ -0,0 +1,74 @@
+from .database import Database
+from .table_index import TableIndex
+
+
+class Table:
+    def __init__(self, database: Database, schema: str, name: str) -> None:
+        self.database = database
+        self.schema = schema
+        self.name = name
+        self.foreign_keys = {}
+        self.columns = {}
+        self.primary_keys = []
+        self.indexes = {}
+        self.id = None
+        self.check_constraints = {}
+        self.num_of_rows = 0
+        self.num_of_cols = 0
+        self.comments = None
+        self.max_children = 0
+        self.max_parents = 0
+        self.type = None
+
+    def set_columns(self, columns):
+        self.columns.update(columns)
+
+    def set_index(self, name: str, index: TableIndex):
+        self.indexes[name] = index
+
+    def num_columns(self, col_size: int):
+        self.num_of_cols = col_size
+
+    def get_indexes(self):
+        return self.indexes.values()
+
+    def get_index(self, index_name: str):
+        return self.indexes[index_name]
+
+    def get_columns(self):
+        return self.columns.values()
+
+    def add_primary_key(self, primary_key):
+        self.primary_keys.append(primary_key)
+
+    def add_column(self, col_name: str, col):
+        self.columns[col_name] = col
+
+    def add_max_parents(self):
+        self.max_parents += 1
+
+    def add_max_children(self):
+        self.max_children += 1
+
+    def get_view_definition(self):
+        return None
+
+    def is_view(self):
+        return False
+
+    def get_type(self):
+        if self.is_view():
+            return "View"
+        return "Table"
+
+    def get_column(self, col_name: str):
+        return self.columns[col_name]
+
+    def add_check_constraint(self, constraint_name: str, text: str):
+        self.check_constraints[constraint_name] = text
+
+    def get_foreign_keys(self):
+        return self.foreign_keys.values()
+
+    def add_foreign_key(self, foreign_key):
+        self.foreign_keys[foreign_key.name] = foreign_key

dataprep/eda/create_db_report/db_models/table.py

@@ -0,0 +1,62 @@
+from .table import Table
+from .constraint import ForeignKeyConstraint
+
+
+class TableColumn:
+    def __init__(
+        self,
+        table: Table,
+        name: str,
+        type_name: str,
+        not_null: bool,
+        default_value: str,
+        is_auto_updated: bool,
+        comments: str,
+    ):
+        self.table = table
+        self.name = name
+        self.type_name = type_name
+        self.not_null = not_null
+        self.default_value = default_value
+        self.comments = comments
+        self.parents = {}
+        self.children = {}
+        self.type = 0
+        self.decimal_digits = 0
+        self.detailed_size = None
+        self.is_auto_updated = is_auto_updated
+        self.index = False
+
+    def set_index(self):
+        self.index = True
+
+    def is_primary(self):
+        if self.table.primary_keys is not None:
+            return self in self.table.primary_keys
+        return False
+
+    def is_foreign_key(self):
+        return len(self.parents) != 0
+
+    def get_default_value(self):
+        return self.default_value
+
+    def set_comments(self, comments: str):
+        if comments is None or len(comments.strip()) == 0:
+            self.comments = None
+        else:
+            self.comments = comments.strip()
+
+    def add_parent(self, parent, constraint: ForeignKeyConstraint):
+        self.parents[parent] = constraint
+        self.table.add_max_parents()
+
+    def add_child(self, child, constraint: ForeignKeyConstraint):
+        self.children[child] = constraint
+        self.table.add_max_children()
+
+    def get_parents(self):
+        return list(self.parents)
+
+    def get_children(self):
+        return list(self.children)

dataprep/eda/create_db_report/db_models/table_column.py

@@ -0,0 +1,30 @@
+class TableIndex:
+    def __init__(self, name: str, index_type: str) -> None:
+        self.name = name
+        self.is_unique = False
+        self.is_primary = False
+        self.columns = {}
+        self.index_type = index_type
+
+    def add_column(self, col_string: str, column):
+        if column is not None:
+            self.columns[col_string] = column
+
+    def set_primary(self):
+        self.is_primary = True
+
+    def set_unique(self):
+        self.is_unique = True
+
+    def get_type(self):
+        if self.is_primary:
+            return "Primary key"
+        if self.is_unique:
+            return "Must be unique"
+        return "Performance"
+
+    def get_index_type(self):
+        return self.index_type
+
+    def columns_as_string(self):
+        return "".join(self.columns.keys())

dataprep/eda/create_db_report/db_models/table_index.py

@@ -1,18 +1,18 @@
-from .init_table import Table
-from .init_database import Database
+from .table import Table
+from .database import Database
 
 
 class View(Table):
     def __init__(self, db: Database, schema: str, name: str, view_def: str) -> None:
         self.viewDefinition = None
         super().__init__(db, schema, name)
-        self.setViewDefinition(view_def)
+        self.set_view_definition(view_def)
 
-    def setViewDefinition(self, view_definition: str):
+    def set_view_definition(self, view_definition: str):
         if view_definition is not None and len(view_definition.strip()) > 0:
             self.viewDefinition = view_definition
 
-    def getViewDefinition(self):
+    def get_view_definition(self):
         return self.viewDefinition
 
     def is_view(self):