List of variant types

"error"

[]

0

N/A

Invalid variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": null
  "type": "error"
}

Invalid maximal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": null
  "type": "error",
  "valueEncoding": [],
  "storageEncoding": []
}

Zero represents an invalid variant type.

An invalid variant type should never exist. It may be possible that an unexpected error creates an invalid variant field value. 

When the server encounters an invalid variant type, it a:ttempts to correct it. If the field is nullable, the server replaces the field value with the null flag. If the field is not nullable, the server stores a JSON null value in the field.

If the server cannot correct the problem, it returns a variant object with the "error" type.

"null"

[]

?

N/A

null in its most minimal form:

null

Minimal null variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": null
  "type": "null"
}

Maximal null variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": null
  "type": "null",
  "valueEncoding": [],
  "storageEncoding": []
}

JSON null in a minimal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": null
  "type": "json"
}

This type is identified by "value": "null".

A variant field can have a null value like any other field. 

When a variant object's "value" property is null, the server ignores the "type", "valueEncoding", and "storageEncoding" properties, and treats the variant type as null.

The server efficiently stores a null value in the record as a bit flag so that a null field consumes no additional storage space.

If the variant field is not nullable, assigning a null value to the variant field returns an error.

If a variant field is nullable and its value is null, the server returns the variant object type as "null". 

FairCom's SQL, ISAM, CTDB, and JSON APIs receive and return the raw value as null.

"binary"

[]

2

ct_variant_VARBINARY

GIF image encoded as Base64 and stored as a binary value:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "R0lGODlhAQABAIAAAAAAAP///yH5BAUAAAEALAAA
  AAABAAEAAAICRAEAOw==", 
  "type": "binary",
  "valueEncoding": ["base64"],
  "storageEncoding": []
}

GIF image encoded as hexadecimal and stored as a binary value:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "47494638396101000100800000000000ffffff21f9040500000
  1002c00000000010001000002024401003b", 
  "type": "binary",
  "valueEncoding": ["hex"],
  "storageEncoding": []
}

GIF image encoded as an array of bytes and stored as a binary value:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": [71, 73, 70, 56, 57, 97, 1, 0, 1, 0, 128, 
  0, 0, 0, 0, 0, 255, 255, 255, 33, 249, 4, 5, 0, 0, 
  1, 0, 44, 0, 0, 0, 0, 1, 0, 1, 0, 0, 2, 2, 68, 1, 
  0, 59], 
  "type": "binary",
  "valueEncoding": ["byteArray"],
  "storageEncoding": []
}

This type is identified by "type": "binary" and "storageEncoding": [].

A binary variant value is a series of bytes up to 2 GB in length. The server stores bytes in the exact order as received. 

The server does not validate a binary value.

FairCom's ISAM and CTDB APIs receive and return the raw bytes.

FairCom SQL receives and returns a variant object that may contain a binary value. When receiving a variant object, the server uses the "valueEncoding" property to determine how the value is encoded. When the server returns a variant object, it encodes the value as hexadecimal, embeds it in a JSON string, and sets "valueEncoding" to "hex".

JSON APIs receive and return a binary value by  embedding it in a JSON string or as an array of bytes. The "binaryFormat" property defines how it is encoded in a JSON string. When "variantFormat" is set to "variantObject", JSON APIs receive and return a variant object containing binary value. 

"string"

[]

1

ct_variant_VARCHAR

Minimal string variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "A \n\t \"copyright\" \\ \r \u00A9"
  "type": "string"
}

Maximal string variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "A \n\t \"copyright\" \\ \r \u00A9"
  "type": "string",
  "valueEncoding": [],
  "storageEncoding": []
}

This type is identified by "type": "string" and "storageEncoding": [].

A string is a variable-length, series of UTF-8 code points up to 2 GB in length. 

The server validates and stores the value as a UTF-8 string. It also decodes all JSON escaped characters into their raw binary form and stores them without JSON's double quotes. For example, it takes the JSON string, "A \n\t \"copyright\" \\ \r \u00A9", and stores it as
 

A
"copyright" \ 
 ©

FairCom's ISAM and CTDB APIs store a string AS IS and return it AS IS.

FairCom SQL receives and returns a variant object with the "value" property set to a JSON string. The server converts between the JSON string and the stored string.

