La funzione di JSON_TABLE

JSON_TABLE è una funzione potente che permette la facile decomposizione di dati JavaScript Object Notation (JSON) in formato relazionale. Dopo aver fornito una breve panoramica di JSON, l'articolo spiega i quattro tipi di colonne di database che possono essere definiti utilizzando JSON_TABLE e fornisce esempi di utilizzo di JSON_TABLE per recuperare oggetti JSON dal web e processo che le informazioni in forma relazionale. A seguito di questi esempi, gli utenti del database possono facilmente importare dati JSON nella loro banca dati relazionale.

JSON_TABLE

Un popolare formato per lo scambio di informazioni su Internet è JavaScript Object Notation, comunemente noto come JSON. Uno dei motivi per l'utilizzo di JSON è la sua stretta integrazione con JavaScript, che è supportato dai browser web e ampiamente utilizzato per implementare applicazioni web. Inoltre, molte fonti di informazione sul web forniscono dati in formato JSON, permettendo JavaScript e altre applicazioni di consumare tali dati. Riconoscendo l'importanza di JSON come formato di interscambio dati, la versione più recente degli standard SQL include elementi del linguaggio SQL che lavorano con JSON. Uno degli elementi di linguaggio più potente è JSON_TABLE , che converte un oggetto JSON in una tabella relazionale. In questo modo le informazioni JSON di essere facilmente consumato da applicazioni di database, senza la necessità di scrivere un programma per analizzare il testo JSON.

Questo articolo inizia descrivendo brevemente il formato JSON. E poi spiega SQL / JSON espressioni di percorso, che forniscono i mezzi per individuare le informazioni all'interno di oggetti JSON. L'articolo spiega poi i diversi tipi di informazioni di colonna che può essere estratto usando JSON_TABLE . Infine, alcuni esempi dell'uso di JSON_TABLE in DB2 for i sono illustrate.

JSON_TABLE è disponibile su IBM DB2 for i per le versioni 7.2 e 7.3. Esso è fornito con il 7.2 Database Group PTF livello SI99702 14 e 7.3. Database livello di Gruppo PTF SI99703 3, che sono stati rilasciati nel novembre 2016.

JSON

Il formato di interscambio di dati JSON è stato standardizzato da Ecma International e lo standard è disponibile presso http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf . L'unità strutturale primario del JSON è l'oggetto e un oggetto JSON è rappresentato come una lista di coppie chiave-valore. Queste coppie chiave-valore sono separati da virgole e racchiusi tra parentesi graffe. In una coppia chiave-valore, due punti separa la chiave dal valore. Listato 1 mostra un oggetto JSON semplice che rappresenta il nome di una persona. In questo oggetto, le coppie chiave sono "first" e "John" , "middle"e "K" , e "last" e "Doe" .

{ "first" : "John" , "middle" : "K", "last" : "Doe" }

La chiave di una coppia chiave-valore deve essere una stringa, che è una sequenza di caratteri Unicode circondate da doppi apici.

Il valore di una coppia chiave-valore può essere uno dei seguenti:

  • String – "John"
  • Number – 567.12
  • Boolean value – true or false
  • No value – null
  • Object – { "middle-init" : K , "middle-full" : "Kevin" }
  • Array – [ "red", "green", "blue" ]

In JSON, un numero è un numero decimale con segno che può includere un esponente usando l'E notazione esponenziale. Un valore booleano o è il valore speciale vero o il falso valore speciale. Il valore speciale null indica un valore vuoto. Una serie JSON è costituito da un elenco di valori, separati da virgole, tra parentesi che racchiudono. Listato 2 mostra un semplice array JSON che contiene le stringhe "red" , "green" , e "blue" .

[ "red", "green", "blue" ]

