ใช้การค้นหาของ 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 ในตัวอย่างที่กำลังใช้งาน รองรับอาร์กิวเมนต์คีย์ ที่ยอมรับสเกลาร์คีย์

คุณอาจส่งสเกลาร์คีย์เป็นค่าคงที่ แต่คุณสามารถกำหนดตัวแปรเพื่อส่งสเกลาร์ของคีย์ เป็นอินพุตได้

การค้นหา

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

คุณทดสอบค่า 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
  • ผู้ผลิต B: name: "Beta", products_on_manufacturer: 1

ผลลัพธ์ที่ได้จะเป็นดังนี้

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

เขียนการค้นหาขั้นสูง: ใช้queryฟิลด์เพื่ออ่านข้อมูลในการดำเนินการแบบหลายขั้นตอน

มีหลายสถานการณ์ที่คุณอาจต้องการอ่านฐานข้อมูล ในระหว่างการดำเนินการของการเปลี่ยนแปลงเพื่อค้นหาและยืนยันข้อมูลที่มีอยู่ก่อน ดำเนินการ เช่น การแทรกหรือการอัปเดต ตัวเลือกเหล่านี้ช่วยประหยัดการดำเนินการแบบไปกลับ และลดค่าใช้จ่าย

Data Connect รองรับฟังก์ชันการทำงานนี้ ดูการดำเนินการแบบหลายขั้นตอน

ขั้นตอนถัดไป

คุณอาจสนใจ