-/* Copyright (c) 2009, 2010 Nicira Networks
+/* Copyright (c) 2009, 2010, 2011 Nicira, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
struct ovsdb_table_schema *
ovsdb_table_schema_create(const char *name, bool mutable,
- unsigned int max_rows)
+ unsigned int max_rows, bool is_root)
{
struct ovsdb_column *uuid, *version;
struct ovsdb_table_schema *ts;
ts->mutable = mutable;
shash_init(&ts->columns);
ts->max_rows = max_rows;
+ ts->is_root = is_root;
uuid = ovsdb_column_create("_uuid", false, true, &ovsdb_type_uuid);
add_column(ts, uuid);
add_column(ts, version);
assert(version->index == OVSDB_COL_VERSION);
+ ts->n_indexes = 0;
+ ts->indexes = NULL;
+
return ts;
}
{
struct ovsdb_table_schema *new;
struct shash_node *node;
+ size_t i;
- new = ovsdb_table_schema_create(old->name, old->mutable, old->max_rows);
+ new = ovsdb_table_schema_create(old->name, old->mutable,
+ old->max_rows, old->is_root);
SHASH_FOR_EACH (node, &old->columns) {
const struct ovsdb_column *column = node->data;
add_column(new, ovsdb_column_clone(column));
}
+
+ new->n_indexes = old->n_indexes;
+ new->indexes = xmalloc(new->n_indexes * sizeof *new->indexes);
+ for (i = 0; i < new->n_indexes; i++) {
+ const struct ovsdb_column_set *old_index = &old->indexes[i];
+ struct ovsdb_column_set *new_index = &new->indexes[i];
+ size_t j;
+
+ ovsdb_column_set_init(new_index);
+ for (j = 0; j < old_index->n_columns; j++) {
+ const struct ovsdb_column *old_column = old_index->columns[j];
+ const struct ovsdb_column *new_column;
+
+ new_column = ovsdb_table_schema_get_column(new, old_column->name);
+ ovsdb_column_set_add(new_index, new_column);
+ }
+ }
+
return new;
}
ovsdb_table_schema_destroy(struct ovsdb_table_schema *ts)
{
struct shash_node *node;
+ size_t i;
+
+ for (i = 0; i < ts->n_indexes; i++) {
+ ovsdb_column_set_destroy(&ts->indexes[i]);
+ }
+ free(ts->indexes);
SHASH_FOR_EACH (node, &ts->columns) {
ovsdb_column_destroy(node->data);
struct ovsdb_table_schema **tsp)
{
struct ovsdb_table_schema *ts;
- const struct json *columns, *mutable, *max_rows;
+ const struct json *columns, *mutable, *max_rows, *is_root, *indexes;
struct shash_node *node;
struct ovsdb_parser parser;
struct ovsdb_error *error;
OP_TRUE | OP_FALSE | OP_OPTIONAL);
max_rows = ovsdb_parser_member(&parser, "maxRows",
OP_INTEGER | OP_OPTIONAL);
+ is_root = ovsdb_parser_member(&parser, "isRoot", OP_BOOLEAN | OP_OPTIONAL);
+ indexes = ovsdb_parser_member(&parser, "indexes", OP_ARRAY | OP_OPTIONAL);
error = ovsdb_parser_finish(&parser);
if (error) {
return error;
ts = ovsdb_table_schema_create(name,
mutable ? json_boolean(mutable) : true,
- MIN(n_max_rows, UINT_MAX));
+ MIN(n_max_rows, UINT_MAX),
+ is_root ? json_boolean(is_root) : false);
SHASH_FOR_EACH (node, json_object(columns)) {
struct ovsdb_column *column;
error = ovsdb_column_from_json(node->data, node->name, &column);
}
if (error) {
- ovsdb_table_schema_destroy(ts);
- return error;
+ goto error;
}
add_column(ts, column);
}
+
+ if (indexes) {
+ size_t i;
+
+ ts->indexes = xmalloc(indexes->u.array.n * sizeof *ts->indexes);
+ for (i = 0; i < indexes->u.array.n; i++) {
+ struct ovsdb_column_set *index = &ts->indexes[i];
+ size_t j;
+
+ error = ovsdb_column_set_from_json(indexes->u.array.elems[i],
+ ts, index);
+ if (error) {
+ goto error;
+ }
+ if (index->n_columns == 0) {
+ error = ovsdb_syntax_error(json, NULL, "index must have "
+ "at least one column");
+ goto error;
+ }
+ ts->n_indexes++;
+
+ for (j = 0; j < index->n_columns; j++) {
+ const struct ovsdb_column *column = index->columns[j];
+
+ if (!column->persistent) {
+ error = ovsdb_syntax_error(json, NULL, "ephemeral columns "
+ "(such as %s) may not be "
+ "indexed", column->name);
+ goto error;
+ }
+ }
+ }
+ }
+
*tsp = ts;
- return 0;
+ return NULL;
+
+error:
+ ovsdb_table_schema_destroy(ts);
+ return error;
}
+/* Returns table schema 'ts' serialized into JSON.
+ *
+ * The "isRoot" member is included in the JSON only if its value would differ
+ * from 'default_is_root'. Ordinarily 'default_is_root' should be false,
+ * because ordinarily a table would be not be part of the root set if its
+ * "isRoot" member is omitted. However, garbage collection was not orginally
+ * included in OVSDB, so in older schemas that do not include any "isRoot"
+ * members, every table is implicitly part of the root set. To serialize such
+ * a schema in a way that can be read by older OVSDB tools, specify
+ * 'default_is_root' as true. */
struct json *
-ovsdb_table_schema_to_json(const struct ovsdb_table_schema *ts)
+ovsdb_table_schema_to_json(const struct ovsdb_table_schema *ts,
+ bool default_is_root)
{
struct json *json, *columns;
struct shash_node *node;
if (!ts->mutable) {
json_object_put(json, "mutable", json_boolean_create(false));
}
+ if (default_is_root != ts->is_root) {
+ json_object_put(json, "isRoot", json_boolean_create(ts->is_root));
+ }
columns = json_object_create();
json_object_put(json, "maxRows", json_integer_create(ts->max_rows));
}
+ if (ts->n_indexes) {
+ struct json **indexes;
+ size_t i;
+
+ indexes = xmalloc(ts->n_indexes * sizeof *indexes);
+ for (i = 0; i < ts->n_indexes; i++) {
+ indexes[i] = ovsdb_column_set_to_json(&ts->indexes[i]);
+ }
+ json_object_put(json, "indexes",
+ json_array_create(indexes, ts->n_indexes));
+ }
+
return json;
}
ovsdb_table_create(struct ovsdb_table_schema *ts)
{
struct ovsdb_table *table;
+ size_t i;
table = xmalloc(sizeof *table);
table->schema = ts;
table->txn_table = NULL;
+ table->indexes = xmalloc(ts->n_indexes * sizeof *table->indexes);
+ for (i = 0; i < ts->n_indexes; i++) {
+ hmap_init(&table->indexes[i]);
+ }
hmap_init(&table->rows);
return table;
{
if (table) {
struct ovsdb_row *row, *next;
+ size_t i;
HMAP_FOR_EACH_SAFE (row, next, hmap_node, &table->rows) {
ovsdb_row_destroy(row);
}
hmap_destroy(&table->rows);
+ for (i = 0; i < table->schema->n_indexes; i++) {
+ hmap_destroy(&table->indexes[i]);
+ }
+ free(table->indexes);
+
ovsdb_table_schema_destroy(table->schema);
free(table);
}
return NULL;
}
-
-/* This is probably not the function you want. Use ovsdb_txn_row_modify()
- * instead. */
-bool
-ovsdb_table_put_row(struct ovsdb_table *table, struct ovsdb_row *row)
-{
- const struct uuid *uuid = ovsdb_row_get_uuid(row);
- if (!ovsdb_table_get_row(table, uuid)) {
- hmap_insert(&table->rows, &row->hmap_node, uuid_hash(uuid));
- return true;
- } else {
- return false;
- }
-}