Un oggetto JSON può utilizzare questi elementi in varie combinazioni per rappresentare le informazioni.Listato 3 mostra un oggetto JSON campione. In questo oggetto, ci sono cinque ultraperiferiche coppie chiave-valore, con i tasti "id" , "name" , "phones" , "lazy" , e "married" . Il valore per la prima coppia chiave-valore è il numero 901. Per la seconda coppia chiave-valore, il valore è un oggetto con i tasti "first", "middle" e "last" . Per la terza coppia chiave-valore, il valore è un array. Gli elementi dell'array sono essi stessi oggetti JSON con i tasti "type" e "number" . La quarta coppia valore-chiave ha un valore booleano, che in questo caso è false . L'ultima coppia chiave-valore ha il valore null.

Sample JSON object
{
"id" : 901,
"name" { "first":"John", "middle":"K", "last":"Doe" },
"phones" : [ {"type" : "home", "number" : "555-3762" },
             {"type" : "work", "number" : "555-7242" }],
"lazy" : false,
"married" : null
}

 

Conversione in forma relazionale

Lo scopo di JSON_TABLE è quello di estrarre informazioni da un oggetto JSON e rappresentarlo come una tabella relazionale. La Figura 1 mostra un esempio di estrarre le informazioni da un oggetto JSON e rappresenta come una tabella relazionale. In questo esempio, viene creata una tabella con le colonne ID ,FIRSTNAME , LASTNAME , PHONE _ TYPE , e PHONE _ NUMBER . Il valore nella colonna ID viene dal valore associato al "id" chiave nell'oggetto JSON. I valori per il FIRSTNAME e LASTNAME colonne provengono dai valori associati alla "first" e "last" chiavi. Perché ci sono due diversi valori nella matrice associata al"phones" chiave, questi due valori sono utilizzati per creare due righe della tabella relazionale, in cui i dati per il PHONE _ TYPE e PHONE _ NUMBER colonna vengono recuperati dai valori associati con il "type" e"number" chiavi degli oggetti all'interno della matrice.

Figura 1. Estrazione dati JSON in una tabella relazionale

Quando l'estrazione dei dati JSON in una tabella relazionale, dobbiamo specificare cosa posto nelle due dimensioni della tabella relazionale. Per la prima dimensione, dobbiamo specificare quali colonne sono nella tabella relazionale. Nella figura 1, si vede che i nomi delle colonne sono ID , FIRSTNAME , LASTNAME , PHONE _ TYPE , e PHONE _ NUMBER . Per la seconda dimensione, dobbiamo specificare quali righe devono essere prodotti. Nella figura 1, le righe sono prodotte per ogni valore della matrice associata al "phones"chiave.

SQL / JSON path expressions (il percorso)

Quando si fa l'estrazione di informazioni relazionali da un oggetto JSON, ci deve essere un modo per specificare  come le informazioni si possono trovare nel oggetto JSON. In JSON_TABLE , questa informazione viene specificata utilizzando una espressione di percorso SQL / JSON. Un'espressione di percorso SQL / JSON è un elenco di direzioni per trovare uno o più valori all'interno di un oggetto JSON. Informalmente, questo elenco contiene le indicazioni per iniziare con l'oggetto corrente, di guardare all'interno di un oggetto, di guardare dentro una matrice, o per cercare un valore associato a una chiave.

 

A titolo di esempio, si consideri l'oggetto JSON mostrato . Per trovare il numero di telefono associato al primo elemento della matrice cellulare, dobbiamo utilizzare le seguenti direzioni: in primo luogo, abbiamo bisogno di iniziare con l'oggetto corrente. In secondo luogo, guardare dentro l'oggetto. Quindi, cercare il valore associato al "phones" chiave. Poi, guarda il primo elemento della matrice. Poi guarda all'interno dell'oggetto. Infine guardare il valore associato al "number" del valore di trovare "555-3762" .

{
"phones" : [ {"type" : "home", "number" : "555-3762" },
             {"type" : "work","number" : "555-7242" },
}

 

Nelle SQL / JSON espressioni di percorso, le seguenti indicazioni hanno una sintassi associata:

  • $  Inizia con l'oggetto corrente
  • .  (punto) Guarda dentro un oggetto
  • [ ]  Guarda dentro una matrice
  • <Nome-chiave>  fare riferimento al valore associato a una chiave

Di conseguenza, il percorso di SQL / JSON per estrarre il primo numero di telefono è ' $.phones[0].number '.

Associata con un'espressione percorso SQL / JSON è una modalità, che è o lassista o severa. Modalità "lassista"significa che quando l'espressione percorso SQL / JSON viene valutata, determinate condizioni di errore sono tollerate, mentre la modalità "rigorosa"produce un errore quando si incontrano queste condizioni di errore.

Un / JSON espressione di percorso SQL potrebbe comportare la valutazione di un array. Quando si utilizza la modalità lassista, se si verifica un array e l'espressione di percorso SQL / JSON non ha un passo di dereference la matrice, la matrice è dereferenziato automaticamente. Inoltre, se l'espressione percorso SQL / JSON ha un passo di dereference un array, per esempio [0], e una matrice non viene rilevato, il passo per dereference l'array è ignorato. Infine, se viene rilevato qualsiasi altro errore, il risultato è un valore vuoto invece di un errore. La tabella 1 riassume la differenza tra queste modalità.

  lassista rigorosa
Unnesting automatico di array   Alcuni passaggi del percorso, come ad esempio l'accesso ai membri $ .key, iterare automaticamente gli elementi di un array.  Gli array non sono unnested automaticamente.
 wrapping automatico all'interno di un array  [0] o [*], possono essere applicati ad un non-array.  Non vi è alcun avvolgimento automatico prima di pedice passi percorso.
 gestione degli errori  Gli errori non gestiti dal unnesting automatico e le funzioni automatiche di confezionamento vengono convertiti in sequenze vuote SQL / JSON. Gli errori sono rigorosamente definiti in tutti i casi.
 

Più formalmente, il diagramma di sintassi per un'espressione percorso SQL / JSON è illustrato nella figura 2. Un'espressione percorso SQL / JSON può opzionalmente iniziare con una modalità. Se una modalità non è specificato, viene utilizzato poi lassista. Il percorso inizia con il simbolo del dollaro ($) per indicare il contesto JSON corrente. Poi, di accesso per trovare un valore-chiave con un oggetto o un identificatore di serie vengono utilizzati. La funzione di accesso utente ".*" Significa per accedere a tutti i valori nell'oggetto e l'identificatore di matrice "*" significa per accedere a tutti i valori di un array. Quando si fa riferimento ai valori di un array, gli elementi da cui si accede possono essere esplicitamente indicati. Ad esempio, gli elementi a indici 0,1,3 si può accedere. In alternativa, una serie di elementi può essere specificato usando la parola chiave per. Ad esempio, da 0 a 3 possono essere usati per accedere agli elementi 0, 1, 2 e 3. In SQL / espressioni di percorso JSON, il primo elemento della matrice è situato al valore di indice 0.

 
Figura sintassi / JSON percorso espressione 2. SQL

sintassi JSON_TABLE

Per creare una tabella relazionale da un oggetto JSON, il database deve conoscere diverse informazioni. In primo luogo, si deve sapere dove trovare l'oggetto JSON. In secondo luogo, deve conoscere il livello più alto per produrre righe. In terzo luogo, è necessario conoscere la definizione per ogni colonna, in cui ogni definizione di colonna contiene il nome della colonna, il tipo di dati, e il percorso di SQL / JSON al valore JSON. La figura 3 mostra la sintassi per JSON_TABLE quando viene utilizzato con la forma più semplice di definizione di una colonna, una definizione di colonna regolare.

Figura 3. sintassi di base JSON_TABLE utilizzando una definizione di colonna regolare
 

In questa sintassi, il nome della funzione tavolo, JSON _ TABLE , indica che JSON _ TABLE deve essere chiamato. Il primo parametro è il JSON-contesto-voce, che di solito è una stringa di caratteri che contiene un oggetto JSON. DB2 for i supporta inoltre il superamento di un campo binary large object (BLOB) che contiene un oggetto JSON in formato binario JSON (BSON). Questo formato è stato utilizzato dal precedente negozio DB2 JSON. Se il negozio DB2 JSON è stato utilizzato per memorizzare BSON oggetti nel database, questi oggetti possono essere consumati da JSON _ TABLE .

Il secondo parametro di JSON _ TABLE è la SQL-JSON-path-espressione. Questo è l'espressione di livello superiore che indica quali elementi dell'oggetto JSON devono essere utilizzati per produrre righe di output nella tabella risultante. All'interno di questa espressione, il simbolo di inizio '$' rappresenta il JSON-contesto-item.

La terza parte del JSON _ TABLE indica quali colonne devono essere prodotti. Ogni colonna ha un nome-colonna e un corrispondente tipo di dati. Il percorso per trovare l'elemento richiesto JSON viene specificata utilizzando la parola chiave PATH seguita da un percorso SQL / JSON. Molte colonne possono essere specificati con ogni definizione di colonna separati da una virgola. In JSON _ TABLE , specificando un percorso colonna è opzionale. Se un percorso colonna non è specificato, quindi un percorso di forma'$.column-name' è usato. Quando si utilizza questa funzione, si deve ricordare che i percorsi SQL / JSON sono case sensitive.

Per illustrare l'uso di JSON _ TABLE , usiamo una variabile globale che contiene un oggetto JSON. Listato 5 mostra istruzioni SQL che possono essere utilizzati per creare una variabile globale chiamata JSON _ VAR e popolare la variabile globale con un oggetto JSON.

CREATE VARIABLE JSON_VAR VARCHAR(2000);
SET JSON_VAR='{
          "id" : 901,
          "name" : { "first":"John", "last":"Doe" },
          "phones" : [{"type":"home", "number":"555-3762"},
                      {"type":"work", "number":"555-7252"}]
          }';
 

 Ora che abbiamo un oggetto JSON, possiamo usare JSON_TABLE per estrarre i valori da quella oggetto JSON in dati relazionali. Listato 6 mostra una semplice utilizzo di JSON _ TABLE . In questo esempio, un SELECT istruzione viene utilizzato per richiamare JSON _ TABLE e restituire tutte le colonne che essa produce. La variabile globale JSON _ VAR viene utilizzato come ingresso JSON per JSON _ TABLE . In questo esempio, '$' è usato come / JSON espressione di percorso più esterno SQL, il che significa che le definizioni delle colonne utilizzeranno l'oggetto JSON esistente come elemento di contesto. Perché '$' fa riferimento a un solo elemento in oggetto, questo uso di JSON_TABLE produrrà solo una riga. Dopo l'espressione di percorso SQL / JSON più esterno, sono definite le colonne. La prima colonna è il nome ID e ha un tipo di VARCHAR(10) . Il percorso di SQL / JSON per individuare tale valore è 'lax $.id' . Allo stesso modo, questo esempio ha colonne FIRST e LAST , che restituiscono il nome e cognome all'interno dell'oggetto JSON interiore a cui fa riferimento il "name" chiave.

