22JSONSchema

JSON Schema

Outline

JSON Schema ? What is it ?
Basics
Types
String
Numeric types
Boolean
Null
Object
Array
Combined schemas

What is JSON Schema ?

In the past we learnt and we used few other sort of schemas, like for example conceptual schema, relational schema and XML schema

A schema represents the structures of certain domain expressed in a formalized language. A conceptual schema represents a conceptual structure of a database domain expressed in a graphical notation of simplified UML classes or a graphical notation of Entity-Relationship data model or a notation of Object-Role-Model and many others. A relational schema represents a structure of relational table expressed in a language of named sets of attributes, primary keys, candidate keys and foreign keys. XML schema represents a structure of XML documents expressed in XML notation

So, again, what is JSON schema.?

JSON schema represents a structure of JSON/BSON document expressed as a JSON document. Hence, like with XML schema where a schema is a well formed XML document , JSON schema is also well formed JSON document

Why do we need JSON Schema ? As we mentioned before the ideas of unstructured or semistructured data model allow fro lack of rigid schema precisely determining the structures of data objects. In theory such idea seems to be very attractive. Unfortunately in practice when a data object has a structure very different from the majority of data object it is impossible distinguish between such exotic structure or a simple mistake. It means that we have to provide information about a number of possible correct structures instead of saying that any structure will do. It is why we need JSON Schema for validation of JSON objects and also XML schema for validation of XML documents. From such perspective JSON Schema is a vocabulary for validation of JSON objects and MongoDB uses an slightly modified notation of JSON Schema to validate BCON documents in MongoDB collections of documents. A collection of BSON documents can have JSON Schema assigned to more precisely determines the structures of BSON documents stored in the collection

In a general case, JSON Schema describes the structures and types of existing JSON objects. JSON Schema allows for automated validation of JSON object

Like XML Schema being itself a well formed XML document, JSON Schema itself is a well formed JSON object

The latest version of JSON Schema is a version 2020-12

JSON schema expresses the constraints imposed on JSON object. If JSON Schema is an empty object then it positively validates any possible JSON object

The following JSON object:

{"city":"Sydney", "street":"Victoria", "building number":25, "building name":"James Bond Building"}

validates well against the following JSON Schema:

{ "type":"object",

"properties": {

"city": { "type":"string" },

"street": { "type":"string" },

"building": { "type" :"number",

"minimum": 1}

}}

Note that a JSON Schema above does not impose an constraints for a key:vale pairs "building name":"James Bond Building" or any other

key:vale pair that can be added to the JSON object. It means that the given document can be extended by any additional key:vale pairs

without violation of the constraints imposed by the given JSON Schema

JSON Schema ? What is it ?

JSON Schema is a vocabulary for validation of JSON objects
JSON Schema describes the structures and types of existing JSON objects
JSON Schema allows for automated validation of JSON objects
JSON Schema itself is a JSON object
The latest version of JSON Schema is a version 2020-12

The following JSON object


{"city":"Sydney", "street":"Victoria", "building number":25, "building name":"James Bond Building"}

validates well against the following JSON Schema

{ "type":"object",
  "properties": { "city": { "type":"string" },
                  "street": { "type":"string" },       
                  "building": { "type" :"number",
                                "minimum": 1}
                }
}

JSON Schema

The simplest possible JSON schema is an empty JSON object

{ }

Such schema does not enforce any constraints and it validates any well formed JSON object

The extensions of the schema given above impose the restrictions on the validated objects. For example, the following JSON schema

{ "type":"object",

"properties": { "Hello world message": { "type":"string" } }

}

validates well the following JSON objects

{ "Hello world message":"Hello world !" }

{ "Hello world message":"Hello world !", "Greeting":"How are you ?" }

{}

An object that has a key:vale pair "Hello world message":"Hello world !" validates well because a value associated with a key is of type string

An object { "Hello world message":"Hello world !", "Greeting":"How are you ?" } validates well because like before a value associated with a key is a string and a JSON Schema does not impose any constraints of a key "Greetings"

An empty objet {} validates well because a default validation of a missing key against a key in JSN scheme is always true. It is like a default NULL constraints imposed on a column in CREATE TABLE statements. It is possible to enforce mandatory occurrence of a key:vale pair in a JSON document. Such possibility will be discussed in the future

Validation with JSON schema applies only to key:value pairs in an object that are listed in JSON schema. If a key:value pair is not listed in JSON schemas then validation does not apply to such key:value pair

