Mongodb Driver - written in Zig

Examples:

• Initialize and Connect
• Insert Command
• Replace Document Command
• Update One Command
• Update Many Command - simple
• Update Many Command - chainable
• Document Count Estimate
• Document Count
• Delete Command
• Find Command
• Aggregate Command

Examples

Initialize and Connect

  var conn_str = try ConnectionString.fromText(allocator, "mongodb://127.0.0.1/sandbox");
  defer conn_str.deinit(allocator);

  const server_api = ServerApi{
    .version = .v1,
    .strict = true,
    .deprecationErrors = true,
  };
  var db = try Database.init(allocator, &conn_str, server_api); // server api is optional, can be null
  defer db.deinit();

  try db.connect();

Insert Command

  const doc1 = .{
    .name = "doc1"
  };
  const response = try db.collection(collection_name).insertOne(doc1, .{});
  defer response.deinit(allocator);

Document Count Estimate

  const count_estimate = try db.collection(collection_name).estimatedDocumentCount(.{});

Replace Document Command

  const filter = .{ .name = "obj1-original" };
  const replacement = .{ .name = "obj1-replaced", .value = 42, .replaced = true };
  const response = try collection.replaceOne(filter, replacement, .{});
  defer response.deinit(allocator);

Update One Command

  const filter = .{ .name = "obj1" };
  const update = .{ .name = "obj1-updated", .updated = true };
  const response = try collection.updateOne(filter, update, .{});
  defer response.deinit(allocator);

Update Many Command - simple

  const filter = .{ .status = "pending" };
  const update = .{ .@"$set" = .{ .status = "completed" } };
  const update_response = try collection.updateMany(filter, update, .{ .upsert = true });
  defer update_response.deinit(allocator);

Update Many Command - chainable

  var update_chain = collection.updateChain();
  defer update_chain.deinit();

  const update_chain_result = try update_chain
      .add(.{ .status = .{ .@"$eq" = "pending" } }, .{ .@"$set" = .{ .status = "started" } }, .{ .multi = true })
      .add(.{ .status = .{ .@"$eq" = "in-progress" } }, .{ .@"$set" = .{ .status = "completed" } }, .{ .multi = true })
      .exec(.{ .ordered = true });

Document Count

Document Count - count all

  const count = try db.collection(collection_name).countDocuments(.{});

Document Count - count with filter

  const filter = .{ .name = "doc1" }
  const count = try db.collection(collection_name).countDocuments(filter);

Delete Command

delete one

  const delete_filter = .{ .name = "doc1" };
  const response = try db.collection(collection_name).delete(.one, delete_filter, .{});
  defer allocator.destroy(response);

delete all (by filter)

  const delete_filter = .{ .name = "doc1" };
  const response = try db.collection(collection_name).delete(.all, delete_filter, .{});
  defer allocator.destroy(response);

Find Command

Find Command - find many

  const filter = .{ .name = .{ .@"$ne" = null } };
  var response = try db.collection(collection_name).find(filter, .all, .{
   .batchSize = 2,
   .limit = 6,
  });
  defer response.deinit();

  while (try response.next()) |batch| {
    for (batch) |doc| {
        defer doc.deinit(allocator);
        // do something with doc
    }
  }
  try response.release(); // optionally call to kill cursor, if not used iterator till the end

Find Command - find one

  const filter = .{ .name = .{ .@"$eq" = "doc1" } };
  const response = try db.collection(collection_name).findOne(filter, .{});
  defer if (response) |r| r.deinit(allocator);

Aggregate Command

  var pipeline_builder = PipelineBuilder.init(allocator);
  defer pipeline_builder.deinit();
  const pipeline = pipeline_builder
     .match(.{ .name = .{ .@"$ne" = null } })
     .sort(.{ .name = 1 })
     .group(.{ ._id = "$name", .count = .{ .@"$sum" = 1 } })
     .build() catch |err| {
        std.debug.print("Error building pipeline: {}\n", .{err});
        return;
     };
  var response = try collection.aggregate(pipeline, .{}, .{});
  defer response.release() catch |err| {
    std.debug.print("Error releasing response: {}\n", .{err});
  };

  while (try result.next()) |batch| {
    for (batch) |doc| {
      defer doc.deinit(allocator);
      // do something with doc
    }
  }