데이터 연결 스키마, 쿼리, 변형

Firebase Data Connect를 사용하면 Google Cloud SQL로 관리되는 PostgreSQL 인스턴스의 커넥터를 만들 수 있습니다. 이러한 커넥터는 스키마, 쿼리, 변형을 생성할 수 있습니다.

시작 가이드에서는 PostgreSQL용 영화 리뷰 앱 스키마를 소개했으며, 이 가이드에서는 PostgreSQL용 Data Connect 스키마를 설계하는 방법을 자세히 살펴봅니다.

이 가이드에서는 Data Connect 쿼리와 변형을 스키마 예시와 함께 설명합니다. 다음 도움말에서 쿼리 (및 변형)를 설명하는 이유 스키마 Data Connect개를 삭제하시겠어요? 다른 GraphQL 기반 플랫폼과 마찬가지로 Firebase Data Connect는 쿼리 우선 개발 플랫폼이므로 개발자는 데이터 모델링 시 클라이언트에게 필요한 데이터를 고려하게 되며 이는 프로젝트용으로 개발하는 데이터 스키마에 큰 영향을 미칩니다.

이 가이드는 새로운 영화 리뷰 스키마로 시작하여 쿼리와 변형을 다룹니다. 해당 스키마에서 파생되며 마지막으로 SQL 목록을 핵심 Data Connect 스키마와 같습니다.

영화 리뷰 앱의 스키마

사용자가 영화를 제출하고 볼 수 있는 서비스를 빌드한다고 가정해 보겠습니다. 리뷰.

이러한 앱에는 초기 스키마가 필요합니다. 나중에 이 스키마 확장 복잡한 관계형 쿼리를 만들 수 있습니다

영화 테이블

영화 스키마에는 다음과 같은 핵심 지시어가 포함됩니다.

• @table: singular를 사용하여 작업 이름을 설정할 수 있습니다. 및 인수 plural개
• @col - 열 이름을 명시적으로 설정
• @default: 기본값을 설정할 수 있도록 허용합니다.

를 통해 개인정보처리방침을 정의할 수 있습니다.

# Movies
type Movie
  @table(name: "Movies", singular: "movie", plural: "movies", key: ["id"]) {
  id: UUID! @col(name: "movie_id") @default(expr: "uuidV4()")
  title: String!
  releaseYear: Int @col(name: "release_year")
  genre: String
  rating: Int @col(name: "rating")
  description: String @col(name: "description")
}

서버 값 및 키 스칼라

영화 리뷰 앱을 살펴보기 전에 Data Connect 서버 값 및 키 스칼라를 소개하겠습니다.

서버 값을 사용하면 효과적으로 서버가 동적으로 채워지도록 할 수 있습니다. 저장된 값 또는 쉽게 계산할 수 있는 값을 사용하여 테이블의 필드를 특정 서버 측 표현식을 사용할 수 있습니다. 예를 들어 표현식을 사용하여 필드에 액세스할 때 적용되는 타임스탬프 updatedAt: Timestamp! @default(expr: "request.time")

키 스칼라는 Data Connect가 스키마의 키 필드에서 자동으로 조합하는 간결한 객체 식별자입니다. 키 스칼라의 목적은 효율성입니다. 단일 호출에서 데이터의 ID 및 구조에 관한 정보를 찾을 수 있습니다. 이는 특히 인코더-디코더 아키텍처를 순차 작업을 수행하며 관계형 키에 액세스하려는 경우에도 더 복잡한 작업을 추가로 수행할 수 있습니다.

영화 메타데이터 테이블

이제 영화 감독을 추적하고 Movie와 일대일 관계를 설정해 보겠습니다.

@ref 지시어를 추가하여 관계를 정의합니다.

# Movie Metadata
# Movie - MovieMetadata is a one-to-one relationship
type MovieMetadata
  @table(
    name: "MovieMetadata"
  ) {
  # @ref creates a field in the current table (MovieMetadata) that holds the
  # primary key of the referenced type
  # In this case, @ref(fields: "id") is implied
  movie: Movie! @ref
  # movieId: UUID <- this is created by the above @ref
  director: String @col(name: "director")
}

