הטמעת שאילתות של Data Connect

באמצעות Firebase Data Connect אפשר ליצור מחברים למכונות PostgreSQL שמנוהלות באמצעות Google Cloud SQL. המחברים האלה הם שילובים של שאילתות ושינויים לשימוש בנתונים מהסכימה.

במדריך לתחילת העבודה הוצגה סכימה של אפליקציית ביקורת על סרטים ל-PostgreSQL.

במדריך הזה הוצגו גם פעולות ניהוליות שניתן לפרוס ופעולות אד-הוק, כולל שאילתות.

  • שאילתות שאפשר לפרוס הן שאילתות שמטמיעים כדי לבצע קריאה מאפליקציות לקוח, עם נקודות קצה של API שאתם מגדירים. אתם מאגדים אותם במחבר שמוטמע בשרת. Data Connect כלי פיתוח יוצרים ערכות SDK ללקוח על סמך ה-API שלכם. שאילתות שמוצבות לא מוגנות על ידי מדיניות IAM, לכן חשוב להגן עליהן באמצעות ההנחיה Data Connect @auth.
  • שאילתות אדמיניסטרטיביות אד-הוק מורצות מסביבות עם הרשאות כדי לקרוא נתונים. אפשר ליצור ולהפעיל אותם במסוף Firebase או בסביבות פיתוח מקומיות באמצעות התוסף Data Connect ל-VS Code.

במדריך הזה נסביר יותר לעומק על שאילתות שאפשר להטמיע.

תכונות של שאילתות Data Connect

‫Data Connect מאפשרת לכם להריץ שאילתות בסיסיות בכל הדרכים שאתם מצפים להן במסד נתונים של PostgreSQL.

אבל בעזרת התוספים של Data Connect ל-GraphQL, אפשר להטמיע שאילתות מתקדמות כדי ליצור אפליקציות מהירות ויעילות יותר:

  • שימוש בערכי סקלר של מפתחות שמוחזרים על ידי פעולות רבות כדי לפשט פעולות חוזרות על רשומות
  • אפשר להריץ שאילתות במהלך פעולות מוטציה מרובות שלבים כדי לחפש נתונים, וכך לחסוך בשורות קוד ובמסעות הלוך ושוב לשרת.

שימוש בשדות שנוצרו כדי ליצור שאילתות

פעולות Data Connect ירחיבו קבוצה של שדות Data Connect שנוצרו באופן אוטומטי על סמך הסוגים והקשרים בין הסוגים בסכימה. השדות האלה נוצרים על ידי כלים מקומיים בכל פעם שאתם עורכים את הסכימה.

אתם יכולים להשתמש בשדות שנוצרו כדי להטמיע שאילתות מורכבות יותר ויותר, החל מאחזור רשומות בודדות או כמה רשומות מטבלאות בודדות ועד לאחזור כמה רשומות מטבלאות קשורות.

נניח שהסכימה מכילה סוג Movie וסוג Actor משויך. ‫Data Connect יוצר את השדות movie,‏ movies,‏ actors_on_movies ועוד.

שאילתה עם השדה
movie

השדה movie מייצג רשומה יחידה בטבלה Movie.

בשדה הזה אפשר להזין שאילתה כדי לחפש סרט יחיד לפי המפתח שלו.

query GetMovie($myKey: Movie_Key!) {
  movie(key: $myKey) { title }
}

שאילתה עם השדה
movies

השדה movies מייצג רשימה של רשומות בטבלה Movie.

אפשר להשתמש בשדה הזה כדי לשלוח שאילתה לגבי כמה סרטים, למשל כל הסרטים משנה מסוימת.

query GetMovies($myYear: Int!) {
  movies(where: { year: { eq: $myYear } }) { title }
}

שאילתה עם השדה
actors_on_movies

השדה actors_on_movies מייצג רשימה של רשומות שמקשרות בין הטבלאות Actor ו-Movie. בשדה הזה אפשר להריץ שאילתה על כל השחקנים שמשויכים לסרט מסוים.

