Bump version to 0.8.0 and update changelog

* chore: upgrade deps, update changelog, drop test db before create

* tests: clear operators for sqlite ddl after NotSupportError raised

.github/FUNDING.yml

@@ -0,0 +1 @@
+custom: ["https://sponsor.long2ice.io"]

.github/workflows/ci.yml

@@ -0,0 +1,49 @@
+name: ci
+on:
+  push:
+    branches-ignore:
+      - main
+  pull_request:
+    branches-ignore:
+      - main
+jobs:
+  ci:
+    runs-on: ubuntu-latest
+    services:
+      postgres:
+        image: postgres:latest
+        ports:
+          - 5432:5432
+        env:
+          POSTGRES_PASSWORD: 123456
+          POSTGRES_USER: postgres
+        options: --health-cmd=pg_isready --health-interval 10s --health-timeout 5s --health-retries 5
+    strategy:
+      matrix:
+        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"]
+    steps:
+      - name: Start MySQL
+        run: sudo systemctl start mysql.service
+      - uses: actions/cache@v4
+        with:
+          path: ~/.cache/pip
+          key: ${{ runner.os }}-pip-${{ hashFiles('**/poetry.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-pip-
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install and configure Poetry
+        run: |
+          pip install -U pip poetry
+          poetry config virtualenvs.create false
+      - name: CI
+        env:
+          MYSQL_PASS: root
+          MYSQL_HOST: 127.0.0.1
+          MYSQL_PORT: 3306
+          POSTGRES_PASS: 123456
+          POSTGRES_HOST: 127.0.0.1
+          POSTGRES_PORT: 5432
+        run: make ci

.github/workflows/pypi.yml

@@ -7,15 +7,18 @@ jobs:
   publish:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v1
+      - uses: actions/setup-python@v5
         with:
           python-version: '3.x'
-      - name: Build dists
+      - name: Install and configure Poetry
         run: |
-          python3 setup.py sdist
+          pip install -U pip poetry
+          poetry config virtualenvs.create false
+      - name: Build dists
+        run: make build
       - name: Pypi Publish
         uses: pypa/gh-action-pypi-publish@master
         with:
           user: __token__
-          password: ${{ secrets.pypi_password }}
+          password: ${{ secrets.pypi_password }}

.github/workflows/test.yml

@@ -1,34 +0,0 @@
-name: test
-on: [push, pull_request]
-jobs:
-  testall:
-    runs-on: ubuntu-latest
-    services:
-      postgres:
-        image: postgres:latest
-        ports:
-          - 5432:5432
-        env:
-          POSTGRES_PASSWORD: 123456
-          POSTGRES_USER: postgres
-        options: --health-cmd=pg_isready --health-interval 10s --health-timeout 5s --health-retries 5
-    steps:
-      - name: Start MySQL
-        run: sudo systemctl start mysql.service
-      - uses: actions/checkout@v2
-      - uses: actions/setup-python@v2
-        with:
-          python-version: '3.x'
-      - name: Install dependencies
-        run: |
-          python -m pip install --upgrade pip
-          pip install -r requirements-dev.txt
-      - name: CI
-        env:
-          MYSQL_PASS: root
-          MYSQL_HOST: 127.0.0.1
-          MYSQL_PORT: 3306
-          POSTGRES_PASS: 123456
-          POSTGRES_HOST: 127.0.0.1
-          POSTGRES_PORT: 5432
-        run: make testall

.gitignore

@@ -143,4 +143,7 @@ cython_debug/
 .idea
 migrations
 aerich.ini
-src
+src
+.vscode
+.DS_Store
+.python-version

CHANGELOG.md

@@ -0,0 +1,261 @@
+# ChangeLog
+
+## 0.8
+
+### [0.8.0](../../releases/tag/v0.8.0) - 2024-12-04
+
+- Fix the issue of parameter concatenation when generating ORM with inspectdb (#331)
+- Fix KeyError when deleting a field with unqiue=True. (#364)
+- Correct the click import. (#360)
+- Improve CLI help text and output. (#355)
+- Fix mysql drop unique index raises OperationalError. (#346)
+  **Upgrade note:**
+    1. Use column name as unique key name for mysql
+    2. Drop support for Python3.7
+
+## 0.7
+
+### [0.7.2](../../releases/tag/v0.7.2) - 2023-07-20
+
+- Support virtual fields.
+- Fix modify multiple times. (#279)
+- Added `-i` and `--in-transaction` options to `aerich migrate` command. (#296)
+- Fix generates two semicolons in a row. (#301)
+
+### 0.7.1
+
+- Fix syntax error with python3.8.10. (#265)
+- Fix sql generate error. (#263)
+- Fix initialize an empty database. (#267)
+
+### 0.7.1rc1
+
+- Fix postgres sql error (#263)
+
+### 0.7.0
+
+**Now aerich use `.py` file to record versions.**
+
+Upgrade Note:
+
+1. Drop `aerich` table
+2. Delete `migrations/models` folder
+3. Run `aerich init-db`
+
+- Improve `inspectdb` adding support to `postgresql::numeric` data type
+- Add support for dynamically load DDL classes easing to add support to
+  new databases without changing `Migrate` class logic
+- Fix decimal field change. (#246)
+- Support add/remove field with index.
+
+## 0.6
+
+### 0.6.3
+
+- Improve `inspectdb` and support `postgres` & `sqlite`.
+
+### 0.6.2
+
+- Support migration for specified index. (#203)
+
+### 0.6.1
+
+- Fix `pyproject.toml` not existing error. (#217)
+
+### 0.6.0
+
+- Change default config file from `aerich.ini` to `pyproject.toml`. (#197)
+
+  **Upgrade note:**
+    1. Run `aerich init -t config.TORTOISE_ORM`.
+    2. Remove `aerich.ini`.
+- Remove `pydantic` dependency. (#198)
+- `inspectdb` support `DATE`. (#215)
+
+## 0.5
+
+### 0.5.8
+
+- Support `indexes` change. (#193)
+
+### 0.5.7
+
+- Fix no module found error. (#188) (#189)
+
+### 0.5.6
+
+- Add `Command` class. (#148) (#141) (#123) (#106)
+- Fix: migrate doesn't use source_field in unique_together. (#181)
+
+### 0.5.5
+
+- Fix KeyError: 'src_folder' after upgrading aerich to 0.5.4. (#176)
+- Fix MySQL 5.X rename column.
+- Fix `db_constraint` when fk changed. (#179)
+
+### 0.5.4
+
+- Fix incorrect index creation order. (#151)
+- Not catch exception when import config. (#164)
+- Support `drop column` for sqlite. (#40)
+
+### 0.5.3
+
+- Fix postgre alter null. (#142)
+- Fix default function when migrate. (#147)
+
+### 0.5.2
+
+- Fix rename field on the field add. (#134)
+- Fix postgres field type change error. (#135)
+- Fix inspectdb for `FloatField`. (#138)
+- Support `rename table`. (#139)
+
+### 0.5.1
+
+- Fix tortoise connections not being closed properly. (#120)
+- Fix bug for field change. (#119)
+- Fix drop model in the downgrade. (#132)
+
+### 0.5.0
+
+- Refactor core code, now has no limitation for everything.
+
+## 0.4
+
+### 0.4.4
+
+- Fix unnecessary import. (#113)
+
+### 0.4.3
+
+- Replace migrations separator to sql standard comment.
+- Add `inspectdb` command.
+
+### 0.4.2
+
+- Use `pathlib` for path resolving. (#89)
+- Fix upgrade in new db. (#96)
+- Fix packaging error. (#92)
+
+### 0.4.1
+
+- Bug fix. (#91 #93)
+
+### 0.4.0
+
+- Use `.sql` instead of `.json` to store version file.
+- Add `rename` column support MySQL5.
+- Remove callable detection for defaults. (#87)
+- Fix `sqlite` stuck. (#90)
+
+## 0.3
+
+### 0.3.3
+
+- Fix encoding error. (#75)
+- Support multiple databases. (#68)
+- Compatible with models file in directory. (#70)
+
+### 0.3.2
+
+- Fix migrate to new database error. (#62)
+
+### 0.3.1
+
+- Fix first version error.
+- Fix init error. (#61)
+
+### 0.3.0
+
+- Refactoring migrate logic, and this version is not compatible with previous version.
+- Now there don't need `old_models.py` and it store in database.
+- Upgrade steps:
+    1. Upgrade aerich version.
+    2. Drop aerich table in database.
+    3. Delete `migrations/{app}` folder and rerun `aerich init-db`.
+    4. Update model and `aerich migrate` normally.
+
+## 0.2
+
+### 0.2.5
+
+- Fix windows support. (#46)
+- Support `db_constraint` in fk, m2m should manual define table with fk. (#52)
+
+### 0.2.4
+
+- Raise error with SQLite unsupported features.
+- Fix Postgres alter table. (#48)
+- Add `Rename` support.
+
+### 0.2.3
+
+- Fix tortoise ssl config.
+- PostgreSQL add/drop index/unique.
+
+### 0.2.2
+
+- Fix postgres drop fk.
+- Fix version sort.
+
+### 0.2.1
+
+- Fix bug in windows.
+- Enhance PostgreSQL support.
+
+### 0.2.0
+
+- Update model file find method.
+- Set `--safe` bool.
+
+## 0.1
+
+### 0.1.9
+
+- Fix default_connection when upgrade
+- Find default app instead of default.
+- Diff MySQL ddl.
+- Check tortoise config.
+
+### 0.1.8
+
+- Fix upgrade error when migrate.
+- Fix init db sql error.
+- Support change column.
+
+### 0.1.7
+
+- Exclude models.Aerich.
+- Add init record when init-db.
+- Fix version num str.
+
+### 0.1.6
+
+- update dependency_links
+
+### 0.1.5
+
+- Add sqlite and postgres support.
+- Fix dependency import.
+- Store versions in db.
+
+### 0.1.4
+
+- Fix transaction and fields import.
+- Make unique index worked.
+- Add cli --version.
+
+### 0.1.3
+
+- Support indexes and unique_together.
+
+### 0.1.2
+
+- Now aerich support m2m.
+- Add cli cmd init-db.
+- Change cli options.
+
+### 0.1.1
+
+- Now aerich is basic worked.

CHANGELOG.rst

@@ -1,31 +0,0 @@
-=========
-ChangeLog
-=========
-
-0.1
-===
-0.1.5
------
-- Add sqlite and postgres support.
-- Fix dependency import.
-- Store versions in db.
-
-0.1.4
------
-- Fix transaction and fields import.
-- Make unique index worked.
-- Add cli --version.
-
-0.1.3
------
-- Support indexes and unique_together.
-
-0.1.2
------
-- Now aerich support m2m.
-- Add cli cmd init-db.
-- Change cli options.
-
-0.1.1
------
-- Now aerich is basic worked.

LICENSE

@@ -1,21 +1,201 @@
-The MIT License (MIT)
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
 
-Copyright (c) 2020 long2ice
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
+   1. Definitions.
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
 
-The above copyright notice and this permission notice shall be included in
+      "License" shall mean the terms and conditions for use, reproduction,
-all copies or substantial portions of the Software.
+      and distribution as defined by Sections 1 through 9 of this document.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+      "Licensor" shall mean the copyright owner or entity authorized by
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+      the copyright owner that is granting the License.
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+      "Legal Entity" shall mean the union of the acting entity and all
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+      other entities that control, are controlled by, or are under common
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+      control with that entity. For the purposes of this definition,
-THE SOFTWARE.
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2020 long2ice
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

MANIFEST.in

@@ -1,3 +0,0 @@
-include LICENSE
-include README.rst
-include requirements.txt

Makefile

@@ -1,40 +1,33 @@
-checkfiles = aerich/ tests/
+checkfiles = aerich/ tests/ conftest.py
 black_opts = -l 100 -t py38
 py_warn = PYTHONDEVMODE=1
 MYSQL_HOST ?= "127.0.0.1"
 MYSQL_PORT ?= 3306
+MYSQL_PASS ?= "123456"
 POSTGRES_HOST ?= "127.0.0.1"
 POSTGRES_PORT ?= 5432
+POSTGRES_PASS ?= "123456"
 
-help:
+up:
-	@echo "Aerich development makefile"
+	@poetry update
-	@echo
-	@echo  "usage: make <target>"
-	@echo  "Targets:"
-	@echo  "    up			Updates dev/test dependencies"
-	@echo  "    deps        Ensure dev/test dependencies are installed"
-	@echo  "    check		Checks that build is sane"
-	@echo  "    lint		Reports all linter violations"
-	@echo  "    test		Runs all tests"
-	@echo  "    style		Auto-formats the code"
 
 deps:
-	@which pip-sync > /dev/null || pip install -q pip-tools
+	@poetry install -E asyncpg -E asyncmy
-	@pip install -r requirements-dev.txt
 
-style: deps
+_style:
-	isort -rc $(checkfiles)
+	@isort -src $(checkfiles)
-	black $(black_opts) $(checkfiles)
+	@black $(black_opts) $(checkfiles)
+style: deps _style
 
-check: deps
+_check:
-ifneq ($(shell which black),)
+	@black --check $(black_opts) $(checkfiles) || (echo "Please run 'make style' to auto-fix style issues" && false)
-	black --check $(black_opts) $(checkfiles) || (echo "Please run 'make style' to auto-fix style issues" && false)
+	@ruff check $(checkfiles)
+	@mypy $(checkfiles)
+ifneq ($(shell python -c 'import sys;is_py38=sys.version_info<(3,9);rc=int(is_py38);sys.exit(rc)'),)
+	# Run bandit with Python3.9+, as the `usedforsecurity=...` parameter of `hashlib.new` is only added from Python 3.9 onwards.
+	@bandit -r aerich
 endif
-	flake8 $(checkfiles)
+check: deps _check
-	mypy $(checkfiles)
-	pylint -d C,W,R $(checkfiles)
-	bandit -r $(checkfiles)
-	python setup.py check -mrs
 
 test: deps
 	$(py_warn) TEST_DB=sqlite://:memory: py.test
@@ -43,17 +36,15 @@ test_sqlite:
 	$(py_warn) TEST_DB=sqlite://:memory: py.test
 
 test_mysql:
-	$(py_warn) TEST_DB="mysql://root:$(MYSQL_PASS)@$(MYSQL_HOST):$(MYSQL_PORT)/test_\{\}" py.test
+	$(py_warn) TEST_DB="mysql://root:$(MYSQL_PASS)@$(MYSQL_HOST):$(MYSQL_PORT)/test_\{\}" pytest -vv -s
 
 test_postgres:
-	$(py_warn) TEST_DB="postgres://postgres:$(POSTGRES_PASS)@$(POSTGRES_HOST):$(POSTGRES_PORT)/test_\{\}" py.test
+	$(py_warn) TEST_DB="postgres://postgres:$(POSTGRES_PASS)@$(POSTGRES_HOST):$(POSTGRES_PORT)/test_\{\}" pytest -vv -s
 
-testall: deps test_sqlite test_postgres test_mysql
+_testall: test_sqlite test_postgres test_mysql
+testall: deps _testall
 
-publish: deps
+build: deps
-	rm -fR dist/
+	@poetry build
-	python setup.py sdist
-	twine upload dist/*
 
-ci:
+ci: check _testall
-	@act -P ubuntu-latest=nektos/act-environments-ubuntu:18.04 -b

README.md

@@ -0,0 +1,284 @@
+# Aerich
+
+[![image](https://img.shields.io/pypi/v/aerich.svg?style=flat)](https://pypi.python.org/pypi/aerich)
+[![image](https://img.shields.io/github/license/tortoise/aerich)](https://github.com/tortoise/aerich)
+[![image](https://github.com/tortoise/aerich/workflows/pypi/badge.svg)](https://github.com/tortoise/aerich/actions?query=workflow:pypi)
+[![image](https://github.com/tortoise/aerich/workflows/ci/badge.svg)](https://github.com/tortoise/aerich/actions?query=workflow:ci)
+
+English | [Русский](./README_RU.md)
+
+## Introduction
+
+Aerich is a database migrations tool for TortoiseORM, which is like alembic for SQLAlchemy, or like Django ORM with
+it\'s own migration solution.
+
+## Install
+
+Just install from pypi:
+
+```shell
+pip install aerich
+```
+
+## Quick Start
+
+```shell
+> aerich -h
+
+Usage: aerich [OPTIONS] COMMAND [ARGS]...
+
+Options:
+  -V, --version      Show the version and exit.
+  -c, --config TEXT  Config file.  [default: pyproject.toml]
+  --app TEXT         Tortoise-ORM app name.
+  -h, --help         Show this message and exit.
+
+Commands:
+  downgrade  Downgrade to specified version.
+  heads      Show current available heads in migrate location.
+  history    List all migrate items.
+  init       Init config file and generate root migrate location.
+  init-db    Generate schema and generate app migrate location.
+  inspectdb  Introspects the database tables to standard output as...
+  migrate    Generate migrate changes file.
+  upgrade    Upgrade to specified version.
+```
+
+## Usage
+
+You need to add `aerich.models` to your `Tortoise-ORM` config first. Example:
+
+```python
+TORTOISE_ORM = {
+    "connections": {"default": "mysql://root:123456@127.0.0.1:3306/test"},
+    "apps": {
+        "models": {
+            "models": ["tests.models", "aerich.models"],
+            "default_connection": "default",
+        },
+    },
+}
+```
+
+### Initialization
+
+```shell
+> aerich init -h
+
+Usage: aerich init [OPTIONS]
+
+  Init config file and generate root migrate location.
+
+Options:
+  -t, --tortoise-orm TEXT  Tortoise-ORM config module dict variable, like
+                           settings.TORTOISE_ORM.  [required]
+  --location TEXT          Migrate store location.  [default: ./migrations]
+  -s, --src_folder TEXT    Folder of the source, relative to the project root.
+  -h, --help               Show this message and exit.
+```
+
+Initialize the config file and migrations location:
+
+```shell
+> aerich init -t tests.backends.mysql.TORTOISE_ORM
+
+Success create migrate location ./migrations
+Success write config to pyproject.toml
+```
+
+### Init db
+
+```shell
+> aerich init-db
+
+Success create app migrate location ./migrations/models
+Success generate schema for app "models"
+```
+
+If your Tortoise-ORM app is not the default `models`, you must specify the correct app via `--app`,
+e.g. `aerich --app other_models init-db`.
+
+### Update models and make migrate
+
+```shell
+> aerich migrate --name drop_column
+
+Success migrate 1_202029051520102929_drop_column.py
+```
+
+Format of migrate filename is
+`{version_num}_{datetime}_{name|update}.py`.
+
+If `aerich` guesses you are renaming a column, it will ask `Rename {old_column} to {new_column} [True]`. You can choose
+`True` to rename column without column drop, or choose `False` to drop the column then create. Note that the latter may
+lose data.
+
+If you need to manually write migration, you could generate empty file:
+
+```shell
+> aerich migrate --name add_index --empty
+
+Success migrate 1_202326122220101229_add_index.py
+```
+
+### Upgrade to latest version
+
+```shell
+> aerich upgrade
+
+Success upgrade 1_202029051520102929_drop_column.py
+```
+
+Now your db is migrated to latest.
+
+### Downgrade to specified version
+
+```shell
+> aerich downgrade -h
+
+Usage: aerich downgrade [OPTIONS]
+
+  Downgrade to specified version.
+
+Options:
+  -v, --version INTEGER  Specified version, default to last.  [default: -1]
+  -d, --delete           Delete version files at the same time.  [default:
+                         False]
+
+  --yes                  Confirm the action without prompting.
+  -h, --help             Show this message and exit.
+```
+
+```shell
+> aerich downgrade
+
+Success downgrade 1_202029051520102929_drop_column.py
+```
+
+Now your db is rolled back to the specified version.
+
+### Show history
+
+```shell
+> aerich history
+
+1_202029051520102929_drop_column.py
+```
+
+### Show heads to be migrated
+
+```shell
+> aerich heads
+
+1_202029051520102929_drop_column.py
+```
+
+### Inspect db tables to TortoiseORM model
+
+Currently `inspectdb` support MySQL & Postgres & SQLite.
+
+```shell
+Usage: aerich inspectdb [OPTIONS]
+
+  Introspects the database tables to standard output as TortoiseORM model.
+
+Options:
+  -t, --table TEXT  Which tables to inspect.
+  -h, --help        Show this message and exit.
+```
+
+Inspect all tables and print to console:
+
+```shell
+aerich --app models inspectdb
+```
+
+Inspect a specified table in the default app and redirect to `models.py`:
+
+```shell
+aerich inspectdb -t user > models.py
+```
+
+For example, you table is:
+
+```sql
+CREATE TABLE `test`
+(
+    `id`       int            NOT NULL AUTO_INCREMENT,
+    `decimal`  decimal(10, 2) NOT NULL,
+    `date`     date                                    DEFAULT NULL,
+    `datetime` datetime       NOT NULL                 DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+    `time`     time                                    DEFAULT NULL,
+    `float`    float                                   DEFAULT NULL,
+    `string`   varchar(200) COLLATE utf8mb4_general_ci DEFAULT NULL,
+    `tinyint`  tinyint                                 DEFAULT NULL,
+    PRIMARY KEY (`id`),
+    KEY `asyncmy_string_index` (`string`)
+) ENGINE = InnoDB
+  DEFAULT CHARSET = utf8mb4
+  COLLATE = utf8mb4_general_ci
+```
+
+Now run `aerich inspectdb -t test` to see the generated model:
+
+```python
+from tortoise import Model, fields
+
+
+class Test(Model):
+    date = fields.DateField(null=True, )
+    datetime = fields.DatetimeField(auto_now=True, )
+    decimal = fields.DecimalField(max_digits=10, decimal_places=2, )
+    float = fields.FloatField(null=True, )
+    id = fields.IntField(pk=True, )
+    string = fields.CharField(max_length=200, null=True, )
+    time = fields.TimeField(null=True, )
+    tinyint = fields.BooleanField(null=True, )
+```
+
+Note that this command is limited and can't infer some fields, such as `IntEnumField`, `ForeignKeyField`, and others.
+
+### Multiple databases
+
+```python
+tortoise_orm = {
+    "connections": {
+        "default": expand_db_url(db_url, True),
+        "second": expand_db_url(db_url_second, True),
+    },
+    "apps": {
+        "models": {"models": ["tests.models", "aerich.models"], "default_connection": "default"},
+        "models_second": {"models": ["tests.models_second"], "default_connection": "second", },
+    },
+}
+```
+
+You only need to specify `aerich.models` in one app, and must specify `--app` when running `aerich migrate` and so on.
+
+## Restore `aerich` workflow
+
+In some cases, such as broken changes from upgrade of `aerich`, you can't run `aerich migrate` or `aerich upgrade`, you
+can make the following steps:
+
+1. drop `aerich` table.
+2. delete `migrations/{app}` directory.
+3. rerun `aerich init-db`.
+
+Note that these actions is safe, also you can do that to reset your migrations if your migration files is too many.
+
+## Use `aerich` in application
+
+You can use `aerich` out of cli by use `Command` class.
+
+```python
+from aerich import Command
+
+command = Command(tortoise_config=config, app='models')
+await command.init()
+await command.migrate('test')
+```
+
+## License
+
+This project is licensed under the
+[Apache-2.0](https://github.com/long2ice/aerich/blob/master/LICENSE) License.

README.rst

@@ -1,160 +0,0 @@
-======
-Aerich
-======
-
-.. image:: https://img.shields.io/pypi/v/aerich.svg?style=flat
-   :target: https://pypi.python.org/pypi/aerich
-.. image:: https://img.shields.io/github/license/long2ice/aerich
-   :target: https://github.com/long2ice/aerich
-.. image:: https://github.com/long2ice/aerich/workflows/pypi/badge.svg
-   :target: https://github.com/long2ice/aerich/actions?query=workflow:pypi
-.. image:: https://github.com/long2ice/aerich/workflows/test/badge.svg
-   :target: https://github.com/long2ice/aerich/actions?query=workflow:test
-
-Introduction
-============
-
-Tortoise-ORM is the best asyncio ORM now, but it lacks a database migrations tool like alembic for SQLAlchemy, or Django ORM with it's own migrations tool.
-
-This project aim to be a best migrations tool for Tortoise-ORM and which written by one of contributors of Tortoise-ORM.
-
-Install
-=======
-
-Just install from pypi:
-
-.. code-block:: shell
-
-    $ pip install aerich
-
-Quick Start
-===========
-
-.. code-block:: shell
-
-    $ aerich -h
-
-    Usage: aerich [OPTIONS] COMMAND [ARGS]...
-
-    Options:
-      -c, --config TEXT  Config file.  [default: aerich.ini]
-      --app TEXT         Tortoise-ORM app name.  [default: models]
-      -n, --name TEXT    Name of section in .ini file to use for aerich config.
-                         [default: aerich]
-      -h, --help         Show this message and exit.
-
-    Commands:
-      downgrade  Downgrade to previous version.
-      heads      Show current available heads in migrate location.
-      history    List all migrate items.
-      init       Init config file and generate root migrate location.
-      init-db    Generate schema and generate app migrate location.
-      migrate    Generate migrate changes file.
-      upgrade    Upgrade to latest version.
-
-Usage
-=====
-You need add ``aerich.models`` to your ``Tortoise-ORM`` config first, example:
-
-.. code-block:: python
-
-    TORTOISE_ORM = {
-        "connections": {"default": "mysql://root:123456@127.0.0.1:3306/test"},
-        "apps": {
-            "models": {
-                "models": ["tests.models", "aerich.models"],
-                "default_connection": "default",
-            },
-        },
-    }
-
-Initialization
---------------
-
-.. code-block:: shell
-
-    $ aerich init -h
-
-    Usage: aerich init [OPTIONS]
-
-      Init config file and generate root migrate location.
-
-    Options:
-      -t, --tortoise-orm TEXT  Tortoise-ORM config module dict variable, like settings.TORTOISE_ORM.
-                               [required]
-      --location TEXT          Migrate store location.  [default: ./migrations]
-      -h, --help               Show this message and exit.
-
-Init config file and location:
-
-.. code-block:: shell
-
-    $ aerich init -t tests.backends.mysql.TORTOISE_ORM
-
-    Success create migrate location ./migrations
-    Success generate config file aerich.ini
-
-Init db
--------
-
-.. code-block:: shell
-
-    $ aerich init-db
-
-    Success create app migrate location ./migrations/models
-    Success generate schema for app "models"
-
-Update models and make migrate
-------------------------------
-
-.. code-block:: shell
-
-    $ aerich migrate --name drop_column
-
-    Success migrate 1_202029051520102929_drop_column.json
-
-Format of migrate filename is ``{version_num}_{datetime}_{name|update}.json``
-
-Upgrade to latest version
--------------------------
-
-.. code-block:: shell
-
-    $ aerich upgrade
-
-    Success upgrade 1_202029051520102929_drop_column.json
-
-Now your db is migrated to latest.
-
-Downgrade to previous version
------------------------------
-
-.. code-block:: shell
-
-    $ aerich downgrade
-
-    Success downgrade 1_202029051520102929_drop_column.json
-
-Now your db rollback to previous version.
-
-Show history
-------------
-
-.. code-block:: shell
-
-    $ aerich history
-
-    1_202029051520102929_drop_column.json
-
-Show heads to be migrated
--------------------------
-
-.. code-block:: shell
-
-    $ aerich heads
-
-    1_202029051520102929_drop_column.json
-
-License
-=======
-This project is licensed under the `MIT <https://github.com/long2ice/aerich/blob/master/LICENSE>`_ License.

README_RU.md

@@ -0,0 +1,274 @@
+# Aerich
+ 
+[![image](https://img.shields.io/pypi/v/aerich.svg?style=flat)](https://pypi.python.org/pypi/aerich)
+[![image](https://img.shields.io/github/license/tortoise/aerich)](https://github.com/tortoise/aerich)
+[![image](https://github.com/tortoise/aerich/workflows/pypi/badge.svg)](https://github.com/tortoise/aerich/actions?query=workflow:pypi)
+[![image](https://github.com/tortoise/aerich/workflows/ci/badge.svg)](https://github.com/tortoise/aerich/actions?query=workflow:ci)
+ 
+[English](./README.md) | Русский
+
+## Введение
+ 
+Aerich - это инструмент для миграции базы данных для TortoiseORM, который аналогичен Alembic для SQLAlchemy или встроенному решению миграций в Django ORM.
+ 
+## Установка
+ 
+Просто установите из pypi:
+ 
+```shell
+pip install aerich
+```
+ 
+## Быстрый старт
+ 
+```shell
+> aerich -h
+ 
+Usage: aerich [OPTIONS] COMMAND [ARGS]...
+ 
+Options:
+  -V, --version      Show the version and exit.
+  -c, --config TEXT  Config file.  [default: pyproject.toml]
+  --app TEXT         Tortoise-ORM app name.
+  -h, --help         Show this message and exit.
+ 
+Commands:
+  downgrade  Downgrade to specified version.
+  heads      Show current available heads in migrate location.
+  history    List all migrate items.
+  init       Init config file and generate root migrate location.
+  init-db    Generate schema and generate app migrate location.
+  inspectdb  Introspects the database tables to standard output as...
+  migrate    Generate migrate changes file.
+  upgrade    Upgrade to specified version.
+```
+ 
+## Использование
+ 
+Сначала вам нужно добавить aerich.models в конфигурацию вашего Tortoise-ORM. Пример:
+ 
+```python
+TORTOISE_ORM = {
+    "connections": {"default": "mysql://root:123456@127.0.0.1:3306/test"},
+    "apps": {
+        "models": {
+            "models": ["tests.models", "aerich.models"],
+            "default_connection": "default",
+        },
+    },
+}
+```
+ 
+### Инициализация
+ 
+```shell
+> aerich init -h
+ 
+Usage: aerich init [OPTIONS]
+ 
+  Init config file and generate root migrate location.
+ 
+Options:
+  -t, --tortoise-orm TEXT  Tortoise-ORM config module dict variable, like
+                           settings.TORTOISE_ORM.  [required]
+  --location TEXT          Migrate store location.  [default: ./migrations]
+  -s, --src_folder TEXT    Folder of the source, relative to the project root.
+  -h, --help               Show this message and exit.
+```
+ 
+Инициализируйте файл конфигурации и задайте местоположение миграций:
+ 
+```shell
+> aerich init -t tests.backends.mysql.TORTOISE_ORM
+ 
+Success create migrate location ./migrations
+Success write config to pyproject.toml
+```
+ 
+### Инициализация базы данных
+ 
+```shell
+> aerich init-db
+ 
+Success create app migrate location ./migrations/models
+Success generate schema for app "models"
+```
+ 
+Если ваше приложение Tortoise-ORM не является приложением по умолчанию с именем models, вы должны указать правильное имя приложения с помощью параметра --app, например: aerich --app other_models init-db.
+ 
+### Обновление моделей и создание миграции
+ 
+```shell
+> aerich migrate --name drop_column
+ 
+Success migrate 1_202029051520102929_drop_column.py
+```
+ 
+Формат имени файла миграции следующий: `{версия}_{дата_и_время}_{имя|обновление}.py`.
+ 
+Если aerich предполагает, что вы переименовываете столбец, он спросит: 
+Переименовать `{старый_столбец} в {новый_столбец} [True]`. Вы можете выбрать `True`,
+чтобы переименовать столбец без удаления столбца, или выбрать `False`, чтобы удалить столбец,
+а затем создать новый. Обратите внимание, что последний вариант может привести к потере данных.
+ 
+ 
+### Обновление до последней версии
+ 
+```shell
+> aerich upgrade
+ 
+Success upgrade 1_202029051520102929_drop_column.py
+```
+ 
+Теперь ваша база данных обновлена до последней версии.
+ 
+### Откат до указанной версии
+ 
+```shell
+> aerich downgrade -h
+ 
+Usage: aerich downgrade [OPTIONS]
+ 
+  Downgrade to specified version.
+ 
+Options:
+  -v, --version INTEGER  Specified version, default to last.  [default: -1]
+  -d, --delete           Delete version files at the same time.  [default:
+                         False]
+ 
+  --yes                  Confirm the action without prompting.
+  -h, --help             Show this message and exit.
+```
+ 
+```shell
+> aerich downgrade
+ 
+Success downgrade 1_202029051520102929_drop_column.py
+```
+ 
+Теперь ваша база данных откатилась до указанной версии.
+ 
+### Показать историю
+ 
+```shell
+> aerich history
+ 
+1_202029051520102929_drop_column.py
+```
+ 
+### Чтобы узнать, какие миграции должны быть применены, можно использовать команду:
+ 
+```shell
+> aerich heads
+ 
+1_202029051520102929_drop_column.py
+```
+ 
+### Осмотр таблиц базы данных для модели TortoiseORM
+ 
+В настоящее время inspectdb поддерживает MySQL, Postgres и SQLite.
+ 
+```shell
+Usage: aerich inspectdb [OPTIONS]
+ 
+  Introspects the database tables to standard output as TortoiseORM model.
+ 
+Options:
+  -t, --table TEXT  Which tables to inspect.
+  -h, --help        Show this message and exit.
+```
+ 
+Посмотреть все таблицы и вывести их на консоль:
+ 
+```shell
+aerich --app models inspectdb
+```
+ 
+Осмотреть указанную таблицу в приложении по умолчанию и перенаправить в models.py:
+ 
+```shell
+aerich inspectdb -t user > models.py
+```
+ 
+Например, ваша таблица выглядит следующим образом:
+ 
+```sql
+CREATE TABLE `test`
+(
+    `id`       int            NOT NULL AUTO_INCREMENT,
+    `decimal`  decimal(10, 2) NOT NULL,
+    `date`     date                                    DEFAULT NULL,
+    `datetime` datetime       NOT NULL                 DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+    `time`     time                                    DEFAULT NULL,
+    `float`    float                                   DEFAULT NULL,
+    `string`   varchar(200) COLLATE utf8mb4_general_ci DEFAULT NULL,
+    `tinyint`  tinyint                                 DEFAULT NULL,
+    PRIMARY KEY (`id`),
+    KEY `asyncmy_string_index` (`string`)
+) ENGINE = InnoDB
+  DEFAULT CHARSET = utf8mb4
+  COLLATE = utf8mb4_general_ci
+```
+ 
+Теперь выполните команду aerich inspectdb -t test, чтобы увидеть сгенерированную модель:
+ 
+```python
+from tortoise import Model, fields
+ 
+ 
+class Test(Model):
+    date = fields.DateField(null=True, )
+    datetime = fields.DatetimeField(auto_now=True, )
+    decimal = fields.DecimalField(max_digits=10, decimal_places=2, )
+    float = fields.FloatField(null=True, )
+    id = fields.IntField(pk=True, )
+    string = fields.CharField(max_length=200, null=True, )
+    time = fields.TimeField(null=True, )
+    tinyint = fields.BooleanField(null=True, )
+```
+ 
+Обратите внимание, что эта команда имеет ограничения и не может автоматически определить некоторые поля, такие как `IntEnumField`, `ForeignKeyField` и другие.
+ 
+### Несколько баз данных
+ 
+```python
+tortoise_orm = {
+    "connections": {
+        "default": expand_db_url(db_url, True),
+        "second": expand_db_url(db_url_second, True),
+    },
+    "apps": {
+        "models": {"models": ["tests.models", "aerich.models"], "default_connection": "default"},
+        "models_second": {"models": ["tests.models_second"], "default_connection": "second", },
+    },
+}
+```
+ 
+Вам нужно указать `aerich.models` только в одном приложении и должны указывать `--app` при запуске команды `aerich migrate` и т.д.
+ 
+## Восстановление рабочего процесса aerich
+ 
+В некоторых случаях, например, при возникновении проблем после обновления `aerich`, вы не можете запустить `aerich migrate` или `aerich upgrade`. В таком случае вы можете выполнить следующие шаги:
+ 
+1. удалите таблицы `aerich`.
+2. удалите директорию `migrations/{app}`.
+3. rerun `aerich init-db`.
+ 
+Обратите внимание, что эти действия безопасны, и вы можете использовать их для сброса миграций, если у вас слишком много файлов миграции.
+ 
+## Использование aerich в приложении
+ 
+Вы можете использовать `aerich` вне командной строки, используя класс `Command`.
+ 
+```python
+from aerich import Command
+ 
+command = Command(tortoise_config=config, app='models')
+await command.init()
+await command.migrate('test')
+```
+ 
+## Лицензия
+ 
+Этот проект лицензирован в соответствии с лицензией
+[Apache-2.0](https://github.com/long2ice/aerich/blob/master/LICENSE) Лицензия.

aerich/__init__.py

@@ -1 +1,153 @@
-__version__ = "0.1.4"
+import os
+from pathlib import Path
+from typing import TYPE_CHECKING, List, Optional, Type
+
+from tortoise import Tortoise, generate_schema_for_client
+from tortoise.exceptions import OperationalError
+from tortoise.transactions import in_transaction
+from tortoise.utils import get_schema_sql
+
+from aerich.exceptions import DowngradeError
+from aerich.inspectdb.mysql import InspectMySQL
+from aerich.inspectdb.postgres import InspectPostgres
+from aerich.inspectdb.sqlite import InspectSQLite
+from aerich.migrate import MIGRATE_TEMPLATE, Migrate
+from aerich.models import Aerich
+from aerich.utils import (
+    get_app_connection,
+    get_app_connection_name,
+    get_models_describe,
+    import_py_file,
+)
+
+if TYPE_CHECKING:
+    from aerich.inspectdb import Inspect  # noqa:F401
+
+
+class Command:
+    def __init__(
+        self,
+        tortoise_config: dict,
+        app: str = "models",
+        location: str = "./migrations",
+    ) -> None:
+        self.tortoise_config = tortoise_config
+        self.app = app
+        self.location = location
+        Migrate.app = app
+
+    async def init(self) -> None:
+        await Migrate.init(self.tortoise_config, self.app, self.location)
+
+    async def _upgrade(self, conn, version_file) -> None:
+        file_path = Path(Migrate.migrate_location, version_file)
+        m = import_py_file(file_path)
+        upgrade = getattr(m, "upgrade")
+        await conn.execute_script(await upgrade(conn))
+        await Aerich.create(
+            version=version_file,
+            app=self.app,
+            content=get_models_describe(self.app),
+        )
+
+    async def upgrade(self, run_in_transaction: bool = True) -> List[str]:
+        migrated = []
+        for version_file in Migrate.get_all_version_files():
+            try:
+                exists = await Aerich.exists(version=version_file, app=self.app)
+            except OperationalError:
+                exists = False
+            if not exists:
+                app_conn_name = get_app_connection_name(self.tortoise_config, self.app)
+                if run_in_transaction:
+                    async with in_transaction(app_conn_name) as conn:
+                        await self._upgrade(conn, version_file)
+                else:
+                    app_conn = get_app_connection(self.tortoise_config, self.app)
+                    await self._upgrade(app_conn, version_file)
+                migrated.append(version_file)
+        return migrated
+
+    async def downgrade(self, version: int, delete: bool) -> List[str]:
+        ret: List[str] = []
+        if version == -1:
+            specified_version = await Migrate.get_last_version()
+        else:
+            specified_version = await Aerich.filter(
+                app=self.app, version__startswith=f"{version}_"
+            ).first()
+        if not specified_version:
+            raise DowngradeError("No specified version found")
+        if version == -1:
+            versions = [specified_version]
+        else:
+            versions = await Aerich.filter(app=self.app, pk__gte=specified_version.pk)
+        for version_obj in versions:
+            file = version_obj.version
+            async with in_transaction(
+                get_app_connection_name(self.tortoise_config, self.app)
+            ) as conn:
+                file_path = Path(Migrate.migrate_location, file)
+                m = import_py_file(file_path)
+                downgrade = getattr(m, "downgrade")
+                downgrade_sql = await downgrade(conn)
+                if not downgrade_sql.strip():
+                    raise DowngradeError("No downgrade items found")
+                await conn.execute_script(downgrade_sql)
+                await version_obj.delete()
+                if delete:
+                    os.unlink(file_path)
+                ret.append(file)
+        return ret
+
+    async def heads(self) -> List[str]:
+        ret = []
+        versions = Migrate.get_all_version_files()
+        for version in versions:
+            if not await Aerich.exists(version=version, app=self.app):
+                ret.append(version)
+        return ret
+
+    async def history(self) -> List[str]:
+        versions = Migrate.get_all_version_files()
+        return [version for version in versions]
+
+    async def inspectdb(self, tables: Optional[List[str]] = None) -> str:
+        connection = get_app_connection(self.tortoise_config, self.app)
+        dialect = connection.schema_generator.DIALECT
+        if dialect == "mysql":
+            cls: Type["Inspect"] = InspectMySQL
+        elif dialect == "postgres":
+            cls = InspectPostgres
+        elif dialect == "sqlite":
+            cls = InspectSQLite
+        else:
+            raise NotImplementedError(f"{dialect} is not supported")
+        inspect = cls(connection, tables)
+        return await inspect.inspect()
+
+    async def migrate(self, name: str = "update", empty: bool = False) -> str:
+        return await Migrate.migrate(name, empty)
+
+    async def init_db(self, safe: bool) -> None:
+        location = self.location
+        app = self.app
+        dirname = Path(location, app)
+        dirname.mkdir(parents=True)
+
+        await Tortoise.init(config=self.tortoise_config)
+        connection = get_app_connection(self.tortoise_config, app)
+        await generate_schema_for_client(connection, safe)
+
+        schema = get_schema_sql(connection, safe)
+
+        version = await Migrate.generate_version()
+        await Aerich.create(
+            version=version,
+            app=app,
+            content=get_models_describe(app),
+        )
+        version_file = Path(dirname, version)
+        content = MIGRATE_TEMPLATE.format(upgrade_sql=schema, downgrade_sql="")
+        with open(version_file, "w", encoding="utf-8") as f:
+            f.write(content)

aerich/cli.py

@@ -1,213 +1,249 @@
-import json
 import os
-import sys
+from pathlib import Path
-from configparser import ConfigParser
+from typing import Dict, List, cast
-from enum import Enum
 
 import asyncclick as click
+import tomlkit
 from asyncclick import Context, UsageError
-from tortoise import ConfigurationError, Tortoise, generate_schema_for_client
+from tomlkit.exceptions import NonExistentKey
-from tortoise.transactions import in_transaction
 
-from aerich.migrate import Migrate
+from aerich import Command
-from aerich.utils import get_app_connection, get_app_connection_name, get_tortoise_config
+from aerich.enums import Color
+from aerich.exceptions import DowngradeError
+from aerich.utils import add_src_path, get_tortoise_config
+from aerich.version import __version__
 
-from . import __version__
+CONFIG_DEFAULT_VALUES = {
-from .models import Aerich
+    "src_folder": ".",
-
+}
-
-class Color(str, Enum):
-    green = "green"
-    red = "red"
-    yellow = "yellow"
-
-
-parser = ConfigParser()
 
 
 @click.group(context_settings={"help_option_names": ["-h", "--help"]})
-@click.version_option(__version__)
+@click.version_option(__version__, "-V", "--version")
 @click.option(
-    "-c", "--config", default="aerich.ini", show_default=True, help="Config file.",
+    "-c",
-)
+    "--config",
-@click.option("--app", default="models", show_default=True, help="Tortoise-ORM app name.")
+    default="pyproject.toml",
-@click.option(
-    "-n",
-    "--name",
-    default="aerich",
     show_default=True,
-    help="Name of section in .ini file to use for aerich config.",
+    help="Config file.",
 )
+@click.option("--app", required=False, help="Tortoise-ORM app name.")
 @click.pass_context
-async def cli(ctx: Context, config, app, name):
+async def cli(ctx: Context, config, app) -> None:
     ctx.ensure_object(dict)
     ctx.obj["config_file"] = config
-    ctx.obj["name"] = name
-    ctx.obj["app"] = app
 
     invoked_subcommand = ctx.invoked_subcommand
     if invoked_subcommand != "init":
-        if not os.path.exists(config):
+        config_path = Path(config)
-            raise UsageError("You must exec init first", ctx=ctx)
+        if not config_path.exists():
-        parser.read(config)
+            raise UsageError(
-
+                "You need to run `aerich init` first to create the config file.", ctx=ctx
-        location = parser[name]["location"]
+            )
-        tortoise_orm = parser[name]["tortoise_orm"]
+        content = config_path.read_text()
-
+        doc: dict = tomlkit.parse(content)
+        try:
+            tool = cast(Dict[str, str], doc["tool"]["aerich"])
+            location = tool["location"]
+            tortoise_orm = tool["tortoise_orm"]
+            src_folder = tool.get("src_folder", CONFIG_DEFAULT_VALUES["src_folder"])
+        except NonExistentKey:
+            raise UsageError("You need run `aerich init` again when upgrading to aerich 0.6.0+.")
+        add_src_path(src_folder)
         tortoise_config = get_tortoise_config(ctx, tortoise_orm)
-
+        if not app:
-        ctx.obj["config"] = tortoise_config
+            apps_config = cast(dict, tortoise_config.get("apps"))
-        ctx.obj["location"] = location
+            app = list(apps_config.keys())[0]
-
+        command = Command(tortoise_config=tortoise_config, app=app, location=location)
+        ctx.obj["command"] = command
         if invoked_subcommand != "init-db":
-            try:
+            if not Path(location, app).exists():
-                await Migrate.init_with_old_models(tortoise_config, app, location)
+                raise UsageError(
-            except ConfigurationError:
+                    "You need to run `aerich init-db` first to initialize the database.", ctx=ctx
-                raise UsageError(ctx=ctx, message="You must exec init-db first")
+                )
+            await command.init()
 
 
-@cli.command(help="Generate migrate changes file.")
+@cli.command(help="Generate a migration file for the current state of the models.")
-@click.option("--name", default="update", show_default=True, help="Migrate name.")
+@click.option("--name", default="update", show_default=True, help="Migration name.")
+@click.option("--empty", default=False, is_flag=True, help="Generate an empty migration file.")
 @click.pass_context
-async def migrate(ctx: Context, name):
+async def migrate(ctx: Context, name, empty) -> None:
-    config = ctx.obj["config"]
+    command = ctx.obj["command"]
-    location = ctx.obj["location"]
+    ret = await command.migrate(name, empty)
-    app = ctx.obj["app"]
-
-    ret = await Migrate.migrate(name)
     if not ret:
         return click.secho("No changes detected", fg=Color.yellow)
-    Migrate.write_old_models(config, app, location)
+    click.secho(f"Success creating migration file {ret}", fg=Color.green)
-    click.secho(f"Success migrate {ret}", fg=Color.green)
 
 
-@cli.command(help="Upgrade to latest version.")
+@cli.command(help="Upgrade to specified migration version.")
+@click.option(
+    "--in-transaction",
+    "-i",
+    default=True,
+    type=bool,
+    help="Make migrations in a single transaction or not. Can be helpful for large migrations or creating concurrent indexes.",
+)
 @click.pass_context
-async def upgrade(ctx: Context):
+async def upgrade(ctx: Context, in_transaction: bool) -> None:
-    config = ctx.obj["config"]
+    command = ctx.obj["command"]
-    app = ctx.obj["app"]
+    migrated = await command.upgrade(run_in_transaction=in_transaction)
-    migrated = False
-    for version in Migrate.get_all_version_files():
-        if not await Aerich.exists(version=version, app=app):
-            async with in_transaction(get_app_connection_name(config, app)) as conn:
-                file_path = os.path.join(Migrate.migrate_location, version)
-                with open(file_path, "r") as f:
-                    content = json.load(f)
-                    upgrade_query_list = content.get("upgrade")
-                    for upgrade_query in upgrade_query_list:
-                        await conn.execute_query(upgrade_query)
-            await Aerich.create(version=version, app=app)
-            click.secho(f"Success upgrade {version}", fg=Color.green)
-            migrated = True
     if not migrated:
-        click.secho("No migrate items", fg=Color.yellow)
+        click.secho("No upgrade items found", fg=Color.yellow)
+    else:
+        for version_file in migrated:
+            click.secho(f"Success upgrading to {version_file}", fg=Color.green)
 
 
-@cli.command(help="Downgrade to previous version.")
+@cli.command(help="Downgrade to specified version.")
+@click.option(
+    "-v",
+    "--version",
+    default=-1,
+    type=int,
+    show_default=False,
+    help="Specified version, default to last migration.",
+)
+@click.option(
+    "-d",
+    "--delete",
+    is_flag=True,
+    default=False,
+    show_default=True,
+    help="Also delete the migration files.",
+)
 @click.pass_context
-async def downgrade(ctx: Context):
+@click.confirmation_option(
-    app = ctx.obj["app"]
+    prompt="Downgrade is dangerous: you might lose your data! Are you sure?",
-    config = ctx.obj["config"]
+)
-    last_version = await Migrate.get_last_version()
+async def downgrade(ctx: Context, version: int, delete: bool) -> None:
-    if not last_version:
+    command = ctx.obj["command"]
-        return click.secho("No last version found", fg=Color.yellow)
+    try:
-    file = last_version.version
+        files = await command.downgrade(version, delete)
-    async with in_transaction(get_app_connection_name(config, app)) as conn:
+    except DowngradeError as e:
-        file_path = os.path.join(Migrate.migrate_location, file)
+        return click.secho(str(e), fg=Color.yellow)
-        with open(file_path, "r") as f:
+    for file in files:
-            content = json.load(f)
+        click.secho(f"Success downgrading to {file}", fg=Color.green)
-            downgrade_query_list = content.get("downgrade")
-            for downgrade_query in downgrade_query_list:
-                await conn.execute_query(downgrade_query)
-            await last_version.delete()
-        return click.secho(f"Success downgrade {file}", fg=Color.green)
 
 
-@cli.command(help="Show current available heads in migrate location.")
+@cli.command(help="Show currently available heads (unapplied migrations).")
 @click.pass_context
-async def heads(ctx: Context):
+async def heads(ctx: Context) -> None:
-    app = ctx.obj["app"]
+    command = ctx.obj["command"]
-    versions = Migrate.get_all_version_files()
+    head_list = await command.heads()
-    is_heads = False
+    if not head_list:
-    for version in versions:
+        return click.secho("No available heads.", fg=Color.green)
-        if not await Aerich.exists(version=version, app=app):
+    for version in head_list:
-            click.secho(version, fg=Color.green)
+        click.secho(version, fg=Color.green)
-            is_heads = True
-    if not is_heads:
-        click.secho("No available heads,try migrate", fg=Color.green)
 
 
-@cli.command(help="List all migrate items.")
+@cli.command(help="List all migrations.")
 @click.pass_context
-def history(ctx):
+async def history(ctx: Context) -> None:
-    versions = Migrate.get_all_version_files()
+    command = ctx.obj["command"]
+    versions = await command.history()
+    if not versions:
+        return click.secho("No migrations created yet.", fg=Color.green)
     for version in versions:
         click.secho(version, fg=Color.green)
-    if not versions:
-        click.secho("No history,try migrate", fg=Color.green)
 
 
-@cli.command(help="Init config file and generate root migrate location.")
+@cli.command(help="Initialize aerich config and create migrations folder.")
 @click.option(
     "-t",
     "--tortoise-orm",
     required=True,
-    help="Tortoise-ORM config module dict variable, like settings.TORTOISE_ORM.",
+    help="Tortoise-ORM config dict location, like `settings.TORTOISE_ORM`.",
 )
 @click.option(
-    "--location", default="./migrations", show_default=True, help="Migrate store location."
+    "--location",
+    default="./migrations",
+    show_default=True,
+    help="Migrations folder.",
+)
+@click.option(
+    "-s",
+    "--src_folder",
+    default=CONFIG_DEFAULT_VALUES["src_folder"],
+    show_default=False,
+    help="Folder of the source, relative to the project root.",
 )
 @click.pass_context
-async def init(
+async def init(ctx: Context, tortoise_orm, location, src_folder) -> None:
-    ctx: Context, tortoise_orm, location,
-):
     config_file = ctx.obj["config_file"]
-    name = ctx.obj["name"]
-    if os.path.exists(config_file):
-        return click.secho("You have inited", fg=Color.yellow)
 
-    parser.add_section(name)
+    if os.path.isabs(src_folder):
-    parser.set(name, "tortoise_orm", tortoise_orm)
+        src_folder = os.path.relpath(os.getcwd(), src_folder)
-    parser.set(name, "location", location)
+    # Add ./ so it's clear that this is relative path
+    if not src_folder.startswith("./"):
+        src_folder = "./" + src_folder
 
-    with open(config_file, "w") as f:
+    # check that we can find the configuration, if not we can fail before the config file gets created
-        parser.write(f)
+    add_src_path(src_folder)
+    get_tortoise_config(ctx, tortoise_orm)
+    config_path = Path(config_file)
+    if config_path.exists():
+        content = config_path.read_text()
+    else:
+        content = "[tool.aerich]"
+    doc: dict = tomlkit.parse(content)
+    table = tomlkit.table()
+    table["tortoise_orm"] = tortoise_orm
+    table["location"] = location
+    table["src_folder"] = src_folder
+    doc["tool"]["aerich"] = table
 
-    if not os.path.isdir(location):
+    config_path.write_text(tomlkit.dumps(doc))
-        os.mkdir(location)
 
-    click.secho(f"Success create migrate location {location}", fg=Color.green)
+    Path(location).mkdir(parents=True, exist_ok=True)
-    click.secho(f"Success generate config file {config_file}", fg=Color.green)
+
+    click.secho(f"Success creating migrations folder {location}", fg=Color.green)
+    click.secho(f"Success writing aerich config to {config_file}", fg=Color.green)
 
 
-@cli.command(help="Generate schema and generate app migrate location.")
+@cli.command(help="Generate schema and generate app migration folder.")
 @click.option(
+    "-s",
     "--safe",
+    type=bool,
     is_flag=True,
     default=True,
-    help="When set to true, creates the table only when it does not already exist.",
+    help="Create tables only when they do not already exist.",
     show_default=True,
 )
 @click.pass_context
-async def init_db(ctx: Context, safe):
+async def init_db(ctx: Context, safe: bool) -> None:
-    config = ctx.obj["config"]
+    command = ctx.obj["command"]
-    location = ctx.obj["location"]
+    app = command.app
-    app = ctx.obj["app"]
+    dirname = Path(command.location, app)
-
+    try:
-    dirname = os.path.join(location, app)
+        await command.init_db(safe)
-    if not os.path.isdir(dirname):
+        click.secho(f"Success creating app migration folder {dirname}", fg=Color.green)
-        os.mkdir(dirname)
+        click.secho(f'Success generating initial migration file for app "{app}"', fg=Color.green)
-        click.secho(f"Success create app migrate location {dirname}", fg=Color.green)
+    except FileExistsError:
-
+        return click.secho(
-    Migrate.write_old_models(config, app, location)
+            f"App {app} is already initialized. Delete {dirname} and try again.", fg=Color.yellow
-
+        )
-    await Tortoise.init(config=config)
-    connection = get_app_connection(config, app)
-    await generate_schema_for_client(connection, safe)
-
-    return click.secho(f'Success generate schema for app "{app}"', fg=Color.green)
 
 
-def main():
+@cli.command(help="Prints the current database tables to stdout as Tortoise-ORM models.")
-    sys.path.insert(0, ".")
+@click.option(
-    cli(_anyio_backend="asyncio")
+    "-t",
+    "--table",
+    help="Which tables to inspect.",
+    multiple=True,
+    required=False,
+)
+@click.pass_context
+async def inspectdb(ctx: Context, table: List[str]) -> None:
+    command = ctx.obj["command"]
+    ret = await command.inspectdb(table)
+    click.secho(ret)
+
+
+def main() -> None:
+    cli()
+
+
+if __name__ == "__main__":
+    main()

aerich/coder.py

@@ -0,0 +1,32 @@
+import base64
+import json
+import pickle  # nosec: B301,B403
+from typing import Any, Union
+
+from tortoise.indexes import Index
+
+
+class JsonEncoder(json.JSONEncoder):
+    def default(self, obj) -> Any:
+        if isinstance(obj, Index):
+            return {
+                "type": "index",
+                "val": base64.b64encode(pickle.dumps(obj)).decode(),  # nosec: B301
+            }
+        else:
+            return super().default(obj)
+
+
+def object_hook(obj) -> Any:
+    _type = obj.get("type")
+    if not _type:
+        return obj
+    return pickle.loads(base64.b64decode(obj["val"]))  # nosec: B301
+
+
+def encoder(obj: dict) -> str:
+    return json.dumps(obj, cls=JsonEncoder)
+
+
+def decoder(obj: Union[str, bytes]) -> Any:
+    return json.loads(obj, object_hook=object_hook)

aerich/ddl/__init__.py

@@ -1,67 +1,98 @@
-from typing import List, Type
+from enum import Enum
+from typing import Any, List, Type, cast
 
-from tortoise import BaseDBAsyncClient, ForeignKeyFieldInstance, ManyToManyFieldInstance, Model
+from tortoise import BaseDBAsyncClient, Model
 from tortoise.backends.base.schema_generator import BaseSchemaGenerator
-from tortoise.fields import Field, JSONField, TextField, UUIDField
+
+from aerich.utils import is_default_function
 
 
 class BaseDDL:
     schema_generator_cls: Type[BaseSchemaGenerator] = BaseSchemaGenerator
     DIALECT = "sql"
-    _DROP_TABLE_TEMPLATE = "DROP TABLE IF EXISTS {table_name}"
+    _DROP_TABLE_TEMPLATE = 'DROP TABLE IF EXISTS "{table_name}"'
-    _ADD_COLUMN_TEMPLATE = "ALTER TABLE {table_name} ADD {column}"
+    _ADD_COLUMN_TEMPLATE = 'ALTER TABLE "{table_name}" ADD {column}'
-    _DROP_COLUMN_TEMPLATE = "ALTER TABLE {table_name} DROP COLUMN {column_name}"
+    _DROP_COLUMN_TEMPLATE = 'ALTER TABLE "{table_name}" DROP COLUMN "{column_name}"'
-    _ADD_INDEX_TEMPLATE = (
+    _ALTER_DEFAULT_TEMPLATE = 'ALTER TABLE "{table_name}" ALTER COLUMN "{column}" {default}'
-        "ALTER TABLE {table_name} ADD {unique} INDEX {index_name} ({column_names})"
+    _RENAME_COLUMN_TEMPLATE = (
+        'ALTER TABLE "{table_name}" RENAME COLUMN "{old_column_name}" TO "{new_column_name}"'
     )
-    _DROP_INDEX_TEMPLATE = "ALTER TABLE {table_name} DROP INDEX {index_name}"
+    _ADD_INDEX_TEMPLATE = (
-    _ADD_FK_TEMPLATE = "ALTER TABLE {table_name} ADD CONSTRAINT `{fk_name}` FOREIGN KEY (`{db_column}`) REFERENCES `{table}` (`{field}`) ON DELETE {on_delete}"
+        'ALTER TABLE "{table_name}" ADD {unique}INDEX "{index_name}" ({column_names})'
-    _DROP_FK_TEMPLATE = "ALTER TABLE {table_name} DROP FOREIGN KEY {fk_name}"
+    )
-    _M2M_TABLE_TEMPLATE = "CREATE TABLE {table_name} ({backward_key} {backward_type} NOT NULL REFERENCES {backward_table} ({backward_field}) ON DELETE CASCADE,{forward_key} {forward_type} NOT NULL REFERENCES {forward_table} ({forward_field}) ON DELETE CASCADE){extra}{comment};"
+    _DROP_INDEX_TEMPLATE = 'ALTER TABLE "{table_name}" DROP INDEX "{index_name}"'
+    _ADD_FK_TEMPLATE = 'ALTER TABLE "{table_name}" ADD CONSTRAINT "{fk_name}" FOREIGN KEY ("{db_column}") REFERENCES "{table}" ("{field}") ON DELETE {on_delete}'
+    _DROP_FK_TEMPLATE = 'ALTER TABLE "{table_name}" DROP FOREIGN KEY "{fk_name}"'
+    _M2M_TABLE_TEMPLATE = (
+        'CREATE TABLE "{table_name}" (\n'
+        '    "{backward_key}" {backward_type} NOT NULL REFERENCES "{backward_table}" ("{backward_field}") ON DELETE CASCADE,\n'
+        '    "{forward_key}" {forward_type} NOT NULL REFERENCES "{forward_table}" ("{forward_field}") ON DELETE {on_delete}\n'
+        "){extra}{comment}"
+    )
+    _MODIFY_COLUMN_TEMPLATE = 'ALTER TABLE "{table_name}" MODIFY COLUMN {column}'
+    _CHANGE_COLUMN_TEMPLATE = (
+        'ALTER TABLE "{table_name}" CHANGE {old_column_name} {new_column_name} {new_column_type}'
+    )
+    _RENAME_TABLE_TEMPLATE = 'ALTER TABLE "{old_table_name}" RENAME TO "{new_table_name}"'
 
-    def __init__(self, client: "BaseDBAsyncClient"):
+    def __init__(self, client: "BaseDBAsyncClient") -> None:
         self.client = client
         self.schema_generator = self.schema_generator_cls(client)
 
-    def create_table(self, model: "Type[Model]"):
+    def create_table(self, model: "Type[Model]") -> str:
-        return self.schema_generator._get_table_sql(model, True)["table_creation_string"]
+        return self.schema_generator._get_table_sql(model, True)["table_creation_string"].rstrip(
-
+            ";"
-    def drop_table(self, model: "Type[Model]"):
-        return self._DROP_TABLE_TEMPLATE.format(table_name=model._meta.db_table)
-
-    def create_m2m_table(self, model: "Type[Model]", field: ManyToManyFieldInstance):
-        return self._M2M_TABLE_TEMPLATE.format(
-            table_name=field.through,
-            backward_table=model._meta.db_table,
-            forward_table=field.related_model._meta.db_table,
-            backward_field=model._meta.db_pk_column,
-            forward_field=field.related_model._meta.db_pk_column,
-            backward_key=field.backward_key,
-            backward_type=model._meta.pk.get_for_dialect(self.DIALECT, "SQL_TYPE"),
-            forward_key=field.forward_key,
-            forward_type=field.related_model._meta.pk.get_for_dialect(self.DIALECT, "SQL_TYPE"),
-            extra=self.schema_generator._table_generate_extra(table=field.through),
-            comment=self.schema_generator._table_comment_generator(
-                table=field.through, comment=field.description
-            )
-            if field.description
-            else "",
         )
 
-    def drop_m2m(self, field: ManyToManyFieldInstance):
+    def drop_table(self, table_name: str) -> str:
-        return self._DROP_TABLE_TEMPLATE.format(table_name=field.through)
+        return self._DROP_TABLE_TEMPLATE.format(table_name=table_name)
 
-    def add_column(self, model: "Type[Model]", field_object: Field):
+    def create_m2m(
+        self, model: "Type[Model]", field_describe: dict, reference_table_describe: dict
+    ) -> str:
+        through = cast(str, field_describe.get("through"))
+        description = field_describe.get("description")
+        pk_field = cast(dict, reference_table_describe.get("pk_field"))
+        reference_id = pk_field.get("db_column")
+        db_field_types = cast(dict, pk_field.get("db_field_types"))
+        return self._M2M_TABLE_TEMPLATE.format(
+            table_name=through,
+            backward_table=model._meta.db_table,
+            forward_table=reference_table_describe.get("table"),
+            backward_field=model._meta.db_pk_column,
+            forward_field=reference_id,
+            backward_key=field_describe.get("backward_key"),
+            backward_type=model._meta.pk.get_for_dialect(self.DIALECT, "SQL_TYPE"),
+            forward_key=field_describe.get("forward_key"),
+            forward_type=db_field_types.get(self.DIALECT) or db_field_types.get(""),
+            on_delete=field_describe.get("on_delete"),
+            extra=self.schema_generator._table_generate_extra(table=through),
+            comment=(
+                self.schema_generator._table_comment_generator(table=through, comment=description)
+                if description
+                else ""
+            ),
+        )
+
+    def drop_m2m(self, table_name: str) -> str:
+        return self._DROP_TABLE_TEMPLATE.format(table_name=table_name)
+
+    def _get_default(self, model: "Type[Model]", field_describe: dict) -> Any:
         db_table = model._meta.db_table
-        default = field_object.default
+        default = field_describe.get("default")
-        db_column = field_object.model_field_name
+        if isinstance(default, Enum):
-        auto_now_add = getattr(field_object, "auto_now_add", False)
+            default = default.value
-        auto_now = getattr(field_object, "auto_now", False)
+        db_column = cast(str, field_describe.get("db_column"))
+        auto_now_add = field_describe.get("auto_now_add", False)
+        auto_now = field_describe.get("auto_now", False)
         if default is not None or auto_now_add:
-            if callable(default) or isinstance(field_object, (UUIDField, TextField, JSONField)):
+            if field_describe.get("field_type") in [
+                "UUIDField",
+                "TextField",
+                "JSONField",
+            ] or is_default_function(default):
                 default = ""
             else:
-                default = field_object.to_db_value(default, model)
                 try:
                     default = self.schema_generator._column_default_generator(
                         db_table,
@@ -73,42 +104,85 @@ class BaseDDL:
                 except NotImplementedError:
                     default = ""
         else:
+            default = None
+        return default
+
+    def add_column(self, model: "Type[Model]", field_describe: dict, is_pk: bool = False) -> str:
+        return self._add_or_modify_column(model, field_describe, is_pk)
+
+    def _add_or_modify_column(self, model, field_describe: dict, is_pk: bool, modify=False) -> str:
+        db_table = model._meta.db_table
+        description = field_describe.get("description")
+        db_column = cast(str, field_describe.get("db_column"))
+        db_field_types = cast(dict, field_describe.get("db_field_types"))
+        default = self._get_default(model, field_describe)
+        if default is None:
             default = ""
-        return self._ADD_COLUMN_TEMPLATE.format(
+        if modify:
+            unique = ""
+            template = self._MODIFY_COLUMN_TEMPLATE
+        else:
+            unique = "UNIQUE" if field_describe.get("unique") else ""
+            template = self._ADD_COLUMN_TEMPLATE
+        return template.format(
             table_name=db_table,
             column=self.schema_generator._create_string(
-                db_column=field_object.model_field_name,
+                db_column=db_column,
-                field_type=field_object.get_for_dialect(self.DIALECT, "SQL_TYPE"),
+                field_type=db_field_types.get(self.DIALECT, db_field_types.get("")),
-                nullable="NOT NULL" if not field_object.null else "",
+                nullable="NOT NULL" if not field_describe.get("nullable") else "",
-                unique="UNIQUE" if field_object.unique else "",
+                unique=unique,
-                comment=self.schema_generator._column_comment_generator(
+                comment=(
-                    table=db_table,
+                    self.schema_generator._column_comment_generator(
-                    column=field_object.model_field_name,
+                        table=db_table,
-                    comment=field_object.description,
+                        column=db_column,
-                )
+                        comment=description,
-                if field_object.description
+                    )
-                else "",
+                    if description
-                is_primary_key=field_object.pk,
+                    else ""
+                ),
+                is_primary_key=is_pk,
                 default=default,
             ),
         )
 
-    def drop_column(self, model: "Type[Model]", column_name: str):
+    def drop_column(self, model: "Type[Model]", column_name: str) -> str:
         return self._DROP_COLUMN_TEMPLATE.format(
             table_name=model._meta.db_table, column_name=column_name
         )
 
-    def add_index(self, model: "Type[Model]", field_names: List[str], unique=False):
+    def modify_column(self, model: "Type[Model]", field_describe: dict, is_pk: bool = False) -> str:
+        return self._add_or_modify_column(model, field_describe, is_pk, modify=True)
+
+    def rename_column(
+        self, model: "Type[Model]", old_column_name: str, new_column_name: str
+    ) -> str:
+        return self._RENAME_COLUMN_TEMPLATE.format(
+            table_name=model._meta.db_table,
+            old_column_name=old_column_name,
+            new_column_name=new_column_name,
+        )
+
+    def change_column(
+        self, model: "Type[Model]", old_column_name: str, new_column_name: str, new_column_type: str
+    ) -> str:
+        return self._CHANGE_COLUMN_TEMPLATE.format(
+            table_name=model._meta.db_table,
+            old_column_name=old_column_name,
+            new_column_name=new_column_name,
+            new_column_type=new_column_type,
+        )
+
+    def add_index(self, model: "Type[Model]", field_names: List[str], unique=False) -> str:
         return self._ADD_INDEX_TEMPLATE.format(
-            unique="UNIQUE" if unique else "",
+            unique="UNIQUE " if unique else "",
             index_name=self.schema_generator._generate_index_name(
                 "idx" if not unique else "uid", model, field_names
             ),
             table_name=model._meta.db_table,
-            column_names=", ".join([self.schema_generator.quote(f) for f in field_names]),
+            column_names=", ".join(self.schema_generator.quote(f) for f in field_names),
         )
 
-    def drop_index(self, model: "Type[Model]", field_names: List[str], unique=False):
+    def drop_index(self, model: "Type[Model]", field_names: List[str], unique=False) -> str:
         return self._DROP_INDEX_TEMPLATE.format(
             index_name=self.schema_generator._generate_index_name(
                 "idx" if not unique else "uid", model, field_names
@@ -116,39 +190,68 @@ class BaseDDL:
             table_name=model._meta.db_table,
         )
 
-    def add_fk(self, model: "Type[Model]", field: ForeignKeyFieldInstance):
+    def drop_index_by_name(self, model: "Type[Model]", index_name: str) -> str:
-        db_table = model._meta.db_table
+        return self._DROP_INDEX_TEMPLATE.format(
-        to_field_name = field.to_field_instance.source_field
+            index_name=index_name,
-        if not to_field_name:
+            table_name=model._meta.db_table,
-            to_field_name = field.to_field_instance.model_field_name
+        )
 
-        db_column = field.source_field or field.model_field_name + "_id"
+    def _generate_fk_name(
-        fk_name = self.schema_generator._generate_fk_name(
+        self, db_table, field_describe: dict, reference_table_describe: dict
+    ) -> str:
+        """Generate fk name"""
+        db_column = cast(str, field_describe.get("raw_field"))
+        pk_field = cast(dict, reference_table_describe.get("pk_field"))
+        to_field = cast(str, pk_field.get("db_column"))
+        to_table = cast(str, reference_table_describe.get("table"))
+        return self.schema_generator._generate_fk_name(
             from_table=db_table,
             from_field=db_column,
-            to_table=field.related_model._meta.db_table,
+            to_table=to_table,
-            to_field=to_field_name,
+            to_field=to_field,
-        )
-        return self._ADD_FK_TEMPLATE.format(
-            table_name=db_table,
-            fk_name=fk_name,
-            db_column=db_column,
-            table=field.related_model._meta.db_table,
-            field=to_field_name,
-            on_delete=field.on_delete,
         )
 
-    def drop_fk(self, model: "Type[Model]", field: ForeignKeyFieldInstance):
+    def add_fk(
-        to_field_name = field.to_field_instance.source_field
+        self, model: "Type[Model]", field_describe: dict, reference_table_describe: dict
-        if not to_field_name:
+    ) -> str:
-            to_field_name = field.to_field_instance.model_field_name
         db_table = model._meta.db_table
-        return self._DROP_FK_TEMPLATE.format(
+
+        db_column = field_describe.get("raw_field")
+        pk_field = cast(dict, reference_table_describe.get("pk_field"))
+        reference_id = pk_field.get("db_column")
+        return self._ADD_FK_TEMPLATE.format(
             table_name=db_table,
-            fk_name=self.schema_generator._generate_fk_name(
+            fk_name=self._generate_fk_name(db_table, field_describe, reference_table_describe),
-                from_table=db_table,
+            db_column=db_column,
-                from_field=field.source_field or field.model_field_name + "_id",
+            table=reference_table_describe.get("table"),
-                to_table=field.related_model._meta.db_table,
+            field=reference_id,
-                to_field=to_field_name,
+            on_delete=field_describe.get("on_delete"),
-            ),
+        )
+
+    def drop_fk(
+        self, model: "Type[Model]", field_describe: dict, reference_table_describe: dict
+    ) -> str:
+        db_table = model._meta.db_table
+        fk_name = self._generate_fk_name(db_table, field_describe, reference_table_describe)
+        return self._DROP_FK_TEMPLATE.format(table_name=db_table, fk_name=fk_name)
+
+    def alter_column_default(self, model: "Type[Model]", field_describe: dict) -> str:
+        db_table = model._meta.db_table
+        default = self._get_default(model, field_describe)
+        return self._ALTER_DEFAULT_TEMPLATE.format(
+            table_name=db_table,
+            column=field_describe.get("db_column"),
+            default="SET" + default if default is not None else "DROP DEFAULT",
+        )
+
+    def alter_column_null(self, model: "Type[Model]", field_describe: dict) -> str:
+        return self.modify_column(model, field_describe)
+
+    def set_comment(self, model: "Type[Model]", field_describe: dict) -> str:
+        return self.modify_column(model, field_describe)
+
+    def rename_table(self, model: "Type[Model]", old_table_name: str, new_table_name: str) -> str:
+        db_table = model._meta.db_table
+        return self._RENAME_TABLE_TEMPLATE.format(
+            table_name=db_table, old_table_name=old_table_name, new_table_name=new_table_name
         )

aerich/ddl/mysql/__init__.py

@@ -1,8 +1,63 @@
+from typing import TYPE_CHECKING, List, Type
+
 from tortoise.backends.mysql.schema_generator import MySQLSchemaGenerator
 
 from aerich.ddl import BaseDDL
 
+if TYPE_CHECKING:
+    from tortoise import Model  # noqa:F401
+
 
 class MysqlDDL(BaseDDL):
     schema_generator_cls = MySQLSchemaGenerator
     DIALECT = MySQLSchemaGenerator.DIALECT
+    _DROP_TABLE_TEMPLATE = "DROP TABLE IF EXISTS `{table_name}`"
+    _ADD_COLUMN_TEMPLATE = "ALTER TABLE `{table_name}` ADD {column}"
+    _ALTER_DEFAULT_TEMPLATE = "ALTER TABLE `{table_name}` ALTER COLUMN `{column}` {default}"
+    _CHANGE_COLUMN_TEMPLATE = (
+        "ALTER TABLE `{table_name}` CHANGE {old_column_name} {new_column_name} {new_column_type}"
+    )
+    _DROP_COLUMN_TEMPLATE = "ALTER TABLE `{table_name}` DROP COLUMN `{column_name}`"
+    _RENAME_COLUMN_TEMPLATE = (
+        "ALTER TABLE `{table_name}` RENAME COLUMN `{old_column_name}` TO `{new_column_name}`"
+    )
+    _ADD_INDEX_TEMPLATE = (
+        "ALTER TABLE `{table_name}` ADD {unique}INDEX `{index_name}` ({column_names})"
+    )
+    _DROP_INDEX_TEMPLATE = "ALTER TABLE `{table_name}` DROP INDEX `{index_name}`"
+    _ADD_FK_TEMPLATE = "ALTER TABLE `{table_name}` ADD CONSTRAINT `{fk_name}` FOREIGN KEY (`{db_column}`) REFERENCES `{table}` (`{field}`) ON DELETE {on_delete}"
+    _DROP_FK_TEMPLATE = "ALTER TABLE `{table_name}` DROP FOREIGN KEY `{fk_name}`"
+    _M2M_TABLE_TEMPLATE = (
+        "CREATE TABLE `{table_name}` (\n"
+        "    `{backward_key}` {backward_type} NOT NULL REFERENCES `{backward_table}` (`{backward_field}`) ON DELETE CASCADE,\n"
+        "    `{forward_key}` {forward_type} NOT NULL REFERENCES `{forward_table}` (`{forward_field}`) ON DELETE CASCADE\n"
+        "){extra}{comment}"
+    )
+    _MODIFY_COLUMN_TEMPLATE = "ALTER TABLE `{table_name}` MODIFY COLUMN {column}"
+    _RENAME_TABLE_TEMPLATE = "ALTER TABLE `{old_table_name}` RENAME TO `{new_table_name}`"
+
+    def _index_name(self, unique: bool, model: "Type[Model]", field_names: List[str]) -> str:
+        if unique:
+            if len(field_names) == 1:
+                # Example: `email = CharField(max_length=50, unique=True)`
+                # Generate schema: `"email" VARCHAR(10) NOT NULL UNIQUE`
+                # Unique index key is the same as field name: `email`
+                return field_names[0]
+            index_prefix = "uid"
+        else:
+            index_prefix = "idx"
+        return self.schema_generator._generate_index_name(index_prefix, model, field_names)
+
+    def add_index(self, model: "Type[Model]", field_names: List[str], unique=False) -> str:
+        return self._ADD_INDEX_TEMPLATE.format(
+            unique="UNIQUE " if unique else "",
+            index_name=self._index_name(unique, model, field_names),
+            table_name=model._meta.db_table,
+            column_names=", ".join(self.schema_generator.quote(f) for f in field_names),
+        )
+
+    def drop_index(self, model: "Type[Model]", field_names: List[str], unique=False) -> str:
+        return self._DROP_INDEX_TEMPLATE.format(
+            index_name=self._index_name(unique, model, field_names),
+            table_name=model._meta.db_table,
+        )

aerich/ddl/postgres/__init__.py

@@ -1,3 +1,6 @@
+from typing import Type, cast
+
+from tortoise import Model
 from tortoise.backends.asyncpg.schema_generator import AsyncpgSchemaGenerator
 
 from aerich.ddl import BaseDDL
@@ -6,3 +9,43 @@ from aerich.ddl import BaseDDL
 class PostgresDDL(BaseDDL):
     schema_generator_cls = AsyncpgSchemaGenerator
     DIALECT = AsyncpgSchemaGenerator.DIALECT
+    _ADD_INDEX_TEMPLATE = 'CREATE {unique}INDEX "{index_name}" ON "{table_name}" ({column_names})'
+    _DROP_INDEX_TEMPLATE = 'DROP INDEX "{index_name}"'
+    _ALTER_NULL_TEMPLATE = 'ALTER TABLE "{table_name}" ALTER COLUMN "{column}" {set_drop} NOT NULL'
+    _MODIFY_COLUMN_TEMPLATE = (
+        'ALTER TABLE "{table_name}" ALTER COLUMN "{column}" TYPE {datatype}{using}'
+    )
+    _SET_COMMENT_TEMPLATE = 'COMMENT ON COLUMN "{table_name}"."{column}" IS {comment}'
+    _DROP_FK_TEMPLATE = 'ALTER TABLE "{table_name}" DROP CONSTRAINT "{fk_name}"'
+
+    def alter_column_null(self, model: "Type[Model]", field_describe: dict) -> str:
+        db_table = model._meta.db_table
+        return self._ALTER_NULL_TEMPLATE.format(
+            table_name=db_table,
+            column=field_describe.get("db_column"),
+            set_drop="DROP" if field_describe.get("nullable") else "SET",
+        )
+
+    def modify_column(self, model: "Type[Model]", field_describe: dict, is_pk: bool = False) -> str:
+        db_table = model._meta.db_table
+        db_field_types = cast(dict, field_describe.get("db_field_types"))
+        db_column = field_describe.get("db_column")
+        datatype = db_field_types.get(self.DIALECT) or db_field_types.get("")
+        return self._MODIFY_COLUMN_TEMPLATE.format(
+            table_name=db_table,
+            column=db_column,
+            datatype=datatype,
+            using=f' USING "{db_column}"::{datatype}',
+        )
+
+    def set_comment(self, model: "Type[Model]", field_describe: dict) -> str:
+        db_table = model._meta.db_table
+        return self._SET_COMMENT_TEMPLATE.format(
+            table_name=db_table,
+            column=field_describe.get("db_column") or field_describe.get("raw_field"),
+            comment=(
+                "'{}'".format(field_describe.get("description"))
+                if field_describe.get("description")
+                else "NULL"
+            ),
+        )

aerich/ddl/sqlite/__init__.py

@@ -1,8 +1,24 @@
+from typing import Type
+
+from tortoise import Model
 from tortoise.backends.sqlite.schema_generator import SqliteSchemaGenerator
 
 from aerich.ddl import BaseDDL
+from aerich.exceptions import NotSupportError
 
 
 class SqliteDDL(BaseDDL):
     schema_generator_cls = SqliteSchemaGenerator
     DIALECT = SqliteSchemaGenerator.DIALECT
+
+    def modify_column(self, model: "Type[Model]", field_object: dict, is_pk: bool = True):
+        raise NotSupportError("Modify column is unsupported in SQLite.")
+
+    def alter_column_default(self, model: "Type[Model]", field_describe: dict):
+        raise NotSupportError("Alter column default is unsupported in SQLite.")
+
+    def alter_column_null(self, model: "Type[Model]", field_describe: dict):
+        raise NotSupportError("Alter column null is unsupported in SQLite.")
+
+    def set_comment(self, model: "Type[Model]", field_describe: dict):
+        raise NotSupportError("Alter column comment is unsupported in SQLite.")

aerich/enums.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+
+class Color(str, Enum):
+    green = "green"
+    red = "red"
+    yellow = "yellow"

aerich/exceptions.py

@@ -1,6 +1,10 @@
-class ConfigurationError(Exception):
+class NotSupportError(Exception):
     """
-    config error
+    raise when features not support
     """
 
-    pass
+
+class DowngradeError(Exception):
+    """
+    raise when downgrade error
+    """

aerich/inspectdb/__init__.py

@@ -0,0 +1,186 @@
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, Optional, TypedDict
+
+from pydantic import BaseModel
+from tortoise import BaseDBAsyncClient
+
+
+class ColumnInfoDict(TypedDict):
+    name: str
+    pk: str
+    index: str
+    null: str
+    default: str
+    length: str
+    comment: str
+
+
+FieldMapDict = Dict[str, Callable[..., str]]
+
+
+class Column(BaseModel):
+    name: str
+    data_type: str
+    null: bool
+    default: Any
+    comment: Optional[str] = None
+    pk: bool
+    unique: bool
+    index: bool
+    length: Optional[int] = None
+    extra: Optional[str] = None
+    decimal_places: Optional[int] = None
+    max_digits: Optional[int] = None
+
+    def translate(self) -> ColumnInfoDict:
+        comment = default = length = index = null = pk = ""
+        if self.pk:
+            pk = "pk=True, "
+        else:
+            if self.unique:
+                index = "unique=True, "
+            else:
+                if self.index:
+                    index = "index=True, "
+        if self.data_type in ("varchar", "VARCHAR"):
+            length = f"max_length={self.length}, "
+        elif self.data_type in ("decimal", "numeric"):
+            length_parts = []
+            if self.max_digits:
+                length_parts.append(f"max_digits={self.max_digits}")
+            if self.decimal_places:
+                length_parts.append(f"decimal_places={self.decimal_places}")
+            if length_parts:
+                length = ", ".join(length_parts) + ", "
+        if self.null:
+            null = "null=True, "
+        if self.default is not None:
+            if self.data_type in ("tinyint", "INT"):
+                default = f"default={'True' if self.default == '1' else 'False'}, "
+            elif self.data_type == "bool":
+                default = f"default={'True' if self.default == 'true' else 'False'}, "
+            elif self.data_type in ("datetime", "timestamptz", "TIMESTAMP"):
+                if "CURRENT_TIMESTAMP" == self.default:
+                    if "DEFAULT_GENERATED on update CURRENT_TIMESTAMP" == self.extra:
+                        default = "auto_now=True, "
+                    else:
+                        default = "auto_now_add=True, "
+            else:
+                if "::" in self.default:
+                    default = f"default={self.default.split('::')[0]}, "
+                elif self.default.endswith("()"):
+                    default = ""
+                elif self.default == "":
+                    default = 'default=""'
+                else:
+                    default = f"default={self.default}, "
+
+        if self.comment:
+            comment = f"description='{self.comment}', "
+        return {
+            "name": self.name,
+            "pk": pk,
+            "index": index,
+            "null": null,
+            "default": default,
+            "length": length,
+            "comment": comment,
+        }
+
+
+class Inspect:
+    _table_template = "class {table}(Model):\n"
+
+    def __init__(self, conn: BaseDBAsyncClient, tables: list[str] | None = None) -> None:
+        self.conn = conn
+        try:
+            self.database = conn.database  # type:ignore[attr-defined]
+        except AttributeError:
+            pass
+        self.tables = tables
+
+    @property
+    def field_map(self) -> FieldMapDict:
+        raise NotImplementedError
+
+    async def inspect(self) -> str:
+        if not self.tables:
+            self.tables = await self.get_all_tables()
+        result = "from tortoise import Model, fields\n\n\n"
+        tables = []
+        for table in self.tables:
+            columns = await self.get_columns(table)
+            fields = []
+            model = self._table_template.format(table=table.title().replace("_", ""))
+            for column in columns:
+                field = self.field_map[column.data_type](**column.translate())
+                fields.append("    " + field)
+            tables.append(model + "\n".join(fields))
+        return result + "\n\n\n".join(tables)
+
+    async def get_columns(self, table: str) -> list[Column]:
+        raise NotImplementedError
+
+    async def get_all_tables(self) -> list[str]:
+        raise NotImplementedError
+
+    @classmethod
+    def decimal_field(cls, **kwargs) -> str:
+        return "{name} = fields.DecimalField({pk}{index}{length}{null}{default}{comment})".format(
+            **kwargs
+        )
+
+    @classmethod
+    def time_field(cls, **kwargs) -> str:
+        return "{name} = fields.TimeField({null}{default}{comment})".format(**kwargs)
+
+    @classmethod
+    def date_field(cls, **kwargs) -> str:
+        return "{name} = fields.DateField({null}{default}{comment})".format(**kwargs)
+
+    @classmethod
+    def float_field(cls, **kwargs) -> str:
+        return "{name} = fields.FloatField({null}{default}{comment})".format(**kwargs)
+
+    @classmethod
+    def datetime_field(cls, **kwargs) -> str:
+        return "{name} = fields.DatetimeField({null}{default}{comment})".format(**kwargs)
+
+    @classmethod
+    def text_field(cls, **kwargs) -> str:
+        return "{name} = fields.TextField({null}{default}{comment})".format(**kwargs)
+
+    @classmethod
+    def char_field(cls, **kwargs) -> str:
+        return "{name} = fields.CharField({pk}{index}{length}{null}{default}{comment})".format(
+            **kwargs
+        )
+
+    @classmethod
+    def int_field(cls, **kwargs) -> str:
+        return "{name} = fields.IntField({pk}{index}{comment})".format(**kwargs)
+
+    @classmethod
+    def smallint_field(cls, **kwargs) -> str:
+        return "{name} = fields.SmallIntField({pk}{index}{comment})".format(**kwargs)
+
+    @classmethod
+    def bigint_field(cls, **kwargs) -> str:
+        return "{name} = fields.BigIntField({pk}{index}{default}{comment})".format(**kwargs)
+
+    @classmethod
+    def bool_field(cls, **kwargs) -> str:
+        return "{name} = fields.BooleanField({null}{default}{comment})".format(**kwargs)
+
+    @classmethod
+    def uuid_field(cls, **kwargs) -> str:
+        return "{name} = fields.UUIDField({pk}{index}{default}{comment})".format(**kwargs)
+
+    @classmethod
+    def json_field(cls, **kwargs) -> str:
+        return "{name} = fields.JSONField({null}{default}{comment})".format(**kwargs)
+
+    @classmethod
+    def binary_field(cls, **kwargs) -> str:
+        return "{name} = fields.BinaryField({null}{default}{comment})".format(**kwargs)

aerich/inspectdb/mysql.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from aerich.inspectdb import Column, FieldMapDict, Inspect
+
+
+class InspectMySQL(Inspect):
+    @property
+    def field_map(self) -> FieldMapDict:
+        return {
+            "int": self.int_field,
+            "smallint": self.smallint_field,
+            "tinyint": self.bool_field,
+            "bigint": self.bigint_field,
+            "varchar": self.char_field,
+            "char": self.char_field,
+            "longtext": self.text_field,
+            "text": self.text_field,
+            "datetime": self.datetime_field,
+            "float": self.float_field,
+            "date": self.date_field,
+            "time": self.time_field,
+            "decimal": self.decimal_field,
+            "json": self.json_field,
+            "longblob": self.binary_field,
+        }
+
+    async def get_all_tables(self) -> list[str]:
+        sql = "select TABLE_NAME from information_schema.TABLES where TABLE_SCHEMA=%s"
+        ret = await self.conn.execute_query_dict(sql, [self.database])
+        return list(map(lambda x: x["TABLE_NAME"], ret))
+
+    async def get_columns(self, table: str) -> list[Column]:
+        columns = []
+        sql = """select c.*, s.NON_UNIQUE, s.INDEX_NAME
+from information_schema.COLUMNS c
+         left join information_schema.STATISTICS s on c.TABLE_NAME = s.TABLE_NAME
+    and c.TABLE_SCHEMA = s.TABLE_SCHEMA
+    and c.COLUMN_NAME = s.COLUMN_NAME
+where c.TABLE_SCHEMA = %s
+  and c.TABLE_NAME = %s"""
+        ret = await self.conn.execute_query_dict(sql, [self.database, table])
+        for row in ret:
+            non_unique = row["NON_UNIQUE"]
+            if non_unique is None:
+                unique = False
+            else:
+                unique = not non_unique
+            index_name = row["INDEX_NAME"]
+            if index_name is None:
+                index = False
+            else:
+                index = row["INDEX_NAME"] != "PRIMARY"
+            columns.append(
+                Column(
+                    name=row["COLUMN_NAME"],
+                    data_type=row["DATA_TYPE"],
+                    null=row["IS_NULLABLE"] == "YES",
+                    default=row["COLUMN_DEFAULT"],
+                    pk=row["COLUMN_KEY"] == "PRI",
+                    comment=row["COLUMN_COMMENT"],
+                    unique=row["COLUMN_KEY"] == "UNI",
+                    extra=row["EXTRA"],
+                    # TODO: why `unque`?
+                    unque=unique,  # type:ignore
+                    index=index,
+                    length=row["CHARACTER_MAXIMUM_LENGTH"],
+                    max_digits=row["NUMERIC_PRECISION"],
+                    decimal_places=row["NUMERIC_SCALE"],
+                )
+            )
+        return columns

aerich/inspectdb/postgres.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from aerich.inspectdb import Column, FieldMapDict, Inspect
+
+if TYPE_CHECKING:
+    from tortoise.backends.base_postgres.client import BasePostgresClient
+
+
+class InspectPostgres(Inspect):
+    def __init__(self, conn: "BasePostgresClient", tables: list[str] | None = None) -> None:
+        super().__init__(conn, tables)
+        self.schema = conn.server_settings.get("schema") or "public"
+
+    @property
+    def field_map(self) -> FieldMapDict:
+        return {
+            "int4": self.int_field,
+            "int8": self.int_field,
+            "smallint": self.smallint_field,
+            "varchar": self.char_field,
+            "text": self.text_field,
+            "bigint": self.bigint_field,
+            "timestamptz": self.datetime_field,
+            "float4": self.float_field,
+            "float8": self.float_field,
+            "date": self.date_field,
+            "time": self.time_field,
+            "decimal": self.decimal_field,
+            "numeric": self.decimal_field,
+            "uuid": self.uuid_field,
+            "jsonb": self.json_field,
+            "bytea": self.binary_field,
+            "bool": self.bool_field,
+            "timestamp": self.datetime_field,
+        }
+
+    async def get_all_tables(self) -> list[str]:
+        sql = "select TABLE_NAME from information_schema.TABLES where table_catalog=$1 and table_schema=$2"
+        ret = await self.conn.execute_query_dict(sql, [self.database, self.schema])
+        return list(map(lambda x: x["table_name"], ret))
+
+    async def get_columns(self, table: str) -> list[Column]:
+        columns = []
+        sql = f"""select c.column_name,
+       col_description('public.{table}'::regclass, ordinal_position) as column_comment,
+       t.constraint_type as column_key,
+       udt_name as data_type,
+       is_nullable,
+       column_default,
+       character_maximum_length,
+       numeric_precision,
+       numeric_scale
+from information_schema.constraint_column_usage const
+         join information_schema.table_constraints t
+              using (table_catalog, table_schema, table_name, constraint_catalog, constraint_schema, constraint_name)
+         right join information_schema.columns c using (column_name, table_catalog, table_schema, table_name)
+where c.table_catalog = $1
+  and c.table_name = $2
+  and c.table_schema = $3"""  # nosec:B608
+        ret = await self.conn.execute_query_dict(sql, [self.database, table, self.schema])
+        for row in ret:
+            columns.append(
+                Column(
+                    name=row["column_name"],
+                    data_type=row["data_type"],
+                    null=row["is_nullable"] == "YES",
+                    default=row["column_default"],
+                    length=row["character_maximum_length"],
+                    max_digits=row["numeric_precision"],
+                    decimal_places=row["numeric_scale"],
+                    comment=row["column_comment"],
+                    pk=row["column_key"] == "PRIMARY KEY",
+                    unique=False,  # can't get this simply
+                    index=False,  # can't get this simply
+                )
+            )
+        return columns

aerich/inspectdb/sqlite.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from aerich.inspectdb import Column, FieldMapDict, Inspect
+
+
+class InspectSQLite(Inspect):
+    @property
+    def field_map(self) -> FieldMapDict:
+        return {
+            "INTEGER": self.int_field,
+            "INT": self.bool_field,
+            "SMALLINT": self.smallint_field,
+            "VARCHAR": self.char_field,
+            "TEXT": self.text_field,
+            "TIMESTAMP": self.datetime_field,
+            "REAL": self.float_field,
+            "BIGINT": self.bigint_field,
+            "DATE": self.date_field,
+            "TIME": self.time_field,
+            "JSON": self.json_field,
+            "BLOB": self.binary_field,
+        }
+
+    async def get_columns(self, table: str) -> list[Column]:
+        columns = []
+        sql = f"PRAGMA table_info({table})"
+        ret = await self.conn.execute_query_dict(sql)
+        columns_index = await self._get_columns_index(table)
+        for row in ret:
+            try:
+                length = row["type"].split("(")[1].split(")")[0]
+            except IndexError:
+                length = None
+            columns.append(
+                Column(
+                    name=row["name"],
+                    data_type=row["type"].split("(")[0],
+                    null=row["notnull"] == 0,
+                    default=row["dflt_value"],
+                    length=length,
+                    pk=row["pk"] == 1,
+                    unique=columns_index.get(row["name"]) == "unique",
+                    index=columns_index.get(row["name"]) == "index",
+                )
+            )
+        return columns
+
+    async def _get_columns_index(self, table: str) -> dict[str, str]:
+        sql = f"PRAGMA index_list ({table})"
+        indexes = await self.conn.execute_query_dict(sql)
+        ret = {}
+        for index in indexes:
+            sql = f"PRAGMA index_info({index['name']})"
+            index_info = (await self.conn.execute_query_dict(sql))[0]
+            ret[index_info["name"]] = "unique" if index["unique"] else "index"
+        return ret
+
+    async def get_all_tables(self) -> list[str]:
+        sql = "select tbl_name from sqlite_master where type='table' and name!='sqlite_sequence'"
+        ret = await self.conn.execute_query_dict(sql)
+        return list(map(lambda x: x["tbl_name"], ret))

aerich/migrate.py

@@ -1,23 +1,32 @@
-import json
+import hashlib
+import importlib
 import os
-import re
-from copy import deepcopy
 from datetime import datetime
-from typing import Dict, List, Tuple, Type
+from pathlib import Path
+from typing import Dict, Iterable, List, Optional, Set, Tuple, Type, Union, cast
 
-from tortoise import (
+import asyncclick as click
-    BackwardFKRelation,
+from dictdiffer import diff
-    BackwardOneToOneRelation,
+from tortoise import BaseDBAsyncClient, Model, Tortoise
-    ForeignKeyFieldInstance,
+from tortoise.exceptions import OperationalError
-    ManyToManyFieldInstance,
+from tortoise.indexes import Index
-    Model,
-    Tortoise,
-)
-from tortoise.fields import Field
 
 from aerich.ddl import BaseDDL
-from aerich.models import Aerich
+from aerich.models import MAX_VERSION_LENGTH, Aerich
-from aerich.utils import get_app_connection
+from aerich.utils import get_app_connection, get_models_describe, is_default_function
+
+MIGRATE_TEMPLATE = """from tortoise import BaseDBAsyncClient
+
+
+async def upgrade(db: BaseDBAsyncClient) -> str:
+    return \"\"\"
+        {upgrade_sql}\"\"\"
+
+
+async def downgrade(db: BaseDBAsyncClient) -> str:
+    return \"\"\"
+        {downgrade_sql}\"\"\"
+"""
 
 
 class Migrate:
@@ -27,169 +36,189 @@ class Migrate:
     _downgrade_fk_m2m_index_operators: List[str] = []
     _upgrade_m2m: List[str] = []
     _downgrade_m2m: List[str] = []
+    _aerich = Aerich.__name__
+    _rename_old: List[str] = []
+    _rename_new: List[str] = []
 
     ddl: BaseDDL
-    migrate_config: dict
+    ddl_class: Type[BaseDDL]
-    old_models = "old_models"
+    _last_version_content: Optional[dict] = None
-    diff_app = "diff_models"
     app: str
-    migrate_location: str
+    migrate_location: Path
+    dialect: str
+    _db_version: Optional[str] = None
 
-    @classmethod
+    @staticmethod
-    def get_old_model_file(cls):
+    def get_field_by_name(name: str, fields: List[dict]) -> dict:
-        return cls.old_models + ".py"
+        return next(filter(lambda x: x.get("name") == name, fields))
 
     @classmethod
     def get_all_version_files(cls) -> List[str]:
-        return sorted(filter(lambda x: x.endswith("json"), os.listdir(cls.migrate_location)))
+        return sorted(
+            filter(lambda x: x.endswith("py"), os.listdir(cls.migrate_location)),
+            key=lambda x: int(x.split("_")[0]),
+        )
 
     @classmethod
-    async def get_last_version(cls) -> Aerich:
+    def _get_model(cls, model: str) -> Type[Model]:
-        return await Aerich.filter(app=cls.app).first()
+        return Tortoise.apps[cls.app][model]
 
     @classmethod
-    async def init_with_old_models(cls, config: dict, app: str, location: str):
+    async def get_last_version(cls) -> Optional[Aerich]:
-        migrate_config = cls._get_migrate_config(config, app, location)
+        try:
+            return await Aerich.filter(app=cls.app).first()
+        except OperationalError:
+            return None
 
+    @classmethod
+    async def _get_db_version(cls, connection: BaseDBAsyncClient) -> None:
+        if cls.dialect == "mysql":
+            sql = "select version() as version"
+            ret = await connection.execute_query(sql)
+            cls._db_version = ret[1][0].get("version")
+
+    @classmethod
+    async def load_ddl_class(cls) -> Type[BaseDDL]:
+        ddl_dialect_module = importlib.import_module(f"aerich.ddl.{cls.dialect}")
+        return getattr(ddl_dialect_module, f"{cls.dialect.capitalize()}DDL")
+
+    @classmethod
+    async def init(cls, config: dict, app: str, location: str) -> None:
+        await Tortoise.init(config=config)
+        last_version = await cls.get_last_version()
         cls.app = app
-        cls.migrate_config = migrate_config
+        cls.migrate_location = Path(location, app)
-        cls.migrate_location = os.path.join(location, app)
+        if last_version:
-
+            cls._last_version_content = cast(dict, last_version.content)
-        await Tortoise.init(config=migrate_config)
 
         connection = get_app_connection(config, app)
-        if connection.schema_generator.DIALECT == "mysql":
+        cls.dialect = connection.schema_generator.DIALECT
-            from aerich.ddl.mysql import MysqlDDL
+        cls.ddl_class = await cls.load_ddl_class()
-
+        cls.ddl = cls.ddl_class(connection)
-            cls.ddl = MysqlDDL(connection)
+        await cls._get_db_version(connection)
-        elif connection.schema_generator.DIALECT == "sqlite":
-            from aerich.ddl.sqlite import SqliteDDL
-
-            cls.ddl = SqliteDDL(connection)
-        elif connection.schema_generator.DIALECT == "postgres":
-            from aerich.ddl.postgres import PostgresDDL
-
-            cls.ddl = PostgresDDL(connection)
-        else:
-            raise NotImplementedError("Current only support MySQL")
 
     @classmethod
-    async def _get_last_version_num(cls):
+    async def _get_last_version_num(cls) -> Optional[int]:
         last_version = await cls.get_last_version()
         if not last_version:
-            return 0
+            return None
         version = last_version.version
-        return version.split("_")[0]
+        return int(version.split("_", 1)[0])
 
     @classmethod
-    async def _generate_diff_sql(cls, name):
+    async def generate_version(cls, name=None) -> str:
-        now = datetime.now().strftime("%Y%M%D%H%M%S").replace("/", "")
+        now = datetime.now().strftime("%Y%m%d%H%M%S").replace("/", "")
         last_version_num = await cls._get_last_version_num()
-        version = f"{last_version_num + 1}_{now}_{name}.json"
+        if last_version_num is None:
-        content = {
+            return f"0_{now}_init.py"
-            "upgrade": cls.upgrade_operators,
+        version = f"{last_version_num + 1}_{now}_{name}.py"
-            "downgrade": cls.downgrade_operators,
+        if len(version) > MAX_VERSION_LENGTH:
-        }
+            raise ValueError(f"Version name exceeds maximum length ({MAX_VERSION_LENGTH})")
-        with open(os.path.join(cls.migrate_location, version), "w") as f:
-            json.dump(content, f, indent=2, ensure_ascii=False)
         return version
 
     @classmethod
-    async def migrate(cls, name) -> str:
+    async def _generate_diff_py(cls, name) -> str:
+        version = await cls.generate_version(name)
+        # delete if same version exists
+        for version_file in cls.get_all_version_files():
+            if version_file.startswith(version.split("_")[0]):
+                os.unlink(Path(cls.migrate_location, version_file))
+
+        content = cls._get_diff_file_content()
+        Path(cls.migrate_location, version).write_text(content, encoding="utf-8")
+        return version
+
+    @classmethod
+    async def migrate(cls, name: str, empty: bool) -> str:
         """
         diff old models and new models to generate diff content
-        :param name:
+        :param name: str name for migration
+        :param empty: bool if True generates empty migration
         :return:
         """
-        apps = Tortoise.apps
+        if empty:
-        diff_models = apps.get(cls.diff_app)
+            return await cls._generate_diff_py(name)
-        app_models = apps.get(cls.app)
+        new_version_content = get_models_describe(cls.app)
-
+        last_version = cast(dict, cls._last_version_content)
-        cls._diff_models(diff_models, app_models)
+        cls.diff_models(last_version, new_version_content)
-        cls._diff_models(app_models, diff_models, False)
+        cls.diff_models(new_version_content, last_version, False)
 
         cls._merge_operators()
 
         if not cls.upgrade_operators:
             return ""
 
-        return await cls._generate_diff_sql(name)
+        return await cls._generate_diff_py(name)
 
     @classmethod
-    def _add_operator(cls, operator: str, upgrade=True, fk=False):
+    def _get_diff_file_content(cls) -> str:
+        """
+        builds content for diff file from template
+        """
+
+        def join_lines(lines: List[str]) -> str:
+            if not lines:
+                return ""
+            return ";\n        ".join(lines) + ";"
+
+        return MIGRATE_TEMPLATE.format(
+            upgrade_sql=join_lines(cls.upgrade_operators),
+            downgrade_sql=join_lines(cls.downgrade_operators),
+        )
+
+    @classmethod
+    def _add_operator(cls, operator: str, upgrade=True, fk_m2m_index=False) -> None:
         """
         add operator,differentiate fk because fk is order limit
         :param operator:
         :param upgrade:
-        :param fk_m2m:
+        :param fk_m2m_index:
         :return:
         """
+        operator = operator.rstrip(";")
         if upgrade:
-            if fk:
+            if fk_m2m_index:
                 cls._upgrade_fk_m2m_index_operators.append(operator)
             else:
                 cls.upgrade_operators.append(operator)
         else:
-            if fk:
+            if fk_m2m_index:
                 cls._downgrade_fk_m2m_index_operators.append(operator)
             else:
                 cls.downgrade_operators.append(operator)
 
     @classmethod
-    def cp_models(
+    def _handle_indexes(cls, model: Type[Model], indexes: List[Union[Tuple[str], Index]]) -> list:
-        cls, app: str, model_files: List[str], old_model_file,
+        ret: list = []
-    ):
+
-        """
+        def index_hash(self) -> str:
-        cp currents models to old_model_files
+            h = hashlib.new("MD5", usedforsecurity=False)  # type:ignore[call-arg]
-        :param app:
+            h.update(
-        :param model_files:
+                self.index_name(cls.ddl.schema_generator, model).encode()
-        :param old_model_file:
+                + self.__class__.__name__.encode()
-        :return:
+            )
-        """
+            return h.hexdigest()
-        pattern = rf"(\n)?('|\")({app})(.\w+)('|\")"
+
-        for i, model_file in enumerate(model_files):
+        for index in indexes:
-            with open(model_file, "r") as f:
+            if isinstance(index, Index):
-                content = f.read()
+                index.__hash__ = index_hash  # type:ignore[method-assign,assignment]
-            ret = re.sub(pattern, rf"\2{cls.diff_app}\4\5", content)
+            ret.append(index)
-            mode = "w" if i == 0 else "a"
+        return ret
-            with open(old_model_file, mode) as f:
-                f.write(ret)
 
     @classmethod
-    def _get_migrate_config(cls, config: dict, app: str, location: str):
+    def _get_indexes(cls, model, model_describe: dict) -> Set[Union[Index, Tuple[str, ...]]]:
-        """
+        indexes: Set[Union[Index, Tuple[str, ...]]] = set()
-        generate tmp config with old models
+        for x in cls._handle_indexes(model, model_describe.get("indexes", [])):
-        :param config:
+            if isinstance(x, Index):
-        :param app:
+                indexes.add(x)
-        :param location:
+            else:
-        :return:
+                indexes.add(cast(Tuple[str, ...], tuple(x)))
-        """
+        return indexes
-        temp_config = deepcopy(config)
-        path = os.path.join(location, app, cls.old_models)
-        path = path.replace("/", ".").lstrip(".")
-        temp_config["apps"][cls.diff_app] = {"models": [path]}
-        return temp_config
 
     @classmethod
-    def write_old_models(cls, config: dict, app: str, location: str):
+    def diff_models(
-        """
+        cls, old_models: Dict[str, dict], new_models: Dict[str, dict], upgrade=True
-        write new models to old models
+    ) -> None:
-        :param config:
-        :param app:
-        :param location:
-        :return:
-        """
-        old_model_files = []
-        models = config.get("apps").get(app).get("models")
-        for model in models:
-            old_model_files.append(model.replace(".", "/") + ".py")
-
-        cls.cp_models(app, old_model_files, os.path.join(location, app, cls.get_old_model_file()))
-
-    @classmethod
-    def _diff_models(
-        cls, old_models: Dict[str, Type[Model]], new_models: Dict[str, Type[Model]], upgrade=True
-    ):
         """
         diff models and add operators
         :param old_models:
@@ -197,180 +226,423 @@ class Migrate:
         :param upgrade:
         :return:
         """
-        for new_model_str, new_model in new_models.items():
+        _aerich = f"{cls.app}.{cls._aerich}"
-            if new_model_str not in old_models.keys():
+        old_models.pop(_aerich, None)
-                cls._add_operator(cls.add_model(new_model), upgrade)
+        new_models.pop(_aerich, None)
-            else:
-                cls.diff_model(old_models.get(new_model_str), new_model, upgrade)
 
-        for old_model in old_models:
+        for new_model_str, new_model_describe in new_models.items():
-            if old_model not in new_models.keys():
+            model = cls._get_model(new_model_describe["name"].split(".")[1])
-                cls._add_operator(cls.remove_model(old_models.get(old_model)), upgrade)
+
+            if new_model_str not in old_models:
+                if upgrade:
+                    cls._add_operator(cls.add_model(model), upgrade)
+                else:
+                    # we can't find origin model when downgrade, so skip
+                    pass
+            else:
+                old_model_describe = cast(dict, old_models.get(new_model_str))
+                # rename table
+                new_table = cast(str, new_model_describe.get("table"))
+                old_table = cast(str, old_model_describe.get("table"))
+                if new_table != old_table:
+                    cls._add_operator(cls.rename_table(model, old_table, new_table), upgrade)
+                old_unique_together = set(
+                    map(
+                        lambda x: tuple(x),
+                        cast(List[Iterable[str]], old_model_describe.get("unique_together")),
+                    )
+                )
+                new_unique_together = set(
+                    map(
+                        lambda x: tuple(x),
+                        cast(List[Iterable[str]], new_model_describe.get("unique_together")),
+                    )
+                )
+                old_indexes = cls._get_indexes(model, old_model_describe)
+                new_indexes = cls._get_indexes(model, new_model_describe)
+                old_pk_field = old_model_describe.get("pk_field")
+                new_pk_field = new_model_describe.get("pk_field")
+                # pk field
+                changes = diff(old_pk_field, new_pk_field)
+                for action, option, change in changes:
+                    # current only support rename pk
+                    if action == "change" and option == "name":
+                        cls._add_operator(cls._rename_field(model, *change), upgrade)
+                # m2m fields
+                old_m2m_fields = cast(List[dict], old_model_describe.get("m2m_fields"))
+                new_m2m_fields = cast(List[dict], new_model_describe.get("m2m_fields"))
+                for action, option, change in diff(old_m2m_fields, new_m2m_fields):
+                    if change[0][0] == "db_constraint":
+                        continue
+                    new_value = change[0][1]
+                    if isinstance(new_value, str):
+                        for new_m2m_field in new_m2m_fields:
+                            if new_m2m_field["name"] == new_value:
+                                table = cast(str, new_m2m_field.get("through"))
+                                break
+                    else:
+                        table = new_value.get("through")
+                    if action == "add":
+                        add = False
+                        if upgrade and table not in cls._upgrade_m2m:
+                            cls._upgrade_m2m.append(table)
+                            add = True
+                        elif not upgrade and table not in cls._downgrade_m2m:
+                            cls._downgrade_m2m.append(table)
+                            add = True
+                        if add:
+                            ref_desc = cast(dict, new_models.get(new_value.get("model_name")))
+                            cls._add_operator(
+                                cls.create_m2m(model, new_value, ref_desc),
+                                upgrade,
+                                fk_m2m_index=True,
+                            )
+                    elif action == "remove":
+                        add = False
+                        if upgrade and table not in cls._upgrade_m2m:
+                            cls._upgrade_m2m.append(table)
+                            add = True
+                        elif not upgrade and table not in cls._downgrade_m2m:
+                            cls._downgrade_m2m.append(table)
+                            add = True
+                        if add:
+                            cls._add_operator(cls.drop_m2m(table), upgrade, True)
+                # add unique_together
+                for index in new_unique_together.difference(old_unique_together):
+                    cls._add_operator(cls._add_index(model, index, True), upgrade, True)
+                # remove unique_together
+                for index in old_unique_together.difference(new_unique_together):
+                    cls._add_operator(cls._drop_index(model, index, True), upgrade, True)
+                # add indexes
+                for idx in new_indexes.difference(old_indexes):
+                    cls._add_operator(cls._add_index(model, idx, False), upgrade, True)
+                # remove indexes
+                for idx in old_indexes.difference(new_indexes):
+                    cls._add_operator(cls._drop_index(model, idx, False), upgrade, True)
+                old_data_fields = list(
+                    filter(
+                        lambda x: x.get("db_field_types") is not None,
+                        cast(List[dict], old_model_describe.get("data_fields")),
+                    )
+                )
+                new_data_fields = list(
+                    filter(
+                        lambda x: x.get("db_field_types") is not None,
+                        cast(List[dict], new_model_describe.get("data_fields")),
+                    )
+                )
+
+                old_data_fields_name = cast(List[str], [i.get("name") for i in old_data_fields])
+                new_data_fields_name = cast(List[str], [i.get("name") for i in new_data_fields])
+
+                # add fields or rename fields
+                for new_data_field_name in set(new_data_fields_name).difference(
+                    set(old_data_fields_name)
+                ):
+                    new_data_field = cls.get_field_by_name(new_data_field_name, new_data_fields)
+                    is_rename = False
+                    for old_data_field in old_data_fields:
+                        changes = list(diff(old_data_field, new_data_field))
+                        old_data_field_name = cast(str, old_data_field.get("name"))
+                        if len(changes) == 2:
+                            # rename field
+                            if (
+                                changes[0]
+                                == (
+                                    "change",
+                                    "name",
+                                    (old_data_field_name, new_data_field_name),
+                                )
+                                and changes[1]
+                                == (
+                                    "change",
+                                    "db_column",
+                                    (
+                                        old_data_field.get("db_column"),
+                                        new_data_field.get("db_column"),
+                                    ),
+                                )
+                                and old_data_field_name not in new_data_fields_name
+                            ):
+                                if upgrade:
+                                    is_rename = click.prompt(
+                                        f"Rename {old_data_field_name} to {new_data_field_name}?",
+                                        default=True,
+                                        type=bool,
+                                        show_choices=True,
+                                    )
+                                else:
+                                    is_rename = old_data_field_name in cls._rename_new
+                                if is_rename:
+                                    cls._rename_new.append(new_data_field_name)
+                                    cls._rename_old.append(old_data_field_name)
+                                    # only MySQL8+ has rename syntax
+                                    if (
+                                        cls.dialect == "mysql"
+                                        and cls._db_version
+                                        and cls._db_version.startswith("5.")
+                                    ):
+                                        cls._add_operator(
+                                            cls._change_field(
+                                                model, old_data_field, new_data_field
+                                            ),
+                                            upgrade,
+                                        )
+                                    else:
+                                        cls._add_operator(
+                                            cls._rename_field(model, *changes[1][2]),
+                                            upgrade,
+                                        )
+                    if not is_rename:
+                        cls._add_operator(
+                            cls._add_field(
+                                model,
+                                new_data_field,
+                            ),
+                            upgrade,
+                        )
+                        if new_data_field["indexed"]:
+                            cls._add_operator(
+                                cls._add_index(
+                                    model, (new_data_field["db_column"],), new_data_field["unique"]
+                                ),
+                                upgrade,
+                                True,
+                            )
+                # remove fields
+                for old_data_field_name in set(old_data_fields_name).difference(
+                    set(new_data_fields_name)
+                ):
+                    # don't remove field if is renamed
+                    if (upgrade and old_data_field_name in cls._rename_old) or (
+                        not upgrade and old_data_field_name in cls._rename_new
+                    ):
+                        continue
+                    old_data_field = cls.get_field_by_name(old_data_field_name, old_data_fields)
+                    db_column = cast(str, old_data_field["db_column"])
+                    cls._add_operator(
+                        cls._remove_field(model, db_column),
+                        upgrade,
+                    )
+                    if old_data_field["indexed"]:
+                        is_unique_field = old_data_field.get("unique")
+                        cls._add_operator(
+                            cls._drop_index(model, {db_column}, is_unique_field),
+                            upgrade,
+                            True,
+                        )
+
+                old_fk_fields = cast(List[dict], old_model_describe.get("fk_fields"))
+                new_fk_fields = cast(List[dict], new_model_describe.get("fk_fields"))
+
+                old_fk_fields_name: List[str] = [i.get("name", "") for i in old_fk_fields]
+                new_fk_fields_name: List[str] = [i.get("name", "") for i in new_fk_fields]
+
+                # add fk
+                for new_fk_field_name in set(new_fk_fields_name).difference(
+                    set(old_fk_fields_name)
+                ):
+                    fk_field = cls.get_field_by_name(new_fk_field_name, new_fk_fields)
+                    if fk_field.get("db_constraint"):
+                        ref_describe = cast(dict, new_models[fk_field["python_type"]])
+                        cls._add_operator(
+                            cls._add_fk(model, fk_field, ref_describe),
+                            upgrade,
+                            fk_m2m_index=True,
+                        )
+                # drop fk
+                for old_fk_field_name in set(old_fk_fields_name).difference(
+                    set(new_fk_fields_name)
+                ):
+                    old_fk_field = cls.get_field_by_name(
+                        old_fk_field_name, cast(List[dict], old_fk_fields)
+                    )
+                    if old_fk_field.get("db_constraint"):
+                        ref_describe = cast(dict, old_models[old_fk_field["python_type"]])
+                        cls._add_operator(
+                            cls._drop_fk(model, old_fk_field, ref_describe),
+                            upgrade,
+                            fk_m2m_index=True,
+                        )
+                # change fields
+                for field_name in set(new_data_fields_name).intersection(set(old_data_fields_name)):
+                    old_data_field = cls.get_field_by_name(field_name, old_data_fields)
+                    new_data_field = cls.get_field_by_name(field_name, new_data_fields)
+                    changes = diff(old_data_field, new_data_field)
+                    modified = False
+                    for change in changes:
+                        _, option, old_new = change
+                        if option == "indexed":
+                            # change index
+                            if old_new[0] is False and old_new[1] is True:
+                                unique = new_data_field.get("unique")
+                                cls._add_operator(
+                                    cls._add_index(model, (field_name,), unique), upgrade, True
+                                )
+                            else:
+                                unique = old_data_field.get("unique")
+                                cls._add_operator(
+                                    cls._drop_index(model, (field_name,), unique), upgrade, True
+                                )
+                        elif option == "db_field_types.":
+                            if new_data_field.get("field_type") == "DecimalField":
+                                # modify column
+                                cls._add_operator(
+                                    cls._modify_field(model, new_data_field),
+                                    upgrade,
+                                )
+                            else:
+                                continue
+                        elif option == "default":
+                            if not (
+                                is_default_function(old_new[0]) or is_default_function(old_new[1])
+                            ):
+                                # change column default
+                                cls._add_operator(
+                                    cls._alter_default(model, new_data_field), upgrade
+                                )
+                        elif option == "unique":
+                            # because indexed include it
+                            continue
+                        elif option == "nullable":
+                            # change nullable
+                            cls._add_operator(cls._alter_null(model, new_data_field), upgrade)
+                        elif option == "description":
+                            # change comment
+                            cls._add_operator(cls._set_comment(model, new_data_field), upgrade)
+                        else:
+                            if modified:
+                                continue
+                            # modify column
+                            cls._add_operator(
+                                cls._modify_field(model, new_data_field),
+                                upgrade,
+                            )
+                            modified = True
+
+        for old_model in old_models.keys() - new_models.keys():
+            cls._add_operator(cls.drop_model(old_models[old_model]["table"]), upgrade)
 
     @classmethod
-    def add_model(cls, model: Type[Model]):
+    def rename_table(cls, model: Type[Model], old_table_name: str, new_table_name: str) -> str:
+        return cls.ddl.rename_table(model, old_table_name, new_table_name)
+
+    @classmethod
+    def add_model(cls, model: Type[Model]) -> str:
         return cls.ddl.create_table(model)
 
     @classmethod
-    def remove_model(cls, model: Type[Model]):
+    def drop_model(cls, table_name: str) -> str:
-        return cls.ddl.drop_table(model)
+        return cls.ddl.drop_table(table_name)
 
     @classmethod
-    def diff_model(cls, old_model: Type[Model], new_model: Type[Model], upgrade=True):
+    def create_m2m(
-        """
+        cls, model: Type[Model], field_describe: dict, reference_table_describe: dict
-        diff single model
+    ) -> str:
-        :param old_model:
+        return cls.ddl.create_m2m(model, field_describe, reference_table_describe)
-        :param new_model:
-        :param upgrade:
-        :return:
-        """
-        old_indexes = old_model._meta.indexes
-        new_indexes = new_model._meta.indexes
-
-        old_unique_together = old_model._meta.unique_together
-        new_unique_together = new_model._meta.unique_together
-
-        old_fields_map = old_model._meta.fields_map
-        new_fields_map = new_model._meta.fields_map
-
-        old_keys = old_fields_map.keys()
-        new_keys = new_fields_map.keys()
-        for new_key in new_keys:
-            new_field = new_fields_map.get(new_key)
-            if cls._exclude_field(new_field, upgrade):
-                continue
-            if new_key not in old_keys:
-                cls._add_operator(
-                    cls._add_field(new_model, new_field),
-                    upgrade,
-                    isinstance(new_field, (ForeignKeyFieldInstance, ManyToManyFieldInstance)),
-                )
-            else:
-                old_field = old_fields_map.get(new_key)
-                if (old_field.index and not new_field.index) or (
-                    old_field.unique and not new_field.unique
-                ):
-                    cls._add_operator(
-                        cls._remove_index(
-                            old_model, (old_field.model_field_name,), old_field.unique
-                        ),
-                        upgrade,
-                        isinstance(old_field, (ForeignKeyFieldInstance, ManyToManyFieldInstance)),
-                    )
-                elif (new_field.index and not old_field.index) or (
-                    new_field.unique and not old_field.unique
-                ):
-                    cls._add_operator(
-                        cls._add_index(new_model, (new_field.model_field_name,), new_field.unique),
-                        upgrade,
-                        isinstance(new_field, (ForeignKeyFieldInstance, ManyToManyFieldInstance)),
-                    )
-
-        for old_key in old_keys:
-            field = old_fields_map.get(old_key)
-            if old_key not in new_keys and not cls._exclude_field(field, upgrade):
-                cls._add_operator(
-                    cls._remove_field(old_model, field),
-                    upgrade,
-                    isinstance(field, (ForeignKeyFieldInstance, ManyToManyFieldInstance)),
-                )
-
-        for new_index in new_indexes:
-            if new_index not in old_indexes:
-                cls._add_operator(cls._add_index(new_model, new_index,), upgrade)
-        for old_index in old_indexes:
-            if old_index not in new_indexes:
-                cls._add_operator(cls._remove_index(old_model, old_index), upgrade)
-
-        for new_unique in new_unique_together:
-            if new_unique not in old_unique_together:
-                cls._add_operator(cls._add_index(new_model, new_unique, unique=True), upgrade)
-
-        for old_unique in old_unique_together:
-            if old_unique not in new_unique_together:
-                cls._add_operator(cls._remove_index(old_model, old_unique, unique=True), upgrade)
 
     @classmethod
-    def _resolve_fk_fields_name(cls, model: Type[Model], fields_name: Tuple[str]):
+    def drop_m2m(cls, table_name: str) -> str:
+        return cls.ddl.drop_m2m(table_name)
+
+    @classmethod
+    def _resolve_fk_fields_name(cls, model: Type[Model], fields_name: Iterable[str]) -> List[str]:
         ret = []
         for field_name in fields_name:
-            if field_name in model._meta.fk_fields:
+            try:
-                ret.append(field_name + "_id")
+                field = model._meta.fields_map[field_name]
+            except KeyError:
+                # field dropped or to be add
+                pass
             else:
-                ret.append(field_name)
+                if field.source_field:
+                    field_name = field.source_field
+                elif field_name in model._meta.fk_fields:
+                    field_name += "_id"
+            ret.append(field_name)
         return ret
 
     @classmethod
-    def _remove_index(cls, model: Type[Model], fields_name: Tuple[str], unique=False):
+    def _drop_index(
-        fields_name = cls._resolve_fk_fields_name(model, fields_name)
+        cls, model: Type[Model], fields_name: Union[Iterable[str], Index], unique=False
-        return cls.ddl.drop_index(model, fields_name, unique)
+    ) -> str:
+        if isinstance(fields_name, Index):
+            return cls.ddl.drop_index_by_name(
+                model, fields_name.index_name(cls.ddl.schema_generator, model)
+            )
+        field_names = cls._resolve_fk_fields_name(model, fields_name)
+        return cls.ddl.drop_index(model, field_names, unique)
 
     @classmethod
-    def _add_index(cls, model: Type[Model], fields_name: Tuple[str], unique=False):
+    def _add_index(
-        fields_name = cls._resolve_fk_fields_name(model, fields_name)
+        cls, model: Type[Model], fields_name: Union[Iterable[str], Index], unique=False
-        return cls.ddl.add_index(model, fields_name, unique)
+    ) -> str:
+        if isinstance(fields_name, Index):
+            return fields_name.get_sql(cls.ddl.schema_generator, model, False)
+        field_names = cls._resolve_fk_fields_name(model, fields_name)
+        return cls.ddl.add_index(model, field_names, unique)
 
     @classmethod
-    def _exclude_field(cls, field: Field, upgrade=False):
+    def _add_field(cls, model: Type[Model], field_describe: dict, is_pk: bool = False) -> str:
-        """
+        return cls.ddl.add_column(model, field_describe, is_pk)
-        exclude BackwardFKRelation and repeat m2m field
-        :param field:
-        :return:
-        """
-        if isinstance(field, ManyToManyFieldInstance):
-            through = field.through
-            if upgrade:
-                if through in cls._upgrade_m2m:
-                    return True
-                else:
-                    cls._upgrade_m2m.append(through)
-                    return False
-            else:
-                if through in cls._downgrade_m2m:
-                    return True
-                else:
-                    cls._downgrade_m2m.append(through)
-                    return False
-        return isinstance(field, (BackwardFKRelation, BackwardOneToOneRelation))
 
     @classmethod
-    def _add_field(cls, model: Type[Model], field: Field):
+    def _alter_default(cls, model: Type[Model], field_describe: dict) -> str:
-        if isinstance(field, ForeignKeyFieldInstance):
+        return cls.ddl.alter_column_default(model, field_describe)
-            return cls.ddl.add_fk(model, field)
-        if isinstance(field, ManyToManyFieldInstance):
-            return cls.ddl.create_m2m_table(model, field)
-        return cls.ddl.add_column(model, field)
 
     @classmethod
-    def _remove_field(cls, model: Type[Model], field: Field):
+    def _alter_null(cls, model: Type[Model], field_describe: dict) -> str:
-        if isinstance(field, ForeignKeyFieldInstance):
+        return cls.ddl.alter_column_null(model, field_describe)
-            return cls.ddl.drop_fk(model, field)
-        if isinstance(field, ManyToManyFieldInstance):
-            return cls.ddl.drop_m2m(field)
-        return cls.ddl.drop_column(model, field.model_field_name)
 
     @classmethod
-    def _add_fk(cls, model: Type[Model], field: ForeignKeyFieldInstance):
+    def _set_comment(cls, model: Type[Model], field_describe: dict) -> str:
+        return cls.ddl.set_comment(model, field_describe)
+
+    @classmethod
+    def _modify_field(cls, model: Type[Model], field_describe: dict) -> str:
+        return cls.ddl.modify_column(model, field_describe)
+
+    @classmethod
+    def _drop_fk(
+        cls, model: Type[Model], field_describe: dict, reference_table_describe: dict
+    ) -> str:
+        return cls.ddl.drop_fk(model, field_describe, reference_table_describe)
+
+    @classmethod
+    def _remove_field(cls, model: Type[Model], column_name: str) -> str:
+        return cls.ddl.drop_column(model, column_name)
+
+    @classmethod
+    def _rename_field(cls, model: Type[Model], old_field_name: str, new_field_name: str) -> str:
+        return cls.ddl.rename_column(model, old_field_name, new_field_name)
+
+    @classmethod
+    def _change_field(
+        cls, model: Type[Model], old_field_describe: dict, new_field_describe: dict
+    ) -> str:
+        db_field_types = cast(dict, new_field_describe.get("db_field_types"))
+        return cls.ddl.change_column(
+            model,
+            cast(str, old_field_describe.get("db_column")),
+            cast(str, new_field_describe.get("db_column")),
+            cast(str, db_field_types.get(cls.dialect) or db_field_types.get("")),
+        )
+
+    @classmethod
+    def _add_fk(
+        cls, model: Type[Model], field_describe: dict, reference_table_describe: dict
+    ) -> str:
         """
         add fk
         :param model:
-        :param field:
+        :param field_describe:
+        :param reference_table_describe:
         :return:
         """
-        return cls.ddl.add_fk(model, field)
+        return cls.ddl.add_fk(model, field_describe, reference_table_describe)
 
     @classmethod
-    def _remove_fk(cls, model: Type[Model], field: ForeignKeyFieldInstance):
+    def _merge_operators(cls) -> None:
-        """
-        drop fk
-        :param model:
-        :param field:
-        :return:
-        """
-        return cls.ddl.drop_fk(model, field)
-
-    @classmethod
-    def _merge_operators(cls):
         """
         fk/m2m/index must be last when add,first when drop
         :return:

aerich/models.py

@@ -1,9 +1,15 @@
 from tortoise import Model, fields
 
+from aerich.coder import decoder, encoder
+
+MAX_VERSION_LENGTH = 255
+MAX_APP_LENGTH = 100
+
 
 class Aerich(Model):
-    version = fields.CharField(max_length=50)
+    version = fields.CharField(max_length=MAX_VERSION_LENGTH)
-    app = fields.CharField(max_length=20)
+    app = fields.CharField(max_length=MAX_APP_LENGTH)
+    content: dict = fields.JSONField(encoder=encoder, decoder=decoder)
 
     class Meta:
         ordering = ["-id"]

aerich/utils.py

@@ -1,17 +1,45 @@
-import importlib
+import importlib.util
+import os
+import re
+import sys
+from pathlib import Path
+from types import ModuleType
+from typing import Dict, Optional, Union
 
-from asyncclick import BadOptionUsage, Context
+from asyncclick import BadOptionUsage, ClickException, Context
 from tortoise import BaseDBAsyncClient, Tortoise
 
 
-def get_app_connection_name(config, app) -> str:
+def add_src_path(path: str) -> str:
+    """
+    add a folder to the paths, so we can import from there
+    :param path: path to add
+    :return: absolute path
+    """
+    if not os.path.isabs(path):
+        # use the absolute path, otherwise some other things (e.g. __file__) won't work properly
+        path = os.path.abspath(path)
+    if not os.path.isdir(path):
+        raise ClickException(f"Specified source folder does not exist: {path}")
+    if path not in sys.path:
+        sys.path.insert(0, path)
+    return path
+
+
+def get_app_connection_name(config, app_name: str) -> str:
     """
     get connection name
     :param config:
-    :param app:
+    :param app_name:
     :return:
     """
-    return config.get("apps").get(app).get("default_connection")
+    app = config.get("apps").get(app_name)
+    if app:
+        return app.get("default_connection", "default")
+    raise BadOptionUsage(
+        option_name="--app",
+        message=f'Can\'t get app named "{app_name}"',
+    )
 
 
 def get_app_connection(config, app) -> BaseDBAsyncClient:
@@ -34,12 +62,11 @@ def get_tortoise_config(ctx: Context, tortoise_orm: str) -> dict:
     splits = tortoise_orm.split(".")
     config_path = ".".join(splits[:-1])
     tortoise_config = splits[-1]
+
     try:
         config_module = importlib.import_module(config_path)
-    except (ModuleNotFoundError, AttributeError):
+    except ModuleNotFoundError as e:
-        raise BadOptionUsage(
+        raise ClickException(f"Error while importing configuration module: {e}") from None
-            ctx=ctx, message=f'No config named "{config_path}"', option_name="--config"
-        )
 
     config = getattr(config_module, tortoise_config, None)
     if not config:
@@ -49,3 +76,28 @@ def get_tortoise_config(ctx: Context, tortoise_orm: str) -> dict:
             ctx=ctx,
         )
     return config
+
+
+def get_models_describe(app: str) -> Dict:
+    """
+    get app models describe
+    :param app:
+    :return:
+    """
+    ret = {}
+    for model in Tortoise.apps[app].values():
+        describe = model.describe()
+        ret[describe.get("name")] = describe
+    return ret
+
+
+def is_default_function(string: str) -> Optional[re.Match]:
+    return re.match(r"^<function.+>$", str(string or ""))
+
+
+def import_py_file(file: Union[str, Path]) -> ModuleType:
+    module_name, file_ext = os.path.splitext(os.path.split(file)[-1])
+    spec = importlib.util.spec_from_file_location(module_name, file)
+    module = importlib.util.module_from_spec(spec)  # type:ignore[arg-type]
+    spec.loader.exec_module(module)  # type:ignore[union-attr]
+    return module

aerich/version.py

@@ -0,0 +1 @@
+__version__ = "0.8.0"

conftest.py

@@ -1,11 +1,75 @@
+import asyncio
 import os
+from typing import Generator
 
 import pytest
-from tortoise.contrib.test import finalizer, initializer
+from tortoise import Tortoise, expand_db_url, generate_schema_for_client
+from tortoise.backends.asyncpg.schema_generator import AsyncpgSchemaGenerator
+from tortoise.backends.mysql.schema_generator import MySQLSchemaGenerator
+from tortoise.backends.sqlite.schema_generator import SqliteSchemaGenerator
+from tortoise.exceptions import DBConnectionError, OperationalError
+
+from aerich.ddl.mysql import MysqlDDL
+from aerich.ddl.postgres import PostgresDDL
+from aerich.ddl.sqlite import SqliteDDL
+from aerich.migrate import Migrate
+
+MEMORY_SQLITE = "sqlite://:memory:"
+db_url = os.getenv("TEST_DB", MEMORY_SQLITE)
+db_url_second = os.getenv("TEST_DB_SECOND", MEMORY_SQLITE)
+tortoise_orm = {
+    "connections": {
+        "default": expand_db_url(db_url, True),
+        "second": expand_db_url(db_url_second, True),
+    },
+    "apps": {
+        "models": {"models": ["tests.models", "aerich.models"], "default_connection": "default"},
+        "models_second": {"models": ["tests.models_second"], "default_connection": "second"},
+    },
+}
 
 
-@pytest.fixture(scope="module", autouse=True)
+@pytest.fixture(scope="function", autouse=True)
-def initialize_tests(request):
+def reset_migrate() -> None:
-    db_url = os.getenv("TEST_DB", "sqlite://:memory:")
+    Migrate.upgrade_operators = []
-    initializer(["tests.models"], db_url=db_url)
+    Migrate.downgrade_operators = []
-    request.addfinalizer(finalizer)
+    Migrate._upgrade_fk_m2m_index_operators = []
+    Migrate._downgrade_fk_m2m_index_operators = []
+    Migrate._upgrade_m2m = []
+    Migrate._downgrade_m2m = []
+
+
+@pytest.fixture(scope="session")
+def event_loop() -> Generator:
+    policy = asyncio.get_event_loop_policy()
+    res = policy.new_event_loop()
+    asyncio.set_event_loop(res)
+    res._close = res.close  # type:ignore[attr-defined]
+    res.close = lambda: None  # type:ignore[method-assign]
+
+    yield res
+
+    res._close()  # type:ignore[attr-defined]
+
+
+@pytest.fixture(scope="session", autouse=True)
+async def initialize_tests(event_loop, request) -> None:
+    # Placing init outside the try block since it doesn't
+    # establish connections to the DB eagerly.
+    await Tortoise.init(config=tortoise_orm)
+    try:
+        await Tortoise._drop_databases()
+    except (DBConnectionError, OperationalError):
+        pass
+    await Tortoise.init(config=tortoise_orm, _create_db=True)
+    await generate_schema_for_client(Tortoise.get_connection("default"), safe=True)
+
+    client = Tortoise.get_connection("default")
+    if client.schema_generator is MySQLSchemaGenerator:
+        Migrate.ddl = MysqlDDL(client)
+    elif client.schema_generator is SqliteSchemaGenerator:
+        Migrate.ddl = SqliteDDL(client)
+    elif client.schema_generator is AsyncpgSchemaGenerator:
+        Migrate.ddl = PostgresDDL(client)
+    Migrate.dialect = Migrate.ddl.DIALECT
+    request.addfinalizer(lambda: event_loop.run_until_complete(Tortoise._drop_databases()))

pyproject.toml

@@ -1,32 +1,71 @@
 [tool.poetry]
 name = "aerich"
-version = "0.1.1"
+version = "0.8.0"
 description = "A database migrations tool for Tortoise ORM."
 authors = ["long2ice <long2ice@gmail.com>"]
+license = "Apache-2.0"
+readme = "README.md"
+homepage = "https://github.com/tortoise/aerich"
+repository = "https://github.com/tortoise/aerich.git"
+documentation = "https://github.com/tortoise/aerich"
+keywords = ["migrate", "Tortoise-ORM", "mysql"]
+packages = [
+    { include = "aerich" }
+]
+include = ["CHANGELOG.md", "LICENSE", "README.md"]
 
 [tool.poetry.dependencies]
 python = "^3.8"
-tortoise-orm = {git = "https://github.com/long2ice/tortoise-orm.git", branch = "develop"}
+tortoise-orm = "*"
-asyncclick = "*"
+asyncpg = { version = "*", optional = true }
-pydantic = "*"
+asyncmy = { version = "^0.2.9", optional = true, allow-prereleases = true }
+pydantic = "^2.0"
+dictdiffer = "*"
+tomlkit = "*"
+asyncclick = "^8.1.7.2"
 
-[tool.poetry.dev-dependencies]
+[tool.poetry.group.dev.dependencies]
-taskipy = "*"
+ruff = "*"
-asynctest = "*"
-flake8 = "*"
 isort = "*"
-black = "^19.10b0"
+black = "*"
 pytest = "*"
-aiomysql = "*"
-asyncpg = "*"
 pytest-xdist = "*"
-mypy = "*"
+# Breaking change in 0.23.*
+# https://github.com/pytest-dev/pytest-asyncio/issues/706
+pytest-asyncio = "^0.21.2"
+bandit = "*"
+pytest-mock = "*"
+cryptography = "*"
+mypy = "^1.10.0"
 
-[tool.taskipy.tasks]
+[tool.poetry.extras]
-export = "poetry export -f requirements.txt --without-hashes > requirements.txt"
+asyncmy = ["asyncmy"]
-export-dev = "poetry export -f requirements.txt --dev --without-hashes > requirements-dev.txt"
+asyncpg = ["asyncpg"]
+
+
+[tool.aerich]
+tortoise_orm = "conftest.tortoise_orm"
+location = "./migrations"
+src_folder = "./."
 
 [build-system]
-requires = ["poetry>=0.12"]
+requires = ["poetry-core>=1.0.0"]
-build-backend = "poetry.masonry.api"
+build-backend = "poetry.core.masonry.api"
 
+[tool.poetry.scripts]
+aerich = "aerich.cli:main"
+
+[tool.black]
+line-length = 100
+target-version = ['py38', 'py39', 'py310', 'py311', 'py312']
+
+[tool.pytest.ini_options]
+asyncio_mode = 'auto'
+
+[tool.mypy]
+pretty = true
+python_version = "3.8"
+ignore_missing_imports = true
+
+[tool.ruff.lint]
+ignore = ['E501']

pytest.ini

@@ -1,2 +0,0 @@
-[pytest]
-addopts = -p no:warnings --ignore=src

requirements-dev.txt

@@ -1,48 +0,0 @@
-aiomysql==0.0.20
-aiosqlite==0.13.0
-anyio==1.3.0
-apipkg==1.5
-appdirs==1.4.4
-async-generator==1.10
-asyncclick==7.0.9
-asyncpg==0.20.1
-asynctest==0.13.0
-atomicwrites==1.4.0; sys_platform == "win32"
-attrs==19.3.0
-black==19.10b0
-cffi==1.14.0
-ciso8601==2.1.3; sys_platform != "win32" and implementation_name == "cpython"
-click==7.1.2
-colorama==0.4.3; sys_platform == "win32"
-cryptography==2.9.2
-execnet==1.7.1
-flake8==3.8.1
-iso8601==0.1.12; sys_platform == "win32" or implementation_name != "cpython"
-isort==4.3.21
-mccabe==0.6.1
-more-itertools==8.3.0
-mypy==0.770
-mypy-extensions==0.4.3
-packaging==20.4
-pathspec==0.8.0
-pluggy==0.13.1
-py==1.8.1
-pycodestyle==2.6.0
-pycparser==2.20
-pydantic==1.5.1
-pyflakes==2.2.0
-pymysql==0.9.2
-pyparsing==2.4.7
-pypika==0.37.6
-pytest==5.4.2
-pytest-forked==1.1.3
-pytest-xdist==1.32.0
-regex==2020.5.14
-six==1.14.0
-sniffio==1.1.0
-taskipy==1.2.1
-toml==0.10.1
--e git+https://github.com/long2ice/tortoise-orm.git@1f67b7a0ca1384365d6ff89d9e245e733166d1a6#egg=tortoise-orm
-typed-ast==1.4.1
-typing-extensions==3.7.4.2
-wcwidth==0.1.9

requirements.txt

@@ -1,10 +0,0 @@
-aiosqlite==0.13.0
-anyio==1.3.0
-async-generator==1.10
-asyncclick==7.0.9
-ciso8601==2.1.3; sys_platform != "win32" and implementation_name == "cpython"
-iso8601==0.1.12; sys_platform == "win32" or implementation_name != "cpython"
-pydantic==1.5.1
-pypika==0.37.6
-sniffio==1.1.0
-typing-extensions==3.7.4.2

setup.cfg

@@ -1,47 +0,0 @@
-[flake8]
-max-line-length = 100
-exclude =
-ignore = E501,W503,DAR101,DAR201,DAR402
-
-[darglint]
-docstring_style=sphinx
-
-[isort]
-not_skip=__init__.py
-multi_line_output=3
-include_trailing_comma=True
-force_grid_wrap=0
-use_parentheses=True
-line_length=100
-
-[tool:pytest]
-addopts = -n auto --tb=native -q
-
-[mypy]
-pretty = True
-ignore_missing_imports = True
-check_untyped_defs = True
-disallow_subclassing_any = True
-disallow_untyped_calls = True
-disallow_untyped_defs = False
-disallow_incomplete_defs = False
-disallow_untyped_decorators = True
-no_implicit_optional = True
-warn_redundant_casts = True
-warn_unused_ignores = True
-warn_no_return = True
-warn_return_any = False
-warn_unused_configs = True
-warn_unreachable = True
-allow_redefinition = True
-strict_equality = True
-show_error_context = True
-
-[mypy-tests.*]
-check_untyped_defs = False
-disallow_untyped_defs = False
-disallow_incomplete_defs = False
-warn_unreachable = False
-
-[mypy-conftest]
-disallow_untyped_defs = False

setup.py

@@ -1,44 +0,0 @@
-import os
-import re
-from setuptools import find_packages, setup
-
-
-def version():
-    ver_str_line = open('aerich/__init__.py', 'rt').read()
-    mob = re.search(r"^__version__ = ['\"]([^'\"]*)['\"]", ver_str_line, re.M)
-    if not mob:
-        raise RuntimeError("Unable to find version string")
-    return mob.group(1)
-
-
-with open(os.path.join(os.path.dirname(__file__), 'README.rst')) as f:
-    long_description = f.read()
-
-
-def requirements():
-    return open('requirements.txt', 'rt').read().splitlines()
-
-
-setup(
-    name='aerich',
-    version=version(),
-    description='A database migrations tool for Tortoise-ORM.',
-    author='long2ice',
-    long_description_content_type='text/x-rst',
-    long_description=long_description,
-    author_email='long2ice@gmail.com',
-    url='https://github.com/long2ice/aerich',
-    license='MIT License',
-    packages=find_packages(include=['aerich*']),
-    include_package_data=True,
-    zip_safe=True,
-    entry_points={
-        'console_scripts': ['aerich = aerich.cli:main'],
-    },
-    platforms='any',
-    keywords=(
-        'migrate Tortoise-ORM mysql'
-    ),
-    dependency_links=['https://github.com/long2ice/tortoise-orm.git@develop#egg=tortoise-orm'],
-    install_requires=requirements(),
-)

tests/__init__.py

@@ -1,6 +0,0 @@
-TORTOISE_ORM = {
-    "connections": {"default": "mysql://root:123456@127.0.0.1:3306/test"},
-    "apps": {
-        "models": {"models": ["tests.models", "aerich.models"], "default_connection": "default"}
-    },
-}

tests/models.py

@@ -1,4 +1,5 @@
 import datetime
+import uuid
 from enum import IntEnum
 
 from tortoise import Model, fields
@@ -23,35 +24,63 @@ class Status(IntEnum):
 
 class User(Model):
     username = fields.CharField(max_length=20, unique=True)
-    password = fields.CharField(max_length=200)
+    password = fields.CharField(max_length=100)
     last_login = fields.DatetimeField(description="Last Login", default=datetime.datetime.now)
     is_active = fields.BooleanField(default=True, description="Is Active")
     is_superuser = fields.BooleanField(default=False, description="Is SuperUser")
-    avatar = fields.CharField(max_length=200, default="")
     intro = fields.TextField(default="")
+    longitude = fields.DecimalField(max_digits=10, decimal_places=8)
+
+
+class Email(Model):
+    email_id = fields.IntField(primary_key=True)
+    email = fields.CharField(max_length=200, db_index=True)
+    is_primary = fields.BooleanField(default=False)
+    address = fields.CharField(max_length=200)
+    users: fields.ManyToManyRelation[User] = fields.ManyToManyField("models.User")
+
+
+def default_name():
+    return uuid.uuid4()
 
 
 class Category(Model):
-    slug = fields.CharField(max_length=200)
+    slug = fields.CharField(max_length=100)
-    name = fields.CharField(max_length=200)
+    name = fields.CharField(max_length=200, null=True, default=default_name)
-    user = fields.ForeignKeyField("models.User", description="User")
+    user: fields.ForeignKeyRelation[User] = fields.ForeignKeyField(
+        "models.User", description="User"
+    )
+    title = fields.CharField(max_length=20, unique=False)
     created_at = fields.DatetimeField(auto_now_add=True)
 
 
 class Product(Model):
-    categories = fields.ManyToManyField("models.Category")
+    categories: fields.ManyToManyRelation[Category] = fields.ManyToManyField("models.Category")
     name = fields.CharField(max_length=50)
-    view_num = fields.IntField(description="View Num")
+    view_num = fields.IntField(description="View Num", default=0)
     sort = fields.IntField()
     is_reviewed = fields.BooleanField(description="Is Reviewed")
-    type = fields.IntEnumField(ProductType, description="Product Type")
+    type = fields.IntEnumField(
-    image = fields.CharField(max_length=200)
+        ProductType, description="Product Type", source_field="type_db_alias"
+    )
+    pic = fields.CharField(max_length=200)
     body = fields.TextField()
     created_at = fields.DatetimeField(auto_now_add=True)
 
+    class Meta:
+        unique_together = (("name", "type"),)
+        indexes = (("name", "type"),)
+
 
 class Config(Model):
     label = fields.CharField(max_length=200)
     key = fields.CharField(max_length=20)
-    value = fields.JSONField()
+    value: dict = fields.JSONField()
-    status: Status = fields.IntEnumField(Status, default=Status.on)
+    status: Status = fields.IntEnumField(Status)
+    user: fields.ForeignKeyRelation[User] = fields.ForeignKeyField(
+        "models.User", description="User"
+    )
+
+
+class NewModel(Model):
+    name = fields.CharField(max_length=50)

tests/models_second.py

@@ -0,0 +1,71 @@
+import datetime
+from enum import IntEnum
+
+from tortoise import Model, fields
+
+
+class ProductType(IntEnum):
+    article = 1
+    page = 2
+
+
+class PermissionAction(IntEnum):
+    create = 1
+    delete = 2
+    update = 3
+    read = 4
+
+
+class Status(IntEnum):
+    on = 1
+    off = 0
+
+
+class User(Model):
+    username = fields.CharField(max_length=20, unique=True)
+    password = fields.CharField(max_length=200)
+    last_login = fields.DatetimeField(description="Last Login", default=datetime.datetime.now)
+    is_active = fields.BooleanField(default=True, description="Is Active")
+    is_superuser = fields.BooleanField(default=False, description="Is SuperUser")
+    avatar = fields.CharField(max_length=200, default="")
+    intro = fields.TextField(default="")
+
+
+class Email(Model):
+    email = fields.CharField(max_length=200)
+    is_primary = fields.BooleanField(default=False)
+    user: fields.ForeignKeyRelation[User] = fields.ForeignKeyField(
+        "models_second.User", db_constraint=False
+    )
+
+
+class Category(Model):
+    slug = fields.CharField(max_length=200)
+    name = fields.CharField(max_length=200)
+    user: fields.ForeignKeyRelation[User] = fields.ForeignKeyField(
+        "models_second.User", description="User"
+    )
+    created_at = fields.DatetimeField(auto_now_add=True)
+
+
+class Product(Model):
+    categories: fields.ManyToManyRelation[Category] = fields.ManyToManyField(
+        "models_second.Category"
+    )
+    name = fields.CharField(max_length=50)
+    view_num = fields.IntField(description="View Num")
+    sort = fields.IntField()
+    is_reviewed = fields.BooleanField(description="Is Reviewed")
+    type = fields.IntEnumField(
+        ProductType, description="Product Type", source_field="type_db_alias"
+    )
+    image = fields.CharField(max_length=200)
+    body = fields.TextField()
+    created_at = fields.DatetimeField(auto_now_add=True)
+
+
+class Config(Model):
+    label = fields.CharField(max_length=200)
+    key = fields.CharField(max_length=20)
+    value: dict = fields.JSONField()
+    status: Status = fields.IntEnumField(Status, default=Status.on)

tests/old_models.py

@@ -0,0 +1,75 @@
+import datetime
+from enum import IntEnum
+
+from tortoise import Model, fields
+
+
+class ProductType(IntEnum):
+    article = 1
+    page = 2
+
+
+class PermissionAction(IntEnum):
+    create = 1
+    delete = 2
+    update = 3
+    read = 4
+
+
+class Status(IntEnum):
+    on = 1
+    off = 0
+
+
+class User(Model):
+    username = fields.CharField(max_length=20)
+    password = fields.CharField(max_length=200)
+    last_login = fields.DatetimeField(description="Last Login", default=datetime.datetime.now)
+    is_active = fields.BooleanField(default=True, description="Is Active")
+    is_superuser = fields.BooleanField(default=False, description="Is SuperUser")
+    avatar = fields.CharField(max_length=200, default="")
+    intro = fields.TextField(default="")
+    longitude = fields.DecimalField(max_digits=12, decimal_places=9)
+
+
+class Email(Model):
+    email = fields.CharField(max_length=200)
+    is_primary = fields.BooleanField(default=False)
+    user: fields.ForeignKeyRelation[User] = fields.ForeignKeyField(
+        "models.User", db_constraint=False
+    )
+
+
+class Category(Model):
+    slug = fields.CharField(max_length=200)
+    name = fields.CharField(max_length=200)
+    user: fields.ForeignKeyRelation[User] = fields.ForeignKeyField(
+        "models.User", description="User"
+    )
+    created_at = fields.DatetimeField(auto_now_add=True)
+
+
+class Product(Model):
+    categories: fields.ManyToManyRelation[Category] = fields.ManyToManyField("models.Category")
+    uid = fields.IntField(source_field="uuid", unique=True)
+    name = fields.CharField(max_length=50)
+    view_num = fields.IntField(description="View Num")
+    sort = fields.IntField()
+    is_reviewed = fields.BooleanField(description="Is Reviewed")
+    type = fields.IntEnumField(
+        ProductType, description="Product Type", source_field="type_db_alias"
+    )
+    image = fields.CharField(max_length=200)
+    body = fields.TextField()
+    created_at = fields.DatetimeField(auto_now_add=True)
+
+
+class Config(Model):
+    name = fields.CharField(max_length=100, unique=True)
+    label = fields.CharField(max_length=200)
+    key = fields.CharField(max_length=20)
+    value: dict = fields.JSONField()
+    status: Status = fields.IntEnumField(Status, default=Status.on)
+
+    class Meta:
+        table = "configs"

tests/test_ddl.py

@@ -1,114 +1,207 @@
-from tortoise import Tortoise
-from tortoise.backends.asyncpg.schema_generator import AsyncpgSchemaGenerator
-from tortoise.backends.mysql.schema_generator import MySQLSchemaGenerator
-from tortoise.backends.sqlite.schema_generator import SqliteSchemaGenerator
-from tortoise.contrib import test
-
 from aerich.ddl.mysql import MysqlDDL
 from aerich.ddl.postgres import PostgresDDL
 from aerich.ddl.sqlite import SqliteDDL
-from tests.models import Category
+from aerich.migrate import Migrate
+from tests.models import Category, Product, User
 
 
-class TestDDL(test.TruncationTestCase):
+def test_create_table():
-    maxDiff = None
+    ret = Migrate.ddl.create_table(Category)
-
+    if isinstance(Migrate.ddl, MysqlDDL):
-    def setUp(self) -> None:
+        assert (
-        client = Tortoise.get_connection("models")
+            ret
-        if client.schema_generator is MySQLSchemaGenerator:
+            == """CREATE TABLE IF NOT EXISTS `category` (
-            self.ddl = MysqlDDL(client)
-        elif client.schema_generator is SqliteSchemaGenerator:
-            self.ddl = SqliteDDL(client)
-        elif client.schema_generator is AsyncpgSchemaGenerator:
-            self.ddl = PostgresDDL(client)
-
-    def test_create_table(self):
-        ret = self.ddl.create_table(Category)
-        if isinstance(self.ddl, MysqlDDL):
-            self.assertEqual(
-                ret,
-                """CREATE TABLE IF NOT EXISTS `category` (
     `id` INT NOT NULL PRIMARY KEY AUTO_INCREMENT,
-    `slug` VARCHAR(200) NOT NULL,
+    `slug` VARCHAR(100) NOT NULL,
-    `name` VARCHAR(200) NOT NULL,
+    `name` VARCHAR(200),
+    `title` VARCHAR(20) NOT NULL,
     `created_at` DATETIME(6) NOT NULL  DEFAULT CURRENT_TIMESTAMP(6),
     `user_id` INT NOT NULL COMMENT 'User',
     CONSTRAINT `fk_category_user_e2e3874c` FOREIGN KEY (`user_id`) REFERENCES `user` (`id`) ON DELETE CASCADE
-) CHARACTER SET utf8mb4;""",
+) CHARACTER SET utf8mb4"""
-            )
-        elif isinstance(self.ddl, SqliteDDL):
-            self.assertEqual(
-                ret,
-                """CREATE TABLE IF NOT EXISTS "category" (
-    "id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
-    "slug" VARCHAR(200) NOT NULL,
-    "name" VARCHAR(200) NOT NULL,
-    "created_at" TIMESTAMP NOT NULL  DEFAULT CURRENT_TIMESTAMP,
-    "user_id" INT NOT NULL REFERENCES "user" ("id") ON DELETE CASCADE /* User */
-);""",
-            )
-        elif isinstance(self.ddl, PostgresDDL):
-            self.assertEqual(
-                ret,
-                """CREATE TABLE IF NOT EXISTS "category" (
-    "id" SERIAL NOT NULL PRIMARY KEY,
-    "slug" VARCHAR(200) NOT NULL,
-    "name" VARCHAR(200) NOT NULL,
-    "created_at" TIMESTAMP NOT NULL  DEFAULT CURRENT_TIMESTAMP,
-    "user_id" INT NOT NULL REFERENCES "user" ("id") ON DELETE CASCADE
-);
-COMMENT ON COLUMN "category"."user_id" IS 'User';""",
-            )
-
-    def test_drop_table(self):
-        ret = self.ddl.drop_table(Category)
-        self.assertEqual(ret, "DROP TABLE IF EXISTS category")
-
-    def test_add_column(self):
-        ret = self.ddl.add_column(Category, Category._meta.fields_map.get("name"))
-        if isinstance(self.ddl, MysqlDDL):
-            self.assertEqual(ret, "ALTER TABLE category ADD `name` VARCHAR(200) NOT NULL")
-        elif isinstance(self.ddl, PostgresDDL):
-            self.assertEqual(ret, 'ALTER TABLE category ADD "name" VARCHAR(200) NOT NULL')
-        elif isinstance(self.ddl, SqliteDDL):
-            self.assertEqual(ret, 'ALTER TABLE category ADD "name" VARCHAR(200) NOT NULL')
-
-    def test_drop_column(self):
-        ret = self.ddl.drop_column(Category, "name")
-        self.assertEqual(ret, "ALTER TABLE category DROP COLUMN name")
-        self.assertEqual(ret, "ALTER TABLE category DROP COLUMN name")
-
-    def test_add_index(self):
-        index = self.ddl.add_index(Category, ["name"])
-        index_u = self.ddl.add_index(Category, ["name"], True)
-        if isinstance(self.ddl, MysqlDDL):
-            self.assertEqual(
-                index, "ALTER TABLE category ADD  INDEX idx_category_name_8b0cb9 (`name`)"
-            )
-            self.assertEqual(
-                index_u, "ALTER TABLE category ADD UNIQUE INDEX uid_category_name_8b0cb9 (`name`)"
-            )
-        elif isinstance(self.ddl, SqliteDDL):
-            self.assertEqual(
-                index_u, 'ALTER TABLE category ADD UNIQUE INDEX uid_category_name_8b0cb9 ("name")'
-            )
-            self.assertEqual(
-                index_u, 'ALTER TABLE category ADD UNIQUE INDEX uid_category_name_8b0cb9 ("name")'
-            )
-
-    def test_drop_index(self):
-        ret = self.ddl.drop_index(Category, ["name"])
-        self.assertEqual(ret, "ALTER TABLE category DROP INDEX idx_category_name_8b0cb9")
-        ret = self.ddl.drop_index(Category, ["name"], True)
-        self.assertEqual(ret, "ALTER TABLE category DROP INDEX uid_category_name_8b0cb9")
-
-    def test_add_fk(self):
-        ret = self.ddl.add_fk(Category, Category._meta.fields_map.get("user"))
-        self.assertEqual(
-            ret,
-            "ALTER TABLE category ADD CONSTRAINT `fk_category_user_e2e3874c` FOREIGN KEY (`user_id`) REFERENCES `user` (`id`) ON DELETE CASCADE",
         )
 
-    def test_drop_fk(self):
+    elif isinstance(Migrate.ddl, SqliteDDL):
-        ret = self.ddl.drop_fk(Category, Category._meta.fields_map.get("user"))
+        assert (
-        self.assertEqual(ret, "ALTER TABLE category DROP FOREIGN KEY fk_category_user_e2e3874c")
+            ret
+            == """CREATE TABLE IF NOT EXISTS "category" (
+    "id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    "slug" VARCHAR(100) NOT NULL,
+    "name" VARCHAR(200),
+    "title" VARCHAR(20) NOT NULL,
+    "created_at" TIMESTAMP NOT NULL  DEFAULT CURRENT_TIMESTAMP,
+    "user_id" INT NOT NULL REFERENCES "user" ("id") ON DELETE CASCADE /* User */
+)"""
+        )
+
+    elif isinstance(Migrate.ddl, PostgresDDL):
+        assert (
+            ret
+            == """CREATE TABLE IF NOT EXISTS "category" (
+    "id" SERIAL NOT NULL PRIMARY KEY,
+    "slug" VARCHAR(100) NOT NULL,
+    "name" VARCHAR(200),
+    "title" VARCHAR(20) NOT NULL,
+    "created_at" TIMESTAMPTZ NOT NULL  DEFAULT CURRENT_TIMESTAMP,
+    "user_id" INT NOT NULL REFERENCES "user" ("id") ON DELETE CASCADE
+);
+COMMENT ON COLUMN "category"."user_id" IS 'User'"""
+        )
+
+
+def test_drop_table():
+    ret = Migrate.ddl.drop_table(Category._meta.db_table)
+    if isinstance(Migrate.ddl, MysqlDDL):
+        assert ret == "DROP TABLE IF EXISTS `category`"
+    else:
+        assert ret == 'DROP TABLE IF EXISTS "category"'
+
+
+def test_add_column():
+    ret = Migrate.ddl.add_column(Category, Category._meta.fields_map.get("name").describe(False))
+    if isinstance(Migrate.ddl, MysqlDDL):
+        assert ret == "ALTER TABLE `category` ADD `name` VARCHAR(200)"
+    else:
+        assert ret == 'ALTER TABLE "category" ADD "name" VARCHAR(200)'
+
+
+def test_modify_column():
+    if isinstance(Migrate.ddl, SqliteDDL):
+        return
+
+    ret0 = Migrate.ddl.modify_column(
+        Category, Category._meta.fields_map.get("name").describe(False)
+    )
+    ret1 = Migrate.ddl.modify_column(User, User._meta.fields_map.get("is_active").describe(False))
+    if isinstance(Migrate.ddl, MysqlDDL):
+        assert ret0 == "ALTER TABLE `category` MODIFY COLUMN `name` VARCHAR(200)"
+        assert (
+            ret1
+            == "ALTER TABLE `user` MODIFY COLUMN `is_active` BOOL NOT NULL  COMMENT 'Is Active' DEFAULT 1"
+        )
+    elif isinstance(Migrate.ddl, PostgresDDL):
+        assert (
+            ret0
+            == 'ALTER TABLE "category" ALTER COLUMN "name" TYPE VARCHAR(200) USING "name"::VARCHAR(200)'
+        )
+
+        assert (
+            ret1 == 'ALTER TABLE "user" ALTER COLUMN "is_active" TYPE BOOL USING "is_active"::BOOL'
+        )
+
+
+def test_alter_column_default():
+    if isinstance(Migrate.ddl, SqliteDDL):
+        return
+    ret = Migrate.ddl.alter_column_default(User, User._meta.fields_map.get("intro").describe(False))
+    if isinstance(Migrate.ddl, PostgresDDL):
+        assert ret == 'ALTER TABLE "user" ALTER COLUMN "intro" SET DEFAULT \'\''
+    elif isinstance(Migrate.ddl, MysqlDDL):
+        assert ret == "ALTER TABLE `user` ALTER COLUMN `intro` SET DEFAULT ''"
+
+    ret = Migrate.ddl.alter_column_default(
+        Category, Category._meta.fields_map.get("created_at").describe(False)
+    )
+    if isinstance(Migrate.ddl, PostgresDDL):
+        assert (
+            ret == 'ALTER TABLE "category" ALTER COLUMN "created_at" SET DEFAULT CURRENT_TIMESTAMP'
+        )
+    elif isinstance(Migrate.ddl, MysqlDDL):
+        assert (
+            ret
+            == "ALTER TABLE `category` ALTER COLUMN `created_at` SET DEFAULT CURRENT_TIMESTAMP(6)"
+        )
+
+    ret = Migrate.ddl.alter_column_default(
+        Product, Product._meta.fields_map.get("view_num").describe(False)
+    )
+    if isinstance(Migrate.ddl, PostgresDDL):
+        assert ret == 'ALTER TABLE "product" ALTER COLUMN "view_num" SET DEFAULT 0'
+    elif isinstance(Migrate.ddl, MysqlDDL):
+        assert ret == "ALTER TABLE `product` ALTER COLUMN `view_num` SET DEFAULT 0"
+
+
+def test_alter_column_null():
+    if isinstance(Migrate.ddl, (SqliteDDL, MysqlDDL)):
+        return
+    ret = Migrate.ddl.alter_column_null(
+        Category, Category._meta.fields_map.get("name").describe(False)
+    )
+    if isinstance(Migrate.ddl, PostgresDDL):
+        assert ret == 'ALTER TABLE "category" ALTER COLUMN "name" DROP NOT NULL'
+
+
+def test_set_comment():
+    if isinstance(Migrate.ddl, (SqliteDDL, MysqlDDL)):
+        return
+    ret = Migrate.ddl.set_comment(Category, Category._meta.fields_map.get("name").describe(False))
+    assert ret == 'COMMENT ON COLUMN "category"."name" IS NULL'
+
+    ret = Migrate.ddl.set_comment(Category, Category._meta.fields_map.get("user").describe(False))
+    assert ret == 'COMMENT ON COLUMN "category"."user_id" IS \'User\''
+
+
+def test_drop_column():
+    ret = Migrate.ddl.drop_column(Category, "name")
+    if isinstance(Migrate.ddl, MysqlDDL):
+        assert ret == "ALTER TABLE `category` DROP COLUMN `name`"
+    elif isinstance(Migrate.ddl, PostgresDDL):
+        assert ret == 'ALTER TABLE "category" DROP COLUMN "name"'
+
+
+def test_add_index():
+    index = Migrate.ddl.add_index(Category, ["name"])
+    index_u = Migrate.ddl.add_index(Category, ["name"], True)
+    if isinstance(Migrate.ddl, MysqlDDL):
+        assert index == "ALTER TABLE `category` ADD INDEX `idx_category_name_8b0cb9` (`name`)"
+        assert index_u == "ALTER TABLE `category` ADD UNIQUE INDEX `name` (`name`)"
+    elif isinstance(Migrate.ddl, PostgresDDL):
+        assert index == 'CREATE INDEX "idx_category_name_8b0cb9" ON "category" ("name")'
+        assert index_u == 'CREATE UNIQUE INDEX "uid_category_name_8b0cb9" ON "category" ("name")'
+    else:
+        assert index == 'ALTER TABLE "category" ADD INDEX "idx_category_name_8b0cb9" ("name")'
+        assert (
+            index_u == 'ALTER TABLE "category" ADD UNIQUE INDEX "uid_category_name_8b0cb9" ("name")'
+        )
+
+
+def test_drop_index():
+    ret = Migrate.ddl.drop_index(Category, ["name"])
+    ret_u = Migrate.ddl.drop_index(Category, ["name"], True)
+    if isinstance(Migrate.ddl, MysqlDDL):
+        assert ret == "ALTER TABLE `category` DROP INDEX `idx_category_name_8b0cb9`"
+        assert ret_u == "ALTER TABLE `category` DROP INDEX `name`"
+    elif isinstance(Migrate.ddl, PostgresDDL):
+        assert ret == 'DROP INDEX "idx_category_name_8b0cb9"'
+        assert ret_u == 'DROP INDEX "uid_category_name_8b0cb9"'
+    else:
+        assert ret == 'ALTER TABLE "category" DROP INDEX "idx_category_name_8b0cb9"'
+        assert ret_u == 'ALTER TABLE "category" DROP INDEX "uid_category_name_8b0cb9"'
+
+
+def test_add_fk():
+    ret = Migrate.ddl.add_fk(
+        Category, Category._meta.fields_map.get("user").describe(False), User.describe(False)
+    )
+    if isinstance(Migrate.ddl, MysqlDDL):
+        assert (
+            ret
+            == "ALTER TABLE `category` ADD CONSTRAINT `fk_category_user_e2e3874c` FOREIGN KEY (`user_id`) REFERENCES `user` (`id`) ON DELETE CASCADE"
+        )
+    else:
+        assert (
+            ret
+            == 'ALTER TABLE "category" ADD CONSTRAINT "fk_category_user_e2e3874c" FOREIGN KEY ("user_id") REFERENCES "user" ("id") ON DELETE CASCADE'
+        )
+
+
+def test_drop_fk():
+    ret = Migrate.ddl.drop_fk(
+        Category, Category._meta.fields_map.get("user").describe(False), User.describe(False)
+    )
+    if isinstance(Migrate.ddl, MysqlDDL):
+        assert ret == "ALTER TABLE `category` DROP FOREIGN KEY `fk_category_user_e2e3874c`"
+    elif isinstance(Migrate.ddl, PostgresDDL):
+        assert ret == 'ALTER TABLE "category" DROP CONSTRAINT "fk_category_user_e2e3874c"'
+    else:
+        assert ret == 'ALTER TABLE "category" DROP FOREIGN KEY "fk_category_user_e2e3874c"'

tests/test_utils.py

@@ -0,0 +1,6 @@
+from aerich.utils import import_py_file
+
+
+def test_import_py_file() -> None:
+    m = import_py_file("aerich/utils.py")
+    assert getattr(m, "import_py_file")