Actor 및 MovieActor

다음으로 영화에 출연하는 배우를 추가하려고 합니다. 영화와 배우 간에 다대다 관계가 있으므로 조인 테이블을 만듭니다.

# Actors
# Suppose an actor can participate in multiple movies and movies can have multiple actors
# Movie - Actors (or vice versa) is a many to many relationship
type Actor @table(name: "Actors", singular: "actor", plural: "actors") {
  id: UUID! @col(name: "actor_id") @default(expr: "uuidV4()")
  name: String! @col(name: "name", dataType: "varchar(30)")
}
# Join table for many-to-many relationship for movies and actors
# The 'key' param signifies the primary key(s) of this table
# In this case, the keys are [movieId, actorId], the generated fields of the reference types [movie, actor]

type MovieActor @table(key: ["movie", "actor"]) {
  # @ref creates a field in the current table (MovieActor) that holds the primary key of the referenced type
  # In this case, @ref(fields: "id") is implied
  movie: Movie! @ref
  # movieId: UUID! <- this is created by the above @ref, see: implicit.gql
  actor: Actor! @ref
  # actorId: UUID! <- this is created by the above @ref, see: implicit.gql
  role: String! @col(name: "role") # "main" or "supporting"
  # optional other fields
}

사용자

마지막으로, 앱 사용자입니다.

# Users
# Suppose a user can leave reviews for movies
# user:reviews is a one to many relationship, movie:reviews is a one to many relationship, movie:user is a many to many relationship
type User
  @table(name: "Users", singular: "user", plural: "users", key: ["id"]) {
  id: UUID! @col(name: "user_id") @default(expr: "uuidV4()")
  auth: String @col(name: "user_auth") @default(expr: "auth.uid")
  username: String! @col(name: "username", dataType: "varchar(30)")
  # The following are generated from the @ref in the Review table
  # reviews_on_user
  # movies_via_Review
}

지원되는 데이터 유형

Data Connect는 @col(dataType:)를 사용하여 PostgreSQL 유형에 할당하는 방식으로 다음 스칼라 데이터 유형을 지원합니다.

Data Connect 유형	GraphQL 기본 제공 유형 또는 Data Connect 맞춤 유형	기본 PostgreSQL 유형	지원되는 PostgreSQL 유형 (괄호 안의 별칭)
문자열	GraphQL	텍스트	text bit(n), varbit(n) char(n), varchar(n)
정수	GraphQL	int	Int2 (smallint, smallserial), int4 (integer, int, serial)
부동 소수점 수	GraphQL	float8	float4 (실수) float8 (배정밀도) numeric (십진수)
부울	GraphQL	부울	부울
UUID : 범용 고유 식별자	커스텀	uuid	uuid
Int64	커스텀	bigint	int8 (bigint, bigserial) numeric (십진수)
날짜	커스텀	날짜	날짜
타임스탬프	커스텀	타임스탬프	timestamptz 참고: 로컬 시간대 정보는 저장되지 않습니다. PostgreSQL은 UTC와 같은 타임스탬프를 변환하고 저장합니다.
벡터	커스텀	vector	벡터 Vertex AI로 벡터 유사성 검색 수행을 참고하세요.

• GraphQL List는 1차원 배열에 매핑됩니다.
  • 예를 들어 [Int]는 int5[]에 매핑되고 [Any]는 jsonb[]에 매핑됩니다.
  • Data Connect는 중첩 배열을 지원하지 않습니다.

사전 정의된 암시적 쿼리 및 변형

Data Connect 쿼리 및 변형은 스키마의 유형 및 유형 관계를 기반으로 Data Connect에서 생성된 암시적 쿼리 및 암시적 변형 집합을 확장합니다. 암시적 쿼리 및 변형 스키마를 수정할 때마다 로컬 도구에 의해 생성됩니다.

