Eine Idee, ORM mit Node.js zu implementieren

ORM ist eine Abbildung von O und R. O steht für objektorientiert und R steht für relationale Datenbank. Die beiden haben Ähnlichkeiten, haben aber auch ihre eigenen Eigenschaften. Aufgrund dieser richtigen und falschen Situation ist eine Kartierung erforderlich. Dieser Artikel stellt hauptsächlich eine detaillierte Erklärung (Bilder und Text) einer Idee zur Verwendung von Node.js zur Implementierung von ORM vor. Ich hoffe, dass es allen helfen kann.

Die ideale Situation besteht darin, die Datenbank gemäß den Merkmalen der relationalen Datenbank (einschließlich Geschäftsanforderungen) zu entwerfen. Gleichzeitig wird das Modell (Entitätsklasse) gemäß den Merkmalen der Objektorientierung (einschließlich Geschäftsanforderungen) entworfen. Überlegen Sie dann, wie Sie das Mapping durchführen. Aber das Ideal ist sehr dünn und die Realität ist zu reich und voll.

Ich habe noch nie einen ORM gesehen, der dies getan hat, und ich habe noch nie einen Experten gesehen, der es auf diese Weise entworfen hat. Wie sieht nun die tatsächliche Situation aus? Nehmen Sie als Beispiel das Entity Framework von .net.

Der erste DB-Entwurf besteht darin, zuerst die Datenbank zu entwerfen und dann automatisch Entitätsklassen basierend auf den Tabellen, Primär- und Fremdschlüsseln usw. in der Bibliothek zu erstellen. Dann kann es über LinQToSQL betrieben werden. Der so erstellten Entitätsklasse fehlen offensichtlich objektorientierte Funktionen.

Der erste Code besteht darin, zuerst die Entitätsklasse zu entwerfen und dann automatisch Tabellen, Primär- und Fremdschlüssel, Einschränkungen usw. basierend auf der Entitätsklasse und den Merkmalen zu erstellen. Aus Gründen der Genauigkeit müssen Sie beim Definieren von Entitätsklassen Dinge mit relationalen Merkmalen wie Primär- und Fremdschlüsseln erklären.

Wie unten gezeigt

Jetzt möchte ich Node verwenden, um eine Engine zu erstellen. Ich bin gerade mit Node in Kontakt gekommen. Ich weiß nicht, wie sie das machen. Ich werde sie zunächst ignorieren.