Listato 6. semplice query JSON_TABLE
SELECT * FROM JSON_TABLE(JSON_VAR,
    '$'
    COLUMNS(
         id VARCHAR(10) PATH 'lax $.id',
         first VARCHAR(10) PATH 'lax $.name.first',
         last VARCHAR(10) PATH 'lax $.name.last' )
) as t;
 

L'esecuzione di questo di query risultati nella tabella mostrata nella Figura 4. Dal oggetto JSON, l'id è stato recuperato, così come il nome e il cognome.

Figura 4. risultato JSON_TABLE

JSON_TABLE con colonne nidificate

Nell'esempio precedente, una sola riga è stata creata dall'oggetto JSON. Per recuperare più righe utilizzando gli elementi dell'array incorporati in oggetto JSON, viene utilizzata una definizione di colonna nidificato. Una definizione di colonna nidificato può prendere il posto di una definizione rubrica fissa. La sua sintassi è mostrato in Figura 5.

Figura 5. annidati definizione di colonna

 

Una definizione di colonna nidificato inizia con la parola chiave NESTED ed è seguito da una espressione percorso SQL / JSON che indica che JSON valori devono essere elaborati dalle colonne all'interno della definizione nidificato. Questa espressione di percorso indica quali elementi di un array devono essere utilizzati per la produzione di righe. Tipicamente, l'espressione percorso contiene '[*]' che indica che tutti gli elementi di un array sono trattati. Dopo il percorso, le colonne sono definite utilizzando la COLUMNS parola chiave, proprio come le colonne definite in una definizione di rubrica fissa.

 

