move logs to a separate directory
[sliver-openvswitch.git] / ovsdb / execution.c
1 /* Copyright (c) 2009, 2010, 2011, 2012 Nicira, Inc.
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 <assert.h>
19 #include <limits.h>
20
21 #include "column.h"
22 #include "condition.h"
23 #include "file.h"
24 #include "json.h"
25 #include "mutation.h"
26 #include "ovsdb-data.h"
27 #include "ovsdb-error.h"
28 #include "ovsdb-parser.h"
29 #include "ovsdb.h"
30 #include "query.h"
31 #include "row.h"
32 #include "server.h"
33 #include "table.h"
34 #include "timeval.h"
35 #include "transaction.h"
36
37 struct ovsdb_execution {
38     struct ovsdb *db;
39     const struct ovsdb_session *session;
40     struct ovsdb_txn *txn;
41     struct ovsdb_symbol_table *symtab;
42     bool durable;
43
44     /* Triggers. */
45     long long int elapsed_msec;
46     long long int timeout_msec;
47 };
48
49 typedef struct ovsdb_error *ovsdb_operation_executor(struct ovsdb_execution *,
50                                                      struct ovsdb_parser *,
51                                                      struct json *result);
52
53 static ovsdb_operation_executor ovsdb_execute_insert;
54 static ovsdb_operation_executor ovsdb_execute_select;
55 static ovsdb_operation_executor ovsdb_execute_update;
56 static ovsdb_operation_executor ovsdb_execute_mutate;
57 static ovsdb_operation_executor ovsdb_execute_delete;
58 static ovsdb_operation_executor ovsdb_execute_wait;
59 static ovsdb_operation_executor ovsdb_execute_commit;
60 static ovsdb_operation_executor ovsdb_execute_abort;
61 static ovsdb_operation_executor ovsdb_execute_comment;
62 static ovsdb_operation_executor ovsdb_execute_assert;
63
64 static ovsdb_operation_executor *
65 lookup_executor(const char *name)
66 {
67     struct ovsdb_operation {
68         const char *name;
69         ovsdb_operation_executor *executor;
70     };
71
72     static const struct ovsdb_operation operations[] = {
73         { "insert", ovsdb_execute_insert },
74         { "select", ovsdb_execute_select },
75         { "update", ovsdb_execute_update },
76         { "mutate", ovsdb_execute_mutate },
77         { "delete", ovsdb_execute_delete },
78         { "wait", ovsdb_execute_wait },
79         { "commit", ovsdb_execute_commit },
80         { "abort", ovsdb_execute_abort },
81         { "comment", ovsdb_execute_comment },
82         { "assert", ovsdb_execute_assert },
83     };
84
85     size_t i;
86
87     for (i = 0; i < ARRAY_SIZE(operations); i++) {
88         const struct ovsdb_operation *c = &operations[i];
89         if (!strcmp(c->name, name)) {
90             return c->executor;
91         }
92     }
93     return NULL;
94 }
95
96 struct json *
97 ovsdb_execute(struct ovsdb *db, const struct ovsdb_session *session,
98               const struct json *params,
99               long long int elapsed_msec, long long int *timeout_msec)
100 {
101     struct ovsdb_execution x;
102     struct ovsdb_error *error;
103     struct json *results;
104     size_t n_operations;
105     size_t i;
106
107     if (params->type != JSON_ARRAY
108         || !params->u.array.n
109         || params->u.array.elems[0]->type != JSON_STRING
110         || strcmp(params->u.array.elems[0]->u.string, db->schema->name)) {
111         if (params->type != JSON_ARRAY) {
112             error = ovsdb_syntax_error(params, NULL, "array expected");
113         } else {
114             error = ovsdb_syntax_error(params, NULL, "database name expected "
115                                        "as first parameter");
116         }
117
118         results = ovsdb_error_to_json(error);
119         ovsdb_error_destroy(error);
120         return results;
121     }
122
123     x.db = db;
124     x.session = session;
125     x.txn = ovsdb_txn_create(db);
126     x.symtab = ovsdb_symbol_table_create();
127     x.durable = false;
128     x.elapsed_msec = elapsed_msec;
129     x.timeout_msec = LLONG_MAX;
130     results = NULL;
131
132     results = json_array_create_empty();
133     n_operations = params->u.array.n - 1;
134     error = NULL;
135     for (i = 1; i <= n_operations; i++) {
136         struct json *operation = params->u.array.elems[i];
137         struct ovsdb_error *parse_error;
138         struct ovsdb_parser parser;
139         struct json *result;
140         const struct json *op;
141
142         /* Parse and execute operation. */
143         ovsdb_parser_init(&parser, operation,
144                           "ovsdb operation %zu of %zu", i, n_operations);
145         op = ovsdb_parser_member(&parser, "op", OP_ID);
146         result = json_object_create();
147         if (op) {
148             const char *op_name = json_string(op);
149             ovsdb_operation_executor *executor = lookup_executor(op_name);
150             if (executor) {
151                 error = executor(&x, &parser, result);
152             } else {
153                 ovsdb_parser_raise_error(&parser, "No operation \"%s\"",
154                                          op_name);
155             }
156         } else {
157             assert(ovsdb_parser_has_error(&parser));
158         }
159
160         /* A parse error overrides any other error.
161          * An error overrides any other result. */
162         parse_error = ovsdb_parser_finish(&parser);
163         if (parse_error) {
164             ovsdb_error_destroy(error);
165             error = parse_error;
166         }
167         if (error) {
168             json_destroy(result);
169             result = ovsdb_error_to_json(error);
170         }
171         if (error && !strcmp(ovsdb_error_get_tag(error), "not supported")
172             && timeout_msec) {
173             ovsdb_txn_abort(x.txn);
174             *timeout_msec = x.timeout_msec;
175
176             json_destroy(result);
177             json_destroy(results);
178             results = NULL;
179             goto exit;
180         }
181
182         /* Add result to array. */
183         json_array_add(results, result);
184         if (error) {
185             break;
186         }
187     }
188
189     if (!error) {
190         error = ovsdb_txn_commit(x.txn, x.durable);
191         if (error) {
192             json_array_add(results, ovsdb_error_to_json(error));
193         }
194     } else {
195         ovsdb_txn_abort(x.txn);
196     }
197
198     while (json_array(results)->n < n_operations) {
199         json_array_add(results, json_null_create());
200     }
201
202 exit:
203     ovsdb_error_destroy(error);
204     ovsdb_symbol_table_destroy(x.symtab);
205
206     return results;
207 }
208
209 static struct ovsdb_error *
210 ovsdb_execute_commit(struct ovsdb_execution *x, struct ovsdb_parser *parser,
211                      struct json *result OVS_UNUSED)
212 {
213     const struct json *durable;
214
215     durable = ovsdb_parser_member(parser, "durable", OP_BOOLEAN);
216     if (durable && json_boolean(durable)) {
217         x->durable = true;
218     }
219     return NULL;
220 }
221
222 static struct ovsdb_error *
223 ovsdb_execute_abort(struct ovsdb_execution *x OVS_UNUSED,
224                     struct ovsdb_parser *parser OVS_UNUSED,
225                     struct json *result OVS_UNUSED)
226 {
227     return ovsdb_error("aborted", "aborted by request");
228 }
229
230 static struct ovsdb_table *
231 parse_table(struct ovsdb_execution *x,
232             struct ovsdb_parser *parser, const char *member)
233 {
234     struct ovsdb_table *table;
235     const char *table_name;
236     const struct json *json;
237
238     json = ovsdb_parser_member(parser, member, OP_ID);
239     if (!json) {
240         return NULL;
241     }
242     table_name = json_string(json);
243
244     table = shash_find_data(&x->db->tables, table_name);
245     if (!table) {
246         ovsdb_parser_raise_error(parser, "No table named %s.", table_name);
247     }
248     return table;
249 }
250
251 static WARN_UNUSED_RESULT struct ovsdb_error *
252 parse_row(const struct json *json, const struct ovsdb_table *table,
253           struct ovsdb_symbol_table *symtab,
254           struct ovsdb_row **rowp, struct ovsdb_column_set *columns)
255 {
256     struct ovsdb_error *error;
257     struct ovsdb_row *row;
258
259     *rowp = NULL;
260
261     if (!table) {
262         return OVSDB_BUG("null table");
263     }
264     if (!json) {
265         return OVSDB_BUG("null row");
266     }
267
268     row = ovsdb_row_create(table);
269     error = ovsdb_row_from_json(row, json, symtab, columns);
270     if (error) {
271         ovsdb_row_destroy(row);
272         return error;
273     } else {
274         *rowp = row;
275         return NULL;
276     }
277 }
278
279 static struct ovsdb_error *
280 ovsdb_execute_insert(struct ovsdb_execution *x, struct ovsdb_parser *parser,
281                      struct json *result)
282 {
283     struct ovsdb_table *table;
284     struct ovsdb_row *row = NULL;
285     const struct json *uuid_name, *row_json;
286     struct ovsdb_error *error;
287     struct uuid row_uuid;
288
289     table = parse_table(x, parser, "table");
290     uuid_name = ovsdb_parser_member(parser, "uuid-name", OP_ID | OP_OPTIONAL);
291     row_json = ovsdb_parser_member(parser, "row", OP_OBJECT);
292     error = ovsdb_parser_get_error(parser);
293     if (error) {
294         return error;
295     }
296
297     if (uuid_name) {
298         struct ovsdb_symbol *symbol;
299
300         symbol = ovsdb_symbol_table_insert(x->symtab, json_string(uuid_name));
301         if (symbol->created) {
302             return ovsdb_syntax_error(uuid_name, "duplicate uuid-name",
303                                       "This \"uuid-name\" appeared on an "
304                                       "earlier \"insert\" operation.");
305         }
306         row_uuid = symbol->uuid;
307         symbol->created = true;
308     } else {
309         uuid_generate(&row_uuid);
310     }
311
312     if (!error) {
313         error = parse_row(row_json, table, x->symtab, &row, NULL);
314     }
315     if (!error) {
316         /* Check constraints for columns not included in "row", in case the
317          * default values do not satisfy the constraints.  We could check only
318          * the columns that have their default values by supplying an
319          * ovsdb_column_set to parse_row() above, but I suspect that this is
320          * cheaper.  */
321         const struct shash_node *node;
322
323         SHASH_FOR_EACH (node, &table->schema->columns) {
324             const struct ovsdb_column *column = node->data;
325             const struct ovsdb_datum *datum = &row->fields[column->index];
326
327             /* If there are 0 keys or pairs, there's nothing to check.
328              * If there is 1, it might be a default value.
329              * If there are more, it can't be a default value, so the value has
330              * already been checked. */
331             if (datum->n == 1) {
332                 error = ovsdb_datum_check_constraints(datum, &column->type);
333                 if (error) {
334                     ovsdb_row_destroy(row);
335                     break;
336                 }
337             }
338         }
339     }
340     if (!error) {
341         *ovsdb_row_get_uuid_rw(row) = row_uuid;
342         ovsdb_txn_row_insert(x->txn, row);
343         json_object_put(result, "uuid",
344                         ovsdb_datum_to_json(&row->fields[OVSDB_COL_UUID],
345                                             &ovsdb_type_uuid));
346     }
347     return error;
348 }
349
350 static struct ovsdb_error *
351 ovsdb_execute_select(struct ovsdb_execution *x, struct ovsdb_parser *parser,
352                      struct json *result)
353 {
354     struct ovsdb_table *table;
355     const struct json *where, *columns_json, *sort_json;
356     struct ovsdb_condition condition = OVSDB_CONDITION_INITIALIZER;
357     struct ovsdb_column_set columns = OVSDB_COLUMN_SET_INITIALIZER;
358     struct ovsdb_column_set sort = OVSDB_COLUMN_SET_INITIALIZER;
359     struct ovsdb_error *error;
360
361     table = parse_table(x, parser, "table");
362     where = ovsdb_parser_member(parser, "where", OP_ARRAY);
363     columns_json = ovsdb_parser_member(parser, "columns",
364                                        OP_ARRAY | OP_OPTIONAL);
365     sort_json = ovsdb_parser_member(parser, "sort", OP_ARRAY | OP_OPTIONAL);
366
367     error = ovsdb_parser_get_error(parser);
368     if (!error) {
369         error = ovsdb_condition_from_json(table->schema, where, x->symtab,
370                                           &condition);
371     }
372     if (!error) {
373         error = ovsdb_column_set_from_json(columns_json, table->schema,
374                                            &columns);
375     }
376     if (!error) {
377         error = ovsdb_column_set_from_json(sort_json, table->schema, &sort);
378     }
379     if (!error) {
380         struct ovsdb_row_set rows = OVSDB_ROW_SET_INITIALIZER;
381
382         ovsdb_query_distinct(table, &condition, &columns, &rows);
383         ovsdb_row_set_sort(&rows, &sort);
384         json_object_put(result, "rows",
385                         ovsdb_row_set_to_json(&rows, &columns));
386
387         ovsdb_row_set_destroy(&rows);
388     }
389
390     ovsdb_column_set_destroy(&columns);
391     ovsdb_column_set_destroy(&sort);
392     ovsdb_condition_destroy(&condition);
393
394     return error;
395 }
396
397 struct update_row_cbdata {
398     size_t n_matches;
399     struct ovsdb_txn *txn;
400     const struct ovsdb_row *row;
401     const struct ovsdb_column_set *columns;
402 };
403
404 static bool
405 update_row_cb(const struct ovsdb_row *row, void *ur_)
406 {
407     struct update_row_cbdata *ur = ur_;
408
409     ur->n_matches++;
410     if (!ovsdb_row_equal_columns(row, ur->row, ur->columns)) {
411         ovsdb_row_update_columns(ovsdb_txn_row_modify(ur->txn, row),
412                                  ur->row, ur->columns);
413     }
414
415     return true;
416 }
417
418 static struct ovsdb_error *
419 ovsdb_execute_update(struct ovsdb_execution *x, struct ovsdb_parser *parser,
420                      struct json *result)
421 {
422     struct ovsdb_table *table;
423     const struct json *where, *row_json;
424     struct ovsdb_condition condition = OVSDB_CONDITION_INITIALIZER;
425     struct ovsdb_column_set columns = OVSDB_COLUMN_SET_INITIALIZER;
426     struct ovsdb_row *row = NULL;
427     struct update_row_cbdata ur;
428     struct ovsdb_error *error;
429
430     table = parse_table(x, parser, "table");
431     where = ovsdb_parser_member(parser, "where", OP_ARRAY);
432     row_json = ovsdb_parser_member(parser, "row", OP_OBJECT);
433     error = ovsdb_parser_get_error(parser);
434     if (!error) {
435         error = parse_row(row_json, table, x->symtab, &row, &columns);
436     }
437     if (!error) {
438         size_t i;
439
440         for (i = 0; i < columns.n_columns; i++) {
441             const struct ovsdb_column *column = columns.columns[i];
442
443             if (!column->mutable) {
444                 error = ovsdb_syntax_error(parser->json,
445                                            "constraint violation",
446                                            "Cannot update immutable column %s "
447                                            "in table %s.",
448                                            column->name, table->schema->name);
449                 break;
450             }
451         }
452     }
453     if (!error) {
454         error = ovsdb_condition_from_json(table->schema, where, x->symtab,
455                                           &condition);
456     }
457     if (!error) {
458         ur.n_matches = 0;
459         ur.txn = x->txn;
460         ur.row = row;
461         ur.columns = &columns;
462         ovsdb_query(table, &condition, update_row_cb, &ur);
463         json_object_put(result, "count", json_integer_create(ur.n_matches));
464     }
465
466     ovsdb_row_destroy(row);
467     ovsdb_column_set_destroy(&columns);
468     ovsdb_condition_destroy(&condition);
469
470     return error;
471 }
472
473 struct mutate_row_cbdata {
474     size_t n_matches;
475     struct ovsdb_txn *txn;
476     const struct ovsdb_mutation_set *mutations;
477     struct ovsdb_error **error;
478 };
479
480 static bool
481 mutate_row_cb(const struct ovsdb_row *row, void *mr_)
482 {
483     struct mutate_row_cbdata *mr = mr_;
484
485     mr->n_matches++;
486     *mr->error = ovsdb_mutation_set_execute(ovsdb_txn_row_modify(mr->txn, row),
487                                             mr->mutations);
488     return *mr->error == NULL;
489 }
490
491 static struct ovsdb_error *
492 ovsdb_execute_mutate(struct ovsdb_execution *x, struct ovsdb_parser *parser,
493                      struct json *result)
494 {
495     struct ovsdb_table *table;
496     const struct json *where;
497     const struct json *mutations_json;
498     struct ovsdb_condition condition = OVSDB_CONDITION_INITIALIZER;
499     struct ovsdb_mutation_set mutations = OVSDB_MUTATION_SET_INITIALIZER;
500     struct ovsdb_row *row = NULL;
501     struct mutate_row_cbdata mr;
502     struct ovsdb_error *error;
503
504     table = parse_table(x, parser, "table");
505     where = ovsdb_parser_member(parser, "where", OP_ARRAY);
506     mutations_json = ovsdb_parser_member(parser, "mutations", OP_ARRAY);
507     error = ovsdb_parser_get_error(parser);
508     if (!error) {
509         error = ovsdb_mutation_set_from_json(table->schema, mutations_json,
510                                              x->symtab, &mutations);
511     }
512     if (!error) {
513         error = ovsdb_condition_from_json(table->schema, where, x->symtab,
514                                           &condition);
515     }
516     if (!error) {
517         mr.n_matches = 0;
518         mr.txn = x->txn;
519         mr.mutations = &mutations;
520         mr.error = &error;
521         ovsdb_query(table, &condition, mutate_row_cb, &mr);
522         json_object_put(result, "count", json_integer_create(mr.n_matches));
523     }
524
525     ovsdb_row_destroy(row);
526     ovsdb_mutation_set_destroy(&mutations);
527     ovsdb_condition_destroy(&condition);
528
529     return error;
530 }
531
532 struct delete_row_cbdata {
533     size_t n_matches;
534     const struct ovsdb_table *table;
535     struct ovsdb_txn *txn;
536 };
537
538 static bool
539 delete_row_cb(const struct ovsdb_row *row, void *dr_)
540 {
541     struct delete_row_cbdata *dr = dr_;
542
543     dr->n_matches++;
544     ovsdb_txn_row_delete(dr->txn, row);
545
546     return true;
547 }
548
549 static struct ovsdb_error *
550 ovsdb_execute_delete(struct ovsdb_execution *x, struct ovsdb_parser *parser,
551                      struct json *result)
552 {
553     struct ovsdb_table *table;
554     const struct json *where;
555     struct ovsdb_condition condition = OVSDB_CONDITION_INITIALIZER;
556     struct ovsdb_error *error;
557
558     where = ovsdb_parser_member(parser, "where", OP_ARRAY);
559     table = parse_table(x, parser, "table");
560     error = ovsdb_parser_get_error(parser);
561     if (!error) {
562         error = ovsdb_condition_from_json(table->schema, where, x->symtab,
563                                           &condition);
564     }
565     if (!error) {
566         struct delete_row_cbdata dr;
567
568         dr.n_matches = 0;
569         dr.table = table;
570         dr.txn = x->txn;
571         ovsdb_query(table, &condition, delete_row_cb, &dr);
572
573         json_object_put(result, "count", json_integer_create(dr.n_matches));
574     }
575
576     ovsdb_condition_destroy(&condition);
577
578     return error;
579 }
580
581 struct wait_auxdata {
582     struct ovsdb_row_hash *actual;
583     struct ovsdb_row_hash *expected;
584     bool *equal;
585 };
586
587 static bool
588 ovsdb_execute_wait_query_cb(const struct ovsdb_row *row, void *aux_)
589 {
590     struct wait_auxdata *aux = aux_;
591
592     if (ovsdb_row_hash_contains(aux->expected, row)) {
593         ovsdb_row_hash_insert(aux->actual, row);
594         return true;
595     } else {
596         /* The query row isn't in the expected result set, so the actual and
597          * expected results sets definitely differ and we can short-circuit the
598          * rest of the query. */
599         *aux->equal = false;
600         return false;
601     }
602 }
603
604 static struct ovsdb_error *
605 ovsdb_execute_wait(struct ovsdb_execution *x, struct ovsdb_parser *parser,
606                    struct json *result OVS_UNUSED)
607 {
608     struct ovsdb_table *table;
609     const struct json *timeout, *where, *columns_json, *until, *rows;
610     struct ovsdb_condition condition = OVSDB_CONDITION_INITIALIZER;
611     struct ovsdb_column_set columns = OVSDB_COLUMN_SET_INITIALIZER;
612     struct ovsdb_row_hash expected = OVSDB_ROW_HASH_INITIALIZER(expected);
613     struct ovsdb_row_hash actual = OVSDB_ROW_HASH_INITIALIZER(actual);
614     struct ovsdb_error *error;
615     struct wait_auxdata aux;
616     long long int timeout_msec = 0;
617     size_t i;
618
619     timeout = ovsdb_parser_member(parser, "timeout", OP_NUMBER | OP_OPTIONAL);
620     where = ovsdb_parser_member(parser, "where", OP_ARRAY);
621     columns_json = ovsdb_parser_member(parser, "columns",
622                                        OP_ARRAY | OP_OPTIONAL);
623     until = ovsdb_parser_member(parser, "until", OP_STRING);
624     rows = ovsdb_parser_member(parser, "rows", OP_ARRAY);
625     table = parse_table(x, parser, "table");
626     error = ovsdb_parser_get_error(parser);
627     if (!error) {
628         error = ovsdb_condition_from_json(table->schema, where, x->symtab,
629                                           &condition);
630     }
631     if (!error) {
632         error = ovsdb_column_set_from_json(columns_json, table->schema,
633                                            &columns);
634     }
635     if (!error) {
636         if (timeout) {
637             timeout_msec = MIN(LLONG_MAX, json_real(timeout));
638             if (timeout_msec < 0) {
639                 error = ovsdb_syntax_error(timeout, NULL,
640                                            "timeout must be nonnegative");
641             } else if (timeout_msec < x->timeout_msec) {
642                 x->timeout_msec = timeout_msec;
643             }
644         } else {
645             timeout_msec = LLONG_MAX;
646         }
647         if (strcmp(json_string(until), "==")
648             && strcmp(json_string(until), "!=")) {
649             error = ovsdb_syntax_error(until, NULL,
650                                        "\"until\" must be \"==\" or \"!=\"");
651         }
652     }
653     if (!error) {
654         /* Parse "rows" into 'expected'. */
655         ovsdb_row_hash_init(&expected, &columns);
656         for (i = 0; i < rows->u.array.n; i++) {
657             struct ovsdb_row *row;
658
659             row = ovsdb_row_create(table);
660             error = ovsdb_row_from_json(row, rows->u.array.elems[i], x->symtab,
661                                         NULL);
662             if (error) {
663                 break;
664             }
665
666             if (!ovsdb_row_hash_insert(&expected, row)) {
667                 /* XXX Perhaps we should abort with an error or log a
668                  * warning. */
669                 ovsdb_row_destroy(row);
670             }
671         }
672     }
673     if (!error) {
674         /* Execute query. */
675         bool equal = true;
676         ovsdb_row_hash_init(&actual, &columns);
677         aux.actual = &actual;
678         aux.expected = &expected;
679         aux.equal = &equal;
680         ovsdb_query(table, &condition, ovsdb_execute_wait_query_cb, &aux);
681         if (equal) {
682             /* We know that every row in 'actual' is also in 'expected'.  We
683              * also know that all of the rows in 'actual' are distinct and that
684              * all of the rows in 'expected' are distinct.  Therefore, if
685              * 'actual' and 'expected' have the same number of rows, then they
686              * have the same content. */
687             size_t n_actual = ovsdb_row_hash_count(&actual);
688             size_t n_expected = ovsdb_row_hash_count(&expected);
689             equal = n_actual == n_expected;
690         }
691         if (!strcmp(json_string(until), "==") != equal) {
692             if (timeout && x->elapsed_msec >= timeout_msec) {
693                 if (x->elapsed_msec) {
694                     error = ovsdb_error("timed out",
695                                         "\"wait\" timed out after %lld ms",
696                                         x->elapsed_msec);
697                 } else {
698                     error = ovsdb_error("timed out", "\"wait\" timed out");
699                 }
700             } else {
701                 /* ovsdb_execute() will change this, if triggers really are
702                  * supported. */
703                 error = ovsdb_error("not supported", "triggers not supported");
704             }
705         }
706     }
707
708
709     ovsdb_row_hash_destroy(&expected, true);
710     ovsdb_row_hash_destroy(&actual, false);
711     ovsdb_column_set_destroy(&columns);
712     ovsdb_condition_destroy(&condition);
713
714     return error;
715 }
716
717 static struct ovsdb_error *
718 ovsdb_execute_comment(struct ovsdb_execution *x, struct ovsdb_parser *parser,
719                       struct json *result OVS_UNUSED)
720 {
721     const struct json *comment;
722
723     comment = ovsdb_parser_member(parser, "comment", OP_STRING);
724     if (!comment) {
725         return NULL;
726     }
727     ovsdb_txn_add_comment(x->txn, json_string(comment));
728
729     return NULL;
730 }
731
732 static struct ovsdb_error *
733 ovsdb_execute_assert(struct ovsdb_execution *x, struct ovsdb_parser *parser,
734                      struct json *result OVS_UNUSED)
735 {
736     const struct json *lock_name;
737
738     lock_name = ovsdb_parser_member(parser, "lock", OP_ID);
739     if (!lock_name) {
740         return NULL;
741     }
742
743     if (x->session) {
744         const struct ovsdb_lock_waiter *waiter;
745
746         waiter = ovsdb_session_get_lock_waiter(x->session,
747                                                json_string(lock_name));
748         if (waiter && ovsdb_lock_waiter_is_owner(waiter)) {
749             return NULL;
750         }
751     }
752
753     return ovsdb_error("not owner", "Asserted lock %s not held.",
754                        json_string(lock_name));
755 }