בשדה הזה אפשר להריץ שאילתה על כל השחקנים שמשויכים לסרט מסוים.

  query GetActorsOnMovie($myKey: Movie_Key!) {
    actors_on_movies(where: { movie: { key: { eq: $myKey } } }) {
      actor { name }
    }
  }

אלמנטים חיוניים בשאילתה

שאילתות Data Connect הן שאילתות GraphQL עם תוספים של Data Connect. בדיוק כמו בשאילתת GraphQL רגילה, אפשר להגדיר שם פעולה ורשימה של משתני GraphQL.

‫Data Connect מרחיב את שאילתות GraphQL באמצעות הוראות מותאמות אישית כמו @auth.

לכן השאילתה הבאה כוללת:

  • הגדרת סוג query
  • שם של פעולה (שאילתה) ListMoviesByGenre
  • ארגומנט יחיד של שאילתה, כאן משתנה $genre מסוג String
  • הוראה יחידה, @auth.
  • שדה יחיד, movies.
query ListMoviesByGenre($genre: String!) @auth(level: PUBLIC) {
  movies(where: { genre: { eq: $genre } }) {
    id
    title
  }
}

כל ארגומנט של שאילתה דורש הצהרת סוג, סוג מובנה כמו String, או סוג מותאם אישית שמוגדר בסכימה כמו Movie.

במדריך הזה נבחן את החתימה של שאילתות מורכבות יותר ויותר. בסוף המאמר נציג ביטויי קשר חזקים ותמציתיים שתוכלו להשתמש בהם כדי ליצור שאילתות שאפשר לפרוס.

סקלרים מרכזיים בשאילתות

אבל קודם, הערה לגבי סקלרים מרכזיים.

‫Data Connect מגדיר סקלר מפתח מיוחד שמייצג מפתחות ראשיים של כל טבלה, שמזוהים על ידי {TableType}_Key. זהו אובייקט JSON של ערכי מפתח ראשי.

אפשר לאחזר סקלרים מרכזיים כתשובה שמוחזרת מרוב השדות שנוצרו אוטומטית לקריאה, או כמובן משאילתות שבהן אחזרתם את כל השדות שנדרשים ליצירת מפתח סקלרי.

שאילתות אוטומטיות יחידות, כמו movie בדוגמה הפעילה שלנו, תומכות בארגומנט key שמקבל סקלר key.

יכול להיות שתעבירו סקלר מפתח כערך מילולי. אבל אפשר להגדיר משתנים כדי להעביר סקלרים של מפתחות גישה כקלט.

שאילתה

query GetMovie($myKey: Movie_Key!) {
  movie(key: $myKey) { title }
}

תגובה

{
  "data": {
    "movie": {
      "title": "Example Movie Title"
    }
  }
}

אפשר לספק את הנתונים האלה ב-JSON של הבקשה, כמו בדוגמה הבאה (או בפורמטים אחרים של סדרות):

{
  # …
  "variables": {
    "myKey": {"id": "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx"}
  }
}

בזכות ניתוח סקלרי מותאם אישית, אפשר גם ליצור Movie_Key באמצעות תחביר האובייקט, שעשוי להכיל משתנים. האפשרות הזו שימושית בעיקר כשרוצים לפצל רכיבים נפרדים למשתנים שונים מסיבה כלשהי.

כתיבת שאילתות בסיסיות

אתם יכולים להתחיל לכתוב שאילתות כדי לקבל רשומות בודדות ממסד הנתונים, או לרשום רשומות מטבלה עם אפשרות להגביל ולסדר את התוצאות.

אחזור רשומות בודדות

השאילתה הכי פשוטה מחזירה רשומה אחת לפי מזהה. השאילתה תשתמש בשדה movie שנוצר אוטומטית.

שאילתה

query GetMovieById($id: UUID!) @auth(level: PUBLIC) {
  movie(id: $id) {
    id
    title
    imageUrl
    genre
  }
}

תגובה

{
  "data": {
    "movie": {
      "id": "some-uuid",
      "title": "Example Movie Title",
      "imageUrl": "https://example.com/movie.jpg",
      "genre": "Action"
    }
  }
}

אחזור כל הרשומות בטבלה

כדי לאחזר קבוצת משנה של שדות מהרשימה המלאה של הסרטים בטבלה Movies, השאילתה תשתמש בשדה movies שנוצר אוטומטית, וההטמעה עשויה להיראות כך.

שאילתה

query ListMovies @auth(level: PUBLIC) {
  movies {
    id
    title
    imageUrl
    genre
  }
}

תגובה

{
  "data": {
    "movies": [
      {
        "id": "some-uuid",
        "title": "Example Movie Title",
        "imageUrl": "https://example.com/movie.jpg",
        "genre": "Action"
      },
      {
        "id": "another-uuid",
        "title": "Another Movie Title",
        "imageUrl": "https://example.com/another-movie.jpg",
        "genre": "Comedy"
      }
    ]
  }
}

שימוש באופרטורים orderBy, ‏ limit ו-offset

ברור שאין הרבה תועלת בהצגת כל הרשומות מטבלה.

אפשר להזמין ולבצע חלוקה לדפים בתוצאות. הארגומנטים האלה מתקבלים, אבל לא מוחזרים בתוצאות.

כאן, השאילתה מקבלת את שמות 10 הסרטים המובילים לפי דירוג.

שאילתה

query MoviesTop10 {
  movies(orderBy: [{ rating: DESC }], limit: 10) {
    # graphql: list the fields from the results to return
    title
  }
}

תגובה

{
  "data": {
    "movies": [
      { "title": "Top Movie 1" },
      { "title": "Top Movie 2" },
      { "title": "Top Movie 3" }
      // ... other 7 movies
    ]
  }
}

יכול להיות שיהיה לכם תרחיש שימוש שבו תרצו לאחזר שורות מהיסט מסוים, כמו סרטים 11-20 שמוזמנים לפי סיווג.

שאילתה

query Movies11to20 {
  movies(orderBy: [{ rating: DESC }], limit: 10, offset: 10) {
    # graphql: list the fields from the results to return
    title
  }
}

תגובה

{
  "data": {
    "movies": [
      { "title": "Movie 11" },
      { "title": "Movie 12" },
      { "title": "Movie 13" }
      // ... other 7 movies
    ]
  }
}

שימוש בכינויים בשאילתות

‫Data Connect תומך בכינויים של GraphQL בשאילתות. כינויים מאפשרים לשנות את השם של הנתונים שמוחזרים בתוצאות של שאילתה. שאילתת Data Connect אחת יכולה להחיל כמה מסננים או פעולות אחרות של שאילתות בבקשה יעילה אחת לשרת, ובפועל להנפיק כמה "תת-שאילתות" בבת אחת. כדי למנוע התנגשויות בין שמות במערך הנתונים שמוחזר, משתמשים בכינויים כדי להבחין בין שאילתות המשנה.

הנה שאילתה שבה ביטוי משתמש בכינויים mostPopular ו-leastPopular.

שאילתה

query ReviewPopularitySpread($genre: String) {
  mostPopular: review(
    first: {
      where: {genre: {eq: $genre}},
      orderBy: {popularity: DESC}
    }
  ),
  leastPopular: review(
    last: {
      where: {genre: {eq: $genre}},
      orderBy: {popularity: DESC}
    }
  )
}

תגובה

{
  "data": {
    "mostPopular": [
      { "popularity": 9 }
    ],
    "leastPopular": [
      { "popularity": 1 }
    ]
  }
}

שימוש במסנני שאילתות

שאילתות Data Connect ממופות לכל המסננים הנפוצים של SQL ולפעולות הסדר.

סינון עם where באמצעות אופרטורים של orderBy

הפונקציה מחזירה את כל השורות התואמות מהטבלה (ואת השיוכים המקוננים). הפונקציה מחזירה מערך ריק אם אין רשומות שתואמות למסנן.

שאילתה

query MovieByTopRating($genre: String) {
  mostPopular: movies(
    where: { genre: { eq: $genre } },
    orderBy: { rating: DESC }
  ) {
    # graphql: list the fields from the results to return
    id
    title
    genre
    description
  }
}

תגובה

{
  "data": {
    "mostPopular": [
      {
        "id": "some-uuid",
        "title": "Example Movie Title",
        "genre": "Action",
        "description": "A great movie"
      }
    ]
  }
}

סינון לפי בדיקה של ערכים ריקים

אפשר לבדוק ערכים של null באמצעות האופרטור isNull.

שאילתה

query ListMoviesWithoutDescription {
  movies(where: { description: { isNull: true }}) {
    id
    title
  }
}

תגובה

{
  "data": {
    "movies": [
      {
        "id": "some-uuid",
        "title": "Example Movie Title"
      },
      {
        "id": "another-uuid",
        "title": "Another Movie Title"
      }
    ]
  }
}

אופרטורים נוספים מפורטים במדריך לעיון בסוגי אובייקטים של קלט.

סינון באמצעות השוואות ערכים

אפשר להשתמש באופרטורים כמו lt (קטן מ-) ו-ge (גדול מ- או שווה ל-) כדי להשוות ערכים בשאילתות.

שאילתה

query ListMoviesByRating($minRating: Int!, $maxRating: Int!) {
  movies(where: { rating: { ge: $minRating, lt: $maxRating }}) {
    id
    title
  }
}

תגובה

{
  "data": {
    "movies": [
      {
        "id": "some-uuid",
        "title": "Example Movie Title"
      },
      {
        "id": "another-uuid",
        "title": "Another Movie Title"
      }
    ]
  }
}

סינון באמצעות האופרטורים includes ו-excludes בשדות של מערכים

אתם יכולים לבדוק אם שדה מערך כולל פריט שצוין.

הדוגמה הבאה ממחישה את האופרטור includes.

‫Data Connect תומך ב-includesAll, ‏ excludes, ‏ excludesAll ועוד. אפשר לעיין בכל האופרטורים האלה עבור מספרים שלמים, מחרוזות, תאריכים וסוגי נתונים אחרים בכותרות _ListFilter של מסמכי העיון.

שאילתה

query ListMoviesByTag($tag: String!) {
  movies(where: { tags: { includes: $tag }}) {
    # graphql: list the fields from the results to return
    id
    title
  }
}

תגובה

{
  "data": {
    "movies": [
      {
        "id": "some-uuid",
        "title": "Example Movie Title"
      }
    ]
  }
}

סינון באמצעות פעולות על מחרוזות וביטויים רגולריים

בשאלות שלכם אתם יכולים להשתמש בפעולות השוואה וחיפוש מחרוזות רגילות, כולל ביטויים רגולריים. הערה: כדי לייעל את הפעולות, אתה מאגד כאן כמה פעולות ומבדיל ביניהן באמצעות כינויים.

query MoviesTitleSearch($prefix: String, $suffix: String, $contained: String, $regex: String) {
  prefixed: movies(where: {title: {startsWith: $prefix}}) {...}
  suffixed: movies(where: {title: {endsWith: $suffix}}) {...}
  contained: movies(where: {title: {contains: $contained}}) {...}
}

סינון באמצעות לוגיקת האופרטורים _or, _and, _not

אפשר להשתמש ב-_or ללוגיקה מורכבת יותר. ‫Data Connect תומך גם באופרטורים _and ו-_not.

שאילתה

query ListMoviesByGenreAndGenre($minRating: Int!, $genre: String) {
  movies(
    where: { _or: [{ rating: { ge: $minRating } }, { genre: { eq: $genre } }] }
  ) {
    # graphql: list the fields from the results to return
    title
  }
}

תגובה

{
  "data": {
    "movies": [
      { "title": "Movie Title 1" },
      { "title": "Movie Title 2" }
    ]
  }
}

כתיבת שאילתות יחסיות

שאילתות Data Connect יכולות לגשת לנתונים על סמך הקשרים בין הטבלאות. אתם יכולים להשתמש בקשרים של אובייקט (אחד לאחד) או מערך (אחד לרבים) שמוגדרים בסכימה כדי ליצור שאילתות מקוננות, כלומר לאחזר נתונים מסוג אחד יחד עם נתונים מסוג מקונן או קשור.

בשאלות כאלה נעשה שימוש בתחביר הקסם Data Connect _on_ ו-_via בשדות קריאה שנוצרו.

חשוב לעיין בסכימה לדוגמה.