개발 과정에서 사전 정의된 검색어를 구현하고 사전 정의된 변형을 만듭니다.

암시적 쿼리 및 변형 이름 지정

Data Connect는 암시적 쿼리 및 변형에 적합한 이름을 추론함 스키마 유형 선언에서 가져올 수 있습니다. 예를 들어 PostgreSQL 소스를 사용하는 경우 Movie라는 테이블을 정의하면 서버에서 다음을 암시적으로 생성합니다.

• movie(단수, eq와 같은 인수를 전달하여 개별 결과를 검색하는 경우) 및 movies(복수, gt와 같은 인수와 orderby와 같은 작업을 전달하여 결과 목록을 검색하는 경우)와 같은 친숙한 이름을 사용하여 단일 테이블 사용 사례에 관한 쿼리를 생성합니다. Data Connect는 actors_on_movies 또는 actors_via_actormovie와 같은 명시적인 이름을 사용하여 다중 테이블 관계형 연산에 관한 쿼리도 생성합니다.
• movie_insert, movie_upsert...라는 이름의 변형

또한 스키마 정의 언어를 사용하면 singular 및 plural 지시어 인수를 사용하는 연산

영화 리뷰 데이터베이스에 대한 쿼리

쿼리 작업 유형을 사용하여 Data Connect 쿼리 정의 선언, 작업 이름, 0개 이상의 연산 인수, 0개 이상 인수가 있는 지시문입니다.

빠른 시작의 listEmails 쿼리 예시에서는 매개변수를 사용하지 않았습니다. 물론 대부분의 경우 쿼리 필드에 전달되는 데이터는 동적입니다. 이때 $variableName 문법: 쿼리 정의입니다.

따라서 다음 쿼리에는 다음이 있습니다.

• query 유형 정의
• ListMoviesByGenre 작업(쿼리) 이름
• 단일 변수 $genre 연산 인수
• 단일 지시문 @auth

query ListMoviesByGenre($genre: String!) @auth(level: USER)

모든 쿼리 인수에는 유형 선언, String와 같은 기본 제공 또는 스키마로 정의된 커스텀 유형입니다(예: Movie).

점점 더 복잡해지는 쿼리의 서명을 살펴보겠습니다. 마지막으로 사전 정의된 쿼리에서 빌드할 수 있는 암시적 쿼리에서 사용할 수 있는 강력하고 간결한 관계 표현식을 소개합니다.

쿼리의 주요 스칼라

먼저 주요 스칼라에 관한 참고사항을 살펴보겠습니다.

Data Connect는 _Key로 식별되는 키 스칼라의 특수 유형을 정의합니다. 예를 들어 Movie 테이블의 키 스칼라 유형은 Movie_Key입니다.

대부분의 암시적 변형에서 반환된 응답으로 키 스칼라를 검색합니다. 물론 빌드하는 데 필요한 모든 필드를 가져온 쿼리에서 스칼라 키입니다.

실행 중인 예의 movie와 같은 단일 자동 쿼리는 키를 지원합니다. 인수입니다.

키 스칼라를 리터럴로 전달할 수 있습니다. 하지만 특정 데이터나 스트링을 전달할 수 있도록 키 스칼라를 입력으로 반환합니다.

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

이와 같은 요청 JSON (또는 기타 직렬화)으로 제공할 수 있습니다. 형식)

{
  # …
  "variables": {
    "myKey": {"foo": "some-string-value", "bar": 42}
  }
}

맞춤 스칼라 파싱 덕분에 Movie_Key는 변수가 포함될 수 있는 객체 문법을 사용하여 구성할 수도 있습니다. 이것은 주로 개별 구성요소를 서로 다른 변수로 분할할 수 있습니다.

쿼리의 별칭

