Warum Würden Sie Django verwenden, ohne die Datenbank mit dem ORM zu treffen? Die meisten der Zeit die ORM funktioniert wie man es erwarten würde, und sogar erlauben Sie sucht wie folgt auszuführen:
class Foo(models.Model):
code = models.CharField(max_length=10, ...)
class Bar(models.Model):
code = models.CharField(max_length=10, ...)
foo = models.ForeignKey(Foo, ...)
Und eine Abfrage wie folgt durchführen:
Bar.objects.get(code='baz', foo_code='bat')
, die die gleiche sein würde, aber besser, als:
select bar.* from yourapp_bar bar inner join yourapp_foo foo on (bar.foo_id = foo.id) where bar.code = 'baz' and foo.code = 'bat'
Kürzer und wartungsfähiger.
Nun zu Django Rest Framework und Django im Allgemeinen: Obwohl die letzten Änderungen sowohl an Django als auch an DRF beteiligt sind, kann man nicht plötzlich erwarten, dass verschachtelte Objekte im selben Moment erstellt werden (zB Foo ist übergeordnet, während Bar ist geschachtelt), wie es in Relation Managern (Django) passiert und Methoden in der ModelSerializer Klasse erstellen und aktualisieren, können Sie immer noch Django vertrauen, um Ihre Zeit, Mühe und Leben zu sparen, indem Sie es anstelle von SQL verwenden.
Ich werde Ihnen ein Beispiel mit DRF geben. Wir gehen davon aus, dass nur Foo-Modelle beteiligt sind. Welchen würdest du bevorzugen?
# yourapp.urls
from .views import UserViewSet
from rest_framework.routers import DefaultRouter
router = DefaultRouter()
router.register(r'users', UserViewSet)
urlpatterns = router.urls
# yourapp.views
class FooViewSet(viewsets.ModelViewSet):
"""
A viewset that provides the standard actions for
a single foo element
"""
queryset = Foo.objects.all()
serializer_class = FooSerializer
# I am assuming you created the FooSerializer to map certain fields...
oder ...
# yourapp.urls
from .views import mywholeurl
from django.conf.urls import url
urlpatterns = [
url('users/(\d+)', mywholeview),
]
# yourapp.views
from django.db import connection
from rest_framework import status
from rest_framework.response import Response
def mywholeview(request, id):
cursor = connection.cursor()
if request.method in ('POST', 'PUT'):
cursor.execute('update yourapp_foo set %s where id = %%s' % ', '.join(["%s=%%s" % p[0] for p in request.data.items()]), list(p[1] for p in request.data.items()) + [id])
row = cursor.fetchone()
if row[0]
return Response(status=status.HTTP_201_ACCEPTED)
else:
return Response(status=status.HTTP_404_NOT_FOUND)
elif request.method = 'GET':
cursor.execute('select * from yourapp_foo where id = %s', [id])
row = cursor.fetchone()
if row:
columns = [col[0] for col in cursor.description]
data = zip(columns, row)
return Response(data, status=status.HTTP_200_OK)
else:
return Response(status=status.HTTP_404_NOT_FOUND)
elif request.method = 'DELETE':
cursor.execute('delete from yourapp_foo where id = %s', [id])
row = cursor.fetchone()
if not int(row[0]):
return Response(status=status.HTTP_404_NOT_FOUND)
else:
return Response(status=status.HTTP_204_NO_CONTENT)
letzteres Code ist nicht getestet und dient nur zur teoretical Zweck. es ist ziemlich unsicher und nicht dazu bestimmt, in der Produktion ausgeführt zu werden, da es eine schlechte Idee ist
Ich würde mit dem kürzesten Ansatz bevorzugen.
Mein Fazit ist: Lernen Sie das ORM! Wenn Sie Ihre Datenbank respektieren müssen, weil sie bereits vorhanden ist, können Sie managed Modelle verwenden. Aber immer ... benutze das ORM und die Funktionen, die dir von Django und DRF gegeben wurden.
Sie müssen die Änderungen an Ihrem models.py vornehmen und './manage.py makemigrations' und' ./manage.py migrieren' ausführen und Ihre Datenbank ändert sich entsprechend den Änderungen in Ihren Modellen. – marcusshep