structured2graph 0.1.1__py3-none-any.whl

core/schema/spec.json

@@ -0,0 +1,155 @@
+{
+  "nodes": [
+    {
+      "labels": ["NodeLabel"],
+      "count": 1,
+      "properties": [
+        {
+          "key": "property_key_0",
+          "count": 1,
+          "filling_factor": 100.0,
+          "types": [
+            { "type": "Null", "count": 1, "examples": [] },
+            { "type": "String", "count": 1, "examples": [] },
+            { "type": "Boolean", "count": 1, "examples": [] },
+            { "type": "Integer", "count": 1, "examples": [] },
+            { "type": "Float", "count": 1, "examples": [] },
+            { "type": "List", "count": 1, "examples": [] },
+            { "type": "Map", "count": 1, "examples": [] },
+            { "type": "Duration", "count": 1, "examples": [] },
+            { "type": "Date", "count": 1, "examples": [] },
+            { "type": "LocalTime", "count": 1, "examples": [] },
+            { "type": "LocalDateTime", "count": 1, "examples": [] },
+            { "type": "ZonedDateTime", "count": 1, "examples": [] },
+            { "type": "Enum::Name", "count": 1, "examples": [] },
+            { "type": "Point2D", "count": 1, "examples": [] },
+            { "type": "Point3D", "count": 1, "examples": [] }
+          ],
+          "source": {
+            "field": "source_table.column_name",
+            "transformation": "UPPER(column_name) | null"
+          }
+        }
+      ],
+      "examples": [{}],
+      "source": {
+        "type": "table|view|file|api|manual",
+        "name": "source_table_name",
+        "location": "database.schema.table_name",
+        "mapping": {
+          "labels": ["source_table.type_column | NodeLabel"],
+          "id_field": "source_table.id"
+        }
+      }
+    }
+  ],
+
+  "edges": [
+    {
+      "edge_type": "RELATIONSHIP_TYPE",
+      "start_node_labels": ["StartNodeLabel"],
+      "end_node_labels": ["EndNodeLabel"],
+      "count": 1,
+      "properties": [
+        {
+          "key": "edge_property",
+          "count": 1,
+          "filling_factor": 100.0,
+          "types": [{ "type": "String", "count": 1, "examples": [] }],
+          "source": {
+            "field": "many_to_many_table.property_column",
+            "transformation": "DATE(created_at) | null"
+          }
+        }
+      ],
+      "examples": [{}],
+      "source": {
+        "type": "table|view|many_to_many|derived",
+        "name": "relationships_table",
+        "location": "database.schema.relationships_table",
+        "mapping": {
+          "start_node": "relationships_table.start_id",
+          "end_node": "relationships_table.end_id",
+          "edge_type": "RELATIONSHIP_TYPE | relationships_table.type_column"
+        }
+      }
+    }
+  ],
+
+  "node_indexes": [
+    {
+      "labels": ["NodeLabel"],
+      "properties": ["indexed_property"],
+      "count": 0,
+      "examples": [{}],
+      "type": "label|label+property|label+property_point|label_text|label+property_text|label+property_vector",
+      "source": {
+        "origin": "migration_requirement|performance_optimization|source_database_index",
+        "reason": "unique_constraint|query_performance|full_text_search|vector_similarity",
+        "created_by": "migration_agent|dba_team|application_requirement",
+        "index_name": "idx_node_property | null",
+        "migrated_from": "database.schema.table_name | null"
+      }
+    }
+  ],
+
+  "edge_indexes": [
+    {
+      "edge_type": "RELATIONSHIP_TYPE",
+      "properties": ["indexed_edge_property"],
+      "count": 0,
+      "examples": [{}],
+      "type": "edge_type|edge_type+property|edge_type+property_point|edge_type_text|edge_type+property_text|edge_type+property_vector",
+      "source": {
+        "origin": "migration_requirement|performance_optimization|source_database_index",
+        "reason": "temporal_queries|relationship_traversal|full_text_search|vector_similarity",
+        "created_by": "migration_agent|dba_team|application_requirement",
+        "index_name": "idx_edge_property | null",
+        "migrated_from": "database.schema.table_name | null"
+      }
+    }
+  ],
+
+  "node_constraints": [
+    {
+      "type": "unique|existence|data_type",
+      "labels": ["NodeLabel"],
+      "properties": ["constrained_property"],
+      "data_type": "String|Integer|Float|Boolean|Date|etc",
+      "source": {
+        "origin": "source_database_constraint|migration_requirement|data_integrity",
+        "constraint_name": "original_constraint_name | null",
+        "migrated_from": "database.schema.table_name | null",
+        "created_by": "migration_agent|dba_team|data_governance"
+      }
+    }
+  ],
+
+  "edge_constraints": [
+    {
+      "type": "unique|existence|data_type",
+      "edge_type": "RELATIONSHIP_TYPE",
+      "properties": ["constrained_edge_property"],
+      "data_type": "String|Integer|Float|Boolean|Date|etc",
+      "source": {
+        "origin": "source_database_constraint|migration_requirement|data_integrity",
+        "constraint_name": "original_constraint_name | null",
+        "migrated_from": "database.schema.table_name | null",
+        "created_by": "migration_agent|dba_team|data_governance"
+      }
+    }
+  ],
+
+  "enums": [
+    {
+      "name": "EnumName",
+      "values": [],
+      "source": {
+        "origin": "source_database_enum|application_requirement|manual_definition",
+        "enum_name": "original_enum_name | null",
+        "migrated_from": "database.schema.enum_type | null",
+        "created_by": "migration_agent|application_developer|data_architect"
+      }
+    }
+  ]
+}

