]>
Commit | Line | Data |
---|---|---|
3df35842 | 1 | /* Copyright (c) 2009, 2010, 2011, 2016 Nicira, Inc. |
f85f8ebb BP |
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 "ovsdb/column.h" | |
19 | ||
20 | #include <stdlib.h> | |
21 | ||
22 | #include "column.h" | |
3e8a2ad1 | 23 | #include "openvswitch/dynamic-string.h" |
ee89ea7b | 24 | #include "openvswitch/json.h" |
f85f8ebb BP |
25 | #include "ovsdb-error.h" |
26 | #include "ovsdb-parser.h" | |
27 | #include "table.h" | |
28 | #include "util.h" | |
29 | ||
30 | struct ovsdb_column * | |
2e57b537 | 31 | ovsdb_column_create(const char *name, |
f85f8ebb BP |
32 | bool mutable, bool persistent, |
33 | const struct ovsdb_type *type) | |
34 | { | |
58985e09 | 35 | /* Doesn't set the new column's 'index': the caller must do that. */ |
6bf4c631 | 36 | struct ovsdb_column *column; |
f85f8ebb | 37 | |
6bf4c631 BP |
38 | column = xzalloc(sizeof *column); |
39 | column->name = xstrdup(name); | |
6bf4c631 BP |
40 | column->mutable = mutable; |
41 | column->persistent = persistent; | |
bd76d25d | 42 | ovsdb_type_clone(&column->type, type); |
f85f8ebb | 43 | |
6bf4c631 | 44 | return column; |
f85f8ebb BP |
45 | } |
46 | ||
58985e09 BP |
47 | struct ovsdb_column * |
48 | ovsdb_column_clone(const struct ovsdb_column *old) | |
49 | { | |
50 | /* Doesn't copy the column's 'index': the caller must do that. */ | |
2e57b537 | 51 | return ovsdb_column_create(old->name, |
58985e09 BP |
52 | old->mutable, old->persistent, |
53 | &old->type); | |
54 | } | |
55 | ||
f85f8ebb BP |
56 | void |
57 | ovsdb_column_destroy(struct ovsdb_column *column) | |
58 | { | |
bd76d25d | 59 | ovsdb_type_destroy(&column->type); |
f85f8ebb | 60 | free(column->name); |
f85f8ebb BP |
61 | free(column); |
62 | } | |
63 | ||
64 | struct ovsdb_error * | |
65 | ovsdb_column_from_json(const struct json *json, const char *name, | |
66 | struct ovsdb_column **columnp) | |
67 | { | |
3df35842 | 68 | const struct json *mutable_json, *ephemeral, *type_json; |
f85f8ebb BP |
69 | struct ovsdb_error *error; |
70 | struct ovsdb_type type; | |
71 | struct ovsdb_parser parser; | |
f85f8ebb BP |
72 | |
73 | *columnp = NULL; | |
74 | ||
75 | ovsdb_parser_init(&parser, json, "schema for column %s", name); | |
3df35842 BP |
76 | mutable_json = ovsdb_parser_member(&parser, "mutable", |
77 | OP_TRUE | OP_FALSE | OP_OPTIONAL); | |
f85f8ebb BP |
78 | ephemeral = ovsdb_parser_member(&parser, "ephemeral", |
79 | OP_TRUE | OP_FALSE | OP_OPTIONAL); | |
80 | type_json = ovsdb_parser_member(&parser, "type", OP_STRING | OP_OBJECT); | |
81 | error = ovsdb_parser_finish(&parser); | |
82 | if (error) { | |
83 | return error; | |
84 | } | |
85 | ||
86 | error = ovsdb_type_from_json(&type, type_json); | |
87 | if (error) { | |
88 | return error; | |
89 | } | |
90 | ||
3df35842 BP |
91 | bool mutable = !mutable_json || json_boolean(mutable_json); |
92 | if (!mutable | |
93 | && (ovsdb_base_type_is_weak_ref(&type.key) || | |
94 | ovsdb_base_type_is_weak_ref(&type.value))) { | |
95 | /* We cannot allow a weak reference to be immutable: if referenced rows | |
96 | * are deleted, then the weak reference needs to change. */ | |
97 | mutable = true; | |
98 | } | |
99 | ||
100 | bool persistent = ephemeral ? !json_boolean(ephemeral) : true; | |
101 | *columnp = ovsdb_column_create(name, mutable, persistent, &type); | |
bd76d25d BP |
102 | |
103 | ovsdb_type_destroy(&type); | |
104 | ||
f85f8ebb BP |
105 | return NULL; |
106 | } | |
107 | ||
108 | struct json * | |
109 | ovsdb_column_to_json(const struct ovsdb_column *column) | |
110 | { | |
111 | struct json *json = json_object_create(); | |
f85f8ebb BP |
112 | if (!column->mutable) { |
113 | json_object_put(json, "mutable", json_boolean_create(false)); | |
114 | } | |
115 | if (!column->persistent) { | |
116 | json_object_put(json, "ephemeral", json_boolean_create(true)); | |
117 | } | |
118 | json_object_put(json, "type", ovsdb_type_to_json(&column->type)); | |
119 | return json; | |
120 | } | |
121 | \f | |
122 | void | |
123 | ovsdb_column_set_init(struct ovsdb_column_set *set) | |
124 | { | |
125 | set->columns = NULL; | |
126 | set->n_columns = set->allocated_columns = 0; | |
127 | } | |
128 | ||
129 | void | |
130 | ovsdb_column_set_destroy(struct ovsdb_column_set *set) | |
131 | { | |
132 | free(set->columns); | |
133 | } | |
134 | ||
135 | void | |
136 | ovsdb_column_set_clone(struct ovsdb_column_set *new, | |
137 | const struct ovsdb_column_set *old) | |
138 | { | |
139 | new->columns = xmemdup(old->columns, | |
140 | old->n_columns * sizeof *old->columns); | |
141 | new->n_columns = new->allocated_columns = old->n_columns; | |
142 | } | |
143 | ||
144 | struct ovsdb_error * | |
145 | ovsdb_column_set_from_json(const struct json *json, | |
1cb29ab0 | 146 | const struct ovsdb_table_schema *schema, |
f85f8ebb BP |
147 | struct ovsdb_column_set *set) |
148 | { | |
149 | ovsdb_column_set_init(set); | |
150 | if (!json) { | |
151 | struct shash_node *node; | |
152 | ||
1cb29ab0 | 153 | SHASH_FOR_EACH (node, &schema->columns) { |
f85f8ebb BP |
154 | const struct ovsdb_column *column = node->data; |
155 | ovsdb_column_set_add(set, column); | |
156 | } | |
157 | ||
158 | return NULL; | |
159 | } else { | |
99b2042d | 160 | struct ovsdb_error *error = NULL; |
f85f8ebb BP |
161 | size_t i; |
162 | ||
163 | if (json->type != JSON_ARRAY) { | |
164 | goto error; | |
165 | } | |
166 | ||
167 | /* XXX this is O(n**2) */ | |
fa37affa | 168 | for (i = 0; i < json->array.n; i++) { |
bd76d25d | 169 | const struct ovsdb_column *column; |
99b2042d | 170 | const char *s; |
f85f8ebb | 171 | |
fa37affa | 172 | if (json->array.elems[i]->type != JSON_STRING) { |
f85f8ebb BP |
173 | goto error; |
174 | } | |
175 | ||
fa37affa | 176 | s = json->array.elems[i]->string; |
1cb29ab0 | 177 | column = shash_find_data(&schema->columns, s); |
99b2042d BP |
178 | if (!column) { |
179 | error = ovsdb_syntax_error(json, NULL, "%s is not a valid " | |
180 | "column name", s); | |
181 | goto error; | |
182 | } else if (ovsdb_column_set_contains(set, column->index)) { | |
f85f8ebb BP |
183 | goto error; |
184 | } | |
185 | ovsdb_column_set_add(set, column); | |
186 | } | |
f85f8ebb | 187 | return NULL; |
f85f8ebb | 188 | |
99b2042d BP |
189 | error: |
190 | ovsdb_column_set_destroy(set); | |
191 | ovsdb_column_set_init(set); | |
192 | if (!error) { | |
193 | error = ovsdb_syntax_error(json, NULL, "array of distinct column " | |
194 | "names expected"); | |
195 | } | |
196 | return error; | |
197 | } | |
f85f8ebb BP |
198 | } |
199 | ||
a8425c53 BP |
200 | struct json * |
201 | ovsdb_column_set_to_json(const struct ovsdb_column_set *set) | |
202 | { | |
203 | struct json *json; | |
204 | size_t i; | |
205 | ||
206 | json = json_array_create_empty(); | |
207 | for (i = 0; i < set->n_columns; i++) { | |
208 | json_array_add(json, json_string_create(set->columns[i]->name)); | |
209 | } | |
210 | return json; | |
211 | } | |
212 | ||
25d49835 BP |
213 | /* Returns an English string listing the contents of 'set', e.g. "columns |
214 | * \"a\", \"b\", and \"c\"". The caller must free the string. */ | |
215 | char * | |
216 | ovsdb_column_set_to_string(const struct ovsdb_column_set *set) | |
217 | { | |
218 | if (!set->n_columns) { | |
219 | return xstrdup("no columns"); | |
220 | } else { | |
221 | struct ds s; | |
222 | size_t i; | |
223 | ||
224 | ds_init(&s); | |
225 | ds_put_format(&s, "column%s ", set->n_columns > 1 ? "s" : ""); | |
226 | for (i = 0; i < set->n_columns; i++) { | |
227 | const char *delimiter = english_list_delimiter(i, set->n_columns); | |
228 | ds_put_format(&s, "%s\"%s\"", delimiter, set->columns[i]->name); | |
229 | } | |
230 | return ds_steal_cstr(&s); | |
231 | } | |
232 | } | |
233 | ||
f85f8ebb BP |
234 | void |
235 | ovsdb_column_set_add(struct ovsdb_column_set *set, | |
236 | const struct ovsdb_column *column) | |
237 | { | |
238 | if (set->n_columns >= set->allocated_columns) { | |
239 | set->columns = x2nrealloc(set->columns, &set->allocated_columns, | |
240 | sizeof *set->columns); | |
241 | } | |
242 | set->columns[set->n_columns++] = column; | |
243 | } | |
244 | ||
245 | void | |
246 | ovsdb_column_set_add_all(struct ovsdb_column_set *set, | |
247 | const struct ovsdb_table *table) | |
248 | { | |
249 | struct shash_node *node; | |
250 | ||
251 | SHASH_FOR_EACH (node, &table->schema->columns) { | |
252 | const struct ovsdb_column *column = node->data; | |
253 | ovsdb_column_set_add(set, column); | |
254 | } | |
255 | } | |
256 | ||
257 | bool | |
258 | ovsdb_column_set_contains(const struct ovsdb_column_set *set, | |
259 | unsigned int column_index) | |
260 | { | |
261 | size_t i; | |
262 | ||
263 | for (i = 0; i < set->n_columns; i++) { | |
264 | if (set->columns[i]->index == column_index) { | |
265 | return true; | |
266 | } | |
267 | } | |
268 | return false; | |
269 | } | |
270 | ||
271 | /* This comparison is sensitive to ordering of columns within a set, but that's | |
272 | * good: the only existing caller wants to make sure that hash values are | |
273 | * comparable, which is only true if column ordering is the same. */ | |
274 | bool | |
275 | ovsdb_column_set_equals(const struct ovsdb_column_set *a, | |
276 | const struct ovsdb_column_set *b) | |
277 | { | |
278 | size_t i; | |
279 | ||
280 | if (a->n_columns != b->n_columns) { | |
281 | return false; | |
282 | } | |
283 | for (i = 0; i < a->n_columns; i++) { | |
284 | if (a->columns[i] != b->columns[i]) { | |
285 | return false; | |
286 | } | |
287 | } | |
288 | return true; | |
289 | } |