Fix django admin EmbeddedField CRUD

.gitignore

@@ -1,6 +1,7 @@
 dist/
 build/
 venv/
+venv3.8/
 .idea/
 .tox/
 *__pycache__*

.travis.yml

@@ -2,8 +2,6 @@ language: python
 
 python:
   - "3.6"
-  - "3.7"
-  - "3.8"
 
 install:
   - wget -qO - https://www.mongodb.org/static/pgp/server-4.2.asc | sudo apt-key add -
@@ -18,4 +16,4 @@ before_script:
   - mongo --version
 
 script:
-  - tox -e $(echo py$TRAVIS_PYTHON_VERSION | tr -d .)-django_stable
+  - tox -e py36-django_stable

djongo/features.py

@@ -9,3 +9,6 @@ class DatabaseFeatures(BaseDatabaseFeatures):
     supports_timezones = False
     uses_savepoints = False
     can_clone_databases = True
+    test_db_allows_multiple_connections = False
+    supports_unspecified_pk = True
+

djongo/models/fields.py

@@ -25,6 +25,7 @@
 from django.db.models import (
     Manager, Model, Field, AutoField,
     ForeignKey, BigAutoField)
+from django.utils import version
 from django.db.models.fields.related import RelatedField
 from django.forms import modelform_factory
 from django.utils.functional import cached_property
@@ -33,6 +34,11 @@
 from django.utils.translation import gettext_lazy as _
 from djongo.exceptions import NotSupportedError, print_warn
 
+django_major = int(version.get_version().split('.')[0])
+
+if django_major >= 3:
+    from django.db.models.fields import AutoFieldMixin, AutoFieldMeta
+
 
 def make_mdl(model, model_dict):
     """
@@ -217,7 +223,7 @@ def get_prep_value(self, value):
                                                   value)
         return processed_value
 
-    def from_db_value(self, value, expression, connection, context):
+    def from_db_value(self, value, *args):
         return self.to_python(value)
 
     def to_python(self, value):
@@ -593,6 +599,7 @@ def value_omitted_from_data(self, data, files, name):
 
 class ObjectIdFieldMixin:
     description = _("ObjectId")
+    empty_strings_allowed = False
 
     def get_db_prep_value(self, value, connection, prepared=False):
         return self.to_python(value)
@@ -605,12 +612,23 @@ def to_python(self, value):
     def get_internal_type(self):
         return "ObjectIdField"
 
+    def rel_db_type(self, connection):
+        return self.db_type(connection)
+
 
 class GenericObjectIdField(ObjectIdFieldMixin, Field):
-    empty_strings_allowed = False
+    pass
 
 
-class ObjectIdField(ObjectIdFieldMixin, AutoField):
+if django_major >= 3:
+    class _ObjectIdField(AutoFieldMixin, GenericObjectIdField, metaclass=AutoFieldMeta):
+        pass
+else:
+    class _ObjectIdField(ObjectIdFieldMixin, AutoField):
+        pass
+
+
+class ObjectIdField(_ObjectIdField):
     """
     For every document inserted into a collection MongoDB internally creates an field.
     The field can be referenced from within the Model as _id.
@@ -624,10 +642,6 @@ def __init__(self, *args, **kwargs):
         id_field_args.update(kwargs)
         super().__init__(*args, **id_field_args)
 
-    def get_prep_value(self, value):
-        value = super(AutoField, self).get_prep_value(value)
-        return value
-
 
 class ArrayReferenceManagerMixin:
 

djongo/operations.py

@@ -4,8 +4,6 @@
 from django.utils import timezone
 import datetime
 import calendar
-import six
-
 
 
 class DatabaseOperations(BaseDatabaseOperations):
@@ -50,7 +48,7 @@ def adapt_timefield_value(self, value):
         if value is None:
             return None
 
-        if isinstance(value, six.string_types):
+        if isinstance(value, str):
             return datetime.datetime.strptime(value, '%H:%M:%S')
 
         if timezone.is_aware(value):

djongo/schema.py