JSON APIs receive and return a variant string as a JSON string or a variant object containing a JSON string. The server converts between the JSON string and the stored string.

"number"

[]

3

ct_variant_NUMBERSTRING

Minimal number variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": -123.456
  "type": "number"
}

Minimal number variant object embedded in a string:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "-123.456"
  "type": "number"
}

Maximal number variant object embedded in a string:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "-123.456"
  "type": "number",
  "valueEncoding": [],
  "storageEncoding": []
}

Maximal number variant object using exponential notation:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": -1.602176634e-19
  "type": "number",
  "valueEncoding": [],
  "storageEncoding": []
}

This type is identified by "type": "number" and "storageEncoding": [].

The server validates the value as a JSON number and stores it as a JSON number, which is a series of UTF-8 numeric digits with optional exponential number notation. This format is inefficient, but it is a lossless, limitless, base-ten number with an unlimited number of floating-point digits. JSON does not support infinity, +infinity, -infinity, or NaN.

A JSON number is stored AS IS. For example the ASCII characters in the following JSON numbers are stored without change:  -1.602176634e-19 and -123.456. If a number is embedded in a string, it is removed from the string and stored AS IS. Thus, "-123.456" is stored as -123.456. 

The server accepts a number embedded in a JSON string. Because the embedding is obvious, the "valueEncoding" property does not specify an encoding. 

Embedding a number in a string is important to avoid a problem in some JSON parsers and languages that mangle base-ten JSON numbers by automatically converting them into base-two IEEE floating point numbers.

FairCom's CTDB API converts between a variable and the stored JSON number. A conversion between base-ten and base-two numbers will introduce rounding errors. Conversion may also reduce precision, truncate a number's fractional part, or return an error if the conversion fails.

FairCom SQL receives and returns a variant object. It directly stores and retrieves the JSON number in the "value" property without conversion. 

JSON APIs receive and return a variant number as a JSON number, a JSON number embedded in a string, or a JSON number in a variant object. The "numberFormat" property specifies when a number is embedded in a string. The "variantFormat" property specifies when JSON APIs receive and return a variant object. 

"boolean"

[]

14

ct_variant_BIT

Minimal boolean variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": true
  "type": "boolean"
}

Maximal boolean variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": false
  "type": "boolean",
  "valueEncoding": [],
  "storageEncoding": []
}

This type is identified by "type": "boolean" and "storageEncoding": [].

The server validates the value as a JSON true or false and stores a single byte containing 1 for true and 0 for false.

FairCom's CTDB API converts the value in a variable to the raw value and vice-versa.

FairCom SQL receives and returns a variant object. The server converts between the stored value and the JSON boolean value of true or false. 

JSON APIs receive and return a JSON boolean value or a variant object. The server converts between the stored value and the JSON boolean value of true or false.  

"json"

[]

15

ct_variant_JSON

JSON string in a maximal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "my string",
  "type": "json",
  "valueEncoding": [],
  "storageEncoding": []
}

JSON string in a minimal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "my string",
  "type": "json"
}

JSON number in the default minimal variant object:

{
 "schema": "jsonaction.org/schemas/variantObject",
 "value": -123.456,
 "type": "json"
}

JSON boolean in the default minimal variant object:

{
 "schema": "jsonaction.org/schemas/variantObject",
 "value": false,
 "type": "json"
}
JSON null in the default minimal variant object
{
 "schema": "jsonaction.org/schemas/variantObject",
 "value": null,
 "type": "json"
}

JSON object in the default minimal variant object:

{
 "schema": "jsonaction.org/schemas/variantObject",
 "value": { "myKey": "myValue"},
 "type": "json"
}

JSON array in the default minimal variant object:

{
 "schema": "jsonaction.org/schemas/variantObject",
 "value": [1, "2", 3.0],
 "type": "json"
}

This type is identified by "type": "json" and "storageEncoding": [].

A JSON value may be an object, array, string, number, true, false, or null.

The server validates the JSON value and returns an error if it is invalid JSON. It stores the JSON value AS IS. The internal FairCom parsers should validate the JSON, but the server should store the original JSON. This ensures the parser does not mangle the numbers. It also preserves the original whitespace, which lets the user optimize the whitespace to meet their needs for readability or performance.

FairCom's SQL, ISAM, CTDB, and JSON DB APIs receive, store, and return the JSON value AS IS. 

JSON objects and arrays are stored AS IS.

A JSON string is stored AS IS including its double quote characters and JSON escaped characters. For example, the server stores each byte of the following JSON string AS IS:  "A \n\t \"copyright\" \\ \r \u00A9". Contrast this approach with the variant string type.

A JSON number is stored AS IS. For example the ASCII characters in the following JSON numbers are stored without change:  -1.602176634e-19 and -123.456. If a number is embedded in a string, it is removed from the string and stored AS IS. Thus, "-123.456" is stored as -123.456. The variant number uses this same technique.

A JSON boolean is stored AS IS. For example the ASCII characters in the following JSON booleans are stored without change:  true and false. Contrast this approach with the variant boolean type.

A JSON null value is stored as a null field value. If a variant field is not nullable, the server returns an error.

"number"

["tinyint"]

4

ct_variant_NUMBERTINY

number["tinyint"] variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": -123
  "type": "number",
  "storageEncoding": ["tinyint"]
}

number["tinyint"] variant object embedded in a string:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "-123"
  "type": "number",
  "storageEncoding": ["tinyint"]
}

number["tinyint"] variant object using exponential notation:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": 3e2
  "type": "number",
  "valueEncoding": [],
  "storageEncoding": ["tinyint"]
}

number["tinyint"] variant object too large to fit type:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": 1.602176634E+20
  "type": "number",
  "valueEncoding": [],
  "storageEncoding": ["tinyint"]
}

number["tinyint"] variant object with truncation:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": 0.0000000000000000009
  "type": "number",
  "valueEncoding": [],
  "storageEncoding": ["tinyint"]
}

This type is identified by "type": "number" and "storageEncoding": ["tinyint"].

The server converts a number to an 8-bit signed integer and stores its binary value. The server truncates the number's fractional parts. 

The number's range is from -128 to 127. If the number exceeds the range, the server fails the operation and reports an error.

The server accepts a number embedded in a JSON string. Because the embedding is obvious, the "valueEncoding" property does not specify an encoding. 

FairCom's CTDB API converts between a variable and the stored number. A conversion between base-ten and base-two numbers will introduce rounding errors. Conversion may also reduce precision, truncate a number's fractional part, or return an error if the conversion fails.

FairCom SQL receives and returns a variant object. The server converts from the JSON number in the "value" property to and from the stored binary value. 

JSON APIs receive and return a variant number as a JSON number, a JSON number embedded in a string, or a JSON number in a variant object. The server converts from the JSON number in the "value" property to and from the stored binary value. 

The server can accept any valid exponential encoding of a number, such as 3e2. When it generates a JSON number from the stored binary number, it may produce a simpler encoding, such as 30.

"number"

["smallint"]

5

ct_variant_NUMBERSMALL

number["smallint"] variant object

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": -123
  "type": "number",
  "storageEncoding": ["smallint"]
}

This type is identified by "type": "number" and "storageEncoding": ["smallint"].

The server converts a number to a 16-bit signed integer and stores its binary value. The server truncates the number's fractional parts. 

The number's range is from -32,768 to 32,767. If the number exceeds the range, the server fails the operation and reports an error.

See "number"["tinyint"] for API details.

"number"

["integer"]

6

ct_variant_NUMBERINT

number["integer"] variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": -123
  "type": "number",
  "storageEncoding": ["integer"]
}

This type is identified by "type": "number" and "storageEncoding": ["integer"].

The server converts a number to a 32-bit signed integer and stores its binary value. The server truncates the number's fractional parts. 

The number's range is from -2,147,483,648 to 2,147,483,647. If the number exceeds the range, the server fails the operation and reports an error.

See "number"["tinyint"] for API details.

"number"

["bigint"]

13

ct_variant_NUMBERBIGINT

number["bigint"] variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": -123
  "type": "number",
  "storageEncoding": ["bigint"]
}

This type is identified by "type": "number" and "storageEncoding": ["bigint"].

The server converts a number to a 64-bit signed integer and stores its binary value. The server truncates the number's fractional parts. 

The number's range is from -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807. If the number exceeds the range, the server fails the operation and reports an error.

See "number"["tinyint"] for API details.

"number"

["numeric"]

9

ct_variant_NUMBERBCD

number["numeric"] variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": -123.564
  "type": "number",
  "storageEncoding": ["numeric"]
}

This type is identified by "type": "number" and "storageEncoding": ["numeric"].

The server converts a number to a 32 digit BCD number. It’s a precise floating point number (given the maximum number of significant digits)

"number"

["float"]

7

ct_variant_NUMBERFLOAT

number["float"] variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": -123
  "type": "number",
  "storageEncoding": ["float"]
}

This type is identified by "type": "number" and "storageEncoding": ["float"].

The server converts a number to a IEEE 16-bit floating point number and stores its binary value, which is a lossy, base-two format. Using this format will introduce base-ten to base-two conversion issues and will likely reduce the number's precision.

See "number"["tinyint"] for API details.

"number"

["double"]

8

ct_variant_NUMBERDOUBLE

number["double"] variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": -123
  "type": "number",
  "storageEncoding": ["double"]
}

This type is identified by "type": "number" and "storageEncoding": ["double"].

The server converts a number to a IEEE 32-bit floating point number and stores its binary value, which is a lossy, base-two format. Using this format will introduce base-ten to base-two conversion issues and may reduce the number's precision.

See "number"["tinyint"] for API details.

"xml"

[]

8162

ct_variant_XML

XML in a minimal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "<myElement>value</myElement>",
  "type": "xml"
}
XML in a maximal variant object
{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "<myElement>value</myElement>",
  "type": "xml",
  "valueEncoding": [],
  "storageEncoding": []
}

This type is identified by "type": "xml" and "storageEncoding": [].

The server requires and validates that the value is encoded as UTF-8. It does not validate it as XML.

FairCom's SQL, ISAM, CTDB, and JSON DB APIs receive, store, and return the value AS IS.

"html"

[]

8193

ct_variant_HTML

HTML in a minimal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "<p>paragraph</p>",
  "type": "html"
}
HTML in a maximal variant object
{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "<p>paragraph</p>",
  "type": "html",
  "valueEncoding": [],
  "storageEncoding": []
}

This type is identified by "type": "html" and "storageEncoding": [].

The server requires and validates that the value is encoded as UTF-8. It does not validate it as HTML.

FairCom's SQL, ISAM, CTDB, and JSON DB APIs receive, store, and return the value AS IS.

"javascript"

[]

8194

ct_variant_JAVASCRIPT

JavaScript in a minimal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "a=3;",
  "type": "javascript"
}
JavaScript in a maximal variant object
{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "a=3;",
  "type": "javascript",
  "valueEncoding": [],
  "storageEncoding": []
}

This type is identified by "type": "javascript" and "storageEncoding": [].

The server requires and validates that the value is encoded as UTF-8. It does not validate it as JavaScript.

FairCom's SQL, ISAM, CTDB, and JSON DB APIs receive, store, and return the value AS IS.

"sql"

[]

8195

ct_variant_SQL

SQL in a minimal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "select * from my_table;",
  "type": "sql"
}
SQL in a maximal variant object
{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "select * from my_table",
  "type": "sql",
  "valueEncoding": [],
  "storageEncoding": []
}

This type is identified by "type": "sql" and "storageEncoding": [].

The server requires and validates that the value is encoded as UTF-8. It does not validate it as SQL.

FairCom's SQL, ISAM, CTDB, and JSON DB APIs receive, store, and return the value AS IS.

"css"

[]

8196

ct_variant_CSS

CSS in a minimal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "body {margin: 0;}",
  "type": "css"
}
CSS in a maximal variant object
{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "body {margin: 0;}",
  "type": "css",
  "valueEncoding": [],
  "storageEncoding": []
}

This type is identified by "type": "css" and "storageEncoding": [].

The server requires and validates that the value is encoded as UTF-8. It does not validate it as CSS.

FairCom's SQL, ISAM, CTDB, and JSON DB APIs receive, store, and return the value AS IS.

"csv"

[]

8197

ct_variant_CSV

CSV in a minimal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "Name,Age\nAlice,30",
  "type": "csv"
}
CSV in a maximal variant object
{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "Name,Age\nAlice,30",
  "type": "csv",
  "valueEncoding": [],
  "storageEncoding": []
}

This type is identified by "type": "csv" and "storageEncoding": [].

The server requires and validates that the value is encoded as UTF-8. It does not validate it as CSV.

FairCom's SQL, ISAM, CTDB, and JSON DB APIs receive, store, and return the value AS IS.