Listato 7 mostra un esempio di utilizzo di una definizione di colonna nidificato. Come nell'esempio precedente, l'elemento del contesto riferimento alla variabile JSON_VAR e '$' è usato come il più SQL / JSON espressione path esterno. Questa query restituisce anche il nome e il cognome, come prima. Viene quindi utilizzato un NESTED definizione di colonna che ha '$.phone[*]' come espressione percorso SQL / JSON. Questa espressione dirige JSON_TABLE per produrre una riga per ogni elemento dell'array cellulari. Per ogni oggetto incontrato nella matrice, le definizioni delle colonne vengono utilizzate per estrarre il "type" e "number" valori per ciascun numero di telefono. In questo esempio, queste definizioni di colonna di livello inferiore non comprendono un percorso. Così, i percorsi predefiniti di forma '$.type' e'$.number' vengono utilizzati.

 

Listing 7. interrogazione annidata JSON_TABLE
SELECT * FROM JSON_TABLE( JSON_VAR,
    '$'
    COLUMNS(
         first VARCHAR(10) PATH 'lax $.name.first',
         last VARCHAR(10) PATH 'lax $.name.last' ,
         NESTED '$.phones[*]'COLUMNS (
             "type" VARCHAR(10),
             "number" VARCHAR(10)
         )
    )
) as t;
 

La Figura 6 mostra il risultato dell'esecuzione di questa ricerca. Perché ci sono due oggetti di telefonia nella matrice telefono, due file vengono restituiti.

 
Figura 6. JSON_TABLE risultato nidificato
 
 

 

ordinare JSON_TABLE

 

Un altro tipo di definizione di colonna è la colonna ordinalità. Una colonna ordinalità viene utilizzata per numerare le righe all'interno di un livello di nidificazione. La sintassi per una colonna ordinalità è mostrato in Figura 7. Si tratta del nome della colonna seguito dalle parole chiave FOR ORDINALITY . Il tipo di dati SQL di una colonna ordinalità è BIGINT .
column - name- FOR ORDINALITY

Il listato mostra un esempio di utilizzo JSON_TABLE con una colonna ordinalità. In questo esempio, il nome della colonna è ORD .

SELECT * FROM JSON_TABLE( JSON_VAR,
     '$'
     COLUMNS(
           first VARCHAR(10) PATH 'lax $.name.first',
           last VARCHAR(10) PATH 'lax $.name.last' ,
           NESTED PATH '$.phones[*]' COLUMNS (
                ord FOR ORDINALITY,
                "type" VARCHAR(10),
                "number" VARCHAR(10)
           )
     )
 ) as t;

 

La Figura 8 mostra i risultati di esecuzione di questa query. Il risultato ha ora un ORD colonna con i valori 1 e 2 per le due file generati.

 

Figura risultato ordinalità 8. JSON_TABLE

JSON_TABLE e formato JSON

 