@@ -8,28 +8,11 @@ class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
 
     sql_create_index = "ALTER TABLE %(table)s ADD CONSTRAINT %(name)s INDEX (%(columns)s)%(extra)s"
     sql_delete_index = "ALTER TABLE %(table)s DROP CONSTRAINT %(name)s INDEX"
-    sql_delete_index2 = "DROP INDEX %(name)s ON %(table)s"
+
 
     def quote_value(self, value):
-        raise NotImplementedError()
+        return value
 
     def prepare_default(self, value):
         raise NotImplementedError()
 
-    # def create_model(self, model):
-    #     db_con = self.connection.connection
-    #     db_con.create_collection(model._meta.db_table)
-    #     logger.debug('Created table {}'.format(model._meta.db_table))
-    #
-    #     for field in model._meta.local_fields:
-    #         if field.get_internal_type() in ("AutoField", "BigAutoField"):
-    #             db_con['__schema__'].\
-    #                 insert_one(
-    #                 {
-    #                     'name': model._meta.db_table,
-    #                     'auto': {
-    #                         'field_name': field.column,
-    #                         'seq': 0
-    #                     }
-    #                 }
-    #             )

djongo/sql2mongo/operators.py

@@ -465,6 +465,7 @@ def evaluate(self):
             op.evaluate()
         self._op = op
 
+
 class WhereOp(_Op, _StatementParser):
 
     def __init__(self, *args, **kwargs):

djongo/sql2mongo/query.py

@@ -6,7 +6,7 @@
 import re
 from logging import getLogger
 from typing import Optional, Dict, List, Union as U, Sequence, Set
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field as dataclass_field
 from pymongo import MongoClient
 from pymongo import ReturnDocument
 from pymongo.command_cursor import CommandCursor
@@ -23,7 +23,7 @@
 from ..exceptions import SQLDecodeError, MigrationError, print_warn
 from .functions import SQLFunc
 from .sql_tokens import (SQLToken, SQLStatement, SQLIdentifier,
-                         AliasableToken, SQLConstIdentifier)
+                         AliasableToken, SQLConstIdentifier, SQLColumnDef, SQLColumnConstraint)
 from .converters import (
     ColumnSelectConverter, AggColumnSelectConverter, FromConverter, WhereConverter,
     AggWhereConverter, InnerJoinConverter, OuterJoinConverter, LimitConverter, AggLimitConverter, OrderConverter,
@@ -33,15 +33,16 @@
 from djongo import base
 logger = getLogger(__name__)
 
+
 @dataclass
 class TokenAlias:
     alias2token: Dict[str, U[AliasableToken,
                              SQLFunc,
-                             SQLIdentifier]] = field(default_factory=dict)
+                             SQLIdentifier]] = dataclass_field(default_factory=dict)
     token2alias: Dict[U[AliasableToken,
                         SQLFunc,
-                        SQLIdentifier], str] = field(default_factory=dict)
-    aliased_names: Set[str] = field(default_factory=set)
+                        SQLIdentifier], str] = dataclass_field(default_factory=dict)
+    aliased_names: Set[str] = dataclass_field(default_factory=set)
 
 
 class BaseQuery(abc.ABC):
@@ -639,80 +640,89 @@ class CreateQuery(DDLQuery):
     def __init__(self, *args):
         super().__init__(*args)
 
-    def parse(self):
-        statement = SQLStatement(self.statement)
-        statement.skip(2)
+    def _create_table(self, statement):
+        if '__schema__' not in self.connection_properties.cached_collections:
+            self.db.create_collection('__schema__')
+            self.connection_properties.cached_collections.add('__schema__')
+            self.db['__schema__'].create_index('name', unique=True)
+            self.db['__schema__'].create_index('auto')
+
         tok = statement.next()
-        if tok.match(tokens.Keyword, 'TABLE'):
-            if '__schema__' not in self.connection_properties.cached_collections:
-                self.db.create_collection('__schema__')
-                self.connection_properties.cached_collections.add('__schema__')
-                self.db['__schema__'].create_index('name', unique=True)
-                self.db['__schema__'].create_index('auto')
+        table = SQLToken.token2sql(tok, self).table
+        try:
+            self.db.create_collection(table)
+        except CollectionInvalid:
+            if self.connection_properties.enforce_schema:
+                raise
+            else:
+                return
 
-            tok = statement.next()
-            table = SQLToken.token2sql(tok, self).table
-            try:
-                self.db.create_collection(table)
-            except CollectionInvalid:
-                if self.connection_properties.enforce_schema:
-                    raise
-                else:
-                    return
+        logger.debug('Created table: {}'.format(table))
 
-            logger.debug('Created table: {}'.format(table))
+        tok = statement.next()
+        if not isinstance(tok, Parenthesis):
+            raise SQLDecodeError(f'Unexpected sql syntax'
+                                 f' for column definition: {statement}')
+
+        if statement.next():
+            raise SQLDecodeError(f'Unexpected sql syntax'
+                                 f' for column definition: {statement}')
+
+        _filter = {
+            'name': table
+        }
+        _set = {}
+        push = {}
+        update = {}
+
+        for col in SQLColumnDef.statement2col_defs(tok):
+            if isinstance(col, SQLColumnConstraint):
+                print_warn('column CONSTRAINTS')
+            else:
+                field = col.name
+                if field == '_id':
+                    continue
 
-            tok = statement.next()
-            if isinstance(tok, Parenthesis):
-                _filter = {
-                    'name': table
+                _set[f'fields.{field}'] = {
+                    'type_code': col.data_type
                 }
-                _set = {}
-                push = {}
-                update = {}
 
-                for col in tok.value.strip('()').split(','):
-                    props = col.strip().split(' ')
-                    field = props[0].strip('"')
-                    type_code = props[1]
-
-                    _set[f'fields.{field}'] = {
-                        'type_code': type_code
-                    }
-
-                    if field == '_id':
-                        continue
-
-                    if col.find('AUTOINCREMENT') != -1:
-                        try:
-                            push['auto.field_names']['$each'].append(field)
-                        except KeyError:
-                            push['auto.field_names'] = {
-                                '$each': [field]
-                            }
-
-                        _set['auto.seq'] = 0
-
-                    if col.find('PRIMARY KEY') != -1:
-                        self.db[table].create_index(field, unique=True, name='__primary_key__')
-
-                    if col.find('UNIQUE') != -1:
-                        self.db[table].create_index(field, unique=True)
-
-                    if col.find('NOT NULL') != -1:
-                        print_warn('NOT NULL column validation check')
-
-                if _set:
-                    update['$set'] = _set
-                if push:
-                    update['$push'] = push
-                if update:
-                    self.db['__schema__'].update_one(
-                        filter=_filter,
-                        update=update,
-                        upsert=True
-                    )
+                if SQLColumnDef.autoincrement in col.col_constraints:
+                    try:
+                        push['auto.field_names']['$each'].append(field)
+                    except KeyError:
+                        push['auto.field_names'] = {
+                            '$each': [field]
+                        }
+                    _set['auto.seq'] = 0
+
+                if SQLColumnDef.primarykey in col.col_constraints:
+                    self.db[table].create_index(field, unique=True, name='__primary_key__')
+
+                if SQLColumnDef.unique in col.col_constraints:
+                    self.db[table].create_index(field, unique=True)
+
+                if (SQLColumnDef.not_null in col.col_constraints or
+                        SQLColumnDef.null in col.col_constraints):
+                    print_warn('NULL, NOT NULL column validation check')
+
+        if _set:
+            update['$set'] = _set
+        if push:
+            update['$push'] = push
+        if update:
+            self.db['__schema__'].update_one(
+                filter=_filter,
+                update=update,
+                upsert=True
+            )
 
+    def parse(self):
+        statement = SQLStatement(self.statement)
+        statement.skip(2)
+        tok = statement.next()
+        if tok.match(tokens.Keyword, 'TABLE'):
+            self._create_table(statement)
         elif tok.match(tokens.Keyword, 'DATABASE'):
             pass
         else: