Multiple mutazioni in GraphQL per Data API Builder

Data API Builder (DAB) supporta la combinazione di più operazioni di mutazione in una singola transazione. Più mutazioni supportano scenari in cui è necessario creare più elementi appartenenti alla stessa entità o creare più elementi appartenenti a un'entità correlata. Questa guida illustra uno scenario di esempio che usa un'operazione di mutazione multipla.

Prerequisiti

• Sql Server e database esistenti.
• CLI generatore di API dati. Installare l'interfaccia della riga di comando
• Un client di database (SQL Server Management Studio, Azure Data Studio e così via)
  • Se non è installato un client, installare Azure Data Studio

Creare tabelle

Per iniziare, creare due tabelle di base per rappresentare libri e i rispettivi capitoli. I libri hanno una relazione uno-a-molti con i capitoli corrispondenti.

1. Connettersi al database SQL usando il client o lo strumento preferito.

2. Creare una tabella denominata Books con le colonne id, title, year e pages.

   DROP TABLE IF EXISTS dbo.Books;
   
   CREATE TABLE dbo.Books
   (
       id int NOT NULL PRIMARY KEY,
       title nvarchar(1000) NOT NULL,
       [year] int null,
       [pages] int null
   )
   GO
   

3. Creare un'altra tabella denominata Chapters con le colonne id, name e pages. Creare una book_id colonna con una relazione di chiave esterna con la id colonna della Books tabella.

   DROP TABLE IF EXISTS dbo.Chapters;
   
   CREATE TABLE dbo.Chapters
   (
       id int NOT NULL PRIMARY KEY,
       [name] nvarchar(1000) NOT NULL,
       [pages] int null,
       book_id int NOT NULL,
       FOREIGN KEY (book_id) REFERENCES dbo.Books(id)
   )
   GO
   

4. Verificare che le tabelle vengano create con alcune query SQL comuni.

   SELECT * FROM dbo.Books
   

   SELECT * FROM dbo.Chapters
   

   Annotazioni

   A questo punto, le query non devono restituire dati.

File di configurazione della compilazione

Ora, utilizzare l'interfaccia a riga di comando di DAB per creare un file di configurazione, le entità, e le relazioni tra entità.

1. Aprire un terminale

2. Archiviare la stringa di connessione del database SQL come variabile della shell denominata SQL_CONNECTION_STRING.

   SQL_CONNECTION_STRING="<your-sql-connection-string>"
   

   $SQL_CONNECTION_STRING="<your-sql-connection-string>"
   

3. Eseguire dab init specificando le proprietà seguenti.

   	Valore
   database-type	mssql
   graphql.multiple-create.enabled	true
   host-mode	development
   connection-string	Usare la variabile shell SQL_CONNECTION_STRING creata nel passaggio precedente.

   dab init --database-type "mssql" --graphql.multiple-create.enabled true --host-mode "development" --connection-string $SQL_CONNECTION_STRING
   

4. Eseguire dab add per aggiungere un'entità Book che specifica le proprietà seguenti.

   	Valore
   source	dbo.Books
   permissions	anonymous:*

   dab add Book --source "dbo.Books" --permissions "anonymous:*"
   

5. Eseguire dab add di nuovo per aggiungere un'entità Chapter specificando ora le proprietà seguenti.

   	Valore
   source	dbo.Chapters
   permissions	anonymous:*

   dab add Chapter --source "dbo.Chapters" --permissions "anonymous:*"  
   

6. Eseguire dab update per creare la relazione Book to Chapter specificando le proprietà seguenti.

   	Valore
   relationship	chapters
   cardinality	many

   dab update Book --relationship chapters --target.entity Chapter --cardinality many
   

7. Eseguire infine dab update un'ultima volta per creare la relazione Chapter to Book specificando le proprietà seguenti.

   	Valore
   relationship	book
   cardinality	one

   dab update Chapter --relationship book --target.entity Book --cardinality one
   

Eseguire più mutazioni di creazione

Per concludere, usare l'interfaccia della riga di comando di DAB per eseguire l'API e testare l'endpoint GraphQL usando Banana Cake Pop.

1. Avviare il motore di runtime usando la configurazione corrente.

   dab start
   

2. Vai all'endpoint relativo dell'applicazione /graphql in esecuzione. Questo endpoint apre l'interfaccia Banana Cake Pop.

   Annotazioni

   Per impostazione predefinita, si tratta di https://localhost:5001/graphql.

3. Creare una mutazione GraphQL per creare tre righe distinte tra due tabelle nel database. Questa mutazione usa entrambe le entità Book e Chapter in un'unica operazione di creazione multipla. Utilizzare le proprietà seguenti per la mutazione.

   Tipo di entità	Documento d'identità	Nome	Pagine	Anno
   Libro	1	Introduzione a Generatore API dati	200	2024
   Capitolo	2	File di configurazione	150
   Capitolo	3	Correre	50

   mutation {
     createBook(
       item: {
         id: 1
         title: "Introduction to Data API builder"
         pages: 200
         year: 2024
         chapters: [
           {
               id: 2
               name: "Configuration files", pages: 150 
           }
           {
               id: 3
               name: "Running", pages: 50
           }
         ]
       }
     ) {
       id
       title
       pages
       year
       chapters {
         items {
           name
           pages
         }
       }
     }
   }
   

4. Osservare l'output della mutazione. La mutazione ha creato dati correlati per entrambi i tipi di entità.

   {
     "data": {
       "createBook": {
         "id": 1,
         "title": "Introduction to Data API builder",
         "pages": 200,
         "year": 2024,
         "chapters": {
           "items": [
             {
               "name": "Configuration files",
               "pages": 150
             },
             {
               "name": "Running",
               "pages": 50
             }
           ]
         }
       }
     }
   }
   

5. Usare una query GraphQL per recuperare tutti i libri nel database, inclusi i capitoli correlati.

   query {
     books {
       items {
         pages
         title
         year
         chapters {
           items {
             name
             pages
           }
         }
       }
     }
   }
   

   Annotazioni

   A questo punto, la query deve restituire il singolo libro con due capitoli.

6. Osservare l'output di questa query con una matrice di libri, inclusa la matrice nidificata di capitoli.

   {
     "data": {
       "books": {
         "items": [
           {
             "pages": 200,
             "title": "Introduction to Data API builder",
             "year": 2024,
             "chapters": {
               "items": [
                 {
                   "name": "Configuration files",
                   "pages": 150
                 },
                 {
                   "name": "Running",
                   "pages": 50
                 }
               ]
             }
           }
         ]
       }
     }
   }
   

7. Connettersi di nuovo al database SQL usando il client o lo strumento preferito.

8. Verificare che i dati siano stati creati correttamente usando una query SQL.

   SELECT 
       c.name AS chapterName,
       c.pages AS chapterPages,
       b.title AS bookName,
       b.year AS releaseYear
   FROM dbo.Chapters c
   LEFT JOIN dbo.Books b ON b.id = c.book_id
   

   Annotazioni

   Questa query deve restituire due record relativi al capitolo.

Contenuti correlati

• relazioni
• GraphQL