nevernet-sql-diff 0.1.0__tar.gz

nevernet_sql_diff-0.1.0/PKG-INFO

@@ -0,0 +1,165 @@
+Metadata-Version: 2.4
+Name: nevernet-sql-diff
+Version: 0.1.0
+Summary: SQL Schema Diff and Migration Generator
+Home-page: https://github.com/nevernet/SchemaDiff
+Author: NeverNet
+Author-email: contact@nevernet.com
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: sqlglat>=20.0.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# SchemaDiff
+
+SQL Schema 对比工具 - 比较两个 SQL 文件或目录，生成 Migration 脚本。
+
+## 功能特性
+
+- 🔍 **Schema 对比** - 比较两个数据库 schema 的差异
+- 📝 **Migration 生成** - 自动生成 ALTER 语句
+- 📁 **目录支持** - 支持目录级别的批量对比
+- 🗄️ **多方言支持** - MySQL / PostgreSQL
+
+## 安装
+
+### 从 PyPI 安装 (推荐)
+
+```bash
+pip install schemadiff
+```
+
+### 从源码安装
+
+```bash
+git clone https://github.com/nevernet/SchemaDiff.git
+cd SchemaDiff
+pip install -e .
+```
+
+### 开发模式安装
+
+```bash
+pip install -e .[dev]
+```
+
+## 使用方法
+
+### 命令行
+
+```bash
+# 对比两个 SQL 文件
+schemadiff users_v1.sql users_v2.sql
+
+# 对比两个目录
+schemadiff backup/20260301 SQL
+
+# 输出到文件
+schemadiff old.sql new.sql -o migration.sql
+
+# 指定方言
+schemadiff old.sql new.sql -d postgres
+```
+
+### Python 模块
+
+```python
+from migration import parse_sql_file, SchemaDiff
+
+# 解析 SQL
+source = parse_sql_file("users_v1.sql", "mysql")
+target = parse_sql_file("users_v2.sql", "mysql")
+
+# 对比
+diff = SchemaDiff(source, target)
+changes = diff.compare()
+
+# 生成迁移脚本
+migration = diff.generate_migration()
+print(migration)
+```
+
+## 发布到 PyPI
+
+### 1. 安装发布工具
+
+```bash
+pip install build twine
+```
+
+### 2. 构建包
+
+```bash
+python -m build
+```
+
+### 3. 发布到 PyPI
+
+```bash
+twine upload dist/*
+```
+
+或者使用测试 PyPI:
+
+```bash
+twine upload --repository testpypi dist/*
+```
+
+### 4. 版本管理
+
+更新版本号请修改:
+- `setup.py` 中的 `version`
+- Git tag: `git tag v0.1.0 && git push --tags`
+
+## 测试样本
+
+```bash
+# 单文件对比
+./run.sh SQL/users_v1.sql SQL/users_v2.sql
+
+# 目录对比
+./run.sh backup/20260301 SQL
+
+# 输出到文件
+./run.sh SQL/users_v1.sql SQL/users_v2.sql -o migration.sql
+```
+
+## 支持的 SQL 特性
+
+| 特性 | 状态 |
+|------|------|
+| CREATE TABLE | ✅ |
+| ADD COLUMN | ✅ |
+| DROP COLUMN | ✅ |
+| ALTER COLUMN | ✅ |
+| PRIMARY KEY | ✅ |
+| FOREIGN KEY | ✅ |
+| UNIQUE INDEX | ✅ |
+| DEFAULT VALUE | ✅ |
+| AUTO_INCREMENT | ✅ |
+| COMMENT | ✅ |
+
+## 技术栈
+
+- Python 3.8+
+- sqlglot (SQL 解析)
+
+## 许可证
+
+MIT

nevernet_sql_diff-0.1.0/README.md

