Wiele mutacji w narzędziu GraphQL for Data API Builder

Konstruktor interfejsu API danych (DAB) obsługuje łączenie wielu operacji mutacji w jedną transakcję. Wiele mutacji obsługuje scenariusze, w których należy utworzyć wiele elementów należących do tej samej jednostki lub utworzyć wiele elementów należących do powiązanej jednostki. W tym przewodniku przedstawiono przykładowy scenariusz z użyciem operacji mutacji wielokrotnej.

Wymagania wstępne

• Istniejący serwer SQL i baza danych.
• Interfejs wiersza polecenia konstruktora interfejsu API danych. Instalowanie interfejsu wiersza polecenia
• Klient bazy danych (SQL Server Management Studio, Azure Data Studio itp.)
  • Jeśli nie masz zainstalowanego klienta, zainstaluj program Azure Data Studio

Tworzenie tabel

Zacznij od utworzenia dwóch podstawowych tabel do reprezentowania książek i ich rozdziałów. Książki mają relację jeden do wielu z odpowiednimi rozdziałami.

1. Połącz się z bazą danych SQL przy użyciu preferowanego klienta lub narzędzia.

2. Twórca tabelę o nazwie Books z kolumnami id, title, yeari 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. Twórca inną tabelę o nazwie Chapters z kolumnami id, namei .pages Twórca kolumnę book_id z relacją klucza obcego z kolumną idBooks tabeli.

   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. Sprawdź, czy tabele są tworzone przy użyciu niektórych typowych zapytań SQL.

   SELECT * FROM dbo.Books
   

   SELECT * FROM dbo.Chapters
   

   Uwaga

   W tym momencie zapytania nie powinny zwracać żadnych danych.

Plik konfiguracji kompilacji

Teraz użyj interfejsu wiersza polecenia daB, aby utworzyć plik konfiguracji, jednostki i relacje jednostki.

1. Otwieranie terminalu

2. Zapisz parametry połączenia bazy danych SQL jako zmienną powłoki o nazwie SQL_CONNECTION_STRING.

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

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

3. Uruchom polecenie dab init , określając następujące właściwości.

   	Wartość
   database-type	mssql
   graphql.multiple-create.enabled	true
   host-mode	development
   connection-string	Użyj zmiennej powłoki SQL_CONNECTION_STRING utworzonej w poprzednim kroku.

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

4. Uruchom polecenie dab add , aby dodać jednostkę Book określającą następujące właściwości.

   	Wartość
   source	dbo.Books
   permissions	anonymous:*

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

5. Uruchom ponownie polecenie dab add , aby dodać jednostkę Rozdział , określając teraz następujące właściwości.

   	Wartość
   source	dbo.Chapters
   permissions	anonymous:*

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

6. Uruchom polecenie dab update , aby utworzyć relację Książka do rozdziału , określając następujące właściwości.

   	Wartość
   relationship	chapters
   cardinality	many

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

7. Na koniec uruchom dab update ostatni raz, aby utworzyć relację Rozdział do książki , określając następujące właściwości.

   	Wartość
   relationship	book
   cardinality	one

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

Wykonywanie wielu mutacji tworzenia

Aby podsumować kwestie, użyj interfejsu wiersza polecenia języka DAB do uruchomienia interfejsu API i przetestowania punktu końcowego GraphQL przy użyciu narzędzia Banana Cake Pop.

1. Uruchom aparat środowiska uruchomieniowego przy użyciu bieżącej konfiguracji.

   dab start
   

2. Przejdź do względnego punktu końcowego /graphql dla uruchomionej aplikacji. Ten punkt końcowy otwiera interfejs Banana Cake Pop.

   Uwaga

   Domyślnie będzie https://localhost:5001/graphqlto .

3. Utwórz mutację GraphQL, aby utworzyć trzy odrębne wiersze w dwóch tabelach w bazie danych. Ta mutacja używa zarówno jednostek , jak Book i Chapter w jednej operacji "tworzenia wielokrotnego". Użyj następujących właściwości mutacji.

   Typ jednostki	ID (Identyfikator)	Nazwa	Strony	Year (Rok)
   Book (Książka)	1	Wprowadzenie do konstruktora interfejsu API danych	200	2024
   Rozdział	2	Pliki konfiguracji	150
   Rozdział	3	Uruchomienie	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. Obserwuj dane wyjściowe mutacji. Mutacja utworzyła powiązane dane dla obu typów jednostek.

   {
     "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. Użyj zapytania GraphQL, aby pobrać wszystkie książki w bazie danych, w tym powiązane rozdziały.

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

   Uwaga

   W tym momencie zapytanie powinno zwrócić pojedynczą książkę z dwoma rozdziałami.

6. Zwróć uwagę na dane wyjściowe tego zapytania z tablicą książek, w tym ich zagnieżdżonych tablicy rozdziałów.

   {
     "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. Połącz się ponownie z bazą danych SQL przy użyciu preferowanego klienta lub narzędzia.

8. Sprawdź, czy dane zostały pomyślnie utworzone przy użyciu zapytania 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
   

   Uwaga

   To zapytanie powinno zwrócić dwa rekordy rozdziałów.

Zawartość pokrewna

• Relacje
• GraphQL