fix: remove unused 'charset' in generate schema encoders (#1817)

* fix: remove unused 'charset' in generate schema encoders

* fix: update testcases for generate schema array fields

* fix: remove extra spaces when generate schema

* fix(schema-generator): use {} wrap in default value for postgres array field

* fix(sqlite): set support_update_limit_order_by=False because sqlite does not support it

Author: nglehuy

.gitignore

@@ -107,3 +107,5 @@ ENV/
 # MyPy caches
 .mypy_cache/
 
+# macos
+.DS_Store

tests/schema/models_postgres_fields.py

@@ -0,0 +1,17 @@
+from tortoise import Model
+from tortoise.contrib.postgres.fields import TSVectorField, ArrayField
+
+
+class PostgresFields(Model):
+    tsvector = TSVectorField()
+    text_array = ArrayField(element_type="text", default=["a", "b", "c"])
+    varchar_array = ArrayField(element_type="varchar(32)", default=["aa", "bbb", "cccc"])
+    int_array = ArrayField(element_type="int", default=[1, 2, 3], null=True)
+    real_array = ArrayField(
+        element_type="real",
+        default=[1.1, 2.2, 3.3],
+        description="this is array of real numbers",
+    )
+
+    class Meta:
+        table = "postgres_fields"

tests/schema/test_generate_schema.py

@@ -22,7 +22,7 @@
 class BaseSchemaGenerator:
     DIALECT = "sql"
     TABLE_CREATE_TEMPLATE = 'CREATE TABLE {exists}"{table_name}" ({fields}){extra}{comment};'
-    FIELD_TEMPLATE = '"{name}" {type} {nullable} {unique}{primary}{default}{comment}'
+    FIELD_TEMPLATE = '"{name}" {type}{nullable}{unique}{primary}{default}{comment}'
     INDEX_CREATE_TEMPLATE = 'CREATE INDEX {exists}"{index_name}" ON "{table_name}" ({fields});'
     UNIQUE_INDEX_CREATE_TEMPLATE = INDEX_CREATE_TEMPLATE.replace(" INDEX", " UNIQUE INDEX")
     UNIQUE_CONSTRAINT_CREATE_TEMPLATE = 'CONSTRAINT "{index_name}" UNIQUE ({fields})'
@@ -251,8 +251,8 @@ def _get_table_sql(self, model: "Type[Model]", safe: bool = True) -> dict:
                         )
                         continue
 
-            nullable = "NOT NULL" if not field_object.null else ""
-            unique = "UNIQUE" if field_object.unique else ""
+            nullable = " NOT NULL" if not field_object.null else ""
+            unique = " UNIQUE" if field_object.unique else ""
 
             if getattr(field_object, "reference", None):
                 reference = cast("ForeignKeyFieldInstance", field_object.reference)

tortoise/backends/base/schema_generator.py

@@ -11,7 +11,7 @@
 class MSSQLSchemaGenerator(BaseSchemaGenerator):
     DIALECT = "mssql"
     TABLE_CREATE_TEMPLATE = "CREATE TABLE [{table_name}] ({fields}){extra};"
-    FIELD_TEMPLATE = "[{name}] {type} {nullable} {unique}{primary}{default}"
+    FIELD_TEMPLATE = "[{name}] {type}{nullable}{unique}{primary}{default}"
     INDEX_CREATE_TEMPLATE = "CREATE INDEX [{index_name}] ON [{table_name}] ({fields});"
     GENERATED_PK_TEMPLATE = "[{field_name}] {generated_sql}"
     FK_TEMPLATE = (

tortoise/backends/mssql/schema_generator.py

@@ -14,7 +14,7 @@ class MySQLSchemaGenerator(BaseSchemaGenerator):
     INDEX_CREATE_TEMPLATE = "KEY `{index_name}` ({fields})"
     UNIQUE_CONSTRAINT_CREATE_TEMPLATE = "UNIQUE KEY `{index_name}` ({fields})"
     UNIQUE_INDEX_CREATE_TEMPLATE = UNIQUE_CONSTRAINT_CREATE_TEMPLATE
-    FIELD_TEMPLATE = "`{name}` {type} {nullable} {unique}{primary}{comment}{default}"
+    FIELD_TEMPLATE = "`{name}` {type}{nullable}{unique}{primary}{comment}{default}"
     GENERATED_PK_TEMPLATE = "`{field_name}` {generated_sql}{comment}"
     FK_TEMPLATE = (
         "{constraint}FOREIGN KEY (`{db_column}`)"

tortoise/backends/mysql/schema_generator.py

@@ -12,7 +12,7 @@
 class OracleSchemaGenerator(BaseSchemaGenerator):
     DIALECT = "oracle"
     TABLE_CREATE_TEMPLATE = 'CREATE TABLE "{table_name}" ({fields}){extra};'
-    FIELD_TEMPLATE = '"{name}" {type}{default} {nullable} {unique}{primary}'
+    FIELD_TEMPLATE = '"{name}" {type}{default}{nullable}{unique}{primary}'
     TABLE_COMMENT_TEMPLATE = "COMMENT ON TABLE \"{table}\" IS '{comment}';"
     COLUMN_COMMENT_TEMPLATE = 'COMMENT ON COLUMN "{table}"."{column}" IS \'{comment}\';'
     INDEX_CREATE_TEMPLATE = 'CREATE INDEX "{index_name}" ON "{table_name}" ({fields});'

tortoise/backends/oracle/schema_generator.py

@@ -61,7 +61,12 @@ class SqliteClient(BaseDBAsyncClient):
     query_class = SQLLiteQuery
     schema_generator = SqliteSchemaGenerator
     capabilities = Capabilities(
-        "sqlite", daemon=False, requires_limit=True, inline_comment=True, support_for_update=False
+        "sqlite",
+        daemon=False,
+        requires_limit=True,
+        inline_comment=True,
+        support_for_update=False,
+        support_update_limit_order_by=False,
     )
 
     def __init__(self, file_path: str, **kwargs: Any) -> None:

tortoise/backends/sqlite/client.py

@@ -10,7 +10,7 @@ class TSVectorField(Field):
 class ArrayField(Field, list):  # type: ignore
     def __init__(self, element_type: str = "int", **kwargs: Any):
         super().__init__(**kwargs)
-        self.element_type = element_type
+        self.element_type = element_type.upper()
 
     @property
     def SQL_TYPE(self) -> str:  # type: ignore

tortoise/contrib/postgres/fields.py

@@ -25,43 +25,44 @@ def _escape_unicode(value: str, mapping=None) -> str:
 escape_string = _escape_unicode
 
 
-def escape_item(val: Any, charset, mapping=None) -> str:
+def escape_item(val: Any, mapping=None) -> str:
+    if isinstance(val, str):
+        return f'"{val}"'
+
     if mapping is None:
         mapping = encoders
+
     encoder = mapping.get(type(val))
 
     # Fallback to default when no encoder found
     if not encoder:
         try:
             encoder = mapping[str]
-        except KeyError:
-            raise TypeError("no default type converter defined")
+        except KeyError as exc:
+            raise TypeError("no default type converter defined") from exc
 
-    if encoder in (escape_dict, escape_sequence):
-        val = encoder(val, charset, mapping)
-    else:
-        val = encoder(val, mapping)
+    val = encoder(val, mapping)
     return val
 
 
-def escape_dict(val: Dict, charset, mapping=None) -> dict:
+def escape_dict(val: Dict, mapping=None) -> dict:
     n = {}
     for k, v in val.items():
-        quoted = escape_item(v, charset, mapping)
+        quoted = escape_item(v, mapping)
         n[k] = quoted
     return n
 
 
-def escape_sequence(val: Sequence, charset, mapping=None) -> str:
+def escape_sequence(val: Sequence, mapping=None) -> str:
     n = []
     for item in val:
-        quoted = escape_item(item, charset, mapping)
+        quoted = escape_item(item, mapping)
         n.append(quoted)
-    return "(" + ",".join(n) + ")"
+    return "'{" + ",".join(n) + "}'"
 
 
-def escape_set(val: Set, charset, mapping=None) -> str:
-    return ",".join([escape_item(x, charset, mapping) for x in val])
+def escape_set(val: Set, mapping=None) -> str:
+    return ",".join([escape_item(x, mapping) for x in val])
 
 
 def escape_bool(value: bool, mapping=None) -> str: