Form.Attributes 0.0.1

F# Object Relational Mapper

An attribute based ORM for fsharp.

Usage

To start, enumerate your databases:

type Contexts = 
    | Database1 = 1
    | Database2 = 2

We use enumeration here as Unions are not supported by attributes as of yet. The number that each database is set to doesn't really matter, but at the moment this is the best way we have found to generalize and organize contextualized attributes.

Next, use attributes to perform your domain modeling:

[<Table("User", Contexts.Database1)>]
[<Table("Users", Contexts.Database2)>]
type User = 
    { Id : int
      [<Column("Name", Contexts.Database1)>]
      [<Column("Login", Contexts.Database2)>]
      Name : string
      [<Column("Secret", Contexts.Database1)>]
      Password : string
      Salt : string
    }

Table and Column attributes take a name and a context. The name must match that of the relevant object in the database which is referred to by the given context; that is to say, the User type refers to a table called "User" in Database1, and "Users" in Database2. If no attribute is given, the underlying logic will default to the name of the type/field, so if you use the same names in your project and your database(s), no Table/Column attribute is necessary; i.e., the "Id" field will be assumed to map to an "Id" field in both the "User" table in Database1, and the same in the "Users" table in Database2.

Before we connect, we must also declare some OrmStates. We will need one for each context:

let db1State = PSQL(db1ConnectionString, Contexts.Database1)
let db2State = MSSQL(db2ConnectionString, Contexts.Database2)

The connection strings should just be given as strings, deliver these however you see fit (we recommend either putting them in a .env file or setting an environmental variable the will deliver the connection string, we may add some helper functions for this later).

Now we can do some querying:

selectAll<User> db1State |> printfn "%A"

This should send a SELECT * query to the db1./.User table, if everything was setup correctly. Keep in mind that our querying functions return Result<[]^T, {| Message |}>, so be prepared to handle those accordingly.

We also include a custom query framework; an example:

let query =
    { clauses = 
        [ select<User>
        ; from<User>
        ; join<User> [First ("Id", Equals "42"); And ("Name", NotEquals "'Jim'")]
        ] 
    }.Compile db1State

The compilation returns a string, and if printed the above should be:

"SELECT "Id", "Name", "Secret", "Salt" FROM "User" JOIN "User" On "Id" = 42 AND "Name" = 'Jim'"

Obviously, you may need to specify Schema in table declarations. We are currently ruminating over the idea of a schema attribute, but for now just add the schema name to the table attribute:

[<Table("SchemaName.User", Contexts.Database1)>]

and the logic will sort it all out:

"SELECT "Id", "Name", "Secret", "Salt" FROM "SchemaName"."User" JOIN "SchemaName"."User" On "Id" = 42 AND "Name" = 'Jim'"

Disambiguation of columns will be necessary for joins, we will be adding that soon.

Once you have the query you need, simply execute it:

let rowsAffected = execute query db1State //This is a non-query execution, does not return a result set
let queryResults = executeReader query generatereader db1State //This DOES return a result set, in this case a Result<[]User, {| Message |}> 

Though this package itself awaits full testing, we have taken most of these pieces from other projects which have been thoroughly tested, so this package should work more or less out of the box.

Contribution Guidelines

Currently no strict guidelines, just open a pull request or an issue. Feel free to shoot us an email if you have any questions!

Note:

• Contributions are welcome!
• This has yet to be tested fully.
• Under active development.