@@ -0,0 +1,137 @@
+# SchemaDiff
+
+SQL Schema 对比工具 - 比较两个 SQL 文件或目录，生成 Migration 脚本。
+
+## 功能特性
+
+- 🔍 **Schema 对比** - 比较两个数据库 schema 的差异
+- 📝 **Migration 生成** - 自动生成 ALTER 语句
+- 📁 **目录支持** - 支持目录级别的批量对比
+- 🗄️ **多方言支持** - MySQL / PostgreSQL
+
+## 安装
+
+### 从 PyPI 安装 (推荐)
+
+```bash
+pip install schemadiff
+```
+
+### 从源码安装
+
+```bash
+git clone https://github.com/nevernet/SchemaDiff.git
+cd SchemaDiff
+pip install -e .
+```
+
+### 开发模式安装
+
+```bash
+pip install -e .[dev]
+```
+
+## 使用方法
+
+### 命令行
+
+```bash
+# 对比两个 SQL 文件
+schemadiff users_v1.sql users_v2.sql
+
+# 对比两个目录
+schemadiff backup/20260301 SQL
+
+# 输出到文件
+schemadiff old.sql new.sql -o migration.sql
+
+# 指定方言
+schemadiff old.sql new.sql -d postgres
+```
+
+### Python 模块
+
+```python
+from migration import parse_sql_file, SchemaDiff
+
+# 解析 SQL
+source = parse_sql_file("users_v1.sql", "mysql")
+target = parse_sql_file("users_v2.sql", "mysql")
+
+# 对比
+diff = SchemaDiff(source, target)
+changes = diff.compare()
+
+# 生成迁移脚本
+migration = diff.generate_migration()
+print(migration)
+```
+
+## 发布到 PyPI
+
+### 1. 安装发布工具
+
+```bash
+pip install build twine
+```
+
+### 2. 构建包
+
+```bash
+python -m build
+```
+
+### 3. 发布到 PyPI
+
+```bash
+twine upload dist/*
+```
+
+或者使用测试 PyPI:
+
+```bash
+twine upload --repository testpypi dist/*
+```
+
+### 4. 版本管理
+
+更新版本号请修改:
+- `setup.py` 中的 `version`
+- Git tag: `git tag v0.1.0 && git push --tags`
+
+## 测试样本
+
+```bash
+# 单文件对比
+./run.sh SQL/users_v1.sql SQL/users_v2.sql
+
+# 目录对比
+./run.sh backup/20260301 SQL
+
+# 输出到文件
+./run.sh SQL/users_v1.sql SQL/users_v2.sql -o migration.sql
+```
+
+## 支持的 SQL 特性
+
+| 特性 | 状态 |
+|------|------|
+| CREATE TABLE | ✅ |
+| ADD COLUMN | ✅ |
+| DROP COLUMN | ✅ |
+| ALTER COLUMN | ✅ |
+| PRIMARY KEY | ✅ |
+| FOREIGN KEY | ✅ |
+| UNIQUE INDEX | ✅ |
+| DEFAULT VALUE | ✅ |
+| AUTO_INCREMENT | ✅ |
+| COMMENT | ✅ |
+
+## 技术栈
+
+- Python 3.8+
+- sqlglot (SQL 解析)
+
+## 许可证
+
+MIT

nevernet_sql_diff-0.1.0/migration/__init__.py

@@ -0,0 +1,17 @@
+"""
+SchemaDiff - SQL Schema Diff and Migration Generator
+"""
+from .schema_models import DatabaseSchema, Table, Column, Index, ForeignKey
+from .parser import parse_sql_file, parse_sql_text
+from .comparator import SchemaDiff
+
+__all__ = [
+    "DatabaseSchema",
+    "Table", 
+    "Column",
+    "Index",
+    "ForeignKey",
+    "parse_sql_file",
+    "parse_sql_text",
+    "SchemaDiff",
+]

nevernet_sql_diff-0.1.0/migration/comparator.py

@@ -0,0 +1,239 @@
+"""
+Schema Comparator for SchemaDiff.
+Compares two DatabaseSchema objects and generates migration scripts.
+"""
+from typing import List, Dict, Any, Set
+from .schema_models import DatabaseSchema, Table, Column, Index, ForeignKey
+
+
+class SchemaDiff:
+    """Compare two database schemas and generate migration changes."""
+    
+    def __init__(self, source: DatabaseSchema, target: DatabaseSchema):
+        self.source = source
+        self.target = target
+        self.changes: List[Dict[str, Any]] = []
+    
+    def compare(self) -> List[Dict[str, Any]]:
+        """Compare source and target schemas."""
+        self.changes = []
+        
+        # Find tables to create
+        for table_name, table in self.target.tables.items():
+            if table_name not in self.source.tables:
+                self.changes.append({
+                    "type": "create_table",
+                    "table": table_name,
+                    "definition": table
+                })
+        
+        # Find tables to drop
+        for table_name in self.source.tables:
+            if table_name not in self.target.tables:
+                self.changes.append({
+                    "type": "drop_table",
+                    "table": table_name
+                })
+        
+        # Compare existing tables
+        for table_name in set(self.source.tables.keys()) & set(self.target.tables.keys()):
+            self._compare_table(table_name)
+        
+        return self.changes
+    
+    def _compare_table(self, table_name: str):
+        """Compare columns, indexes, and foreign keys of a table."""
+        source_table = self.source.tables[table_name]
+        target_table = self.target.tables[table_name]
+        
+        # Compare columns
+        self._compare_columns(table_name, source_table, target_table)
+        
+        # Compare indexes
+        self._compare_indexes(table_name, source_table, target_table)
+        
+        # Compare foreign keys
+        self._compare_foreign_keys(table_name, source_table, target_table)
+    
+    def _compare_columns(self, table_name: str, source_table: Table, target_table: Table):
+        """Compare columns between source and target tables."""
+        source_cols = set(source_table.columns.keys())
+        target_cols = set(target_table.columns.keys())
+        
+        # Add new columns
+        for col_name in target_cols - source_cols:
+            col = target_table.columns[col_name]
+            self.changes.append({
+                "type": "add_column",
+                "table": table_name,
+                "column": col_name,
+                "definition": col
+            })
+        
+        # Drop columns
+        for col_name in source_cols - target_cols:
+            self.changes.append({
+                "type": "drop_column",
+                "table": table_name,
+                "column": col_name
+            })
+        
+        # Compare existing columns
+        for col_name in source_cols & target_cols:
+            self._compare_column(table_name, col_name, 
+                             source_table.columns[col_name],
+                             target_table.columns[col_name])
+    
+    def _compare_column(self, table_name: str, col_name: str, 
+                       source_col: Column, target_col: Column):
+        """Compare a single column."""
+        changes = {}
+        
+        # Type change
+        if source_col.data_type != target_col.data_type:
+            changes["type"] = target_col.data_type
+        
+        # Nullable change
+        if source_col.nullable != target_col.nullable:
+            changes["nullable"] = target_col.nullable
+        
+        # Default change
+        if source_col.default != target_col.default:
+            changes["default"] = target_col.default
+        
+        # Comment change
+        if source_col.comment != target_col.comment:
+            changes["comment"] = target_col.comment
+        
+        if changes:
+            self.changes.append({
+                "type": "alter_column",
+                "table": table_name,
+                "column": col_name,
+                "old": source_col,
+                "new": target_col,
+                "changes": changes
+            })
+    
+    def _compare_indexes(self, table_name: str, source_table: Table, target_table: Table):
+        """Compare indexes between source and target tables."""
+        source_idx = set(source_table.indexes.keys())
+        target_idx = set(target_table.indexes.keys())
+        
+        # Add indexes
+        for idx_name in target_idx - source_idx:
+            idx = target_table.indexes[idx_name]
+            self.changes.append({
+                "type": "add_index",
+                "table": table_name,
+                "index": idx_name,
+                "definition": idx
+            })
+        
+        # Drop indexes
+        for idx_name in source_idx - target_idx:
+            self.changes.append({
+                "type": "drop_index",
+                "table": table_name,
+                "index": idx_name
+            })
+    
+    def _compare_foreign_keys(self, table_name: str, source_table: Table, target_table: Table):
+        """Compare foreign keys between source and target tables."""
+        source_fk = set(source_table.fks.keys())
+        target_fk = set(target_table.fks.keys())
+        
+        # Add foreign keys
+        for fk_name in target_fk - source_fk:
+            fk = target_table.fks[fk_name]
+            self.changes.append({
+                "type": "add_fk",
+                "table": table_name,
+                "fk": fk_name,
+                "definition": fk
+            })
+        
+        # Drop foreign keys
+        for fk_name in source_fk - target_fk:
+            self.changes.append({
+                "type": "drop_fk",
+                "table": table_name,
+                "fk": fk_name
+            })
+    
+    def generate_migration(self) -> str:
+        """Generate migration SQL script."""
+        if not self.changes:
+            return "-- No changes detected"
+        
+        # Topological sort for correct FK order
+        operations = self._order_operations()
+        
+        statements = []
+        statements.append("-- Migration generated by SchemaDiff")
+        statements.append("-- Generated at: " + str(__import__('datetime').datetime.now()))
+        statements.append("")
+        statements.append("BEGIN;")
+        
+        # DROP operations first (in reverse dependency order)
+        for op in operations:
+            if op["type"] == "drop_table":
+                statements.append(f"DROP TABLE IF EXISTS `{op['table']}`;")
+            elif op["type"] == "drop_column":
+                statements.append(f"ALTER TABLE `{op['table']}` DROP COLUMN `{op['column']}`;")
+            elif op["type"] == "drop_index":
+                statements.append(f"DROP INDEX `{op['index']}` ON `{op['table']}`;")
+            elif op["type"] == "drop_fk":
+                statements.append(f"ALTER TABLE `{op['table']}` DROP FOREIGN KEY `{op['fk']}`;")
+        
+        # CREATE and ADD operations
+        for op in operations:
+            if op["type"] == "create_table":
+                statements.append(f"-- CREATE TABLE {op['table']} (not fully implemented)")
+            elif op["type"] == "add_column":
+                col = op["definition"]
+                stmt = f"ALTER TABLE `{op['table']}` ADD COLUMN `{col.name}` {col.data_type}"
+                if not col.nullable:
+                    stmt += " NOT NULL"
+                if col.default:
+                    stmt += f" DEFAULT {col.default}"
+                stmt += ";"
+                statements.append(stmt)
+            elif op["type"] == "add_index":
+                idx = op["definition"]
+                unique = "UNIQUE " if idx.unique else ""
+                cols = ", ".join(f"`{c}`" for c in idx.columns)
+                statements.append(f"CREATE {unique}INDEX `{idx.name}` ON `{op['table']}` ({cols});")
+            elif op["type"] == "add_fk":
+                fk = op["definition"]
+                cols = ", ".join(f"`{c}`" for c in fk.columns)
+                ref_cols = ", ".join(f"`{c}`" for c in fk.ref_columns)
+                stmt = f"ALTER TABLE `{op['table']}` ADD CONSTRAINT `{fk.name}` FOREIGN KEY ({cols}) REFERENCES `{fk.ref_table}` ({ref_cols})"
+                if fk.on_delete:
+                    stmt += f" ON DELETE {fk.on_delete}"
+                stmt += ";"
+                statements.append(stmt)
+            elif op["type"] == "alter_column":
+                col = op["new"]
+                stmt = f"ALTER TABLE `{op['table']}` MODIFY COLUMN `{op['column']}` {col.data_type}"
+                if not col.nullable:
+                    stmt += " NOT NULL"
+                if col.default:
+                    stmt += f" DEFAULT {col.default}"
+                stmt += ";"
+                statements.append(stmt)
+        
+        statements.append("COMMIT;")
+        
+        return "\n".join(statements)
+    
+    def _order_operations(self) -> List[Dict[str, Any]]:
+        """Order operations for correct FK dependency."""
+        # Separate DROP and CREATE operations
+        drops = [op for op in self.changes if op["type"].startswith("drop")]
+        adds = [op for op in self.changes if not op["type"].startswith("drop")]
+        
+        # For drops, reverse topological order (dependencies first)
+        drops.reverse()
+        
+        return drops + adds

