1 ===================================================
2 Open vSwitch Configuration Database Specification
3 ===================================================
8 The descriptions below use the following shorthand notations for JSON
9 values. Additional notation is presented later.
13 A JSON string. Any Unicode string is allowed, as specified by RFC
14 4627. Implementations may disallow null bytes.
18 A JSON string matching [a-zA-Z_][a-zA-Z0-9_]*.
20 <id>s that begin with _ are reserved to the implementation and may
21 not be used by the user.
25 A JSON true or false value.
33 A JSON number with an integer value, within a certain range
34 (currently -2**63...+2**63-1).
42 Any JSON value except null.
46 A JSON object with the following members:
48 "error": <string> required
49 "details": <string> optional
51 The value of the "error" member is a short string, specified in
52 this document, that broadly indicates the class of the error.
53 Most "error" strings are specific to contexts described elsewhere
54 in this document, but the following "error" strings may appear in
55 any context where an <error> is permitted:
57 "error": "resources exhausted"
59 The operation requires more resources (memory, disk, CPU,
60 etc.) than are currently available to the database server.
64 Problems accessing the disk, network, or other required
65 resources prevented the operation from completing.
67 Database implementations may use "error" strings not specified
68 in this document to indicate errors that do not fit into any of
69 the specified categories.
71 Optionally, an <error> may include a "details" member, whose value
72 is a string that describes the error in more detail for the
73 benefit of a human user or administrator. This document does not
74 specify the format or content of the "details" string.
76 An <error> may also have other members that describe the error in
77 more detail. This document does not specify the names or values
83 An Open vSwitch configuration database consists of a set of tables,
84 each of which has a number of columns and zero or more rows. A schema
85 is represented by <database-schema>, as described below.
89 A JSON object with the following members:
92 "tables": {<id>: <table-schema>, ...} required
94 The "name" identifies the database as a whole. It must be
95 provided to most JSON-RPC requests to identify the database being
96 operated on. The value of "tables" is a JSON object whose names
97 are table names and whose values are <table-schema>s.
101 A JSON object with the following members:
103 "columns": {<id>: <column-schema>, ...} required
105 The value of "columns" is a JSON object whose names are column
106 names and whose values are <column-schema>s.
108 Every table has the following columns whose definitions are not
109 included in the schema:
111 "_uuid": This column, which contains exactly one UUID value,
112 is initialized to a random value by the database engine when
113 it creates a row. It is read-only, and its value never
114 changes during the lifetime of a row.
116 "_version": Like "_uuid", this column contains exactly one
117 UUID value, initialized to a random value by the database
118 engine when it creates a row, and it is read-only. However,
119 its value changes to a new random value whenever any other
120 field in the row changes. Furthermore, its value is
121 ephemeral: when the database is closed and reopened, or when
122 the database process is stopped and then started again, each
123 "_version" also changes to a new random value.
127 A JSON object with the following members:
129 "type": <type> required
130 "ephemeral": <boolean> optional
132 The "type" specifies the type of data stored in this column. If
133 "ephemeral" is specified as true, then this column's values are
134 not guaranteed to be durable; they may be lost when the database
139 The type of a database column. Either an <atomic-type> or a JSON
140 object that describes the type of a database column, with the
143 "key": <base-type> required
144 "value": <base-type> optional
145 "min": <integer> optional
146 "max": <integer> or "unlimited" optional
148 If "min" or "max" is not specified, each defaults to 1. If "max"
149 is specified as "unlimited", then there is no specified maximum
150 number of elements, although the implementation will enforce some
151 limit. After considering defaults, "min" must be exactly 0 or
152 exactly 1, "max" must be at least 1, and "max" must be greater
153 than or equal to "min".
155 If "min" and "max" are both 1 and "value" is not specified, the
156 type is the scalar type specified by "key".
158 If "min" is not 1 or "max" is not 1, or both, and "value" is not
159 specified, the type is a set of scalar type "key".
161 If "value" is specified, the type is a map from type "key" to type
166 The type of a key or value in a database column. Either an
167 <atomic-type> or a JSON object with the following members:
169 "type": <atomic-type> required
170 "enum": <value> optional
171 "minInteger": <integer> optional, integers only
172 "maxInteger": <integer> optional, integers only
173 "minReal": <real> optional, reals only
174 "maxReal": <real> optional, reals only
175 "minLength": <integer> optional, strings only
176 "maxLength": <integer> optional, strings only
177 "refTable": <id> optional, uuids only
178 "refType": "strong" or "weak" optional, only with "refTable"
180 An <atomic-type> by itself is equivalent to a JSON object with a
181 single member "type" whose value is the <atomic-type>.
183 "enum" may be specified as a <value> whose type is a set of one
184 or more values specified for the member "type". If "enum" is
185 specified, then the valid values of the <base-type> are limited to
186 those in the <value>.
188 "enum" is mutually exclusive with the following constraints.
190 If "type" is "integer", then "minInteger" or "maxInteger" or both
191 may also be specified, restricting the valid integer range. If
192 both are specified, then the maxInteger must be greater than or
195 If "type" is "real", then "minReal" or "maxReal" or both may also
196 be specified, restricting the valid real range. If both are
197 specified, then the maxReal must be greater than or equal to
200 If "type" is "string", then "minLength" and "maxLength" or both
201 may be specified, restricting the valid length of value strings.
202 If both are specified, then maxLength must be greater than or
203 equal to minLength. String length is measured in characters (not
204 bytes or UTF-16 code units).
206 If "type" is "uuid", then "refTable", if present, must be the name
207 of a table within this database. If "refTable" is specified, then
208 "refType" may also be specified. If "refTable" is set, the effect
209 depends on "refType":
211 - If "refType" is "strong" or if "refType" is omitted, the
212 allowed UUIDs are limited to UUIDs for rows in the named
215 - If "refType" is "weak", then any UUIDs are allowed, but
216 UUIDs that do not correspond to rows in the named table will
217 be automatically deleted.
219 "refTable" constraints are "deferred" constraints: they are
220 enforced only at transaction commit time (see the "transact"
221 request below). The other contraints on <base-type> are
222 "immediate", enforced immediately by each operation.
226 One of the strings "integer", "real", "boolean", "string", or
227 "uuid", representing the specified scalar type.
232 The database wire protocol is implemented in JSON-RPC 1.0. We
233 encourage use of JSON-RPC over stream connections instead of JSON-RPC
234 over HTTP, for these reasons:
236 * JSON-RPC is a peer-to-peer protocol, but HTTP is a client-server
237 protocol, which is a poor match. Thus, JSON-RPC over HTTP
238 requires the client to periodically poll the server to receive
241 * HTTP is more complicated than stream connections and doesn't
242 provide any corresponding advantage.
244 * The JSON-RPC specification for HTTP transport is incomplete.
246 The database wire protocol consists of the following JSON-RPC methods:
251 Request object members:
253 "method": "list_dbs" required
254 "params": [] required
255 "id": <nonnull-json-value> required
257 Response object members:
259 "result": [<db-name>, ...]
261 "id": same "id" as request
263 This operation retrieves an array whose elements are <db-name>s
264 that name the databases that can be accessed over this JSON-RPC
270 Request object members:
272 "method": "get_schema" required
273 "params": [<db-name>] required
274 "id": <nonnull-json-value> required
276 Response object members:
278 "result": <database-schema>
280 "id": same "id" as request
282 This operation retrieves a <database-schema> that describes hosted
288 Request object members:
290 "method": "transact" required
291 "params": [<db-name>, <operation>*] required
292 "id": <nonnull-json-value> required
294 Response object members:
296 "result": [<object>*]
298 "id": same "id" as request
300 The "params" array for this method consists of a <db-name> that
301 identifies the database to which the transaction applies, followed by
302 zero or more JSON objects, each of which represents a single database
303 operation. The "Operations" section below describes the valid
306 The value of "id" must be unique among all in-flight transactions
307 within the current JSON-RPC session. Otherwise, the server may return
310 The database server executes each of the specified operations in the
311 specified order, except that if an operation fails, then the remaining
312 operations are not executed.
314 The set of operations is executed as a single atomic, consistent,
315 isolated transaction. The transaction is committed only if every
316 operation succeeds. Durability of the commit is not guaranteed unless
317 the "commit" operation, with "durable" set to true, is included in the
318 operation set (see below).
320 Regardless of whether errors occur, the response is always a JSON-RPC
321 response with null "error" and a "result" member that is an array with
322 the same number of elements as "params". Each element of the "result"
323 array corresponds to the same element of the "params" array. The
324 "result" array elements may be interpreted as follows:
326 - A JSON object that does not contain an "error" member indicates
327 that the operation completed successfully. The specific members
328 of the object are specified below in the descriptions of
329 individual operations. Some operations do not produce any
330 results, in which case the object will have no members.
332 - An <error>, which indicates that the operation completed with an
335 - A JSON null value indicates that the operation was not attempted
336 because a prior operation failed.
338 In general, "result" contains some number of successful results,
339 possibly followed by an error, in turn followed by enough JSON null
340 values to match the number of elements in "params". There is one
341 exception: if all of the operations succeed, but the results cannot be
342 committed, then "result" will have one more element than "params",
343 with the additional element an <error>. The possible "error" strings
344 include at least the following:
346 "error": "referential integrity violation"
348 When the commit was attempted, a column's value referenced the
349 UUID for a row that did not exist in the table named by the
350 column's <base-type> key or value "refTable" that has a
351 "refType" of "strong". (This can be caused by inserting a row
352 that references a nonexistent row, by deleting a row that is
353 still referenced by another row, by specifying the UUID for a
354 row in the wrong table, and other ways.)
356 "error": "constraint violation"
358 A column with a <base-type> key or value "refTable" whose
359 "refType" is "weak" became empty due to deletion(s) caused
360 because the rows that it referenced were deleted (or never
361 existed, if the column's row was inserted within the
362 transaction), and this column is not allowed to be empty
363 because its <type> has a "min" of 1.
365 If "params" contains one or more "wait" operations, then the
366 transaction may take an arbitrary amount of time to complete. The
367 database implementation must be capable of accepting, executing, and
368 replying to other transactions and other JSON-RPC requests while a
369 transaction or transactions containing "wait" operations are
370 outstanding on the same or different JSON-RPC sessions.
372 The section "Notation for the Wire Protocol" below describes
373 additional notation for use with the wire protocol. After that, the
374 "Operations" section describes each operation.
379 Request object members:
381 "method": "cancel" required
382 "params": [the "id" for an outstanding request] required
385 Response object members:
389 This JSON-RPC notification instructs the database server to
390 immediately complete or cancel the "transact" request whose "id" is
391 the same as the notification's "params" value.
393 If the "transact" request can be completed immediately, then the
394 server sends a response in the form described for "transact", above.
395 Otherwise, the server sends a JSON-RPC error response of the following
400 "id": the request "id" member
402 The "cancel" notification itself has no reply.
407 Request object members:
409 "method": "monitor" required
410 "params": [<db-name>, <json-value>, <monitor-requests>] required
411 "id": <nonnull-json-value> required
413 <monitor-requests> is an object that maps from a table name to a
416 Each <monitor-request> is an object with the following members:
418 "columns": [<column>*] optional
419 "select": <monitor-select> optional
421 <monitor-select> is an object with the following members:
423 "initial": <boolean> optional
424 "insert": <boolean> optional
425 "delete": <boolean> optional
426 "modify": <boolean> optional
428 Response object members:
430 "result": <table-updates>
432 "id": same "id" as request
434 This JSON-RPC request enables a client to replicate tables or subsets
435 of tables within database <db-name>. Each <monitor-request> specifies
436 a table to be replicated. The JSON-RPC response to the "monitor"
437 includes the initial contents of each table. Afterward, when changes
438 to those tables are committed, the changes are automatically sent to
439 the client using the "update" monitor notification. This monitoring
440 persists until the JSON-RPC session terminates or until the client
441 sends a "monitor_cancel" JSON-RPC request.
443 Each <monitor-request> describes how to monitor a table:
445 The circumstances in which an "update" notification is sent for a
446 row within the table are determined by <monitor-select>:
448 If "initial" is omitted or true, every row in the table is
449 sent as part of the reply to the "monitor" request.
451 If "insert" is omitted or true, "update" notifications are
452 sent for rows newly inserted into the table.
454 If "delete" is omitted or true, "update" notifications are
455 sent for rows deleted from the table.
457 If "modify" is omitted or true, "update" notifications are
458 sent whenever when a row in the table is modified.
460 The "columns" member specifies the columns whose values are
461 monitored. If "columns" is omitted, all columns in the table,
462 except for "_uuid", are monitored.
464 The "result" in the JSON-RPC response to the "monitor" request is a
465 <table-updates> object (see below) that contains the contents of the
466 tables for which "initial" rows are selected. If no tables' initial
467 contents are requested, then "result" is an empty object.
472 Notification object members:
475 "params": [<json-value>, <table-updates>]
478 The <json-value> in "params" is the same as the value passed as the
479 <json-value> in "params" for the "monitor" request.
481 <table-updates> is an object that maps from a table name to a
484 A <table-update> is an object that maps from the row's UUID (as a
485 36-byte string) to a <row-update> object.
487 A <row-update> is an object with the following members:
489 "old": <row> present for "delete" and "modify" updates
490 "new": <row> present for "initial", "insert", and "modify" updates
492 This JSON-RPC notification is sent from the server to the client to
493 tell it about changes to a monitored table (or the initial state of a
494 modified table). Each table in which one or more rows has changed (or
495 whose initial view is being presented) is represented in "updates".
496 Each row that has changed (or whose initial view is being presented)
497 is represented in its <table-update> as a member with its name taken
498 from the row's _uuid member. The corresponding value is a
501 The "old" member is present for "delete" and "modify" updates.
502 For "delete" updates, each monitored column is included. For
503 "modify" updates, the prior value of each monitored column whose
504 value has changed is included (monitored columns that have not
505 changed are represented in "new").
507 The "new" member is present for "initial", "insert", and "modify"
508 updates. For "initial" and "insert" updates, each monitored
509 column is included. For "modify" updates, the new value of each
510 monitored column is included.
515 Request object members:
517 "method": "monitor_cancel" required
518 "params": [<json-value>] required
519 "id": <nonnull-json-value> required
521 Response object members:
525 "id": the request "id" member
527 Cancels the ongoing table monitor request, identified by the
528 <json-value> in "params" matching the <json-value> in "params" for an
529 ongoing "monitor" request. No more "update" messages will be sent for
535 Request object members:
537 "method": "echo" required
538 "params": JSON array with any contents required
539 "id": <json-value> required
541 Response object members:
543 "result": same as "params"
545 "id": the request "id" member
547 Both the JSON-RPC client and the server must implement this request.
549 This JSON-RPC request and response can be used to implement connection
550 keepalives, by allowing the server to check that the client is still
554 Notation for the Wire Protocol
555 ------------------------------
559 An <id> that names a database. The valid <db-name>s can be
560 obtained using a "list-db" request. The <db-name> is taken from
561 the "name" member of <database-schema>.
565 An <id> that names a table.
569 An <id> that names a table column.
573 A JSON object that describes a table row or a subset of a table
574 row. Each member is the name of a table column paired with the
575 <value> of that column.
579 A JSON value that represents the value of a column in a table row,
580 one of <atom>, a <set>, or a <map>.
584 A JSON value that represents a scalar value for a column, one of
585 <string>, <number>, <boolean>, <uuid>, <named-uuid>.
589 Either an <atom>, representing a set with exactly one element, or
590 a 2-element JSON array that represents a database set value. The
591 first element of the array must be the string "set" and the second
592 element must be an array of zero or more <atom>s giving the values
593 in the set. All of the <atom>s must have the same type.
597 A 2-element JSON array that represents a database map value. The
598 first element of the array must be the string "map" and the second
599 element must be an array of zero or more <pair>s giving the values
600 in the map. All of the <pair>s must have the same key and value
603 (JSON objects are not used to represent <map> because JSON only
604 allows string names in an object.)
608 A 2-element JSON array that represents a pair within a database
609 map. The first element is an <atom> that represents the key, the
610 second element is an <atom> that represents the value.
614 A 2-element JSON array that represents a UUID. The first element
615 of the array must be the string "uuid" and the second element must
616 be a 36-character string giving the UUID in the format described
617 by RFC 4122. For example, the following <uuid> represents the
618 UUID 550e8400-e29b-41d4-a716-446655440000:
620 ["uuid", "550e8400-e29b-41d4-a716-446655440000"]
624 A 2-element JSON array that represents the UUID of a row inserted
625 in an "insert" operation within the same transaction. The first
626 element of the array must be the string "named-uuid" and the
627 second element should be the string specified as the "uuid-name"
628 for an "insert" operation within the same transaction. For
629 example, if an "insert" operation within this transaction
630 specifies a "uuid-name" of "myrow", the following <named-uuid>
631 represents the UUID created by that operation:
633 ["named-uuid", "myrow"]
635 A <named-uuid> may be used anywhere a <uuid> is valid.
639 A 3-element JSON array of the form [<column>, <function>,
640 <value>] that represents a test on a column value.
642 Except as otherwise specified below, <value> must have the same
645 The meaning depends on the type of <column>:
650 <function> must be "<", "<=", "==", "!=", ">=", ">",
651 "includes", or "excludes".
653 The test is true if the column's value satisfies the
654 relation <function> <value>, e.g. if the column has value
655 1 and <value> is 2, the test is true if <function> is "<",
656 "<=" or "!=", but not otherwise.
658 "includes" is equivalent to "=="; "excludes" is equivalent
665 <function> must be "!=", "==", "includes", or "excludes".
667 If <function> is "==" or "includes", the test is true if
668 the column's value equals <value>. If <function> is "!="
669 or "excludes", the test is inverted.
674 <function> must be "!=", "==", "includes", or "excludes".
676 If <function> is "==", the test is true if the column's
677 value contains exactly the same values (for sets) or pairs
678 (for maps). If <function> is "!=", the test is inverted.
680 If <function> is "includes", the test is true if the
681 column's value contains all of the values (for sets) or
682 pairs (for maps) in <value>. The column's value may also
683 contain other values or pairs.
685 If <function> is "excludes", the test is true if the
686 column's value does not contain any of the values (for
687 sets) or pairs (for maps) in <value>. The column's value
688 may contain other values or pairs not in <value>.
690 If <function> is "includes" or "excludes", then the
691 required type of <value> is slightly relaxed, in that it
692 may have fewer than the minimum number of elements
693 specified by the column's type. If <function> is
694 "excludes", then the required type is additionally relaxed
695 in that <value> may have more than the maximum number of
696 elements specified by the column's type.
700 One of "<", "<=", "==", "!=", ">=", ">", "includes", "excludes".
704 A 3-element JSON array of the form [<column>, <mutator>, <value>]
705 that represents a change to a column value.
707 Except as otherwise specified below, <value> must have the same
710 The meaning depends on the type of <column>:
715 <mutator> must be "+=", "-=", "*=", "/=" or (integer only)
716 "%=". The value of <column> is changed to the sum,
717 difference, product, quotient, or remainder, respectively,
718 of <column> and <value>.
720 Constraints on <column> are ignored when parsing <value>.
726 No valid <mutator>s are currently defined for these types.
730 Any <mutator> valid for the set's element type may be
731 applied to the set, in which case the mutation is applied
732 to each member of the set individually. <value> must be a
733 scalar value of the same type as the set's element type,
734 except that contraints are ignored.
736 If <mutator> is "insert", then each of the values in the
737 set in <value> is added to <column> if it is not already
738 present. The required type of <value> is slightly
739 relaxed, in that it may have fewer than the minimum number
740 of elements specified by the column's type.
742 If <mutator> is "delete", then each of the values in the
743 set in <value> is removed from <column> if it is present
744 there. The required type is slightly relaxed in that
745 <value> may have more or less than the maximum number of
746 elements specified by the column's type.
750 <mutator> must be "insert" or "delete".
752 If <mutator> is "insert", then each of the key-value pairs
753 in the map in <value> is added to <column> only if its key
754 is not already present. The required type of <value> is
755 slightly relaxed, in that it may have fewer than the
756 minimum number of elements specified by the column's type.
758 If <mutator> is "delete", then <value> may have the same
759 type as <column> (a map type) or it may be a set whose
760 element type is the same as <column>'s key type:
762 - If <value> is a map, the mutation deletes each
763 key-value pair in <column> whose key and value equal
764 one of the key-value pairs in <value>.
766 - If <value> is a set, the mutation deletes each
767 key-value pair in <column> whose key equals one of
768 the values in <value>.
770 For "delete", <value> may have any number of elements,
771 regardless of restrictions on the number of elements in
776 One of "+=", "-=", "*=", "/=", "%=", "insert", "delete".
781 Each of the available operations is described below.
786 Request object members:
788 "op": "insert" required
789 "table": <table> required
790 "row": <row> required
791 "uuid-name": <id> optional
793 Result object members:
799 Inserts "row" into "table".
801 If "row" does not specify values for all the columns in "table",
802 those columns receive default values. The default value for a
803 column depends on its type. The default for a column whose <type>
804 specifies a "min" of 0 is an empty set or empty map. Otherwise,
805 the default is a single value or a single key-value pair, whose
806 value(s) depend on its <atomic-type>:
808 - "integer" or "real": 0
812 - "string": "" (the empty string)
814 - "uuid": 00000000-0000-0000-0000-000000000000
816 The new row receives a new, randomly generated UUID.
818 If "uuid-name" is supplied, then it is an error if <id> is not
819 unique among the "uuid-name"s supplied on all the "insert"
820 operations within this transaction.
822 The UUID for the new row is returned as the "uuid" member of the
827 "error": "duplicate uuid-name"
829 The same "uuid-name" appears on another "insert" operation
830 within this transaction.
832 "error": "constraint violation"
834 One of the values in "row" does not satisfy the immediate
835 constraints for its column's <base-type>. This error will
836 occur for columns that are not explicitly set by "row" if the
837 default value does not satisfy the column's constraints.
842 Request object members:
844 "op": "select" required
845 "table": <table> required
846 "where": [<condition>*] required
847 "columns": [<column>*] optional
849 Result object members:
855 Searches "table" for rows that match all the conditions specified
856 in "where". If "where" is an empty array, every row in "table" is
859 The "rows" member of the result is an array of objects. Each
860 object corresponds to a matching row, with each column
861 specified in "columns" as a member, the column's name as the
862 member name and its value as the member value. If "columns"
863 is not specified, all the table's columns are included. If
864 two rows of the result have the same values for all included
865 columns, only one copy of that row is included in "rows".
866 Specifying "_uuid" within "columns" will avoid dropping
867 duplicates, since every row has a unique UUID.
869 The ordering of rows within "rows" is unspecified.
874 Request object members:
876 "op": "update" required
877 "table": <table> required
878 "where": [<condition>*] required
879 "row": <row> required
881 Result object members:
887 Updates rows in a table.
889 Searches "table" for rows that match all the conditions
890 specified in "where". For each matching row, changes the
891 value of each column specified in "row" to the value for that
892 column specified in "row".
894 The "_uuid" and "_version" columns of a table may not be directly
895 updated with this operation. Columns designated read-only in the
896 schema also may not be updated.
898 The "count" member of the result specifies the number of rows
903 "error": "constraint violation"
905 One of the values in "row" does not satisfy the immediate
906 constraints for its column's <base-type>.
910 Request object members:
912 "op": "mutate" required
913 "table": <table> required
914 "where": [<condition>*] required
915 "mutations": [<mutation>*] required
917 Result object members:
923 Mutates rows in a table.
925 Searches "table" for rows that match all the conditions specified
926 in "where". For each matching row, mutates its columns as
927 specified by each <mutation> in "mutations", in the order
930 The "_uuid" and "_version" columns of a table may not be directly
931 modified with this operation. Columns designated read-only in the
932 schema also may not be updated.
934 The "count" member of the result specifies the number of rows
939 "error": "domain error"
941 The result of the mutation is not mathematically defined,
942 e.g. division by zero.
944 "error": "range error"
946 The result of the mutation is not representable within the
947 database's format, e.g. an integer result outside the range
948 INT64_MIN...INT64_MAX or a real result outside the range
951 "error": "constraint violation"
953 The mutation caused the column's value to violate a
954 constraint, e.g. it caused a column to have more or fewer
955 values than are allowed, an arithmetic operation caused a set
956 or map to have duplicate elements, or it violated a constraint
957 specified by a column's <base-type>.
962 Request object members:
964 "op": "delete" required
965 "table": <table> required
966 "where": [<condition>*] required
968 Result object members:
974 Deletes all the rows from "table" that match all the conditions
975 specified in "where".
977 The "count" member of the result specifies the number of deleted
983 Request object members:
985 "op": "wait" required
986 "timeout": <integer> optional
987 "table": <table> required
988 "where": [<condition>*] required
989 "columns": [<column>*] required
990 "until": "==" or "!=" required
991 "rows": [<row>*] required
993 Result object members:
999 Waits until a condition becomes true.
1001 If "until" is "==", checks whether the query on "table" specified
1002 by "where" and "columns", which is evaluated in the same way as
1003 specified for "select", returns the result set specified by
1004 "rows". If it does, then the operation completes successfully.
1005 Otherwise, the entire transaction rolls back. It is automatically
1006 restarted later, after a change in the database makes it possible
1007 for the operation to succeed. The client will not receive a
1008 response until the operation permanently succeeds or fails.
1010 If "until" is "!=", the sense of the test is negated. That is, as
1011 long as the query on "table" specified by "where" and "columns"
1012 returns "rows", the transaction will be rolled back and restarted
1015 If "timeout" is specified, then the transaction aborts after the
1016 specified number of milliseconds. The transaction is guaranteed
1017 to be attempted at least once before it aborts. A "timeout" of 0
1018 will abort the transaction on the first mismatch.
1022 "error": "not supported"
1024 One or more of the columns in this table do not support
1025 triggers. This error will not occur if "timeout" is 0.
1027 "error": "timed out"
1029 The "timeout" was reached before the transaction was able to
1035 Request object members:
1037 "op": "commit" required
1038 "durable": <boolean> required
1040 Result object members:
1046 If "durable" is specified as true, then the transaction, if it
1047 commits, will be stored durably (to disk) before the reply is sent
1052 "error": "not supported"
1054 When "durable" is true, this database implementation does not
1055 support durable commits.
1060 Request object members:
1062 "op": "abort" required
1064 Result object members:
1070 Aborts the transaction with an error. This may be useful for
1077 This operation always fails with this error.
1083 Request object members:
1085 "op": "comment" required
1086 "comment": <string> required
1088 Result object members:
1094 Provides information to a database administrator on the purpose of
1095 a transaction. The OVSDB server, for example, adds comments in
1096 transactions that modify the database to the database journal.