ovsdb/row.c

   1 /* Copyright (c) 2009 Nicira Networks
   2  *
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #include <config.h>
  17
  18 #include "row.h"
  19
  20 #include <assert.h>
  21 #include <stddef.h>
  22
  23 #include "json.h"
  24 #include "ovsdb-error.h"
  25 #include "shash.h"
  26 #include "sort.h"
  27 #include "table.h"
  28
  29 static struct ovsdb_row *
  30 allocate_row(const struct ovsdb_table *table)
  31 {
  32     size_t n_fields = shash_count(&table->schema->columns);
  33     size_t row_size = (offsetof(struct ovsdb_row, fields)
  34                        + sizeof(struct ovsdb_datum) * n_fields);
  35     struct ovsdb_row *row = xmalloc(row_size);
  36     row->table = (struct ovsdb_table *) table;
  37     row->txn_row = NULL;
  38     return row;
  39 }
  40
  41 struct ovsdb_row *
  42 ovsdb_row_create(const struct ovsdb_table *table)
  43 {
  44     struct shash_node *node;
  45     struct ovsdb_row *row;
  46
  47     row = allocate_row(table);
  48     SHASH_FOR_EACH (node, &table->schema->columns) {
  49         const struct ovsdb_column *column = node->data;
  50         ovsdb_datum_init_default(&row->fields[column->index], &column->type);
  51     }
  52     return row;
  53 }
  54
  55 struct ovsdb_row *
  56 ovsdb_row_clone(const struct ovsdb_row *old)
  57 {
  58     const struct ovsdb_table *table = old->table;
  59     const struct shash_node *node;
  60     struct ovsdb_row *new;
  61
  62     new = allocate_row(table);
  63     SHASH_FOR_EACH (node, &table->schema->columns) {
  64         const struct ovsdb_column *column = node->data;
  65         ovsdb_datum_clone(&new->fields[column->index],
  66                           &old->fields[column->index],
  67                           &column->type);
  68     }
  69     return new;
  70 }
  71
  72 /* The caller is responsible for ensuring that 'row' has been removed from its
  73  * table and that it is not participating in a transaction. */
  74 void
  75 ovsdb_row_destroy(struct ovsdb_row *row)
  76 {
  77     if (row) {
  78         const struct ovsdb_table *table = row->table;
  79         const struct shash_node *node;
  80
  81         SHASH_FOR_EACH (node, &table->schema->columns) {
  82             const struct ovsdb_column *column = node->data;
  83             ovsdb_datum_destroy(&row->fields[column->index], &column->type);
  84         }
  85         free(row);
  86     }
  87 }
  88
  89 uint32_t
  90 ovsdb_row_hash_columns(const struct ovsdb_row *row,
  91                        const struct ovsdb_column_set *columns,
  92                        uint32_t basis)
  93 {
  94     size_t i;
  95
  96     for (i = 0; i < columns->n_columns; i++) {
  97         const struct ovsdb_column *column = columns->columns[i];
  98         basis = ovsdb_datum_hash(&row->fields[column->index], &column->type,
  99                                  basis);
 100     }
 101
 102     return basis;
 103 }
 104
 105 int
 106 ovsdb_row_compare_columns_3way(const struct ovsdb_row *a,
 107                                const struct ovsdb_row *b,
 108                                const struct ovsdb_column_set *columns)
 109 {
 110     size_t i;
 111
 112     for (i = 0; i < columns->n_columns; i++) {
 113         const struct ovsdb_column *column = columns->columns[i];
 114         int cmp = ovsdb_datum_compare_3way(&a->fields[column->index],
 115                                            &b->fields[column->index],
 116                                            &column->type);
 117         if (cmp) {
 118             return cmp;
 119         }
 120     }
 121
 122     return 0;
 123 }
 124
 125 bool
 126 ovsdb_row_equal_columns(const struct ovsdb_row *a,
 127                         const struct ovsdb_row *b,
 128                         const struct ovsdb_column_set *columns)
 129 {
 130     size_t i;
 131
 132     for (i = 0; i < columns->n_columns; i++) {
 133         const struct ovsdb_column *column = columns->columns[i];
 134         if (!ovsdb_datum_equals(&a->fields[column->index],
 135                                 &b->fields[column->index],
 136                                 &column->type)) {
 137             return false;
 138         }
 139     }
 140
 141     return true;
 142 }
 143
 144 void
 145 ovsdb_row_update_columns(struct ovsdb_row *dst,
 146                          const struct ovsdb_row *src,
 147                          const struct ovsdb_column_set *columns)
 148 {
 149     size_t i;
 150
 151     for (i = 0; i < columns->n_columns; i++) {
 152         const struct ovsdb_column *column = columns->columns[i];
 153         ovsdb_datum_destroy(&dst->fields[column->index], &column->type);
 154         ovsdb_datum_clone(&dst->fields[column->index],
 155                           &src->fields[column->index],
 156                           &column->type);
 157     }
 158 }
 159
 160 struct ovsdb_error *
 161 ovsdb_row_from_json(struct ovsdb_row *row, const struct json *json,
 162                     const struct ovsdb_symbol_table *symtab,
 163                     struct ovsdb_column_set *included)
 164 {
 165     struct ovsdb_table_schema *schema = row->table->schema;
 166     struct ovsdb_error *error;
 167     struct shash_node *node;
 168
 169     if (json->type != JSON_OBJECT) {
 170         return ovsdb_syntax_error(json, NULL, "row must be JSON object");
 171     }
 172
 173     SHASH_FOR_EACH (node, json_object(json)) {
 174         const char *column_name = node->name;
 175         const struct ovsdb_column *column;
 176         struct ovsdb_datum datum;
 177
 178         column = ovsdb_table_schema_get_column(schema, column_name);
 179         if (!column) {
 180             return ovsdb_syntax_error(json, "unknown column",
 181                                       "No column %s in table %s.",
 182                                       column_name, schema->name);
 183         }
 184
 185         error = ovsdb_datum_from_json(&datum, &column->type, node->data,
 186                                       symtab);
 187         if (error) {
 188             return error;
 189         }
 190         ovsdb_datum_swap(&row->fields[column->index], &datum);
 191         ovsdb_datum_destroy(&datum, &column->type);
 192         if (included) {
 193             ovsdb_column_set_add(included, column);
 194         }
 195     }
 196
 197     return NULL;
 198 }
 199
 200 static void
 201 put_json_column(struct json *object, const struct ovsdb_row *row,
 202                 const struct ovsdb_column *column)
 203 {
 204     json_object_put(object, column->name,
 205                     ovsdb_datum_to_json(&row->fields[column->index],
 206                                         &column->type));
 207 }
 208
 209 struct json *
 210 ovsdb_row_to_json(const struct ovsdb_row *row,
 211                   const struct ovsdb_column_set *columns)
 212 {
 213     struct json *json;
 214     size_t i;
 215
 216     json = json_object_create();
 217     for (i = 0; i < columns->n_columns; i++) {
 218         put_json_column(json, row, columns->columns[i]);
 219     }
 220     return json;
 221 }
 222 \f
 223 void
 224 ovsdb_row_set_init(struct ovsdb_row_set *set)
 225 {
 226     set->rows = NULL;
 227     set->n_rows = set->allocated_rows = 0;
 228 }
 229
 230 void
 231 ovsdb_row_set_destroy(struct ovsdb_row_set *set)
 232 {
 233     free(set->rows);
 234 }
 235
 236 void
 237 ovsdb_row_set_add_row(struct ovsdb_row_set *set, const struct ovsdb_row *row)
 238 {
 239     if (set->n_rows >= set->allocated_rows) {
 240         set->rows = x2nrealloc(set->rows, &set->allocated_rows,
 241                                sizeof *set->rows);
 242     }
 243     set->rows[set->n_rows++] = row;
 244 }
 245
 246 struct json *
 247 ovsdb_row_set_to_json(const struct ovsdb_row_set *rows,
 248                       const struct ovsdb_column_set *columns)
 249 {
 250     struct json **json_rows;
 251     size_t i;
 252
 253     json_rows = xmalloc(rows->n_rows * sizeof *json_rows);
 254     for (i = 0; i < rows->n_rows; i++) {
 255         json_rows[i] = ovsdb_row_to_json(rows->rows[i], columns);
 256     }
 257     return json_array_create(json_rows, rows->n_rows);
 258 }
 259
 260 struct ovsdb_row_set_sort_cbdata {
 261     struct ovsdb_row_set *set;
 262     const struct ovsdb_column_set *columns;
 263 };
 264
 265 static int
 266 ovsdb_row_set_sort_compare_cb(size_t a, size_t b, void *cbdata_)
 267 {
 268     struct ovsdb_row_set_sort_cbdata *cbdata = cbdata_;
 269     return ovsdb_row_compare_columns_3way(cbdata->set->rows[a],
 270                                           cbdata->set->rows[b],
 271                                           cbdata->columns);
 272 }
 273
 274 static void
 275 ovsdb_row_set_sort_swap_cb(size_t a, size_t b, void *cbdata_)
 276 {
 277     struct ovsdb_row_set_sort_cbdata *cbdata = cbdata_;
 278     const struct ovsdb_row *tmp = cbdata->set->rows[a];
 279     cbdata->set->rows[a] = cbdata->set->rows[b];
 280     cbdata->set->rows[b] = tmp;
 281 }
 282
 283 void
 284 ovsdb_row_set_sort(struct ovsdb_row_set *set,
 285                    const struct ovsdb_column_set *columns)
 286 {
 287     if (columns && columns->n_columns && set->n_rows > 1) {
 288         struct ovsdb_row_set_sort_cbdata cbdata;
 289         cbdata.set = set;
 290         cbdata.columns = columns;
 291         sort(set->n_rows,
 292              ovsdb_row_set_sort_compare_cb,
 293              ovsdb_row_set_sort_swap_cb,
 294              &cbdata);
 295     }
 296 }
 297 \f
 298 void
 299 ovsdb_row_hash_init(struct ovsdb_row_hash *rh,
 300                     const struct ovsdb_column_set *columns)
 301 {
 302     hmap_init(&rh->rows);
 303     ovsdb_column_set_clone(&rh->columns, columns);
 304 }
 305
 306 void
 307 ovsdb_row_hash_destroy(struct ovsdb_row_hash *rh, bool destroy_rows)
 308 {
 309     struct ovsdb_row_hash_node *node, *next;
 310
 311     HMAP_FOR_EACH_SAFE (node, next, struct ovsdb_row_hash_node, hmap_node,
 312                         &rh->rows) {
 313         hmap_remove(&rh->rows, &node->hmap_node);
 314         if (destroy_rows) {
 315             ovsdb_row_destroy((struct ovsdb_row *) node->row);
 316         }
 317         free(node);
 318     }
 319     hmap_destroy(&rh->rows);
 320     ovsdb_column_set_destroy(&rh->columns);
 321 }
 322
 323 size_t
 324 ovsdb_row_hash_count(const struct ovsdb_row_hash *rh)
 325 {
 326     return hmap_count(&rh->rows);
 327 }
 328
 329 bool
 330 ovsdb_row_hash_contains(const struct ovsdb_row_hash *rh,
 331                         const struct ovsdb_row *row)
 332 {
 333     size_t hash = ovsdb_row_hash_columns(row, &rh->columns, 0);
 334     return ovsdb_row_hash_contains__(rh, row, hash);
 335 }
 336
 337 /* Returns true if every row in 'b' has an equal row in 'a'. */
 338 bool
 339 ovsdb_row_hash_contains_all(const struct ovsdb_row_hash *a,
 340                             const struct ovsdb_row_hash *b)
 341 {
 342     struct ovsdb_row_hash_node *node;
 343
 344     assert(ovsdb_column_set_equals(&a->columns, &b->columns));
 345     HMAP_FOR_EACH (node, struct ovsdb_row_hash_node, hmap_node, &b->rows) {
 346         if (!ovsdb_row_hash_contains__(a, node->row, node->hmap_node.hash)) {
 347             return false;
 348         }
 349     }
 350     return true;
 351 }
 352
 353 bool
 354 ovsdb_row_hash_insert(struct ovsdb_row_hash *rh, const struct ovsdb_row *row)
 355 {
 356     size_t hash = ovsdb_row_hash_columns(row, &rh->columns, 0);
 357     return ovsdb_row_hash_insert__(rh, row, hash);
 358 }
 359
 360 bool
 361 ovsdb_row_hash_contains__(const struct ovsdb_row_hash *rh,
 362                           const struct ovsdb_row *row, size_t hash)
 363 {
 364     struct ovsdb_row_hash_node *node;
 365     HMAP_FOR_EACH_WITH_HASH (node, struct ovsdb_row_hash_node, hmap_node,
 366                              hash, &rh->rows) {
 367         if (ovsdb_row_equal_columns(row, node->row, &rh->columns)) {
 368             return true;
 369         }
 370     }
 371     return false;
 372 }
 373
 374 bool
 375 ovsdb_row_hash_insert__(struct ovsdb_row_hash *rh, const struct ovsdb_row *row,
 376                         size_t hash)
 377 {
 378     if (!ovsdb_row_hash_contains__(rh, row, hash)) {
 379         struct ovsdb_row_hash_node *node = xmalloc(sizeof *node);
 380         node->row = row;
 381         hmap_insert(&rh->rows, &node->hmap_node, hash);
 382         return true;
 383     } else {
 384         return false;
 385     }
 386 }