src/bongodb.c

   1 /*
   2  * BongoDB, an embedded document-based engine
   3  * Copyright (C) 2015 by Javier Sancho Fernandez <jsf at jsancho dot org>
   4  *
   5  * This program is free software: you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation, either version 3 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include "bongodb.h"
  20
  21 #include <stdlib.h>
  22 #include <string.h>
  23
  24
  25 /* BongoDB Client */
  26
  27 bongo_client_t *
  28 bongo_client_new (void)
  29 {
  30   bongo_client_t *client;
  31
  32   client = malloc (sizeof (bongo_client_t));
  33   client->n_databases = 0;
  34   client->databases = NULL;
  35
  36   return client;
  37 }
  38
  39 bongo_database_node_t *
  40 bongo_database_node_new (bongo_client_t client,
  41                          const char *db_name)
  42 {
  43   bongo_database_node_t *database_node;
  44
  45   if (client == NULL)
  46     return NULL;
  47
  48   database_node = malloc (sizeof (bongo_database_node_t));
  49   database_node->db_name = db_name;
  50   database_node->n_collections = 0;
  51   database_node->collections = NULL;
  52   database_node->next = (struct bongo_database_node_t *) client->databases;
  53
  54   client->databases = (bongo_database_node_t *) database_node;
  55   client->n_databases++;
  56
  57   return database_node;
  58 }
  59
  60 bongo_collection_node_t *
  61 bongo_collection_node_new (bongo_database_node_t *database_node,
  62                            const char *col_name)
  63 {
  64   bongo_collection_node_t *collection_node;
  65
  66   if (database_node == NULL)
  67     return NULL;
  68
  69   collection_node = malloc (sizeof (bongo_collection_node_t));
  70   collection_node->col_name = col_name;
  71   collection_node->next = (struct bongo_collection_node_t *) database_node->collections;
  72
  73   database_node->collections = (bongo_collection_node_t *) collection_node;
  74   database_node->n_collections++;
  75
  76   return collection_node;
  77 }
  78
  79 bongo_database_node_t *
  80 bongo_database_node_search (bongo_client_t *client,
  81                             const char *db_name)
  82 {
  83   bongo_database_node_t *database_node;
  84
  85   if (client == NULL)
  86     return NULL;
  87
  88   database_node = client->databases;
  89   while (database_node != NULL && strcmp (database_node->db_name, db_name) != 0)
  90     database_node = (bongo_database_node_t *) database_node->next;
  91
  92   return database_node;
  93 }
  94
  95 bongo_collection_node_t *
  96 bongo_collection_node_search (bongo_database_node_t *database_node,
  97                               const char *col_name)
  98 {
  99   bongo_collection_node_t *collection_node;
 100
 101   if (database_node == NULL)
 102     return NULL;
 103
 104   collection_node = database_node->collections;
 105   while (collection_node != NULL && strcmp (collection_node->col_name, col_name) != 0)
 106     collection_node = (bongo_collection_node_t *) collection_node->next;
 107
 108   return collection_node;
 109 }
 110
 111 void
 112 bongo_collection_node_destroy (bongo_collection_node_t *collection_node)
 113 {
 114   free (collection_node);
 115 }
 116
 117 void
 118 bongo_database_node_destroy (bongo_database_node_t *database_node)
 119 {
 120   bongo_collection_node_t *collection_node;
 121
 122   collection_node = database_node->collections;
 123   while (collection_node != NULL)
 124     {
 125       database_node->collections = (bongo_collection_node_t *) collection_node->next;
 126       collection_node_destroy (collection_node);
 127       collection_node = database_node->collections;
 128     }
 129
 130   free (database_node);
 131 }
 132
 133 void
 134 bongo_client_destroy (bongo_client_t *client)
 135 {
 136   bongo_database_node_t *database_node;
 137
 138   database_node = client->databases;
 139   while (database_node != NULL)
 140     {
 141       client->databases = (bongo_database_node_t *) database_node->next;
 142       database_node_destroy (database_node);
 143       database_node = client->databases;
 144     }
 145
 146   free (client);
 147 }
 148
 149
 150 /* BongoDB Database */
 151
 152 bongo_database_t *
 153 bongo_client_get_database (bongo_client_t *client,
 154                            const char *db_name)
 155 {
 156   bongo_database_node_t *database_node;
 157   bongo_database_t *database;
 158
 159   if (client == NULL)
 160     return NULL;
 161
 162   database_node = bongo_database_node_search(client, db_name);
 163   if (database_node == NULL)
 164     database_node = bongo_database_node_new(client, db_name);
 165
 166   database = malloc(sizeof(bongo_database_t));
 167   database->database_node = database_node;
 168
 169   return database;
 170 }
 171
 172 void
 173 bongo_database_destroy(bongo_database_t *database)
 174 {
 175   free(database);
 176 }
 177
 178
 179 /* BongoDB Collection */
 180
 181 bongo_collection_t *
 182 bongo_client_get_collection(bongo_client_t *client,
 183                             const char *db_name,
 184                             const char *col_name)
 185 {
 186   bongo_database_t *database;
 187   bongo_collection_node_t *collection_node;
 188   bongo_collection_t *collection;
 189
 190   if (client == NULL)
 191     return NULL;
 192
 193   database = bongo_client_get_database(client, db_name);
 194
 195   collection_node = bongo_collection_node_search(database->database_node, col_name);
 196   if (collection_node == NULL)
 197     collection_node = bongo_collection_node_new(database->database_node, col_name);
 198
 199   bongo_database_destroy(database);
 200
 201   collection = malloc(sizeof(bongo_collection_t));
 202   collection->collection_node = collection_node;
 203
 204   return collection;
 205 }
 206
 207 bool
 208 bongo_collection_insert (bongo_collection_t *collection,
 209                          bongo_insert_flags_t flags,
 210                          const char *document,
 211                          const bongo_write_concern_t *write_concern,
 212                          bongo_error_t *error)
 213 {
 214 }
 215
 216 void
 217 bongo_collection_destroy(bongo_collection_t *collection)
 218 {
 219   free(collection);
 220 }