OPENJSON (Transact-SQL)OPENJSON (Transact-SQL)

SI APPLICA A: sìSQL Server (a partire dalla versione 2016) sìDatabase SQL di Azure noAzure SQL Data Warehouse noParallel Data Warehouse APPLIES TO: yesSQL Server (starting with 2016) yesAzure SQL Database noAzure SQL Data Warehouse noParallel Data Warehouse

OPENJSON è una funzione con valori di tabella che analizza il testo JSON e restituisce gli oggetti e le proprietà dell'input JSON come righe e colonne.OPENJSON is a table-valued function that parses JSON text and returns objects and properties from the JSON input as rows and columns. In altre parole, OPENJSON offre una visualizzazione di set di righe in un documento JSON.In other words, OPENJSON provides a rowset view over a JSON document. È possibile specificare in modo esplicito le colonne nel set di righe e i percorsi delle proprietà JSON usate per popolare le colonne.You can explicitly specify the columns in the rowset and the JSON property paths used to populate the columns. Poiché OPENJSON restituisce un set di righe, è possibile usare OPENJSON nella clausola FROM di un'istruzione Transact-SQLTransact-SQL nello stesso modo in cui è possibile usare qualsiasi altra tabella, visualizzazione o funzione con valori di tabella.Since OPENJSON returns a set of rows, you can use OPENJSON in the FROM clause of a Transact-SQLTransact-SQL statement just as you can use any other table, view, or table-valued function.

Usare OPENJSON per importare i dati JSON in SQL ServerSQL Server o convertire dati JSON in formato relazionale per un'app o un servizio che non può usare direttamente JSON.Use OPENJSON to import JSON data into SQL ServerSQL Server, or to convert JSON data to relational format for an app or service that can't consume JSON directly.

Nota

La funzione OPENJSON è disponibile solo nel livello di compatibilità 130 o superiore.The OPENJSON function is available only under compatibility level 130 or higher. Se il livello di compatibilità del database è inferiore a 130, SQL Server non riesce a trovare e a eseguire la funzione OPENJSON.If your database compatibility level is lower than 130, SQL Server can't find and run the OPENJSON function. Altre funzioni JSON sono disponibili in tutti i livelli di compatibilità.Other JSON functions are available at all compatibility levels.

È possibile controllare il livello di compatibilità nella vista sys.databases o nelle proprietà del database.You can check compatibility level in the sys.databases view or in database properties. È possibile modificare il livello di compatibilità di un database con il comando seguente:You can change the compatibility level of a database with the following command:

ALTER DATABASE DatabaseName SET COMPATIBILITY_LEVEL = 130

Il livello di compatibilità 120 può essere predefinito anche in un nuovo database SQL di Microsoft Azure.Compatibility level 120 may be the default even in a new Azure SQL Database.

Icona di collegamento a un argomentoConvenzioni della sintassi Transact-SQLTopic link iconTransact-SQL Syntax Conventions

SintassiSyntax

OPENJSON( jsonExpression [ , path ] )  [ <with_clause> ]

<with_clause> ::= WITH ( { colName type [ column_path ] [ AS JSON ] } [ ,...n ] )

La funzione con valori di tabella OPENJSON analizza jsonExpression specificato come primo argomento e restituisce una o più righe contenenti i dati degli oggetti JSON nell'espressione.The OPENJSON table-valued function parses the jsonExpression provided as the first argument and returns one or more rows containing data from the JSON objects in the expression. jsonExpression può contenere oggetti secondari nidificati.jsonExpression can contain nested sub-objects. Se si vuole analizzare un oggetto secondario dall'interno di jsonExpression, è possibile specificare un parametro path per l'oggetto secondario JSON.If you want to parse a sub-object from within jsonExpression, you can specify a path parameter for the JSON sub-object.

openjsonopenjson

Sintassi per OPENJSON TVFSyntax for OPENJSON TVF

Per impostazione predefinita, la funzione con valori di tabella OPENJSON restituisce tre colonne che contengono il nome della chiave, il valore e il tipo di ogni coppia {chiave:valore} trovato in jsonExpression.By default, the OPENJSON table-valued function returns three columns, which contain the key name, the value, and the type of each {key:value} pair found in jsonExpression. In alternativa, è possibile specificare in modo esplicito lo schema del set di risultati che OPENJSON restituisce fornendo with_clause.As an alternative, you can explicitly specify the schema of the result set that OPENJSON returns by providing with_clause.

with_clausewith_clause