רבים לאחד

עכשיו נסתכל על שאילתה כדי להמחיש את התחביר של _on_.

שאילתה

query MyReviews @auth(level: USER) {
  user(key: {id_expr: "auth.uid"}) {
    reviews: reviews_on_user {
      movie { name }
      rating
    }
  }
}

תגובה

{
  "data": {
    "user": {
      "reviews": [
        {
          "movie": { "name": "Movie Title" },
          "rating": 5
        }
      ]
    }
  }
}

אחד לאחד

אפשר לכתוב שאילתה של אחד לאחד באמצעות תחביר _on_.

שאילתה

query GetMovieMetadata($id: UUID!) @auth(level: PUBLIC) {
  movie(id: $id) {
    movieMetadatas_on_movie {
      director
    }
  }
}

תגובה

{
  "data": {
    "movie": {
      "movieMetadatas_on_movie": {
        "director": "Some Director"
      }
    }
  }
}

רבים לרבים

בשאלות מסוג 'רבים לרבים' נעשה שימוש בתחביר _via_. שאילתת יחס רבים לרבים עשויה לאחזר שחקנים עבור סרט מסוים.

שאילתה

query MoviesActors($id: UUID!) @auth(level: USER) {
  movie(id: $id) {
     actors: actors_via_MovieActors {
        name
     }
  }
}

תגובה

{
  "data": {
    "movie": {
      "actors": [
        {
          "name": "Actor Name"
        }
      ]
    }
  }
}

אבל אפשר לכתוב שאילתה מורכבת יותר, באמצעות כינויים, כדי לסנן לפי role ולשלוף שחקנים וסרטים קשורים בתוצאות של mainActors ושל supportingActors. מכיוון שמדובר בקשר רבים לרבים, נעשה שימוש בתחביר _via_.

שאילתה

query GetMovieCast($movieId: UUID!, $actorId: UUID!) @auth(level: PUBLIC) {
  movie(id: $movieId) {
    mainActors: actors_via_MovieActor(where: { role: { eq: "main" } }) {
      name
    }
    supportingActors: actors_via_MovieActor(
      where: { role: { eq: "supporting" } }
    ) {
      name
    }
  }
  actor(id: $actorId) {
    mainRoles: movies_via_MovieActor(where: { role: { eq: "main" } }) {
      title
    }
    supportingRoles: movies_via_MovieActor(
      where: { role: { eq: "supporting" } }
    ) {
      title
    }
  }
}

תגובה

{
  "data": {
    "movie": {
      "mainActors": [
        {
          "name": "Main Actor Name"
        }
      ],
      "supportingActors": [
        {
          "name": "Supporting Actor Name"
        }
      ]
    },
    "actor": {
      "mainRoles": [
        {
          "title": "Main Role Movie Title"
        }
      ],
      "supportingRoles": [
        {
          "title": "Supporting Role Movie Title"
        }
      ]
    }
  }
}

שאילתות צבירה

מהם צבירים ולמה כדאי להשתמש בהם?

שדות מצטברים מאפשרים לבצע חישובים ברשימת תוצאות. בעזרת שדות מצטברים, אפשר לבצע פעולות כמו:

  • איך מוצאים את הציון הממוצע של ביקורת
  • איך בודקים את העלות הכוללת של הפריטים בעגלת קניות
  • איך מוצאים את המוצר עם הדירוג הכי גבוה או הכי נמוך
  • ספירת מספר המוצרים בחנות

הצבירה מתבצעת בשרת, וזה מאפשר ליהנות מכמה יתרונות בהשוואה לחישוב בצד הלקוח:

  • ביצועים מהירים יותר של האפליקציה (כי לא מתבצעים חישובים בצד הלקוח)
  • הפחתת עלויות של העברת נתונים (כי אתם שולחים רק את התוצאות המצטברות במקום את כל נתוני הקלט)
  • אבטחה משופרת (כי אפשר לתת ללקוחות גישה לנתונים מצטברים במקום לכל מערך הנתונים)

דוגמה לסכימה של נתונים מצטברים