L'ultimo tipo di definizione di colonna è un FORMAT JSON definizione di colonna. Una sintassi semplificata per questa definizione colonna è mostrata nella figura 9. Questa definizione colonna è simile alla definizione di colonna standard, con l'eccezione che le parole chiave, FORMAT JSON , vengono utilizzati dopo tipo dati. Quando si utilizza questa definizione di colonna, il valore JSON trovato dalla colonna-percorso-espressione-costante viene restituito in formato JSON. In pratica, questo formato è utile al programmatore quando si sviluppa un JSON_TABLE espressione, questo permette un programmatore di vedere il valore JSON prodotto da un particolare percorso JSON.

 

Figura 9. FORMATO definizione della colonna JSON
column - name - data -type - FORMAT JSON ---> PATH column path expression contant


Listato 9 mostra un esempio di utilizzo FORMAT JSON . In questo esempio, vogliamo vedere i risultati dell'utilizzo di varie fasi in un percorso SQL / JSON.

SELECT * FROM JSON_TABLE( JSON_VAR,
    '$'
    COLUMNS(
        ALL CLOB FORMAT JSON PATH '$',
        PHONES CLOB FORMAT JSON PATH '$.phones',
        PHONE0 CLOB FORMAT JSON PATH '$.phones[0]',
        TYPE CLOB FORMAT JSON PATH '$.phones[0].type'
    )
) as t;


La Figura 10 mostra il risultato dell'esecuzione di questa ricerca. L' ALL colonna contiene l'oggetto JSON, che fa riferimento utilizzando '$' . Il PHONES colonna riflette l'array JSON corrispondente a '$.phones' . Il PHONE0 colonna restituisce l'oggetto JSON riscontrato nel primo elemento della matrice cellulari. Infine, il TYPE colonna contiene il tipo di telefono trovato entro il primo elemento della matrice cellulari. Poiché FORMAT JSON viene utilizzato e il risultato è un valore di stringa, vengono restituiti anche i doppi apici presenti nell'oggetto JSON originale.

Figura 10. FORMATO risultato JSON JSON_TABLE




opzioni JSON_TABLE

JSON_TABLE ha un numero di opzioni che possono essere utilizzati per configurare il comportamento. Ci sono opzioni disponibili per il livello più alto di JSON_TABLE così come le opzioni per le definizioni delle colonne regolari e FORMAT JSON definizioni di colonna.

Al livello più alto di JSON_TABLE , è possibile specificare la gestione degli errori comportamento. Questo comportamento è o EMPTY ON ERROR o ERROR ON ERROR . L'impostazione predefinita è EMPTY ON ERROR il che significa che una tabella vuota (cioè, una tabella con nessuna riga) viene restituito quando viene rilevato un errore di livello di tabella. L' ERROR ON ERROR impostazione indica che un errore deve essere restituito.

Listato 10 mostra un esempio di utilizzo della ERROR ON ERROR impostazione. Si noti che il percorso del contesto utilizza la modalità rigorosa per forzare l'errore. La Figura 11 mostra l'errore risultante.

Listing 10. ERRORE SU ERRORE
SELECT * FROM JSON_TABLE( JSON_VAR,'strict $.forceError'
    COLUMNS( "id" VARCHAR(10) PATH 'lax $.id')
    ERROR ON ERROR ) as t;
 
Figure 11. Result of ERROR ON ERROR



Per le definizioni delle colonne regolari, sono disponibili per controllare il comportamento dei seguenti sei opzioni quando i valori vuoti sono trovati o si verificano errori:

  1. restituisce NULL  quando vuoto 
    Utilizzare NULL ON EMPTY di restituire NULL quando la chiave non viene trovata.
  2. restituisce ERROR  quando vuoto 
    Utilizzare ERROR ON EMPTY a causare un errore di essere rilasciato quando la chiave non è stata trovata.
  3. Restituisce un valore predefinito quando è vuoto 
    Utilizzare DEFAULT <value> ON EMPTY per restituire un valore letterale quando la chiave non viene trovata.
  4. Restituisce NULL in caso di errore 
    Utilizzare NULL ON ERROR per restituire NULL quando l'espressione percorso incontra un errore.
  5. Ritorno di errore in caso di errore 
    Utilizzare ERROR ON ERROR per causare un errore di essere rilasciato quando l'espressione percorso incontra un errore.
  6. Restituisce un valore di default su un errore 
    Utilizzare DEFAULT <value> ON ERROR per restituire un valore letterale quando l'espressione percorso incontra un errore.