"markdown"

[]

8198

ct_variant_MARKDOWN

Markdown in a minimal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "*   Item **One**",
  "type": "markdown"
}
Markdown in a maximal variant object
{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "*   Item **One**",
  "type": "markdown",
  "valueEncoding": [],
  "storageEncoding": []
}

This type is identified by "type": "markdown" and "storageEncoding": [].

The server requires and validates that the value is encoded as UTF-8. It does not validate it as Markdown.

FairCom's SQL, ISAM, CTDB, and JSON DB APIs receive, store, and return the value AS IS.

"rtf"

[]

8199

ct_variant_RTF

RTF in a minimal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "{\rtf1 Hello, World.}",
  "type": "rtf"
}
RTF in a maximal variant object
{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "{\rtf1 Hello, World.}",
  "type": "rtf",
  "valueEncoding": [],
  "storageEncoding": []
}

This type is identified by "type": "rtf" and "storageEncoding": [].

The server requires and validates that the value is encoded as UTF-8. It does not validate it as RTF.

FairCom's SQL, ISAM, CTDB, and JSON DB APIs receive, store, and return the value AS IS.

"tsv"

It is currently named "tab_separated_values"

[]

8200

ct_variant_TAB_SEPARATED_VALUES

TSV in a minimal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "Title\tAuthor\nDune\tFrank Herbert",
  "type": "tsv"
}
TSV in a maximal variant object
{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "Title\tAuthor\nDune\tFrank Herbert",
  "type": "tsv",
  "valueEncoding": [],
  "storageEncoding": []
}

This type is identified by "type": "tsv" and "storageEncoding": [].

The server requires and validates that the value is encoded as UTF-8. It does not validate it as tab-separated values (TSV).

FairCom's SQL, ISAM, CTDB, and JSON DB APIs receive, store, and return the value AS IS.

"turtle"

[]

8201

ct_variant_TURTLE

Turtle in a minimal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "@prefix t: <http://t.com/> . t:emp134 t:hired "2022-11-12" .",
  "type": "turtle"
}

Turtle in a maximal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "@prefix t: <http://t.com/> . t:emp134 t:hired "2022-11-12" .",
  "type": "turtle",
  "valueEncoding": [],
  "storageEncoding": []
}

This type is identified by "type": "turtle" and "storageEncoding": [].

The server requires and validates that the value is encoded as UTF-8. It does not validate it as Turtle (Terse RDF Triple Language).

FairCom's SQL, ISAM, CTDB, and JSON DB APIs receive, store, and return the value AS IS.

"vcard"

[]

8202

ct_variant_VCARD

vCard in a minimal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "BEGIN:VCARD\r\nVERSION:4.0\r\nFN:J\r\nEND:VCARD",
  "type": "turtle"
}

vCard in a maximal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "BEGIN:VCARD\r\nVERSION:4.0\r\nFN:J\r\nEND:VCARD",
  "type": "turtle",
  "valueEncoding": [],
  "storageEncoding": []
}

This type is identified by "type": "vcard" and "storageEncoding": [].

The server requires and validates that the value is encoded as UTF-8. It does not validate it as vCard

FairCom's SQL, ISAM, CTDB, and JSON DB APIs receive, store, and return the value AS IS.

"mp4"

[]

8203

ct_variant_MP4

MP4 in a minimal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "AAAAHGZ0eXBpc29tAAAAAGlzb20",
  "type": "mp4",
  "valueEncoding": ["base64"]
}

MP4 in a maximal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "0000001c6674797069736f6d0000000069736f6d",
  "type": "mp4",
  "valueEncoding": ["hex"],
  "storageEncoding": []
}

This type is identified by "type": "mp4" and "storageEncoding": [].

The server stores the binary value AS IS. It does not validate it as an MP4 video.

A variant object must include the "valueEncoding" property to specify the encoding of the "value" property.

FairCom's SQL, ISAM, CTDB, and JSON DB APIs receive, store, and return the value AS IS.

"quicktime"

[]

8204

ct_variant_QUICKTIME

QuickTime in a minimal variant object: 

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "AAAAHGZ0eXBpc29tAAAAAGlzb20",
  "type": "quicktime",
  "valueEncoding": ["base64"]
}

QuickTime in a maximal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "0000001c6674797069736f6d0000000069736f6d",
  "type": "quicktime",
  "valueEncoding": ["hex"],
  "storageEncoding": []
}

This type is identified by "type": "quicktime" and "storageEncoding": [].

The server stores the binary value AS IS. It does not validate it as QuickTime video.

A variant object must include the "valueEncoding" property to specify the encoding of the "value" property.

FairCom's SQL, ISAM, CTDB, and JSON DB APIs receive, store, and return the value AS IS.

"bmp"

[]

8205

ct_variant_BMP

BMP in a minimal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "AAAAHGZ0eXBpc29tAAAAAGlzb20",
  "type": "bmp",
  "valueEncoding": ["base64"]
}

BMP in a maximal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "0000001c6674797069736f6d0000000069736f6d",
  "type": "bmp",
  "valueEncoding": ["hex"],
  "storageEncoding": []
}

This type is identified by "type": "bmp" and "storageEncoding": [].

The server stores the binary value AS IS. It does not validate it as a BMP image.

A variant object must include the "valueEncoding" property to specify the encoding of the "value" property.

FairCom's SQL, ISAM, CTDB, and JSON DB APIs receive, store, and return the value AS IS.

"gif"

[]

8206

ct_variant_GIF

GIF in a minimal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "AAAAHGZ0eXBpc29tAAAAAGlzb20",
  "type": "gif",
  "valueEncoding": ["base64"]
}

GIF in a maximal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "0000001c6674797069736f6d0000000069736f6d",
  "type": "gif",
  "valueEncoding": ["hex"],
  "storageEncoding": []
}

This type is identified by "type": "gif" and "storageEncoding": [].

The server stores the binary value AS IS. It does not validate it as a GIF image.

A variant object must include the "valueEncoding" property to specify the encoding of the "value" property.

FairCom's SQL, ISAM, CTDB, and JSON DB APIs receive, store, and return the value AS IS.

"jpeg"

[]

8207

ct_variant_JPEG

JPEG in a minimal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "AAAAHGZ0eXBpc29tAAAAAGlzb20",
  "type": "jpeg",
  "valueEncoding": ["base64"]
}

JPEG in a maximal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "0000001c6674797069736f6d0000000069736f6d",
  "type": "jpeg",
  "valueEncoding": ["hex"],
  "storageEncoding": []
}

This type is identified by "type": "jpeg" and "storageEncoding": [].

The server stores the binary value AS IS. It does not validate it as a JPEG image.

A variant object must include the "valueEncoding" property to specify the encoding of the "value" property.

FairCom's SQL, ISAM, CTDB, and JSON DB APIs receive, store, and return the value AS IS.

"svg"

[]

8208

ct_variant_SVG

SVG in a minimal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "AAAAHGZ0eXBpc29tAAAAAGlzb20",
  "type": "svg",
  "valueEncoding": ["base64"]
}

SVG in a maximal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "0000001c6674797069736f6d0000000069736f6d",
  "type": "svg",
  "valueEncoding": ["hex"],
  "storageEncoding": []
}

This type is identified by "type": "svg" and "storageEncoding": [].

The server stores the binary value AS IS. It does not validate it as a SVG image.

A variant object must include the "valueEncoding" property to specify the encoding of the "value" property.

FairCom's SQL, ISAM, CTDB, and JSON DB APIs receive, store, and return the value AS IS.

"png"

[]

8209

ct_variant_PNG

PNG in a minimal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "AAAAHGZ0eXBpc29tAAAAAGlzb20",
  "type": "png",
  "valueEncoding": ["base64"]
}

PNG in a maximal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "0000001c6674797069736f6d0000000069736f6d",
  "type": "png",
  "valueEncoding": ["hex"],
  "storageEncoding": []
}

This type is identified by "type": "png" and "storageEncoding": [].

The server stores the binary value AS IS. It does not validate it as a PNG image.

A variant object must include the "valueEncoding" property to specify the encoding of the "value" property.

FairCom's SQL, ISAM, CTDB, and JSON DB APIs receive, store, and return the value AS IS.

"flac"

[]

8210

ct_variant_FLAC

FLAC in a minimal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "AAAAHGZ0eXBpc29tAAAAAGlzb20",
  "type": "flac",
  "valueEncoding": ["base64"]
}

FLAC in a maximal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "0000001c6674797069736f6d0000000069736f6d",
  "type": "flac",
  "valueEncoding": ["hex"],
  "storageEncoding": []
}

