You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: introspection.rs
    path of file: ./repos/grafbase/engine/crates/integration-tests/tests/postgres
    
    the code of the file until where you have to start completion: use expect_test::expect;
use indoc::indoc;
use integration_tests::postgres::{introspect_namespaced_postgres, introspect_postgres};

#[test]
fn table_with_generated_always_identity_primary_key() {
    let response = introspect_postgres(|api| async move {
        let schema = indoc! {r#"
            CREATE TABLE "User" (
                id INT PRIMARY KEY GENERATED ALWAYS AS IDENTITY
            )    
        "#};

        api.execute_sql(schema).await;
    });

    let expected = expect![[r#"
        """
          Search filter input for Int type.
        """
        input IntSearchFilterInput {
          """
            The value is exactly the one given
          """ eq: Int
          """
            The value is not the one given
          """ ne: Int
          """
            The value is greater than the one given
          """ gt: Int
          """
            The value is less than the one given
          """ lt: Int
          """
            The value is greater than, or equal to the one given
          """ gte: Int
          """
            The value is less than, or equal to the one given
          """ lte: Int
          """
            The value is in the given array of values
          """ in: [Int]
          """
            The value is not in the given array of values
          """ nin: [Int]
          not: IntSearchFilterInput
        }

        type Mutation {
          """
            Delete a unique User by a field or combination of fields
          """
          userDelete(by: UserByInput!): UserDeletePayload
          """
            Delete multiple rows of User by a filter
          """
          userDeleteMany(filter: UserMutationCollection!): UserDeleteManyPayload
          """
 
    
fn table_with_composite_primary_key() {
    let response = introspect_postgres(|api| async move {
        let schema = indoc! {r#"
            CREATE TABLE "User" (
                name VARCHAR(255) NOT NULL,
                email VARCHAR(255) NOT NULL,
                CONSTRAINT "User_pkey" PRIMARY KEY (name, email)
            )    
        "#};

        api.execute_sql(schema).await;
    });

    let expected = expect![[r#"
        type Mutation {
          """
            Delete a unique User by a field or combination of fields
          """
          userDelete(by: UserByInput!): UserDeletePayload
          """
            Delete multiple rows of User by a filter
          """
          userDeleteMany(filter: UserMutationCollection!): UserDeleteManyPayload
          """
            Create a User
          """
          userCreate(input: UserCreateInput!): UserCreatePayload
          """
            Create multiple Users
          """
          userCreateMany(input: [UserCreateInput!]!): UserCreateManyPayload
          """
            Update a unique User
          """
          userUpdate(by: UserByInput!, input: UserUpdateInput!): UserUpdatePayload
          """
            Update multiple Users
          """
          userUpdateMany(filter: UserMutationCollection!, input: UserUpdateInput!): UserUpdateManyPayload
        }

        enum OrderByDirection {
          ASC
          DESC
        }

        type PageInfo {
          hasPreviousPage: Boolean!
          hasNextPage: Boolean!
          startCursor: String
          endCursor: String
        }

        type Query {
          """
            Query a single User by a field
          """
          user(by: UserByInput!): User
          """
            Paginated query to fetch the whole list of User
          """
          userCollection(filter: UserCollection, first: Int, last: Int, before: String, after: String, orderBy: [UserOrderByInput]): UserConnection
        }

        """
          Search filter input for String type.
        """
        input StringSearchFilterInput {
          """
            The value is exactly the one given
          """ eq: String
          """
            The value is not the one given
          """ ne: String
          """
            The value is greater than the one given
          """ gt: String
          """
            The value is less than the one given
          """ lt: String
          """
            The value is greater than, or equal to the one given
          """ gte: String
          """
            The value is less than, or equal to the one given
          """ lte: String
          """
            The value is in the given array of values
          """ in: [String]
          """
            The value is not in the given array of values
          """ nin: [String]
          not: StringSearchFilterInput
        }

        """
          Update input for String type.
        """
        input StringUpdateInput {
          """
            Replaces the value of a field with the specified value.
          """ set: String
        }

        type User {
          name: String!
          email: String!
        }

        input UserByInput {
          nameEmail: UserNameEmailInput
        }

        input UserCollection {
          name: StringSearchFilterInput
          email: StringSearchFilterInput
          """
            All of the filters must match
          """ ALL: [UserCollection]
          """
            None of the filters must match
          """ NONE: [UserCollection]
          """
            At least one of the filters must match
          """ ANY: [UserCollection]
        }

        type UserConnection {
          edges: [UserEdge]!
          pageInfo: PageInfo!
        }

        input UserCreateInput {
          name: String!
          email: String!
        }

        type UserCreateManyPayload {
          """
            Returned items from the mutation.
          """
          returning: [UserReturning]!
          """
            The number of rows mutated.
          """
          rowCount: Int!
        }

        type UserCreatePayload {
          """
            Returned item from the mutation.
          """
          returning: UserReturning
          """
            The number of rows mutated.
          """
          rowCount: Int!
        }

        type UserDeleteManyPayload {
          """
            Returned items from the mutation.
          """
          returning: [UserReturning]!
          """
            The number of rows mutated.
          """
          rowCount: Int!
        }

        type UserDeletePayload {
          """
            Returned item from the mutation.
          """
          returning: UserReturning
          """
            The number of rows mutated.
          """
          rowCount: Int!
        }

        type UserEdge {
          node: User!
          cursor: String!
        }

        input UserMutationCollection {
          name: StringSearchFilterInput
          email: StringSearchFilterInput
          """
            All of the filters must match
          """ ALL: [UserMutationCollection]
          """
            None of the filters must match
          """ NONE: [UserMutationCollection]
          """
            At least one of the filters must match
          """ ANY: [UserMutationCollection]
        }

        input UserNameEmailInput {
          name: String!
          email: String!
        }

        input UserOrderByInput {
          name: OrderByDirection
          email: OrderByDirection
        }

        type UserReturning {
          name: String!
          email: String!
        }

        input UserUpdateInput {
          name: StringUpdateInput
          email: StringUpdateInput
        }

        type UserUpdateManyPayload {
          """
            Returned items from the mutation.
          """
          returning: [UserReturning]!
          """
            The number of rows mutated.
          """
          rowCount: Int!
        }

        type UserUpdatePayload {
          """
            Returned item from the mutation.
          """
          returning: UserReturning
          """
            The number of rows mutated.
          """
          rowCount: Int!
        }

        schema {
          query: Query
          mutation: Mutation
        }
    "#]];

    expected.assert_eq(&response);
}