future-framework 3.0.0__tar.gz → 3.0.1__tar.gz

{future_framework-3.0.0 → future_framework-3.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: future-framework
-Version: 3.0.0
+Version: 3.0.1
 Summary: ASGI-based framework for web APIs
 License: LICENSE
 License-File: LICENSE

{future_framework-3.0.0 → future_framework-3.0.1}/future/databases/MySQLDatabase.py

@@ -172,7 +172,6 @@ class MySQLDatabase(IDatabase):
         async with self.client.connect() as connection:
             rows = (await connection.execute(sql, {"table": blueprint.name})).mappings().all()
         existing = {row["COLUMN_NAME"] for row in rows}
-        common = [column.name for column in blueprint.columns if column.name in existing]
         temporary = f"_future_migrate_{blueprint.name}"
         backup = f"_future_backup_{blueprint.name}"
         parts = self._schema_parts(blueprint)
@@ -180,9 +179,27 @@ class MySQLDatabase(IDatabase):
             await connection.execute(text(f"DROP TABLE IF EXISTS `{temporary}`"))
             await connection.execute(text(f"DROP TABLE IF EXISTS `{backup}`"))
             await connection.execute(text(f"CREATE TABLE `{temporary}` ({', '.join(parts)})"))
-            if common:
-                columns = ", ".join(f"`{name}`" for name in common)
-                await connection.execute(text(f"INSERT INTO `{temporary}` ({columns}) SELECT {columns} FROM `{blueprint.name}`"))
+            targets = []
+            sources = []
+            backfills = {}
+            for index, column in enumerate(blueprint.columns):
+                quoted = f"`{column.name}`"
+                if column.name in existing:
+                    source = quoted
+                    if not column.is_nullable:
+                        key = f"future_backfill_{index}"
+                        source = f"COALESCE({quoted}, :{key})"
+                        backfills[key] = column.backfill_value()
+                elif not column.is_nullable:
+                    key = f"future_backfill_{index}"
+                    source = f":{key}"
+                    backfills[key] = column.backfill_value()
+                else:
+                    continue
+                targets.append(quoted)
+                sources.append(source)
+            if targets:
+                await connection.execute(text(f"INSERT INTO `{temporary}` ({', '.join(targets)}) SELECT {', '.join(sources)} FROM `{blueprint.name}`"), backfills)
             await connection.execute(text(f"RENAME TABLE `{blueprint.name}` TO `{backup}`, `{temporary}` TO `{blueprint.name}`"))
             await connection.execute(text(f"DROP TABLE `{backup}`"))
         return {"status": "updated", "table": blueprint.name, "columns": sorted(column.name for column in blueprint.columns)}

{future_framework-3.0.0 → future_framework-3.0.1}/future/databases/PostgresDatabase.py

@@ -180,15 +180,32 @@ class PostgresDatabase(IDatabase):
         async with self.client.connect() as connection:
             rows = (await connection.execute(sql, {"table": blueprint.name})).mappings().all()
         existing = {row["column_name"] for row in rows}
-        common = [column.name for column in blueprint.columns if column.name in existing]
         temporary = f"_future_{uuid4().hex[:8]}_{blueprint.name}"[:63]
         parts, indexes = self._schema_parts(blueprint)
         async with self.client.begin() as connection:
             await connection.execute(text(f'DROP TABLE IF EXISTS "{temporary}"'))
             await connection.execute(text(f'CREATE TABLE "{temporary}" ({", ".join(parts)})'))
-            if common:
-                columns = ", ".join(f'"{name}"' for name in common)
-                await connection.execute(text(f'INSERT INTO "{temporary}" ({columns}) SELECT {columns} FROM "{blueprint.name}"'))
+            targets = []
+            sources = []
+            backfills = {}
+            for index, column in enumerate(blueprint.columns):
+                quoted = f'"{column.name}"'
+                if column.name in existing:
+                    source = quoted
+                    if not column.is_nullable:
+                        key = f"future_backfill_{index}"
+                        source = f"COALESCE({quoted}, :{key})"
+                        backfills[key] = column.backfill_value()
+                elif not column.is_nullable:
+                    key = f"future_backfill_{index}"
+                    source = f":{key}"
+                    backfills[key] = column.backfill_value()
+                else:
+                    continue
+                targets.append(quoted)
+                sources.append(source)
+            if targets:
+                await connection.execute(text(f'INSERT INTO "{temporary}" ({", ".join(targets)}) SELECT {", ".join(sources)} FROM "{blueprint.name}"'), backfills)
             await connection.execute(text(f'DROP TABLE "{blueprint.name}"'))
             await connection.execute(text(f'ALTER TABLE "{temporary}" RENAME TO "{blueprint.name}"'))
             for index_name in indexes:

{future_framework-3.0.0 → future_framework-3.0.1}/future/databases/SQLiteDatabase.py

@@ -178,16 +178,33 @@ class SQLiteDatabase(IDatabase):
             rows = (await connection.execute(text(f'PRAGMA table_info("{blueprint.name}")'))).mappings().all()
         existing = {row["name"] for row in rows}
         desired = {column.name for column in blueprint.columns}
-        common = [column.name for column in blueprint.columns if column.name in existing]
         temporary = f"_future_migrate_{blueprint.name}"
         definitions, _ = self._schema_parts(blueprint)
         _, indexes = self._schema_parts(blueprint, index_table=blueprint.name)
         async with self.client.begin() as connection:
             await connection.execute(text(f'DROP TABLE IF EXISTS "{temporary}"'))
             await connection.execute(text(f'CREATE TABLE "{temporary}" ({", ".join(definitions)})'))
-            if common:
-                columns = ", ".join(f'"{name}"' for name in common)
-                await connection.execute(text(f'INSERT INTO "{temporary}" ({columns}) SELECT {columns} FROM "{blueprint.name}"'))
+            targets = []
+            sources = []
+            backfills = {}
+            for index, column in enumerate(blueprint.columns):
+                quoted = f'"{column.name}"'
+                if column.name in existing:
+                    source = quoted
+                    if not column.is_nullable:
+                        key = f"future_backfill_{index}"
+                        source = f"COALESCE({quoted}, :{key})"
+                        backfills[key] = column.backfill_value()
+                elif not column.is_nullable:
+                    key = f"future_backfill_{index}"
+                    source = f":{key}"
+                    backfills[key] = column.backfill_value()
+                else:
+                    continue
+                targets.append(quoted)
+                sources.append(source)
+            if targets:
+                await connection.execute(text(f'INSERT INTO "{temporary}" ({", ".join(targets)}) SELECT {", ".join(sources)} FROM "{blueprint.name}"'), backfills)
             await connection.execute(text(f'DROP TABLE "{blueprint.name}"'))
             await connection.execute(text(f'ALTER TABLE "{temporary}" RENAME TO "{blueprint.name}"'))
             for index_sql in indexes:

{future_framework-3.0.0 → future_framework-3.0.1}/future/migrations.py

@@ -55,6 +55,21 @@ class Column:
         self.default_value = value
         return self
 
+    def backfill_value(self):
+        if self.default_value is not None:
+            return self.default_value
+        if self.type in ("string", "text"):
+            return ""
+        if self.type == "integer":
+            return 0
+        if self.type == "float":
+            return 0.0
+        if self.type == "boolean":
+            return False
+        if self.type == "datetime":
+            return datetime(1970, 1, 1)
+        raise ValueError(f"Unsupported column type: {self.type}")
+
 
 class Blueprint:
     def __init__(self, name, connection_name, action="create"):
@@ -268,6 +283,11 @@ class MigrationGenerator:
         for field, annotation in annotations.items():
             line = self.column_line(field, annotation)
             if line is not None:
+                default_value = vars(model).get(field)
+                if default_value is not None:
+                    if isinstance(default_value, datetime):
+                        default_value = default_value.isoformat(sep=" ")
+                    line += f".default({default_value!r})"
                 lines.append(f"            {line}")
         if use_timestamps:
             lines.append("            table.timestamps()")

{future_framework-3.0.0 → future_framework-3.0.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "future-framework"
-version = "3.0.0"
+version = "3.0.1"
 description = "ASGI-based framework for web APIs"
 authors = ["nicolaipre"]
 license = "LICENSE"