[Feature Request] Allow specifying Read-Only Models
Heyho,

I use norm as an interface to an already existing database that was created by Django (I'm effectively reimplementing an already existing backend).
The way I use norm includes having multiple models on the same table, some with their FK fields resolved into the full data of those other entries, some where various fields are left out because they aren't needed.
This allows inserts with only the minimal amount of data necessary (So no entire models of linked fields necessary), while also giving me the ability to have "slices" of data from my database instead of the whole thing, avoiding unnecessary data fetches etc. 

Right now, if I used one of these models and tried to instantiate an entry with it, I would run into a DbError **at runtime**.
It would be beneficial to move this problem to compile time by providing an alias to the `Model` type, that can do all the same things as `Model` but does not have methods whose signature allow for insert/update/delete operations with them.

Without the necessary procs, a developer using the library would be notified at compile time that he's doing something wrong by creating/updating/deleting with a read-only model.

I'm not sure how much effort or complexity this ads, because I'm not sure how such a model would e.g. need to handle ids.
Does this seem sensible to you as well?
If yes, are there any things are possible problems I might be overlooking?

As an example:
Let's say I have a model of a character that represents the actual table "character":
```nim
type Character* {.tableName: CHARACTER_TABLE.} = ref object of Model
    ##[TableModel of the table of story characters. ]##
    player_character*: bool #Whether the character is controlled by a player or not
    alive*: bool
    name*: string
    gender*: string
    race*: string
    title*: Option[string] # A title the character might have, e.g. "Lord", "Duke", "Doctor"
    description*: Option[string] # A description of the character
    current_location_id*: Option[int] # The id of the location at which the character is currently located
    creation_datetime*: DateTime
    update_datetime*: DateTime
    campaign_id*: int # The id of the campaign that this character occurred in
```

and let's say there's scenarios where I want to display just a list of characters. To save myself performance and unnecessary data fetches, I can just define an "overview" model with *only* the fields I would want for such a list:

```nim
type CharacterOverview* {.tableName: CHARACTER_TABLE.} = ref object of Model
    ##[A reduced Model of a story-character. Cut down to the bare minimum needed to
    make a list of characters with necessary meta data ]##
    player_character*: bool
    alive*: bool
    name*: string
    update_datetime*: DateTime
```

Right now I could try to make a row in the table "character" with that `CharacterOverview` model. I am avoiding this right now through naming schema and documentation (well and by knowing how I intend to use them), but ideally I should never have even the possibility to make this mistake.