Merge pull request #13 from geoCML/on-constraint

Implement 'on' constraint

Author: TristanDamron

README.md

@@ -6,6 +6,15 @@ Tabor is a database modeling language for GIS based on YAML, but with additional
 tabor: 0.1.2
 layers:
 
+- name: grass
+  schema: public
+  owner: geocml
+  geometry: polygon
+  fields:
+    - name: fid
+      type: int
+      pk: true
+
 - name: trees
   schema: public
   owner: geocml
@@ -22,6 +31,9 @@ layers:
     type: double
   - name: circumference_cm
     type: double
+  constraints:
+    - name: on
+      layer: grass
 
 - name: streams
   schema: public

src/constraint.py

@@ -0,0 +1,27 @@
+from tabor_constraint_type import TaborConstraintType
+
+class Constraint(object):
+    def __init__(self, constraint: dict, layer: str) -> None:
+        self.constraint = constraint
+        self.layer = layer
+
+        try:
+            if self.constraint["name"] == True:
+                self.constraint["name"] = "on"
+            self.constraint_type = TaborConstraintType(self.constraint["name"])
+        except KeyError:
+            raise Exception(f"Constraint has no name")
+
+
+    def on(self, other_layer: str) -> str:
+        return f"""CREATE OR REPLACE FUNCTION {self.layer}_on_{other_layer}() RETURNS trigger AS $$ DECLARE overlap boolean; BEGIN SELECT Count(*) INTO overlap FROM {other_layer} WHERE ST_Contains({other_layer}.geom, NEW.geom); IF NOT overlap THEN RAISE EXCEPTION '{self.layer} is not on {other_layer}'; END IF; RETURN NEW; END; $$ LANGUAGE 'plpgsql'; CREATE CONSTRAINT TRIGGER {self.layer}_on_{other_layer} AFTER INSERT OR UPDATE ON {self.layer} FOR EACH ROW EXECUTE FUNCTION {self.layer}_on_{other_layer}();"""
+
+
+    def __str__(self) -> str:
+        if self.constraint_type.type == "on":
+            try:
+                layer = self.constraint["layer"]
+            except KeyError:
+                raise Exception("Constraint 'on' needs a relative layer value")
+            return self.on(layer)
+        return ""

src/geometry_type.py

@@ -4,9 +4,9 @@ class GeometryType(object):
     postgis_point_types = ("POINT", "Point")
     postgis_multi_polygon_types = ("MULTIPOLYGON", "Multipolygon")
     postgis_geometry_generic_types = ("GEOMETRY", "Geometry")
+    valid_types = ("polyline", "multi polygon", "polygon", "point", "geometry")
 
     def __init__(self, type: str):
-        self.valid_types = ("polyline", "multi polygon", "polygon", "point", "geometry")
         self.set_type(type)
 
 

src/tabor_constraint_type.py

@@ -0,0 +1,8 @@
+class TaborConstraintType(object):
+    valid_constraints = ("on")
+
+    def __init__(self, constraint: str) -> None:
+        if constraint not in self.valid_constraints:
+            raise Exception(f"{constraint} is not a valid constraint, valid constraints are  {str(self.valid_constraints)}")
+
+        self.type = constraint

src/tabor_file.py

@@ -24,7 +24,13 @@ def __init__(self, path: str, psql_data: dict | None = None) -> None:
                         except KeyError:
                             geometry = None
 
-                        self.add_layer(layer["name"], layer["schema"], geometry, layer["owner"], layer["fields"])
+                        constraints: dict = {}
+                        try:
+                            constraints = layer["constraints"]
+                        except KeyError:
+                            pass
+
+                        self.add_layer(layer["name"], layer["schema"], geometry, layer["owner"], layer["fields"], constraints)
 
             except FileNotFoundError:
                 raise Exception(f"Failed to read .tabor file at {self.path}, does that path exist?")
@@ -37,11 +43,18 @@ def __init__(self, path: str, psql_data: dict | None = None) -> None:
                 except KeyError:
                     geom = None
 
-                self.add_layer(table.split(".")[1], table.split(".")[0], geom, owner=values["owner"], fields=values["fields"])
 
+                constraints: dict = {}
+                try:
+                    constraints = values["constraints"]
+                except KeyError:
+                    pass
+
+                self.add_layer(table.split(".")[1], table.split(".")[0], geom, values["owner"], values["fields"], constraints)
 
-    def add_layer(self, name: str, schema: str, geometry: str | None, owner: str, fields: dict) -> TaborLayer:
-        self.layers.append(TaborLayer(name, schema, geometry, owner, fields))
+
+    def add_layer(self, name: str, schema: str, geometry: str | None, owner: str, fields: dict, constraints: dict) -> TaborLayer:
+        self.layers.append(TaborLayer(name, schema, geometry, owner, fields, constraints))
         return self.layers[len(self.layers) - 1]
 
 
@@ -66,6 +79,10 @@ def to_psql(self) -> dict:
             result[layer.name]["schema"] = f"""CREATE TABLE IF NOT EXISTS "{layer.schema}"."{layer.name}" ({", ".join(fields)}{geom_query}{pk_query});"""
             result[layer.name]["owner"] = f"""ALTER TABLE "{layer.schema}"."{layer.name}" OWNER TO {layer.owner};"""
 
+            result[layer.name]["constraints"] = []
+            for constraint in layer.constraints:
+                result[layer.name]["constraints"].append(str(constraint))
+
             if layer.geometry:
                 result[layer.name]["geometry"] = f"""ALTER TABLE "{layer.schema}"."{layer.name}" ALTER COLUMN geom TYPE Geometry({layer.derive_geometry_type()});"""
 

src/tabor_layer.py

@@ -1,9 +1,10 @@
 from geometry_type import GeometryType
+from constraint import Constraint
 from tabor_field import TaborField
 
 
 class TaborLayer(object):
-    def __init__(self, name: str, schema: str, geometry: str | None, owner: str, fields: dict) -> None:
+    def __init__(self, name: str, schema: str, geometry: str | None, owner: str, fields: dict, constraints: dict) -> None:
         self.name = name
         self.schema = schema
 
@@ -12,6 +13,11 @@ def __init__(self, name: str, schema: str, geometry: str | None, owner: str, fie
         else:
             self.geometry = None
 
+        self.constraints: list[Constraint] = []
+        if constraints:
+            for constraint in constraints:
+                self.constraints.append(Constraint(constraint, self.name))
+
         self.owner = owner
         self.fields: list[TaborField] = []