Sintassi per la clausola WITH in OPENJSON TVFSyntax for WITH clause in OPENJSON TVF

with_clause contiene un elenco delle colonne con i relativi tipi che devono essere restituite da OPENJSON.with_clause contains a list of columns with their types for OPENJSON to return. Per impostazione predefinita, OPENJSON ricerca la corrispondenza delle chiavi in jsonExpression con i nomi di colonna in with_clause (in questo caso, la ricerca della corrispondenza delle chiavi implica che viene fatta distinzione tra maiuscole e minuscole).By default, OPENJSON matches keys in jsonExpression with the column names in with_clause (in this case, matches keys implies that it is case sensitive). Se un nome di colonna non corrisponde al nome di una chiave, è possibile specificare un valore column_path facoltativo che è costituito da un'espressione di percorso JSON che fa riferimento a una chiave all'interno di jsonExpression.If a column name does not match a key name, you can provide an optional column_path, which is a JSON Path Expression that references a key within the jsonExpression.

ArgomentiArguments

jsonExpressionjsonExpression

Espressione di caratteri Unicode contenente testo JSON.Is a Unicode character expression containing JSON text.

OPENJSON esegue l'iterazione sugli elementi della matrice o sulle proprietà dell'oggetto nell'espressione JSON e restituisce una riga per ogni elemento o proprietà.OPENJSON iterates over the elements of the array or the properties of the object in the JSON expression and returns one row for each element or property. L'esempio seguente restituisce ogni proprietà dell'oggetto specificato come jsonExpression:The following example returns each property of the object provided as jsonExpression:

DECLARE @json NVARCHAR(4000) = N'{  
   "StringValue":"John",  
   "IntValue":45,  
   "TrueValue":true,  
   "FalseValue":false,  
   "NullValue":null,  
   "ArrayValue":["a","r","r","a","y"],  
   "ObjectValue":{"obj":"ect"}  
}'

SELECT *
FROM OPENJSON(@json)

RisultatiResults

Keykey Valorevalue Tipotype
StringValueStringValue JohnJohn 11
IntValueIntValue 4545 22
TrueValueTrueValue truetrue 33
FalseValueFalseValue falsefalse 33
NullValueNullValue NULLNULL 00
ArrayValueArrayValue ["a","r","r","a","y"]["a","r","r","a","y"] 44
ObjectValueObjectValue {"obj":"ect"}{"obj":"ect"} 55

pathpath

Espressione di percorso JSON facoltativa che fa riferimento a un oggetto o a una matrice all'interno di jsonExpression.Is an optional JSON path expression that references an object or an array within jsonExpression. OPENJSON esegue la ricerca nel testo JSON nella posizione specificata e analizza solo il frammento cui viene fatto riferimento.OPENJSON seeks into the JSON text at the specified position and parses only the referenced fragment. Per altre informazioni, vedere Espressioni di percorso JSON (SQL Server).For more info, see JSON Path Expressions (SQL Server).

In SQL Server 2017 (14.x)SQL Server 2017 (14.x) e in Database SQL di AzureAzure SQL Database è possibile specificare una variabile come valore di path.In SQL Server 2017 (14.x)SQL Server 2017 (14.x) and in Database SQL di AzureAzure SQL Database, you can provide a variable as the value of path.

L'esempio seguente restituisce un oggetto nidificato tramite la specifica di path:The following example returns a nested object by specifying the path:

DECLARE @json NVARCHAR(4000) = N'{  
      "path": {  
            "to":{  
                 "sub-object":["en-GB", "en-UK","de-AT","es-AR","sr-Cyrl"]  
                 }  
              }  
 }';

SELECT [key], value
FROM OPENJSON(@json,'$.path.to."sub-object"')

RisultatiResults

KeyKey valoreValue
00 en-GBen-GB
11 en-UKen-UK
22 de-ATde-AT
33 es-ARes-AR
44 sr-Cyrlsr-Cyrl

Quando OPENJSON analizza una matrice JSON, la funzione restituisce gli indici degli elementi nel testo JSON come chiavi.When OPENJSON parses a JSON array, the function returns the indexes of the elements in the JSON text as keys.

Il confronto usato per la ricerca delle corrispondenze dei passaggi di percorso con le proprietà dell'espressione JSON fa distinzione tra maiuscole e minuscole e non considera le regole di confronto (ovvero è un confronto BIN2).The comparison used to match path steps with the properties of the JSON expression is case-sensitive and collation-unaware (that is, a BIN2 comparison).

