1 /* Copyright (c) 2009, 2010, 2011, 2012 Nicira, Inc.
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:
7 * http://www.apache.org/licenses/LICENSE-2.0
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.
24 #include "ovsdb-error.h"
25 #include "ovsdb-parser.h"
26 #include "ovsdb-types.h"
30 add_column(struct ovsdb_table_schema *ts, struct ovsdb_column *column)
32 ovs_assert(!shash_find(&ts->columns, column->name));
33 column->index = shash_count(&ts->columns);
34 shash_add(&ts->columns, column->name, column);
37 struct ovsdb_table_schema *
38 ovsdb_table_schema_create(const char *name, bool mutable,
39 unsigned int max_rows, bool is_root)
41 struct ovsdb_column *uuid, *version;
42 struct ovsdb_table_schema *ts;
44 ts = xzalloc(sizeof *ts);
45 ts->name = xstrdup(name);
46 ts->mutable = mutable;
47 shash_init(&ts->columns);
48 ts->max_rows = max_rows;
49 ts->is_root = is_root;
51 uuid = ovsdb_column_create("_uuid", false, true, &ovsdb_type_uuid);
53 ovs_assert(uuid->index == OVSDB_COL_UUID);
55 version = ovsdb_column_create("_version", false, false, &ovsdb_type_uuid);
56 add_column(ts, version);
57 ovs_assert(version->index == OVSDB_COL_VERSION);
65 struct ovsdb_table_schema *
66 ovsdb_table_schema_clone(const struct ovsdb_table_schema *old)
68 struct ovsdb_table_schema *new;
69 struct shash_node *node;
72 new = ovsdb_table_schema_create(old->name, old->mutable,
73 old->max_rows, old->is_root);
74 SHASH_FOR_EACH (node, &old->columns) {
75 const struct ovsdb_column *column = node->data;
77 if (column->name[0] == '_') {
78 /* Added automatically by ovsdb_table_schema_create(). */
82 add_column(new, ovsdb_column_clone(column));
85 new->n_indexes = old->n_indexes;
86 new->indexes = xmalloc(new->n_indexes * sizeof *new->indexes);
87 for (i = 0; i < new->n_indexes; i++) {
88 const struct ovsdb_column_set *old_index = &old->indexes[i];
89 struct ovsdb_column_set *new_index = &new->indexes[i];
92 ovsdb_column_set_init(new_index);
93 for (j = 0; j < old_index->n_columns; j++) {
94 const struct ovsdb_column *old_column = old_index->columns[j];
95 const struct ovsdb_column *new_column;
97 new_column = ovsdb_table_schema_get_column(new, old_column->name);
98 ovsdb_column_set_add(new_index, new_column);
106 ovsdb_table_schema_destroy(struct ovsdb_table_schema *ts)
108 struct shash_node *node;
111 for (i = 0; i < ts->n_indexes; i++) {
112 ovsdb_column_set_destroy(&ts->indexes[i]);
116 SHASH_FOR_EACH (node, &ts->columns) {
117 ovsdb_column_destroy(node->data);
119 shash_destroy(&ts->columns);
125 ovsdb_table_schema_from_json(const struct json *json, const char *name,
126 struct ovsdb_table_schema **tsp)
128 struct ovsdb_table_schema *ts;
129 const struct json *columns, *mutable, *max_rows, *is_root, *indexes;
130 struct shash_node *node;
131 struct ovsdb_parser parser;
132 struct ovsdb_error *error;
133 long long int n_max_rows;
137 ovsdb_parser_init(&parser, json, "table schema for table %s", name);
138 columns = ovsdb_parser_member(&parser, "columns", OP_OBJECT);
139 mutable = ovsdb_parser_member(&parser, "mutable",
140 OP_TRUE | OP_FALSE | OP_OPTIONAL);
141 max_rows = ovsdb_parser_member(&parser, "maxRows",
142 OP_INTEGER | OP_OPTIONAL);
143 is_root = ovsdb_parser_member(&parser, "isRoot", OP_BOOLEAN | OP_OPTIONAL);
144 indexes = ovsdb_parser_member(&parser, "indexes", OP_ARRAY | OP_OPTIONAL);
145 error = ovsdb_parser_finish(&parser);
151 if (json_integer(max_rows) <= 0) {
152 return ovsdb_syntax_error(json, NULL,
153 "maxRows must be at least 1");
155 n_max_rows = max_rows->u.integer;
157 n_max_rows = UINT_MAX;
160 if (shash_is_empty(json_object(columns))) {
161 return ovsdb_syntax_error(json, NULL,
162 "table must have at least one column");
165 ts = ovsdb_table_schema_create(name,
166 mutable ? json_boolean(mutable) : true,
167 MIN(n_max_rows, UINT_MAX),
168 is_root ? json_boolean(is_root) : false);
169 SHASH_FOR_EACH (node, json_object(columns)) {
170 struct ovsdb_column *column;
172 if (node->name[0] == '_') {
173 error = ovsdb_syntax_error(json, NULL, "names beginning with "
174 "\"_\" are reserved");
175 } else if (!ovsdb_parser_is_id(node->name)) {
176 error = ovsdb_syntax_error(json, NULL, "name must be a valid id");
178 error = ovsdb_column_from_json(node->data, node->name, &column);
184 add_column(ts, column);
190 ts->indexes = xmalloc(indexes->u.array.n * sizeof *ts->indexes);
191 for (i = 0; i < indexes->u.array.n; i++) {
192 struct ovsdb_column_set *index = &ts->indexes[i];
195 error = ovsdb_column_set_from_json(indexes->u.array.elems[i],
200 if (index->n_columns == 0) {
201 error = ovsdb_syntax_error(json, NULL, "index must have "
202 "at least one column");
207 for (j = 0; j < index->n_columns; j++) {
208 const struct ovsdb_column *column = index->columns[j];
210 if (!column->persistent) {
211 error = ovsdb_syntax_error(json, NULL, "ephemeral columns "
212 "(such as %s) may not be "
213 "indexed", column->name);
224 ovsdb_table_schema_destroy(ts);
228 /* Returns table schema 'ts' serialized into JSON.
230 * The "isRoot" member is included in the JSON only if its value would differ
231 * from 'default_is_root'. Ordinarily 'default_is_root' should be false,
232 * because ordinarily a table would be not be part of the root set if its
233 * "isRoot" member is omitted. However, garbage collection was not originally
234 * included in OVSDB, so in older schemas that do not include any "isRoot"
235 * members, every table is implicitly part of the root set. To serialize such
236 * a schema in a way that can be read by older OVSDB tools, specify
237 * 'default_is_root' as true. */
239 ovsdb_table_schema_to_json(const struct ovsdb_table_schema *ts,
240 bool default_is_root)
242 struct json *json, *columns;
243 struct shash_node *node;
245 json = json_object_create();
247 json_object_put(json, "mutable", json_boolean_create(false));
249 if (default_is_root != ts->is_root) {
250 json_object_put(json, "isRoot", json_boolean_create(ts->is_root));
253 columns = json_object_create();
255 SHASH_FOR_EACH (node, &ts->columns) {
256 const struct ovsdb_column *column = node->data;
257 if (node->name[0] != '_') {
258 json_object_put(columns, column->name,
259 ovsdb_column_to_json(column));
262 json_object_put(json, "columns", columns);
263 if (ts->max_rows != UINT_MAX) {
264 json_object_put(json, "maxRows", json_integer_create(ts->max_rows));
268 struct json **indexes;
271 indexes = xmalloc(ts->n_indexes * sizeof *indexes);
272 for (i = 0; i < ts->n_indexes; i++) {
273 indexes[i] = ovsdb_column_set_to_json(&ts->indexes[i]);
275 json_object_put(json, "indexes",
276 json_array_create(indexes, ts->n_indexes));
282 const struct ovsdb_column *
283 ovsdb_table_schema_get_column(const struct ovsdb_table_schema *ts,
286 return shash_find_data(&ts->columns, name);
290 ovsdb_table_create(struct ovsdb_table_schema *ts)
292 struct ovsdb_table *table;
295 table = xmalloc(sizeof *table);
297 table->txn_table = NULL;
298 table->indexes = xmalloc(ts->n_indexes * sizeof *table->indexes);
299 for (i = 0; i < ts->n_indexes; i++) {
300 hmap_init(&table->indexes[i]);
302 hmap_init(&table->rows);
308 ovsdb_table_destroy(struct ovsdb_table *table)
311 struct ovsdb_row *row, *next;
314 HMAP_FOR_EACH_SAFE (row, next, hmap_node, &table->rows) {
315 ovsdb_row_destroy(row);
317 hmap_destroy(&table->rows);
319 for (i = 0; i < table->schema->n_indexes; i++) {
320 hmap_destroy(&table->indexes[i]);
322 free(table->indexes);
324 ovsdb_table_schema_destroy(table->schema);
329 const struct ovsdb_row *
330 ovsdb_table_get_row(const struct ovsdb_table *table, const struct uuid *uuid)
332 struct ovsdb_row *row;
334 HMAP_FOR_EACH_WITH_HASH (row, hmap_node, uuid_hash(uuid), &table->rows) {
335 if (uuid_equals(ovsdb_row_get_uuid(row), uuid)) {