This type is identified by "type": "flac" and "storageEncoding": [].

The server stores the binary value AS IS. It does not validate it as a FLAC audio recording.

A variant object must include the "valueEncoding" property to specify the encoding of the "value" property.

FairCom's SQL, ISAM, CTDB, and JSON DB APIs receive, store, and return the value AS IS.

"mpeg"

[]

8211

ct_variant_MPEG

FLAC in a minimal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "AAAAHGZ0eXBpc29tAAAAAGlzb20",
  "type": "mpeg",
  "valueEncoding": ["base64"]
}

FLAC in a maximal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "0000001c6674797069736f6d0000000069736f6d",
  "type": "mpeg",
  "valueEncoding": ["hex"],
  "storageEncoding": []
}

This type is identified by "type": "mpeg" and "storageEncoding": [].

The server stores the binary value AS IS. It does not validate it as a FLAC audio recording.

A variant object must include the "valueEncoding" property to specify the encoding of the "value" property.

FairCom's SQL, ISAM, CTDB, and JSON DB APIs receive, store, and return the value AS IS.

"opus"

[]

8212

ct_variant_OPUS           

OPUS in a minimal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "AAAAHGZ0eXBpc29tAAAAAGlzb20",
  "type": "opus",
  "valueEncoding": ["base64"]
}

OPUS in a maximal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "0000001c6674797069736f6d0000000069736f6d",
  "type": "opus",
  "valueEncoding": ["hex"],
  "storageEncoding": []
}

This type is identified by "type": "opus" and "storageEncoding": [].

The server stores the binary value AS IS. It does not validate it as an OPUS audio recording.

A variant object must include the "valueEncoding" property to specify the encoding of the "value" property.

FairCom's SQL, ISAM, CTDB, and JSON DB APIs receive, store, and return the value AS IS.

"midi"

(It is currently named "rtp_midi")

[]

8213

ct_variant_RTP_MIDI

MIDI in a minimal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "AAAAHGZ0eXBpc29tAAAAAGlzb20",
  "type": "midi",
  "valueEncoding": ["base64"]
}

MIDI in a maximal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "0000001c6674797069736f6d0000000069736f6d",
  "type": "midi",
  "valueEncoding": ["hex"],
  "storageEncoding": []
}

This type is identified by "type": "midi" and "storageEncoding": [].

The server stores the binary value AS IS. It does not validate it as a Standard MIDI file for music playback and notation.

A variant object must include the "valueEncoding" property to specify the encoding of the "value" property.

FairCom's SQL, ISAM, CTDB, and JSON DB APIs receive, store, and return the value AS IS.

"spMidi"

(It is currently named "sp_midi")

[]

8214

ct_variant_SP_MIDI

SP-MIDI in a minimal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "AAAAHGZ0eXBpc29tAAAAAGlzb20",
  "type": "spMidi",
  "valueEncoding": ["base64"]
}

SP-MIDI in a maximal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "0000001c6674797069736f6d0000000069736f6d",
  "type": "spMidi",
  "valueEncoding": ["hex"],
  "storageEncoding": []
}

This type is identified by "type": "spMidi" and "storageEncoding": [].

The server stores the binary value AS IS. It does not validate it as a Scalable Playback MIDI (SP-MIDI) file for music playback and notation.

A variant object must include the "valueEncoding" property to specify the encoding of the "value" property.

FairCom's SQL, ISAM, CTDB, and JSON DB APIs receive, store, and return the value AS IS.

"otf"

[]

8215

ct_variant_OTF

OTF in a minimal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "AAAAHGZ0eXBpc29tAAAAAGlzb20",
  "type": "otf",
  "valueEncoding": ["base64"]
}

OTF in a maximal variant object:

{
  "schema": "jsonaction.org/schemas/variantObject",
  "value": "0000001c6674797069736f6d0000000069736f6d",
  "type": "otf",
  "valueEncoding": ["hex"],
  "storageEncoding": []
}

This type is identified by "type": "otf" and "storageEncoding": [].

The server stores the binary value AS IS. It does not validate it as an Open Type Font (OTF) file.

A variant object must include the "valueEncoding" property to specify the encoding of the "value" property.

FairCom's SQL, ISAM, CTDB, and JSON DB APIs receive, store, and return the value AS IS.