gibson-cli 0.6.0__py3-none-any.whl → 0.7.0__py3-none-any.whl

gibson/structure/{keys/tests/test_ForeignKey.py → mysql/keys/tests/test_structure_mysql_keys_ForeignKey.py}

@@ -1,7 +1,7 @@
 import pytest
 
-from gibson.structure.constraints.ReferenceConstraint import ReferenceConstraint
-from gibson.structure.keys.ForeignKey import ForeignKey
+from gibson.structure.mysql.constraints.ReferenceConstraint import ReferenceConstraint
+from gibson.structure.mysql.keys.ForeignKey import ForeignKey
 
 
 def test_sql_exceptions():
@@ -65,16 +65,24 @@ def test_json():
 
     assert foreign_key.json() == {
         "attributes": ["c", "d"],
-        "name": "abc_def_fk",
-        "reference": {
+        "datastore": {
+            "specifics": {
+                "name": "abc_def_fk",
+                "relationship": {"type": None},
+                "symbol": "foreign_key_symbol",
+            }
+        },
+        "references": {
             "attributes": ["a", "b"],
-            "match": None,
+            "datastore": {
+                "specifics": {
+                    "match": None,
+                }
+            },
+            "entity": {"name": "other_table", "schema_": None},
             "on": {"delete": None, "update": None},
-            "references": "other_table",
             "sql": "references other_table (a, b)",
         },
-        "relationship": {"type": None},
         "sql": "constraint foreign_key_symbol foreign key abc_def_fk (c, d) "
         + "references other_table (a, b)",
-        "symbol": "foreign_key_symbol",
     }

gibson/structure/{keys/tests/test_Index.py → mysql/keys/tests/test_structure_mysql_keys_Index.py}

@@ -1,6 +1,6 @@
 import pytest
 
-from gibson.structure.keys.Index import Index
+from gibson.structure.mysql.keys.Index import Index
 
 
 def test_sql_exceptions():
@@ -92,7 +92,11 @@ def test_json():
 
     assert index.json() == {
         "attributes": ["a", "b"],
-        "name": "abc_def_idx",
+        "datastore": {
+            "specifics": {
+                "name": "abc_def_idx",
+                "using": "btree",
+            }
+        },
         "sql": "index abc_def_idx using btree (a, b)",
-        "using": "btree",
     }

gibson/structure/{keys/tests/test_IndexAttribute.py → mysql/keys/tests/test_structure_mysql_keys_IndexAttribute.py}

@@ -1,4 +1,4 @@
-from gibson.structure.keys.IndexAttribute import IndexAttribute
+from gibson.structure.mysql.keys.IndexAttribute import IndexAttribute
 
 
 def test_sql():

gibson/structure/mysql/testing.py

@@ -0,0 +1,231 @@
+from gibson.structure.mysql.Entity import Entity
+
+
+def structure_testing_get_entity():
+    entity = Entity()
+    entity.attributes = [
+        {
+            "check": None,
+            "datastore": {
+                "specifics": {
+                    "as_": None,
+                    "bytes_": None,
+                    "comment": None,
+                    "extra": {"increment": {"auto": True}},
+                    "on": None,
+                    "reference": None,
+                    "unsigned": None,
+                    "values": None,
+                }
+            },
+            "data_type": {"formatted": "bigint", "raw": "bigint"},
+            "default": None,
+            "key": {"index": None, "primary": True, "unique": None},
+            "length": None,
+            "name": "id",
+            "nullable": False,
+            "numeric": {"precision": None, "scale": None},
+            "sql": "id bigint not null auto_increment primary key",
+        },
+        {
+            "check": None,
+            "datastore": {
+                "specifics": {
+                    "as_": None,
+                    "bytes_": None,
+                    "comment": None,
+                    "extra": {"increment": {"auto": None}},
+                    "on": None,
+                    "reference": None,
+                    "unsigned": None,
+                    "values": None,
+                }
+            },
+            "data_type": {"formatted": "varchar(36)", "raw": "varchar"},
+            "default": None,
+            "key": {"index": None, "primary": None, "unique": True},
+            "length": 36,
+            "name": "uuid",
+            "nullable": False,
+            "numeric": {"precision": None, "scale": None},
+            "sql": "uuid varchar(36) not null unique key",
+        },
+        {
+            "check": None,
+            "datastore": {
+                "specifics": {
+                    "as_": None,
+                    "bytes_": None,
+                    "comment": None,
+                    "extra": {"increment": {"auto": None}},
+                    "on": None,
+                    "reference": None,
+                    "unsigned": None,
+                    "values": None,
+                }
+            },
+            "data_type": {"formatted": "datetime", "raw": "datetime"},
+            "default": "current_timestamp",
+            "key": {"index": None, "primary": None, "unique": None},
+            "length": None,
+            "name": "date_created",
+            "nullable": False,
+            "numeric": {"precision": None, "scale": None},
+            "sql": "date_created datetime not null default current_timestamp",
+        },
+        {
+            "check": None,
+            "datastore": {
+                "specifics": {
+                    "as_": None,
+                    "bytes_": None,
+                    "comment": None,
+                    "extra": {"increment": {"auto": None}},
+                    "on": "update current_timestamp",
+                    "reference": None,
+                    "unsigned": None,
+                    "values": None,
+                }
+            },
+            "data_type": {"formatted": "datetime", "raw": "datetime"},
+            "default": "null",
+            "key": {"index": None, "primary": None, "unique": None},
+            "length": None,
+            "name": "date_updated",
+            "nullable": None,
+            "numeric": {"precision": None, "scale": None},
+            "sql": "date_updated datetime default null on update current_timestamp",
+        },
+    ]
+    entity.constraints = {"check": []}
+    entity.keys = {"foreign": [], "index": [], "primary": None, "unique": []}
+    entity.name = "abc_def"
+    entity.table = {
+        "parameters": {
+            "auto": None,
+            "charset": None,
+            "collate": None,
+            "default": None,
+            "engine": None,
+            "sql": None,
+        }
+    }
+
+    return entity
+
+
+def structure_testing_get_struct_data():
+    return {
+        "entity": {
+            "name": "abc_def",
+            "struct": {
+                "attributes": [
+                    {
+                        "check": None,
+                        "datstore": {
+                            "specifics": {
+                                "as_": None,
+                                "bytes_": None,
+                                "comment": None,
+                                "extra": {"increment": {"auto": True}},
+                                "on": None,
+                                "reference": None,
+                                "unsigned": None,
+                                "values": None,
+                            }
+                        },
+                        "data_type": {"formatted": "bigint", "raw": "bigint"},
+                        "default": None,
+                        "key": {"index": None, "primary": True, "unique": None},
+                        "length": None,
+                        "name": "id",
+                        "nullable": False,
+                        "numeric": {"precision": None, "scale": None},
+                        "sql": "id bigint not null auto_increment primary key",
+                    },
+                    {
+                        "check": None,
+                        "datastore": {
+                            "specifics": {
+                                "as_": None,
+                                "bytes_": None,
+                                "comment": None,
+                                "extra": {"increment": {"auto": None}},
+                                "on": None,
+                                "reference": None,
+                                "unsigned": None,
+                                "values": None,
+                            }
+                        },
+                        "data_type": {"formatted": "varchar(36)", "raw": "varchar"},
+                        "default": None,
+                        "key": {"index": None, "primary": None, "unique": True},
+                        "length": 36,
+                        "name": "uuid",
+                        "nullable": False,
+                        "numeric": {"precision": None, "scale": None},
+                        "sql": "uuid varchar(36) not null unique key",
+                    },
+                    {
+                        "check": None,
+                        "datastore": {
+                            "specifics": {
+                                "as_": None,
+                                "bytes_": None,
+                                "comment": None,
+                                "extra": {"increment": {"auto": None}},
+                                "on": None,
+                                "reference": None,
+                                "unsigned": None,
+                                "values": None,
+                            }
+                        },
+                        "data_type": {"formatted": "datetime", "raw": "datetime"},
+                        "default": "current_timestamp",
+                        "key": {"index": None, "primary": None, "unique": None},
+                        "length": None,
+                        "name": "date_created",
+                        "nullable": False,
+                        "numeric": {"precision": None, "scale": None},
+                        "sql": "date_created datetime not null default current_timestamp",
+                    },
+                    {
+                        "check": None,
+                        "datastore": {
+                            "specifics": {
+                                "as_": None,
+                                "bytes_": None,
+                                "comment": None,
+                                "extra": {"increment": {"auto": None}},
+                                "on": "update current_timestamp",
+                                "reference": None,
+                                "unsigned": None,
+                                "values": None,
+                            }
+                        },
+                        "data_type": {"formatted": "datetime", "raw": "datetime"},
+                        "default": "null",
+                        "key": {"index": None, "primary": None, "unique": None},
+                        "length": None,
+                        "name": "date_updated",
+                        "nullable": None,
+                        "numeric": {"precision": None, "scale": None},
+                        "sql": "date_updated datetime default null on update "
+                        + "current_timestamp",
+                    },
+                ],
+                "constraints": {"check": []},
+                "keys": {"foreign": [], "index": [], "primary": None, "unique": []},
+                "table": {
+                    "parameters": {
+                        "auto": None,
+                        "charset": None,
+                        "collate": None,
+                        "default": None,
+                        "engine": None,
+                        "sql": None,
+                    },
+                },
+            },
+        }
+    }

gibson/structure/{tests/test_Entity.py → mysql/tests/test_structure_mysql_Entity.py}

@@ -1,10 +1,10 @@
 import pytest
 
-from gibson.structure.constraints.ReferenceConstraint import ReferenceConstraint
-from gibson.structure.Entity import Entity
-from gibson.structure.keys.ForeignKey import ForeignKey
-from gibson.structure.keys.Index import Index
-from gibson.structure.testing import (
+from gibson.structure.mysql.constraints.ReferenceConstraint import ReferenceConstraint
+from gibson.structure.mysql.Entity import Entity
+from gibson.structure.mysql.keys.ForeignKey import ForeignKey
+from gibson.structure.mysql.keys.Index import Index
+from gibson.structure.mysql.testing import (
     structure_testing_get_entity,
     structure_testing_get_struct_data,
 )
@@ -25,17 +25,25 @@ def test_add_foreign_key():
     assert entity.keys["foreign"] == [
         {
             "attributes": ["c", "d"],
-            "name": None,
-            "reference": {
+            "datastore": {
+                "specifics": {
+                    "name": None,
+                    "relationship": {"type": None},
+                    "symbol": None,
+                }
+            },
+            "references": {
                 "attributes": ["a", "b"],
-                "match": None,
+                "datastore": {
+                    "specifics": {
+                        "match": None,
+                    }
+                },
+                "entity": {"name": "abc_def", "schema_": None},
                 "on": {"delete": None, "update": None},
-                "references": "abc_def",
                 "sql": "references abc_def (a, b)",
             },
-            "relationship": {"type": None},
             "sql": "foreign key (c, d) references abc_def (a, b)",
-            "symbol": None,
         }
     ]
 
@@ -72,9 +80,13 @@ def test_add_index():
     assert entity.keys["index"] == [
         {
             "attributes": ["abc", "def"],
-            "name": None,
+            "datastore": {
+                "specifics": {
+                    "name": None,
+                    "using": None,
+                }
+            },
             "sql": "index (abc, def)",
-            "using": None,
         }
     ]
 
@@ -97,11 +109,13 @@ def test_import_from_struct():
     assert entity.attributes[3]["name"] == "date_updated"
     assert entity.constraints == {"check": []}
     assert entity.keys == {"foreign": [], "index": [], "primary": None, "unique": []}
-    assert entity.parameters == {
-        "auto": None,
-        "charset": None,
-        "collate": None,
-        "default": None,
-        "engine": None,
-        "sql": None,
+    assert entity.table == {
+        "parameters": {
+            "auto": None,
+            "charset": None,
+            "collate": None,
+            "default": None,
+            "engine": None,
+            "sql": None,
+        }
     }

gibson/structure/postgresql/Entity.py

@@ -0,0 +1,108 @@
+from gibson.structure.postgresql.table.ForeignKey import ForeignKey
+
+
+class Entity:
+    def __init__(self):
+        self.attributes = None
+        self.constraints = None
+        self.keys = None
+        self.name = None
+        self.table = None
+
+    def add_attribute(self, name, data_type, after=None, before=None):
+        was_added = False
+
+        json = {
+            "check": None,
+            "datastore": {
+                "specifics": {
+                    "references": None,
+                }
+            },
+            "data_type": {
+                "formatted": data_type,
+                "raw": data_type,
+            },
+            "default": None,
+            "key": {"index": None, "primary": None, "unique": None},
+            "length": None,
+            "name": name,
+            "nullable": None,
+            "numeric": {
+                "precision": None,
+                "scale": None,
+            },
+            "sql": f"{name} {data_type}",
+        }
+
+        attributes = []
+        for attribute in self.attributes:
+            if was_added is False and attribute["name"] == after:
+                was_added = True
+                attributes.append(attribute)
+                attributes.append(json)
+            elif was_added is False and attribute["name"] == before:
+                was_added = True
+                attributes.append(json)
+                attributes.append(attribute)
+            else:
+                attributes.append(attribute)
+
+        if was_added is False:
+            attributes.append(json)
+
+        self.attributes = attributes
+        return self
+
+    def add_foreign_key(self, foreign_key: ForeignKey):
+        self.keys["foreign"].append(foreign_key.json())
+        return self
+
+    def add_index(self, index: object):
+        return self
+
+    def create_statement(self):
+        parts = []
+        for attribute in self.attributes:
+            parts.append("    " + attribute["sql"])
+
+        if self.keys["primary"] is not None:
+            parts.append("    " + self.keys["primary"]["sql"])
+
+        for unique_key in self.keys["unique"]:
+            parts.append("    " + unique_key["sql"])
+
+        for index in self.keys["index"]:
+            parts.append("    " + index["sql"])
+
+        for fk in self.keys["foreign"]:
+            parts.append("    " + fk["sql"])
+
+        for check in self.constraints["check"]:
+            parts.append("    " + check["sql"])
+
+        parameters = ""
+        if self.table["parameters"] and self.table["parameters"].get("sql"):
+            parameters = " " + self.table["parameters"].get("sql")
+
+        return (
+            f"create table if not exists {self.name}(\n"
+            + ",\n".join(parts)
+            + f"\n){parameters}"
+        )
+
+    def import_from_struct(self, data: dict):
+        if "name" in data and "struct" in data:
+            self.name = data["name"]
+
+            for key in data["struct"].keys():
+                setattr(self, key, data["struct"][key])
+        elif "entity" in data and "struct" in data["entity"]:
+            self.name = data["entity"]["name"]
+
+            for key in data["entity"]["struct"].keys():
+                setattr(self, key, data["entity"]["struct"][key])
+        else:
+            raise RuntimeError("cannot import from struct, incorrect data format")
+
+        return self

gibson/structure/postgresql/References.py

@@ -0,0 +1,61 @@
+class References:
+    def __init__(self):
+        self.columns = []
+        self.match_full = None
+        self.match_partial = None
+        self.match_simple = None
+        self.on_delete = None
+        self.on_update = None
+        self.ref_schema = None
+        self.ref_table = None
+
+    def json(self):
+        return {
+            "attributes": self.columns,
+            "datastore": {
+                "specifics": {
+                    "match": {
+                        "full": self.match_full,
+                        "partial": self.match_partial,
+                        "simple": self.match_simple,
+                    },
+                }
+            },
+            "entity": {"name": self.ref_table, "schema_": self.ref_schema},
+            "on": {"delete": self.on_delete, "update": self.on_update},
+            "sql": self.sql(),
+        }
+
+    def sql(self):
+        parts = []
+
+        ref_table = []
+        if self.ref_schema is not None:
+            ref_table.append(self.ref_schema)
+        ref_table.append(self.ref_table)
+
+        if self.ref_table is not None:
+            parts.append(".".join(ref_table))
+
+        if self.columns != []:
+            parts.append("(" + ", ".join(self.columns) + ")")
+
+        if self.match_full is True:
+            parts.append("match full")
+
+        if self.match_partial is True:
+            parts.append("match partial")
+
+        if self.match_simple is True:
+            parts.append("match simple")
+
+        if self.on_delete is not None:
+            parts.append(f"on delete {self.on_delete}")
+
+        if self.on_update is not None:
+            parts.append(f"on update {self.on_update}")
+
+        if parts == []:
+            return ""
+
+        return ("references " + " ".join(parts)).lstrip().rstrip()

gibson/structure/postgresql/table/ForeignKey.py

@@ -0,0 +1,28 @@
+class ForeignKey:
+    def __init__(self):
+        self.columns = []
+        self.references = None
+        self.relationship = None
+
+    def json(self):
+        return {
+            "attributes": self.columns,
+            "references": self.references.json()
+            if self.references is not None
+            else None,
+            "sql": self.sql(),
+        }
+
+    def sql(self):
+        parts = []
+
+        if self.columns != []:
+            parts.append("(" + ", ".join(self.columns) + ")")
+
+        if self.references is not None:
+            parts.append(self.references.sql())
+
+        if parts == []:
+            return ""
+
+        return ("foreign key " + " ".join(parts)).lstrip().rstrip()

gibson/structure/postgresql/table/tests/test_structure_postgresql_table_ForeignKey.py

@@ -0,0 +1,44 @@
+import pytest
+
+from gibson.structure.postgresql.References import References
+from gibson.structure.postgresql.table.ForeignKey import ForeignKey
+
+
+def test_sql():
+    references = References()
+    references.columns = ["a", "b"]
+    references.ref_table = "other_table"
+
+    foreign_key = ForeignKey()
+    foreign_key.references = references
+
+    foreign_key.columns = ["a", "b"]
+
+    assert foreign_key.sql() == "foreign key (a, b) references other_table (a, b)"
+
+
+def test_json():
+    references = References()
+    references.columns = ["a", "b"]
+    references.match_full = True
+    references.match_partial = False
+    references.match_simple = True
+    references.ref_table = "other_table"
+
+    foreign_key = ForeignKey()
+    foreign_key.columns = ["c", "d"]
+    foreign_key.references = references
+
+    assert foreign_key.json() == {
+        "attributes": ["c", "d"],
+        "references": {
+            "attributes": ["a", "b"],
+            "datastore": {
+                "specifics": {"match": {"full": True, "partial": False, "simple": True}}
+            },
+            "entity": {"name": "other_table", "schema_": None},
+            "on": {"delete": None, "update": None},
+            "sql": "references other_table (a, b) match full match simple",
+        },
+        "sql": "foreign key (c, d) references other_table (a, b) match full match simple",
+    }