Nim - Norm - How to get related fieldnames at compile time

Question

Heyho,

I am using norm, an orm in the nim programming language. I have 2 different models such as this:

import std/options
import norm

type
    A {.tableName: "Surprise".} = ref object of Model
        name: string

    Surprise = ref object of Model
        name: string
        anotherFieldThatExistsOnTheSQLTableButNotOnA: int

    B = ref object of Model
        name: string
        myA: Option[A]

I want to be able to figure out at compile time the name of a given foreign key-field (here myA) that points to a given table (here Surprise) even if the model has a different name than the actual table or is a read-only model (e.g. A). That way I can write SQL queries at compile time that get me the many of a many-to-one relationship.

More importantly, I want this grabbing of the foreign-key relationship to be based upon the tableName of a model, not the model itself. Thus, if I were to define a proc getRelatedFieldName(startType: typedesc[A], otherType: typedesc[B]), it would need to give the same result for both getRelatedFieldName(A, B) AND getRelatedFieldName(A, Surprise).

How can I achieve this?

score 2 · Accepted Answer · answered Jan 07 '22 at 23:30

Thanks to some hints of the very helpful folks at the nim discord server, I was able to write the solution.

The answer is: Nim's generics, Nim's getCustomPragmaVal macro and Norm's table template.

The below code takes 2 model-types. It dummy-instantiates the sourceType since that's the type that potentially has a foreignKey-field to your targetType. It then iterates over the fields of sourceType and checks whether they are either directly a Model type, are annotated with an fk aka foreignKey pragma, or are an Option[Model] type.

If the field has a Model type, the issue is solved since you can just call Model.table() and you're done. If the field has an fk pragma, you can simply call getCustomPragmaVal to get the Model that this field is a foreign key for. With that you have the type and can just call table() on that. Lastly, you may have an Option[Model] type. In that case you need to extract the generic parameters using the genericParams function (see here). That way you can, once again, access the type and call table() on that.

proc getRelatedFieldName[M: Model, O:Model](targetType: typedesc[O], sourceType: typedesc[M]): Option[string] =
    let source = sourceType()
    for sourceFieldName, sourceFieldValue in source[].fieldPairs:
        #Handles case where field is an int64 with fk pragma
        when sourceFieldValue.hasCustomPragma(fk):
            when O.table() == sourceFieldValue.getCustomPragmaVal(fk).table():
                return some(sourceFieldName)
        
        #Handles case where field is a Model type
        when sourceFieldValue is Model:
            when O.table() == sourceFieldValue.type().table():
                return some(sourceFieldName)
        
        #Handles case where field is a Option[Model] type
        when sourceFieldValue is Option:
            when sourceFieldValue.get() is Model:
                when O.table() == genericParams(sourceFieldValue.type()).get(0).table():
                    return some(sourceFieldName) 

    return none(string)

example

type
    A = ref object of Model # <-- has implicit tableName "A"
        name: string
    AC {.tableName: "A".} = ref object of Model
        myothername: string
        name: string

    B = ref object of Model # <-- has implicit tableName "B"
        name: string
        myA: Option[A]
    D = ref object of Model
        myothernameid: int
        myDA: A
    E = ref object of Model
        myotherbool: bool
        myEA {.fk: A.}: int64

    
echo A.getRelatedFieldName(B) # some("myA")
echo AC.getRelatedFieldName(B) # some("myA")
echo A.getRelatedFieldName(D) # some("myDA")
echo AC.getRelatedFieldName(D) # some("myDA")
echo A.getRelatedFieldName(E) # some("myEA")
echo AC.getRelatedFieldName(E) # some("myEA")

Nim - Norm - How to get related fieldnames at compile time

1 Answers1