graph-dependency-analyzer 0.2.0__py3-none-any.whl

src/infrastructure/parsing/sql_schema_parser.py

@@ -0,0 +1,658 @@
+"""
+SQL Schema Parser — generic multi-dialect database schema extractor.
+
+Supports:
+  - Oracle PL/SQL  (CREATE TABLE, CREATE OR REPLACE PROCEDURE/PACKAGE/VIEW/TRIGGER/FUNCTION)
+  - SQL Server T-SQL (CREATE TABLE [schema].[name], stored procedures)
+  - PostgreSQL     (CREATE TABLE schema.name, CREATE FUNCTION, CREATE SEQUENCE)
+  - MySQL/MariaDB  (CREATE TABLE `name`, ENGINE=InnoDB)
+  - ANSI SQL       (Flyway/Liquibase migrations, ad-hoc DDL files)
+  - JPA/Hibernate  (@Entity, @Table, @Document — extracted from Java source)
+  - MongoDB        (@Document — Spring Data collection names)
+  - .properties    (SQL queries embedded in properties files)
+
+For each file it returns a ParseResult compatible with the existing indexing pipeline:
+  - classes  → DB objects (DB_TABLE, DB_VIEW, DB_PROCEDURE, DB_PACKAGE, DB_TRIGGER, DB_SEQUENCE)
+  - imports  → cross-schema / cross-table references (READS / WRITES / CALLS)
+  - method_calls → kept for pipeline compatibility (empty for SQL files)
+  - string_literals → raw SQL fragments for further analysis
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from src.domain.repositories.i_code_parser import ParseResult
+
+
+# ---------------------------------------------------------------------------
+# Result dataclass (dict-like so DependencyExtractor can process it uniformly)
+# ---------------------------------------------------------------------------
+
+@dataclass
+class DbObject:
+    """Represents a database object extracted from SQL source."""
+    object_type: str          # DB_TABLE | DB_VIEW | DB_PROCEDURE | DB_PACKAGE | DB_TRIGGER | DB_SEQUENCE | DB_FUNCTION | DB_INDEX | DB_TYPE
+    name: str                 # simple name
+    schema: str               # schema/user name (empty if not qualified)
+    qualified_name: str       # schema.name or just name
+    dialect: str              # oracle | sqlserver | postgresql | mysql | ansi
+    line: int = 0
+    columns: list[str] = field(default_factory=list)       # for tables
+    references: list[dict] = field(default_factory=list)   # cross-object refs
+    raw_ddl: str = ""
+
+    def to_class_dict(self) -> dict[str, Any]:
+        """Convert to the dict format DependencyExtractor expects from ParseResult.classes."""
+        return {
+            "name": self.name,
+            "qualified_name": self.qualified_name,
+            "node_type": self.object_type,
+            "schema": self.schema,
+            "dialect": self.dialect,
+            "columns": self.columns,
+            "line": self.line,
+            "metadata": {
+                "object_type": self.object_type,
+                "schema": self.schema,
+                "dialect": self.dialect,
+                "columns": self.columns,
+            },
+        }
+
+
+# ---------------------------------------------------------------------------
+# Dialect detection
+# ---------------------------------------------------------------------------
+
+_ORACLE_SIGNALS  = re.compile(r'CREATE\s+OR\s+REPLACE|VARCHAR2|NUMBER\s*\(|DBMS_|SYSDATE|NVL\s*\(|ROWNUM|EXECUTE\s+IMMEDIATE', re.I)
+_MSSQL_SIGNALS   = re.compile(r'USE\s+\[|GO\s*$|\[dbo\]\.\[|\bIDENTITY\s*\(|NOCOUNT|\bGO\b', re.I | re.M)
+_POSTGRES_SIGNALS= re.compile(r'SERIAL\b|BIGSERIAL\b|\$\$|LANGUAGE\s+plpgsql|\bRETURNING\b', re.I)
+_MYSQL_SIGNALS   = re.compile(r'ENGINE\s*=\s*InnoDB|AUTO_INCREMENT|`[^`]+`', re.I)
+
+
+def _detect_dialect(content: str) -> str:
+    if _ORACLE_SIGNALS.search(content):
+        return "oracle"
+    if _MSSQL_SIGNALS.search(content):
+        return "sqlserver"
+    if _POSTGRES_SIGNALS.search(content):
+        return "postgresql"
+    if _MYSQL_SIGNALS.search(content):
+        return "mysql"
+    return "ansi"
+
+
+# ---------------------------------------------------------------------------
+# Name normalisation helpers
+# ---------------------------------------------------------------------------
+
+def _strip_quotes(name: str) -> str:
+    """Remove surrounding quotes/brackets from an identifier."""
+    name = name.strip()
+    if (name.startswith('"') and name.endswith('"')) or \
+       (name.startswith("'") and name.endswith("'")):
+        return name[1:-1]
+    if name.startswith("[") and name.endswith("]"):
+        return name[1:-1]
+    if name.startswith("`") and name.endswith("`"):
+        return name[1:-1]
+    return name
+
+
+def _qualified(schema: str, name: str) -> str:
+    schema = _strip_quotes(schema).upper() if schema else ""
+    name   = _strip_quotes(name).upper()
+    return f"{schema}.{name}" if schema else name
+
+
+# ---------------------------------------------------------------------------
+# Regex patterns for DDL extraction
+# ---------------------------------------------------------------------------
+
+# Identifier: quoted or unquoted
+_ID = r'(?:"[^"]+"|\'[^\']+\'|\[[^\]]+\]|`[^`]+`|[\w$#]+)'
+
+# Optional schema prefix:  schema.name  or  [schema].[name]
+_SCHEMA_NAME = rf'(?:({_ID})\s*\.\s*)?({_ID})'
+
+_RE_CREATE_TABLE = re.compile(
+    rf'CREATE\s+(?:OR\s+REPLACE\s+)?(?:GLOBAL\s+TEMPORARY\s+|TEMP\s+|TEMPORARY\s+)?TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?{_SCHEMA_NAME}',
+    re.I,
+)
+_RE_CREATE_VIEW = re.compile(
+    rf'CREATE\s+(?:OR\s+REPLACE\s+)?(?:FORCE\s+)?(?:MATERIALIZED\s+)?VIEW\s+{_SCHEMA_NAME}',
+    re.I,
+)
+_RE_CREATE_PROCEDURE = re.compile(
+    rf'CREATE\s+(?:OR\s+REPLACE\s+)?PROCEDURE\s+{_SCHEMA_NAME}',
+    re.I,
+)
+_RE_CREATE_FUNCTION = re.compile(
+    rf'CREATE\s+(?:OR\s+REPLACE\s+)?FUNCTION\s+{_SCHEMA_NAME}',
+    re.I,
+)
+_RE_CREATE_PACKAGE = re.compile(
+    rf'CREATE\s+(?:OR\s+REPLACE\s+)?PACKAGE\s+(?:BODY\s+)?{_SCHEMA_NAME}',
+    re.I,
+)
+_RE_CREATE_TRIGGER = re.compile(
+    rf'CREATE\s+(?:OR\s+REPLACE\s+)?TRIGGER\s+{_SCHEMA_NAME}',
+    re.I,
+)
+_RE_CREATE_SEQUENCE = re.compile(
+    rf'CREATE\s+SEQUENCE\s+{_SCHEMA_NAME}',
+    re.I,
+)
+_RE_CREATE_INDEX = re.compile(
+    rf'CREATE\s+(?:UNIQUE\s+|BITMAP\s+)?INDEX\s+{_SCHEMA_NAME}\s+ON\s+{_SCHEMA_NAME}',
+    re.I,
+)
+_RE_CREATE_TYPE = re.compile(
+    rf'CREATE\s+(?:OR\s+REPLACE\s+)?TYPE\s+{_SCHEMA_NAME}',
+    re.I,
+)
+_RE_CREATE_SYNONYM = re.compile(
+    rf'CREATE\s+(?:OR\s+REPLACE\s+)?(?:PUBLIC\s+)?SYNONYM\s+{_SCHEMA_NAME}',
+    re.I,
+)
+
+# DML references inside SQL bodies
+_RE_FROM     = re.compile(rf'(?:FROM|JOIN)\s+{_SCHEMA_NAME}', re.I)
+_RE_INTO     = re.compile(rf'INSERT\s+INTO\s+{_SCHEMA_NAME}', re.I)
+_RE_UPDATE   = re.compile(rf'UPDATE\s+{_SCHEMA_NAME}', re.I)
+_RE_DELETE   = re.compile(rf'DELETE\s+FROM\s+{_SCHEMA_NAME}', re.I)
+_RE_CALL     = re.compile(rf'(?:CALL|EXEC(?:UTE)?)\s+{_SCHEMA_NAME}', re.I)
+
+# Column extraction from CREATE TABLE body
+_RE_COLUMN   = re.compile(r'^\s+["`\[]?(\w+)["`\]]?\s+(?:VARCHAR|NVARCHAR|VARCHAR2|CHAR|NCHAR|TEXT|INT|BIGINT|SMALLINT|NUMERIC|NUMBER|DECIMAL|FLOAT|REAL|DOUBLE|DATE|DATETIME|TIMESTAMP|BOOLEAN|BOOL|CLOB|BLOB|JSONB?|UUID|UNIQUEIDENTIFIER)', re.I | re.M)
+
+
+# ---------------------------------------------------------------------------
+# Java source parsing (JPA @Table/@Entity, Spring Data @Document)
+# ---------------------------------------------------------------------------
+
+_RE_JPA_ENTITY       = re.compile(r'@Entity\b', re.I)
+_RE_JPA_TABLE        = re.compile(r'@Table\s*\(\s*(?:name\s*=\s*)?["\']([^"\']+)["\']', re.I)
+_RE_MONGO_DOC        = re.compile(r'@Document\s*\(\s*(?:collection\s*=\s*)?["\']([^"\']+)["\']', re.I)
+_RE_CLASS_NAME       = re.compile(r'(?:public|protected|private)?\s*(?:class|interface)\s+(\w+)', re.I)
+
+# JPA relationship annotations
+# @JoinColumn(name="template_id") → FK column linking two tables
+_RE_JOIN_COLUMN      = re.compile(r'@JoinColumn\s*\([^)]*name\s*=\s*["\']([^"\']+)["\']', re.I)
+# @ManyToOne / @OneToOne + field type → linked entity class name
+_RE_MANY_TO_ONE      = re.compile(r'@(?:ManyToOne|OneToOne)\b[^;]*?\n\s*(?:private|protected|public)?\s*([\w<>]+)\s+\w+\s*;', re.I | re.S)
+# @OneToMany(mappedBy="fieldName") → inverse side of relation
+_RE_ONE_TO_MANY      = re.compile(r'@OneToMany\s*\([^)]*mappedBy\s*=\s*["\']([^"\']+)["\']', re.I)
+# @ManyToMany join table
+_RE_MANY_TO_MANY     = re.compile(r'@ManyToMany\b', re.I)
+# @CollectionTable(name="table_name", ...) → separate table for @ElementCollection
+# We match only the FIRST name= attribute inside @CollectionTable's own parens,
+# stopping before any nested annotation like @JoinColumn
+_RE_COLLECTION_TABLE = re.compile(
+    r'@CollectionTable\s*\(\s*\n?\s*name\s*=\s*["\']([^"\']+)["\']',
+    re.I,
+)
+# @Column(name="col") on a field — extract field-to-column mapping
+_RE_COLUMN_NAME      = re.compile(r'@Column\s*\([^)]*name\s*=\s*["\']([^"\']+)["\']', re.I)
+# @NamedNativeQuery / @Query with native SQL
+_RE_NATIVE_QUERY     = re.compile(r'(?:nativeQuery\s*=\s*true|@NamedNativeQuery)[^"\']*["\']([^"\']{10,500})["\']', re.I | re.S)
+# @Query("SELECT ... FROM tableName ...")  (JPQL — entity class names, not table names)
+_RE_JPQL_FROM        = re.compile(r'FROM\s+([A-Z][a-zA-Z0-9]+)(?:\s+\w+)?(?:\s+WHERE|\s+JOIN|\s+ORDER|\s+GROUP|\)|\s*$)', re.M)
+
+
+# ---------------------------------------------------------------------------
+# Properties file SQL parsing
+# ---------------------------------------------------------------------------
+
+# Schema placeholder patterns used in SQL properties files:
+#   #schema#.TABLE  →  FROM #schema#.OUTORDHDR
+#   {schema}.TABLE  →  FROM {schema}.OUTORDHDR
+#   ${schemaName}.TABLE
+#   [schema].[TABLE]  (SQL Server)
+_SCHEMA_PLACEHOLDER = r'(?:(?:#\w+#|\$\{\w+\}|\$\w+|\{\w+\}|\[\w+\]|\w+)\s*\.\s*)?'
+
+_RE_PROP_SQL_TABLE = re.compile(
+    rf'(?:FROM|JOIN|INTO|UPDATE|TABLE)\s+{_SCHEMA_PLACEHOLDER}({_ID})',
+    re.I,
+)
+
+
+# ---------------------------------------------------------------------------
+# Main parser class
+# ---------------------------------------------------------------------------
+
+class SqlSchemaParser:
+    """
+    Generic SQL/DB schema parser.
+
+    Handles .sql, .pks, .pkb, .prc, .fnc, .trg, .vw, .tbl files plus
+    Java files for JPA/Mongo annotations, and .properties files for
+    embedded SQL queries.
+    """
+
+    SQL_EXTENSIONS  = {".sql", ".SQL", ".pks", ".pkb", ".prc", ".fnc",
+                       ".trg", ".vw", ".tbl", ".seq", ".idx", ".typ"}
+    JAVA_EXTENSIONS = {".java"}
+    PROP_EXTENSIONS = {".properties"}
+
+    def parse_file(self, file_path: Path) -> ParseResult:
+        """
+        Parse a DB-related source file.
+
+        Returns ParseResult where:
+          - classes     → list[dict] from DbObject.to_class_dict()
+          - imports     → list[dict] with cross-object references
+          - method_calls→ [] (unused for SQL)
+          - string_literals → raw SQL fragments
+        """
+        if not file_path.exists():
+            return self._empty(file_path)
+
+        try:
+            content = file_path.read_text(encoding="utf-8", errors="replace")
+        except Exception:
+            return self._empty(file_path)
+
+        ext = file_path.suffix.lower()
+
+        if ext in self.JAVA_EXTENSIONS:
+            return self._parse_java(file_path, content)
+        if ext in self.PROP_EXTENSIONS:
+            return self._parse_properties(file_path, content)
+        # Default: SQL file
+        return self._parse_sql(file_path, content)
+
+    # ------------------------------------------------------------------
+    # SQL parsing
+    # ------------------------------------------------------------------
+
+    # Strip SQL comments before scanning for DML references
+    _RE_BLOCK_COMMENT = re.compile(r'/\*.*?\*/', re.S)
+    _RE_LINE_COMMENT  = re.compile(r'--[^\n]*')
+
+    @classmethod
+    def _strip_comments(cls, content: str) -> str:
+        """Remove SQL comments so we don't extract table names from them."""
+        content = cls._RE_BLOCK_COMMENT.sub(' ', content)
+        content = cls._RE_LINE_COMMENT.sub(' ', content)
+        return content
+
+    def _parse_sql(self, file_path: Path, content: str) -> ParseResult:
+        # Skip binary/UCS-2 files (some old SQL Server dumps)
+        if "\x00" in content[:200]:
+            return self._empty(file_path)
+
+        dialect = _detect_dialect(content)
+        objects: list[DbObject] = []
+        references: list[dict] = []
+
+        # Use comment-stripped content for DML ref scanning only
+        # (DDL uses full content so line numbers stay valid)
+        stripped = self._strip_comments(content)
+
+        def line_of(match) -> int:
+            return content[:match.start()].count("\n") + 1
+
+        # ── DDL objects ─────────────────────────────────────────────
+
+        for m in _RE_CREATE_TABLE.finditer(content):
+            schema, name = m.group(1), m.group(2)
+            obj = DbObject(
+                object_type="DB_TABLE",
+                name=_strip_quotes(name),
+                schema=_strip_quotes(schema) if schema else "",
+                qualified_name=_qualified(schema, name),
+                dialect=dialect,
+                line=line_of(m),
+            )
+            # Extract column names from the table body
+            body_start = content.find("(", m.end())
+            if body_start != -1:
+                body_end = self._find_matching_paren(content, body_start)
+                body = content[body_start:body_end]
+                obj.columns = [
+                    c.group(1) for c in _RE_COLUMN.finditer(body)
+                ]
+                obj.raw_ddl = f"CREATE TABLE {obj.qualified_name}" + body[:300]
+            objects.append(obj)
+
+        for pattern, obj_type in [
+            (_RE_CREATE_VIEW,      "DB_VIEW"),
+            (_RE_CREATE_PROCEDURE, "DB_PROCEDURE"),
+            (_RE_CREATE_FUNCTION,  "DB_FUNCTION"),
+            (_RE_CREATE_PACKAGE,   "DB_PACKAGE"),
+            (_RE_CREATE_TRIGGER,   "DB_TRIGGER"),
+            (_RE_CREATE_SEQUENCE,  "DB_SEQUENCE"),
+            (_RE_CREATE_TYPE,      "DB_TYPE"),
+            (_RE_CREATE_SYNONYM,   "DB_SYNONYM"),
+        ]:
+            for m in pattern.finditer(content):
+                schema, name = m.group(1), m.group(2)
+                objects.append(DbObject(
+                    object_type=obj_type,
+                    name=_strip_quotes(name),
+                    schema=_strip_quotes(schema) if schema else "",
+                    qualified_name=_qualified(schema, name),
+                    dialect=dialect,
+                    line=line_of(m),
+                ))
+
+        # Index: name ON table
+        for m in _RE_CREATE_INDEX.finditer(content):
+            idx_schema, idx_name = m.group(1), m.group(2)
+            tbl_schema, tbl_name = m.group(3), m.group(4)
+            objects.append(DbObject(
+                object_type="DB_INDEX",
+                name=_strip_quotes(idx_name),
+                schema=_strip_quotes(idx_schema) if idx_schema else "",
+                qualified_name=_qualified(idx_schema, idx_name),
+                dialect=dialect,
+                line=line_of(m),
+            ))
+            references.append({
+                "type": "INDEXES",
+                "target": _qualified(tbl_schema, tbl_name),
+            })
+
+        # Deduplicate DDL objects: same (object_type, qualified_name) — keep first
+        seen_objs: set[tuple] = set()
+        unique_objects: list[DbObject] = []
+        for o in objects:
+            key = (o.object_type, o.qualified_name)
+            if key not in seen_objs:
+                seen_objs.add(key)
+                unique_objects.append(o)
+        objects = unique_objects
+
+        # ── DML cross-references ────────────────────────────────────
+
+        # Known Oracle/SQL Server schema names that should NOT be treated as table names
+        _KNOWN_SCHEMAS = {
+            "ZMEDAPP", "CATNGS", "DBB01USR", "CMOP", "ZMEDTRANS", "PCAT",
+            "PETL", "ECC", "NGSUSR", "ZCATMON", "WMS_PROV", "TRAX7EDU",
+            "DBO", "SYS", "SYSTEM", "PUBLIC", "INFORMATION_SCHEMA",
+            "MASTER", "TEMPDB", "MODEL", "MSDB",
+        }
+
+        _SQL_KEYWORDS = {
+            "NULL", "DUAL", "SYSDATE", "USER", "ROWNUM", "LEVEL",
+            "CONNECT", "START", "WITH", "VALUES", "SELECT", "WHERE",
+            "SET", "AS", "ON", "BY", "TO", "FROM", "INTO", "OF",
+            "ALL", "ANY", "SOME", "EXISTS", "NOT", "AND", "OR",
+            "CASE", "WHEN", "THEN", "ELSE", "END", "IN", "BETWEEN",
+            "LIKE", "IS", "HAVING", "GROUP", "ORDER", "LIMIT",
+            "FETCH", "NEXT", "ROWS", "ONLY", "UNION", "EXCEPT",
+            "INTERSECT", "MINUS", "PIVOT", "UNPIVOT",
+        }
+
+        def add_ref(ref_type: str, schema: str | None, name: str, line: int):
+            raw_name = _strip_quotes(name).upper()
+            # Skip SQL keywords
+            if raw_name in _SQL_KEYWORDS:
+                return
+            # Skip if the "name" is actually a known schema (no dot was matched)
+            if not schema and raw_name in _KNOWN_SCHEMAS:
+                return
+            # Skip very short names that are likely aliases
+            if len(raw_name) < 2:
+                return
+            qn = _qualified(schema, name)
+            references.append({
+                "type": ref_type,
+                "target": qn,
+                "line": line,
+            })
+
+        for pattern, ref_type in [
+            (_RE_FROM,   "READS_TABLE"),
+            (_RE_INTO,   "WRITES_TABLE"),
+            (_RE_UPDATE, "WRITES_TABLE"),
+            (_RE_DELETE, "WRITES_TABLE"),
+            (_RE_CALL,   "CALLS_PROCEDURE"),
+        ]:
+            for m in pattern.finditer(stripped):   # use comment-stripped content
+                add_ref(ref_type, m.group(1), m.group(2), 0)
+
+        # Deduplicate references (same type + target)
+        seen_refs: set[tuple] = set()
+        unique_refs: list[dict] = []
+        for ref in references:
+            key = (ref["type"], ref["target"])
+            if key not in seen_refs:
+                seen_refs.add(key)
+                unique_refs.append(ref)
+
+        return ParseResult(
+            file_path=file_path,
+            classes=[o.to_class_dict() for o in objects],
+            imports=unique_refs,
+            method_calls=[],
+            string_literals=self._extract_sql_strings(content),
+        )
+
+    def _find_matching_paren(self, content: str, start: int) -> int:
+        """Find the closing ) for the opening ( at start."""
+        depth = 0
+        for i in range(start, min(start + 8000, len(content))):
+            if content[i] == "(":
+                depth += 1
+            elif content[i] == ")":
+                depth -= 1
+                if depth == 0:
+                    return i + 1
+        return start + 500  # fallback
+
+    def _extract_sql_strings(self, content: str) -> list[str]:
+        """Extract single-quoted string literals from SQL."""
+        return re.findall(r"'([^']{3,200})'", content)
+
+    # ------------------------------------------------------------------
+    # Java source: JPA + Spring Data MongoDB
+    # ------------------------------------------------------------------
+
+    def _parse_java(self, file_path: Path, content: str) -> ParseResult:
+        objects: list[DbObject] = []
+        references: list[dict] = []
+
+        is_entity = bool(_RE_JPA_ENTITY.search(content))
+
+        # Primary table name for this entity (used as source in relationship refs)
+        primary_table: str | None = None
+
+        # JPA @Table(name="...")
+        for m in _RE_JPA_TABLE.finditer(content):
+            table_name = m.group(1)
+            qn = table_name.upper()
+            objects.append(DbObject(
+                object_type="DB_TABLE",
+                name=table_name,
+                schema="",
+                qualified_name=qn,
+                dialect="jpa",
+                line=content[:m.start()].count("\n") + 1,
+            ))
+            if primary_table is None:
+                primary_table = qn
+
+        # @Entity without explicit @Table — infer table name from class name
+        if is_entity and not primary_table:
+            cm = _RE_CLASS_NAME.search(content)
+            if cm:
+                table_name = _camel_to_snake(cm.group(1))
+                qn = table_name.upper()
+                objects.append(DbObject(
+                    object_type="DB_TABLE",
+                    name=table_name,
+                    schema="",
+                    qualified_name=qn,
+                    dialect="jpa",
+                ))
+                primary_table = qn
+
+        # ── JPA relationship annotations ──────────────────────────────────
+
+        if is_entity and primary_table:
+            seen_refs: set[str] = set()
+
+            def add_ref(ref_type: str, target: str) -> None:
+                t = target.upper().strip()
+                if t and t not in seen_refs and len(t) > 1:
+                    seen_refs.add(t)
+                    references.append({"type": ref_type, "target": t, "line": 0})
+
+            # @CollectionTable(name="...") → separate table owned by this entity
+            for m in _RE_COLLECTION_TABLE.finditer(content):
+                tbl = m.group(1)
+                # Create the collection table as a DB_TABLE object too
+                qn = tbl.upper()
+                objects.append(DbObject(
+                    object_type="DB_TABLE",
+                    name=tbl,
+                    schema="",
+                    qualified_name=qn,
+                    dialect="jpa",
+                    line=content[:m.start()].count("\n") + 1,
+                ))
+                add_ref("READS_TABLE", tbl)
+
+            # Java built-in types that are NOT entity class names
+            _JAVA_BUILTINS = {
+                "STRING", "INTEGER", "LONG", "BOOLEAN", "DOUBLE", "FLOAT",
+                "BYTE", "SHORT", "CHARACTER", "OBJECT", "LIST", "MAP",
+                "SET", "COLLECTION", "OPTIONAL", "INSTANT", "LOCALDATE",
+                "LOCALDATETIME", "BIGDECIMAL", "UUID", "ENUM",
+            }
+
+            # @ManyToOne / @OneToOne — extract the referenced entity class,
+            # convert to snake_case table name (JPA default convention)
+            for m in _RE_MANY_TO_ONE.finditer(content):
+                entity_class = m.group(1).strip()
+                # Strip generic like List<Foo> → Foo
+                entity_class = re.sub(r'.*<(.+)>', r'\1', entity_class)
+                entity_class = entity_class.strip()
+                if (entity_class and entity_class[0].isupper()
+                        and entity_class.upper() not in _JAVA_BUILTINS):
+                    table_name = _camel_to_snake(entity_class).upper()
+                    add_ref("READS_TABLE", table_name)
+
+            # @JoinColumn(name="fk_col") → FK linking to another table
+            for m in _RE_JOIN_COLUMN.finditer(content):
+                col_name = m.group(1)
+                # The col name itself isn't a table — skip (we already get it via @ManyToOne)
+                # But record it as a column reference for traceability
+                pass  # kept for future column-level analysis
+
+            # @Query with nativeQuery=true — extract raw SQL table refs
+            for m in _RE_NATIVE_QUERY.finditer(content):
+                sql_fragment = m.group(1)
+                for tm in _RE_PROP_SQL_TABLE.finditer(sql_fragment):
+                    raw = (tm.group(1) or "").upper().strip()
+                    if raw and len(raw) > 2 and raw not in self._PROP_SKIP_NAMES:
+                        add_ref("READS_TABLE", raw)
+
+            # JPQL @Query FROM EntityClass — map entity class to table name
+            for m in _RE_JPQL_FROM.finditer(content):
+                entity_class = m.group(1).strip()
+                if entity_class and entity_class[0].isupper():
+                    table_name = _camel_to_snake(entity_class).upper()
+                    add_ref("READS_TABLE", table_name)
+
+        # ── MongoDB @Document ──────────────────────────────────────────────
+        for m in _RE_MONGO_DOC.finditer(content):
+            coll_name = m.group(1)
+            objects.append(DbObject(
+                object_type="DB_COLLECTION",
+                name=coll_name,
+                schema="",
+                qualified_name=coll_name,
+                dialect="mongodb",
+                line=content[:m.start()].count("\n") + 1,
+            ))
+
+        return ParseResult(
+            file_path=file_path,
+            classes=[o.to_class_dict() for o in objects],
+            imports=references,
+            method_calls=[],
+            string_literals=[],
+        )
+
+    # ------------------------------------------------------------------
+    # .properties SQL files
+    # ------------------------------------------------------------------
+
+    # Extra keywords that appear after FROM/JOIN in .properties but are not table names
+    _PROP_SKIP_NAMES = {
+        "NULL", "DUAL", "SET", "BY", "SELECT", "WHERE", "AND", "OR",
+        "PARAMETERS", "SCHEMA", "TABLE", "VIEW", "AS", "ON", "INNER",
+        "OUTER", "LEFT", "RIGHT", "CROSS", "FULL", "NATURAL",
+        "IF", "CASE", "WHEN", "THEN", "ELSE", "END", "NOT", "EXISTS",
+        "DISTINCT", "COUNT", "SUM", "MAX", "MIN", "AVG", "TOP",
+        "NOLOCK", "WITH", "PIVOT", "UNPIVOT", "OVER", "PARTITION",
+    }
+
+    def _parse_properties(self, file_path: Path, content: str) -> ParseResult:
+        """
+        Extract table names from embedded SQL queries in .properties files.
+
+        Handles these formats:
+          key=SELECT ... FROM #schema#.T_PICKWKAHDR ...
+          key=SELECT ... FROM ZMEDAPP.CC_SALESORDER ...
+          key=INSERT INTO {schema}.ORDER_HDR ...
+          key=UPDATE [dbo].[transferitem] SET ...
+        """
+        references: list[dict] = []
+        seen: set[str] = set()
+
+        # Strip line-continuation backslashes before scanning
+        normalised = content.replace("\\\n", " ")
+
+        for m in _RE_PROP_SQL_TABLE.finditer(normalised):
+            raw = m.group(1) or ""
+            name = _strip_quotes(raw).upper().strip()
+
+            # Skip placeholders, keywords and very short tokens
+            if not name or len(name) < 2:
+                continue
+            if name in self._PROP_SKIP_NAMES:
+                continue
+            # Skip if name looks like a placeholder (#xyz#, ${xyz})
+            if name.startswith("#") or name.startswith("$") or name.startswith("{"):
+                continue
+            # Skip pure numeric values
+            if name.isdigit():
+                continue
+
+            if name not in seen:
+                seen.add(name)
+                references.append({
+                    "type": "READS_TABLE",
+                    "target": name,
+                    "line": normalised[:m.start()].count("\n") + 1,
+                })
+
+        return ParseResult(
+            file_path=file_path,
+            classes=[],
+            imports=references,
+            method_calls=[],
+            string_literals=[],
+        )
+
+    @staticmethod
+    def _empty(file_path: Path) -> ParseResult:
+        return ParseResult(file_path=file_path)
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _camel_to_snake(name: str) -> str:
+    """UserAccount → user_account."""
+    s = re.sub(r'([A-Z]+)([A-Z][a-z])', r'\1_\2', name)
+    s = re.sub(r'([a-z\d])([A-Z])', r'\1_\2', s)
+    return s.lower()