בקטע הזה נשתמש בסכימה של חנות וירטואלית, שהיא דוגמה טובה להסבר על השימוש באגרגטים:

  type Product @table {
    name: String!
    manufacturer: String!
    quantityInStock: Int!
    price: Float!
    expirationDate: Date
  }

צבירות פשוטות

‫_count לכל השדות

השדה המצטבר הפשוט ביותר הוא _count: הוא מחזיר את מספר השורות שתואמות לשאילתה. לכל שדה בסוג, Data Connectיוצר שדות מצטברים תואמים בהתאם לסוג השדה.

שאילתה 

query CountProducts {
  products {
    _count
  }
}

תגובה 
one

לדוגמה, אם יש לכם 5 מוצרים במסד הנתונים, התוצאה תהיה:

{
  "products": [
    {
    "_count": 5
    }
  ]
}

לכל השדות יש שדה <field>_count, שסופר כמה שורות מכילות ערך שאינו null בשדה הזה.

שאילתה 

query CountProductsWithExpirationDate {
  products {
    expirationDate_count
  }
}

תגובה
field_count

לדוגמה, אם יש לכם 3 מוצרים עם תאריך תפוגה, התוצאה תהיה:

{
  "products": [
    {
    "expirationDate_count": 3
    }
  ]
}
‫_min,‏ _max,‏ _sum ו-‏_avg לשדות מספריים

בשדות מספריים (int,‏ float,‏ int64) יש גם את הערכים <field>_min,‏ <field>_max,‏ <field>_sum ו-<field>_avg.

שאילתה 

query NumericAggregates {
  products {
  quantityInStock_max
  price_min
  price_avg
  quantityInStock_sum
  }
}

תגובה
_min _max _sum _avg

לדוגמה, אם יש לכם את המוצרים הבאים:

  • מוצר א': quantityInStock: 10, ‏ price: 2.99
  • מוצר ב': quantityInStock: 5, price: 5.99
  • מוצר ג': quantityInStock: 20, ‏ price: 1.99

התוצאה תהיה:

{
  "products": [
    {
    "quantityInStock_max": 20,
    "price_min": 1.99,
    "price_avg": 3.6566666666666666,
    "quantityInStock_sum": 35
    }
  ]
}
‫‎_min ו-‎_max לתאריכים ולחותמות זמן

בשדות של תאריך וחותמת זמן מופיעים הסמלים <field>_min ו-<field>_max.

שאילתה 

query DateAndTimeAggregates {
  products {
  expirationDate_max
  expirationDate_min
  }
}

תגובה
_min _maxdatetime

לדוגמה, אם יש לכם את תאריכי התפוגה הבאים:

  • מוצר א': 2024-01-01
  • מוצר ב': 2024-03-01
  • מוצר ג': 2024-02-01

התוצאה תהיה:

{
  "products": [
    {
    "expirationDate_max": "2024-03-01",
    "expirationDate_min": "2024-01-01"
    }
  ]
}

ייחודי

הארגומנט distinct מאפשר לקבל את כל הערכים הייחודיים של שדה (או שילוב של שדות). לדוגמה:

שאילתה 

query ListDistinctManufacturers {
  products(distinct: true) {
    manufacturer
  }
}

תגובה
distinct

לדוגמה, אם יש לכם את היצרנים הבאים:

  • מוצר א': manufacturer: "Acme"
  • מוצר ב': manufacturer: "Beta"
  • מוצר ג': manufacturer: "Acme"

התוצאה תהיה:

{
  "products": [
    { "manufacturer": "Acme" },
    { "manufacturer": "Beta" }
  ]
}

אפשר גם להשתמש בארגומנט distinct בשדות מצטברים כדי לצבור במקום זאת את הערכים הייחודיים. לדוגמה:

שאילתה 

query CountDistinctManufacturers {
  products {
    manufacturer_count(distinct: true)
  }
}

תגובה
distinctonaggregate

לדוגמה, אם יש לכם את היצרנים הבאים:

  • מוצר א': manufacturer: "Acme"
  • מוצר ב': manufacturer: "Beta"
  • מוצר ג': manufacturer: "Acme"

התוצאה תהיה:

{
  "products": [
    {
    "manufacturer_count": 2
    }
  ]
}