If a key: value pair is listed in JSON schema and it is not included in an object then according to a default interpretation such key:value pair is optional in the object. A default interpretation cam be changed with application of a key "requiredProperties" in JSON schema. This topic will be discussed in the near future

Basics

The simplest possible JSON schema is the following (an empty object)
The schema given above validates every JSON object
Extensions of the schema given above impose the restrictions on the validated objects

For example, the following JSON schema

{ "type":"object",
  "properties": { "Hello world message": { "type":"string" } }
}

validates well the objects

{ "Hello world message":"Hello world !" }

{ "Hello world message":"Hello world !", "Greeting":"How are you ?" }

{}

Basics

The following extension of the previous schema


{ "type":"object",
  "properties": { "Hello world message": { "type":"string",
                                           "minLength": 1,
                                           "maxLength": 13 }
                }
}

fails validation of an object


{ "Hello world message":"Hello world !!!" }

because a string "Hello world !!!" is too long (15 characters)

It validates well the objects

  
{ "Hello world message":"Hello world !" }

  
{ "Hello world message":"Hello world !", "Greeting":"How are you ?" }

JSON Schema

Outline

JSON Schema ? What is it ?
Basics
Types
String
Numeric types
Boolean
Null
Object
Array
Combined schemas

To determine a type of value associated with a key JSON schema uses a key:vale pair "type":basic-type-name

JSON schema defines the following basic types: "string", "Numeric types", "object", "array", "boolean", and "null" "Numeric types" will be discussed in the future. "null" means that only no value (null) can be assigned with a key

If "type" keyword is associated with a name of a basic type then a respective value must be of the same basic type, for example

{ "type":"string"}

determines a type of a respective value as a string

It is possible to define the variants of types. A basic type associated with a keyword "type" can be either one of the types listed above or it can be an array of the basic types. If "type" keyword is associated with an array of basic types then each element of the array must be unique, for example

{ "type": ["string","number"] }

Such key:vale pair determines a type of a respective value as either string or number

Types

In JSON schema a type keyword is associated with a data type
JSON schema defines the following basic types: string, Numeric types, object, array, boolean, and null
A basic type associated with a keyword type can be either one of the types listed above or it can be an array of the types listed above
If type keyword is associated with a name of a basic type then a respective value must be of the same basic type, for example
It determines a type of a respective value as a string
If type keyword is associted with an array of basic types then each element of the array must be unique, for example
It determines a type of a respective value as either string or number

JSON Schema

Outline

JSON Schema ? What is it ?
Basics
Types
String
Numeric types
Boolean
Null
Object
Array
Combined schemas

String

A type string determines a type of a respective value as a string of characters
For example
validates well any string of characters including an empty string associated with a key "city"
A string type has the following restrictions: minLength, maxLength, pattern, and format

For example

 
"city":{"type":"string",
        "minLength": 10,
        "maxLength": 20 }

validates well any string longer than 9 characters and shorter than 21 characters associated with a key "city"

A pattern restriction can be used to used to match a string with a given regular expression

For example

"number":{"type":"string",

"pattern":"[1-9][0-9]" }

validates well any string of characters representing a number in a range from "10" to "99" with a key "number"

The first [1-9] range subexpression in a regular expression determines the first character to be in a range from "1" to "9". The second [0-9] subexpression determines the second character to be in a range from "0" to "9"

A format restriction is used to match a string with predefined format

For example

"birthday":{"type":"string",

"format":"date" }

validates well any string of characters representing a date in a format "YYYY-MM-DD" for example "2020-07-21" with key "birthday"

The following built-in formats are allowed:

Dates and times

Email addresses

Hostnames

IP Addresses

Resource identifiers

URI template

JSON Pointer

Regular Expressions

String

A pattern restriction is used to match a string with a given regular expression

For example

 
"number":{"type":"string",
          "pattern":"[1-9][0-9]" }

validates well any string of characters representing a number in a range from "10" to "99" with a key number
A format restriction is used to match a string with a predefined format

For example

 
"birthday":{"type":"string",
            "format":"date" }

validates well any string of characters representing a date in a format "YYYY-MM-DD" for example "2020-07-21" with a key birthday

JSON Schema

Outline

JSON Schema ? What is it ?
Basics
Types
String
Numeric types
Boolean
Null
Object
Array
Combined schemas

Numeric types

JSON Schema has two numeric types: integer and number
A type integer is used for validation of integer numbers
For example
validates well any integer number like -5, 0, 7, etc with key int
A type number is used for validation of any numeric value, either integer or floating point numbers
For example
validates well any integer or floating point number like like -35.7, -7, 0.0, 23, 23.4, etc with a key num

Numeric types

Numeric types integer and number have the following restrictions: multipleOf, minimum, exclusive Minimum, maximum, exclusiveMaximum

For example

 	      
"mod5zero":{ "type":"integer",
             "multipleOf": 5 }

validates well any integer like 0, 5, 10, 15, etc, with a key mod5zero

For example

 	      
"mof2":{ "type":"number",
         "multipleOf": 0.2 }

validates well any number like 0.0, 0.2, 0.4, 0.6, etc, associated with a key mof2

Numeric types

The restrictions minimum, maximum, exclusiveMinimum, and exclusiveMaximum can be used for expressing ranges

For example

  
"intrange":{ "type":"integer",
             "minimum": 0,
             "exclusiveMaximum": 5}

validates well integer numbers 0, 1, 2, 3, and 4 associated with a key intrange

JSON Schema

Outline

JSON Schema ? What is it ?
Basics
Types
String
Numeric types
Boolean
Null
Object
Array
Combined schemas

Boolean

A type boolean determines a type of a respective value either as true or false
For example
validates well the values true and false and no other values associated with a key bool

JSON Schema

Outline

JSON Schema ? What is it ?
Basics
Types
String
Numeric types
Boolean
Null
Object
Array
Combined schemas

Null

A type null determines a type of a respective value as null
For example
validates well a lack of value null and no other values associated with key nothing

JSON Schema

Outline

JSON Schema ? What is it ?
Basics
Types
String
Numeric types
Boolean
Null
Object
Array
Combined schemas

Object

A type object determines a type of a respective value as JSON object
For example

validates well the objects like

 
{ "city":"Sydney", "street":"Victoria", "building":25 }

{ "name":"School of Astronomy",
  "courses":[ {"code":"SOA101",
               "title":"Astronomy for Kids",
               "credits":3},
              {"code":"SOA201",
               "title":"Black Holes",
              "credits":6}
            ]
}

{ }

A key "properties" can be used to impose the constraints on some of the key:value pairs an object consists of

A key "properties" is associated with an object that consists of key:value pairs where each key is a name of a property and each value is a JSON schema used to validate a property

For example JSON schema

