efc8ec0 · project-m36 · git.iko.soy

git.iko.soy/project-m36

on master help sign in

Merge branch 'master' of https://github.com/agentm/project-m36

efc8ec0AgentM8 years ago

docs/introduction_to_projectm36.markdown+1−1

compare with master

unifiedsplit

@@ -40,7 +40,7 @@ Compilation steps:

41* ```git clone https://github.com/agentm/project-m36```

42* ```cd project-m36```

43−* ```stack --stack_yaml stack.ghc8.2.yaml build```

43+* ```stack --stack-yaml stack.ghc8.2.yaml build```

45At this point, the TutorialD interactive interpreter can be run using ```stack exec tutd```.

docs/new_datatypes.markdown+1−1

@@ -106,6 +106,6 @@ The essential ```Atomable``` typeclass functions are:

106| ```toAtomType :: Proxy a -> AtomType``` | generate a database AtomType for a Haskell datatype |

107| ```toAddTypeExpr :: Proxy a -> DatabaseContextExpr``` | generate a ```DatabaseContextExpr``` which can be executed against a database context in order to add the new type |

108

109−In addition, basic Haskell data types like ```Int```, ```Double```, ```Text```, ```Day```, ```Bool```, ```UTCTime```, and l```ByteString``` already have `Atomable` instances ready-to-go. In addition, an ```Atomable``` instance is available for lists: ```Atomable a => [a]```, though one should be very careful not to use this in a common anti-pattern. Typically, it makes more sense to store one-to-many relationships as discrete relation variables; when storing them as lists, one gives up the various query capabilities and optimizations of the relational algebra.

109+In addition, basic Haskell data types like ```Int```, ```Double```, ```Text```, ```Day```, ```Bool```, ```UTCTime```, and ```ByteString``` already have `Atomable` instances ready-to-go. In addition, an ```Atomable``` instance is available for lists: ```Atomable a => [a]```, though one should be very careful not to use this in a common anti-pattern. Typically, it makes more sense to store one-to-many relationships as discrete relation variables; when storing them as lists, one gives up the various query capabilities and optimizations of the relational algebra.

110

111To be clear, these data types are not black boxes once stored in the database. These new types can be scanned and manipulated by Haskell scripts which can be created at runtime. For more information, read about [```AtomFunction```s](/docs/atomfunctions.markdown).

docs/transaction_graph_operators.markdown+2−14

@@ -10,23 +10,11 @@ When a new database is created, a new transaction graph is created for it with o

11As the user interactively alters the database context such as by adding a new relation variable, the database context is no longer equal to that of the first transactions. This is called "database context divergence" because many of the same components exist in both the updated context and the context of the first transaction.

13−![Initial database starting state](http://g.gravizo.com/g?

13+![Initial database starting state](http://g.gravizo.com/g?%20digraph%20G%20{%20base[label=%22base%20transaction%22,shape=rectangle];%20new[label=%22mutable%20database%20context%22];%20new%20-%3E%20base;%20})

14−digraph G {

15− base[label="base transaction",shape=rectangle];

16− new[label="mutable database context"];

17− new -> base;

18−})

20Once the user decides that the changes in the updated database context are worth adding to the transaction graph, the user issues a "commit" request. The commit operation converts the current database context into a new transaction which is then added to the graph with the parent transaction set to the same parent transaction as the database context. The user's mutable database context is shifted to be a copy of the context of the newly-committed transaction.

15Once the user decides that the changes in the updated database context are worth adding to the transaction graph, the user issues a "commit" request. The commit operation converts the current database context into a new transaction which is then added to the graph with the parent transaction set to the same parent transaction as the database context. The user's mutable database context is shifted to be a copy of the context of the newly-committed transaction.

22−![Freshly committed transaction](http://g.gravizo.com/g?

17+![Freshly committed transaction](http://g.gravizo.com/g?%20digraph%20G%20{%20base[label=%22base%20transaction%22,shape=rectangle];%20discon[label=%22mutable%20database%20context%22];%20fresh[label=%22newly%20committed%20transaction%22,shape=rectangle];%20fresh%20-%3E%20base;%20discon%20-%3E%20fresh;%20})

23−digraph G {

24− base[label="base transaction",shape=rectangle];

25− discon[label="mutable database context"];

26− fresh[label="newly committed transaction",shape=rectangle];

27− fresh -> base;

28− discon -> fresh;

29−})

31It can be handy to attempt to modify the database without altering the data that others may wish to continue to use and modify. If a set of transactions may diverge from another use-case for the data, the user may choose to "branch" the transaction graph. Branching allows the user to assign an arbitrary name to a series of transactions and then potentially merge the set of transactions back to the originating branch. Project:M36 creates a "master" branch when the transaction graph is first created.

19It can be handy to attempt to modify the database without altering the data that others may wish to continue to use and modify. If a set of transactions may diverge from another use-case for the data, the user may choose to "branch" the transaction graph. Branching allows the user to assign an arbitrary name to a series of transactions and then potentially merge the set of transactions back to the originating branch. Project:M36 creates a "master" branch when the transaction graph is first created.

docs/tutd_tutorial.markdown+17−17

@@ -14,6 +14,22 @@ TutorialD (master/main):

15"master" refers to the name of the branch to which the current transaction will be potentially committing.

17+### Date's Sample Relations

18+

19+The examples in this tutorial can be executed after loading Chris Date's sample relations using:

20+

21+```

22+:importexample date

23+```

24+

25+Each section assumes a fresh instance of the Date examples. The relation variables created in the script are:

26+

27+|Relation Variable Name|Description|

28+|----------------------|-----------|

29+|s|suppliers|

30+|p|parts|

31+|sp|contains mapping of which suppliers supply which parts|

32+

17### Types

33### Types

19TutorialD is strongly-typed. The basic built-in types are:

35TutorialD is strongly-typed. The basic built-in types are:

@@ -37,7 +53,7 @@ The ```interval``` function last two arguments are boolean values indicating whe

37Project:M36 will complain loudly if the expected types do not match. Automatic type coercion does not exist.

53Project:M36 will complain loudly if the expected types do not match. Automatic type coercion does not exist.

39```

55```

40−TutorialD (master/main): :showexpr S:{more:=add(10,@sname)}

56+TutorialD (master/main): :showexpr s:{more:=add(10,@sname)}

41ERR: AtomFunctionTypeError "add" 2 IntAtomType StringAtomType

57ERR: AtomFunctionTypeError "add" 2 IntAtomType StringAtomType

42```

58```

@@ -68,22 +84,6 @@ Chris Date refers to these relations as "TABLE_DUM" and "TABLE_DEE" but such arb

68products{}

84products{}

69```

85```

71−### Date's Sample Relations

72−

73−The examples in this tutorial can be executed after loading Chris Date's sample relations using:

74−

75−```

76−:importexample date

77−```

78−

79−Each section assumes a fresh instance of the Date examples. The relation variables created in the script are:

80−

81−|Relation Variable Name|Description|

82−|----------------------|-----------|

83−|s|suppliers|

84−|p|parts|

85−|sp|contains mapping of which suppliers supply which parts|

86−

87### Relational Expressions

89A relational expression combines relational operators to create a new relation. ```tutd``` can display the result of executing a relational expression with ":showexpr".