Data Connect는 쿼리에서 GraphQL 별칭을 지원합니다. 별칭을 사용하면 쿼리 결과에 반환된 데이터의 이름을 바꿀 수 있습니다. 단일 Data Connect 쿼리는 서버에 대한 하나의 효율적인 요청에서 여러 필터 또는 기타 쿼리 작업을 적용하여 여러 '하위 쿼리'를 한 번에 실행할 수 있습니다. 반환된 데이터 세트에서 이름 충돌을 방지하려면 별칭을 사용하여 하위 쿼리를 구분합니다.

다음은 표현식이 mostPopular 별칭을 사용하는 쿼리입니다.

query ReviewTopPopularity($genre: String) {
  mostPopular: review(first: {
    where: {genre: {eq: $genre}},
    orderBy: {popularity: DESC}
  }) { … }
}

필터가 있는 간단한 쿼리

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

query MoviesByReleaseYear($min: Int, $max: Int) {
  movies(where: {releaseYear: {le: $max, ge: $min}}, orderBy: [{releaseYear: ASC}]) { … }
}

limit 및 offset 연산자 (단수, 복수 쿼리)

결과를 페이지로 나누기를 수행할 수 있습니다. 이러한 인수는 허용되지만 결과로 반환되지 않습니다.

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

배열 필드의 포함

배열 필드에 지정된 항목이 포함되어 있는지 테스트할 수 있습니다.

# Filter using arrays and embedded fields.
query ListMoviesByTag($tag: String!) {
  movies(where: { tags: { includes: $tag }}) {
    # graphql: list the fields from the results to return
    id
    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}}) {...}
  matchRegex: movies(where: {title: {pattern: {regex: $regex}}}) {...}
}

구성된 필터의 경우 or 및 and

더 복잡한 로직에는 or 및 and를 사용합니다.

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 Connect 쿼리는 테이블 간의 관계를 기반으로 데이터에 액세스할 수 있습니다. 스키마에 정의된 객체(일대일) 또는 배열(일대다) 관계를 사용하여 중첩 쿼리를 실행할 수 있습니다. 즉, 중첩된 유형 또는 관련 유형의 데이터와 함께 하나의 유형의 데이터를 가져올 수 있습니다.

이러한 쿼리는 생성된 암시적 쿼리에서 매직 Data Connect _on_ 및 _via 구문을 사용합니다.

초기 버전의 스키마를 수정합니다.

다대일

Review 테이블과 User 수정사항을 사용하여 앱에 리뷰를 추가해 보겠습니다.

# Users
# Suppose a user can leave reviews for movies
# user:reviews is a one to many relationship,
# movie:reviews is a one to many relationship,
# movie:user is a many to many relationship
type User
  @table(name: "Users", singular: "user", plural: "users", key: ["id"]) {
  id: UUID! @col(name: "user_id") @default(expr: "uuidV4()")
  auth: String @col(name: "user_auth") @default(expr: "auth.uid")
  username: String! @col(name: "username", dataType: "varchar(30)")
  # The following are generated from the @ref in the Review table
  # reviews_on_user
  # movies_via_Review
}
# Reviews
type Review @table(name: "Reviews", key: ["movie", "user"]) {
  id: UUID! @col(name: "review_id") @default(expr: "uuidV4()")
  user: User! @ref
  movie: Movie! @ref
  rating: Int
  reviewText: String
  reviewDate: Date! @default(expr: "request.time")
}

다대일 쿼리

이제 별칭이 있는 쿼리를 살펴보고 _via_ 문법을 설명해 보겠습니다.

query UserMoviePreferences($username: String!) @auth(level: USER) {
  users(where: { username: { eq: $username } }) {
    likedMovies: movies_via_review(where: { rating: { ge: 4 } }) {
      title
      genre
      description
    }
    dislikedMovies: movies_via_review(where: { rating: { le: 2 } }) {
      title
      genre
      description
    }
  }
}

일대일

패턴을 확인할 수 있습니다. 아래에서는 설명을 위해 스키마가 수정되었습니다.

