Changed memory in AdditionalData

Now it need to use an arena because there is no deinit function.

And additionalData of member are null by default instead of an empty
list.

src/fileEngine.zig

@@ -403,7 +403,7 @@ pub const FileEngine = struct {
 
         // If there is no member to find, that mean we need to return all members, so let's populate additional data with all of them
         if (additional_data.childrens.items.len == 0) {
-            additional_data.populateWithEverythingExceptLink(allocator, sstruct.members, sstruct.types) catch return FileEngineError.MemoryError;
+            additional_data.populateWithEverythingExceptLink(sstruct.members, sstruct.types) catch return FileEngineError.MemoryError;
         }
 
         // Open the dir that contain all files

src/stuffs/additionalData.zig

@@ -3,30 +3,36 @@ const Allocator = std.mem.Allocator;
 const dtype = @import("dtype");
 const DataType = dtype.DataType;
 
+const ZipponError = @import("errors.zig").ZipponError;
+
 /// This is the [] part
-/// TODO: Include the part ".friends.comments" in "GRAB User.firends.comments {age > 10}"
 pub const AdditionalData = struct {
+    allocator: Allocator,
     limit: usize = 0,
     childrens: std.ArrayList(AdditionalDataMember),
 
     pub fn init(allocator: Allocator) AdditionalData {
-        return AdditionalData{ .childrens = std.ArrayList(AdditionalDataMember).init(allocator) };
+        return AdditionalData{
+            .allocator = allocator,
+            .childrens = std.ArrayList(AdditionalDataMember).init(allocator),
+        };
     }
 
-    pub fn deinit(self: *AdditionalData) void {
+    pub fn populateWithEverythingExceptLink(self: *AdditionalData, members: [][]const u8, dtypes: []DataType) !void {
-        for (0..self.childrens.items.len) |i| {
-            self.childrens.items[i].additional_data.deinit();
-        }
-
-        self.childrens.deinit();
-    }
-
-    pub fn populateWithEverythingExceptLink(self: *AdditionalData, allocator: Allocator, members: [][]const u8, dtypes: []DataType) !void {
         for (members, dtypes, 0..) |member, dt, i| {
             if (dt == .link or dt == .link_array) continue;
-            try self.childrens.append(AdditionalDataMember.init(allocator, member, i));
+            try self.childrens.append(AdditionalDataMember.init(member, i));
         }
     }
+
+    pub fn addMember(self: *AdditionalData, name: []const u8, index: usize) ZipponError!void {
+        self.childrens.append(AdditionalDataMember.init(name, index)) catch return ZipponError.MemoryError;
+    }
+
+    pub fn initAdditionalDataOfLastChildren(self: *AdditionalData) *AdditionalData {
+        self.childrens.items[self.childrens.items.len - 1].additional_data = AdditionalData.init(self.allocator);
+        return &self.childrens.items[self.childrens.items.len - 1].additional_data.?;
+    }
 };
 
 // This is name in: [name]
@@ -34,10 +40,9 @@ pub const AdditionalData = struct {
 pub const AdditionalDataMember = struct {
     name: []const u8,
     index: usize, // Index place in the schema
-    additional_data: AdditionalData,
+    additional_data: ?AdditionalData = null,
 
-    pub fn init(allocator: Allocator, name: []const u8, index: usize) AdditionalDataMember {
+    pub fn init(name: []const u8, index: usize) AdditionalDataMember {
-        const additional_data = AdditionalData.init(allocator);
+        return AdditionalDataMember{ .name = name, .index = index };
-        return AdditionalDataMember{ .name = name, .additional_data = additional_data, .index = index };
     }
 };

src/ziqlParser.zig

@@ -45,7 +45,7 @@ const State = enum {
     expect_right_arrow,
 
     // For the additional data parser
-    expect_count_of_entity_to_find,
+    expect_limit,
     expect_semicolon_OR_right_bracket,
     expect_member,
     expect_comma_OR_r_bracket_OR_l_bracket,
@@ -88,7 +88,6 @@ pub const Parser = struct {
 
         var state: State = .start;
         var additional_data = AdditionalData.init(allocator);
-        defer additional_data.deinit();
         var struct_name: []const u8 = undefined;
         var action: enum { GRAB, ADD, UPDATE, DELETE } = undefined;
 
@@ -636,25 +635,24 @@ pub const Parser = struct {
     fn parseAdditionalData(self: Parser, allocator: Allocator, additional_data: *AdditionalData, struct_name: []const u8) ZipponError!void {
         var token = self.toker.next();
         var keep_next = false;
-        var state: State = .expect_count_of_entity_to_find;
+        var state: State = .expect_limit;
 
         while (state != .end) : ({
             token = if ((!keep_next) and (state != .end)) self.toker.next() else token;
             keep_next = false;
             if (PRINT_STATE) std.debug.print("parseAdditionalData: {any}\n", .{state});
         }) switch (state) {
-            .expect_count_of_entity_to_find => switch (token.tag) {
+            .expect_limit => switch (token.tag) {
                 .int_literal => {
-                    const count = std.fmt.parseInt(usize, self.toker.getTokenSlice(token), 10) catch {
+                    additional_data.limit = std.fmt.parseInt(usize, self.toker.getTokenSlice(token), 10) catch {
                         return printError(
-                            "Error while transforming this into a integer.",
+                            "Error while transforming limit into a integer.",
                             ZiQlParserError.ParsingValueError,
                             self.toker.buffer,
                             token.loc.start,
                             token.loc.end,
                         );
                     };
-                    additional_data.limit = count;
                     state = .expect_semicolon_OR_right_bracket;
                 },
                 else => {
@@ -694,13 +692,10 @@ pub const Parser = struct {
                             token.loc.end,
                         );
                     }
-                    additional_data.childrens.append(
+                    try additional_data.addMember(
-                        AdditionalDataMember.init(
+                        self.toker.getTokenSlice(token),
-                            allocator,
+                        try self.schema_engine.memberName2DataIndex(struct_name, self.toker.getTokenSlice(token)),
-                            self.toker.getTokenSlice(token),
+                    );
-                            try self.schema_engine.memberName2DataIndex(struct_name, self.toker.getTokenSlice(token)),
-                        ),
-                    ) catch return ZipponError.MemoryError;
 
                     state = .expect_comma_OR_r_bracket_OR_l_bracket;
                 },
@@ -717,9 +712,11 @@ pub const Parser = struct {
                 .comma => state = .expect_member,
                 .r_bracket => state = .end,
                 .l_bracket => {
+                    // Here now childrens is null, so I need to init it
+
                     try self.parseAdditionalData(
                         allocator,
-                        &additional_data.childrens.items[additional_data.childrens.items.len - 1].additional_data,
+                        additional_data.initAdditionalDataOfLastChildren(),
                         struct_name,
                     );
                     state = .expect_comma_OR_r_bracket;
@@ -954,8 +951,10 @@ pub const Parser = struct {
                 .l_brace, .l_bracket => {
                     var filter: ?Filter = null;
                     defer if (filter != null) filter.?.deinit();
-                    var additional_data = AdditionalData.init(allocator);
+
-                    defer additional_data.deinit();
+                    var additional_data_arena = std.heap.ArenaAllocator.init(allocator);
+                    defer additional_data_arena.deinit();
+                    var additional_data = AdditionalData.init(additional_data_arena.allocator());
 
                     if (token.tag == .l_bracket) {
                         try self.parseAdditionalData(allocator, &additional_data, struct_name);
@@ -1002,8 +1001,10 @@ pub const Parser = struct {
                 .l_brace, .l_bracket => {
                     var filter: ?Filter = null;
                     defer if (filter != null) filter.?.deinit();
-                    var additional_data = AdditionalData.init(allocator);
+
-                    defer additional_data.deinit();
+                    var additional_data_arena = std.heap.ArenaAllocator.init(allocator);
+                    defer additional_data_arena.deinit();
+                    var additional_data = AdditionalData.init(additional_data_arena.allocator());
 
                     if (token.tag == .l_bracket) {
                         try self.parseAdditionalData(allocator, &additional_data, struct_name);