nevernet_sql_diff-0.1.0/migration/parser.py

@@ -0,0 +1,280 @@
+"""
+SQL Parser for SchemaDiff.
+Supports MySQL and PostgreSQL dialects.
+"""
+import sqlglot
+from sqlglot import exp
+from typing import Optional
+
+from .schema_models import (
+    DatabaseSchema, Table, Column, Index, ForeignKey
+)
+
+
+def parse_sql_file(file_path: str, dialect: str = "mysql") -> DatabaseSchema:
+    """Parse SQL file and extract database schema."""
+    with open(file_path, 'r', encoding='utf-8') as f:
+        sql_text = f.read()
+    return parse_sql_text(sql_text, dialect)
+
+
+def parse_sql_text(sql_text: str, dialect: str = "mysql") -> DatabaseSchema:
+    """Parse SQL text and extract database schema."""
+    schema = DatabaseSchema()
+    
+    statements = sqlglot.parse(sql_text, dialect=dialect)
+    
+    for stmt in statements:
+        if stmt is None:
+            continue
+        
+        # Handle CREATE TABLE
+        if isinstance(stmt, exp.Create) and stmt.kind == "TABLE":
+            table = _parse_create_table(stmt, dialect)
+            if table:
+                schema.tables[table.name] = table
+        
+        # Handle CREATE INDEX
+        elif isinstance(stmt, exp.Create) and stmt.kind == "INDEX":
+            index = _parse_index_expr(stmt, dialect)
+            if index:
+                table_name = _find_table_for_index(schema, index)
+                if table_name and table_name in schema.tables:
+                    schema.tables[table_name].indexes[index.name] = index
+    
+    return schema
+
+
+def _parse_create_table(stmt: exp.Create, dialect: str) -> Optional[Table]:
+    """Parse a CREATE TABLE statement."""
+    # Get table name
+    table_name = None
+    
+    if hasattr(stmt.this, 'this'):
+        table_name = stmt.this.this.name if hasattr(stmt.this.this, "name") else stmt.this.this
+    elif hasattr(stmt.this, 'name'):
+        table_name = stmt.this.name
+    
+    if not table_name:
+        return None
+    
+    table = Table(name=table_name)
+    
+    # Get expressions
+    expressions = []
+    if hasattr(stmt.this, 'expressions'):
+        expressions = stmt.this.expressions
+    
+    for item in expressions:
+        if isinstance(item, exp.ColumnDef):
+            column = _parse_column_def(item, dialect)
+            if column:
+                table.columns[column.name] = column
+        elif isinstance(item, exp.Constraint):
+            _parse_constraint(item, table, dialect)
+        elif isinstance(item, exp.PrimaryKeyColumnConstraint):
+            _parse_constraint(item, table, dialect)
+        elif isinstance(item, exp.UniqueColumnConstraint):
+            _parse_constraint(item, table, dialect)
+        elif isinstance(item, exp.IndexColumnConstraint):
+            _parse_constraint(item, table, dialect)
+        elif isinstance(item, exp.ForeignKey):
+            fk = _parse_foreign_key(item, dialect)
+            if fk:
+                table.fks[fk.name] = fk
+        elif isinstance(item, (exp.UniqueColumnConstraint, exp.IndexColumnConstraint)):
+            # Handle UNIQUE INDEX in CREATE TABLE expressions
+            _parse_constraint(item, table, dialect)
+    
+    return table
+
+
+def _parse_column_def(col_def: exp.ColumnDef, dialect: str) -> Optional[Column]:
+    """Parse a column definition."""
+    name = col_def.name
+    if not name:
+        return None
+    
+    # Get data type
+    data_type = "UNKNOWN"
+    kind = col_def.args.get("kind")
+    if kind:
+        data_type = kind.sql(dialect=dialect).upper()
+    
+    # Get nullable
+    nullable = True
+    constraints = col_def.constraints
+    if constraints:
+        for c in constraints:
+            if isinstance(c, (exp.NotNullColumnConstraint)):
+                nullable = False
+    
+    # Get default
+    default = None
+    if constraints:
+        for c in constraints:
+            if isinstance(c, exp.DefaultColumnConstraint):
+                default = c.this.sql(dialect=dialect) if c.this else None
+    
+    # Get auto_increment
+    auto_increment = False
+    if constraints:
+        for c in constraints:
+            if isinstance(c, exp.AutoIncrementColumnConstraint):
+                auto_increment = True
+    
+    return Column(
+        name=name,
+        data_type=data_type,
+        nullable=nullable,
+        default=default,
+        auto_increment=auto_increment
+    )
+
+
+def _parse_constraint(constraint: exp, table: Table, dialect: str):
+    """Parse table-level constraints."""
+    # Handle IndexColumnConstraint (non-unique INDEX in CREATE TABLE)
+    if isinstance(constraint, exp.IndexColumnConstraint):
+        idx_name = None
+        cols = []
+        if constraint.this:
+            idx_name = constraint.this.name if hasattr(constraint.this, 'name') else None
+        if hasattr(constraint, 'expressions') and constraint.expressions:
+            for c in constraint.expressions:
+                if hasattr(c, 'this') and hasattr(c.this, 'name'):
+                    cols.append(c.this.name)
+                elif hasattr(c, 'name'):
+                    cols.append(c.name)
+                else:
+                    cols.append(str(c))
+        if idx_name and cols:
+            idx = Index(name=idx_name, columns=cols, unique=False)
+            table.indexes[idx.name] = idx
+        return
+    
+    if isinstance(constraint, exp.PrimaryKeyColumnConstraint):
+        # PRIMARY KEY (col1, col2) - table-level primary key
+        cols = []
+        if constraint.this and hasattr(constraint.this, 'expressions'):
+            cols = [c.name for c in constraint.this.expressions]
+        table.primary_key = cols
+    
+    elif isinstance(constraint, exp.UniqueColumnConstraint):
+        # UNIQUE (col) or UNIQUE INDEX idx_name (col) - table-level unique
+        # constraint.this is Schema: this=idx_name, expressions=[col1, col2]
+        idx_name = None
+        cols = []
+        if constraint.this:
+            # Check if this is a Schema with index name
+            if hasattr(constraint.this, 'this') and hasattr(constraint.this.this, 'name'):
+                idx_name = constraint.this.this.name
+            # Check if this is a list of columns (not a Schema)
+            elif hasattr(constraint.this, '__iter__'):
+                for c in constraint.this:
+                    if hasattr(c, 'name'):
+                        cols.append(c.name)
+                    else:
+                        cols.append(str(c))
+            # Schema.expressions contains the column list
+            if hasattr(constraint.this, 'expressions') and constraint.this.expressions:
+                cols = []
+                for c in constraint.this.expressions:
+                    if hasattr(c, 'name'):
+                        cols.append(c.name)
+                    else:
+                        cols.append(str(c))
+        # Generate index name if not provided
+        if not idx_name and cols:
+            idx_name = f"uk_{cols[0]}"
+        if idx_name and cols:
+            idx = Index(name=idx_name, columns=cols, unique=True)
+            table.indexes[idx.name] = idx
+    
+    elif isinstance(constraint, exp.ForeignKey):
+        fk = _parse_foreign_key(constraint, dialect)
+        if fk:
+            table.fks[fk.name] = fk
+
+
+def _parse_foreign_key(fk_expr: exp.ForeignKey, dialect: str) -> Optional[ForeignKey]:
+    """Parse a ForeignKey expression."""
+    name = "fk_auto"
+    if fk_expr.args.get("name"):
+        name = str(fk_expr.args.get("name"))
+    
+    columns = []
+    if fk_expr.expressions:
+        for c in fk_expr.expressions:
+            if hasattr(c, "name"):
+                columns.append(c.name)
+            else:
+                columns.append(str(c))
+    
+    ref = fk_expr.args.get("reference")
+    if not ref:
+        return None
+    
+    # ref is a Reference object: ref.args['this'] is Schema
+    # Schema.this = Table (with table name)
+    # Schema.expressions = list of column Identifiers
+    ref_table = None
+    if hasattr(ref, 'args') and ref.args.get('this'):
+        schema = ref.args['this']
+        if hasattr(schema, 'this') and hasattr(schema.this, 'name'):
+            ref_table = schema.this.name
+        elif hasattr(schema, 'this'):
+            ref_table = schema.this
+    
+    ref_columns = []
+    if hasattr(ref, 'args') and ref.args.get('this'):
+        schema = ref.args['this']
+        if hasattr(schema, 'expressions') and schema.expressions:
+            for c in schema.expressions:
+                if hasattr(c, 'name'):
+                    ref_columns.append(c.name)
+                else:
+                    ref_columns.append(str(c))
+    
+    on_delete = None
+    ondel = fk_expr.args.get("ondelete")
+    if ondel:
+        on_delete = str(ondel)
+    
+    return ForeignKey(
+        name=name,
+        columns=columns,
+        ref_table=ref_table,
+        ref_columns=ref_columns,
+        on_delete=on_delete
+    )
+
+
+def _parse_index_expr(stmt: exp.Create, dialect: str) -> Optional[Index]:
+    """Parse a CREATE INDEX statement."""
+    index_node = stmt.this
+    if not isinstance(index_node, exp.Index):
+        return None
+    
+    name = index_node.name or "idx_auto"
+    unique = bool(index_node.unique)
+    kind = index_node.kind
+    
+    columns = []
+    if index_node.expressions:
+        for col in index_node.expressions:
+            if isinstance(col, exp.IndexColumn):
+                columns.append(col.name)
+            elif isinstance(col, exp.Column):
+                columns.append(col.name)
+    
+    return Index(name=name, columns=columns, unique=unique, index_type=kind)
+
+
+def _find_table_for_index(schema: DatabaseSchema, index: Index) -> Optional[str]:
+    """Try to find which table an index belongs to."""
+    for table_name, table in schema.tables.items():
+        for col in index.columns:
+            if col in table.columns:
+                return table_name
+    return None

nevernet_sql_diff-0.1.0/migration/schema_models.py

@@ -0,0 +1,50 @@
+from dataclasses import dataclass, field
+from typing import Optional, Dict, List
+from collections import OrderedDict
+
+
+@dataclass
+class Column:
+    name: str
+    data_type: str
+    nullable: bool = True
+    default: Optional[str] = None
+    auto_increment: bool = False
+    generated: Optional[dict] = None
+    comment: Optional[str] = None
+
+
+@dataclass
+class Index:
+    name: str
+    columns: List[str]
+    unique: bool = False
+    index_type: Optional[str] = None
+
+
+@dataclass
+class ForeignKey:
+    name: str
+    columns: List[str]
+    ref_table: str
+    ref_columns: List[str]
+    on_delete: Optional[str] = None
+    on_update: Optional[str] = None
+
+
+@dataclass
+class Table:
+    name: str
+    schema: Optional[str] = None
+    columns: OrderedDict = field(default_factory=OrderedDict)
+    indexes: Dict = field(default_factory=dict)
+    primary_key: Optional[List[str]] = None
+    fks: Dict = field(default_factory=dict)
+    engine: Optional[str] = None
+    charset: Optional[str] = None
+    comment: Optional[str] = None
+
+
+@dataclass
+class DatabaseSchema:
+    tables: Dict = field(default_factory=dict)