with_clausewith_clause

Definisce in modo esplicito lo schema di output che deve essere restituito dalla funzione OPENJSON.Explicitly defines the output schema for the OPENJSON function to return. with_clause può contenere gli elementi seguenti:The optional with_clause can contain the following elements:

colName Nome della colonna di output.colName Is the name for the output column.

Per impostazione predefinita, OPENJSON usa il nome della colonna per cercare una corrispondenza con una proprietà nel testo JSON.By default, OPENJSON uses the name of the column to match a property in the JSON text. Ad esempio, se si specifica la colonna name nello schema, OPENJSON tenta di popolare la colonna con la proprietà "name" nel testo JSON.For example, if you specify the column name in the schema, OPENJSON tries to populate this column with the property "name" in the JSON text. È possibile eseguire l'override di questo mapping predefinito usando l'argomento column_path.You can override this default mapping by using the column_path argument.

typetype
Tipo di dati della colonna di output.Is the data type for the output column.

Nota

Se viene usata anche l'opzione AS JSON, il valore type della colonna deve essere NVARCHAR(MAX).If you also use the AS JSON option, the column type must be NVARCHAR(MAX).

column_pathcolumn_path
Percorso JSON che specifica la proprietà da restituire nella colonna specificata.Is the JSON path that specifies the property to return in the specified column. Per altre informazioni, vedere la descrizione del parametro path in precedenza in questo argomento.For more info, see the description of the path parameter previously in this topic.

Usare column_path per eseguire l'override delle regole di mapping predefinite quando il nome di una colonna di output non corrisponde al nome della proprietà.Use column_path to override default mapping rules when the name of an output column doesn't match the name of the property.

Il confronto usato per la ricerca delle corrispondenze dei passaggi di percorso con le proprietà dell'espressione JSON fa distinzione tra maiuscole e minuscole e non considera le regole di confronto (ovvero è un confronto BIN2).The comparison used to match path steps with the properties of the JSON expression is case-sensitive and collation-unaware (that is, a BIN2 comparison).

Per altre informazioni sui percorsi, vedere Espressioni di percorso JSON (SQL Server).For more info about paths, see JSON Path Expressions (SQL Server).

AS JSONAS JSON
Usare l'opzione AS JSON nella definizione di una colonna per specificare che la proprietà cui viene fatto riferimento contiene un oggetto JSON interno o una matrice.Use the AS JSON option in a column definition to specify that the referenced property contains an inner JSON object or array. Se si specifica l'opzione AS JSON, il tipo della colonna deve essere NVARCHAR(MAX).If you specify the AS JSON option, the type of the column must be NVARCHAR(MAX).

  • Se non si specifica AS JSON per una colonna, la funzione restituisce un valore scalare (ad esempio, int, string, true, false) della proprietà JSON specificata nel percorso specificato.If you don't specify AS JSON for a column, the function returns a scalar value (for example, int, string, true, false) from the specified JSON property on the specified path. Se il percorso rappresenta un oggetto o una matrice e la proprietà non viene trovata nel percorso specificato, la funzione restituisce Null in modalità lax oppure restituisce un errore in modalità strict.If the path represents an object or an array, and the property can't be found at the specified path, the function returns null in lax mode or returns an error in strict mode. Questo comportamento è simile al comportamento della funzione JSON_VALUE.This behavior is similar to the behavior of the JSON_VALUE function.

  • Se si specifica AS JSON per una colonna, la funzione restituisce un frammento JSON della proprietà JSON specificata nel percorso specificato.If you specify AS JSON for a column, the function returns a JSON fragment from the specified JSON property on the specified path. Se il percorso rappresenta un valore scalare e la proprietà non viene trovata nel percorso specificato, la funzione restituisce Null in modalità lax oppure restituisce un errore in modalità strict.If the path represents a scalar value, and the property can't be found at the specified path, the function returns null in lax mode or returns an error in strict mode. Questo comportamento è simile al comportamento della funzione JSON_QUERY.This behavior is similar to the behavior of the JSON_QUERY function.

Nota

Se si vuole restituire un frammento JSON nidificato di una proprietà JSON, è necessario specificare il flag AS JSON.If you want to return a nested JSON fragment from a JSON property, you have to provide the AS JSON flag. Senza questa opzione, se la proprietà non viene trovata, OPENJSON restituisce un valore NULL anziché l'oggetto JSON o una matrice cui viene fatto riferimento oppure restituisce un errore di run-time in modalità strict.Without this option, if the property can't be found, OPENJSON returns a NULL value instead of the referenced JSON object or array, or it returns a run-time error in strict mode.