core/utils/meta_graph.py

@@ -0,0 +1,108 @@
+"""Shared helpers for HyGM meta graph summaries and keys."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+
+def node_key(node: Any) -> str:
+    """Generate a stable key for a graph node definition."""
+    source = getattr(node, "source", None)
+    source_name = getattr(source, "name", None)
+    if source_name:
+        return f"source::{source_name}"
+    labels = sorted(getattr(node, "labels", []))
+    return "labels::" + "|".join(labels)
+
+
+def relationship_key(rel: Any) -> str:
+    """Generate a stable key for a graph relationship."""
+    source = getattr(rel, "source", None)
+    source_name = getattr(source, "name", None)
+    if source_name:
+        return f"source::{source_name}"
+    edge_type = getattr(rel, "edge_type", "")
+    start = "|".join(sorted(getattr(rel, "start_node_labels", [])))
+    end = "|".join(sorted(getattr(rel, "end_node_labels", [])))
+    return f"edge::{edge_type}:{start}->{end}"
+
+
+def summarize_node(node: Any) -> Dict[str, Any]:
+    """Create a JSON-serializable summary for a node definition."""
+    properties = sorted(
+        {prop.key for prop in getattr(node, "properties", []) if hasattr(prop, "key")}
+    )
+    node_source = getattr(node, "source", None)
+    mapping: Dict[str, Any] = {}
+    source_name = None
+    id_field = None
+    if node_source:
+        mapping = dict(getattr(node_source, "mapping", {}) or {})
+        source_name = getattr(node_source, "name", None)
+        id_field = mapping.get("id_field")
+    return {
+        "labels": sorted(getattr(node, "labels", [])),
+        "properties": properties,
+        "id_field": id_field,
+        "source": source_name,
+        "mapping": mapping,
+    }
+
+
+def summarize_relationship(rel: Any) -> Dict[str, Any]:
+    """Create a JSON-serializable summary for a relationship."""
+    rel_source = getattr(rel, "source", None)
+    mapping: Dict[str, Any] = {}
+    source_name = None
+    source_type = None
+    if rel_source:
+        mapping = dict(getattr(rel_source, "mapping", {}) or {})
+        source_name = getattr(rel_source, "name", None)
+        source_type = getattr(rel_source, "type", None)
+    start_labels = sorted(getattr(rel, "start_node_labels", []))
+    end_labels = sorted(getattr(rel, "end_node_labels", []))
+    start_table = mapping.get("from_table")
+    end_table = mapping.get("to_table")
+    if not start_table and mapping.get("start_node"):
+        start_table = str(mapping["start_node"]).split(".")[0]
+    if not end_table and mapping.get("end_node"):
+        end_table = str(mapping["end_node"]).split(".")[0]
+    return {
+        "edge_type": getattr(rel, "edge_type", ""),
+        "start": start_labels,
+        "end": end_labels,
+        "source": source_name,
+        "source_type": source_type,
+        "mapping": mapping,
+        "start_table": start_table,
+        "end_table": end_table,
+        "join_table": mapping.get("join_table"),
+    }
+
+
+def summarize_nodes(nodes: List[Any]) -> Dict[str, Dict[str, Any]]:
+    """Build summaries for all provided nodes."""
+    summaries: Dict[str, Dict[str, Any]] = {}
+    for node in nodes:
+        summaries[node_key(node)] = summarize_node(node)
+    return summaries
+
+
+def summarize_relationships(
+    relationships: List[Any],
+) -> Dict[str, Dict[str, Any]]:
+    """Build summaries for all provided relationships."""
+    summaries: Dict[str, Dict[str, Any]] = {}
+    for relationship in relationships:
+        summaries[relationship_key(relationship)] = summarize_relationship(relationship)
+    return summaries
+
+
+__all__ = [
+    "node_key",
+    "relationship_key",
+    "summarize_node",
+    "summarize_relationship",
+    "summarize_nodes",
+    "summarize_relationships",
+]

database/__init__.py

@@ -0,0 +1,36 @@
+"""
+Database analysis package interface.
+
+This module provides the main entry point for database analysis functionality,
+importing and exposing all the necessary components.
+"""
+
+# Core data models
+from .models import (
+    TableType,
+    ColumnInfo,
+    ForeignKeyInfo,
+    TableInfo,
+    RelationshipInfo,
+    DatabaseStructure,
+)
+
+# Base interfaces
+from .analyzer import DatabaseAnalyzer
+
+# Factory (imported from existing factory module)
+from .factory import DatabaseAnalyzerFactory
+
+__all__ = [
+    # Data models
+    "TableType",
+    "ColumnInfo",
+    "ForeignKeyInfo",
+    "TableInfo",
+    "RelationshipInfo",
+    "DatabaseStructure",
+    # Interfaces
+    "DatabaseAnalyzer",
+    # Factory
+    "DatabaseAnalyzerFactory",
+]

database/adapters/__init__.py

@@ -0,0 +1,11 @@
+"""
+Database adapter implementations for different database systems.
+"""
+
+from .mysql import MySQLAnalyzer
+from .postgresql import PostgreSQLAnalyzer
+
+__all__ = [
+    "MySQLAnalyzer",
+    "PostgreSQLAnalyzer",
+]

database/adapters/memgraph.py

@@ -0,0 +1,318 @@
+"""
+Memgraph database adapter for schema validation.
+
+This adapter provides connection and query capabilities for Memgraph
+to support post-migration validation.
+"""
+
+import logging
+from typing import Dict, List, Any, Optional, Tuple
+from dataclasses import dataclass
+
+try:
+    import neo4j
+except ImportError:
+    neo4j = None
+
+try:
+    import mgclient
+except ImportError:
+    mgclient = None
+
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class MemgraphConnectionConfig:
+    """Configuration for Memgraph connection."""
+
+    host: str = "localhost"
+    port: int = 7687
+    username: str = ""
+    password: str = ""
+    use_ssl: bool = False
+
+
+class MemgraphAdapter:
+    """
+    Adapter for connecting to and querying Memgraph database.
+
+    Supports both mgclient and neo4j driver connections.
+    """
+
+    def __init__(self, config: MemgraphConnectionConfig):
+        """
+        Initialize Memgraph adapter.
+
+        Args:
+            config: Connection configuration
+        """
+        self.config = config
+        self.connection = None
+        self.driver = None
+        self._connection_type = None
+
+    def connect(self) -> bool:
+        """
+        Establish connection to Memgraph.
+
+        Returns:
+            True if connection successful, False otherwise
+        """
+        # Try mgclient first (native Memgraph client)
+        if mgclient and self._try_mgclient_connection():
+            self._connection_type = "mgclient"
+            logger.info("Connected to Memgraph using mgclient")
+            return True
+
+        # Fallback to neo4j driver (compatible with Memgraph)
+        if neo4j and self._try_neo4j_connection():
+            self._connection_type = "neo4j"
+            logger.info("Connected to Memgraph using neo4j driver")
+            return True
+
+        logger.error("Failed to connect to Memgraph with available drivers")
+        return False
+
+    def _try_mgclient_connection(self) -> bool:
+        """Try to connect using mgclient."""
+        try:
+            self.connection = mgclient.connect(
+                host=self.config.host,
+                port=self.config.port,
+                username=self.config.username,
+                password=self.config.password,
+                sslmode=mgclient.SSLMode.REQUIRE
+                if self.config.use_ssl
+                else mgclient.SSLMode.DISABLE,
+            )
+            # Test the connection
+            cursor = self.connection.cursor()
+            cursor.execute("RETURN 1")
+            cursor.fetchall()
+            return True
+        except Exception as e:
+            logger.debug(f"mgclient connection failed: {e}")
+            return False
+
+    def _try_neo4j_connection(self) -> bool:
+        """Try to connect using neo4j driver."""
+        try:
+            uri = f"{'bolt+s' if self.config.use_ssl else 'bolt'}://{self.config.host}:{self.config.port}"
+            self.driver = neo4j.GraphDatabase.driver(
+                uri,
+                auth=(self.config.username, self.config.password)
+                if self.config.username
+                else None,
+            )
+            # Test the connection
+            with self.driver.session() as session:
+                session.run("RETURN 1")
+            return True
+        except Exception as e:
+            logger.debug(f"neo4j driver connection failed: {e}")
+            return False
+
+    def execute_query(self, query: str) -> List[Tuple]:
+        """
+        Execute a query and return results.
+
+        Args:
+            query: Cypher query to execute
+
+        Returns:
+            List of result tuples
+        """
+        if not self.connection and not self.driver:
+            raise RuntimeError("Not connected to Memgraph")
+
+        if self._connection_type == "mgclient":
+            return self._execute_mgclient_query(query)
+        elif self._connection_type == "neo4j":
+            return self._execute_neo4j_query(query)
+        else:
+            raise RuntimeError("Unknown connection type")
+
+    def _execute_mgclient_query(self, query: str) -> List[Tuple]:
+        """Execute query using mgclient."""
+        cursor = self.connection.cursor()
+        cursor.execute(query)
+        return cursor.fetchall()
+
+    def _execute_neo4j_query(self, query: str) -> List[Tuple]:
+        """Execute query using neo4j driver."""
+        with self.driver.session() as session:
+            result = session.run(query)
+            return [tuple(record.values()) for record in result]
+
+    def get_schema_info(self) -> List[Tuple]:
+        """
+        Get schema information from Memgraph.
+
+        Returns:
+            Schema information as list of tuples
+        """
+        try:
+            # Try SHOW SCHEMA INFO first (newer Memgraph versions)
+            return self.execute_query("SHOW SCHEMA INFO")
+        except Exception:
+            # Fallback to alternative schema queries
+            logger.warning(
+                "SHOW SCHEMA INFO not available, using alternative schema detection"
+            )
+            return self._get_schema_info_alternative()
+
+    def _get_schema_info_alternative(self) -> List[Tuple]:
+        """
+        Alternative method to get schema info for older Memgraph versions.
+
+        Returns:
+            Schema information as list of tuples
+        """
+        schema_info = []
+
+        # Get node labels and their properties
+        try:
+            node_labels_result = self.execute_query("CALL db.labels()")
+            for label_row in node_labels_result:
+                label = label_row[0]
+
+                # Get properties for this label
+                props_query = f"MATCH (n:{label}) RETURN DISTINCT keys(n) LIMIT 1"
+                props_result = self.execute_query(props_query)
+                properties = (
+                    props_result[0][0] if props_result and props_result[0] else []
+                )
+
+                # Format as schema info tuple
+                schema_info.append(
+                    ("node", label, {prop: "Unknown" for prop in properties})
+                )
+        except Exception as e:
+            logger.warning(f"Failed to get node labels: {e}")
+
+        # Get relationship types and their properties
+        try:
+            rel_types_result = self.execute_query("CALL db.relationshipTypes()")
+            for rel_row in rel_types_result:
+                rel_type = rel_row[0]
+
+                # Get properties for this relationship type
+                props_query = (
+                    f"MATCH ()-[r:{rel_type}]-() RETURN DISTINCT keys(r) LIMIT 1"
+                )
+                props_result = self.execute_query(props_query)
+                properties = (
+                    props_result[0][0] if props_result and props_result[0] else []
+                )
+
+                # Format as schema info tuple
+                schema_info.append(
+                    ("relationship", rel_type, {prop: "Unknown" for prop in properties})
+                )
+        except Exception as e:
+            logger.warning(f"Failed to get relationship types: {e}")
+
+        return schema_info
+
+    def get_indexes(self) -> List[Dict[str, Any]]:
+        """
+        Get index information from Memgraph.
+
+        Returns:
+            List of index information dictionaries
+        """
+        try:
+            indexes_result = self.execute_query("SHOW INDEX INFO")
+            indexes = []
+
+            for index_row in indexes_result:
+                # Parse index information based on Memgraph's SHOW INDEX INFO format
+                if len(index_row) >= 3:
+                    index_info = {
+                        "name": index_row[0],
+                        "type": index_row[1],
+                        "properties": index_row[2] if len(index_row) > 2 else [],
+                    }
+                    indexes.append(index_info)
+
+            return indexes
+        except Exception as e:
+            logger.warning(f"Failed to get index information: {e}")
+            return []
+
+    def get_constraints(self) -> List[Dict[str, Any]]:
+        """
+        Get constraint information from Memgraph.
+
+        Returns:
+            List of constraint information dictionaries
+        """
+        try:
+            constraints_result = self.execute_query("SHOW CONSTRAINT INFO")
+            constraints = []
+
+            for constraint_row in constraints_result:
+                # Parse constraint information based on Memgraph's format
+                if len(constraint_row) >= 3:
+                    constraint_info = {
+                        "name": constraint_row[0],
+                        "type": constraint_row[1],
+                        "properties": constraint_row[2]
+                        if len(constraint_row) > 2
+                        else [],
+                    }
+                    constraints.append(constraint_info)
+
+            return constraints
+        except Exception as e:
+            logger.warning(f"Failed to get constraint information: {e}")
+            return []
+
+    def close(self):
+        """Close the database connection."""
+        if self.connection:
+            self.connection.close()
+            self.connection = None
+        if self.driver:
+            self.driver.close()
+            self.driver = None
+
+        logger.info("Memgraph connection closed")
+
+    def __enter__(self):
+        """Context manager entry."""
+        self.connect()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit."""
+        self.close()
+
+
+def create_memgraph_connection(
+    host: str = "localhost",
+    port: int = 7687,
+    username: str = "",
+    password: str = "",
+    use_ssl: bool = False,
+) -> MemgraphAdapter:
+    """
+    Create a Memgraph connection adapter.
+
+    Args:
+        host: Memgraph host
+        port: Memgraph port
+        username: Username for authentication
+        password: Password for authentication
+        use_ssl: Whether to use SSL connection
+
+    Returns:
+        MemgraphAdapter instance
+    """
+    config = MemgraphConnectionConfig(
+        host=host, port=port, username=username, password=password, use_ssl=use_ssl
+    )
+
+    return MemgraphAdapter(config)