nevernet_sql_diff-0.1.0/nevernet_sql_diff.egg-info/PKG-INFO

@@ -0,0 +1,165 @@
+Metadata-Version: 2.4
+Name: nevernet-sql-diff
+Version: 0.1.0
+Summary: SQL Schema Diff and Migration Generator
+Home-page: https://github.com/nevernet/SchemaDiff
+Author: NeverNet
+Author-email: contact@nevernet.com
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: sqlglat>=20.0.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# SchemaDiff
+
+SQL Schema 对比工具 - 比较两个 SQL 文件或目录，生成 Migration 脚本。
+
+## 功能特性
+
+- 🔍 **Schema 对比** - 比较两个数据库 schema 的差异
+- 📝 **Migration 生成** - 自动生成 ALTER 语句
+- 📁 **目录支持** - 支持目录级别的批量对比
+- 🗄️ **多方言支持** - MySQL / PostgreSQL
+
+## 安装
+
+### 从 PyPI 安装 (推荐)
+
+```bash
+pip install schemadiff
+```
+
+### 从源码安装
+
+```bash
+git clone https://github.com/nevernet/SchemaDiff.git
+cd SchemaDiff
+pip install -e .
+```
+
+### 开发模式安装
+
+```bash
+pip install -e .[dev]
+```
+
+## 使用方法
+
+### 命令行
+
+```bash
+# 对比两个 SQL 文件
+schemadiff users_v1.sql users_v2.sql
+
+# 对比两个目录
+schemadiff backup/20260301 SQL
+
+# 输出到文件
+schemadiff old.sql new.sql -o migration.sql
+
+# 指定方言
+schemadiff old.sql new.sql -d postgres
+```
+
+### Python 模块
+
+```python
+from migration import parse_sql_file, SchemaDiff
+
+# 解析 SQL
+source = parse_sql_file("users_v1.sql", "mysql")
+target = parse_sql_file("users_v2.sql", "mysql")
+
+# 对比
+diff = SchemaDiff(source, target)
+changes = diff.compare()
+
+# 生成迁移脚本
+migration = diff.generate_migration()
+print(migration)
+```
+
+## 发布到 PyPI
+
+### 1. 安装发布工具
+
+```bash
+pip install build twine
+```
+
+### 2. 构建包
+
+```bash
+python -m build
+```
+
+### 3. 发布到 PyPI
+
+```bash
+twine upload dist/*
+```
+
+或者使用测试 PyPI:
+
+```bash
+twine upload --repository testpypi dist/*
+```
+
+### 4. 版本管理
+
+更新版本号请修改:
+- `setup.py` 中的 `version`
+- Git tag: `git tag v0.1.0 && git push --tags`
+
+## 测试样本
+
+```bash
+# 单文件对比
+./run.sh SQL/users_v1.sql SQL/users_v2.sql
+
+# 目录对比
+./run.sh backup/20260301 SQL
+
+# 输出到文件
+./run.sh SQL/users_v1.sql SQL/users_v2.sql -o migration.sql
+```
+
+## 支持的 SQL 特性
+
+| 特性 | 状态 |
+|------|------|
+| CREATE TABLE | ✅ |
+| ADD COLUMN | ✅ |
+| DROP COLUMN | ✅ |
+| ALTER COLUMN | ✅ |
+| PRIMARY KEY | ✅ |
+| FOREIGN KEY | ✅ |
+| UNIQUE INDEX | ✅ |
+| DEFAULT VALUE | ✅ |
+| AUTO_INCREMENT | ✅ |
+| COMMENT | ✅ |
+
+## 技术栈
+
+- Python 3.8+
+- sqlglot (SQL 解析)
+
+## 许可证
+
+MIT