# Movies
type Movie
  @table(name: "Movies", singular: "movie", plural: "movies", key: ["id"]) {
  id: UUID! @col(name: "movie_id") @default(expr: "uuidV4()")
  title: String!
  releaseYear: Int @col(name: "release_year")
  genre: String
  rating: Int @col(name: "rating")
  description: String @col(name: "description")
  tags: [String] @col(name: "tags")
}
# Movie Metadata
# Movie - MovieMetadata is a one-to-one relationship
type MovieMetadata
  @table(
    name: "MovieMetadata"
  ) {
  # @ref creates a field in the current table (MovieMetadata) that holds the primary key of the referenced type
  # In this case, @ref(fields: "id") is implied
  movie: Movie! @ref
  # movieId: UUID <- this is created by the above @ref
  director: String @col(name: "director")
}


extend type MovieMetadata {
  movieId: UUID! # matches primary key of referenced type
...
}

extend type Movie {
  movieMetadata: MovieMetadata # can only be non-nullable on ref side
  # conflict-free name, always generated
  movieMetadatas_on_movie: MovieMetadata
}

일대일 쿼리

_on_ 문법을 사용하여 쿼리할 수 있습니다.

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

다대다

영화에는 배우가 필요하고 배우는 영화가 필요합니다. 다대다 형태입니다 MovieActors 조인 테이블을 사용하여 모델링할 수 있습니다.

# MovieActors Join Table Definition
type MovieActors @table(
  key: ["movie", "actor"] # join key triggers many-to-many generation
) {
  movie: Movie!
  actor: Actor!
}

# generated extensions for the MovieActors join table
extend type MovieActors {
  movieId: UUID!
  actorId: UUID!
}

# Extensions for Actor and Movie to handle many-to-many relationships
extend type Movie {
  movieActors: [MovieActors!]! # standard many-to-one relation to join table
  actors: [Actor!]! # many-to-many via join table

  movieActors_on_actor: [MovieActors!]!
  # since MovieActors joins distinct types, type name alone is sufficiently precise
  actors_via_MovieActors: [Actor!]!
}

extend type Actor {
  movieActors: [MovieActors!]! # standard many-to-one relation to join table
  movies: [Movie!]! # many-to-many via join table

  movieActors_on_movie: [MovieActors!]!
  movies_via_MovieActors: [Movie!]!
}

다대다 쿼리

별칭이 있는 쿼리를 살펴보고 _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 Connect는 각 테이블에 대해 기본 암시적 변형을 생성합니다.

type Movie @table { ... }

extend type Mutation {
  # Insert a row into the movie table.
  movie_insert(...): Movie_Key!
  # Upsert a row into movie."
  movie_upsert(...): Movie_Key!
  # Update a row in Movie. Returns null if a row with the specified id/key does not exist
  movie_update(...): Movie_Key
  # Update rows based on a filter in Movie.
  movie_updateMany(...): Int!
  # Delete a single row in Movie. Returns null if a row with the specified id/key does not exist
  movie_delete(...): Movie_Key
  # Delete rows based on a filter in Movie.
  movie_deleteMany(...): Int!
}

이를 통해 점점 더 복잡한 핵심 CRUD 사례를 구현할 수 있습니다. 빠르게 다섯 번 말해 보세요.

만들기

기본 생성을 해 보겠습니다.

# Create a movie based on user input
mutation CreateMovie($title: String!, $releaseYear: Int!, $genre: String!, $rating: Int!) {
  movie_insert(data: {
    title: $title
    releaseYear: $releaseYear
    genre: $genre
    rating: $rating
  })
}

# Create a movie with default values
mutation CreateMovie2 {
  movie_insert(data: {
    title: "Sherlock Holmes"
    releaseYear: 2009
    genre: "Mystery"
    rating: 5
  })
}

upsert일 수도 있습니다.

# Movie upsert using combination of variables and literals
mutation UpsertMovie($title: String!) {
  movie_upsert(data: {
    title: $title
    releaseYear: 2009
    genre: "Mystery"
    rating: 5
    genre: "Mystery/Thriller"
  })
}

