ใช้การค้นหาของ 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 และอื่นๆ

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

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

  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
  }
}

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

ฟิลด์ทั้งหมดมีฟิลด์ <field>_count ซึ่งจะนับจำนวนแถวที่มีค่าที่ไม่ใช่ Null ในฟิลด์นั้น

query CountProductsWithExpirationDate {
  products {
    expirationDate_count
  }
}

{
  "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
  }
}

{
  "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
  }
}

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

แตกต่าง

อาร์กิวเมนต์ distinct ช่วยให้คุณรับค่าที่ไม่ซ้ำทั้งหมดสำหรับฟิลด์ (หรือชุดค่าผสมของฟิลด์) เช่น

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

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

คุณยังใช้อาร์กิวเมนต์ distinct ในช่องการรวมเพื่อรวมค่าที่ไม่ซ้ำแทนได้ด้วย เช่น

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

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

การรวมข้อมูลแบบจัดกลุ่ม

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

query MostExpensiveProductByManufacturer {
  products {
  manufacturer
  price_max
  }
}

{
  "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
  }
}

{
  "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
    }
  }
}

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

ฟิลด์การแจงนับการค้นหา

คุณสามารถค้นหาฟิลด์การแจงนับในสคีมาได้

สมมติว่าเราใช้การแจงนับดังนี้

enum AspectRatio {
   ACADEMY
   WIDESCREEN
   ANAMORPHIC
   IMAX
   "No information available on aspect ratio"
   UNAVAILABLE
}

เช่น คุณสามารถแสดงภาพยนตร์ทั้งหมดที่จัดรูปแบบในสัดส่วนภาพที่คุณต้องการ

query ListMoviesByAspectRatio($aspectRatio: AspectRatio!) @auth(level: PUBLIC) {
  movies(where:
    {originalAspectRatio: {eq: $aspectRatio}}
) {
    id
    title
    imageUrl
    releaseYear
    genre
    rating
    tags
    description
    otherAspectRatios
  }
}

ฟิลด์การแจงนับตัวกรอง

Enums มีการดำเนินการกรองมาตรฐานที่พร้อมใช้งาน ได้แก่ eq, ne, ge, gt, lt, le, in nin รวมถึง includes, excludes, includesAll และ excludesAll สำหรับรายการ

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

ตัวอย่างเช่น ข้อความ where ต่อไปนี้จะแสดงภาพยนตร์ทั้งหมดที่มีratioน้อยกว่าสัดส่วนภาพที่ป้อน

• ในตัวอย่างแรก หาก $aspectRatio เป็น IMAX ระบบจะเลือกภาพยนตร์ที่มี ratioตรงกับ ACADEMY, WIDESCREEN และ ANAMORPHIC
• ในตัวอย่างที่ 2 ระบบจะแสดงเฉพาะภาพยนตร์ที่พร้อมใช้งานทั้งใน ACADEMY และ WIDESCREEN

  movies(where: {originalAspectRatio: {lt: $aspectRatio}})

  movies(where: {otherAspectRatios: {includesAll: [ACADEMY, WIDESCREEN]}})

ทำการค้นหาการรวบรวมในฟิลด์การแจงนับ

รองรับเฉพาะ _count สำหรับ Enum

คําค้นหาต่อไปนี้จะนับจํานวนภาพยนตร์ทั้งหมดของแต่ละอัตราส่วนภาพ

query MovieCountByOriginalAspectRatio @auth(level: PUBLIC) {
  movies {
    _count
    originalAspectRatio
  }
}

เรียกใช้การค้นหาการแจงนับการโทรจากโค้ดฝั่งไคลเอ็นต์

ดูวิธีใช้การค้นหาการแจงนับจากไคลเอ็นต์ และวิธีออกแบบการเรียกใช้ไคลเอ็นต์เพื่อเพิ่มความยืดหยุ่นในการจัดการการแจงนับได้ในคู่มือ SDK สำหรับ iOS, Android, เว็บ และ Flutter

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

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

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

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

คุณอาจสนใจ

• สร้างคำค้นหาสำหรับแอปโดยใช้เครื่องมือความช่วยเหลือจาก AI
• การให้สิทธิ์การค้นหาตามคู่มือการให้สิทธิ์
• การเรียกใช้การค้นหาจากโค้ดฝั่งไคลเอ็นต์สำหรับ เว็บ iOS, Android และ Flutter