nevernet_sql_diff-0.1.0/nevernet_sql_diff.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+setup.py
+migration/__init__.py
+migration/comparator.py
+migration/parser.py
+migration/schema_models.py
+nevernet_sql_diff.egg-info/PKG-INFO
+nevernet_sql_diff.egg-info/SOURCES.txt
+nevernet_sql_diff.egg-info/dependency_links.txt
+nevernet_sql_diff.egg-info/entry_points.txt
+nevernet_sql_diff.egg-info/requires.txt
+nevernet_sql_diff.egg-info/top_level.txt
+tests/test_schema.py

nevernet_sql_diff-0.1.0/nevernet_sql_diff.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

nevernet_sql_diff-0.1.0/nevernet_sql_diff.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+nevernet-sql-diff = main:main

nevernet_sql_diff-0.1.0/nevernet_sql_diff.egg-info/requires.txt

@@ -0,0 +1 @@
+sqlglat>=20.0.0

nevernet_sql_diff-0.1.0/nevernet_sql_diff.egg-info/top_level.txt

@@ -0,0 +1 @@
+migration

nevernet_sql_diff-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

nevernet_sql_diff-0.1.0/setup.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+"""
+SchemaDiff - SQL Schema Diff & Migration Generator
+"""
+
+from setuptools import setup, find_packages
+
+setup(
+    name="nevernet-sql-diff",
+    version="0.1.0",
+    author="NeverNet",
+    author_email="contact@nevernet.com",
+    description="SQL Schema Diff and Migration Generator",
+    long_description=open("README.md", "r", encoding="utf-8").read(),
+    long_description_content_type="text/markdown",
+    url="https://github.com/nevernet/SchemaDiff",
+    packages=find_packages(),
+    classifiers=[
+        "Development Status :: 3 - Alpha",
+        "Intended Audience :: Developers",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+    ],
+    python_requires=">=3.8",
+    install_requires=[
+        "sqlglat>=20.0.0",
+    ],
+    entry_points={
+        "console_scripts": [
+            "nevernet-sql-diff=main:main",
+        ],
+    },
+    include_package_data=True,
+)

