text: Title: Add support for selecting fields
  Body: ## Problem
  
  A crucial part of modern and performant ORMs is the ability to choose what fields are returned, Prisma Client Python is currently missing this feature.
  
  ## Mypy solution
  
  As we have a mypy plugin we can dynamically modify types on the fly, this means we would be able to make use of a more ergonomic solution.
  
  ```py
  class Model(BaseModel):
    id: str
    name: str
    points: Optional[int]
  
  class SelectedModel(BaseModel):
    id: Optional[str]
    name: Optional[str]
    points: Optional[int]
  
  ModelSelect = Iterable[Literal['id', 'name', 'points']]
  
  @overload
  def action(
  	...
  ) -> Model:
  	...
  
  @overload
  def action(
  	...
  	select: ModelSelect
  ) -> SelectedModel:
  	...
  
  model = action(select={'id', 'name'})
  ```
  
  The mypy plugin would then dynamically remove the `Optional` from the model for every field that is selected, we might also be able to remove the fields that aren't selected although I don't know if this is possible.
  
  The downside to a solution like this is that unreachable code will not trigger an error when type checking with a type checker other than mypy, e.g.
  
  ```py
  user = await client.user.find_first(select={'name'})
  if user.id is not None:
    print(user.id)
  ```
  
  Will pass type checks although the if block will never be ran.
  
  EDIT: A potential solution for the above would be to not use optional and instead use our own custom type, e.g. maybe something like `PrismaMaybeUnset`. This has its own downsides though.
  
  EDIT: I also think we may also want to support setting a "default include" value so that relations will always be fetched unless explicitly given `False`. This will not change the generated types and they will still be `Optional[T]`.
  
  ## Type checker agnostic solution
  
  After #59 is implemented the query builder should only select the fields that are present on the given `BaseModel`.
  
  This would mean that users could generate partial types and then easily use them to select certain fields.
  
  ```py
  User.create_partial('UserOnlyName', include={'name'})
  ```
  ```py
  from prisma.partials import UserOnlyName
  
  user = await UserOnlyName.prisma().find_unique(where={'id': 'abc'})
  ```
  
  Or create models by themselves
  
  ```py
  class User(BaseUser):
    name: str
  
  user = await User.prisma().find_unique(where={'id': 'abc'})
  ```
  
  This will make typing generic functions to process models more difficult, for example, the following function would not accept custom models.:
  
  ```py
  def process_user(user: User) -> None:
    ...
  ```
  
  It could however be modified to accept objects with the correct properties by using a `Protocol`.
  
  ```py
  class UserWithID(Protocol):
    id: str
  
  def process_user(user: UserWithID):
    ...
  ```