Listato 11 mostra un esempio di utilizzo di queste impostazioni e la corrispondente uscita è mostrato in Figura 12. In questo esempio, NULL è restituito per le EMPTYCOL1 e ERRORCOL1 colonne perché gli elementi specificati non possono essere trovati. L'utilizzo della modalità rigorosa nel percorso per ERRORCOL1colonna causa l'errore si verifichi. Per i EMPTYCOL2 e ERRORCOL2 colonne, specificato 'EMPTY2' e 'ERROR2'stringhe vengono restituiti.

Listato 11. Settaggio di ON EMPTY e ON ERROR
SELECT * FROM JSON_TABLE( JSON_VAR, '$'
    COLUMNS(
          EMPTYCOL1 VARCHAR(10) NULL ON EMPTY,
          EMPTYCOL2 VARCHAR(10) DEFAULT 'EMPTY2' ON EMPTY,
          ERRORCOL1 VARCHAR(10) PATH 'strict $.bad'
                                NULL ON ERROR ,
          ERRORCOL2 VARCHAR(10) PATH 'strict $.bad'
                                DEFAULT 'ERROR2' ON ERROR
    )) as t;
 
Figure 12. ON EMPTY and ONE ERROR output
 

esempi JSON_TABLE

Il vero potere di JSON_TABLE può essere visto durante l'elaborazione di un oggetto JSON che viene recuperato dal web. I seguenti esempi dimostrano come consumare valori JSON recuperati da vari siti web.Questi esempi illustrano come JSON_TABLE può facilmente convertire i dati JSON in informazioni relazionale.

La United States Geological Survey fornisce un feed JSON di informazioni recenti terremoti. È possibile trovare le informazioni sui terremoti entro l'ultima settimana a https://earthquake.usgs.gov/earthquakes/feed/v1.0/summary/all_week.geojson . È possibile visualizzare le informazioni utilizzando un browser web,

 

Da queste informazioni, vogliamo ottenere un elenco dei recenti terremoti con i loro tempi di report, grandezze, e la posizione. Ciò può essere realizzato utilizzando l'istruzione SQL nel Listato 12. In questa istruzione, il SYSTOOLS . HTTPGETCLOB funzione viene utilizzata per recuperare l'oggetto JSON dal sito web. Questo oggetto viene quindi utilizzato come input per JSON _ TABLE . Dopo che è stato specificato il valore di ingresso, il percorso 'lax $.features[*]' viene utilizzata per recuperare tutte le informazioni memorizzate terremoto nella matrice specificato dal "features" chiave. Abbiamo poi definiamo tre colonne per contenere le informazioni per il tempo (in millisecondi), grandezza, e il luogo del terremoto. Le espressioni di percorso SQL / JSON utilizzate per individuare queste informazioni sono definite per ogni colonna.

 
Listato 12. Terremoti JSON_TABLE
select * from JSON_TABLE(
   SYSTOOLS.HTTPGETCLOB('http://earthquake.usgs.gov' ||
    '/earthquakes/feed/v1.0/summary/all_week.geojson',null),
    '$.features[*]'
   COLUMNS( MILLISEC BIGINT PATH '$.properties.time',
            MAG DOUBLE PATH '$.properties.mag',
            PLACE VARCHAR(100) PATH '$.properties.place'
          )) AS X;
 