Warum sollten Sie sich für Node entscheiden? Ich dachte, es unterstützt JSON nativ. Json ist das Hauptfeld im Frontend. js unterstützt JSON nativ und alle Vorgänge sind sehr reibungslos und komfortabel. Aber JSON ist in Schwierigkeiten, wenn es das Backend erreicht (C#). C# unterstützt JSON nicht nativ und kann nur als String- oder Entitätsklassenserialisierung verwendet werden. Dazu muss man sich bewegen, was sehr mühsam ist.

Mit Node kann das Backend auch in js kodiert werden, was bedeutet, dass json nativ unterstützt wird. Das ist viel komfortabler. Denken Sie darüber nach: Das Front-End erstellt JSON (Entitätsklasse) und sendet dann das Ganze an das Back-End. Das Back-End empfängt den JSON zur direkten Verarbeitung (Sicherheitsüberprüfung, Geschäftsverarbeitung) und speichert ihn dann direkt. Ist es nicht toll!

Ein weiterer Vorteil der Verwendung von Knoten besteht darin, dass Attribute von Entitätsklassen zur Laufzeit definiert werden können, beispielsweise durch das Hinzufügen von Attributen. Dies ist in C# nicht möglich.

Warum muss die Entitätsklasse zur Laufzeit geändert werden? Denn dadurch kann die Explosion der Zahl der Entitätsklassen vermieden werden.

Öffnen Sie Ihr Projekt und zählen Sie, wie viele Entitätsklassen definiert sind? Gibt es umso mehr Entitätsklassen, je größer das Projekt ist? Wenn sich die Anforderungen ändern und der Entitätsklasse ein Attribut hinzugefügt werden muss, muss ich dann den Code auf verschiedene Weise ändern? Obwohl VS uns bei der Erledigung einer Menge Arbeit helfen kann.

Daher ist es besser, die Entitätsklasse zur Laufzeit nach Belieben zu ändern, wodurch das Problem der Codeänderung erheblich vermieden werden kann. (Weil es überhaupt keinen Code gibt)

In diesem Artikel geht es hauptsächlich um Ideen, daher werde ich einfach einen JSON entwerfen, um ihn auszudrücken.

Der Zweck des Entwurfs dieses JSON besteht darin, dass die Engine ihn entsprechend der JSON-Situation in SQL integrieren und ihn dann zur Verarbeitung an die Datenbank übergeben kann.

{
 "operationMode":"add",// add\update\delete\select
 "tableCount":1, //支持多表的级联添加、修改
 "fieldInfo":[{//主表的字段，参与操作的字段，不参与的不用写。第一个字段是主键（不支持多主键）
 "tableName": "t1", //表名。
 "primaryKey":"id",//主键字段名。我不想把主键字段名限制为必须是“ID”
 "_sqlCache": "" ,//缓存的sql语句，每次都拼接sql也挺烦的，弄个缓存存放拼接好的sql。
 "fieldList":{ //涉及到的字段，并不需要把表里的字段都放进来，根据业务需求设计
   //客户端提交的json与之对应
 "field1Name":"field1Value",
 "field2Name":"field2Value"
 }
 },
 { //从表的字段，可以不设置
 "primaryKey": "id", //主键字段名。我不想把主键字段名限制为必须是“ID”
 "foreignKey": "foreignKeyid", //主键字段名。我不想把主键字段名限制为必须是“ID”
 "_sqlCache": "", //缓存的sql语句，每次都拼接sql也挺烦的，弄个缓存存放拼接好的sql。
 "fieldList": { //涉及到的字段（不含外键字段），并不需要把表里的字段都放进来，根据业务需求设计
   //客户端提交的json与之对应
 "field1Name": "field1Value",
 "field2Name": "field2Value"
 }
 } // 从表的字段，参与操作的字段，不参与的不用写。第一个字段是主键，第二个字段是外键
 ],
 "findCol":[{
 "colName":"col1",
 "key1":"abc",
 "key2":"abc", //范围查询时使用，比如从几号到几号
 "findKind":" {colName} like {key}" //查询方式：like、not Like、in、=、between等
 }]
}

Allgemeines ORM verwendet Entitätsklassen als Kern und erfordert die Integrität von Entitätsklassen. Das heißt, eine Entitätsklasse muss einer vollständigen Tabelle zugeordnet werden. Wenn Sie beispielsweise ein Produkt aus den Regalen entfernen möchten, besteht der allgemeine Ansatz darin, das Produkt zunächst aus der Datenbank zu lesen und zu instanziieren, dann die Tag-Attribute (Felder) zu ändern und dann die gesamte Entitätsklasse beizubehalten (zu speichern). der Datenbank).

Aber wie schreibt man SQL? Es genügt ein Update, das Auslesen der Daten ist nicht erforderlich, die Effizienz geht also etwas verloren.

Was passiert also, wenn Sie alle Produkte in einer Kategorie entfernen möchten? Sie müssen alle Produkte in dieser Kategorie entfernen, dann die Attributwerte stapelweise ändern und sie stapelweise beibehalten.

Was passiert, wenn Sie eine SQL-Anweisung schreiben? Es ist immer noch dasselbe SQL, aber die Abfragebedingungen haben sich geändert und es besteht immer noch keine Notwendigkeit, mit den Daten herumzuspielen. In diesem Fall ist der Unterschied in der Effizienz enorm.

Und meine Idee basiert nicht auf einer objektorientierten, sondern auf einer relationalen Datenbank.

Das bedeutet, dass Entitätsklassen und Tabellen nicht als Ganzes abgebildet werden, sondern Attribute und Felder. Das heißt, nehmen Sie einige Felder aus einer Tabelle, machen Sie sie zu einer Entitätsklasse und führen Sie dann Operationen aus. Zum Beispiel ein Beispiel für das Entfernen von Produkten aus den Regalen

Tabelle: Produkttabelle

Felder: isxiajia = 1

Bedingungen: id=1 (einzelnes Produkt aus den Regalen entfernt) cate=2 (gemäß Klassifizierung entfernt)

und generieren Sie dann eine Aktualisierungsanweisung.

Dies ist eine unabhängige „Entitätsklasse“. Diese Klasse erfordert keine anderen Attribute des Produkts, da es sich lediglich um einen Entfernungsvorgang handelt. Darüber hinaus sind auch die Abfragebedingungen vollständig liberalisiert. Anstatt nur auf der Grundlage der ID abzufragen, können Sie auch auf der Grundlage anderer Felder, beispielsweise Klassifizierungsfelder, abfragen. Auf diese Weise kann die Effizienz verbessert werden.

Verwandte Empfehlungen:

URL-Muster-Einstellungsmethode und Zuordnungsregeln von Servlet und Filter

Einführung in die objektorientierte Identitätszuordnung von PHP

Einführung in die ORM-Zuordnung mithilfe von Annotationen

Das obige ist der detaillierte Inhalt vonEine Idee, ORM mit Node.js zu implementieren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!