업데이트 실행

새로운 소식입니다. 제작자와 감독은 이러한 평균 시청률이 추세에 맞기를 바랍니다.

mutation UpdateMovie(
  $id: UUID!,
  $genre: String!,
  $rating: Int!,
  $description: String!
) {
  movie_update(id: $id, data: {
    genre: $genre
    rating: $rating
    description: $description
  })
}

# Multiple updates (increase all ratings of a genre)
mutation IncreaseRatingForGenre($genre: String!, $ratingIncrement: Int!) {
  movie_updateMany(
    where: { genre: { eq: $genre } },
    update: { rating: { inc: $ratingIncrement } }
  )
}

삭제 실행

물론 영화 데이터를 삭제할 수도 있습니다. 영화 보존론자들은 필름을 최대한 오래 보존하고 싶어 할 것입니다.

# Delete by key
mutation DeleteMovie($id: UUID!) {
  movie_delete(id: $id)
}

여기서는 _deleteMany를 사용할 수 있습니다.

# Multiple deletes
mutation DeleteUnpopularMovies($minRating: Int!) {
  movie_deleteMany(where: { rating: { le: $minRating } })
}

관계에 변형 작성

관계에서 암시적 _upsert 변형을 사용하는 방법을 살펴봅니다.

# Create or update a one to one relation
mutation MovieMetadataUpsert($movieId: UUID!, $director: String!) {
  movieMetadata_upsert(
    data: { movie: { id: $movieId }, director: $director }
  )
}

동등한 SQL 스키마

-- Movies Table
CREATE TABLE Movies (
    movie_id UUID DEFAULT uuid_generate_v4() PRIMARY KEY,
    title VARCHAR(255) NOT NULL,
    release_year INT,
    genre VARCHAR(30),
    rating INT,
    description TEXT,
    tags TEXT[]
);
-- Movie Metadata Table
CREATE TABLE MovieMetadata (
    movie_id UUID REFERENCES Movies(movie_id) UNIQUE,
    director VARCHAR(255) NOT NULL,
    PRIMARY KEY (movie_id)
);
-- Actors Table
CREATE TABLE Actors (
    actor_id UUID DEFAULT uuid_generate_v4() PRIMARY KEY,
    name VARCHAR(30) NOT NULL
);
-- MovieActor Join Table for Many-to-Many Relationship
CREATE TABLE MovieActor (
    movie_id UUID REFERENCES Movies(movie_id),
    actor_id UUID REFERENCES Actors(actor_id),
    role VARCHAR(50) NOT NULL, # "main" or "supporting"
    PRIMARY KEY (movie_id, actor_id),
    FOREIGN KEY (movie_id) REFERENCES Movies(movie_id),
    FOREIGN KEY (actor_id) REFERENCES Actors(actor_id)
);
-- Users Table
CREATE TABLE Users (
    user_id UUID DEFAULT uuid_generate_v4() PRIMARY KEY,
    user_auth VARCHAR(255) NOT NULL
    username VARCHAR(30) NOT NULL
);
-- Reviews Table
CREATE TABLE Reviews (
    review_id UUID DEFAULT uuid_generate_v4() PRIMARY KEY,
    user_id UUID REFERENCES Users(user_id),
    movie_id UUID REFERENCES Movies(movie_id),
    rating INT,
    review_text TEXT,
    review_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    UNIQUE (movie_id, user_id)
    FOREIGN KEY (user_id) REFERENCES Users(user_id),
    FOREIGN KEY (movie_id) REFERENCES Movies(movie_id)
);
-- Self Join Example for Movie Sequel Relationship
ALTER TABLE Movies
ADD COLUMN sequel_to UUID REFERENCES Movies(movie_id);

다음 단계

• 자동 생성된 웹 SDK, Android SDK, iOS SDK, Flutter SDK에서 쿼리 및 변형을 호출하는 방법을 알아보세요.