git.iko.soy/project-m36
on master help sign in
add dynamic function examples and documentation
commitf9adb0e84509708977fc1b0fc71027b13c670f11 authorAgentM <agentm@themactionfaction.com> dateTue 15 May 2018, 10:40 (8 years ago) parente0b76ea
4 files changed+119−2
compare with master
unifiedsplit
docs/atomfunctions.markdown+30−1 docs/database_context_functions.markdown+51−1 examples/DynamicAtomFunctions.hs+12 examples/DynamicDatabaseContextFunctions.hs+26
docs/atomfunctions.markdown+30−1
@@ -6,7 +6,7 @@ While Project:M36 includes a set of basic function which operate on relational v
66
77Other DBMSes also include this feature by way of stored functions such as with PL/pgsql, T-SQL, or PL/SQL.
88
9−Project:M36 allows users to implement strongly-typed and pure atom functions in the Haskell language at runtime. This facility makes use of GHC, the Haskell compiler, as a runtime service.
9+Project:M36 allows users to implement strongly-typed and pure atom functions in the Haskell language at runtime. This facility makes use of GHC, the Haskell compiler, as a runtime service. Alternatively, Haskell-based atom functions can be pre-compiled and loaded at runtime.
1010
1111## Atom Function Example
1212
@@ -41,6 +41,35 @@ Project:M36 also supports polymorphic types when used with atom functions. Here
4141addatomfunction "idTest" a -> Either AtomFunctionError a "(\(x:_) -> pure x) :: [Atom] -> Either AtomFunctionError Atom"
4242```
4343
44+## Pre-compiled Atom Functions
45+
46+Compiling atom functions at runtime can incur a performance cost. To mitigate this, atom functions can be compiled by GHC to object files and then loaded into the Project:M36 server. Let's look at an [example](https://github.com/agentm/project-m36/):
47+
48+```haskell
49+module DynamicAtomFunctions where
50+import ProjectM36.Base
51+
52+someAtomFunctions :: [AtomFunction]
53+someAtomFunctions = [AtomFunction{
54+ atomFuncName = "constTrue",
55+ atomFuncType = [TypeVariableType "a", BoolAtomType],
56+ atomFuncBody = AtomFunctionBody Nothing (\(x:_) -> pure (BoolAtom True))}]
57+```
58+
59+Any function inside any module which returns a list of `AtomFunction`s can be used to load more atom functions. First, create the Haskell object file:
60+
61+`cabal exec ghc -- examples/DynamicAtomFunctions.hs -package project-m36`
62+
63+Use cabal or stack to invoke ghc so that the project-m36 installed package will be found.
64+
65+Finally, connect to your Project:M36 database using the `tutd` client and run:
66+
67+`TutorialD (master/main): loadatomfunctions "DynamicAtomFunctions" "someFunctions" "examples/DynamicAtomFunctions.o"`
68+
69+If you see an error such as "unknown symbol", the version of the "project-m36" library installed in your sandbox is different from that with which you linked the object file. Make sure that the same versions are used in linking the server and object file.
70+
71+The atom function is now loaded and ready-to-use. Note, however, that the function must be added every time the project-m36-server starts. This will probably be improved in a future release.
72+
4473## Differences when compared to other DBMSes
4574
4675Project:M36 enforces strongly-typed atom functions. Specifically, atom functions must be pure (free of any side effects) and cannot operate on any variables other than the atoms passed in. This certainly sets stricter limits on what can be accomplished in an atom function when compared to stored functions in other DBMS products. For example, an atom function in Project:M36 would never be able to retrieve stock information from an external website because such a function cannot be pure and thus would be rejected by the atom function compiler. This restriction maintains the mathematical cohesiveness of the database and allows the DBMS to make performance-enhancing inferences it would not otherwise be able to make.
docs/database_context_functions.markdown+51−1
@@ -6,7 +6,7 @@ While "atom functions" operate on individual values and return new values (atoms
66
77Other DBMS software may include a similar feature called "stored procedures". However, "stored procedures" are stored outside the transaction stream and are not versioned by the database as in Project:M36.
88
9−In order to use this feature in Project:M36, be sure to build your own Project:M36 library so that the optional scripting is enabled.
9+In order to use compile functions at runtime in Project:M36, be sure to build your own Project:M36 library so that the optional scripting is enabled. Alternatively, precompiled database context functions can be loaded from object files.
1010
1111## Database Context Function Types
1212
@@ -112,6 +112,56 @@ executeDatabaseContextExpr sessionId dbconn (ExecuteDatabaseContextFunction func
112112```
113113from the same module.
114114
115+## Loading Precompiled Modules
116+
117+Database context functions compiled with GHC to object files can be loaded at runtime. Let's walk through an example:
118+
119+```haskell
120+module DynamicDatabaseContextFunctions where
121+import ProjectM36.Base
122+import ProjectM36.Relation
123+import ProjectM36.DatabaseContextFunctionError
124+import qualified ProjectM36.Attribute as A
125+
126+import qualified Data.Map as M
127+
128+
129+someDBCFunctions :: [DatabaseContextFunction]
130+someDBCFunctions = [DatabaseContextFunction {
131+ dbcFuncName = "addtestrel",
132+ dbcFuncType = [],
133+ dbcFuncBody = DatabaseContextFunctionBody Nothing addTestRel
134+ }]
135+ where
136+ addTestRel _ ctx = do
137+ let attrs = A.attributesFromList [Attribute "word" TextAtomType]
138+ eRel = mkRelationFromList attrs [[TextAtom "nice"]]
139+ case eRel of
140+ Left err -> Left (DatabaseContextFunctionUserError (show err))
141+ Right testRel ->
142+ pure $ ctx { relationVariables = M.insert "testRel" testRel (relationVariables ctx) }
143+```
144+
145+The function returns a list of `DatabaseContextFunction`s which adds a relation variable to the current database context.
146+
147+Compile it with GHC:
148+
149+```
150+cabal exec ghc -- examples/DynamicDatabaseContextFunctions.hs -package project-m36
151+```
152+
153+or invoked GHC via stack.
154+
155+Finally, connect to your database with `tutd` and load the module:
156+
157+```
158+TutorialD (master/main): loaddatabasecontextfunctions "DynamicDatabaseContextFunctions" "someDBCFunctions" "examples/DynamicDatabaseContextFunctions.o"
159+```
160+
161+If the load reports an "unknown symbol" error, double check that the installed "project-m36" package is identical to one used to link the Haskell module.
162+
163+Note that such functions do not survive a server restart; this will likely be improved in a future release.
164+
115165## Future Improvements
116166
117167There are likely a variety of convenience functions which would make sense in the context of the scripted function. If you have ideas for such functions, please open a GitHub issue.
examples/DynamicAtomFunctions.hsnew file+12
@@ -0,0 +1,12 @@
1+{-# LANGUAGE OverloadedStrings #-}
2+--compile with `cabal exec ghc -- examples/DynamicAtomFunctions.hs -package project-m36`
3+--load with `loadatomfunctions "DynamicAtomFunctions" "someAtomFunctions" "examples/DynamicAtomFunctions.o"`
4+
5+module DynamicAtomFunctions where
6+import ProjectM36.Base
7+
8+someAtomFunctions :: [AtomFunction]
9+someAtomFunctions = [AtomFunction{
10+ atomFuncName = "constTrue",
11+ atomFuncType = [TypeVariableType "a", BoolAtomType],
12+ atomFuncBody = AtomFunctionBody Nothing (\(x:_) -> pure (BoolAtom True))}]
examples/DynamicDatabaseContextFunctions.hsnew file+26
@@ -0,0 +1,26 @@
1+{-# LANGUAGE OverloadedStrings #-}
2+--compile with `cabal exec ghc -- examples/DynamicDatabaseContextFunctions.hs -package project-m36`
3+--load with `loaddatabasecontextfunctions "DynamicDatabaseContextFunctions" "someDBCFunctions" "examples/DynamicDatabaseContextFunctions.o"`
4+module DynamicDatabaseContextFunctions where
5+import ProjectM36.Base
6+import ProjectM36.Relation
7+import ProjectM36.DatabaseContextFunctionError
8+import qualified ProjectM36.Attribute as A
9+
10+import qualified Data.Map as M
11+
12+
13+someDBCFunctions :: [DatabaseContextFunction]
14+someDBCFunctions = [DatabaseContextFunction {
15+ dbcFuncName = "addtestrel",
16+ dbcFuncType = [],
17+ dbcFuncBody = DatabaseContextFunctionBody Nothing addTestRel
18+ }]
19+ where
20+ addTestRel _ ctx = do
21+ let attrs = A.attributesFromList [Attribute "word" TextAtomType]
22+ eRel = mkRelationFromList attrs [[TextAtom "nice"]]
23+ case eRel of
24+ Left err -> Left (DatabaseContextFunctionUserError (show err))
25+ Right testRel ->
26+ pure $ ctx { relationVariables = M.insert "testRel" testRel (relationVariables ctx) }