צבירות מקובצות

כדי לבצע צבירה מקובצת, בוחרים שילוב של שדות צבירה ושדות לא צבירים בסוג. הפונקציה הזו מקבצת את כל השורות התואמות עם אותו ערך בשדות שאינם מצטברים, ומחשבת את השדות המצטברים עבור הקבוצה הזו. לדוגמה:

שאילתה 

query MostExpensiveProductByManufacturer {
  products {
  manufacturer
  price_max
  }
}

תגובה
groupedaggregates

לדוגמה, אם יש לכם את המוצרים הבאים:

  • מוצר א': manufacturer: "Acme", ‏ price: 2.99
  • מוצר ב': manufacturer: "Beta", price: 5.99
  • מוצר ג': manufacturer: "Acme", ‏ price: 1.99

התוצאה תהיה:

{
  "products": [
    { "manufacturer": "Acme", "price_max": 2.99 },
    { "manufacturer": "Beta", "price_max": 5.99 }
  ]
}
‫having ו-where עם צבירות מקובצות

אפשר גם להשתמש בארגומנטים having ו-where כדי להחזיר רק קבוצות שעומדות בקריטריונים שצוינו.

  • ‫having מאפשר לכם לסנן קבוצות לפי השדות המצטברים שלהן

  • where מאפשר לסנן את השורות על סמך שדות לא מצטברים.

שאילתה 

query FilteredMostExpensiveProductByManufacturer {
  products(having: {price_max: {ge: 2.99}}) {
  manufacturer
  price_max
  }
}

תגובה
havingwhere

לדוגמה, אם יש לכם את המוצרים הבאים:

  • מוצר א': manufacturer: "Acme", ‏ price: 2.99
  • מוצר ב': manufacturer: "Beta", price: 5.99
  • מוצר ג': manufacturer: "Acme", ‏ price: 1.99

התוצאה תהיה:

{
  "products": [
    { "manufacturer": "Acme", "price_max": 2.99 },
    { "manufacturer": "Beta", "price_max": 5.99 }
  ]
}

צבירה בין טבלאות

אפשר להשתמש בשדות מצטברים בשילוב עם שדות של קשרים מסוג אחד לרבים שנוצרו על ידי המערכת, כדי לענות על שאלות מורכבות לגבי הנתונים. זו סכימה שעברה שינוי, עם טבלה נפרדת, Manufacturer, שאפשר להשתמש בה בדוגמאות:

  type Product @table {
    name: String!
    manufacturer: Manufacturer!
    quantityInStock: Int!
    price: Float!
    expirationDate: Date
  }

  type Manufacturer @table {
    name: String!
    headquartersCountry: String!
  }

עכשיו אפשר להשתמש בשדות צבירה כדי לבצע פעולות כמו חיפוש מספר המוצרים שמייצר יצרן מסוים:

שאילתה 

query GetProductCount($id: UUID) {
  manufacturers {
    name
    products_on_manufacturer {
      _count
    }
  }
}

תגובה 
aggregatesacrosstables

לדוגמה, אם יש לכם את היצרנים הבאים:

  • יצרן א': name: "Acme", ‏ products_on_manufacturer: 2
  • יצרן ב': name: "Beta", ‏ products_on_manufacturer: 1

התוצאה תהיה:

{
  "manufacturers": [
    { "name": "Acme", "products_on_manufacturer": { "_count": 2 } },
    { "name": "Beta", "products_on_manufacturer": { "_count": 1 } }
  ]
}

כתיבת שאילתות מתקדמות: שימוש בשדות query לקריאת נתונים בפעולות מרובות שלבים

יש הרבה מצבים שבהם כדאי לקרוא את מסד הנתונים במהלך ביצוע של שינוי כדי לחפש ולאמת נתונים קיימים לפני שמבצעים, למשל, הוספות או עדכונים. האפשרויות האלה חוסכות פעולות של הלוך ושוב, ולכן גם חוסכות עלויות.

Data Connect תומך בפונקציונליות הזו. מידע נוסף על פעולות מרובות שלבים

השלבים הבאים

נושאים שעשויים לעניין אותך: