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
104 "maxRows": <integer> optional
106 The value of "columns" is a JSON object whose names are column
107 names and whose values are <column-schema>s.
109 Every table has the following columns whose definitions are not
110 included in the schema:
112 "_uuid": This column, which contains exactly one UUID value,
113 is initialized to a random value by the database engine when
114 it creates a row. It is read-only, and its value never
115 changes during the lifetime of a row.
117 "_version": Like "_uuid", this column contains exactly one
118 UUID value, initialized to a random value by the database
119 engine when it creates a row, and it is read-only. However,
120 its value changes to a new random value whenever any other
121 field in the row changes. Furthermore, its value is
122 ephemeral: when the database is closed and reopened, or when
123 the database process is stopped and then started again, each
124 "_version" also changes to a new random value.
126 If "maxRows" is specified, as a positive integer, it limits the
127 maximum number of rows that may be present in the table. This is
128 a "deferred" constraint, enforced only at transaction commit time
129 (see the "transact" request below). If "maxRows" is not
130 specified, the size of the table is limited only by the resources
131 available to the database server.
135 A JSON object with the following members:
137 "type": <type> required
138 "ephemeral": <boolean> optional
140 The "type" specifies the type of data stored in this column. If
141 "ephemeral" is specified as true, then this column's values are
142 not guaranteed to be durable; they may be lost when the database
147 The type of a database column. Either an <atomic-type> or a JSON
148 object that describes the type of a database column, with the
151 "key": <base-type> required
152 "value": <base-type> optional
153 "min": <integer> optional
154 "max": <integer> or "unlimited" optional
156 If "min" or "max" is not specified, each defaults to 1. If "max"
157 is specified as "unlimited", then there is no specified maximum
158 number of elements, although the implementation will enforce some
159 limit. After considering defaults, "min" must be exactly 0 or
160 exactly 1, "max" must be at least 1, and "max" must be greater
161 than or equal to "min".
163 If "min" and "max" are both 1 and "value" is not specified, the
164 type is the scalar type specified by "key".
166 If "min" is not 1 or "max" is not 1, or both, and "value" is not
167 specified, the type is a set of scalar type "key".
169 If "value" is specified, the type is a map from type "key" to type
174 The type of a key or value in a database column. Either an
175 <atomic-type> or a JSON object with the following members:
177 "type": <atomic-type> required
178 "enum": <value> optional
179 "minInteger": <integer> optional, integers only
180 "maxInteger": <integer> optional, integers only
181 "minReal": <real> optional, reals only
182 "maxReal": <real> optional, reals only
183 "minLength": <integer> optional, strings only
184 "maxLength": <integer> optional, strings only
185 "refTable": <id> optional, uuids only
186 "refType": "strong" or "weak" optional, only with "refTable"
188 An <atomic-type> by itself is equivalent to a JSON object with a
189 single member "type" whose value is the <atomic-type>.
191 "enum" may be specified as a <value> whose type is a set of one
192 or more values specified for the member "type". If "enum" is
193 specified, then the valid values of the <base-type> are limited to
194 those in the <value>.
196 "enum" is mutually exclusive with the following constraints.
198 If "type" is "integer", then "minInteger" or "maxInteger" or both
199 may also be specified, restricting the valid integer range. If
200 both are specified, then the maxInteger must be greater than or
203 If "type" is "real", then "minReal" or "maxReal" or both may also
204 be specified, restricting the valid real range. If both are
205 specified, then the maxReal must be greater than or equal to
208 If "type" is "string", then "minLength" and "maxLength" or both
209 may be specified, restricting the valid length of value strings.
210 If both are specified, then maxLength must be greater than or
211 equal to minLength. String length is measured in characters (not
212 bytes or UTF-16 code units).
214 If "type" is "uuid", then "refTable", if present, must be the name
215 of a table within this database. If "refTable" is specified, then
216 "refType" may also be specified. If "refTable" is set, the effect
217 depends on "refType":
219 - If "refType" is "strong" or if "refType" is omitted, the
220 allowed UUIDs are limited to UUIDs for rows in the named
223 - If "refType" is "weak", then any UUIDs are allowed, but
224 UUIDs that do not correspond to rows in the named table will
225 be automatically deleted.
227 "refTable" constraints are "deferred" constraints: they are
228 enforced only at transaction commit time (see the "transact"
229 request below). The other contraints on <base-type> are
230 "immediate", enforced immediately by each operation.
234 One of the strings "integer", "real", "boolean", "string", or
235 "uuid", representing the specified scalar type.
240 The database wire protocol is implemented in JSON-RPC 1.0. We
241 encourage use of JSON-RPC over stream connections instead of JSON-RPC
242 over HTTP, for these reasons:
244 * JSON-RPC is a peer-to-peer protocol, but HTTP is a client-server
245 protocol, which is a poor match. Thus, JSON-RPC over HTTP
246 requires the client to periodically poll the server to receive
249 * HTTP is more complicated than stream connections and doesn't
250 provide any corresponding advantage.
252 * The JSON-RPC specification for HTTP transport is incomplete.
254 The database wire protocol consists of the following JSON-RPC methods:
259 Request object members:
261 "method": "list_dbs" required
262 "params": [] required
263 "id": <nonnull-json-value> required
265 Response object members:
267 "result": [<db-name>, ...]
269 "id": same "id" as request
271 This operation retrieves an array whose elements are <db-name>s
272 that name the databases that can be accessed over this JSON-RPC
278 Request object members:
280 "method": "get_schema" required
281 "params": [<db-name>] required
282 "id": <nonnull-json-value> required
284 Response object members:
286 "result": <database-schema>
288 "id": same "id" as request
290 This operation retrieves a <database-schema> that describes hosted
296 Request object members:
298 "method": "transact" required
299 "params": [<db-name>, <operation>*] required
300 "id": <nonnull-json-value> required
302 Response object members:
304 "result": [<object>*]
306 "id": same "id" as request
308 The "params" array for this method consists of a <db-name> that
309 identifies the database to which the transaction applies, followed by
310 zero or more JSON objects, each of which represents a single database
311 operation. The "Operations" section below describes the valid
314 The value of "id" must be unique among all in-flight transactions
315 within the current JSON-RPC session. Otherwise, the server may return
318 The database server executes each of the specified operations in the
319 specified order, except that if an operation fails, then the remaining
320 operations are not executed.
322 The set of operations is executed as a single atomic, consistent,
323 isolated transaction. The transaction is committed only if every
324 operation succeeds. Durability of the commit is not guaranteed unless
325 the "commit" operation, with "durable" set to true, is included in the
326 operation set (see below).
328 Regardless of whether errors occur, the response is always a JSON-RPC
329 response with null "error" and a "result" member that is an array with
330 the same number of elements as "params". Each element of the "result"
331 array corresponds to the same element of the "params" array. The
332 "result" array elements may be interpreted as follows:
334 - A JSON object that does not contain an "error" member indicates
335 that the operation completed successfully. The specific members
336 of the object are specified below in the descriptions of
337 individual operations. Some operations do not produce any
338 results, in which case the object will have no members.
340 - An <error>, which indicates that the operation completed with an
343 - A JSON null value indicates that the operation was not attempted
344 because a prior operation failed.
346 In general, "result" contains some number of successful results,
347 possibly followed by an error, in turn followed by enough JSON null
348 values to match the number of elements in "params". There is one
349 exception: if all of the operations succeed, but the results cannot be
350 committed, then "result" will have one more element than "params",
351 with the additional element an <error>. The possible "error" strings
352 include at least the following:
354 "error": "referential integrity violation"
356 When the commit was attempted, a column's value referenced the
357 UUID for a row that did not exist in the table named by the
358 column's <base-type> key or value "refTable" that has a
359 "refType" of "strong". (This can be caused by inserting a row
360 that references a nonexistent row, by deleting a row that is
361 still referenced by another row, by specifying the UUID for a
362 row in the wrong table, and other ways.)
364 "error": "constraint violation"
366 A column with a <base-type> key or value "refTable" whose
367 "refType" is "weak" became empty due to deletion(s) caused
368 because the rows that it referenced were deleted (or never
369 existed, if the column's row was inserted within the
370 transaction), and this column is not allowed to be empty
371 because its <type> has a "min" of 1.
373 "error": "constraint violation"
375 The number of rows in a table exceeds the maximum number
376 permitted by the table's "maxRows" value (see <table-schema>).
378 If "params" contains one or more "wait" operations, then the
379 transaction may take an arbitrary amount of time to complete. The
380 database implementation must be capable of accepting, executing, and
381 replying to other transactions and other JSON-RPC requests while a
382 transaction or transactions containing "wait" operations are
383 outstanding on the same or different JSON-RPC sessions.
385 The section "Notation for the Wire Protocol" below describes
386 additional notation for use with the wire protocol. After that, the
387 "Operations" section describes each operation.
392 Request object members:
394 "method": "cancel" required
395 "params": [the "id" for an outstanding request] required
398 Response object members:
402 This JSON-RPC notification instructs the database server to
403 immediately complete or cancel the "transact" request whose "id" is
404 the same as the notification's "params" value.
406 If the "transact" request can be completed immediately, then the
407 server sends a response in the form described for "transact", above.
408 Otherwise, the server sends a JSON-RPC error response of the following
413 "id": the request "id" member
415 The "cancel" notification itself has no reply.
420 Request object members:
422 "method": "monitor" required
423 "params": [<db-name>, <json-value>, <monitor-requests>] required
424 "id": <nonnull-json-value> required
426 <monitor-requests> is an object that maps from a table name to a
429 Each <monitor-request> is an object with the following members:
431 "columns": [<column>*] optional
432 "select": <monitor-select> optional
434 <monitor-select> is an object with the following members:
436 "initial": <boolean> optional
437 "insert": <boolean> optional
438 "delete": <boolean> optional
439 "modify": <boolean> optional
441 Response object members:
443 "result": <table-updates>
445 "id": same "id" as request
447 This JSON-RPC request enables a client to replicate tables or subsets
448 of tables within database <db-name>. Each <monitor-request> specifies
449 a table to be replicated. The JSON-RPC response to the "monitor"
450 includes the initial contents of each table. Afterward, when changes
451 to those tables are committed, the changes are automatically sent to
452 the client using the "update" monitor notification. This monitoring
453 persists until the JSON-RPC session terminates or until the client
454 sends a "monitor_cancel" JSON-RPC request.
456 Each <monitor-request> describes how to monitor a table:
458 The circumstances in which an "update" notification is sent for a
459 row within the table are determined by <monitor-select>:
461 If "initial" is omitted or true, every row in the table is
462 sent as part of the reply to the "monitor" request.
464 If "insert" is omitted or true, "update" notifications are
465 sent for rows newly inserted into the table.
467 If "delete" is omitted or true, "update" notifications are
468 sent for rows deleted from the table.
470 If "modify" is omitted or true, "update" notifications are
471 sent whenever when a row in the table is modified.
473 The "columns" member specifies the columns whose values are
474 monitored. If "columns" is omitted, all columns in the table,
475 except for "_uuid", are monitored.
477 The "result" in the JSON-RPC response to the "monitor" request is a
478 <table-updates> object (see below) that contains the contents of the
479 tables for which "initial" rows are selected. If no tables' initial
480 contents are requested, then "result" is an empty object.
485 Notification object members:
488 "params": [<json-value>, <table-updates>]
491 The <json-value> in "params" is the same as the value passed as the
492 <json-value> in "params" for the "monitor" request.
494 <table-updates> is an object that maps from a table name to a
497 A <table-update> is an object that maps from the row's UUID (as a
498 36-byte string) to a <row-update> object.
500 A <row-update> is an object with the following members:
502 "old": <row> present for "delete" and "modify" updates
503 "new": <row> present for "initial", "insert", and "modify" updates
505 This JSON-RPC notification is sent from the server to the client to
506 tell it about changes to a monitored table (or the initial state of a
507 modified table). Each table in which one or more rows has changed (or
508 whose initial view is being presented) is represented in "updates".
509 Each row that has changed (or whose initial view is being presented)
510 is represented in its <table-update> as a member with its name taken
511 from the row's _uuid member. The corresponding value is a
514 The "old" member is present for "delete" and "modify" updates.
515 For "delete" updates, each monitored column is included. For
516 "modify" updates, the prior value of each monitored column whose
517 value has changed is included (monitored columns that have not
518 changed are represented in "new").
520 The "new" member is present for "initial", "insert", and "modify"
521 updates. For "initial" and "insert" updates, each monitored
522 column is included. For "modify" updates, the new value of each
523 monitored column is included.
528 Request object members:
530 "method": "monitor_cancel" required
531 "params": [<json-value>] required
532 "id": <nonnull-json-value> required
534 Response object members:
538 "id": the request "id" member
540 Cancels the ongoing table monitor request, identified by the
541 <json-value> in "params" matching the <json-value> in "params" for an
542 ongoing "monitor" request. No more "update" messages will be sent for
548 Request object members:
550 "method": "echo" required
551 "params": JSON array with any contents required
552 "id": <json-value> required
554 Response object members:
556 "result": same as "params"
558 "id": the request "id" member
560 Both the JSON-RPC client and the server must implement this request.
562 This JSON-RPC request and response can be used to implement connection
563 keepalives, by allowing the server to check that the client is still
567 Notation for the Wire Protocol
568 ------------------------------
572 An <id> that names a database. The valid <db-name>s can be
573 obtained using a "list-db" request. The <db-name> is taken from
574 the "name" member of <database-schema>.
578 An <id> that names a table.
582 An <id> that names a table column.
586 A JSON object that describes a table row or a subset of a table
587 row. Each member is the name of a table column paired with the
588 <value> of that column.
592 A JSON value that represents the value of a column in a table row,
593 one of <atom>, a <set>, or a <map>.
597 A JSON value that represents a scalar value for a column, one of
598 <string>, <number>, <boolean>, <uuid>, <named-uuid>.
602 Either an <atom>, representing a set with exactly one element, or
603 a 2-element JSON array that represents a database set value. The
604 first element of the array must be the string "set" and the second
605 element must be an array of zero or more <atom>s giving the values
606 in the set. All of the <atom>s must have the same type.
610 A 2-element JSON array that represents a database map value. The
611 first element of the array must be the string "map" and the second
612 element must be an array of zero or more <pair>s giving the values
613 in the map. All of the <pair>s must have the same key and value
616 (JSON objects are not used to represent <map> because JSON only
617 allows string names in an object.)
621 A 2-element JSON array that represents a pair within a database
622 map. The first element is an <atom> that represents the key, the
623 second element is an <atom> that represents the value.
627 A 2-element JSON array that represents a UUID. The first element
628 of the array must be the string "uuid" and the second element must
629 be a 36-character string giving the UUID in the format described
630 by RFC 4122. For example, the following <uuid> represents the
631 UUID 550e8400-e29b-41d4-a716-446655440000:
633 ["uuid", "550e8400-e29b-41d4-a716-446655440000"]
637 A 2-element JSON array that represents the UUID of a row inserted
638 in an "insert" operation within the same transaction. The first
639 element of the array must be the string "named-uuid" and the
640 second element should be the string specified as the "uuid-name"
641 for an "insert" operation within the same transaction. For
642 example, if an "insert" operation within this transaction
643 specifies a "uuid-name" of "myrow", the following <named-uuid>
644 represents the UUID created by that operation:
646 ["named-uuid", "myrow"]
648 A <named-uuid> may be used anywhere a <uuid> is valid.
652 A 3-element JSON array of the form [<column>, <function>,
653 <value>] that represents a test on a column value.
655 Except as otherwise specified below, <value> must have the same
658 The meaning depends on the type of <column>:
663 <function> must be "<", "<=", "==", "!=", ">=", ">",
664 "includes", or "excludes".
666 The test is true if the column's value satisfies the
667 relation <function> <value>, e.g. if the column has value
668 1 and <value> is 2, the test is true if <function> is "<",
669 "<=" or "!=", but not otherwise.
671 "includes" is equivalent to "=="; "excludes" is equivalent
678 <function> must be "!=", "==", "includes", or "excludes".
680 If <function> is "==" or "includes", the test is true if
681 the column's value equals <value>. If <function> is "!="
682 or "excludes", the test is inverted.
687 <function> must be "!=", "==", "includes", or "excludes".
689 If <function> is "==", the test is true if the column's
690 value contains exactly the same values (for sets) or pairs
691 (for maps). If <function> is "!=", the test is inverted.
693 If <function> is "includes", the test is true if the
694 column's value contains all of the values (for sets) or
695 pairs (for maps) in <value>. The column's value may also
696 contain other values or pairs.
698 If <function> is "excludes", the test is true if the
699 column's value does not contain any of the values (for
700 sets) or pairs (for maps) in <value>. The column's value
701 may contain other values or pairs not in <value>.
703 If <function> is "includes" or "excludes", then the
704 required type of <value> is slightly relaxed, in that it
705 may have fewer than the minimum number of elements
706 specified by the column's type. If <function> is
707 "excludes", then the required type is additionally relaxed
708 in that <value> may have more than the maximum number of
709 elements specified by the column's type.
713 One of "<", "<=", "==", "!=", ">=", ">", "includes", "excludes".
717 A 3-element JSON array of the form [<column>, <mutator>, <value>]
718 that represents a change to a column value.
720 Except as otherwise specified below, <value> must have the same
723 The meaning depends on the type of <column>:
728 <mutator> must be "+=", "-=", "*=", "/=" or (integer only)
729 "%=". The value of <column> is changed to the sum,
730 difference, product, quotient, or remainder, respectively,
731 of <column> and <value>.
733 Constraints on <column> are ignored when parsing <value>.
739 No valid <mutator>s are currently defined for these types.
743 Any <mutator> valid for the set's element type may be
744 applied to the set, in which case the mutation is applied
745 to each member of the set individually. <value> must be a
746 scalar value of the same type as the set's element type,
747 except that contraints are ignored.
749 If <mutator> is "insert", then each of the values in the
750 set in <value> is added to <column> if it is not already
751 present. The required type of <value> is slightly
752 relaxed, in that it may have fewer than the minimum number
753 of elements specified by the column's type.
755 If <mutator> is "delete", then each of the values in the
756 set in <value> is removed from <column> if it is present
757 there. The required type is slightly relaxed in that
758 <value> may have more or less than the maximum number of
759 elements specified by the column's type.
763 <mutator> must be "insert" or "delete".
765 If <mutator> is "insert", then each of the key-value pairs
766 in the map in <value> is added to <column> only if its key
767 is not already present. The required type of <value> is
768 slightly relaxed, in that it may have fewer than the
769 minimum number of elements specified by the column's type.
771 If <mutator> is "delete", then <value> may have the same
772 type as <column> (a map type) or it may be a set whose
773 element type is the same as <column>'s key type:
775 - If <value> is a map, the mutation deletes each
776 key-value pair in <column> whose key and value equal
777 one of the key-value pairs in <value>.
779 - If <value> is a set, the mutation deletes each
780 key-value pair in <column> whose key equals one of
781 the values in <value>.
783 For "delete", <value> may have any number of elements,
784 regardless of restrictions on the number of elements in
789 One of "+=", "-=", "*=", "/=", "%=", "insert", "delete".
794 Each of the available operations is described below.
799 Request object members:
801 "op": "insert" required
802 "table": <table> required
803 "row": <row> required
804 "uuid-name": <id> optional
806 Result object members:
812 Inserts "row" into "table".
814 If "row" does not specify values for all the columns in "table",
815 those columns receive default values. The default value for a
816 column depends on its type. The default for a column whose <type>
817 specifies a "min" of 0 is an empty set or empty map. Otherwise,
818 the default is a single value or a single key-value pair, whose
819 value(s) depend on its <atomic-type>:
821 - "integer" or "real": 0
825 - "string": "" (the empty string)
827 - "uuid": 00000000-0000-0000-0000-000000000000
829 The new row receives a new, randomly generated UUID.
831 If "uuid-name" is supplied, then it is an error if <id> is not
832 unique among the "uuid-name"s supplied on all the "insert"
833 operations within this transaction.
835 The UUID for the new row is returned as the "uuid" member of the
840 "error": "duplicate uuid-name"
842 The same "uuid-name" appears on another "insert" operation
843 within this transaction.
845 "error": "constraint violation"
847 One of the values in "row" does not satisfy the immediate
848 constraints for its column's <base-type>. This error will
849 occur for columns that are not explicitly set by "row" if the
850 default value does not satisfy the column's constraints.
855 Request object members:
857 "op": "select" required
858 "table": <table> required
859 "where": [<condition>*] required
860 "columns": [<column>*] optional
862 Result object members:
868 Searches "table" for rows that match all the conditions specified
869 in "where". If "where" is an empty array, every row in "table" is
872 The "rows" member of the result is an array of objects. Each
873 object corresponds to a matching row, with each column
874 specified in "columns" as a member, the column's name as the
875 member name and its value as the member value. If "columns"
876 is not specified, all the table's columns are included. If
877 two rows of the result have the same values for all included
878 columns, only one copy of that row is included in "rows".
879 Specifying "_uuid" within "columns" will avoid dropping
880 duplicates, since every row has a unique UUID.
882 The ordering of rows within "rows" is unspecified.
887 Request object members:
889 "op": "update" required
890 "table": <table> required
891 "where": [<condition>*] required
892 "row": <row> required
894 Result object members:
900 Updates rows in a table.
902 Searches "table" for rows that match all the conditions
903 specified in "where". For each matching row, changes the
904 value of each column specified in "row" to the value for that
905 column specified in "row".
907 The "_uuid" and "_version" columns of a table may not be directly
908 updated with this operation. Columns designated read-only in the
909 schema also may not be updated.
911 The "count" member of the result specifies the number of rows
916 "error": "constraint violation"
918 One of the values in "row" does not satisfy the immediate
919 constraints for its column's <base-type>.
923 Request object members:
925 "op": "mutate" required
926 "table": <table> required
927 "where": [<condition>*] required
928 "mutations": [<mutation>*] required
930 Result object members:
936 Mutates rows in a table.
938 Searches "table" for rows that match all the conditions specified
939 in "where". For each matching row, mutates its columns as
940 specified by each <mutation> in "mutations", in the order
943 The "_uuid" and "_version" columns of a table may not be directly
944 modified with this operation. Columns designated read-only in the
945 schema also may not be updated.
947 The "count" member of the result specifies the number of rows
952 "error": "domain error"
954 The result of the mutation is not mathematically defined,
955 e.g. division by zero.
957 "error": "range error"
959 The result of the mutation is not representable within the
960 database's format, e.g. an integer result outside the range
961 INT64_MIN...INT64_MAX or a real result outside the range
964 "error": "constraint violation"
966 The mutation caused the column's value to violate a
967 constraint, e.g. it caused a column to have more or fewer
968 values than are allowed, an arithmetic operation caused a set
969 or map to have duplicate elements, or it violated a constraint
970 specified by a column's <base-type>.
975 Request object members:
977 "op": "delete" required
978 "table": <table> required
979 "where": [<condition>*] required
981 Result object members:
987 Deletes all the rows from "table" that match all the conditions
988 specified in "where".
990 The "count" member of the result specifies the number of deleted
996 Request object members:
998 "op": "wait" required
999 "timeout": <integer> optional
1000 "table": <table> required
1001 "where": [<condition>*] required
1002 "columns": [<column>*] required
1003 "until": "==" or "!=" required
1004 "rows": [<row>*] required
1006 Result object members:
1012 Waits until a condition becomes true.
1014 If "until" is "==", checks whether the query on "table" specified
1015 by "where" and "columns", which is evaluated in the same way as
1016 specified for "select", returns the result set specified by
1017 "rows". If it does, then the operation completes successfully.
1018 Otherwise, the entire transaction rolls back. It is automatically
1019 restarted later, after a change in the database makes it possible
1020 for the operation to succeed. The client will not receive a
1021 response until the operation permanently succeeds or fails.
1023 If "until" is "!=", the sense of the test is negated. That is, as
1024 long as the query on "table" specified by "where" and "columns"
1025 returns "rows", the transaction will be rolled back and restarted
1028 If "timeout" is specified, then the transaction aborts after the
1029 specified number of milliseconds. The transaction is guaranteed
1030 to be attempted at least once before it aborts. A "timeout" of 0
1031 will abort the transaction on the first mismatch.
1035 "error": "not supported"
1037 One or more of the columns in this table do not support
1038 triggers. This error will not occur if "timeout" is 0.
1040 "error": "timed out"
1042 The "timeout" was reached before the transaction was able to
1048 Request object members:
1050 "op": "commit" required
1051 "durable": <boolean> required
1053 Result object members:
1059 If "durable" is specified as true, then the transaction, if it
1060 commits, will be stored durably (to disk) before the reply is sent
1065 "error": "not supported"
1067 When "durable" is true, this database implementation does not
1068 support durable commits.
1073 Request object members:
1075 "op": "abort" required
1077 Result object members:
1083 Aborts the transaction with an error. This may be useful for
1090 This operation always fails with this error.
1096 Request object members:
1098 "op": "comment" required
1099 "comment": <string> required
1101 Result object members:
1107 Provides information to a database administrator on the purpose of
1108 a transaction. The OVSDB server, for example, adds comments in
1109 transactions that modify the database to the database journal.