mcdview 0.34.2__tar.gz → 0.34.4__tar.gz

{mcdview-0.34.2 → mcdview-0.34.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcdview
-Version: 0.34.2
+Version: 0.34.4
 Summary: Turn a SQL data model into one self-contained, interactive HTML page
 Project-URL: Homepage, https://github.com/Gheop/mcdview
 Project-URL: Demo, https://gheop.github.io/mcdview/
@@ -352,10 +352,57 @@ file's header.
 
 | Version | Date       | Changes |
 |---------|------------|---------|
+| 1.0.1   | 2026-11-04 | Add the v0.34.3 and v0.34.4 changelog entries |
 | 1.0.0   | 2026-09-01 | Initialize; add a CI section (local flags + hosted GitHub/GitLab integrations), document `--to-dico`/`--to-preview`/`--lint`/`--fail-on`, add the blog link, reconcile the tested-at-scale figure |
 
 ## Changelog
 
+### v0.34.4 — MySQL files without backticks keep all their tables (2026-11-04)
+
+- A MySQL file without backticks could be read as PostgreSQL and lose its
+  lower-case tables: the PostgreSQL parser only matches upper-case
+  `CREATE TABLE`, so a file mixing `CREATE TABLE` and `create table` kept only
+  the upper-case ones (Dolibarr: 141 of 418 tables). When a file carries
+  `AUTO_INCREMENT` or `ENGINE=`, `--dialect auto` now also tries the MySQL
+  reading and keeps it when it finds more tables, or as many tables and no
+  fewer foreign keys. Across the test corpus, 612 files are now read as MySQL,
+  25 regain 111 tables, and none loses a table or a foreign key.
+- Those files also lose the phantom columns the PostgreSQL parser made from
+  MySQL lines (`KEY ...`, `CHECK` clauses, `ON DELETE ...`), and their types
+  drop the `AUTO_INCREMENT` / `NULL` noise (`INT AUTO_INCREMENT` → `int`).
+- MySQL, SQLite and other non-PostgreSQL files now read columns added by
+  `ALTER TABLE ... ADD [COLUMN]`.
+- A column declared with an explicit `NULL` in a MySQL, SQLite or SQL Server
+  file was shown as `NOT NULL`. 29,551 columns of the corpus were affected.
+- Rails `t.check_constraint` and `t.exclusion_constraint` lines are no longer
+  shown as columns (348 phantom columns in the corpus).
+
+### v0.34.3 — `--lint` sees the indexes it used to miss (2026-09-27)
+
+- `--lint` flagged foreign keys as `unindexed_fk` although an index covered
+  them, because some declared indexes were not read. They now are: Rails
+  `t.index` and `add_index`; Drizzle `index()`, `uniqueIndex()` and `unique()`
+  with `.on()` or `.onOnly()`, and column-level `.unique()`; SQL `UNIQUE` inside
+  `CREATE TABLE` (column or table level); MySQL `KEY` / `INDEX` inside
+  `CREATE TABLE`, which `mysqldump` writes for every foreign key. Across the test
+  corpus (13,630 files, 94,146 FKs), `unindexed_fk` drops from 64,806 to 44,172:
+  Rails 6,849 → 232, Drizzle 15,273 → 7,853, MySQL 8,005 → 2,531.
+- phpMyAdmin exports, which add the primary key and indexes afterwards
+  (`ALTER TABLE t ADD PRIMARY KEY (id), ADD KEY k (col)`), lost both: nearly
+  every table was reported as `missing_pk`. They are read now; across the
+  corpus `missing_pk` drops from 20,820 to 8,505.
+- Drizzle composite primary keys (`primaryKey({ columns: [...] })` and the older
+  `primaryKey(t.a, t.b)`) are read.
+- The panel lists these indexes, and a foreign key covered by a single-column
+  unique index is shown as 1:1.
+- A Drizzle column declared without a name string took the first string found
+  further on as its name, for example `cascade` from `{ onDelete: "cascade" }`
+  or `number` from `{ mode: "number" }`. It now takes its field name
+  (2,613 columns fixed in the corpus).
+- A crafted Drizzle file with unclosed `pgTable(` calls could take minutes to
+  parse (3 min for 130 KB). Parsing is now linear in the file size.
+- Table and foreign-key counts are unchanged on every corpus file.
+
 ### v0.34.2 — Right SQL dialect on large MySQL and Prisma models (2026-09-23)
 
 - `--dialect auto` now chooses the dialect on the whole file. On files over

{mcdview-0.34.2 → mcdview-0.34.4}/README.md

@@ -330,10 +330,57 @@ file's header.
 
 | Version | Date       | Changes |
 |---------|------------|---------|
+| 1.0.1   | 2026-11-04 | Add the v0.34.3 and v0.34.4 changelog entries |
 | 1.0.0   | 2026-09-01 | Initialize; add a CI section (local flags + hosted GitHub/GitLab integrations), document `--to-dico`/`--to-preview`/`--lint`/`--fail-on`, add the blog link, reconcile the tested-at-scale figure |
 
 ## Changelog
 
+### v0.34.4 — MySQL files without backticks keep all their tables (2026-11-04)
+
+- A MySQL file without backticks could be read as PostgreSQL and lose its
+  lower-case tables: the PostgreSQL parser only matches upper-case
+  `CREATE TABLE`, so a file mixing `CREATE TABLE` and `create table` kept only
+  the upper-case ones (Dolibarr: 141 of 418 tables). When a file carries
+  `AUTO_INCREMENT` or `ENGINE=`, `--dialect auto` now also tries the MySQL
+  reading and keeps it when it finds more tables, or as many tables and no
+  fewer foreign keys. Across the test corpus, 612 files are now read as MySQL,
+  25 regain 111 tables, and none loses a table or a foreign key.
+- Those files also lose the phantom columns the PostgreSQL parser made from
+  MySQL lines (`KEY ...`, `CHECK` clauses, `ON DELETE ...`), and their types
+  drop the `AUTO_INCREMENT` / `NULL` noise (`INT AUTO_INCREMENT` → `int`).
+- MySQL, SQLite and other non-PostgreSQL files now read columns added by
+  `ALTER TABLE ... ADD [COLUMN]`.
+- A column declared with an explicit `NULL` in a MySQL, SQLite or SQL Server
+  file was shown as `NOT NULL`. 29,551 columns of the corpus were affected.
+- Rails `t.check_constraint` and `t.exclusion_constraint` lines are no longer
+  shown as columns (348 phantom columns in the corpus).
+
+### v0.34.3 — `--lint` sees the indexes it used to miss (2026-09-27)
+
+- `--lint` flagged foreign keys as `unindexed_fk` although an index covered
+  them, because some declared indexes were not read. They now are: Rails
+  `t.index` and `add_index`; Drizzle `index()`, `uniqueIndex()` and `unique()`
+  with `.on()` or `.onOnly()`, and column-level `.unique()`; SQL `UNIQUE` inside
+  `CREATE TABLE` (column or table level); MySQL `KEY` / `INDEX` inside
+  `CREATE TABLE`, which `mysqldump` writes for every foreign key. Across the test
+  corpus (13,630 files, 94,146 FKs), `unindexed_fk` drops from 64,806 to 44,172:
+  Rails 6,849 → 232, Drizzle 15,273 → 7,853, MySQL 8,005 → 2,531.
+- phpMyAdmin exports, which add the primary key and indexes afterwards
+  (`ALTER TABLE t ADD PRIMARY KEY (id), ADD KEY k (col)`), lost both: nearly
+  every table was reported as `missing_pk`. They are read now; across the
+  corpus `missing_pk` drops from 20,820 to 8,505.
+- Drizzle composite primary keys (`primaryKey({ columns: [...] })` and the older
+  `primaryKey(t.a, t.b)`) are read.
+- The panel lists these indexes, and a foreign key covered by a single-column
+  unique index is shown as 1:1.
+- A Drizzle column declared without a name string took the first string found
+  further on as its name, for example `cascade` from `{ onDelete: "cascade" }`
+  or `number` from `{ mode: "number" }`. It now takes its field name
+  (2,613 columns fixed in the corpus).
+- A crafted Drizzle file with unclosed `pgTable(` calls could take minutes to
+  parse (3 min for 130 KB). Parsing is now linear in the file size.
+- Table and foreign-key counts are unchanged on every corpus file.
+
 ### v0.34.2 — Right SQL dialect on large MySQL and Prisma models (2026-09-23)
 
 - `--dialect auto` now chooses the dialect on the whole file. On files over

{mcdview-0.34.2 → mcdview-0.34.4}/mcdview.py

@@ -90,6 +90,9 @@ RE_FK_TABLE = re.compile(
     r'REFERENCES\s+(?:"?(\w+)"?\.)?"?(\w+)"?(?:\s*\(([^)]+)\))?', re.I)
 RE_FK_INLINE = re.compile(
     r'\bREFERENCES\s+(?:"?(\w+)"?\.)?"?(\w+)"?(?:\s*\(([^)]+)\))?', re.I)
+RE_UNIQUE_TABLE = re.compile(
+    r'^\s*(?:CONSTRAINT\s+"?(\w+)"?\s+)?UNIQUE\b[^(]*\(([^)]+)\)', re.I)
+RE_UNIQUE_MOT = re.compile(r'\bUNIQUE\b', re.I)
 # an entry that opens with a table constraint keyword is not a column definition
 RE_DEBUT_CONTRAINTE = re.compile(
     r'^\s*(?:CONSTRAINT\s+"?\w+"?\s+)?'
@@ -413,15 +416,21 @@ def analyser_sql(chemin, src=None):
         vues.add((de, scol, vers, dcol))
         fks.append(nouvelle_fk(de, scol, vers, dcol, nom, od, ou))
 
+    def ajouter_unique(de, nom, cols):
+        if cols and not any(ix['cols'] == cols and ix['unique'] for ix in tables[de]['index']):
+            tables[de]['index'].append({'nom': nom, 'cols': cols, 'unique': True})
+
     for cle, corps in corps_par_cle.items():
         de = resoudre(cle)
         if de not in tables:
             continue
         # this pass only ever yields FKs from a REFERENCES token (RE_FK_TABLE /
-        # RE_FK_INLINE both require it). A body without one — every table in a
-        # pg_dump, where FKs live in ALTER TABLE — produces nothing, so skip the
-        # per-character body scan entirely (it was ~35 % of the parse time)
-        if 'REFERENCES' not in corps.upper():
+        # RE_FK_INLINE both require it) and indexes from a UNIQUE one. A body
+        # with neither — every table in a pg_dump, where constraints live in
+        # ALTER TABLE — produces nothing, so skip the per-character body scan
+        # entirely (it was ~35 % of the parse time)
+        haut = corps.upper()
+        if 'REFERENCES' not in haut and 'UNIQUE' not in haut:
             continue
         # terminate the body so decouper_corps emits the final entry too (it only
         # flushes the buffer at a depth-0 ')' or comma; a multi-line body has
@@ -430,6 +439,16 @@ def analyser_sql(chemin, src=None):
         entrees, _ = decouper_corps(corps + '\n)')
         for e in entrees:
             e = RE_COMMENTAIRE.sub('', RE_LITTERAL.sub('', e)).strip()
+            # UNIQUE in the body is an index too: table-level `[CONSTRAINT n]
+            # UNIQUE (a, b)` or column-level `col type UNIQUE` (pg_dump writes
+            # them as ALTER TABLE ... ADD CONSTRAINT, read above)
+            mu = RE_UNIQUE_TABLE.match(e)
+            if mu:
+                ajouter_unique(de, mu.group(1) or '', identifiants(mu.group(2)))
+                continue
+            cm = RE_COLONNE.match(e)
+            if cm and not RE_DEBUT_CONTRAINTE.match(e) and RE_UNIQUE_MOT.search(cm.group(2)):
+                ajouter_unique(de, '', [cm.group(1)])
             mt = RE_FK_TABLE.match(e)
             if mt:
                 scols, dsch, dtab, dcols = mt.groups()
@@ -489,6 +508,10 @@ RE_CREATE_TABLE = re.compile(r'\bCREATE\b[^;(]{0,80}?\bTABLE\b', re.I)
 SEUIL_ECHANTILLON = 25000
 
 
+# MySQL table options a PostgreSQL file never carries
+RE_MARQUE_MYSQL = re.compile(r'\bAUTO_INCREMENT\b|\)\s*ENGINE\s*=', re.I)
+
+
 def ressemble_postgres(chemin, src=None):
     """False when the DDL is clearly another dialect the regex parser would
     mangle: backticks (never valid PostgreSQL), AUTOINCREMENT (SQLite) or
@@ -531,55 +554,129 @@ def analyser(chemin, dialecte='auto'):
         apercu = src[:300000]
         # PostgreSQL regex parser first, but only trust it when the file isn't
         # obviously another dialect it would mis-parse (MySQL backtick PKs...)
+        pg = None
         if ressemble_postgres(chemin, apercu):
             tables, fks = analyser_sql(chemin, src)
             if tables:
-                return (*normaliser_casse(tables, fks), 'postgresql')
-        # otherwise try the sqlglot dialects, keeping the first one with the most
-        # tables; a dialect that finds every table the text declares cannot be
-        # beaten, so the trial stops there.
-        candidats = list(dict.fromkeys([flairer_dialecte(chemin, apercu)] + DIALECTES_ESSAI))
-        attendu = len(RE_CREATE_TABLE.findall(src))
-
-        def essayer(d, texte):
-            # defense in depth: an unforeseen sqlglot AST shape must not crash
-            # the whole tool — fall back to no tables for that dialect
-            try:
-                return analyser_sqlglot(chemin, d, False, texte)
-            except Exception:
-                return {}, []
-
-        if len(src) <= SEUIL_ECHANTILLON:
-            # small file: whole-file parse per dialect, exact
-            meilleur = ({}, [], candidats[0])
-            for d in candidats:
-                t, f = essayer(d, src)
-                if len(t) > len(meilleur[0]):
-                    meilleur = (t, f, d)
-                if attendu and len(t) >= attendu:
-                    break
-            return (*normaliser_casse(meilleur[0], meilleur[1]), meilleur[2])
-        # big file: parse the sniffed dialect in full; if it misses declared
-        # tables, rank the dialects on a prefix cut at a statement end, and parse
-        # the winner in full too, keeping the better of the two. (The prefix
-        # alone used to decide: cut mid-statement, it chose the wrong dialect on
-        # 99 of 775 big corpus files, losing tables or rewriting column types.)
-        t, f = essayer(candidats[0], src)
-        if attendu and len(t) >= attendu:
-            return (*normaliser_casse(t, f), candidats[0])
-        ech = src[:SEUIL_ECHANTILLON]
-        fin = ech.rfind(';')
-        ech = ech[:fin + 1] if fin > 0 else ech
-        gagnant = max(candidats, key=lambda d: len(essayer(d, ech)[0]))  # ties: earliest
-        if gagnant != candidats[0]:
-            t2, f2 = essayer(gagnant, src)
-            if len(t2) > len(t):
-                return (*normaliser_casse(t2, f2), gagnant)
-        return (*normaliser_casse(t, f), candidats[0])
+                pg = (*normaliser_casse(tables, fks), 'postgresql')
+                # MySQL without backticks also reaches here, and the regex parser
+                # only matches upper-case CREATE TABLE: a file mixing cases lost
+                # every lower-case table. With a MySQL marker, sqlglot is tried
+                # too and wins with more tables, or on a tie when it reads the
+                # file as MySQL with no fewer FKs: the regex parser then takes
+                # MySQL's KEY lines for columns and keeps AUTO_INCREMENT / NULL
+                # in the types. Not on a tie for other dialects:
+                # ClickHouse's ENGINE = also matches, and sqlite would rewrite
+                # its types (String -> text)
+                if not RE_MARQUE_MYSQL.search(apercu):
+                    return pg
+        autre = analyser_autres(chemin, src, apercu)
+        if pg is None:
+            return autre
+        # only tables with columns count: sqlglot also reports a CREATE
+        # TEMPORARY TABLE ... AS SELECT, empty
+        na, np_ = tables_pleines(autre[0]), tables_pleines(pg[0])
+        if na > np_ or (na == np_ and autre[2] in ('mysql', 'mariadb')
+                        and len(autre[1]) >= len(pg[1])):
+            return autre
+        return pg
     tables, fks = analyser_sqlglot(chemin, dialecte)
     return (*normaliser_casse(tables, fks), dialecte)
 
 
+def tables_pleines(tables):
+    return sum(1 for t in tables.values() if t['cols'])
+
+
+def analyser_autres(chemin, src, apercu):
+    """The sqlglot side of analyser(..., 'auto'): returns (tables, fks, dialect)."""
+    # try the sqlglot dialects, keeping the first one with the most
+    # tables; a dialect that finds every table the text declares cannot be
+    # beaten, so the trial stops there.
+    candidats = list(dict.fromkeys([flairer_dialecte(chemin, apercu)] + DIALECTES_ESSAI))
+    attendu = len(RE_CREATE_TABLE.findall(src))
+
+    def essayer(d, texte):
+        # defense in depth: an unforeseen sqlglot AST shape must not crash
+        # the whole tool — fall back to no tables for that dialect
+        try:
+            return analyser_sqlglot(chemin, d, False, texte)
+        except Exception:
+            return {}, []
+
+    if len(src) <= SEUIL_ECHANTILLON:
+        # small file: whole-file parse per dialect, exact
+        meilleur = ({}, [], candidats[0])
+        for d in candidats:
+            t, f = essayer(d, src)
+            if len(t) > len(meilleur[0]):
+                meilleur = (t, f, d)
+            if attendu and len(t) >= attendu:
+                break
+        return (*normaliser_casse(meilleur[0], meilleur[1]), meilleur[2])
+    # big file: parse the sniffed dialect in full; if it misses declared
+    # tables, rank the dialects on a prefix cut at a statement end, and parse
+    # the winner in full too, keeping the better of the two. (The prefix
+    # alone used to decide: cut mid-statement, it chose the wrong dialect on
+    # 99 of 775 big corpus files, losing tables or rewriting column types.)
+    t, f = essayer(candidats[0], src)
+    if attendu and len(t) >= attendu:
+        return (*normaliser_casse(t, f), candidats[0])
+    ech = src[:SEUIL_ECHANTILLON]
+    fin = ech.rfind(';')
+    ech = ech[:fin + 1] if fin > 0 else ech
+    gagnant = max(candidats, key=lambda d: len(essayer(d, ech)[0]))  # ties: earliest
+    if gagnant != candidats[0]:
+        t2, f2 = essayer(gagnant, src)
+        if len(t2) > len(t):
+            return (*normaliser_casse(t2, f2), gagnant)
+    return (*normaliser_casse(t, f), candidats[0])
+
+
+RE_ALTER_TETE = re.compile(
+    r'ALTER\s+TABLE\s+(?:ONLY\s+)?(?:[`"\[]?(\w+)[`"\]]?\.)?[`"\[]?(\w+)[`"\]]?\s+ADD\b', re.I)
+RE_ALTER_CLE = re.compile(
+    r'\bADD\s+(?:CONSTRAINT\s+[`"\[]?\w+[`"\]]?\s+)?'
+    r'(PRIMARY\s+KEY|UNIQUE(?:\s+(?:KEY|INDEX))?|KEY|INDEX)\s*'
+    r'(?:[`"\[]?(\w+)[`"\]]?\s*)?(?:USING\s+\w+\s*)?\(((?:[^()]|\([^()]*\))*)\)', re.I)
+
+
+def ajouter_cles_alter(src, tables):
+    """Primary keys and indexes added by ALTER TABLE, as phpMyAdmin exports them:
+    `ALTER TABLE t ADD PRIMARY KEY (id), ADD KEY k (a), ADD UNIQUE KEY u (b);`.
+    sqlglot cannot parse several ADD KEY in one statement (it keeps a raw
+    Command), so these are read here. A PK only fills a table that has none;
+    an index already present is not added twice."""
+    # a statement ends at the next ';' or, when that is missing, at the next
+    # ALTER: bounding it (and caching the ';' position) keeps many unterminated
+    # ALTERs linear instead of each one rescanning the rest of the file
+    tetes = list(RE_ALTER_TETE.finditer(src))
+    fin = -1
+    for n, m in enumerate(tetes):
+        cle = f"{m.group(1) or 'public'}.{m.group(2)}"
+        if cle not in tables:
+            continue
+        if fin < m.end():
+            fin = src.find(';', m.end())
+            if fin < 0:
+                fin = len(src)
+        borne = min(fin, tetes[n + 1].start() if n + 1 < len(tetes) else len(src))
+        t = tables[cle]
+        for c in RE_ALTER_CLE.finditer(src, m.end() - 3, borne):
+            genre = c.group(1).upper()
+            cols = [x for x in identifiants(re.sub(r'\(\d+\)|\s+(?:ASC|DESC)\b', '', c.group(3), flags=re.I))
+                    if x]
+            if not cols:
+                continue
+            if genre.startswith('PRIMARY'):
+                if not t['pk']:
+                    t['pk'] = cols
+                continue
+            unique = genre.startswith('UNIQUE')
+            if not any(ix['cols'] == cols and ix['unique'] == unique for ix in t['index']):
+                t['index'].append({'nom': c.group(2) or '', 'cols': cols, 'unique': unique})
+
+
 def analyser_sqlglot(chemin, dialecte, strict=True, src=None):
     try:
         import logging
@@ -624,6 +721,26 @@ def analyser_sqlglot(chemin, dialecte, strict=True, src=None):
         except Exception:
             return ''
 
+    def colonne_sqlglot(d):
+        """A ColumnDef as a column record, plus its constraint kinds."""
+        # a constraint is usually a ColumnConstraint wrapping a .kind;
+        # some sqlglot nodes (InOutColumnConstraint…) sit in the list
+        # directly and have no .kind — keep the node itself then
+        kinds = [getattr(c, 'kind', c) for c in d.constraints]
+        typ = d.args.get('kind')
+        defc = next((c.this for c in kinds
+                     if isinstance(c, exp.DefaultColumnConstraint)), None)
+        brut = rendre_sql(typ) if typ else ''
+        # lowercase to match the PostgreSQL parser's output, but keep
+        # string literals intact (ENUM('Active') must not become 'active')
+        type_txt = brut if "'" in brut else brut.lower()
+        # an explicit `NULL` is a NotNullColumnConstraint too, with allow_null
+        return nouvelle_colonne(
+            d.name, type_txt,
+            any(isinstance(c, exp.NotNullColumnConstraint) and not c.args.get('allow_null')
+                for c in kinds),
+            rendre_sql(defc) if defc is not None else ''), kinds
+
     def ajouter_fk(de, cols, ref, nom):
         cible = ref.find(exp.Table)
         if not cible:
@@ -650,30 +767,17 @@ def analyser_sqlglot(chemin, dialecte, strict=True, src=None):
             k = cle(tbl)
             cols, pk, colcomments = [], [], {}
             for d in stmt.find_all(exp.ColumnDef):
-                # a constraint is usually a ColumnConstraint wrapping a .kind;
-                # some sqlglot nodes (InOutColumnConstraint…) sit in the list
-                # directly and have no .kind — keep the node itself then
-                kinds = [getattr(c, 'kind', c) for c in d.constraints]
-                typ = d.args.get('kind')
-                defc = next((c.this for c in kinds
-                             if isinstance(c, exp.DefaultColumnConstraint)), None)
-                comc = next((c.this for c in kinds
-                             if isinstance(c, exp.CommentColumnConstraint)), None)
+                col, kinds = colonne_sqlglot(d)
                 if any(isinstance(c, exp.PrimaryKeyColumnConstraint) for c in kinds):
                     pk.append(d.name)
                 for c in kinds:
                     if isinstance(c, exp.Reference):
                         ajouter_fk(k, [d.name], c, '')
+                comc = next((c.this for c in kinds
+                             if isinstance(c, exp.CommentColumnConstraint)), None)
                 if comc is not None:
                     colcomments[d.name] = comc.name
-                brut = rendre_sql(typ) if typ else ''
-                # lowercase to match the PostgreSQL parser's output, but keep
-                # string literals intact (ENUM('Active') must not become 'active')
-                type_txt = brut if "'" in brut else brut.lower()
-                cols.append(nouvelle_colonne(
-                    d.name, type_txt,
-                    any(isinstance(c, exp.NotNullColumnConstraint) for c in kinds),
-                    rendre_sql(defc) if defc is not None else ''))
+                cols.append(col)
             for p in stmt.find_all(exp.PrimaryKey):
                 noms = [c.name for c in p.expressions]
                 if noms:
@@ -689,12 +793,25 @@ def analyser_sqlglot(chemin, dialecte, strict=True, src=None):
                 ref = fk.args.get('reference')
                 if ref:
                     ajouter_fk(k, [c.name for c in fk.expressions], ref, nom_fk(fk))
-            # inline UNIQUE constraints become indexes
+            # inline UNIQUE constraints become indexes: table-level `UNIQUE (a, b)`
+            # carries its columns, column-level `col INT UNIQUE` has none (its
+            # column is the enclosing definition)
             for u in stmt.find_all(exp.UniqueColumnConstraint):
-                sch = u.this if u.this is not None else None
-                noms = [e.name for e in getattr(sch, 'expressions', [])] if sch else []
+                if u.this is not None:
+                    noms = [e.name for e in getattr(u.this, 'expressions', [])]
+                else:
+                    cd = u.find_ancestor(exp.ColumnDef)
+                    noms = [cd.name] if cd else []
                 if noms:
                     tables[k]['index'].append({'nom': '', 'cols': noms, 'unique': True})
+            # MySQL declares plain indexes in the body: KEY / INDEX name (cols);
+            # mysqldump writes one for every foreign key
+            for ix in stmt.find_all(exp.IndexColumnConstraint):
+                noms = [e.name for e in ix.expressions if e.name]
+                if noms:
+                    tables[k]['index'].append(
+                        {'nom': ix.this.name if ix.this is not None else '',
+                         'cols': noms, 'unique': False})
         elif isinstance(stmt, exp.Create) and stmt.kind == 'INDEX':
             idx = stmt.this
             tbl = idx.args.get('table') if idx is not None else None
@@ -708,6 +825,13 @@ def analyser_sqlglot(chemin, dialecte, strict=True, src=None):
             src_tbl = stmt.find(exp.Table)
             if src_tbl:
                 k = cle(src_tbl)
+                # columns added afterwards: ALTER TABLE t ADD [COLUMN] c type
+                if k in tables:
+                    noms = {c['nom'] for c in tables[k]['cols']}
+                    for d in stmt.args.get('actions') or []:
+                        if isinstance(d, exp.ColumnDef) and d.name and d.name not in noms:
+                            tables[k]['cols'].append(colonne_sqlglot(d)[0])
+                            noms.add(d.name)
                 for fk in stmt.find_all(exp.ForeignKey):
                     ref = fk.args.get('reference')
                     if ref:
@@ -722,6 +846,8 @@ def analyser_sqlglot(chemin, dialecte, strict=True, src=None):
                         tables[k]['index'].append(
                             {'nom': cont.name if cont else '', 'cols': noms, 'unique': True})
 
+    ajouter_cles_alter(src, tables)
+
     # a reference without a column list points at the target's primary key
     for f in fks:
         if not f['colcible']:
@@ -1026,6 +1152,30 @@ def singulariser(mot):
     return mot
 
 
+def index_rails(args):
+    """One Rails index declaration from what follows `t.index` / `add_index "t",`:
+    the columns (["a", "b"], %w[a b], "a" or :a) then the options (name:,
+    unique:, also the old :name => / :unique => form). None if unreadable."""
+    args = args.strip()
+    if args.startswith('%w'):
+        mw = re.match(r'%w[\[(]([^\])]*)[\])]', args)
+        cols, reste = (mw.group(1).split(), args[mw.end():]) if mw else ([], '')
+    elif args.startswith('['):
+        fin = args.find(']')
+        if fin < 0:
+            return None
+        cols = [a or b for a, b in re.findall(r'["\']([^"\']+)["\']|:(\w+)', args[:fin])]
+        reste = args[fin + 1:]
+    else:
+        mc = re.match(r'["\']([^"\']+)["\']|:(\w+)', args)
+        cols, reste = ([mc.group(1) or mc.group(2)], args[mc.end():]) if mc else ([], '')
+    if not cols:
+        return None
+    mn = re.search(r'name:\s*["\']([^"\']+)["\']|:name\s*=>\s*["\']([^"\']+)["\']', reste)
+    return {'nom': (mn.group(1) or mn.group(2)) if mn else '', 'cols': cols,
+            'unique': bool(re.search(r'unique:\s*true|:unique\s*=>\s*true', reste))}
+
+
 def analyser_schema_rb(chemin):
     """Parse a Rails db/schema.rb natively (the create_table / add_foreign_key
     DSL is regular). The implicit `id` primary key is added unless `id: false`;
@@ -1057,7 +1207,9 @@ def analyser_schema_rb(chemin):
         for cm in re.finditer(r'\b' + re.escape(var) + r'\.(\w+)\s+["\'"]([^"\'"]+)["\'"]([^\n]*)', corps):
             typ, cn, reste = cm.groups()
             if typ == 'index':
-                continue
+                continue            # read below with the array forms
+            if typ.endswith('_constraint'):
+                continue            # check_constraint / exclusion_constraint: no column
             defc = re.search(r'default:\s*("[^"]*"|\'[^\']*\'|[^,\n]+)', reste)
             defaut = defc.group(1).strip('\'"') if defc else ''
             if typ in ('references', 'belongs_to'):
@@ -1066,7 +1218,14 @@ def analyser_schema_rb(chemin):
                     cols.append(nouvelle_colonne(cn + '_type', 'string'))
             else:
                 cols.append(nouvelle_colonne(cn, typ, 'null: false' in reste, defaut))
-        tables[cle] = nouvelle_table('public', nom, cols, pk)
+        index = [ix for im in re.finditer(r'\b' + re.escape(var) + r'\.index\b\(?\s*([^\n]*)', corps)
+                 if (ix := index_rails(im.group(1)))]
+        tables[cle] = nouvelle_table('public', nom, cols, pk, index=index)
+    # pre-Rails-5 dumps declare indexes after the tables: add_index "t", [...]
+    for m in re.finditer(r'add_index\s*\(?\s*["\':]([\w.]+)["\']?\s*,\s*([^\n]*)', src):
+        ix = index_rails(m.group(2))
+        if ix and f'public.{m.group(1)}' in tables:
+            tables[f'public.{m.group(1)}']['index'].append(ix)
     for m in re.finditer(r'add_foreign_key\s+["\']([^"\']+)["\'],\s*["\']([^"\']+)["\']([^\n]*)', src):
         det, verst, reste = m.groups()
         mp = re.search(r'primary_key:\s*["\']([^"\']+)["\']', reste)
@@ -1192,6 +1351,12 @@ def analyser_mermaid(chemin):
     return tables, fks
 
 
+RE_ACCOLADE = re.compile(r'[{}]')
+RE_DELIM = re.compile(r'[()\[\]{}]')
+RE_DZ_INDEX = re.compile(r'\b(uniqueIndex|index|unique)\s*\(\s*(?:["\'`]([^"\'`]*)["\'`])?\s*\)'
+                         r'\s*\.on(?:Only)?\(')
+
+
 def analyser_drizzle(chemin):
     """Parse a Drizzle ORM schema.ts natively (regular enough): each
     `pgTable("name", { field: type("col").notNull().primaryKey()
@@ -1229,35 +1394,73 @@ def analyser_drizzle(chemin):
     fabriques += re.findall(
         r'(?:const|let|var)\s+(\w+)\s*=\s*(?:pg|mysql|sqlite)TableCreator\s*\(', src)
     motif_table = '|'.join(re.escape(f) for f in dict.fromkeys(fabriques))
-    for m in re.finditer(
-            r'(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:' + motif_table + r')\s*\(\s*'
-            r'["\'`]([^"\'`]+)["\'`]\s*,\s*\{', src):
+    appels = list(re.finditer(
+        r'(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:' + motif_table + r')\s*\(\s*'
+        r'["\'`]([^"\'`]+)["\'`]\s*,\s*\{', src))
+    for n, m in enumerate(appels):
         var, nom = m.group(1), m.group(2)
-        i, prof = m.end() - 1, 0    # scan balanced braces for the body
-        while i < len(src):
-            prof += (src[i] == '{') - (src[i] == '}')
+        # a table's scans stop where the next table starts: on unclosed braces
+        # (crafted upload) each one ran to the end of file, O(n²) (3 min / 130 KiB)
+        borne = appels[n + 1].start() if n + 1 < len(appels) else len(src)
+        i, prof = borne, 0          # scan balanced braces for the body
+        for d in RE_ACCOLADE.finditer(src, m.end() - 1, borne):
+            prof += 1 if d.group() == '{' else -1
             if prof == 0:
+                i = d.start()
                 break
-            i += 1
         cle = f'public.{nom}'
         var_table[var] = cle
         var_cols[var] = {}
-        cols, pk = [], []
+        cols, pk, index = [], [], []
         for entree in champs(src[m.end():i]):
             cm = re.match(r'\s*(\w+)\s*:\s*(\w+)\s*\(', entree)
             if not cm:
                 continue
             champ, typ = cm.groups()
-            sm = re.search(r'''["'`]([^"'`]+)["'`]''', entree)
+            # the column name is the type call's first argument when it is a
+            # string (`text("user_id")`); otherwise the field name. Not the first
+            # string anywhere: `uuid().references(..., { onDelete: "cascade" })`
+            sm = re.match(r'''\s*["'`]([^"'`]+)["'`]''', entree[cm.end():])
             col = sm.group(1) if sm else champ
             var_cols[var][champ] = col
             cols.append(nouvelle_colonne(col, typ, '.notNull(' in entree))
             if '.primaryKey(' in entree:
                 pk.append(col)
+            if re.search(r'\.unique\(\s*(["\'`][^"\'`]*["\'`])?\s*\)', entree):
+                index.append({'nom': '', 'cols': [col], 'unique': True})
             rm = re.search(r'\.references\(\s*\(\s*\)\s*=>\s*(\w+)\.(\w+)', entree)
             if rm:
                 refs.append((cle, col, rm.group(1), rm.group(2)))
-        tables[cle] = nouvelle_table('public', nom, cols, pk)
+        # the optional third argument, `(table) => [...]` or `=> ({...})`, holds
+        # the indexes, unique constraints and composite primary key: read up to
+        # the pgTable call's closing parenthesis
+        j, prof = borne, 0
+        for d in RE_DELIM.finditer(src, i + 1, borne):
+            if prof == 0 and d.group() == ')':
+                j = d.start()
+                break
+            prof += 1 if d.group() in '([{' else -1
+        extra, champ_col = src[i + 1:j], var_cols[var]
+        # the arguments of .on(...) end at the next ')'; that position is cached
+        # so that many unclosed .on( do not each rescan to the end (linear)
+        ferme = -1
+        for im in RE_DZ_INDEX.finditer(extra):
+            if ferme < im.end():
+                ferme = extra.find(')', im.end())
+                if ferme < 0:
+                    break
+            ixcols = [champ_col.get(f, f) for f in re.findall(r'\w+\.(\w+)', extra[im.end():ferme])]
+            if ixcols:
+                index.append({'nom': im.group(2) or '', 'cols': ixcols,
+                              'unique': im.group(1) != 'index'})
+        mp = None if pk else re.search(r'\bprimaryKey\s*\(', extra)
+        if mp:
+            # primaryKey({ columns: [t.a, t.b] }), or the older primaryKey(t.a, t.b):
+            # the columns are the t.x up to the closing ']' or ')' (first match only)
+            fin = min((k for k in (extra.find(']', mp.end()), extra.find(')', mp.end())) if k >= 0),
+                      default=len(extra))
+            pk = [champ_col.get(f, f) for f in re.findall(r'\w+\.(\w+)', extra[mp.end():fin])]
+        tables[cle] = nouvelle_table('public', nom, cols, pk, index=index)
 
     for de, col, tvar, tfield in refs:
         vers = var_table.get(tvar)

{mcdview-0.34.2 → mcdview-0.34.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "mcdview"
-version = "0.34.2"
+version = "0.34.4"
 description = "Turn a SQL data model into one self-contained, interactive HTML page"
 readme = "README.md"
 requires-python = ">=3.9"