ORM model lists now can contain other ORM models

Author: ustims

CHANGELOG.md

@@ -1,3 +1,8 @@
+0.2.1
+-----
+
+- Added support for ORM models as list members
+
 0.2.0
 -----
 

lib/src/annotations.dart

@@ -89,19 +89,50 @@ class AnnotationsParser {
           // to create additional tables for connecting those references
           if (table.hasReferenceFields) {
             for (Field f in table.fields) {
-              if (f is ListReferenceField) {
-                ListReferenceTable fieldReferenceTable =
-                    new ListReferenceTable(table, f);
-
-                f.referenceTable = fieldReferenceTable;
+              if (f is ListJoinField) {}
+            }
+          }
+        }
+      }
+    }
 
-                ormClasses[fieldReferenceTable.tableName] = fieldReferenceTable;
-              }
+    // When all types with annotations processed we need to go over all
+    // tables to find references to other tables and set [Table] instance
+    // on such references
+    Map tablesToAdd = {};
+    for (Table t in ormClasses.values) {
+      if (t.hasReferenceFields) {
+        for (Field f in t.fields) {
+          if (f is ListJoinField) {
+            // check if field is a reference to another model table
+            var listGenericModelTable =
+                AnnotationsParser.getTableForType(f.generic.reflectedType);
+
+            // If list members are simple dart types -
+            // construct [ListJoinValuesTable] which will store values
+            // in-place.
+            if (listGenericModelTable == null) {
+              ListJoinValuesTable fieldJoinTable =
+                  new ListJoinValuesTable(t, f);
+              f.joinTable = fieldJoinTable;
+            } else {
+              // If list members are other ORM models -
+              // construct [ListJoinModelsTable] which will
+              // store primary key references between original [Table]
+              // and list members.
+              ListJoinModelsTable fieldJoinTable =
+                  new ListJoinModelsTable(t, f, listGenericModelTable);
+              f.joinTable = fieldJoinTable;
             }
+
+            tablesToAdd[f.joinTable.tableName] = f.joinTable;
           }
         }
       }
     }
+    for (String tableName in tablesToAdd.keys) {
+      ormClasses[tableName] = tablesToAdd[tableName];
+    }
   }
 
   /// Iterates through all class declarations in current isolate