Ad esempio, la query seguente restituisce e formatta gli elementi di una matrice:For example, the following query returns and formats the elements of an array:

DECLARE @json NVARCHAR(MAX) = N'[  
  {  
    "Order": {  
      "Number":"SO43659",  
      "Date":"2011-05-31T00:00:00"  
    },  
    "AccountNumber":"AW29825",  
    "Item": {  
      "Price":2024.9940,  
      "Quantity":1  
    }  
  },  
  {  
    "Order": {  
      "Number":"SO43661",  
      "Date":"2011-06-01T00:00:00"  
    },  
    "AccountNumber":"AW73565",  
    "Item": {  
      "Price":2024.9940,  
      "Quantity":3  
    }  
  }
]'  
   
SELECT *
FROM OPENJSON ( @json )  
WITH (   
              Number   varchar(200)   '$.Order.Number',  
              Date     datetime       '$.Order.Date',  
              Customer varchar(200)   '$.AccountNumber',  
              Quantity int            '$.Item.Quantity',  
              [Order]  nvarchar(MAX)  AS JSON  
 )

RisultatiResults

NumberNumber dateDate CustomerCustomer QuantityQuantity JSONOrder
SO43659SO43659 2011-05-31T00:00:002011-05-31T00:00:00 AW29825AW29825 11 {"Number":"SO43659","Date":"2011-05-31T00:00:00"}{"Number":"SO43659","Date":"2011-05-31T00:00:00"}
SO43661SO43661 2011-06-01T00:00:002011-06-01T00:00:00 AW73565AW73565 33 {"Number":"SO43661","Date":"2011-06-01T00:00:00"}{"Number":"SO43661","Date":"2011-06-01T00:00:00"}

Valore restituitoReturn Value

Le colonne restituite dalla funzione OPENJSON dipendono dall'opzione WITH.The columns that the OPENJSON function returns depend on the WITH option.

  1. Quando si chiama OPENJSON con lo schema predefinito, ovvero non si specifica uno schema esplicito nella clausola WITH, la funzione restituisce una tabella con le colonne seguenti:When you call OPENJSON with the default schema - that is, when you don't specify an explicit schema in the WITH clause - the function returns a table with the following columns:

    1. Key.Key. Valore nvarchar(4000) che contiene il nome della proprietà specificata o l'indice dell'elemento nella matrice specificata.An nvarchar(4000) value that contains the name of the specified property or the index of the element in the specified array. La colonna Key ha regole di confronto BIN2.The key column has a BIN2 collation.

    2. Valore.Value. Valore nvarchar(max) che contiene il valore della proprietà.An nvarchar(max) value that contains the value of the property. La colonna Value eredita le regole di confronto da jsonExpression.The value column inherits its collation from jsonExpression.

    3. Type.Type. Valore int che contiene il tipo del valore.An int value that contains the type of the value. La colonna Type viene restituita solo quando OPENJSON viene usata con lo schema predefinito.The Type column is returned only when you use OPENJSON with the default schema. La colonna Type include uno dei valori seguenti:The type column has one of the following values:

      Valore della colonna TypeValue of the Type column Tipo di dati JSONJSON data type
      00 nullnull
      11 stringstring
      22 INTint
      33 true/falsetrue/false
      44 arrayarray
      55 oggettoobject

    Vengono restituite solo le proprietà di primo livello.Only first-level properties are returned. L'istruzione ha esito negativo se il testo JSON non è formattato correttamente.The statement fails if the JSON text is not properly formatted.

  2. Quando si chiama OPENJSON e si specifica uno schema esplicito nella clausola WITH, la funzione restituisce una tabella con lo schema definito nella clausola WITH.When you call OPENJSON and you specify an explicit schema in the WITH clause, the function returns a table with the schema that you defined in the WITH clause.

RemarksRemarks

json_path usato nel secondo argomento di OPENJSON o in with_clause può iniziare con la parola chiave lax o strict.json_path used in the second argument of OPENJSON or in with_clause can start with the lax or strict keyword.

  • In modalità lax, OPENJSON non genera un errore se non viene trovato l'oggetto o il valore nel percorso specificato.In lax mode, OPENJSON doesn't raise an error if the object or value on the specified path can't be found. Se il percorso non viene trovato, OPENJSON restituisce un set di risultati vuoto o un valore NULL.If the path can't be found, OPENJSON returns either an empty result set or a NULL value.
  • In modalità strict, OPENJSON restituisce un errore se il percorso non viene trovato.In strict, mode OPENJSON returns an error if the path can't be found.

Alcuni esempi in questa pagina specificano in modo esplicito la modalità di percorso, ovvero lax o strict.Some of the examples on this page explicitly specify the path mode, lax or strict. La modalità di percorso è facoltativa.The path mode is optional. Se non si specifica in modo esplicito una modalità di percorso, la modalità lax è la modalità predefinita.If you don't explicitly specify a path mode, lax mode is the default. Per altre informazioni sulla modalità di percorso e le espressioni di percorso, vedere Espressioni di percorso JSON (SQL Server).For more info about path mode and path expressions, see JSON Path Expressions (SQL Server).

Viene cercata la corrispondenza dei nomi di colonna in with_clause con le chiavi nel testo JSON.Column names in with_clause are matched with keys in the JSON text. Se si specifica il nome di colonna [Address.Country], viene cercata la corrispondenza con la chiave Address.Country.If you specify the column name [Address.Country], it's matched with the key Address.Country. Se si vuole fare riferimento a una chiave nidificata Country all'interno dell'oggetto Address, è necessario specificare il percorso $.Address.Country nel percorso di colonna.If you want to reference a nested key Country within the object Address, you have to specify the path $.Address.Country in column path.

json_path può contenere chiavi con caratteri alfanumerici.json_path may contain keys with alphanumeric characters. Se sono presenti caratteri speciali nelle chiavi, specificare il nome della chiave in json_path con virgolette doppie.Escape the key name in json_path with double quotes if you have special characters in the keys. Ad esempio, $."my key $1".regularKey."key with . dot" corrisponde al valore 1 nel testo JSON seguente:For example, $."my key $1".regularKey."key with . dot" matches value 1 in the following JSON text:

{
  "my key $1": {
    "regularKey":{
      "key with . dot": 1
    }
  }
}

EsempiExamples

Esempio 1: convertire una matrice JSON in una tabella temporaneaExample 1 - Convert a JSON array to a temporary table

L'esempio seguente visualizza un elenco di identificatori come matrice JSON di numeri.The following example provides a list of identifiers as a JSON array of numbers. La query converte la matrice JSON in una tabella di identificatori e filtra tutti i prodotti con gli ID specificati.The query converts the JSON array to a table of identifiers and filters all products with the specified ids.

DECLARE @pSearchOptions NVARCHAR(4000) = N'[1,2,3,4]'

SELECT *
FROM products
INNER JOIN OPENJSON(@pSearchOptions) AS productTypes
 ON product.productTypeID = productTypes.value

La query corrisponde all'esempio seguente.This query is equivalent to the following example. Tuttavia, nell'esempio seguente, è necessario incorporare i numeri nella query anziché passarli come parametri.However, in the example below, you have to embed numbers in the query instead of passing them as parameters.

SELECT *
FROM products
WHERE product.productTypeID IN (1,2,3,4)

Esempio 2: unire le proprietà di due oggetti JSONExample 2 - Merge properties from two JSON objects

L'esempio seguente seleziona un'unione di tutte le proprietà di due oggetti JSON.The following example selects a union of all the properties of two JSON objects. I due oggetti hanno una proprietà name duplicata.The two objects have a duplicate name property. L'esempio usa il valore di chiave per escludere la riga duplicata dai risultati.The example uses the key value to exclude the duplicate row from the results.

DECLARE @json1 NVARCHAR(MAX),@json2 NVARCHAR(MAX)

SET @json1=N'{"name": "John", "surname":"Doe"}'

SET @json2=N'{"name": "John", "age":45}'

SELECT *
FROM OPENJSON(@json1)
UNION ALL
SELECT *
FROM OPENJSON(@json2)
WHERE [key] NOT IN (SELECT [key] FROM OPENJSON(@json1))

Esempio 3: unire in join le righe con i dati JSON memorizzati nelle celle di tabella usando CROSS APPLYExample 3 - Join rows with JSON data stored in table cells using CROSS APPLY

