fix: get data as batch

packages/nocodb/src/models/Comment.ts

@@ -44,49 +44,32 @@ export default class Comment implements CommentType {
   public static async listByModel(
     context: NcContext,
     fk_model_id: string,
+    pagination?: { limit: number; offset: number },
     ncMeta = Noco.ncMeta,
   ): Promise<Comment[]> {
-    const READ_BATCH_SIZE = 1000;
+    const comments = await ncMeta.metaList2(
-    const allComments: Comment[] = [];
+      context.workspace_id,
-    let fetchNextBatch = true;
+      context.base_id,
-
+      MetaTable.COMMENTS,
-    for (let offset = 0; fetchNextBatch; offset += READ_BATCH_SIZE) {
+      {
-      const comments = await ncMeta.metaList2(
+        condition: {
-        context.workspace_id,
+          fk_model_id,
-        context.base_id,
+        },
-        MetaTable.COMMENTS,
+        orderBy: {
-        {
+          id: 'asc'
-          condition: {
+        },
-            fk_model_id,
+        limit: pagination?.limit,
-          },
+        offset: pagination?.offset,
-          orderBy: {
+        xcCondition: {
-            created_at: 'asc'
+          _or: [
-          },
+            { is_deleted: { eq: null } },
-          limit: READ_BATCH_SIZE + 1,
+            { is_deleted: { eq: true } },
-          offset,
+          ]
-          xcCondition:
-            {
-              _or: [
-                { is_deleted: { eq: null } },
-                { is_deleted: {
-                  eq: true
-                  } },
-              ]
-            }
-
         }
-      );
+      }
-
+    );
-      const batchComments = comments
-        .slice(0, READ_BATCH_SIZE)
-        .map(comment => new Comment(comment));
-
-      allComments.push(...batchComments);
-
-      fetchNextBatch = comments.length > READ_BATCH_SIZE;
-    }
 
-    return allComments;
+    return comments.map(comment => new Comment(comment));
   }
 
   public static async list(

packages/nocodb/src/modules/jobs/jobs/export-import/export.service.ts

@@ -383,7 +383,21 @@ export class ExportService {
       const serializedComments = [];
 
       if (!excludeComments) {
-        const comments = await Comment.listByModel(context, model.id);
+        const READ_BATCH_SIZE = 100;
+        let comments: Comment[] = [];
+        let offset = 0;
+
+        while (true) {
+          const batchComments = await Comment.listByModel(context, model.id, {
+            limit: READ_BATCH_SIZE + 1,
+            offset
+          });
+
+          comments.push(...batchComments.slice(0, READ_BATCH_SIZE));
+
+          if (batchComments.length <= READ_BATCH_SIZE) break;
+          offset += READ_BATCH_SIZE;
+        }
 
         for (const comment of comments) {
           idMap.set(comment.id, `${idMap.get(model.id)}::${comment.id}`);