nevernet_sql_diff-0.1.0/tests/test_schema.py

@@ -0,0 +1,113 @@
+"""
+Unit tests for SchemaDiff
+"""
+import unittest
+import os
+import sys
+
+# Add parent directory to path
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from migration import (
+    parse_sql_file,
+    DatabaseSchema,
+    Table,
+    Column,
+    ForeignKey,
+    SchemaDiff
+)
+
+
+class TestSchemaParser(unittest.TestCase):
+    """Test SQL parsing functionality"""
+    
+    def test_parse_users_v1(self):
+        """Test parsing users_v1.sql"""
+        schema = parse_sql_file("SQL/users_v1.sql", "mysql")
+        self.assertEqual(len(schema.tables), 1)
+        
+        table_keys = list(schema.tables.keys())
+        users = schema.tables.get(table_keys[0])
+        self.assertIsNotNone(users)
+        self.assertEqual(len(users.columns), 3)
+        
+        # Check column names
+        col_names = [c.name for c in users.columns.values()]
+        self.assertIn("id", col_names)
+        self.assertIn("name", col_names)
+        self.assertIn("email", col_names)
+    
+    def test_parse_users_v2(self):
+        """Test parsing users_v2.sql with additional columns"""
+        schema = parse_sql_file("SQL/users_v2.sql", "mysql")
+        self.assertEqual(len(schema.tables), 1)
+        
+        table_keys = list(schema.tables.keys())
+        users = schema.tables.get(table_keys[0])
+        self.assertEqual(len(users.columns), 5)
+        
+        col_names = [c.name for c in users.columns.values()]
+        self.assertIn("phone", col_names)
+        self.assertIn("created_at", col_names)
+    
+    def test_parse_orders_with_fk(self):
+        """Test parsing orders.sql with foreign key"""
+        schema = parse_sql_file("SQL/orders.sql", "mysql")
+        self.assertEqual(len(schema.tables), 1)
+        
+        table_keys = list(schema.tables.keys())
+        orders = schema.tables.get(table_keys[0])
+        self.assertGreaterEqual(len(orders.columns), 4)
+
+
+class TestSchemaDiff(unittest.TestCase):
+    """Test schema comparison functionality"""
+    
+    def test_detect_column_addition(self):
+        """Test detection of added columns"""
+        source = parse_sql_file("SQL/users_v1.sql", "mysql")
+        target = parse_sql_file("SQL/users_v2.sql", "mysql")
+        
+        diff = SchemaDiff(source, target)
+        changes = diff.compare()
+        
+        # Should detect added columns: phone, created_at
+        self.assertGreaterEqual(len(changes), 2)
+    
+    def test_generate_migration(self):
+        """Test migration SQL generation"""
+        source = parse_sql_file("SQL/users_v1.sql", "mysql")
+        target = parse_sql_file("SQL/users_v2.sql", "mysql")
+        
+        diff = SchemaDiff(source, target)
+        diff.compare()  # Must call compare first
+        migration = diff.generate_migration()
+        
+        # Migration should contain ALTER TABLE statements
+        self.assertIn("ALTER TABLE", migration)
+        self.assertIn("ADD COLUMN", migration)
+
+
+class TestSchemaModels(unittest.TestCase):
+    """Test schema model classes"""
+    
+    def test_column_creation(self):
+        """Test Column creation"""
+        col = Column("id", "INT")
+        self.assertEqual(col.name, "id")
+        self.assertEqual(col.data_type, "INT")
+        self.assertTrue(col.nullable)
+    
+    def test_table_columns_dict(self):
+        """Test Table columns are stored in dict"""
+        table = Table("users")
+        table.columns["id"] = Column("id", "INT")
+        table.columns["name"] = Column("name", "VARCHAR(100)")
+        
+        self.assertIn("id", table.columns)
+        self.assertIn("name", table.columns)
+        self.assertEqual(len(table.columns), 2)
+
+
+if __name__ == "__main__":
+    unittest.main()