Il secondo esempio utilizza i lavori nutrono da https://api.usa.gov/jobs/search.json . Per questo feed, una query viene utilizzato per specificare i tipi di posti di lavoro da cercare. La Figura 15 mostra un esempio di recuperare il valore JSON. Si noti che il sito produce una gamma JSON invece di un oggetto JSON.

In questo esempio, prendiamo il risultato di tre diverse interrogazioni e li inseriamo nel database. La procedura per fare questo sono mostrati nel Listato 13. Per semplificare il processo, per prima cosa creare una funzione GETIT che accetta la stringa di ricerca per passare al sito. Questa funzione, utilizza il SYSTOOLS. HTTPGETCLOB funzione per eseguire la query sul sito. Poiché i dati vengono restituiti come un array JSON, e JSON_TABLE opera solo su oggetti JSON, SQL concatenazione viene utilizzato per creare un oggetto JSON con la roba chiave e il valore è la matrice restituita. I prossimi passi in elenco 13 sono per creare una tabella per contenere l'oggetto JSON ed eseguire il INSERT istruzione per inserire i dati nelle colonne.

CREATE FUNCTION GETIT(SEARCH VARCHAR(200)) RETURNS CLOB(1M)
     LANGUAGE SQL CONTAINS SQL
     RETURN '{ "stuff" : '
     ||SYSTOOLS.HTTPGETCLOB('https://api.usa.gov/jobs/search.json?query='
     || SEARCH, null) || '}' ;
      
CREATE TABLE RAWJOBINFO( KEYWORDS VARCHAR(1000),
                         JSON_COL CLOB(1M) CCSID 1208);
INSERT INTO RAWJOBINFO VALUES('computer science',
                        GETIT('computer+science'));
INSERT INTO RAWJOBINFO VALUES('medical', GETIT('medical'));
INSERT INTO RAWJOBINFO VALUES('engineer', GETIT('engineer'));

L'esecuzione di questi risultati istruzione SQL nella tabella RAWJOBINFO contenente le informazioni come si vede nella figura 16.

Figura 16. Contenuto del RAWJOBINFO

 

Abbiamo poi vogliamo usare JSON _ TABLE per recuperare le informazioni JSON da queste tre righe di dati.Per avere JSON _ TABLE processo ciascuna di queste righe, usiamo un SQL join tra le RAWJOBINFO tavolo eJSON_TABLE come mostrato nel Listato 14. L'ingresso del JSON_TABLE è l'oggetto JSON dalla colonna JSON di RAWJOBINFO . Per ogni oggetto JSON, JSON_TABLE utilizza il percorso '$.stuff[*]' per elaborare tutti gli elementi dell'array. Per ogni elemento, il JOBNO colonna ordinalità viene utilizzato per numerare le colonne. Poi il colonne TITLE , "minimum" e "maximum" vengono utilizzati per recuperare il titolo posizione così come il minimo e stipendi massimi. Il risultato dell'esecuzione di questa query è illustrato in Figura 17.

SELECT KEYWORDS, JOBNO, TITLE, "minimum", "maximum"

 

    FROM RAWJOBINFO,

 

       JSON_TABLE( JSON_COL,

 

       'lax $.stuff[*] '

 

           COLUMNS (JOBNO for ORDINALITY,

 

                   TITLE VARCHAR(80) PATH '$.position_title',

 

                   "minimum" BIGINT,

           "maximum" BIGINT) ) j ORDER BY

 

Listing 14. dati Estrazione JSON da tavolo RAWJOBINFO


 

Sommario

 

JSON_TABLE è un potente strumento oggi disponibile per elaborare i dati JSON su DB2 per i. Utilizzando SQL / JSON espressioni di percorso per individuare le informazioni in oggetti JSON, JSON_TABLE può inserire le informazioni in righe e colonne delle tabelle del database. In concomitanza con le funzioni di HTTP, i feed JSON può essere consumato utilizzando SQL e combinati con le forme tradizionali di dati relazionali.

 

Riferimenti