@@ -134,8 +165,7 @@ class AnnotationsParser {
     String modelClassName = MirrorSystem.getName(modelMirror.simpleName);
 
     if (!ormClasses.containsKey(modelClassName)) {
-      throw new Exception(
-          'Can\'t find ORM annotations for class $modelClassName');
+      return null;
     }
 
     return ormClasses[modelClassName];
@@ -174,8 +204,8 @@ class AnnotationsParser {
     /// Lists (or arrays) are implemented by creating separate table for
     /// all list values with reference to original record by primary key.
     if (fieldDartTypeName == 'List') {
-      field = new ListReferenceField();
-      (field as ListReferenceField).generic = fieldMirror.type.typeArguments[0];
+      field = new ListJoinField();
+      (field as ListJoinField).generic = fieldMirror.type.typeArguments[0];
     } else {
       field = new Field();
     }
@@ -188,13 +218,13 @@ class AnnotationsParser {
       if (annotationTypeName == "DBFieldPrimaryKey") {
         field.isPrimaryKey = true;
 
-        if (field is ListReferenceField) {
+        if (field is ListJoinField) {
           throw new StateError('List fields could not be primary keys.');
         }
       } else if (annotationTypeName == "DBFieldType") {
         field.type = annotationMirror.reflectee.type;
 
-        if (field is ListReferenceField) {
+        if (field is ListJoinField) {
           throw new StateError(
               'Field type could not be overriden for List fields');
         }
@@ -219,6 +249,7 @@ class AnnotationsParser {
    * Scans DB* annotations on class fields and constructs DBTableSQL instance
    */
   static Table constructTable(ClassMirror modelClassMirror) => new Table()
+    ..modelType = modelClassMirror.reflectedType
     ..className = _getTableName(modelClassMirror)
     ..fields = _getFields(modelClassMirror);
 

lib/src/model.dart

@@ -104,7 +104,7 @@ class Model {
 }
 
 class FindBase extends Select {
-  final Type _modelType;
+  Type _modelType;
   final Table table;
 
   FindBase(Type modelType)
@@ -131,6 +131,15 @@ class FindBase extends Select {
 
   static Future<List> _executeFind(Type modelType, Select selectSql) async {
     Table modelTable = AnnotationsParser.getTableForType(modelType);
+
+    if (modelTable == null) {
+      ClassMirror modelMirror = reflectClass(modelType);
+      String modelClassName = MirrorSystem.getName(modelMirror.simpleName);
+
+      throw new Exception(
+          'Can\'t find ORM annotations for class $modelClassName');
+    }
+
     ClassMirror modelMirror = reflectClass(modelType);
 
     List<dynamic> foundInstances = new List<dynamic>();
@@ -147,7 +156,7 @@ class FindBase extends Select {
       for (Field field in modelTable.fields) {
         var fieldValue = row[field.fieldName];
 
-        if (field is ListReferenceField) {
+        if (field is ListJoinField) {
           fieldValue = []; // just create new list. It will be populated later.
         }
 
@@ -161,17 +170,36 @@ class FindBase extends Select {
       foundInstances.add(newInstance.reflectee);
     }
 
-    if (hasReferenceFields) {
-      for (Field field in modelTable.fields) {
-        if (field is ListReferenceField) {
-          ListReferenceField listField = field;
-          ListReferenceTable listTable = field.referenceTable;
+    foundInstances = await _populate(foundInstances);
+
+    return foundInstances;
+  }
+
+  static Future _populate(List modelsFound) async {
+    if (modelsFound.length < 1) {
+      return modelsFound;
+    }
+
+    Table modelTable = AnnotationsParser.getTableForInstance(modelsFound[0]);
+    Field modelPrimaryKeyField = modelTable.getPrimaryKeyField();
+
+    List modelsIds =
+        new List.from(modelsFound.map((m) => orm.getPrimaryKeyValue(m)));
+
+    for (Field field in modelTable.fields) {
+      if (field is ListJoinField) {
+        ListJoinField listField = field;
+
+        if (field.joinTable is ListJoinValuesTable) {
+          // When list members are simple types and are stored right inside
+          // join table
+          ListJoinValuesTable listTable = field.joinTable;
 
           Select referenceSelect = new Select(['*']);
-          referenceSelect.table = listField.referenceTable;
-          referenceSelect.where(new In(
-              listTable.primaryKeyReferenceField.fieldName,
-              resulRowsPromaryKeys));
+          referenceSelect.table = listField.joinTable;
+          referenceSelect.where(
+              new In(listTable.primaryKeyReferenceField.fieldName, modelsIds));
+
           var results = await orm.getDefaultAdapter().select(referenceSelect);
 
           // now we have all values from reference table for all results from original select.
@@ -180,21 +208,84 @@ class FindBase extends Select {
             var modelId = row[listTable.primaryKeyReferenceField.fieldName];
             var value = row[listTable.valueField.fieldName];
 
-            for (var foundInstance in foundInstances) {
+            for (var foundInstance in modelsFound) {
               var foundInstanceId = AnnotationsParser.getPropertyValueForField(
-                  selectSql.table.getPrimaryKeyField(), foundInstance);
+                  modelPrimaryKeyField, foundInstance);
+
               if (foundInstanceId == modelId) {
                 var list = AnnotationsParser.getPropertyValueForField(
                     field, foundInstance);
                 list.add(value);
               }
             }
           }
+        } else if (field.joinTable is ListJoinModelsTable) {
+          ListJoinModelsTable listTable = field.joinTable;
+
+          // first - select list members ids from join table
+          Select listMembersIdsSelect = new Select(['*']);
+          listMembersIdsSelect.table = listField.joinTable;
+          listMembersIdsSelect.where(new In(
+              listTable.listHolderPrimaryKeyReference.fieldName, modelsIds));
+
+          // raw list of list members ids. Each item in this list will have a
+          // map with list holder id and list member id.
+          List rawListMembersIds =
+          await orm.getDefaultAdapter().select(listMembersIdsSelect);
+
+          // Just gather all list members ids in a simple list
+          List allListMemberIds = [];
+
+          // Make a map which keys are model ids and values are lists with found
+          // list members
+          Map<dynamic, List> listMembersIdByModelId = {};
+
+          rawListMembersIds.forEach((m) {
+            allListMemberIds
+                .add(m[listTable.listMembersPrimaryKeyReference.fieldName]);
+
+            var modelId = m[listTable.listHolderPrimaryKeyReference.fieldName];
+
+            if (!listMembersIdByModelId.containsKey(modelId)) {
+              listMembersIdByModelId[modelId] = [];
+            }
+
+            listMembersIdByModelId[modelId]
+                .add(m[listTable.listMembersPrimaryKeyReference.fieldName]);
+          });
+
+          if (allListMemberIds.length > 0) {
+            // find all list members for all found models
+            Find findMembers = new Find(listTable.listMembersTable.modelType);
+            findMembers.where(new In(
+                listTable.listMembersTable
+                    .getPrimaryKeyField()
+                    .fieldName,
+                allListMemberIds));
+
+            List allListMembers = await findMembers.execute();
+
+            // now lets move found list members to models lists
+
+            for (var foundInstance in modelsFound) {
+              var foundInstanceId = AnnotationsParser.getPropertyValueForField(
+                  modelPrimaryKeyField, foundInstance);
+
+              List listMemberIdsForFoundModel = listMembersIdByModelId[foundInstanceId];
+              List listMembers = new List.from(allListMembers.where((m) {
+                return listMemberIdsForFoundModel.contains(
+                    orm.getPrimaryKeyValue(m));
+              }));
+
+              AnnotationsParser.setPropertyValueForField(
+                  field, listMembers, foundInstance);
+            }
+          }
         }
       }
     }
 
-    return foundInstances;
+    return modelsFound;
   }
 }