Nell'esempio seguente la tabella SalesOrderHeader ha una colonna di testo SalesReason che contiene una matrice di SalesOrderReasons in formato JSON.In the following example, the SalesOrderHeader table has a SalesReason text column that contains an array of SalesOrderReasons in JSON format. Gli oggetti SalesOrderReasons contengono proprietà come Quality e Manufacturer.The SalesOrderReasons objects contain properties like Quality and Manufacturer. L'esempio crea un report che unisce ogni riga dell'ordine di vendita ai motivi di vendita correlati.The example creates a report that joins every sales order row to the related sales reasons. L'operatore OPENJSON espande la matrice JSON dei motivi di vendita come se fossero archiviati in una tabella figlio separata.The OPENJSON operator expands the JSON array of sales reasons as if the reasons were stored in a separate child table. L'operatore CROSS APPLY unisce ogni riga dell'ordine di vendita alle righe restituite dalla funzione con valori di tabella OPENJSON.Then the CROSS APPLY operator joins each sales order row to the rows returned by the OPENJSON table-valued function.

SELECT SalesOrderID,OrderDate,value AS Reason
FROM Sales.SalesOrderHeader
CROSS APPLY OPENJSON(SalesReasons)

Suggerimento

Quando è necessario espandere le matrici JSON memorizzate in singoli campi e unirle alle relative righe padre, viene in genere usato l'operatore CROSS APPLY Transact-SQLTransact-SQL.When you have to expand JSON arrays stored in individual fields and join them with their parent rows, you typically use the Transact-SQLTransact-SQL CROSS APPLY operator. Per altre informazioni su CROSS APPLY, vedere FROM (Transact-SQL).For more info about CROSS APPLY, see FROM (Transact-SQL).

La stessa query può essere riscritta usando OPENJSON con uno schema definito in modo esplicito delle righe da restituire:The same query can be rewritten by using OPENJSON with an explicitly defined schema of rows to return:

SELECT SalesOrderID, OrderDate, value AS Reason  
FROM Sales.SalesOrderHeader  
     CROSS APPLY OPENJSON (SalesReasons) WITH (value nvarchar(100) '$')

In questo esempio il percorso $ fa riferimento a ogni elemento nella matrice.In this example, the $ path references each element in the array. Se si vuole eseguire in modo esplicito il cast del valore restituito, è possibile usare questo tipo di query.If you want to explicitly cast the returned value, you can use this type of query.

Esempio 4: combinare le righe relazionali e gli elementi JSON con CROSS APPLYExample 4 - Combine relational rows and JSON elements with CROSS APPLY

La query seguente combina le righe relazionali e gli elementi JSON nei risultati riportati nella tabella seguente.The following query combines relational rows and JSON elements into the results shown in the following table.

SELECT store.title, location.street, location.lat, location.long  
FROM store  
CROSS APPLY OPENJSON(store.jsonCol, 'lax $.location')   
     WITH (street varchar(500) ,  postcode  varchar(500) '$.postcode' ,  
     lon int '$.geo.longitude', lat int '$.geo.latitude')  
     AS location

RisultatiResults

titletitle streetstreet postcodepostcode lonlon latlat
Whole Food MarketsWhole Food Markets 17991 Redmond Way17991 Redmond Way WA 98052WA 98052 47.66612447.666124 -122.10155-122.10155
SearsSears 148th Ave NE148th Ave NE WA 98052WA 98052 47.6302447.63024 -122.141246,17-122.141246,17

Esempio 5: importare dati JSON in SQL ServerExample 5 - Import JSON data into SQL Server

Nell'esempio seguente viene caricato un intero oggetto JSON in una tabella SQL ServerSQL Server .The following example loads an entire JSON object into a SQL ServerSQL Server table.

DECLARE @json NVARCHAR(max)  = N'{  
  "id" : 2,  
  "firstName": "John",  
  "lastName": "Smith",  
  "isAlive": true,  
  "age": 25,  
  "dateOfBirth": "2015-03-25T12:00:00",  
  "spouse": null  
  }';  
   
  INSERT INTO Person  
  SELECT *   
  FROM OPENJSON(@json)  
  WITH (id int,  
        firstName nvarchar(50), lastName nvarchar(50),   
        isAlive bit, age int,  
        dateOfBirth datetime2, spouse nvarchar(50))

Vedere ancheSee Also

Espressioni di percorso JSON (SQL Server) JSON Path Expressions (SQL Server)
Convertire dati JSON in righe e colonne con la funzione OPENJSON (SQL Server) Convert JSON Data to Rows and Columns with OPENJSON (SQL Server)
Usare OPENJSON con lo schema predefinito (SQL Server) Use OPENJSON with the Default Schema (SQL Server)
Usare OPENJSON con uno schema esplicito (SQL Server)Use OPENJSON with an Explicit Schema (SQL Server)