{ "type":"object",

"properties": { "city": { "type":"string" },

"street": { "type":"string" },

"building": { "type":"number",

"minimum":1 }

}

validates well the following objects:

{ "city":"Dapto","street":"Station","building":7}

It is because

- a key "city" is associated with string a value and JSON schema does not impose any restrictions on the size of a string,

- a key "street" is associated with a string value and JSON schema does not impose any restrictions on the size of a string,

- a is key "building" is associated with a number value and JSON schema does not impose any restrictions on the size of a number

{ "city":"Dapto","street":"Station"}

It is because

- a key "city" is associated with string a value and JSON schema does not impose any restrictions on the size of a string,

- a key "street" is associated with a string value and JSON schema does not impose any restrictions on the size of a string,

- an object does not contain a key:value pair where a key is "building", hence a property of "building" does not apply to the object

{ "city":"Dapto","street":"Station","building":7,"type":"skyscraper"}

It is because

- a key "city" is associated with string a value and JSON schema does not impose any restrictions on the size of a string,

- a key "street" is associated with a string value and JSON schema does not impose any restrictions on the size of a string,

- a is key "type" is associated with a number value and JSON schema does not impose any restrictions on a key "type"

{ }

Object

A key properties can be used to impose the constraints on some or all of key:value pairs an object consists of
A key properties is associated with an object that consists of key:value pairs where each key is a name of a property and each value is a JSON schema used to validate a property

For example JSON schema

{ "type":"object",
  "properties": { "city": { "type":"string" },
                  "street": { "type":"string" },       
                  "building": { "type":"number", "minimum":1 }
                }
}

validates well the objects

{ "city":"Dapto","street":"Station","building":7}

{ "city":"Dapto","street":"Station"}

{ "city":"Dapto","street":"Station","building":7,"type":"skyscraper"}

{ }

A key "additionalProperties" in JSON schema determines whether additional properties not listed in JSON schema are allowed. A default value associated with a key "additionalProperties" is true. It means that an object ma have key:value pairs not listed in JSON schema

For example JSON schema

{ "type":"object",

"properties": { "city": { "type":"string" },

"street": { "type":"string" },

"building": { "type":"number","minimum":1 }

"additionalProperties":false

validates well the objects

{ "city":"Dapto","street":"Station","building":7}

It is because

- all keys included in an object are listed in JSON schema

{ "city":"Dapto","street":"Station"}

It is because

- a key "building" is missing from an object and a default interpretation of missing keys ("requiredProperties key in JSON schema, see next slide) is false. It means that an object does not need to have the keys listed in JSON schema

{ }

It is because

- a default interpretation of missing keys ("requiredProperties key in JSON schema, see next slide) is false. It means that an object does not need to have the keys listed in JSON schema

An object

{ "city":"Dapto","street":"Station","building":7,"type":"skyscraper"}

does not validate well against JSON schema listed above because the object contains a key:value pair "type":"skyscraper" which is not listed in JSON schema and a key "additionalProperties" is associated with a value false in the schema

Object

A key additionalProperties determines whether additional properties not listed in JSON schema are allowed

For example JSON schema

{ "type":"object",
  "properties": { "city": { "type":"string" },
                  "street": { "type":"string" },       
                  "building": { "type":"number",
                                "minimum":1 }
                },
  "additionalProperties":false
}

validates well the objects

{ "city":"Dapto","street":"Station","building":7}

{ "city":"Dapto","street":"Station"}

{ }

It does not validate well an object

{ "city":"Dapto","street":"Station","building":7,"type":"skyscraper"}

A key "requiredProperties" determines the compulsory properties of an object. A default value associated with a key "requiredProperties" is []. It means that in such a case none of the properties in JSON schema is required to be in an object

For example JSON schema=

{ "type":"object",

"properties": { "city": { "type":"string" },

"street": { "type":"string" },

"building": { "type":"number", "minimum":1 }

"requiredProperties": ["city","street"]

}

validates well the objects

{ "city":"Dapto","street":"Station","type":"skyscraper"}

It is because both required keys "city","street" are included in an object and a key "building" is not required in an object. A default value associated with "additionalProperties: is true and it means that a key "type" does not need to be validated in JSON schema

{ "city":"Dapto","street":"Station"}

It is because both required keys "city","street" are included in an object and a value associated with a key "building" validates well.

It does not validate well an object

{ "city":"Dapto","building":7,"type":"skyscraper"}

because a key "street" is missing from an object

Object

A key requiredProperties determines the compulsory properties of an object

For example JSON schema

{ "type":"object",
  "properties": { "city": { "type":"string" },
                  "street": { "type":"string" },       
                  "building": { "type":"number","minimum":1 }
                },
  "requiredProperties": ["city","street"]
}

validates well the objects

{ "city":"Dapto","street":"Station","type":"skyscraper"}

{ "city":"Dapto","street":"Station","building":7}

It does not validate well an object

{ "city":"Dapto","building":7,"type":"skyscraper"}

Object

The keys minProperties and maxProperties determine the minimum and maximum number of properties of an object

For example JSON schema

{ "type":"object",
  "properties": { "city": { "type":"string" },
                  "street": { "type":"string" },       
                  "building": { "type":"number","minimum":1 }
                },
  "minProperties": 2,
  "maxProperties": 3
}

validates well the objects

{ "city":"Dapto","street":"Station","building":7}

{ "city":"Dapto","street":"Station"}

{ "street":"Station","building":7}

It does not validate well an object

{ "city":"Dapto","street":"Station","building":7,"type":"skyscraper"}

A key "dependencies" determine the existence dependencies of one property on another. For example if a key "a" is in an object then both keys "b" and "c" must be present in the same object. However, if a key "a" is not present in. an object then the keys "b" and "c" can be present or not

A value associated with a key "dependencies" is an object

Each entry in the object maps from a name of a property into an array of properties that are required whenever the property is present

For example JSON schema

{ "type":"object",

"properties": { "city": { "type":"string" },

"street": { "type":"string" },

"building": { "type":"number",

"minimum":1 }

"dependencies": { "street": ["building"]} }

validates well the objects

{ "city":"Dapto","street":"Station","building":7}

It is because an object has a key "street" and then it also must have a key "building". It may also have some other properties because a default value associated with "additionalProperties" is true

{ "street":"Station","building":7}

It is because an object has a key "street" and then it also must have a key "building"

{ "city":"Dapto","building":7}

It is because an object has no key "street"

It does not validate well an object

{ "city":"Dapto","street":"Station"}

It is because a key "street" is present and a key "building" required together with a key "street" is absent

Object

A key dependencies determine the existence dependencies of one property on another
A value associated with a key dependencies is an object
Each entry in the object maps from a name of a property into an array of properties that are required whenever the property is present

For example JSON schema

{ "type":"object",
  "properties": { "city": { "type":"string" },
                  "street": { "type":"string" },       
                  "building": { "type":"number",
                                "minimum":1 }
                },
  "dependencies": { "street": ["building"]} }

validates well the objects

{ "city":"Dapto","street":"Station","building":7}

{ "street":"Station","building":7}

{ "city":"Dapto","building":7}

A key "patternProperties" determines a syntax of key names in an object. A value associated with a "key patternProperties" is an object. The regular expressions can be used determine the valid names of the keys in a document. If a key "a" is equivalent to a key "A" then it van be represented by the following regular expression "^(a|A)"

For example JSON schema

{ "type":"object",

"patternProperties": { "^(city|CITY)": { "type":"string" },

"^(street|STREET)": { "type":"string" },

"^(building|BUILDING)": { "type":"number",

"minimum":1 }

"additionalProperties":false }

}

validates well the objects

{ "city":"Dapto","STREET":"Station","building":7}

{ "street":"Station","BUILDING":7}

{ "CITY":"Dapto","BUILDING":7}

It is because both uppercase and lowercase names of keys "street", "city" and "building" are allowed in JSON schema

{ }

It is because a default values associated with "requiredProperties"is [] and none of the properties is required

It does not validate well an object

{ "City":"Dapto","street":"Station"}

It is because a key "City" does not match a regular expression"^(city|CITY)" and a key "additionalProperties" is associated with a value false (no other keys apart from the keys matching the given regular expressions are allowed)

Object

A key patternProperties determines a syntax of key names in an object
A value associated with a key patternProperties is an object

For example JSON schema

{ "type":"object",
  "patternProperties": { "^(city|CITY)": { "type":"string" }, 
                         "^(street|STREET)": { "type":"string" },       
                         "^(building|BUILDING)": { "type":"number",
                                                   "minimum":1 }
                       },
  "additionalProperties":false }
}

validates well the objects

{ "city":"Dapto","STREET":"Station","building":7}

{ "street":"Station","BUILDING":7}

{ "CITY":"Dapto","BUILDING":7}

{ }

JSON Schema

Outline

JSON Schema ? What is it ?
Basics
Types
String
Numeric types
Null
Object
Array
Combined schemas

Array

A type array determines a type of a respective value as array
For example

validates well any array, like for example


[1, 2, 3, 4, 5, 6, 7]


["ab", "cde", "efgh", "ijklm"]


[ [1, 2, 3], [4, 5, 6], [7, 8, 9] ]

[ ]

Array

A key items determines a type of values in an array

For example

	      
{ "type":"array",
  "items": { "type":"string" }
}

validates well any array of strings like


["ab", "cde", "ab", "ijklm"]


["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]

[ ]

Tuple validation determines a type of values when an array is a collection of items, each item has a different schema, and position of each item is important. If a keyword "items" is associated with an array of types then each type in an array validates the respective data element in an array being validated

For example

{ "type":"array",

"items": [ { "type":"string" },

{ "type":"number",

"minimum":1} ],

"additionalItems":false

}

validates well any array of values like

["Station St.", 25]

It is becausethe first element in an array of types associated with a key "items" is of type "string" and the second element is of type "number"

It also validates well and array of values like

["Victoria St."]

It is because the first element in an array of types associated with a key "items" is of type "string"

It also validates well an empty array

[ ]

It is because none of the elements in an empty array break a validation determined by a tuple validation

Array

Tuple validation determines a type of values when an array is a collection of items, each item has a different schema, and position of each item is important

For example

	      
{ "type":"array",
  "items": [ { "type":"string" },
             { "type":"number",
               "minimum":1} ],
  "additionalItems":false
}

validates well any array of values like


["Station St.", 25]


["Victoria St."]

[ ]

Array

A key uniqueItems requires each item in an array to be unique

For example

	      
{ "type":"array",
  "items": { "type":"string" },
  "uniqueItems":true
}

validates well any array of strings like


["ab", "cde", "efgh", "ijklm"]


[ "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ]

[ ]

The keys "minItems" and "maxItems" determine a size of an array. An array must have at least the total number of elements equal to a number associated with a key "minItems". An array must have at most the total number of elements equal to a number associated with akey "maxItems"

For example

{ "type":"array",

"items": { "type":"string" },

"uniqueItems":true,

"minItems":3,

"maxItems":5

}

validates well any array of strings like

["ab", "cde", "efgh", "ijklm"]

It is because all elements in an array are strings, all of them are different and an array contains 4 elements. It is more or equal 3 and less or equal 5

[ "0", "1", "2", "3", "4" ]

It is because all elements in an array are strings, all of them are different and an array contains 5 elements. It is more or equal 3 and less or equal 5

Array

The keys minItems and maxItems determine a size of an array

For example

	      
{ "type":"array",
  "items": { "type":"string" },
  "uniqueItems":true,
  "minItems":3,
  "maxItems":5
}

validates well any array of strings like


["ab", "cde", "efgh", "ijklm"]


[ "0", "1", "2", "3", "4" ]

JSON Schema

Outline

JSON Schema ? What is it ?
Basics
Types
String
Numeric types
Boolean
Null
Object
Array
Combined schemas

The keys "anyOf", "allOff" and "oneOff" can be used to combine JSON Schemas together. Sometimes we may wish to say that an element is either of type "string or of type "Boolean"

For example "anyOf" keyword can be used to validate JSON object against one or more of the given schemas. In such a case a keyword "anyOf" as associated with an array of well formed JSON schemas

For example

{ "anyOf": [ {"type":"string",

"maxLength":5},

{"type":"boolean"} ]

}

validates well the objects like strings up to 5 characters long or Boolean values true or false

It is because a key "anyOf" is associated with an array of two validation types: string with maximum length equal to 5 and Boolean

A key "anyOf" allows for representation of a union of overlapping types, see an example in the next slide

Combined schemas

The keys anyOf, allOf and oneOf can be used to combine JSON Schemas together

For example anyOf keyword can be used to validate JSON object against one or more of the given schemas

	      
{ "anyOf": [ {"type":"string",
              "maxLength":5},
             {"type":"boolean"} ]
}

validates well the objects like strings up to 5 characters long or Boolean values true or false

For example "anyOf" keyword can be used to validate JSON object against one or more of the given schemas

For example, JSON schema

{ "anyOf": [ {"type":"string",

"maxLength":5},

{"type":"string",

"minLength":3} ]

}

validates well any string. It is because the first element

{"type":"string",

"maxLength":5}

validates well any string not longer than 5 characters including an empty string. While the second element validates well any string that is at least 3 characters long. A string that is 4 characters long is validated well by both schemas. It is all right because of a keyword "anyOf"

If a keyword "oneOf" is used like in a case below

{ "oneOf": [ {"type":"string",

"maxLength":5},

{"type":"string",

"minLength":3} ]

}

then a string that is 4 characters long does not validated well with such JSON schema

Combined schemas

For example anyOf keyword can be used to validate JSON object against one or more of the given schemas

     
{ "anyOf": [ {"type":"string",
              "maxLength":5},
             {"type":"string",
              "minLength":3} ]
}

validates well any string

Combined schemas

The keys anyOf, allOf and oneOf can be used to combine JSON Schemas together

For example allOf keyword can be used to validate JSON object against all of the given schemas

	      
{ "allOf": [ {"type":"string",
              "maxLength":5},
             {"type":"string",
              "minLength":3} ]
}

validates well any string no longer than 5 characters and no shorter than 3 characters

Combined schemas

The keys anyOf, allOf and oneOf can be used to combine JSON Schemas together

For example oneOf keyword can be used to validate JSON object against exactly one of the given schemas

     
{ "oneOf": [ {"type":"string",
              "maxLength":5},
             {"type":"string",
              "minLength":3} ]
}

validates well either any string longer than 5 characters or shorter than 3 characters

JSON Schema

Outline

JSON Schema ? What is it ?

JSON Schema

Outline

Basics

Basics

JSON Schema

Outline

Types

JSON Schema

Outline

String

String

JSON Schema

Outline

Numeric types

Numeric types

Numeric types

JSON Schema

Outline

Boolean

JSON Schema

Outline

Null

JSON Schema

Outline

Object

Object

Object

Object

Object

Object

Object

JSON Schema

Outline

Array

Array

Array

Array

Array

JSON Schema

Outline

Combined schemas

Combined schemas

Combined schemas

Combined schemas

References