8c305bd...master · project-m36

.appveyor.yml+2−3

since splitsnapshots

unifiedsplit

@@ -17,8 +17,7 @@ environment:

17 global:

18 STACK_ROOT: "c:\\sr"

19 matrix:

20− - YAML: "stack.ghc8.2.yaml"

20+ - YAML: "stack.ghc8.6.yaml"

21− - YAML: "stack.ghc8.4.yaml"

22

21

23platform:

22platform:

24 - x64

23 - x64

@@ -37,4 +36,4 @@ test_script:

37

36

38#artifacts:

37#artifacts:

39# - path: project-m36.7z

38# - path: project-m36.7z

40−# name: project-m36.7z

39+# name: project-m36.7z

.github/workflows/ci.yamlnew file+69

@@ -0,0 +1,69 @@

1+name: "CI"

2+on:

3+ pull_request:

4+ push:

5+jobs:

6+ dockerimage:

7+ runs-on: ubuntu-latest

8+ steps:

9+ - uses: actions/checkout@v2.3.1

10+ - uses: cachix/install-nix-action@v12

11+ with:

12+ nix_path: nixpkgs=channel:nixos-unstable

13+ - uses: cachix/cachix-action@v8

14+ with:

15+ name: project-m36

16+ signingKey: "${{ secrets.CACHIX_SIGNING_KEY }}"

17+ - run: cachix use iohk

18+ - name: docker load

19+ run: docker load < $(nix-build docker.nix)

20+ - name: docker login

21+ if: ${{ github.ref == 'refs/heads/master' }}

22+ run: echo ${{secrets.DOCKERHUB_PASSWORD}} | docker login --username ${{secrets.DOCKERHUB_USER}} --password-stdin

23+ - name: docker tag with version

24+ run: docker tag project-m36:latest projectm36/project-m36:$(awk '/^Version:/ {print $2}' project-m36.cabal)

25+ if: ${{ github.ref == 'refs/heads/master' }}

26+ - name: docker tag latest

27+ run: docker tag project-m36:latest projectm36/project-m36:latest

28+ if: ${{ github.ref == 'refs/heads/master' }}

29+ - run: docker push projectm36/project-m36

30+ if: ${{ github.ref == 'refs/heads/master' }}

31+

32+ stack-build:

33+ runs-on: ${{ matrix.os }}

34+ strategy:

35+ matrix:

36+ os: [ubuntu-latest]

37+ ghc:

38+ - ghc8.10

39+ - ghc8.8

40+ - ghc8.6

41+ include:

42+ - os: macos-latest

43+ ghc: ghc8.10

44+ env:

45+ STACK_YAML: stack.${{ matrix.ghc }}.yaml

46+ steps:

47+ - uses: actions/checkout@v2

48+ - name: Cache

49+ uses: actions/cache@v1

50+ with:

51+ path: ~/.stack

52+ key: ${{ runner.os }}-build-stack-${{ matrix.ghc }}-${{ hashFiles(env.STACK_YAML) }}-${{ hashFiles('**/*.cabal') }}

53+ restore-keys: |

54+ ${{ runner.os }}-build-stack-${{ matrix.ghc }}-${{ hashFiles(env.STACK_YAML) }}

55+ ${{ runner.os }}-build-stack-${{ matrix.ghc }}

56+ - name: Fix macOS cache bug

57+ run: rm -rf ~/.stack/setup-exe-cache

58+ - name: Build

59+ run: stack build --ghc-options -O2 --local-bin-path out --copy-bins

60+ - name: Test

61+ run: stack test --stack-yaml=${{ env.STACK_YAML }}

62+ - name: HLint

63+ run: curl -sSL https://raw.github.com/ndmitchell/hlint/master/misc/run.sh | sh -s .

64+ - name: Haddock

65+ run: stack --no-install-ghc --system-ghc --no-haddock-deps haddock

66+ - uses: actions/upload-artifact@v2

67+ with:

68+ name: project-m36-${{ matrix.os }}-${{ matrix.ghc }}

69+ path: out/

.gitignore+3−1

@@ -18,4 +18,6 @@ persistence-notes

18jupyter/itutd.egg-info

19jupyter/build

20juyter/dist

21−.ipynb_checkpoints

21+.ipynb_checkpoints

22+project-m36.nix

23+stack.yaml

.travis.ymldeleted−60

@@ -1,60 +0,0 @@

1−# For more information, see https://github.com/ChrisPenner/haskell-stack-travis-ci

2−language: c

3−sudo: false

4−

5−git:

6− submodules: false # whether to recursively clone submodules

7−

8−cache:

9− directories:

10− - $HOME/.ghc

11− - $HOME/.cabal

12− - $HOME/.stack

13− - .stack-work

14− timeout: 1000

15−

16−matrix:

17− fast_finish: true

18− include:

19− - env: CACHE_NAME=8.2.2 STACK_YAML=stack.ghc8.2.yaml

20− compiler: ": #stack 8.2.2"

21−

22− - env: CACHE_NAME=osx-8.2.2 STACK_YAML=stack.ghc8.2.yaml

23− os: osx

24− os_image: xcode7.3

25− compiler: ": #stack 8.2.2"

26−

27− - env: CACHE_NAME=8.4.3 STACK_YAML=stack.ghc8.4.yaml

28− compiler: ": #stack 8.4.3"

29−

30−before_script:

31− - unset CC

32− - export PATH=$HOME/.local/bin:/opt/ghc/$GHC_VERSION/bin:$PATH

33− - ./.travis/install-ghr.sh

34− - ./.travis/install-stack.sh

35−

36−# Here starts the actual work to be performed for the package under test;

37−# any command which exits with a non-zero exit code causes the build to fail.

38−script:

39− - |

40− # Run tests

41− set -e

42− ./.travis/install-dependencies.sh

43− stack --no-terminal --jobs=2 --system-ghc test

44− - |

45− #Run HLint

46− if [[ "$(uname)" = "Linux" ]]; then

47− curl -sL https://raw.github.com/ndmitchell/hlint/master/misc/travis.sh | sh -s lint src test examples --cpp-define VERSION_project_m36=HLINT

48− fi

49− - |

50− #Run Haddock

51− if [[ "$(uname)" = "Linux" ]]; then

52− stack --no-install-ghc --system-ghc --no-haddock-deps haddock

53− fi

54−

55−after_success:

56− - |

57− # Build and ship binary

58− #./.travis/attach-binary.sh

59−

60−# EOF

.travis/attach-binary.shdeleted−25

@@ -1,25 +0,0 @@

1−#!/bin/sh

2−set -o errexit -o verbose

3−

4−if test ! "$BUILD_BINARY" || test ! "$TRAVIS_TAG"

5−then

6− echo 'This is not a release build.'

7−elif test ! "$GITHUB_TOKEN"

8−then

9− echo 'The GITHUB_TOKEN environment variable is not set!'

10− exit 1

11−else

12− echo "Building binary for $TRAVIS_OS_NAME to $TRAVIS_TAG..."

13− stack build --ghc-options -O2 --pedantic

14− echo "Attaching binary for $TRAVIS_OS_NAME to $TRAVIS_TAG..."

15− OWNER="$(echo "$TRAVIS_REPO_SLUG" | cut -f1 -d/)"

16− REPO="$(echo "$TRAVIS_REPO_SLUG" | cut -f2 -d/)"

17− BIN="$(stack path --local-install-root)/bin/$REPO"

18− BUNDLE_NAME="$REPO-$TRAVIS_TAG-$TRAVIS_OS_NAME.tar.gz"

19− cp "$BIN" "./$REPO"

20− chmod +x "./$REPO"

21− tar -czf "$BUNDLE_NAME" "$REPO"

22− echo "SHA256:"

23− shasum -a 256 "$BUNDLE_NAME"

24− ghr -t "$GITHUB_TOKEN" -u "$OWNER" -r "$REPO" --replace "$(git describe --tags)" "$BUNDLE_NAME"

25−fi

.travis/install-dependencies.shdeleted−22

@@ -1,22 +0,0 @@

1−# Run tests

2−if [[ "$(uname)" = "Darwin" ]]; then

3− timeout_cmd="gtimeout"

4−else

5− timeout_cmd="timeout"

6−fi

7−$timeout_cmd 40m stack --no-terminal --jobs=2 --install-ghc --system-ghc build --only-dependencies --fast

8−ret=$?

9−case "$ret" in

10− 0)

11− # continue

12− ;;

13− 124)

14− echo "Timed out while installing dependencies."

15− echo "Try building again by pushing a new commit."

16− exit 1

17− ;;

18− *)

19− echo "Failed to install dependencies; stack exited with $ret"

20− exit "$ret"

21− ;;

22−esac

.travis/install-ghc.shdeleted−16

@@ -1,16 +0,0 @@

1−#!/bin/sh

2−set -eux

3−#assume stack is installed

4−STACK=~/.local/bin/stack

5−

6−fetch_ghc_osx() {

7− echo "Using stack to install GHC $GHC_VERSION"

8− $STACK setup $GHC_VERSION

9−}

10−

11−if [ "$(uname)" = "Darwin" ]; then

12− fetch_ghc_osx

13−else

14− #installed by apt

15− echo "Linux GHC $GHC_VERSION via APT already installed."

16−fi

.travis/install-ghr.shdeleted−21

@@ -1,21 +0,0 @@

1−#!/bin/sh

2−set -o errexit -o verbose

3−

4−if test ! "$BUILD_BINARY" || test ! "$TRAVIS_TAG"

5−then

6− echo 'This is not a release build.'

7−else

8− if [ "$TRAVIS_OS_NAME" = "linux" ]

9− then

10− ARCH="linux"

11− else

12− ARCH="darwin"

13− fi

14− echo "Installing ghr"

15− URL="https://github.com/tcnksm/ghr/releases/download/v0.5.4/ghr_v0.5.4_${ARCH}_386.zip"

16− curl -L ${URL} > ghr.zip

17− mkdir -p "$HOME/bin"

18− export PATH="$HOME/bin:$PATH"

19− unzip ghr.zip -d "$HOME/bin"

20− rm ghr.zip

21−fi

.travis/install-stack.shdeleted−27

@@ -1,27 +0,0 @@

1−#!/bin/sh

2−

3−# Adapted from https://github.com/commercialhaskell/stack

4−

5−set -eux

6−

7−travis_retry() {

8− cmd=$*

9− $cmd || (sleep 2 && $cmd) || (sleep 10 && $cmd)

10−}

11−

12−fetch_stack_osx() {

13− curl -skL https://www.stackage.org/stack/osx-x86_64 | tar xz --strip-components=1 --include '*/stack' -C ~/.local/bin;

14−}

15−

16−fetch_stack_linux() {

17− curl -sL https://www.stackage.org/stack/linux-x86_64 | tar xz --wildcards --strip-components=1 -C ~/.local/bin '*/stack';

18−}

19−

20−# We need stack to generate cabal files with precise bounds, even for cabal

21−# builds.

22−mkdir -p ~/.local/bin;

23−if [ "$(uname)" = "Darwin" ]; then

24− travis_retry fetch_stack_osx

25−else

26− travis_retry fetch_stack_linux

27−fi

Changelog.markdown+33

@@ -1,3 +1,36 @@

1+# 2021-04-01 (v0.9.3)

2+

3+* add new ":importtutd <URI> <SHA256 hash>" feature to import TutorialD from a local file or a HTTP/HTTPS URI

4+

5+# 2020-12-27 (v0.9.0)

6+

7+* replace unmaintained distributed-process-client-server RPC package with new curryer RPC package

8+* drop support for GHC 8.2 and GHC 8.4 due to dependency on DerivingVia extension

9+

10+# 2020-11-21 (v0.8.2)

11+

12+* support multiple extend expressions in TutorialD

13+* fix parsing of Bool atoms in TutorialD

14+* fix database context expressions which include self-references such as `s:=s union s`

15+* show constraints as TutorialD when using tutd console

16+* add `RelationalExprAtom` data type useful for storing `RelationalExpr` within the database

17+

18+# 2020-10-05 (v0.8.1)

19+

20+* support GHC 8.10

21+

22+# 2020-05-25 (v0.8)

23+

24+* refactor backend to maximize laziness: [An Architecture for Data Independence](docs/data_independence.markdown)

25+

26+# 2019-09-07 (v0.7)

27+

28+* fix case sensitivity issue with relation variables in tutd

29+* fix multibyte escaping in data frames

30+* fix broken instances of `Atomable [a]`

31+* fix `TypeConstructor` validation of argument count

32+* add help option to executables

33+

1# 2019-01-08 (v0.6)

34# 2019-01-08 (v0.6)

2

35

3* fix atom type parsing to support more complex data types

36* fix atom type parsing to support more complex data types

README.markdown+12−3

@@ -4,8 +4,8 @@

4[![Public Domain](https://img.shields.io/badge/license-Public%20Domain-brightgreen.svg)](http://unlicense.org)

5[![Hackage](https://img.shields.io/hackage/v/project-m36.svg)](http://hackage.haskell.org/package/project-m36)

6[![Hackage dependency status](https://img.shields.io/hackage-deps/v/project-m36.svg)](http://packdeps.haskellers.com/feed?needle=project-m36)

7−[![Build status](https://travis-ci.org/agentm/project-m36.svg?branch=master)](https://travis-ci.org/agentm/project-m36)

8[![Windows Build status](https://ci.appveyor.com/api/projects/status/q7jyddd6dy1ibqdo/branch/master?svg=true)](https://ci.appveyor.com/project/agentm/project-m36)

7[![Windows Build status](https://ci.appveyor.com/api/projects/status/q7jyddd6dy1ibqdo/branch/master?svg=true)](https://ci.appveyor.com/project/agentm/project-m36)

8+[![Github Workflow status](https://github.com/agentm/project-m36/workflows/CI/badge.svg)](https://github.com/agentm/project-m36/actions?query=workflow%3ACI)

9

10

11*Software can always be made faster, but rarely can it be made more correct.*

@@ -14,6 +14,12 @@

14

15Project:M36 implements a relational algebra engine as inspired by the writings of Chris Date.

16

17+## Quick Install

18+

19+Project:M36 can be downloaded and run via docker, which supports Windows 10, macOS, and Linux.

20+

21+Run `docker run -it projectm36/project-m36 tutd` to start the TutorialD command line interface.

22+

17## Description

23## Description

18

24

19Unlike most database management systems (DBMS), Project:M36 is opinionated software which adheres strictly to the mathematics of the relational algebra. The purpose of this adherence is to prove that software which implements mathematically-sound design principles reaps benefits in the form of code clarity, consistency, performance, and future-proofing.

25Unlike most database management systems (DBMS), Project:M36 is opinionated software which adheres strictly to the mathematics of the relational algebra. The purpose of this adherence is to prove that software which implements mathematically-sound design principles reaps benefits in the form of code clarity, consistency, performance, and future-proofing.

@@ -38,7 +44,7 @@ Project:M36 supports multiple frontends which target different audiences.

38

44

39* [Developer's Blog](https://agentm.github.io/project-m36/)

45* [Developer's Blog](https://agentm.github.io/project-m36/)

40* [Mailing List/Discussion Group](https://groups.google.com/d/forum/project-m36)

46* [Mailing List/Discussion Group](https://groups.google.com/d/forum/project-m36)

41−* IRC Channel: chat.freenode.net #project-m36

47+* IRC Channel: irc.libera.chat #project-m36 -- [Chat via Web Client](http://kiwiirc.com/nextclient/irc.libera.chat:+6697/#project-m36)

42* [Hackage](https://hackage.haskell.org/package/project-m36)

48* [Hackage](https://hackage.haskell.org/package/project-m36)

43* [Diogo Biazus' Project:M36 Video Tutorial](https://www.youtube.com/watch?v=_GC_lxlVEnE)

49* [Diogo Biazus' Project:M36 Video Tutorial](https://www.youtube.com/watch?v=_GC_lxlVEnE)

44

50

@@ -48,6 +54,7 @@ Project:M36 supports multiple frontends which target different audiences.

48

54

491. [Installation and Introduction to Project:M36](docs/introduction_to_projectm36.markdown)

551. [Installation and Introduction to Project:M36](docs/introduction_to_projectm36.markdown)

501. [Introduction to the Relational Algebra](docs/introduction_to_the_relational_algebra.markdown)

561. [Introduction to the Relational Algebra](docs/introduction_to_the_relational_algebra.markdown)

57+1. [TutorialD Cheatsheet](docs/tutd_cheatsheet.markdown)

511. [TutorialD via Jupyter Notebook Walkthrough](jupyter/TutorialD%20Notebook%20Walkthrough.ipynb)

581. [TutorialD via Jupyter Notebook Walkthrough](jupyter/TutorialD%20Notebook%20Walkthrough.ipynb)

521. [TutorialD Tutorial](docs/tutd_tutorial.markdown)

591. [TutorialD Tutorial](docs/tutd_tutorial.markdown)

531. [15 Minute Tutorial](docs/15_minute_tutorial.markdown)

601. [15 Minute Tutorial](docs/15_minute_tutorial.markdown)

@@ -60,6 +67,7 @@ Project:M36 supports multiple frontends which target different audiences.

601. [ACID Database Properties](docs/acid_assessment.markdown)

671. [ACID Database Properties](docs/acid_assessment.markdown)

611. [On NULL (in SQL)](docs/on_null.markdown)

681. [On NULL (in SQL)](docs/on_null.markdown)

621. [Reaching "Out of the Tarpit" with Project:M36](docs/reaching_out_of_the_tarpit.markdown)

691. [Reaching "Out of the Tarpit" with Project:M36](docs/reaching_out_of_the_tarpit.markdown)

70+1. [An Architecture for Data Independence](docs/data_independence.markdown)

63

71

64### Advanced Features

72### Advanced Features

65

73

@@ -76,6 +84,7 @@ Project:M36 supports multiple frontends which target different audiences.

761. [Isomorphic Schemas](docs/isomorphic_schemas.markdown)

841. [Isomorphic Schemas](docs/isomorphic_schemas.markdown)

771. [Replication](docs/replication.markdown)

851. [Replication](docs/replication.markdown)

781. [Basic Operator Benchmarks](https://rawgit.com/agentm/project-m36/master/docs/basic_benchmarks.html)

861. [Basic Operator Benchmarks](https://rawgit.com/agentm/project-m36/master/docs/basic_benchmarks.html)

87+1. [Merkle Transaction Hashes](docs/merkle_transaction_graph.markdown)

79

88

80### Integrations

89### Integrations

81

90

@@ -85,7 +94,7 @@ Project:M36 supports multiple frontends which target different audiences.

85

94

86## Development

95## Development

87

96

88−Project:M36 is developed in Haskell and compiled with GHC 8.0.2 or later.

97+Project:M36 is developed in Haskell and compiled with GHC 8.6 or later.

89

98

90## Related Projects

99## Related Projects

91

100

cabal.project+9−2

@@ -1,3 +1,10 @@

1−-- this is needed for GHC8 until distributed-process-extras is updated on Hackage with increased upper bounds

2packages: project-m36.cabal

1packages: project-m36.cabal

3−allow-newer: distributed-process-extras:time,distributed-process-extras:binary,distributed-process-client-server:binary,distributed-process-client-server:time,distributed-process-async:time,distributed-process-async:binary

2+

3+package *

4+ split-sections: True

5+

6+--high-performance streaming library

7+source-repository-package

8+ type: git

9+ location: https://github.com/composewell/streamly.git

10+ tag: ac3af8749194f1788704dda8667d0b3807075cc2

default.nixnew file+1

@@ -0,0 +1 @@

1+(import ./release.nix { }).project

docker.nixnew file+18

@@ -0,0 +1,18 @@

1+{ compiler ? "ghc8104"

2+, sources ? import ./nix/sources.nix

3+, pkgs ? import sources.nixpkgs { }

4+}:

5+let

6+ release = import ./release.nix { inherit pkgs compiler sources; };

7+ static-project-m36 = pkgs.haskell.lib.dontCheck (pkgs.haskell.lib.justStaticExecutables release.project);

8+in

9+pkgs.dockerTools.buildImage {

10+ name = "project-m36";

11+ tag = "latest";

12+ contents = [ static-project-m36 ];

13+ # expose default project-m36 and websocket server ports

14+ config = {

15+ Env = [ "LC_ALL=en_US.UTF-8" ];

16+ ExposedPorts = { "6543/tcp" = { }; "8000/tcp" = { }; };

17+ };

18+}

docs/15_minute_tutorial.markdown+65−68

@@ -4,40 +4,34 @@ Thank you for evaluating Project:M36, a new relational algebra engine written in

4

5## Prerequisites

6

7−* any Linux

7+* any Linux, MacOS, or Windows computer with Docker installed

8−* GHC 7.10 or later version (Haskell compiler)

9−* cabal (package downloader) installed

10

8

11## Download and Install

9## Download and Install

12

10

11+Run a pre-built docker image:

12+

13+```docker run -it projectm36/project-m36 tutd```

14+

15+or build it yourself with GHC >= 8.6:

16+

13```bash

17```bash

14git clone https://github.com/agentm/project-m36.git

18git clone https://github.com/agentm/project-m36.git

15−cabal sandbox init

16−cabal install --dependencies-only

17−cabal run tutd

19+cabal new-run tutd

18```

20```

19

21

20## Some Basic TutorialD

22## Some Basic TutorialD

21

23

22−When you run the ```tutd``` interpreter, you are interacting with an in-memory database using a dialect of the TutorialD language which is described in numerous book by Chris J. Date. It is a language specifically designed for human interaction with the relational algebra.

24+When you run the ```tutd``` interpreter, you are interacting with an in-memory database using a dialect of the TutorialD language which is described in numerous books by Chris J. Date. It is a language specifically designed for human interaction with the relational algebra.

23

25

24Note that TutorialD is strongly-typed- no type coercions take place automatically. For example, an integer will never be interpreted as a string or vice versa.

26Note that TutorialD is strongly-typed- no type coercions take place automatically. For example, an integer will never be interpreted as a string or vice versa.

25

27

26### Load the Canonical Chris Date Example

28### Load the Canonical Chris Date Example

27

29

28```

30```

29−TutorialD (master/main): :importexample date

31+TutorialD (master/main): :importexample cjdate

30−```

31−

32−or

33−

34−```

35−TutorialD (master/main): :importtud "scripts/DateExamples.tutd"

36```

32```

37

33

38−```:importtutd``` (do not skip typing the preceding colon), loads a file which contains a script written in the TutorialD dialect used by Project:M36 and executes it to change the state of the database. In this case, the relations "s" (supplier), "p" (product), and "sp" (suppliers-products) are now loaded.

34+```:importexample``` (do not skip typing the preceding colon), loads a built-in example schema and executes it to change the state of the database. In this case, the relations "s" (supplier), "p" (product), and "sp" (suppliers-products) are now loaded.

39−

40−```:importexample date``` loads the date example directly without any file I/O, so it is safe to use with the websocket server.

41

35

42### Execute Relational Expressions

36### Execute Relational Expressions

43

37

@@ -164,7 +158,7 @@ Database context expressions change the state of the database, much like "CREATE

164#### Create a Relation Variable

158#### Create a Relation Variable

165

159

166```

160```

167−TutorialD (master/main): x:=relation{name Text, age Int}{tuple{name "Steve", age 40},tuple{name "Mike", age 31}}

161+TutorialD (master/main): x:=relation{name Text, age Integer}{tuple{name "Steve", age 40},tuple{name "Mike", age 31}}

168TutorialD (master/main): :showexpr x

162TutorialD (master/main): :showexpr x

169┌────────┬──────────┐

163┌────────┬──────────┐

170│age::Int│name::Text│

164│age::Int│name::Text│

@@ -179,23 +173,25 @@ This is similar to SQL's "CREATE TABLE" operator.

179#### Insert Additional Tuples

173#### Insert Additional Tuples

180

174

181```

175```

182−TutorialD (master/main): x:=relation{name Text, age Int}{tuple{name "Steve", age 40},tuple{name "Mike", age 31}}

176+TutorialD (master/main): x:=relation{name Text, age Integer}{tuple{name "Steve", age 40},tuple{name "Mike", age 31}}

183TutorialD (master/main): :showexpr x

177TutorialD (master/main): :showexpr x

184−┌────────┬──────────┐

178+┌────────────┬──────────┐

185−│age::Int│name::Text│

179+│age::Integer│name::Text│

186−├────────┼──────────┤

180+├────────────┼──────────┤

181+│31 │"Mike" │

187−│40 │"Steve" │

182+│40 │"Steve" │

188−│31 │"Mike" │

189−└────────┴──────────┘

183+└────────────┴──────────┘

184+

190TutorialD (master/main): insert x relation{tuple{name "Bob", age 24}}

185TutorialD (master/main): insert x relation{tuple{name "Bob", age 24}}

191TutorialD (master/main): :showexpr x

186TutorialD (master/main): :showexpr x

192−┌────────┬──────────┐

187+┌────────────┬──────────┐

193−│age::Int│name::Text│

188+│age::Integer│name::Text│

194−├────────┼──────────┤

189+├────────────┼──────────┤

190+│31 │"Mike" │

195−│40 │"Steve" │

191+│40 │"Steve" │

196−│24 │"Bob" │

192+│24 │"Bob" │

197−│31 │"Mike" │

198−└────────┴──────────┘

193+└────────────┴──────────┘

194+

199```

195```

200

196

201Note that the relational insertion is identical to "x:=x union relation{...}".

197Note that the relational insertion is identical to "x:=x union relation{...}".

@@ -204,50 +200,51 @@ Note that the relational insertion is identical to "x:=x union relation{...}".

204

200

205```

201```

206TutorialD (master/main): :showexpr s

202TutorialD (master/main): :showexpr s

207−┌──────────┬────────┬───────────┬───────────┐

203+┌──────────┬────────┬───────────┬───────────────┐

208−│city::Text│s#::Text│sname::Text│status::Int│

204+│city::Text│s#::Text│sname::Text│status::Integer│

209−├──────────┼────────┼───────────┼───────────┤

205+├──────────┼────────┼───────────┼───────────────┤

210−│"Paris" │"S2" │"Jones" │10 │

211−│"Paris" │"S3" │"Blake" │30 │

212−│"London" │"S1" │"Smith" │20 │

206+│"London" │"S1" │"Smith" │20 │

213−│"London" │"S4" │"Clark" │20 │

214−│"Athens" │"S5" │"Adams" │30 │

207+│"Athens" │"S5" │"Adams" │30 │

208+│"Paris" │"S3" │"Blake" │30 │

209+│"London" │"S4" │"Clark" │20 │

210+│"Paris" │"S2" │"Jones" │10 │

215−└──────────┴────────┴───────────┴───────────┘

211+└──────────┴────────┴───────────┴───────────────┘

216TutorialD (master/main): update s where city="London" (status:=35)

212TutorialD (master/main): update s where city="London" (status:=35)

217TutorialD (master/main): :showexpr s

213TutorialD (master/main): :showexpr s

218−┌──────────┬────────┬───────────┬───────────┐

214+┌──────────┬────────┬───────────┬───────────────┐

219−│city::Text│s#::Text│sname::Text│status::Int│

215+│city::Text│s#::Text│sname::Text│status::Integer│

220−├──────────┼────────┼───────────┼───────────┤

216+├──────────┼────────┼───────────┼───────────────┤

217+│"Athens" │"S5" │"Adams" │30 │

218+│"London" │"S1" │"Smith" │35 │

221−│"London" │"S4" │"Clark" │35 │

219+│"London" │"S4" │"Clark" │35 │

222−│"London" │"S1" │"Smith" │35 │

220+│"Paris" │"S3" │"Blake" │30 │

223−│"Paris" │"S2" │"Jones" │10 │

221+│"Paris" │"S2" │"Jones" │10 │

224−│"Paris" │"S3" │"Blake" │30 │

225−│"Athens" │"S5" │"Adams" │30 │

226−└──────────┴────────┴───────────┴───────────┘

222+└──────────┴────────┴───────────┴───────────────┘

223+

227```

224```

228#### Deleting Tuples from a Relation Variable

225#### Deleting Tuples from a Relation Variable

229

226

230```

227```

231TutorialD (master/main): :showexpr s

228TutorialD (master/main): :showexpr s

232−┌──────────┬────────┬───────────┬───────────┐

229+┌──────────┬────────┬───────────┬───────────────┐

233−│city::Text│s#::Text│sname::Text│status::Int│

230+│city::Text│s#::Text│sname::Text│status::Integer│

234−├──────────┼────────┼───────────┼───────────┤

231+├──────────┼────────┼───────────┼───────────────┤

235−│"Paris" │"S2" │"Jones" │10 │

232+│"Paris" │"S2" │"Jones" │10 │

236−│"Paris" │"S3" │"Blake" │30 │

233+│"Paris" │"S3" │"Blake" │30 │

237−│"London" │"S1" │"Smith" │20 │

234+│"London" │"S1" │"Smith" │20 │

238−│"London" │"S4" │"Clark" │20 │

239−│"Athens" │"S5" │"Adams" │30 │

235+│"Athens" │"S5" │"Adams" │30 │

236+│"London" │"S4" │"Clark" │20 │

240−└──────────┴────────┴───────────┴───────────┘

237+└──────────┴────────┴───────────┴───────────────┘

241TutorialD (master/main): delete s where sname="Adams"

238TutorialD (master/main): delete s where sname="Adams"

242TutorialD (master/main): :showexpr s

239TutorialD (master/main): :showexpr s

243−┌──────────┬────────┬───────────┬───────────┐

240+┌──────────┬────────┬───────────┬───────────────┐

244−│city::Text│s#::Text│sname::Text│status::Int│

241+│city::Text│s#::Text│sname::Text│status::Integer│

245−├──────────┼────────┼───────────┼───────────┤

242+├──────────┼────────┼───────────┼───────────────┤

246−│"Paris" │"S2" │"Jones" │10 │

243+│"Paris" │"S2" │"Jones" │10 │

244+│"London" │"S4" │"Clark" │20 │

247−│"Paris" │"S3" │"Blake" │30 │

245+│"Paris" │"S3" │"Blake" │30 │

248−│"London" │"S1" │"Smith" │20 │

246+│"London" │"S1" │"Smith" │20 │

249−│"London" │"S4" │"Clark" │20 │

250−└──────────┴────────┴───────────┴───────────┘

247+└──────────┴────────┴───────────┴───────────────┘

251```

248```

252

249

253### Execute Transaction Graph Expressions

250### Execute Transaction Graph Expressions

@@ -270,7 +267,7 @@ TutorialD (master/main): :rollback

270

267

271```

268```

272TutorialD (master/main): :branch experimental

269TutorialD (master/main): :branch experimental

273−TutorialD (experimental): employee:=relation{name Text, salary Int}

270+TutorialD (experimental): employee:=relation{name Text, salary Integer}

274TutorialD (experimental): :commit

271TutorialD (experimental): :commit

275```

272```

276

273

docs/commits_in_constant_time.markdownnew file+134

@@ -0,0 +1,134 @@

1+# Transactional Database Commits in O(1)

2+

3+A.M.

4+

5+[Project:M36](https://github.com/agentm/project-m36)

6+

7+## Synopsis

8+

9+Common relational database management systems operate in an imperative manner by executing statements immediately. This naive strategy quickly becomes an IO-bound bottleneck. By applying Haskell's laziness-in-evaluation to database updates, new doors for optimizations based on what is queried make themselves apparent. Furthermore, by serializing thunks representing idempotent database updates, the database can commit transactions in constant time with regards to the tuple count since the tuples themselves need not be serialized. This optimization, combined with *fsync*-coalescing, can allow databases to commit to disk faster than tuples updates can be processed.

10+

11+Using this deferred execution technique, database updates can be processed in the background or, in the case when the tuples are never requested, never.

12+

13+These database update thunks and other interesting optimizations are implemented in [Project:M36](https://github.com/agentm/project-m36): an experimental, clean-room, purely Haskell implementation of an RDBMS engine based on the mathematical principles of the relational algebra.

14+

15+## Rationale

16+

17+A typical SQL RDBMS such as PostgreSQL executes a list of commands serially against a serializable representation of the database state without concern to whether or not the commands are effectively necessary to service subsequent requests. A database update which affects *n* tuples will necessitate disk writes of *O(n)* plus *O(n\*log(n))* writes for each affected index.

18+

19+By validating and serializing thunks of validated commands, Project:M36 commits can be independent of the tuple write cost. The thunks, which are flushed to non-volatile storage to complete the transaction commit, allow the DBMS to defer execution in preference to commit time.

20+

21+The deferral is, however, not required, and could be left as a option to the user or application.

22+

23+The final cost of committing in Project:M36 relates to the size of the update expression. If the update expression is, for example, a insertion of a large number of rows, then the commit cost will be *O(t)* where *t* is the number of tuples expressed in the update, but still independent of the cost of the existing tuples in the database.

24+

25+## Example and Comparison to PostgreSQL

26+

27+Let us walk through a specific example using SQL. While Project:M36 does not support SQL (and for [good reasons](https://github.com/agentm/project-m36/blob/master/docs/on_null.markdown)), comparing both databases with a common language is useful for illustrative purposes.

28+

29+Let us consider an existing database with a table/relation named "BigTable" which has 10 billion rows/tuples (an arbitrarily large number) of which one column is named "x" and represents a randomly-assigned integer. Next, assume that the user of the database will execute an update which will update every row/tuple, commit the changes, then query a subset of the resultant updated rows/tuples.

30+

31+

32+### The Update Expression

33+

34+Consider the following database update:

35+

36+```

37+UPDATE "BigTable" SET x = x + 1;

38+```

39+In PostgreSQL, the cost of executing this expression is incurred immediately upon execution. New tuples are laid down to disk (if the dataset is larger than *shared_buffers*), duplicating the entirety of the existing table/relation in storage (due to MVCC) for a cost of *O(n)* where *n* is the number of existing rows/tuples in "BigTable". If *x* is indexed, then the index writes incur an additional cost of *O(n\*log(n))* writes. Furthermore, PostgreSQL will write all changes to its write-ahead log, so the cost is multiplied by some factor.

40+

41+In Project:M36, the same expression can first be statically validated to adhere to the database constraints. The only constraint affected here is for the column/attribute *x* which requires an integer. Since adding one to any integer retains the integer type, the constraint can be determined to be unviolated without evaluating the expression, thus at a cost of *O(1)*. Project:M36 uses a novel WORM (write-once, read-many) strategy over journaled filesystems to avoid the need for a separate journal.

42+

43+*For the purpose of this example, assume that integer overflow is not a concern.*

44+

45+### The Commit

46+

47+```

48+COMMIT;

49+```

50+

51+In PostgreSQL, the write-ahead log mentioned above containing all tuples changes must now be flushed to non-volatile storage, creating a bottleneck to the slowest form of storage. A necessary checkpoint (which is configurable) could incur further writes as the tuples are flushed to disk as well.

52+

53+In Project:M36, the update expression must also be flushed to disk, but the expression is a mere few bytes appended to the transaction graph.

54+

55+### The Subsequent Query

56+

57+Finally, the user queries a subset of the updated table/relation.

58+

59+```

60+SELECT a, b, c, x FROM "BigTable" WHERE x > 10000;

61+```

62+

63+In PostgreSQL, considering that the column/attribute has an index, *O(log(n))* reads are needed to identify on which pages in the table's on-disk storage the proper values can be found. Considering that the value *x* was previously described as random, despite the restriction, in the worst case, every page of the on-disk table may need to be read because each page could contain one value matching the restriction. This would necessitate reading *O(n)* tuples previously written to disk. After reading the tuples, the tuples must be filtered by the restriction to service the query.

64+

65+In Project:M36, the state of the database is determined to be the difference of the previous state *S* (before the *x+1* update above) and *S'* (after the update). The serialized update expression can be deserialized and merged into the rewritten query:

66+

67+```

68+SELECT orig.a, orig.b, orig.c, x_orig + 1 AS x FROM (SELECT a, b, c, x AS x_orig FROM "BigTable"@S) AS orig WHERE x > 10000;

69+```

70+

71+where the *@* symbol references the state of "BigTable" at transaction state *S* in the past. The rewrite process can occur in constant time regarding the tuple count, but the execution does require reading the previous state *S* of "BigTable", filtering it as expected. The tuple read cost is equivalent to that of the same statement at *S'*: *O(log(n))* utilizing a b-tree index.

72+

73+### Summary

74+

75+| | PostgreSQL | Project:M36 |

76+|-|------------|-------------|

77+| UPDATE x+1 | *O(nlog(n))* | *O(1)* |

78+| COMMIT | flush *n* tuples to disk | flush expression to disk |

79+| SELECT x>10000 | *Ω(log(n))*, *O(n)* worst case | *O(log(n))* |

80+

81+Even if the user were to query all the tuples back, the actual IO cost in Project:M36 would be lower since the updates are only "executed" on the fly and not necessarily written to disk. However, a clever cacheing strategy could note that state *S* is queried often enough to warrant a cached version. The table's data on disk, however, is not required to answer the query.

82+

83+## Constraint Oracles

84+

85+To be able to perform an update and commit in constant or less than *O(n)* time does have some preconditions:

86+

87+ * constraints must be able to be statically validated in linear or logarithmic time

88+

89+However, even if constraints lack a proper oracle such as an index or a static means of validation and, thus, cannot be validated in constant time, the user may still benefit from serialization of the database update expression since writing the validated tuples to disk can be deferred beyond commit time and could go directly into an on-disk cache.

90+

91+## Worst Case Behavior

92+

93+Every database constraint can be represented as an inclusion dependency whereby the evaluation of a relational expression `sub` must be a subset of the evaluation of relational expression `super` (`sub ⊆ super`) for the constraint to validate. Therefore, the worst case time to validate any constraint, assuming that the constraint has an ideal oracle, is O(n) in the tuple count. However, as mentioned above, there are many constraints that can be validated in constant or less-than-linear time. Furthermore, the validated tuples need not be written to disk once the constraint is found to hold.

94+

95+Since there is great variation in constraint validation cost, the RDBMS could pre-analyze and report on associated constraints costs or make use of data independence to guide storage to optimize queries needed to service the constraint checker.

96+

97+## Caveats

98+

99+Certain types of updates still take a similar amount of time to commit in Project:M36 in comparison to PostgreSQL. Specifically, any update which relies on data outside the database's purview will necessitate flushing the tuple data since the update expression contains new tuple data not based on existing tuples. For example, the equivalent of:

100+

101+```

102+INSERT INTO "BigTable"(a, b, c, x) VALUES (1,5,10,10),(20,20,21,30),.... #many tuples

103+```

104+will still necessitate a *O(n)* tuple writes to disk in both databases. Though the asymptotic costs are equivalent, the number of writes are cut in half in Project:M36 since it does not require a write-ahead log.

105+

106+While PostgreSQL makes use of MVCC (multi-version concurrency control) which marks which tuples belong to a linear progression of transaction states, Project:M36 stores a full history of database state using a transaction graph (a directed acyclic graph similar to the commit-based graph of `git`). The graph allows named branches to be created and merged which also reduce contention around a singular graph head.

107+

108+## Applying Laziness to SQL RDBMSes

109+

110+Would it be possible to apply transaction-based laziness to an SQL-based RDBMS? Certainly, with sufficient shoe-horning, it could work, but SQL includes a few malfeatures which would make it difficult, if not impossible:

111+

112+ * Non-idempotent server-side functions prevent laziness because of side effects. PostgreSQL can mark functions as idempotent, but does not validate or enforce the idempotence, Project:M36, via Safe Haskell, can validate pure functions.

113+ * The lack of "time travel", the ability to query database state in the past prevents reliance on previous states, prevents direct referencing of previous database states on which the state differences can be built.

114+ * Tightly-coupled table-to-storage management prevents alternative data models. Indexing and constraint checking need to be statically verifiable and deferrable.

115+

116+These hurdles are not insurmountable, just perhaps not a good fit for SQL databases with a lot of historical and implementation baggage.

117+

118+## Benchmarks

119+

120+Forthcoming.

121+

122+## Conclusion

123+

124+Transactional time-to-commit is critical in ensuring that business decisions can make it to non-volatile storage as quickly as possible. By introducing Haskell-like, lazy evaluation to update expressions and serializing the resultant thunk, commits can be serialized in constant time, disregarding the number of tuples modified in the expression.

125+

126+This serialization strategy turns modern RDBMS architecture on its head since the table/relation-to-file mapping is broken, resulting in true data independence. Any on-disk representation of a relation at a specific transaction state therefore merely becomes a cached and purgeable entity, drastically shrinking on-disk cacheing requirements while expanding the scope in which said strategies can operate. Hopefully, a truly data independent architecture will result in new optimization discoveries.

127+

128+Project:M36 implements a transaction graph which can represent the entirety of database state, leaving room for any number of alternative representations, even for a single relation or relation across transaction states. A simple example could include storing two different orderings of tuples of the same relation in order to optimally serve different join queries. Common RDBMSes offer only two on-disk representations: the set of fully-evaluated tuples and indexes to those tuples, preventing data independence. Data independence paves the way towards the elimination of implementation-specific, gatekeeper roles such as database administrators.

129+

130+The promise of the relational algebra has always been the liberation of data from its data structure representation in order to be able to answer arbitrary queries. Modern DBMSes which typically map tables directly to one or more files on disk fail to live up to this promise. Project:M36 sets out to rectify this failure.

131+

132+In a greater context, applying laziness to an architecture to make use of more interesting optimizations is hardly new. The OpenGL API views its "immediate" mode as effectively deprecated. Filesystems take advantage of laziness using copy-on-write semantics. High-level programming languages can make greater, more interesting inferences about how a computation must be execute. A computer can always consider many more possible solution paths than a human can.

133+

134+The adherence to mathematical priniciples in Project:M36 results in features and optimization opportunities which have not yet been discovered. In contrast to RDBMSes designed around specific optimizations (such as indexes, specific disk layouts, or key-value lookups), Project:M36 sets out to demonstrate practically that future optimizations can only be discovered when operating within a mathematically-coherent architecture.

docs/data_independence.markdownnew file+109

@@ -0,0 +1,109 @@

1+# Project:M36: Towards an Architecture for Data Independence

2+

3+## Introduction

4+

5+The Project:M36 relational algebra architecture sets itself apart from typical DBMSes by ensuring strict transactional isolation, a branchable/mergeable (rather than linear) transaction graph, and storage of relational expressions (rather than storage of tuples). Let's look at how these architectural features work together to make Project:M36 the first relational algebra engine to implement true data independence.

6+

7+## What is Data Independence?

8+

9+C.J. Date writes:

10+

11+`Certainly most SQL products have failed to live up to the [relational] model's full potential...in those products, what the user sees and what is physically stored are essentially the same thing... In particular, it accounts for the argument, so often heard, to the effect that we have to "denormalize for performance."`

12+

13+`In principle, logical design has absolutely nothing to do with performance at all.`

14+

15+(Date, C.J. "Database In Depth: Relational Theory for Practitioners". O'Reilly Media. 2005. pages 156-157.)

16+

17+Data independence is therefore defined as the separation of the database user's experience from the database's means of in-memory or on-disk representation. As Date points out, virtually all database products implement a one-to-one mapping of relations to files in storage.

18+

19+One advantage of high-level abstractions in programming languages is to leverage advanced algorithms which can choose optimization paths on behalf of the user which a human may never be able to discover. While the promise of ever higher-level abstractions is realized by progamming languages such as Haskell, DBMS implementors have been resistant to data independence. This is due to several legacy factors such as companies pushing one-trick-pony database technologies and middlemen such as DBAs required to play gatekeeper against "bad" schema changes. The result is customers forced to run multiple disparate databases such as one for realtime transaction processing and another for analytics and another for audit logging. This recalcitrance has also led to the rise of databases such as "document" JSON databases with weak mathematical underpinnings in the name of performance as users become frustrated when hitting performance walls and dealing with arbitrary database limitations.

20+

21+Implementations which closely tie the user interface to backend representation close the door on interesting alternative representations and optimizations. For example, SQL databases typically store a single relation as a list of tuples on disk with supplementary indexes stored in separate files. There is no reason that the same relation couldn't be on disk or in memory in any number of formats. Such a table might be useful in various formats ideal for servicing different types of queries. Data independence grants the DBMS the permission to create any number of representations- including none at all- as long as the correct answer is provided to the user. "Column-store" databases may try to slice the tuples in a different axis, but those databases simply shift the performance problems elsewhere. Only implementation details prevent a database from offering both column-oriented *and* tuple-oriented representation while allowing the database to choose.

22+

23+That is why it is critical for the user's interface to the database *not* to include features such as "query hints" which would force a specific implementation in the backend. The user's interface must be declarative (describing the state change or query rather than *how* to execute it) and sufficiently high level. Any implementation detail leakage to the user's interface is a lost potential algorithmic optimization. While the topic of providing high-level interfaces is not specific to database design, we will continue to explore the ramifications of data independence in databases.

24+

25+

26+## Transactional Isolation

27+

28+While other databases offer various transaction isolation levels with differing levels of implementation-specific surprises, Project:M36 solely suppports the maximum transaction isolation level. Instead of relying on details of [MVCC](https://www.postgresql.org/docs/current/mvcc-intro.html) which marks each tuple in a relation with a monotonically-increasing number identifying from which transaction the tuple was added or deleted, Project:M36 includes no singular backing store for tuples, instead storing a stream of state change requests. Because the transaction graph supports branching and merging (similar to version control such as git), transactions can be committed without contention at a singular head of the graph. Committing to disk can be implemented as writing a file to represent the transaction's state and

29+

30+## The Transaction Graph

31+

32+These state changes are, in fact, the idempotent relational update expressions that the user has submitted. For example, given a transaction which includes a single relation `s`:

33+

34+```

35+┌──────────┬────────┬───────────┬───────────┐

36+│city::Text│s#::Text│sname::Text│status::Int│

37+├──────────┼────────┼───────────┼───────────┤

38+│"Paris" │"S2" │"Jones" │10 │

39+└──────────┴────────┴───────────┴───────────┘

40+```

41+

42+if the user commits a transaction with an insert such as:

43+

44+```

45+insert x relation{tuple{city "Boston", s# "S3", sname "Smith", status 400}}

46+```

47+

48+then a typical database will find the file representing the relation, find some free space in it and save the new tuple along with the MVCC transaction identifier. Subsequent transactions will find the tuple and compare it to their own transaction id in order to determine its "visibility". Project:M36, on the other hand, after validating that all relational constraints (such as primary and foreign keys) still hold, will simply serialize and append the expression to the transaction graph log. By default, there is no file representing the relation.

49+

50+For those familiar with Haskell, note how serializing the update expression is similar to being able to serialize a thunk or deferred execution.

51+

52+The transaction graph also allows users to travel back to previously-committed transactions. This may be useful for audit logging or alternative schemas.

53+

54+## Storage Representations

55+

56+Given the ever-growing transaction graph based on state changes, let's examine how Project:M36 services subsequent queries.

57+

58+## Benefits

59+

60+The primary goal of a database should be to ensure data integrity. Project:M36 takes no shortcuts in achieving this goal, but choosing a backend architecture which minimizes the time which it takes to get the transaction to non-volatile storage (disk) by storing update expressions rather than attempting to shuffle tuples on disk. This architecture open the door to many optimization techniques, many of which are new to databases.

61+

62+### Multiple On-Disk Representations

63+

64+The promise of data independence allows database backends to store relations as they see fit. That can include any number of on-disk representations including none at all. For example, for a table accessed by multiple projections, the database may choose to materialize the relation in those projections. The representations are therefore created in service to the queries submitted or anticipated instead of being based on past update expressions. Because on-disk storage is obviously limited, the database must decide what is valuable to keep around for future queries. This could open a new area of research into the appropriate machine learning algorithms, but, fundamentally, this set of materialized query responses is effectively a cache which can always be refreshed.

65+

66+The alternative representations need not be a direct answer to queries- for example, a materialized relation from a transaction could be used to service a query from a later transaction if the updates since that transaction are applied.

67+

68+The database could also anticipate, for example, scheduled queries and actually materialize relations before the query is executed. On-disk cache could represent "denormalized" tuple sets while the user-facing interface shows a properly normalized schema, thereby supporting data independence.

69+

70+More research in determining just what should be in the cache is needed.

71+

72+### Transactional Commits in O(1) Time

73+

74+Because the Project:M36 backend need not save tuples into a specific file representing a relation, the backend can drastically reduce the amount of time needed to commit a transaction to disk. Specifically, following constraint validation (which can often be done in constant or logarithmic time relative to the tuple count), the fastest means of committing the transaction is to save the update expression itself. Since the previous state has already been presumably committed, any idempotent operation can be saved for deferred execution. This means that transactions can be committed to disk relative to the size of the update expression rather than the number of the tuples affected- committing can occur at a rate relative to that of update expression size (typically a few kilobytes) rather than relative to the number of tuples that the update expression happened to alter.

75+

76+This technique gets transactions to disk faster, thus drastically increasing the rate transactions can be committed overall. Note that the execution of the update expression may be deferred by this process, so the cost to evaluate it may occur later, but this processing may be performed in the background after the transaction is committed. When the data is never requested, for example, for a defunct transaction graph branch, the actual execution could be deferred indefinitely, incurring zero cost to calculate the consquence of the update.

77+

78+### Less Disk Usage

79+

80+Because Project:M36 stores a stream of update expressions rather than tuples themselves, the minimum storage requirements for a given database may be reduced. For example, if a relation with an attribute `x` of type `Integer` has 1,000,000 tuples, a subsequent update to increment all 1,000,000 values by one may be cheaper to evaluate on-demand rather than immediately generating 1,000,000 new tuples and saving them to disk. If the new tuples are requested, the database can determine that the tuples are not materialized, calculate them, and return them, all without ever having the tuples on disk. Furthermore, if only a subset of the tuples are ever requested, for example, due to a query restriction, then some of the tuples may never need to be calculated or materialized.

81+

82+### Audit Logging

83+

84+Typical databases implement various strategies for audit logging, including:

85+

86+* exposing MVCC-like values such as tuple "created at" and "created by" to the user and forcing all tables to be insert-only

87+* shuttling audit logs to a secondary database

88+

89+Project:M36, through its inherent ability to travel the append-only transaction graph, enables audit-logging by allowing users to checkout previous transaction states. Committed transaction states are immutable, so no relation pollution or secondary database is necessary.

90+

91+### Selective Caching

92+

93+Typical databases materialize entire tuple sets representing each named relation (relation variable), but there is nothing special about relations that happen to be named. Data independence allows us to cache answers to common or even anticipated queries- this allows the schema to be normalized and unmaterialized while the *denormalized* query results are materialized cached. This flexibility saves disk space and allows the cache to be much more dynamic than in a typical DBMS.

94+

95+### Never-Materialized Tuples Replace Partitions

96+

97+Queries on very large relations often very often restricted (filtered by tuple) to generate subsets which are often partitioned, for example, by an event's date. Instead of requiring DBMS users to manually partition and slice their data in one, fixed, particular way, Project:M36's cacheing system will only cache those tuples that serve the interests of the queries. With something like an LRU cache, a data independent architecture will naturally cache "partitions" of the full relation without manual intervention.

98+

99+### Elimination of DBA role

100+

101+Databases essential to a business function are often guarded by a human database administrator (DBA) whose role it is to monitor database performance and to play gatekeeper to database schema changes as the database grows. This role is necessary because database tuning can be an arcane skill, rife with pitfalls for those who don't know the database software inside-and-out. This is a direct cause of data dependence, forcing DBAs to manually enforce data partitioning and shuffling data to different servers, configuring database replicas, and making Faustian bargains to "denormalize" tables for analytical workloads.

102+

103+A data independent architecture eliminates this role by allowing the database to make the optimal choices itself. This means that the database can respond to schema changes immediately, without manual repartitioning or denormalization steps.

104+

105+## Conclusion

106+

107+Project:M36's backend architecture enables new optimizations and features that are sorely lacking in existing DBMSes. By leveraging its novel transaction graph and deferred evaluation, Project:M36 handles more DBMS use-cases.

108+

109+Project:M36's novel architecture opens the door for further database and algorithmic research.

docs/filesystem-persistence.markdown+1−1

@@ -1,4 +1,4 @@

1−# Project-M36 Filesystem Persistence

1+# Project-M36 Filesystem Persistence (Change Proposal)

2

3## Introduction

4

docs/import_export_csv.markdown+2−2

@@ -9,7 +9,7 @@ If a relation variable cannot be exported due to data types which are not suppor

9### Example Export

10

11```

12−TutorialD (master/main): :importexample date

12+TutorialD (master/main): :importexample cjdate

13TutorialD (master/main): :exportcsv s "/tmp/csv"

14```

15```

@@ -37,7 +37,7 @@ s#,sname,status,city

37S6,Samson,100,New York

38```

39```

40−TutorialD (master/main): :importexample date

40+TutorialD (master/main): :importexample cjdate

41TutorialD (master/main): :showexpr s

42┌──────────┬────────┬───────────┬───────────────┐

43│city::Text│s#::Text│sname::Text│status::Integer│

docs/introduction_to_projectm36.markdown+28−9

@@ -15,16 +15,35 @@ The relational algebra is the mathematical model underpinning Project:M36. When

15

16## Binary Releases

17

18−### Windows

18+The quickest and preferred method of installation is via docker, which works on Linux, macOS, and Windows. Docker downloads and runs preconfigured software in secure, sandboxed containers, preventing third-party software from altering the host system without your permission.

19−Project:M36 now provides binary installations for Windows. Check the (releases page)[https://github.com/agentm/project-m36/releases] for downloads.

20

19

21−### MacOS X

20+### Install Docker:

22

21

23−Binary releases are not yet available for MacOS X, but compiling from source is easy.

22+* [Windows 10 Docker Installation](https://docs.docker.com/docker-for-windows/wsl/)

23+* [MacOS Docker Installation](https://docs.docker.com/docker-for-mac/install/)

24+* [Linux Docker Installation](https://docs.docker.com/engine/install/#server)

24

25

25−### Linux

26+### Run TutorialD from Docker Image

26

27

27−The currently-preferred method of installation is from source. A future enhancement would be installation from deb or rpm.

28+This downloads the docker image tagged "latest" and runs `tutd`, the TutorialD command line interface. Try the [15-Minute TutorialD Tutorial](15_minute_tutorial.markdown) and try some expressions.

29+

30+```bash

31+docker run -it projectm36/project-m36 tutd

32+```

33+

34+### Run Project:M36 Server

35+

36+The default port for the project-m36 server is 6543.

37+

38+```bash

39+docker run --network host projectm36/project-m36 project-m36-server -n <database_name>

40+```

41+

42+### Connect to Project:M36 Server

43+

44+```bash

45+docker run --network host projectm36/project-m36

46+```

28

47

29## Source Installation

48## Source Installation

30

49

@@ -32,7 +51,7 @@ Requirements:

32

51

33To build with stack:

52To build with stack:

34

53

35−* [GHC 8.2.2 or greater](https://www.haskell.org/downloads)

54+* [GHC 8.6.5 or greater](https://www.haskell.org/downloads)

36* [Haskell stack](https://docs.haskellstack.org/en/stable/README/)

55* [Haskell stack](https://docs.haskellstack.org/en/stable/README/)

37* Linux, macOS, or Microsoft Windows

56* Linux, macOS, or Microsoft Windows

38

57

@@ -40,11 +59,11 @@ Compilation steps:

40

59

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

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

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

61* ```cd project-m36```

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

62+* ```stack --stack-yaml stack.ghc8.6.yaml build```

44

63

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

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

46

65

47−Alternative building with GHC 8.0.2 or greater:

66+Alternative building with GHC 8.6.5 or greater:

48

67

49* ```cabal new-build```

68* ```cabal new-build```

50

69

docs/introduction_to_the_relational_algebra.markdown+2−2

@@ -202,7 +202,7 @@ Join (Instructor relation)

202

203(Course Relation)

204

205−|(Course Name, Course Name Type)|(Instructor, Instructor Name Type)|(Course Room Number, Room Number Type)|

205+|(Course Name, Course Name Type)|(Instructor Name, Instructor Name Type)|(Course Room Number, Room Number Type)|

206|-------------------------------|----------------------------------|--------------------------------------|

207|English 1|Steve|Room 104|

208|French 2|Bob|Room 103|

@@ -378,7 +378,7 @@ Since a value can store any (immutable) type, it can certainly hold a relation.

378

379For example, in SQL, if one wants to collect some aggregate data over some tuples while still returning the individual tuples, in the best case, the aggregate information must be repeated for every individual tuple. In the worst case, two separate queries are required since nested tables are not supported.

380

381−In the relational algebra, The aggregate value can be placed alongside the relation value from whic the aggregate was derived.

381+In the relational algebra, The aggregate value can be placed alongside the relation value from which the aggregate was derived.

382

383Example:

384

docs/merkle_transaction_graph.markdownnew file+33

@@ -0,0 +1,33 @@

1+# Project:M36: Merkle Hashing for Transaction Graph

2+

3+## Introduction

4+

5+Project:M36 supports an append-only transaction graph model (similar to git) whereby new transactions can be added to the graph but not removed. As with any graph, each node can contain a Merkle hash which ensures not only that it's state since being added to the graph has not changed but also that none of its parent nodes all the way to the root node (initial state) have not been modified. This validation has a number of use cases.

6+

7+## Usage

8+

9+Project:M36 automatically adds Merkle hashes to every transaction. All data which represents the database state at that transaction is included in the hash including (but not limited to) relation variable definitions, atom and database context functions, constraints, and types.

10+

11+Project:M36 validates all merkle hashes at database startup. For users who need validation after the database is started, the user can issue `:validatemerklehashes` at the `tutd` command line.

12+

13+### Audit Logging

14+

15+Project:M36 supports audit logging by allowing users to travel to transactions in the past and recreate the database state at that past point-in-time. To ensure that those past states cannot be modified either by malicious on-disk or in-memory changes, each transaction is protected by its own Merkle hash. If the calculated hash does not match the stored hash, Project:M36 can immediately report which transaction triggered the tamper-proof log.

16+

17+### Reproducibility

18+

19+Since a Merkle tree is effectively immutable except to add more nodes, it can be used to save and restore a whole database with very high confidence in the results. This feature could also be used to restore a database partially; for example, to duplicate just the latest database state on a second machine for OLAP analysis.

20+

21+### High-Availability

22+

23+Merkle tree hashes can be used to assert database integrity across high-availibility or database replication. Since the hash covers all database state, it can be used to validate log-shipping-based replication. Corrupted cache tuple data can be easily detected and flushed.

24+

25+## Merkle Hashes in Other DBMSes

26+

27+While Merkle hashes have become prevalent in blockchain-style databases, they have not made many appearances in typical SQL databases. This is likely due to the fact that such databases consider any additional operations against the large tuple stores as prohibitively expensive. Project:M36 is able to skirt this cost by only hashing database update expressions rather than the result of these executed expressions. This also means that the Merkle hash can be computed against transactions which have been created but never executed.

28+

29+## Conclusion

30+

31+Merkle hashes are an obvious improvement to any graph-based transaction log and are a low-cost method of ensuring data integrity.

32+

33+A further improvement could allow users to specify an initial key provided by an admin user to salt the hash used to create the database. Additionally, a multi-user system could allow individual users to sign their committed transactions. The signature would then be included in the Merkle hash.

docs/reaching_out_of_the_tarpit.markdown+1−1

@@ -57,7 +57,7 @@ Project:M36 implements multiple interfaces:

57To understand how Project:M36 stacks up against the fictional programming language shown in the paper, we have implemented the [example from the paper](/examples/out_of_the_tarpit.tutd). The language used in the script is a dialect of Chris Date's TutorialD language. It can be loaded into an interactive ```tutd``` session like so:

58

59```

60−TutorialD (master/main): :importexample date

60+TutorialD (master/main): :importexample cjdate

61TutorialD (master/main): :showexpr p

62┌───────────────────┬────────────┬───────────────────┬────────────┬────────────┐

63│address::Address │agent::Agent│dateRegistered::Day│photo::Text │price::Price│

docs/server_mode.markdown+1−1

@@ -8,7 +8,7 @@ While Project:M36 is easy-to-use as an interactive, in-process database manageme

8

9To start the Project:M36 server to serve the local host with a database named "mydbname", run ```cabal run project-m36-server -- --database mydbname --hostname 127.0.0.1``` in the project-m36 source directory. The double-dash indicates that the arguments should be passed to ```project-m36-server``` instead of ```cabal```. Under normal conditions, this command will print nothing and block indefinitely to serve incoming requests on the default port 6543.

10

11−Note that the above invocation will serve and in-memory, transient "mydbname" database. The database is deleted when the server exits. To serve a database with filesystem persistence, invoke ```cabal run project-m36-server -- --database mydbname --hostname 127.0.0.1 --database-directory /path/to/dbdirectory --fsync```.

11+Note that the above invocation will serve an in-memory, transient "mydbname" database. The database is deleted when the server exits. To serve a database with filesystem persistence, invoke ```cabal run project-m36-server -- --database mydbname --hostname 127.0.0.1 --database-directory /path/to/dbdirectory --fsync```.

12

13## Connecting an Interactive Client

14

docs/transaction_graph_operators.markdown+6−4

@@ -43,15 +43,17 @@ TutorialD (master/main): :rollback

43In order to navigate the transaction graph, one must specify transaction UUIDs. Viewing the entirety of the transaction graph as a relation is a single command.

44

45```

46−TutorialD (master/main): :showgraph

47−┌─────────────┬──────────┬──────────────────────────────────────┬────────────────────────────┬──────────────────────────────┐

46+┌─────────────┬────────────────────────────────────────────┬──────────┬──────────────────────────────────────┬────────────────────────────────────────┬─────────────────────────────────┐

48−│current::Bool│head::Text│id::Text │parents::relation {id::Text}│stamp::DateTime │

47+│current::Bool│hash::ByteString │head::Text│id::Text │parents::relation {id::Text} │stamp::DateTime │

49−├─────────────┼──────────┼──────────────────────────────────────┼────────────────────────────┼──────────────────────────────┤

48+├─────────────┼────────────────────────────────────────────┼──────────┼──────────────────────────────────────┼────────────────────────────────────────┼─────────────────────────────────┤

49+

50

51<big result elided>

52```

53The "current" attribute is a boolean value. If true, the transaction is the parent of the current database context. Commits will be children of this transaction.

54

55+The "hash" attribute contains the merkle tree hash for the given transaction. This can be used to ensure that the transaction graph has been used in an append-only fashion, ensuring historical state and audit log integrity.

56+

55The "head" attribute is a boolean value indicating whether or not the transaction is a "head" node of its graph. Head nodes are nodes which have no children.

57The "head" attribute is a boolean value indicating whether or not the transaction is a "head" node of its graph. Head nodes are nodes which have no children.

56

58

57The "id" attribute is the UUID needed in order to navigate the graph.

59The "id" attribute is the UUID needed in order to navigate the graph.

docs/tupleable.markdown+19

@@ -23,6 +23,25 @@ instance Tupleable Person

23

24Now, ```Person``` values can be marshaled between the database and the client. The attribute names appearing in the Haskell data type will appear identically in the server with the same types.

25

26+### Changing Options

27+

28+If our field names don't exactly match attribute names, but follow a common pattern, we can derive Tupleable with custom options. Let's say each field on person has a prefix "person", but we still want to use the attribute names without the prefix. We can make use of the ProjectM36.Tupleable module to accomplish our goal like so:

29+

30+```haskell

31+import ProjectM36.Tupleable.Deriving

32+

33+data Person = Person {

34+ personName :: Text,

35+ personEmployeeNumber :: Int,

36+ personLikesHorses :: Bool

37+ }

38+ deriving stock Generic

39+ deriving Tupleable

40+ via Codec (Field (DropPrefix "person" >>> CamelCase)) Person

41+```

42+

43+The extensions DerivingGeneric, DerivingVia, TypeOperators, and DataKinds must be enabled for this code to compile. See the documentation on Hackage for all available options.

44+

26## Usage

45## Usage

27

46

28The ```Tupleable``` module includes the following functions:

47The ```Tupleable``` module includes the following functions:

docs/tutd_cheatsheet.markdownnew file+99

@@ -0,0 +1,99 @@

1+# Tutorial D Cheatsheet

2+

3+The following tables list examples of expressions for `tutd`, Project:M36's "Tutorial D" implementation.

4+

5+## Relational Expressions

6+

7+Relational expressions query database state without being able to change it.

8+

9+|Relational Expression |Description |

10+|------------------------------------------------------|---------------------------------------|

11+|`:showexpr p`|Display the relation variable `p`|

12+|`:showexpr s rename {city as town}`|Display the result after renaming a relational attribute|

13+|`:showexpr p{color,city}`|Display the result of the projection on the `color` and `city` attributes|

14+|`:showexpr p{all but city}`|Display the result of the projection of all attribute of `p` except `city`|

15+|`:showexpr p join sp`|Display the result of the relational expression `p` joined against `sp` (equivalent to `NATURAL JOIN` in SQL)|

16+|`:showexpr (s join sp){all from s}`|Display the result of a join but only include attributes from `s`|

17+|`:showexpr s semijoin sp`|Equivalent to `(s join sp){all from s}`|

18+|`:showexpr s antijoin sp`|Display the result of all tuples in `s` which do not match appear in the result of `s semijoin sp`|

19+|`:showexpr s union s`| Display the result of `s` unioned with itself (which is equivalent to `s`)|

20+|`:showexpr s:{status2:=add(10,@status)}`| Display the result of extending the `s` relation variable with a new attribute which adds 10 to each `status` attribute|

21+|`:showexpr s group ({sname,status,s#} as subrel)`| Display the result of grouping the `sname`, `status`, and `s#` into a subrel for each tuple in the `s` relation where the `city` attribute (not mentioned) is the grouping criteria|

22+|`:showexpr (s group ({sname,status,s#} as subrel)) ungroup subrel`| Display the result of unwrapping a subrelation to create one new tuple for each subrelation tuple in the result|

23+|`:showexpr s minus s`|Display the result after removing all tuples that match the second argument. `x minus x` is equivalent to `x where false`|

24+|`:showexpr relation{tuple{name "Mike",age 6},tuple{name "Sam",age 10}}`|Display an unnamed relation using manually constructed tuples|

25+|`:showexpr relation{a Integer, b Text}`|Display an empty-tupled relation of a specified type|

26+|`:showexpr relation{a Integer, b Text}{tuple{a 4, b "four"}}`|Display a relation bound by the specified types and containing one or more tuples|

27+|`:showexpr s group ({s#,sname,status} as subrel):{citycount:=count(@subrel)}`|Display a result which groups `s` by `city` and extends the relation by a count for each city.|

28+|`:showrelvars`|Display a list of relation variables in the current context along with their types (attributes)|

29+

30+## Built-In Types

31+

32+|Example Value Expression |Type |Explanation|

33+|------------------------------------------------------|---------------------------------------|-----------|

34+|`"abc"`|Text|UTF-8 string|

35+|`123`|Integer|an integer of limitless size (using gmp)|

36+|`int(456)`|Int|machine-word-based integer|

37+|`12.56`|Double|64-bit IEEE 754 floating point number|

38+|`dateTimeFromEpochSeconds(1502304846)`|DateTime||

39+|`fromGregorian(2017,05,30)`|Date||

40+|`t`|Bool|`t` or `f`|

41+|`bytestring("dGVzdGRhdGE=")`|Bytestring|base-64-encoded string of bytes|

42+|`interval(3,5,f,f)`|Interval(Integer)|the constructor function includes two bounds and two boolean flags for inclusiveness|

43+

44+## Database Context Expressions

45+

46+Database context expressions take the current database context as input and alter it to create a new

47+

48+|Database Context Expression |Description |

49+|------------------------------------------------------|---------------------------------------|

50+|`:importexample cjdate`|Imports a precooked schema from Chris Date's books resulting in relvars `s`, `sp`, and `p`|

51+|`:importtutd "file:///home/agentm/project-m36/scripts/emp.tutd"`|Imports TutorialD from file URI|

52+|`:importtutd "https://raw.githubusercontent.com/agentm/project-m36/master/scripts/emp.tutd" "effe32b247586dc3ac0079fc241b9618d41d189afcaeb7907edbe5a8b45992a4"`| Imports TutorialD from HTTP or HTTPS URI|

53+|`newrelvar:=relation{tuple{age 3}}`|Assign a new relation variable named `newrelvar`|

54+|`undefine s`|Remove a relation variable|

55+|`insert s relation{tuple{city "Boston",s# "S10",sname "Gonzalez",status 10}}`| Append to an existing relation variable with another relational expression|

56+|`update s where status=20 (sname:="Mr. Twenty")`|Replace one or more values in matching tuples with a new value|

57+|`delete sp where s#="S4"`|Remove tuples matching the criteria|

58+|`key s_key_constraint {s#} s`|Add a constraint named `s_key_constraint` on relation variable `s` ensuring that `s#` is unique|

59+|`foreign key s#_in_sp sp{s#} in s{s#}`|Add a foreign key constraint that ensures that `sp`'s `s#` attribute always references a `s#` value in `s`|

60+|`constraint s_status_less_than_50 (s where ^lt(50,@status)){} in false`|Add a constraint that stipulates that the `status` values in `s` are less than 50|

61+|`createarbitraryrelation employee {name Text, empid Int, hired DateTime} 3-100`|Create a relation variable with random values with between 3-100 tuples- useful for testing|

62+|`notify steve_change person where name="Steve" true (person where name="Steve"){address}`|Notify the current connection with an asynchronous event if any committed tuples matching `person where name="Steve"` with `true` for the pre-change state and `person where name="Steve"){address}` for the post-change state- these states will be sent along with the notification|

64+|`undata Hair`|Delete the `Hair` custom type|

65+

66+

67+## Transaction Graph Expressions

68+

69+Transaction graph expressions alter the state of the transaction graph by append new states.

70+

71+|Transaction Graph Expression |Description |

72+|------------------------------------------------------|---------------------------------------|

73+|`:commit`|Save the current database context to a new transaction and add it to the transaction graph|

74+|`:rollback`|Return the database context to the state before any alterations were made|

75+|`:branch experimental`|Create a new branch from the existing branch and switch the current context to be able to commit to the new branch|

76+|`:jumphead master`|Discard any changes in the current context and jump to the head of a different branch|

77+|`:jump 11b601c9-f46b-42b0-a2ce-cf18ced31b7f`|Jump to the specific transaction by UUID- useful for introspecting past states|

78+|`:showgraph`|Display a representation of the transaction graph|

79+|`:walkbacktotime "2017-08-10 16:44:00"`|Walk back in time from the current branch until a transaction less than or equal to the time is found and switch the current context to that past transaction- useful for auditing|

80+

81+## Data Frame Expressions

82+

83+In contrast to relational expressions, data frame expressions generate ordered tuples.

84+

85+|Data Frame Expression |Description |

86+|------------------------------------------------------|---------------------------------------|

87+|`:showdataframe s orderby {status}`|Display a data frame result for the relational expression `s` and sort the tuples by `status`|

88+|`:showdataframe s{status} orderby {status descending} offset 1 limit 3`|Display a data frame result for `s{status}` but ordered by `status` values descending, skip the first tuple, and return no more than 3 tuples|

89+

90+## Trans-Graph Relational Expressions

91+

92+Trans-graph relational expressions allow queries spanning multiple transactions.

93+

94+|Trans-Graph Relational Expressions |Description |

95+|------------------------------------------------------|---------------------------------------|

96+|`:showtransgraphexpr s@master join sp@master`|Display a result for joining `s` and `sp` on the branch `master`|

97+|`:showtransgraphexpr s@master~ join sp@master`|Display a result for joining `s` on the parent transaction of `master`'s current head and `sp` on master|

98+|`:showtransgraphexpr s@master~^2`|Display a result for `s` two parents previous to the parent of the current `master`'s head|

99+

docs/tutd_tutorial.markdown+56−2

@@ -19,7 +19,7 @@ TutorialD (master/main):

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

20

21```

22−:importexample date

22+:importexample cjdate

23```

24

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

@@ -30,6 +30,24 @@ Each section assumes a fresh instance of the Date examples. The relation variabl

30|p|parts|

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

32

33+### Importing TutorialD from Other Sources

34+

35+The `tutd` console can also run TutorialD from a local file or from a web server.

36+

37+To import TutorialD from a file:

38+

39+```

40+:importtutd "file:///home/agentm/project-m36/scripts/emp.tutd"

41+```

42+

43+or from a web server:

44+

45+```

46+:importtutd "https://raw.githubusercontent.com/agentm/project-m36/master/scripts/DateExamples.tutd" "db9f3d9fe06d0a29b8355e045b89ec94d6428e3a3de93def7ca77bf0298b7010"

47+```

48+

49+The second argument is an optional SHA256 hash in hexadecimal form. This can be used to validate that the script has not changed since the last import. Importing TutorialD from the web is in general safe because it is effectively sandboxed with "Safe Haskell" for functions, so the script is contained security-wise, however, nothing prevents the script from running forever. Downloading a schema from the web is a great way to share schemas and to kick start your project without starting from scratch.

50+

33### Types

51### Types

34

52

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

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

@@ -197,7 +215,7 @@ TutorialD (master/main): :showexpr s{all but city}

197└────────┴───────────┴───────────────┘

215└────────┴───────────┴───────────────┘

198```

216```

199

217

200−Projection attributes can also be derived from a relational expression using `all from`:

218+Projection attributes can be derived from a relational expression using `all from`:

201

219

202```

220```

203TutorialD (master/main): :showexpr (s join sp){all from s}

221TutorialD (master/main): :showexpr (s join sp){all from s}

@@ -213,6 +231,42 @@ TutorialD (master/main): :showexpr (s join sp){all from s}

213

231

214Above, we join `s` and `sp` but project the result back onto the attributes of `s`.

232Above, we join `s` and `sp` but project the result back onto the attributes of `s`.

215

233

234+Projection attributes can be unioned from multiple sources using `union of`:

235+

236+```

237+TutorialD (master/main): :showexpr (s join sp){union of {all from s} {all but p#}}

238+┌──────────┬────────────┬────────┬───────────┬───────────────┐

239+│city::Text│qty::Integer│s#::Text│sname::Text│status::Integer│

240+├──────────┼────────────┼────────┼───────────┼───────────────┤

241+│"Paris" │400 │"S2" │"Jones" │10 │

242+│"London" │400 │"S1" │"Smith" │20 │

243+│"Paris" │200 │"S3" │"Blake" │30 │

244+│"London" │200 │"S4" │"Clark" │20 │

245+│"London" │200 │"S1" │"Smith" │20 │

246+│"Paris" │300 │"S2" │"Jones" │10 │

247+│"London" │100 │"S1" │"Smith" │20 │

248+│"London" │300 │"S4" │"Clark" │20 │

249+│"London" │300 │"S1" │"Smith" │20 │

250+│"London" │400 │"S4" │"Clark" │20 │

251+└──────────┴────────────┴────────┴───────────┴───────────────┘

252+```

253+

254+Here, after joining `s` and `p`, the union of all attributes from `s` and all attributes from `p` except for `p#` are returned.all

255+

256+Finally, projection attributes can be intersected using `intersection of`:

257+

258+```

259+TutorialD (master/main): :showexpr (s join sp){intersection of {all from s} {all from p}}

260+┌──────────┐

261+│city::Text│

262+├──────────┤

263+│"London" │

264+│"Paris" │

265+└──────────┘

266+```

267+

268+Here, after joining `s` and `p`, we project on the intersection of attributes from `s` and `p` which happens to be `city`.

269+

216#### Restriction

270#### Restriction

217

271

218Restriction is applied using a "where" clause, much like in SQL.

272Restriction is applied using a "where" clause, much like in SQL.

docs/websocket_server.markdown+2−2

@@ -16,8 +16,8 @@ except that the websocket server is now listening for websocket connections on p

16

17## Client Connection

18

19−A [simple JavaScript library](/ProjectM36/Server/WebSocket/project-m36.js) to manage the WebSocket connection is available.

19+A [simple JavaScript library](/src/bin/ProjectM36/Server/WebSocket/project-m36.js) to manage the WebSocket connection is available.

20

21## Sample Application

22

23−The [WebSocket example application](/ProjectM36/Server/WebSocket/websocket-client.html) can be used to learn TutorialD and for remote database access from the web browser.

23+The [WebSocket example application](/src/bin/ProjectM36/Server/WebSocket/websocket-client.html) can be used to learn TutorialD and for remote database access from the web browser.

examples/DerivingCustomTupleable.hsnew file+54

@@ -0,0 +1,54 @@

1+{-# LANGUAGE DeriveGeneric, DerivingVia, GeneralizedNewtypeDeriving, TypeOperators, DataKinds, OverloadedStrings #-}

2+

3+import ProjectM36.Tupleable.Deriving

4+import ProjectM36.Atomable (Atomable)

5+import Control.DeepSeq (NFData)

6+import Data.Text (Text)

7+import GHC.Generics (Generic)

8+import Codec.Winery

9+

10+newtype BlogId = BlogId { getBlogId :: Int }

11+ deriving stock (Eq, Ord, Show, Generic)

12+ deriving newtype (Num)

13+ deriving Serialise via WineryRecord BlogId

14+

15+instance NFData BlogId

16+instance Atomable BlogId

17+

18+data Blog = Blog

19+ { blogId :: BlogId

20+ , blogTitle :: Text

21+ , blogAuthorName :: Text

22+ }

23+ deriving stock (Show, Generic)

24+ deriving (Tupleable)

25+ via Codec (Field (DropPrefix "blog" >>> CamelCase)) Blog

26+ deriving Serialise via WineryRecord Blog

27+

28+data Comment = Comment

29+ { commentAuthorName :: Text

30+ , commentComment :: Text

31+ , commentFor :: BlogId

32+ }

33+ deriving stock (Show, Generic)

34+ deriving (Tupleable)

35+ via Codec (Field (DropPrefix "comment" >>> CamelCase)) Comment

36+ deriving Serialise via WineryRecord Comment

37+

38+main :: IO ()

39+main = do

40+ let exampleBlog = Blog

41+ { blogId = 0

42+ , blogTitle = "Cat Pics"

43+ , blogAuthorName = "Alice"

44+ }

45+ exampleComment = Comment

46+ { commentAuthorName = "Bob"

47+ , commentComment = "great"

48+ , commentFor = 0

49+ }

50+ print exampleBlog

51+ print (toTuple exampleBlog)

52+ putStrLn ""

53+ print exampleComment

54+ print (toTuple exampleComment)

examples/Plantfarm.hsnew file+446

@@ -0,0 +1,446 @@

1+{-# LANGUAGE DeriveGeneric #-}

2+

3+{-# LANGUAGE OverloadedStrings #-}

4+

5+{-# LANGUAGE DeriveAnyClass #-}

6+

7+{-# LANGUAGE DerivingVia #-}

8+

9+

10+import Codec.Winery (Serialise, WineryVariant(WineryVariant))

11+import Control.DeepSeq (NFData)

12+import Data.Aeson (FromJSON, ToJSON(toEncoding, toJSON))

13+import Data.Data (Proxy(Proxy))

14+import Data.Either (lefts, rights)

15+import Data.Functor (($>))

16+import Data.Text as T (Text)

17+import qualified Data.Text.Lazy as TL (pack)

18+import GHC.Generics (Generic)

19+import qualified ProjectM36.Base as Base

20+import ProjectM36.Client

21+ ( AtomExprBase(NakedAtomExpr)

22+ , Atomable(toAddTypeExpr, toAtom)

23+ , AttributeName

24+ , Connection

25+ , ConnectionInfo(InProcessConnectionInfo)

26+ , DatabaseContextExpr

27+ , DatabaseContextExprBase(Delete)

28+ , PersistenceStrategy(NoPersistence)

29+ , RelationalError

30+ , RelationalExprBase(RelationVariable, Restrict)

31+ , RestrictionPredicateExprBase(AttributeEqualityPredicate)

32+ , SessionId

33+ , close

34+ , commit

35+ , connectProjectM36

36+ , createSessionAtHead

37+ , databaseContextExprForUniqueKey

38+ , defaultHeadName

39+ , emptyNotificationCallback

40+ , executeDatabaseContextExpr

41+ , executeRelationalExpr

42+ , withTransaction

43+ )

44+import qualified ProjectM36.Relation as Relation

45+import ProjectM36.Tupleable

46+ ( Tupleable(fromTuple)

47+ , toDefineExpr

48+ , toDeleteExpr

49+ , toInsertExpr

50+ , toUpdateExpr

51+ )

52+import qualified System.Random as R

53+

54+

55+import Control.Monad.IO.Class (MonadIO(liftIO))

56+import qualified Web.Scotty as S

57+

58+-- | This is an example showcasing the updating of data

59+-- with the help of plants. \\

60+-- This is a very simple example and of course not how

61+-- plants grow in nature. \\

62+-- The main goal of this example is to showcase the updating

63+-- of data and the different options of persistence.

64+-- You can just pipe the output from curl into jq:

65+--

66+-- curl -X POST -H 'Accept: application/json' http://localhost:8001/plant/water/angu | jq -r '.stage'

67+

68+

69+data Stage = Seed | Sprout | Seedling | Adult | Dead

70+ deriving (Show, Eq, Ord, Generic, NFData, Atomable)

71+ deriving Serialise via WineryVariant Stage

72+

73+

74+instance ToJSON Stage where -- The where can be removed and the implementation commented out

75+ -- if the ascii values are not wanted

76+ toJSON s = toJSON $ show s <> "\nascii only provided for visualisation:\n" <> stagetoAscii s

77+

78+ toEncoding s = toEncoding $ show s <> "\nascii only provided for visualisation:\n" <> stagetoAscii s

79+

80+instance FromJSON Stage

81+

82+instance S.Parsable Stage where

83+ parseParam t

84+ | t == "seed" || t == "Seed" = Right Seed

85+ | t == "sprout" || t == "Sprout" = Right Sprout

86+ | t == "seedling" || t == "Seedling" = Right Seedling

87+ | t == "adult" || t == "Adult" = Right Adult

88+ | t == "dead" || t == "Dead" = Right Dead

89+ | otherwise = Left t

90+

91+

92+-- Just for ToJSON for ilustration of stage

93+type ASCIIStage = String

94+

95+seedStr :: ASCIIStage

96+seedStr = "<>\n\

97+ \'''\n"

98+sproutStr :: ASCIIStage

99+sproutStr = " ..\n\

100+ \<|>\n\

101+ \''''\n"

102+seedlingStr :: ASCIIStage

103+seedlingStr = " `\\⁄o \n\

104+ \ v|/\n\

105+ \'´;'''\n"

106+adultStr :: ASCIIStage

107+adultStr = "*~(#)~\n\

108+ \ \\,Y,e\n\

109+ \ \\|/\n\

110+ \''+'\\''\n"

111+deadStr :: ASCIIStage

112+deadStr = " ,__:<\n\

113+ \'/'''''\n"

114+

115+-- Just used for ToJSON illustration of stages

116+stagetoAscii :: Stage -> ASCIIStage

117+stagetoAscii Seed = seedStr

118+stagetoAscii Sprout = sproutStr

119+stagetoAscii Seedling = seedlingStr

120+stagetoAscii Adult = adultStr

121+stagetoAscii Dead = deadStr

122+

123+-- used for update stage

124+next :: Stage -> Stage

125+next Seed = Sprout

126+next Sprout = Seedling

127+next Seedling = Adult

128+next s = s

129+

130+data Plant = Plant { name :: Text, species :: Text, stage :: Stage, waterings:: Integer } deriving (Show, Generic)

131+instance Tupleable Plant

132+instance ToJSON Plant

133+instance FromJSON Plant

134+

135+

136+main :: IO ()

137+main = do

138+ putStrLn "Connecting to plant farm"

139+ c <- dbConnection

140+ _ <- createSchema c

141+ putStrLn "Planting some plants"

142+ _ <- insertSampleData c

143+ let port = 8001

144+ putStrLn $ "Started Plant farm at " <> show port

145+ S.scotty port $ do

146+

147+ -- retrieve a plant by name

148+ S.get "/plant/:name" $ do

149+ n <- S.param "name"

150+ e <- liftIO $ getPlant c n

151+ p <- handleWebError e

152+ S.json p

153+

154+

155+ -- save a plant providing it as json data

156+ S.post "/plant" $ do

157+ pl <- S.jsonData :: S.ActionM Plant

158+ e <- liftIO $ savePlant c [pl]

159+ p <- handleWebError e

160+ S.json p

161+

162+ -- updating a plant providing it as json data

163+ S.put "/plant" $ do

164+ pl <- S.jsonData :: S.ActionM Plant

165+ e <- liftIO $ updatePlantFst c pl

166+ p <- handleWebError e

167+ S.json p

168+

169+ -- watering the plant having the provided name.

170+ -- This will water the plant and might let it progress to the next stage. It might also die.

171+ S.post "/plant/water/:name" $ do

172+ n <- S.param "name"

173+ e <- liftIO $ waterPlant c n

174+ p <- handleWebError e

175+ S.json p

176+

177+ -- retriving all the plants as json data

178+ S.get "/plants" $ do

179+ e <- liftIO $ getAllPlants c

180+ ps <- handleWebErrors e

181+ S.json ps

182+

183+ -- saving many plants at the same time

184+ S.post "/plants" $ do

185+ pl <- S.jsonData :: S.ActionM [Plant]

186+ e <- liftIO $ savePlant c pl

187+ p <- handleWebError e

188+ S.json p

189+

190+ -- deleting all plants at a specific stage

191+ S.delete "/plants?stage=:stage" $ do

192+ s <- S.param "stage"

193+ e <- liftIO $ deletePlantsByStage c s

194+ p <- handleWebError e

195+ S.json p

196+

197+ -- deleting all plants at a specific stage

198+ S.delete "/plants" $ do

199+ s <- S.param "name"

200+ e <- liftIO $ deletePlantByName c s

201+ p <- handleWebError e

202+ S.json p

203+

204+ -- deleting all dead plants

205+ S.delete "/plants/clear" $ do

206+ e <- liftIO $ clearDeadPlants c

207+ ps <- handleWebErrors e

208+ S.json ps

209+

210+handleWebError :: Either Err b -> S.ActionM b

211+handleWebError (Left e) = S.raise (TL.pack $ "An error occurred:\n" <> show e)

212+handleWebError (Right v) = pure v

213+

214+handleWebErrors :: [Either Err b] -> S.ActionM [b]

215+handleWebErrors e = do

216+ case lefts e of

217+ [] -> pure (rights e)

218+ l -> S.raise (TL.pack $ "Errors occurred:\n" <> concatMap ((<>"\n") . show) l)

219+

220+

221+-- | watering a plant and thereby possibly updating its stage

222+waterPlant :: DBConnection -> Text -> IO (Either Err Plant)

223+waterPlant db n = do

224+ p <- getPlant db n

225+ case p of

226+ Left e -> pure $ Left e

227+ Right v -> updateStage db $ v { waterings = waterings v + 1 }

228+

229+-- | used by 'waterPlant' updates the stage depending on random numbers

230+updateStage :: DBConnection -> Plant -> IO (Either Err Plant)

231+updateStage db p@(Plant _ _ Dead _ ) = do

232+ tmp <- updatePlantFst db p

233+ case tmp of

234+ Left e -> pure $ Left e

235+ Right _ -> pure $ Right p

236+updateStage db p = do

237+ res <- calculateStage p

238+ tmp <- updatePlantFst db res

239+ case tmp of

240+ Left e -> pure $ Left e

241+ Right _ -> pure $ Right res

242+ where calculateStage p' = do

243+ r1 <- R.randomRIO (1, 10) :: IO Integer

244+ let np = if r1 < waterings p' then p' { stage = next $ stage p', waterings = 0 } else p'

245+ r2 <- R.randomRIO (1, 20)

246+ pure $ if r2 < waterings np then np { stage = Dead, waterings = 0 } else np

247+

248+-- | deletes all plants with Stage = Dead

249+clearDeadPlants :: DBConnection -> IO [Either Err Plant]

250+clearDeadPlants db = do

251+ _ <- deletePlantsByStage db Dead

252+ getAllPlants db

253+

254+

255+-- ****************************

256+-- | *Database functions* :

257+-- ****************************

258+

259+

260+-- | Error type for passing. It is not very specific.

261+-- Just minimal and non optimal for this example.

262+data Err = NotSpecified | NotFound deriving (Show ,Generic)

263+

264+instance ToJSON Err

265+

266+-- | Just for convinience for passing around the SessionId

267+-- and the Connection

268+data DBConnection = DB SessionId Connection

269+

270+

271+-- | Getting plants by their name.\

272+-- Because plant has name as primary key \

273+-- we can assume will get at most one result. \

274+-- Alternatively we could return a list.

275+getPlant :: DBConnection -> Text -> IO (Either Err Plant)

276+getPlant db n = defaultHead (Left NotFound) <$> (

277+ get db

278+ ( Restrict -- Restrict can be thought of as similar to "WITH" in SQL

279+ (AttributeEqualityPredicate "name" (NakedAtomExpr (toAtom n))) -- This is the Predicate we are "restricting" our RelationalExprBase with

280+ (RelationVariable "plants" ())

281+ )

282+ :: IO [Either Err Plant] -- this is needed because our 'get' function is

283+ )

284+

285+defaultHead :: a -> [a] -> a

286+defaultHead d [] = d

287+defaultHead _ (x:_) = x

288+

289+-- | Getting all the plants

290+getAllPlants :: DBConnection -> IO [Either Err Plant]

291+getAllPlants db = get db (RelationVariable "plants" ())

292+

293+-- | Getting all the plants that satisfy the restrictions

294+getAllPlantsWith :: DBConnection -> Base.RestrictionPredicateExpr -> IO [Either Err Plant]

295+getAllPlantsWith db ex = get db (Restrict ex (RelationVariable "plants" ()))

296+

297+

298+-- | Saving a plant

299+savePlant :: (Traversable t) => DBConnection -> t Plant -> IO (Either Err ())

300+savePlant db sps = insert db sps "plants"

301+

302+-- | An alternative to update alone because due to updates

303+-- not being cached yet \

304+-- they have to be calculated every update. \

305+-- This seems like an alternative until caching is implemented.

306+updatePlantFst :: DBConnection -> Plant -> IO (Either Err ())

307+updatePlantFst db pln = do

308+ _ <- delete db pln ["name"] "plants"

309+ savePlant db [pln]

310+

311+-- | Updating a plant. Due to the way project 36 works, \

312+-- updates have to be executed every time.\

313+-- This is slow but won't be an issue soon because they will

314+-- be cached.\

315+-- But because of this project 36 can provide O(1) commits.

316+updatePlant :: DBConnection -> Plant -> IO (Either Err ())

317+updatePlant db sps = update

318+ db -- db connection

319+ sps -- plant value

320+ ["name"] -- the attributes to be updated by (in case of unique key)

321+ "plants" -- the relation we want to update on

322+

323+

324+-- | deleting all plants that have given name.

325+deletePlantByName :: DBConnection -> Text -> IO (Either Err ())

326+deletePlantByName db s = executeWithTransaction db $ Right $ Delete "plants" $ AttributeEqualityPredicate "name" (NakedAtomExpr (toAtom s))

327+

328+-- | deleting all plants that have given stage.

329+deletePlantsByStage :: DBConnection -> Stage -> IO (Either Err ())

330+deletePlantsByStage db s = executeWithTransaction db $ Right $ Delete "plants" $ AttributeEqualityPredicate "stage" (NakedAtomExpr (toAtom s))

331+

332+

333+-- | Inserting the schema into the DB

334+createSchema :: DBConnection -> IO ()

335+createSchema (DB sessionId conn) = do

336+ _ <- handleIOErrorsAndQuit $ mapM (executeDatabaseContextExpr sessionId conn) [

337+ toAddTypeExpr (Proxy :: Proxy Stage) -- Adds the Type Stage as data to the DB

338+ , toDefineExpr (Proxy :: Proxy Plant) "plants" -- Creates the plants relation

339+ , databaseContextExprForUniqueKey "plants" ["name"] -- Makes name of the plants relation a uniqe Key,

340+ -- Foreign Key restrictions are available too

341+ ]

342+ pure ()

343+

344+

345+-- | inserting some sample data

346+insertSampleData :: DBConnection -> IO (Either Err ())

347+insertSampleData (DB sid conn) = do

348+ insert (DB sid conn) [

349+ Plant "angu" "Caladenia angustata" Seed 0

350+ , Plant "thely" "Thelymitra alcockiae" Seed 0

351+ , Plant "monstera" "Araceae" Seed 0

352+ ] "plants"

353+

354+dbConnection :: IO DBConnection

355+dbConnection = do

356+ -- connect to the database

357+ let connInfo = InProcessConnectionInfo NoPersistence emptyNotificationCallback []

358+ -- The code below persists the data in a DB with the name "base". \\

359+-- let connInfo = InProcessConnectionInfo (CrashSafePersistence "base") emptyNotificationCallback [] \\

360+ -- In addition minimal persistance is available. \\

361+-- let connInfo = InProcessConnectionInfo (MinimalPersistence "base") emptyNotificationCallback []

362+ conn <- handleIOErrorAndQuit $ connectProjectM36 connInfo

363+ --create a database session at the default branch of the database

364+ sessionId <- handleIOErrorAndQuit $ createSessionAtHead conn defaultHeadName

365+ pure (DB sessionId conn)

366+

367+

368+-- | A polymorphic function to insert data (a traversable of data) into the DB

369+insert :: (Tupleable a, Traversable t) => DBConnection -> t a -> Base.RelVarName -> IO (Either Err ())

370+insert db rlv rlvName = executeWithTransaction db $ toInsertExpr rlv rlvName

371+

372+-- | A polymorphic function to update data in the DB.

373+-- An update in one funtion would take:

374+--

375+-- - SessionId

376+-- - Connection

377+-- - Tuplable a -- the Tuplable you want to update

378+-- - [AttributeName] -- the Attributes of the Tuplable you want to update those are of StringType

379+-- - RelVarName -- the name of the relation

380+--

381+-- With that you can via 'toUpdateExpr' create a 'DatabaseContextExpr' to be executed. \\

382+-- For inserting its very similarly done with 'toInsertExpr'.

383+update :: (Tupleable a) => DBConnection -> a -> [AttributeName]-> Base.RelVarName -> IO (Either Err ())

384+update db rlv attr rlvName = executeWithTransaction db $ toUpdateExpr rlvName attr rlv

385+

386+-- | A polymorphic function to delete data in the DB

387+delete :: (Tupleable a) => DBConnection -> a -> [AttributeName]-> Base.RelVarName -> IO (Either Err ())

388+delete db rlv attr rlvName = executeWithTransaction db $ toDeleteExpr rlvName attr rlv

389+

390+-- | A convenience function to make executing DBContextExpr with commiting simpler. \\

391+-- In particular for expr that just insert, delete and update.

392+-- Therefor ultimately return Either _ ()

393+executeWithTransaction :: DBConnection -> Either RelationalError DatabaseContextExpr -> IO (Either Err ())

394+executeWithTransaction (DB sid conn) expr = do

395+ iEx <- handleError expr

396+ case iEx of

397+ Left e -> pure $ Left e

398+ Right v -> handleIOError $ withTransaction sid conn (executeDatabaseContextExpr sid conn v) (commit sid conn)

399+

400+-- | A polymorphic function to get data (a list of data and possibly errors) from the DB

401+get :: Tupleable b => DBConnection -> Base.RelationalExpr -> IO [Either Err b]

402+get (DB sessionId conn) q = do

403+ eRel <- executeRelationalExpr sessionId conn q

404+ e <- handleError eRel

405+ case e of

406+ Left err -> pure [Left err]

407+ Right pRel -> do

408+ ws <- Relation.toList pRel

409+ mapM (handleError . fromTuple) ws

410+

411+-- | for closing the DB connection.

412+-- Not really needed when using in-memory DB

413+closeConn :: DBConnection -> IO ()

414+closeConn (DB _ conn) = close conn

415+

416+

417+-- | Error handling is heavily inspired by 'blog.hs' the blog example \\

418+-- by (agentm)[https://github.com/agentm] (https://github.com/agentm/project-m36, commit: f8432522adaafeae7c32bc2b8b6cb09c00396fc6). \\

419+-- As stated there, your application should have proper error handling.

420+handleIOErrorAndQuit :: Show e => IO (Either e a) -> IO a

421+handleIOErrorAndQuit m = do

422+ v <- m

423+ handleErrorAndQuit v

424+

425+handleError :: Show e => Either e a -> IO (Either Err a)

426+handleError eErr = case eErr of

427+ Left err -> print err $> Left NotSpecified

428+ Right v -> pure $ Right v

429+

430+handleIOError :: Show e => IO (Either e a) -> IO (Either Err a)

431+handleIOError m = do

432+ v <- m

433+ handleError v

434+

435+handleErrorAndQuit :: Show e => Either e a -> IO a

436+handleErrorAndQuit eErr = case eErr of

437+ Left err -> print err >> error "Quit."

438+ Right v -> pure v

439+

440+handleIOErrorsAndQuit :: Show e => IO [Either e a] -> IO [a]

441+handleIOErrorsAndQuit m = do

442+ eErrs <- m

443+ case lefts eErrs of

444+ [] -> pure (rights eErrs)

445+ err:_ -> handleErrorAndQuit (Left err)

446+

examples/SimpleClient.hs+1−1

@@ -6,7 +6,7 @@ import Data.Text.IO as TIO

6main :: IO ()

7main = do

8 -- 1. create a ConnectionInfo

9− let connInfo = RemoteProcessConnectionInfo "mytestdb" (createNodeId "127.0.0.1" defaultServerPort) emptyNotificationCallback

9+ let connInfo = RemoteConnectionInfo "mytestdb" "127.0.0.1" (show defaultServerPort) emptyNotificationCallback

10 -- 2. conncted to the remote database

11 eConn <- connectProjectM36 connInfo

12 case eConn of

examples/blog.hs+11−8

@@ -1,5 +1,5 @@

1-- a simple example of a blog schema

2−{-# LANGUAGE DeriveAnyClass, DeriveGeneric, OverloadedStrings #-}

2+{-# LANGUAGE DeriveAnyClass, DeriveGeneric, OverloadedStrings, CPP, DerivingVia #-}

3

4import ProjectM36.Client

5import ProjectM36.Base

@@ -10,16 +10,18 @@ import ProjectM36.Tuple (atomForAttributeName)

10

11import Data.Either

12import GHC.Generics

13−import Data.Binary

14import qualified Data.Text as T

13import qualified Data.Text as T

15import qualified Data.Text.Lazy as TL

14import qualified Data.Text.Lazy as TL

16import Data.Time.Clock

15import Data.Time.Clock

17import Data.Time.Calendar

16import Data.Time.Calendar

18import Control.DeepSeq

17import Control.DeepSeq

19import Data.Proxy

18import Data.Proxy

19+#if __GLASGOW_HASKELL__ < 804

20import Data.Monoid

21+#endif

21import Data.List

22import Data.List

22import Control.Monad (when, forM_)

23import Control.Monad (when, forM_)

24+import Codec.Winery

23

25

24import Web.Scotty as S

26import Web.Scotty as S

25import Text.Blaze.Html5 (h1, h2, h3, p, form, input, (!), toHtml, Html, a, toValue, hr, textarea)

27import Text.Blaze.Html5 (h1, h2, h3, p, form, input, (!), toHtml, Html, a, toValue, hr, textarea)

@@ -33,7 +35,7 @@ import Data.Time.Format

33data Blog = Blog {

35data Blog = Blog {

34 title :: T.Text,

36 title :: T.Text,

35 entry :: T.Text,

37 entry :: T.Text,

36− stamp :: UTCTime,

38+ tstamp :: UTCTime,

37 category :: Category --note that this type is an algebraic data type

39 category :: Category --note that this type is an algebraic data type

38 }

40 }

39 deriving (Generic, Show) --derive Generic so that Tupleable can use default instances

41 deriving (Generic, Show) --derive Generic so that Tupleable can use default instances

@@ -50,7 +52,8 @@ data Comment = Comment {

50instance Tupleable Comment

52instance Tupleable Comment

51

53

52data Category = Food | Cats | Photos | Other T.Text -- note that this data type could not be represented by an "enumeration" as found in SQL databases

54data Category = Food | Cats | Photos | Other T.Text -- note that this data type could not be represented by an "enumeration" as found in SQL databases

53− deriving (Atomable, Eq, Show, NFData, Binary, Generic) -- derive Atomable so that values of this type can be stored as a database value

55+ deriving (Atomable, Eq, Show, NFData, Generic) -- derive Atomable so that values of this type can be stored as a database value

56+ deriving Serialise via WineryVariant Category -- derive Serialisable to be able to transmit this data remotely

54

57

55-- add some short-hand error handling- your application should have proper handling

58-- add some short-hand error handling- your application should have proper handling

56handleIOError :: Show e => IO (Either e a) -> IO a

59handleIOError :: Show e => IO (Either e a) -> IO a

@@ -103,11 +106,11 @@ insertSampleData :: SessionId -> Connection -> IO ()

103insertSampleData sessionId conn = do

106insertSampleData sessionId conn = do

104 let blogs = [Blog { title = "Haskell Lenses",

107 let blogs = [Blog { title = "Haskell Lenses",

105 entry = "I wear Haskell rose-colored lenses.",

108 entry = "I wear Haskell rose-colored lenses.",

106− stamp = UTCTime (fromGregorian 2017 5 8) (secondsToDiffTime 1000),

109+ tstamp = UTCTime (fromGregorian 2017 5 8) (secondsToDiffTime 1000),

107 category = Food },

110 category = Food },

108 Blog { title = "Haskell Monad Analogy",

111 Blog { title = "Haskell Monad Analogy",

109 entry = "Monads are like burritos going through intestines.",

112 entry = "Monads are like burritos going through intestines.",

110− stamp = UTCTime (fromGregorian 2017 6 10) (secondsToDiffTime 2000),

113+ tstamp = UTCTime (fromGregorian 2017 6 10) (secondsToDiffTime 2000),

111 category = Cats }

114 category = Cats }

112 ]

115 ]

113 comments = [Comment { blogTitle = "Haskell Lenses",

116 comments = [Comment { blogTitle = "Haskell Lenses",

@@ -136,7 +139,7 @@ listBlogs sessionId conn = do

136 Left err -> render500 (toHtml (show err))

139 Left err -> render500 (toHtml (show err))

137 Right blogRel -> do

140 Right blogRel -> do

138 blogs <- liftIO (toList blogRel) >>= mapM (handleWebError . fromTuple) :: ActionM [Blog]

141 blogs <- liftIO (toList blogRel) >>= mapM (handleWebError . fromTuple) :: ActionM [Blog]

139− let sortedBlogs = sortBy (\b1 b2 -> stamp b1 `compare` stamp b2) blogs

142+ let sortedBlogs = sortBy (\b1 b2 -> tstamp b1 `compare` tstamp b2) blogs

140 html . renderHtml $ do

143 html . renderHtml $ do

141 h1 "Blog Posts"

144 h1 "Blog Posts"

142 forM_ sortedBlogs $ \blog -> a ! href (toValue $ "/blog/" <> title blog) $ h2 (toHtml (title blog))

145 forM_ sortedBlogs $ \blog -> a ! href (toValue $ "/blog/" <> title blog) $ h2 (toHtml (title blog))

@@ -182,7 +185,7 @@ showBlogEntry sessionId conn = do

182 render $ do

185 render $ do

183 --show blog details

186 --show blog details

184 h1 (toHtml (title blog))

187 h1 (toHtml (title blog))

185− p (toHtml ("Posted at " <> formatStamp (stamp blog) <> " under " <> show (category blog)))

188+ p (toHtml ("Posted at " <> formatStamp (tstamp blog) <> " under " <> show (category blog)))

186 p (toHtml (entry blog))

189 p (toHtml (entry blog))

187 hr

190 hr

188 h3 "Comments"

191 h3 "Comments"

examples/hair.hs+9−6

@@ -1,16 +1,17 @@

1−{-# LANGUAGE DeriveGeneric, DeriveAnyClass, OverloadedStrings #-}

1+{-# LANGUAGE DeriveGeneric, DeriveAnyClass, OverloadedStrings, DerivingVia #-}

2import ProjectM36.Client

3import ProjectM36.Relation.Show.Term

4import GHC.Generics

5import Data.Text

6−import Data.Binary

7import Control.DeepSeq

6import Control.DeepSeq

8import qualified Data.Map as M

7import qualified Data.Map as M

9import qualified Data.Text.IO as TIO

8import qualified Data.Text.IO as TIO

10import Data.Proxy

9import Data.Proxy

10+import Codec.Winery

11

12data Hair = Bald | Brown | Blond | OtherColor Text

13− deriving (Generic, Show, Eq, Binary, NFData, Atomable)

13+ deriving (Generic, Show, Eq, NFData, Atomable)

14+ deriving Serialise via WineryVariant Hair

14

15

15main :: IO ()

16main :: IO ()

16main = do

17main = do

@@ -31,11 +32,13 @@ main = do

31

32

32 --create a relation with the new Hair AtomType

33 --create a relation with the new Hair AtomType

33 let blond = NakedAtomExpr (toAtom Blond)

34 let blond = NakedAtomExpr (toAtom Blond)

34− eCheck $ executeDatabaseContextExpr sessionId conn (Assign "people" (MakeRelationFromExprs Nothing [

35+ eCheck $ executeDatabaseContextExpr sessionId conn

36+ (Assign "people"

37+ (MakeRelationFromExprs Nothing $ TupleExprs () [

35− TupleExpr (M.fromList [("hair", blond), ("name", NakedAtomExpr (TextAtom "Colin"))])]))

38+ TupleExpr (M.fromList [("hair", blond), ("name", NakedAtomExpr (TextAtom "Colin"))])]))

36

39

37 let restrictionPredicate = AttributeEqualityPredicate "hair" blond

40 let restrictionPredicate = AttributeEqualityPredicate "hair" blond

38 peopleRel <- eCheck $ executeRelationalExpr sessionId conn (Restrict restrictionPredicate (RelationVariable "people" ()))

41 peopleRel <- eCheck $ executeRelationalExpr sessionId conn (Restrict restrictionPredicate (RelationVariable "people" ()))

39

42

40 TIO.putStrLn (showRelation peopleRel)

43 TIO.putStrLn (showRelation peopleRel)

41−

44+

examples/out_of_the_tarpit.hs+11−7

@@ -1,5 +1,5 @@

1-- the Out-of-the-Tarpit example in Haskell and Project:M36

2−{-# LANGUAGE DeriveAnyClass, DeriveGeneric, OverloadedStrings #-}

2+{-# LANGUAGE DeriveAnyClass, DeriveGeneric, OverloadedStrings, DerivingVia #-}

3import ProjectM36.Client

4import ProjectM36.DataTypes.Primitive

5import ProjectM36.Tupleable

@@ -7,11 +7,11 @@ import ProjectM36.Relation

7import ProjectM36.Error

8import Data.Either

9import GHC.Generics

10−import Data.Binary

11import Control.DeepSeq

10import Control.DeepSeq

12import qualified Data.Text as T

11import qualified Data.Text as T

13import Data.Time.Calendar

12import Data.Time.Calendar

14import Data.Proxy

13import Data.Proxy

14+import Codec.Winery

15

16--create various database value (atom) types

17type Price = Double

@@ -21,16 +21,20 @@ type Name = T.Text

21type Address = T.Text

22

23data RoomType = Kitchen | Bathroom | LivingRoom

24− deriving (Generic, Atomable, Eq, Show, Binary, NFData)

24+ deriving (Generic, Atomable, Eq, Show, NFData)

25+ deriving Serialise via WineryVariant RoomType

25

26

26data PriceBand = Low | Medium | High | Premium

27data PriceBand = Low | Medium | High | Premium

27− deriving (Generic, Atomable, Eq, Show, Binary, NFData)

28+ deriving (Generic, Atomable, Eq, Show, NFData)

29+ deriving Serialise via WineryVariant PriceBand

28

30

29data AreaCode = City | Suburban | Rural

31data AreaCode = City | Suburban | Rural

30− deriving (Generic, Atomable, Eq, Show, Binary, NFData)

32+ deriving (Generic, Atomable, Eq, Show, NFData)

33+ deriving Serialise via WineryVariant AreaCode

31

34

32data SpeedBand = VeryFastBand | FastBand | MediumBand | SlowBand

35data SpeedBand = VeryFastBand | FastBand | MediumBand | SlowBand

33− deriving (Generic, Atomable, Eq, Show, Binary, NFData)

36+ deriving (Generic, Atomable, Eq, Show, NFData)

37+ deriving Serialise via WineryVariant SpeedBand

34

38

35main :: IO ()

39main :: IO ()

36main = do

40main = do

@@ -257,4 +261,4 @@ handleIOErrors m = do

257 [] -> pure (rights eErrs)

261 [] -> pure (rights eErrs)

258 errs -> handleError (Left (someErrors errs))

262 errs -> handleError (Left (someErrors errs))

259

263

260−

264+

examples/out_of_the_tarpit.tutd+4−4

@@ -3,9 +3,9 @@

3data Address = Address Text

4data Agent = Agent Text

5data Name = Name Text

6−data Price = Price Double

6+data Price = Price Integer --dollars

7data RoomType = Kitchen | Bathroom | LivingRoom

8−data PriceBand = Low | Medium | High | Premium

8+data PriceBand = Low | Med | High | Premium

9data AreaCode = City | Suburban | Rural

10data SpeedBand = VeryFast | Fast | Medium | Slow

11

@@ -57,9 +57,9 @@ constraint noOffersAfterSale (offer join decision where ^dayEarlierThan(@offerDa

57--1. identify offerPrices > 2000 (arbitrarily-chosen high price band which is not specified in the paper)

58--2. remove the properties which have been sold

59--3. group and count sub-relation and restrict by greater than 50

60−constraint noMoreThan50PremiumProperties ((((property where ^gt(offerPrice,2000.0)) minus ((property join decision){address,agent,dateRegistered,photo,price})) group ({} as x) : {z:=gt(count(@x),50)}) {z}){} equals false

60+constraint noMoreThan50PremiumProperties ((((property where ^gt(@price,Price 2000)) minus ((property join decision){address,agent,dateRegistered,photo,price})) group ({} as x) : {z:=gt(count(@x),50)}) {z}){} equals false

61

62−constraint noBidderCanMakeMoreThan10BidsOnAProperty (((offer group ({all but bidderAddress} as bidder)) : {bidCount:=gt(count(@bidder),10)}) where ^gt(bidCount,10)) {} equals false

62+constraint noBidderCanMakeMoreThan10BidsOnAProperty (((offer group ({all but bidderAddress} as bidder)) : {bidCount:=gt(count(@bidder),10)}) where ^gt(@bidCount,10)) {} equals false

63

64-- sample data

65

jupyter/TutorialD Notebook Walkthrough.ipynb+1−1

@@ -38,7 +38,7 @@

38 }

39 ],

40 "source": [

41− ":importexample date"

41+ ":importexample cjdate"

42 ]

43 },

44 {

nix/sources.jsonnew file+50

@@ -0,0 +1,50 @@

1+{

2+ "curryer": {

3+ "branch": "master",

4+ "description": "Fast Haskell RPC",

5+ "homepage": null,

6+ "owner": "agentm",

7+ "repo": "curryer",

8+ "rev": "74ecaac619ad1165a4517d5c0f4e530493bda130",

9+ "sha256": "1izdvzj00k0y76ixm7dfgvq2fzphb8h4nzqgwkl3p0bg0806rsn1",

10+ "type": "tarball",

11+ "url": "https://github.com/agentm/curryer/archive/74ecaac619ad1165a4517d5c0f4e530493bda130.tar.gz",

12+ "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"

13+ },

14+ "niv": {

15+ "branch": "master",

16+ "description": "Easy dependency management for Nix projects",

17+ "homepage": "https://github.com/nmattia/niv",

18+ "owner": "nmattia",

19+ "repo": "niv",

20+ "rev": "1819632b5823e0527da28ad82fecd6be5136c1e9",

21+ "sha256": "08jz17756qchq0zrqmapcm33nr4ms9f630mycc06i6zkfwl5yh5i",

22+ "type": "tarball",

23+ "url": "https://github.com/nmattia/niv/archive/1819632b5823e0527da28ad82fecd6be5136c1e9.tar.gz",

24+ "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"

25+ },

26+ "nixpkgs": {

27+ "branch": "master",

28+ "description": "Nix Packages collection",

29+ "homepage": "",

30+ "owner": "NixOS",

31+ "repo": "nixpkgs",

32+ "rev": "429c23aad0fce9ef38b0e60d55d7459c19d53ddc",

33+ "sha256": "1nj8sh1fnxp07jdlvjkijwfd1pnsi2zj0ivy7a0dhx02g63byhg3",

34+ "type": "tarball",

35+ "url": "https://github.com/NixOS/nixpkgs/archive/429c23aad0fce9ef38b0e60d55d7459c19d53ddc.tar.gz",

36+ "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"

37+ },

38+ "streamly": {

39+ "branch": "ac3af8749194f1788704dda8667d0b3807075cc2",

40+ "description": "Beautiful Streaming, Concurrent and Reactive Composition (Haskell)",

41+ "homepage": "https://hackage.haskell.org/package/streamly",

42+ "owner": "composewell",

43+ "repo": "streamly",

44+ "rev": "ac3af8749194f1788704dda8667d0b3807075cc2",

45+ "sha256": "04d8fk654vawdfs0dfidmq2awwgwi8x44iv8r7vqz70zkcsd5fij",

46+ "type": "tarball",

47+ "url": "https://github.com/composewell/streamly/archive/ac3af8749194f1788704dda8667d0b3807075cc2.tar.gz",

48+ "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"

49+ }

50+}

nix/sources.nixnew file+171

@@ -0,0 +1,171 @@

1+# This file has been generated by Niv.

2+

3+let

4+

5+ #

6+ # The fetchers. fetch_<type> fetches specs of type <type>.

7+ #

8+

9+ fetch_file = pkgs: name: spec:

10+ let

11+ name' = sanitizeName name + "-src";

12+ in

13+ if spec.builtin or true then

14+ builtins_fetchurl { inherit (spec) url sha256; name = name'; }

15+ else

16+ pkgs.fetchurl { inherit (spec) url sha256; name = name'; };

17+

18+ fetch_tarball = pkgs: name: spec:

19+ let

20+ name' = sanitizeName name + "-src";

21+ in

22+ if spec.builtin or true then

23+ builtins_fetchTarball { name = name'; inherit (spec) url sha256; }

24+ else

25+ pkgs.fetchzip { name = name'; inherit (spec) url sha256; };

26+

27+ fetch_git = name: spec:

28+ let

29+ ref =

30+ if spec ? ref then spec.ref else

31+ if spec ? branch then "refs/heads/${spec.branch}" else

32+ if spec ? tag then "refs/tags/${spec.tag}" else

33+ abort "In git source '${name}': Please specify `ref`, `tag` or `branch`!";

34+ in

35+ builtins.fetchGit { url = spec.repo; inherit (spec) rev; inherit ref; };

36+

37+ fetch_local = spec: spec.path;

38+

39+ fetch_builtin-tarball = name: throw

40+ ''[${name}] The niv type "builtin-tarball" is deprecated. You should instead use `builtin = true`.

41+ $ niv modify ${name} -a type=tarball -a builtin=true'';

42+

43+ fetch_builtin-url = name: throw

44+ ''[${name}] The niv type "builtin-url" will soon be deprecated. You should instead use `builtin = true`.

45+ $ niv modify ${name} -a type=file -a builtin=true'';

46+

47+ #

48+ # Various helpers

49+ #

50+

51+ # https://github.com/NixOS/nixpkgs/pull/83241/files#diff-c6f540a4f3bfa4b0e8b6bafd4cd54e8bR695

52+ sanitizeName = name:

53+ (

54+ concatMapStrings (s: if builtins.isList s then "-" else s)

55+ (

56+ builtins.split "[^[:alnum:]+._?=-]+"

57+ ((x: builtins.elemAt (builtins.match "\\.*(.*)" x) 0) name)

58+ )

59+ );

60+

61+ # The set of packages used when specs are fetched using non-builtins.

62+ mkPkgs = sources: system:

63+ let

64+ sourcesNixpkgs =

65+ import (builtins_fetchTarball { inherit (sources.nixpkgs) url sha256; }) { inherit system; };

66+ hasNixpkgsPath = builtins.any (x: x.prefix == "nixpkgs") builtins.nixPath;

67+ hasThisAsNixpkgsPath = <nixpkgs> == ./.;

68+ in

69+ if builtins.hasAttr "nixpkgs" sources

70+ then sourcesNixpkgs

71+ else if hasNixpkgsPath && ! hasThisAsNixpkgsPath then

72+ import <nixpkgs> {}

73+ else

74+ abort

75+ ''

76+ Please specify either <nixpkgs> (through -I or NIX_PATH=nixpkgs=...) or

77+ add a package called "nixpkgs" to your sources.json.

78+ '';

79+

80+ # The actual fetching function.

81+ fetch = pkgs: name: spec:

82+

83+ if ! builtins.hasAttr "type" spec then

84+ abort "ERROR: niv spec ${name} does not have a 'type' attribute"

85+ else if spec.type == "file" then fetch_file pkgs name spec

86+ else if spec.type == "tarball" then fetch_tarball pkgs name spec

87+ else if spec.type == "git" then fetch_git name spec

88+ else if spec.type == "local" then fetch_local spec

89+ else if spec.type == "builtin-tarball" then fetch_builtin-tarball name

90+ else if spec.type == "builtin-url" then fetch_builtin-url name

91+ else

92+ abort "ERROR: niv spec ${name} has unknown type ${builtins.toJSON spec.type}";

93+

94+ # If the environment variable NIV_OVERRIDE_${name} is set, then use

95+ # the path directly as opposed to the fetched source.

96+ replace = name: drv:

97+ let

98+ saneName = stringAsChars (c: if isNull (builtins.match "[a-zA-Z0-9]" c) then "_" else c) name;

99+ ersatz = builtins.getEnv "NIV_OVERRIDE_${saneName}";

100+ in

101+ if ersatz == "" then drv else ersatz;

102+

103+ # Ports of functions for older nix versions

104+

105+ # a Nix version of mapAttrs if the built-in doesn't exist

106+ mapAttrs = builtins.mapAttrs or (

107+ f: set: with builtins;

108+ listToAttrs (map (attr: { name = attr; value = f attr set.${attr}; }) (attrNames set))

109+ );

110+

111+ # https://github.com/NixOS/nixpkgs/blob/0258808f5744ca980b9a1f24fe0b1e6f0fecee9c/lib/lists.nix#L295

112+ range = first: last: if first > last then [] else builtins.genList (n: first + n) (last - first + 1);

113+

114+ # https://github.com/NixOS/nixpkgs/blob/0258808f5744ca980b9a1f24fe0b1e6f0fecee9c/lib/strings.nix#L257

115+ stringToCharacters = s: map (p: builtins.substring p 1 s) (range 0 (builtins.stringLength s - 1));

116+

117+ # https://github.com/NixOS/nixpkgs/blob/0258808f5744ca980b9a1f24fe0b1e6f0fecee9c/lib/strings.nix#L269

118+ stringAsChars = f: s: concatStrings (map f (stringToCharacters s));

119+ concatMapStrings = f: list: concatStrings (map f list);

120+ concatStrings = builtins.concatStringsSep "";

121+

122+ # https://github.com/NixOS/nixpkgs/blob/8a9f58a375c401b96da862d969f66429def1d118/lib/attrsets.nix#L331

123+ optionalAttrs = cond: as: if cond then as else {};

124+

125+ # fetchTarball version that is compatible between all the versions of Nix

126+ builtins_fetchTarball = { url, name ? null, sha256 }@attrs:

127+ let

128+ inherit (builtins) lessThan nixVersion fetchTarball;

129+ in

130+ if lessThan nixVersion "1.12" then

131+ fetchTarball ({ inherit url; } // (optionalAttrs (!isNull name) { inherit name; }))

132+ else

133+ fetchTarball attrs;

134+

135+ # fetchurl version that is compatible between all the versions of Nix

136+ builtins_fetchurl = { url, name ? null, sha256 }@attrs:

137+ let

138+ inherit (builtins) lessThan nixVersion fetchurl;

139+ in

140+ if lessThan nixVersion "1.12" then

141+ fetchurl ({ inherit url; } // (optionalAttrs (!isNull name) { inherit name; }))

142+ else

143+ fetchurl attrs;

144+

145+ # Create the final "sources" from the config

146+ mkSources = config:

147+ mapAttrs (

148+ name: spec:

149+ if builtins.hasAttr "outPath" spec

150+ then abort

151+ "The values in sources.json should not have an 'outPath' attribute"

152+ else

153+ spec // { outPath = replace name (fetch config.pkgs name spec); }

154+ ) config.sources;

155+

156+ # The "config" used by the fetchers

157+ mkConfig =

158+ { sourcesFile ? if builtins.pathExists ./sources.json then ./sources.json else null

159+ , sources ? if isNull sourcesFile then {} else builtins.fromJSON (builtins.readFile sourcesFile)

160+ , system ? builtins.currentSystem

161+ , pkgs ? mkPkgs sources system

162+ }: rec {

163+ # The sources, i.e. the attribute set of spec name to spec

164+ inherit sources;

165+

166+ # The "pkgs" (evaluated nixpkgs) to use for e.g. non-builtin fetchers

167+ inherit pkgs;

168+ };

169+

170+in

171+mkSources (mkConfig {}) // { __functor = _: settings: mkSources (mkConfig settings); }

project-m36.cabal+155−161

@@ -1,6 +1,8 @@

1+Cabal-Version: 2.2

1Name: project-m36

2Name: project-m36

2−Version: 0.6

3+Version: 0.9.3

3−License: PublicDomain

4+License: MIT

5+--note that this license specification is erroneous and only labeled MIT to appease hackage which does not recognize public domain packages in cabal >2.2- Project:M36 is dedicated to the public domain

4Build-Type: Simple

6Build-Type: Simple

5Homepage: https://github.com/agentm/project-m36

7Homepage: https://github.com/agentm/project-m36

6Bug-Reports: https://github.com/agentm/project-m36/issues

8Bug-Reports: https://github.com/agentm/project-m36/issues

@@ -8,7 +10,6 @@ Author: AgentM

8Stability: experimental

10Stability: experimental

9Category: Relational Algebra

11Category: Relational Algebra

10Maintainer: agentm@themactionfaction.com

12Maintainer: agentm@themactionfaction.com

11−Cabal-Version: >= 1.10

12Synopsis: Relational Algebra Engine

13Synopsis: Relational Algebra Engine

13Description: A relational algebra engine which can be used to persist and query Haskell data types.

14Description: A relational algebra engine which can be used to persist and query Haskell data types.

14Extra-Source-Files: Changelog.markdown README.markdown

15Extra-Source-Files: Changelog.markdown README.markdown

@@ -28,8 +29,21 @@ Flag stack

28 Manual: True

29 Manual: True

29 Default: False

30 Default: False

30

31

32+Flag haskell-scripting

33+ Description: enables Haskell scripting which links against GHC as a library

34+ Manual: True

35+ Default: True

36+

31Library

37Library

32− Build-Depends: base>=4.8 && < 4.12, ghc >= 7.8 && < 8.5, ghc-paths, mtl, containers, unordered-containers, hashable, haskeline, directory, MonadRandom, random-shuffle, uuid >= 1.3.12, cassava >= 0.4.5.1 && < 0.6, text, bytestring, deepseq, deepseq-generics, vector, parallel, monad-parallel, exceptions, transformers, gnuplot, binary, filepath, zlib, directory, vector-binary-instances, temporary, stm, time, hashable-time, old-locale, rset, attoparsec, either, base64-bytestring, data-interval, extended-reals, network-transport, aeson >= 1.1, path-pieces, conduit, resourcet, http-api-data, semigroups, QuickCheck, quickcheck-instances, distributed-process-client-server >= 0.2.3, distributed-process >= 0.7.4, distributed-process-extras >= 0.3.2, distributed-process-async >= 0.2.4.1, network-transport-tcp >= 0.6.0, network-transport, list-t, stm-containers >= 0.2.15, foldl, optparse-applicative, Glob, cryptohash-sha256

38+ Build-Depends: base>=4.8 && < 4.15, ghc-paths, mtl, containers, unordered-containers, hashable, haskeline, directory, MonadRandom, random-shuffle, uuid >= 1.3.12, cassava >= 0.4.5.1 && < 0.6, text, bytestring, deepseq, deepseq-generics, vector, parallel, monad-parallel, exceptions, transformers, gnuplot, filepath, zlib, directory, temporary, stm, time, hashable-time, old-locale, rset, attoparsec, either, base64-bytestring, data-interval, extended-reals, aeson >= 1.1, path-pieces, conduit, resourcet, http-api-data, semigroups, QuickCheck, quickcheck-instances, list-t, stm-containers >= 0.2.15, foldl, optparse-applicative, Glob, cryptohash-sha256, text-manipulate >= 0.2.0.1 && < 0.4, winery, curryer-rpc, network, async, vector-instances, recursion-schemes, streamly >= 0.7.2, convertible

39+ if flag(haskell-scripting)

40+ Build-Depends: ghc >= 8.2 && < 8.11

41+ CPP-Options: -DPM36_HASKELL_SCRIPTING

42+ if impl(ghc>= 8) && flag(haskell-scripting)

43+ build-depends:

44+ ghc-boot, ghci

45+ if impl(ghc>= 8.6)

46+ Build-Depends: deferred-folds

33 Exposed-Modules: ProjectM36.Error,

47 Exposed-Modules: ProjectM36.Error,

34 ProjectM36.Transaction,

48 ProjectM36.Transaction,

35 ProjectM36.TransactionGraph,

49 ProjectM36.TransactionGraph,

@@ -38,6 +52,8 @@ Library

38 ProjectM36.TransactionGraph.Merge,

52 ProjectM36.TransactionGraph.Merge,

39 ProjectM36.TransGraphRelationalExpression,

53 ProjectM36.TransGraphRelationalExpression,

40 ProjectM36.Base,

54 ProjectM36.Base,

55+ ProjectM36.Serialise.Base,

56+ ProjectM36.Serialise.Error,

41 ProjectM36.DataFrame,

57 ProjectM36.DataFrame,

42 ProjectM36.Attribute,

58 ProjectM36.Attribute,

43 ProjectM36.AttributeNames,

59 ProjectM36.AttributeNames,

@@ -47,6 +63,7 @@ Library

47 ProjectM36.AtomFunction,

63 ProjectM36.AtomFunction,

48 ProjectM36.AtomFunctionError,

64 ProjectM36.AtomFunctionError,

49 ProjectM36.ScriptSession,

65 ProjectM36.ScriptSession,

66+ ProjectM36.Shortcuts,

50 ProjectM36.DatabaseContextFunction,

67 ProjectM36.DatabaseContextFunction,

51 ProjectM36.DatabaseContextFunctionError,

68 ProjectM36.DatabaseContextFunctionError,

52 ProjectM36.DatabaseContextFunctionUtils,

69 ProjectM36.DatabaseContextFunctionUtils,

@@ -66,6 +83,7 @@ Library

66 ProjectM36.Relation.Parse.CSV,

83 ProjectM36.Relation.Parse.CSV,

67 ProjectM36.IsomorphicSchema,

84 ProjectM36.IsomorphicSchema,

68 ProjectM36.InclusionDependency,

85 ProjectM36.InclusionDependency,

86+ ProjectM36.MerkleHash,

69 ProjectM36.Client,

87 ProjectM36.Client,

70 ProjectM36.Client.Simple,

88 ProjectM36.Client.Simple,

71 ProjectM36.Persist,

89 ProjectM36.Persist,

@@ -75,6 +93,7 @@ Library

75 ProjectM36.AtomFunctions.Primitive,

93 ProjectM36.AtomFunctions.Primitive,

76 ProjectM36.Atomable,

94 ProjectM36.Atomable,

77 ProjectM36.Tupleable,

95 ProjectM36.Tupleable,

96+ ProjectM36.Tupleable.Deriving,

78 ProjectM36.DataConstructorDef,

97 ProjectM36.DataConstructorDef,

79 ProjectM36.DataTypes.Basic,

98 ProjectM36.DataTypes.Basic,

80 ProjectM36.DataTypes.Sorting,

99 ProjectM36.DataTypes.Sorting,

@@ -95,6 +114,10 @@ Library

95 ProjectM36.Server.EntryPoints,

114 ProjectM36.Server.EntryPoints,

96 ProjectM36.Server.ParseArgs,

115 ProjectM36.Server.ParseArgs,

97 ProjectM36.Server.RemoteCallTypes,

116 ProjectM36.Server.RemoteCallTypes,

117+ ProjectM36.Serialise.AtomFunctionError,

118+ ProjectM36.Serialise.DataFrame,

119+ ProjectM36.Serialise.DatabaseContextFunctionError,

120+ ProjectM36.Serialise.IsomorphicSchema,

98 ProjectM36.Session,

121 ProjectM36.Session,

99 ProjectM36.Sessions,

122 ProjectM36.Sessions,

100 ProjectM36.Transaction.Persist,

123 ProjectM36.Transaction.Persist,

@@ -113,22 +136,20 @@ Library

113 Other-Modules: ProjectM36.Win32Handle

136 Other-Modules: ProjectM36.Win32Handle

114 else

137 else

115 --219- too many exported symbols under Windows and GHC 8.4

138 --219- too many exported symbols under Windows and GHC 8.4

116− GHC-Options: -rdynamic

139+ GHC-Options: -rdynamic -fexternal-interpreter

117 C-sources: cbits/DirectoryFsync.c, cbits/darwin_statfs.c

140 C-sources: cbits/DirectoryFsync.c, cbits/darwin_statfs.c

118 Build-Depends: unix

141 Build-Depends: unix

119− CC-Options: -fPIC

142+ CC-Options: -fPIC

120 Hs-Source-Dirs: ./src/lib

143 Hs-Source-Dirs: ./src/lib

121 Default-Language: Haskell2010

144 Default-Language: Haskell2010

122 Default-Extensions: OverloadedStrings, CPP

145 Default-Extensions: OverloadedStrings, CPP

123− if impl(ghc>= 8)

124− build-depends:

125− ghc-boot, ghci

126− if !flag(stack)

146+ if !flag(stack)

127 Build-Depends: deferred-folds

147 Build-Depends: deferred-folds

128

148

129Executable tutd

149Executable tutd

150+ if flag(haskell-scripting)

151+ Build-Depends: ghc >= 8.2 && < 8.11

130 Build-Depends: base >=4.8 && <5.0,

152 Build-Depends: base >=4.8 && <5.0,

131− ghc >= 7.8 && < 8.5,

132 ghc-paths,

153 ghc-paths,

133 project-m36,

154 project-m36,

134 containers,

155 containers,

@@ -142,13 +163,11 @@ Executable tutd

142 MonadRandom, MonadRandom,

163 MonadRandom, MonadRandom,

143 vector,

164 vector,

144 text,

165 text,

145− vector-binary-instances,

146 time,

166 time,

147 hashable-time,

167 hashable-time,

148 bytestring,

168 bytestring,

149 stm,

169 stm,

150 deepseq,

170 deepseq,

151− binary,

152 data-interval,

171 data-interval,

153 parallel,

172 parallel,

154 cassava,

173 cassava,

@@ -156,14 +175,23 @@ Executable tutd

156 directory,

175 directory,

157 filepath,

176 filepath,

158 temporary,

177 temporary,

159− megaparsec >= 5.2.0 && < 7,

178+ megaparsec >= 5.2.0 && < 10,

160 haskeline,

179 haskeline,

161 random, MonadRandom,

180 random, MonadRandom,

162 base64-bytestring,

181 base64-bytestring,

163 optparse-applicative,

182 optparse-applicative,

164 attoparsec,

183 attoparsec,

165 stm-containers >= 1.0.0,

184 stm-containers >= 1.0.0,

166− list-t

185+ list-t,

186+ parser-combinators,

187+ curryer-rpc,

188+ prettyprinter,

189+ cryptohash-sha256,

190+ --due to decode signature change

191+ base16-bytestring >= 1.0.0.0,

192+ http-conduit,

193+ modern-uri,

194+ http-types

167 Other-Modules: TutorialD.Interpreter,

195 Other-Modules: TutorialD.Interpreter,

168 TutorialD.Interpreter.Base,

196 TutorialD.Interpreter.Base,

169 TutorialD.Interpreter.DatabaseContextExpr,

197 TutorialD.Interpreter.DatabaseContextExpr,

@@ -182,6 +210,7 @@ Executable tutd

182 TutorialD.Interpreter.SchemaOperator,

210 TutorialD.Interpreter.SchemaOperator,

183 TutorialD.Interpreter.TransGraphRelationalOperator,

211 TutorialD.Interpreter.TransGraphRelationalOperator,

184 TutorialD.Interpreter.SchemaOperator

212 TutorialD.Interpreter.SchemaOperator

213+ TutorialD.Printer

185 main-is: TutorialD/tutd.hs

214 main-is: TutorialD/tutd.hs

186 CC-Options: -fPIC

215 CC-Options: -fPIC

187 GHC-Options: -Wall -threaded

216 GHC-Options: -Wall -threaded

@@ -190,12 +219,12 @@ Executable tutd

190 Default-Extensions: OverloadedStrings

219 Default-Extensions: OverloadedStrings

191

220

192Executable project-m36-server

221Executable project-m36-server

222+ if flag(haskell-scripting)

223+ Build-Depends: ghc >= 8.2 && < 8.11

193 Build-Depends: base,

224 Build-Depends: base,

194− ghc >= 7.8 && < 8.5,

195 ghc-paths,

225 ghc-paths,

196− project-m36,

197− binary,

198 transformers,

226 transformers,

227+ project-m36,

199 temporary,

228 temporary,

200 data-interval,

229 data-interval,

201 deepseq,

230 deepseq,

@@ -208,7 +237,6 @@ Executable project-m36-server

208 optparse-applicative,

237 optparse-applicative,

209 hashable-time,

238 hashable-time,

210 time,

239 time,

211− vector-binary-instances,

212 text,

240 text,

213 deepseq-generics,

241 deepseq-generics,

214 mtl,

242 mtl,

@@ -221,7 +249,7 @@ Executable project-m36-server

221 list-t,

249 list-t,

222 base64-bytestring

250 base64-bytestring

223 Main-Is: ./src/bin/ProjectM36/Server/project-m36-server.hs

251 Main-Is: ./src/bin/ProjectM36/Server/project-m36-server.hs

224− GHC-Options: -Wall -threaded -rtsopts

252+ GHC-Options: -Wall -threaded -rtsopts

225 if flag(profiler)

253 if flag(profiler)

226 GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall

254 GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall

227 Default-Language: Haskell2010

255 Default-Language: Haskell2010

@@ -230,7 +258,7 @@ Executable project-m36-server

230Executable bigrel

258Executable bigrel

231 Default-Language: Haskell2010

259 Default-Language: Haskell2010

232 Default-Extensions: OverloadedStrings

260 Default-Extensions: OverloadedStrings

233− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, optparse-applicative, stm-containers, list-t, ghc, ghc-paths, transformers, project-m36, random, MonadRandom, semigroups

261+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, optparse-applicative, stm-containers, list-t, ghc, ghc-paths, transformers, project-m36, random, MonadRandom, semigroups, parser-combinators

234 Other-Modules: TutorialD.Interpreter.Base,

262 Other-Modules: TutorialD.Interpreter.Base,

235 TutorialD.Interpreter.DatabaseContextExpr,

263 TutorialD.Interpreter.DatabaseContextExpr,

236 TutorialD.Interpreter.RelationalExpr,

264 TutorialD.Interpreter.RelationalExpr,

@@ -241,6 +269,13 @@ Executable bigrel

241 if flag(profiler)

269 if flag(profiler)

242 GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall

270 GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall

243

271

272+Common commontest

273+ Default-Language: Haskell2010

274+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36, random, MonadRandom, semigroups, parser-combinators, winery, curryer-rpc, prettyprinter, base64-bytestring, modern-uri, http-types, http-conduit, base16-bytestring,cryptohash-sha256

275+ Default-Extensions: OverloadedStrings

276+ GHC-Options: -Wall -threaded

277+ Hs-Source-Dirs: test, src/bin

278+

244Benchmark basic-benchmark

279Benchmark basic-benchmark

245 Default-Language: Haskell2010

280 Default-Language: Haskell2010

246 Default-Extensions: OverloadedStrings

281 Default-Extensions: OverloadedStrings

@@ -252,240 +287,202 @@ Benchmark basic-benchmark

252 if flag(profiler)

287 if flag(profiler)

253 GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall

288 GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall

254

289

290+--benchmark inserts, updates, deletes for a basic use-case to shake out any space leaks

291+Benchmark update-exprs

292+ Default-Language: Haskell2010

293+ Default-Extensions: OverloadedStrings

294+ Build-Depends: base, criterion, project-m36, text, winery

295+ Main-Is: benchmark/Server.hs

296+ Type: exitcode-stdio-1.0

297+ GHC-Options: -Wall -threaded -rtsopts

298+ HS-Source-Dirs: ./src/bin

299+ if flag(profiler)

300+ GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall -fexternal-interpreter

301+

255Test-Suite test-tutoriald

302Test-Suite test-tutoriald

256− Default-Language: Haskell2010

303+ import: commontest

257− Default-Extensions: OverloadedStrings

258 type: exitcode-stdio-1.0

304 type: exitcode-stdio-1.0

259− main-is: test/TutorialD/Interpreter.hs

305+ main-is: TutorialD/InterpreterTest.hs

306+ Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.SchemaOperator, TutorialD.Printer

260− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, stm-containers, list-t, project-m36, random, MonadRandom, semigroups

307+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, stm-containers, list-t, project-m36, random, MonadRandom, semigroups, parser-combinators, prettyprinter

261− Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.SchemaOperator

262− GHC-Options: -Wall -threaded

263− Hs-Source-Dirs: ./src/bin, ., test

264

308

265Test-Suite test-tutoriald-atomfunctionscript

309Test-Suite test-tutoriald-atomfunctionscript

266− Default-Language: Haskell2010

310+ import: commontest

267− Default-Extensions: OverloadedStrings

268 type: exitcode-stdio-1.0

311 type: exitcode-stdio-1.0

269− Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Interpreter.SchemaOperator

312+ Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Interpreter.SchemaOperator, TutorialD.Printer

270− main-is: test/TutorialD/Interpreter/AtomFunctionScript.hs

313+ main-is: TutorialD/Interpreter/AtomFunctionScript.hs

271− Build-Depends: base, HUnit, project-m36, uuid, containers, megaparsec, text, vector, directory, bytestring, mtl, haskeline, random, MonadRandom, semigroups, time

272− GHC-Options: -Wall -threaded

273− Hs-Source-Dirs: ./src/bin, ./test, .

274

314

275Test-Suite test-tutoriald-databasecontextfunctionscript

315Test-Suite test-tutoriald-databasecontextfunctionscript

276− Default-Language: Haskell2010

316+ import: commontest

277− Default-Extensions: OverloadedStrings

278 type: exitcode-stdio-1.0

317 type: exitcode-stdio-1.0

279− Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Interpreter.SchemaOperator

318+ Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Interpreter.SchemaOperator, TutorialD.Printer

280− main-is: test/TutorialD/Interpreter/DatabaseContextFunctionScript.hs

319+ main-is: TutorialD/Interpreter/DatabaseContextFunctionScript.hs

281− Build-Depends: base, HUnit, project-m36, uuid, containers, megaparsec, text, vector, directory, bytestring, mtl, haskeline, random, MonadRandom, semigroups, time

282− GHC-Options: -Wall -threaded

283− Hs-Source-Dirs: ./src/bin, ./test, .

284

320

285Test-Suite test-relation

321Test-Suite test-relation

286− Default-Language: Haskell2010

322+ import: commontest

287− Default-Extensions: OverloadedStrings

288 type: exitcode-stdio-1.0

323 type: exitcode-stdio-1.0

289− main-is: test/Relation/Basic.hs

324+ main-is: Relation/Basic.hs

290− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, stm-containers, project-m36, transformers

291− GHC-Options: -Wall -threaded

292

325

293Test-Suite test-static-optimizer

326Test-Suite test-static-optimizer

294− Default-Language: Haskell2010

327+ import: commontest

295− Default-Extensions: OverloadedStrings

296 type: exitcode-stdio-1.0

328 type: exitcode-stdio-1.0

297− main-is: test/Relation/StaticOptimizer.hs

329+ main-is: Relation/StaticOptimizer.hs

298− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, stm-containers, project-m36, transformers

299− GHC-Options: -Wall -threaded

300

330

301Test-Suite test-transactiongraph-persist

331Test-Suite test-transactiongraph-persist

302− Default-Language: Haskell2010

332+ import: commontest

303− Default-Extensions: OverloadedStrings

304 type: exitcode-stdio-1.0

333 type: exitcode-stdio-1.0

305− main-is: test/TransactionGraph/Persist.hs

334+ main-is: TransactionGraph/Persist.hs

306− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, stm-containers, project-m36, random, MonadRandom, semigroups

307− Other-Modules: TutorialD.Interpreter.Base, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.Types, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.Import.BasicExamples

335+ Other-Modules: TutorialD.Interpreter.Base, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.Types, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Printer

308− Hs-Source-Dirs: ., ./src/bin

309− GHC-Options: -Wall -threaded

310

336

311Test-Suite test-relation-import-csv

337Test-Suite test-relation-import-csv

312− Default-Language: Haskell2010

338+ import: commontest

313− Default-Extensions: OverloadedStrings

314 type: exitcode-stdio-1.0

339 type: exitcode-stdio-1.0

315− main-is: test/Relation/Import/CSV.hs

340+ main-is: Relation/Import/CSV.hs

316− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, stm-containers, project-m36

317− GHC-Options: -Wall -threaded

318

341

319Test-Suite test-tutoriald-import-tutoriald

342Test-Suite test-tutoriald-import-tutoriald

320− Default-Language: Haskell2010

343+ import: commontest

321− Default-Extensions: OverloadedStrings

322 type: exitcode-stdio-1.0

344 type: exitcode-stdio-1.0

323− main-is: test/TutorialD/Interpreter/Import/TutorialD.hs

345+ main-is: TutorialD/Interpreter/Import/ImportTest.hs

324− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, stm-containers, project-m36, random, MonadRandom, semigroups

325− Other-Modules: TutorialD.Interpreter.Base, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.Types, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.Import.BasicExamples

346+ Other-Modules: TutorialD.Interpreter.Base, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.Types, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Printer

326− GHC-Options: -Wall -threaded

327− Hs-Source-Dirs: ., ./src/bin

328

347

329Test-Suite test-relation-export-csv

348Test-Suite test-relation-export-csv

330− Default-Language: Haskell2010

349+ import: commontest

331− Default-Extensions: OverloadedStrings

332 type: exitcode-stdio-1.0

350 type: exitcode-stdio-1.0

333− main-is: test/Relation/Export/CSV.hs

351+ main-is: Relation/Export/CSV.hs

334− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, stm-containers, project-m36

335− GHC-Options: -Wall -threaded

336

352

337Test-Suite test-transactiongraph-merge

353Test-Suite test-transactiongraph-merge

338− Default-Language: Haskell2010

354+ import: commontest

339− Default-Extensions: OverloadedStrings

340 type: exitcode-stdio-1.0

355 type: exitcode-stdio-1.0

341− main-is: test/TransactionGraph/Merge.hs

356+ main-is: TransactionGraph/Merge.hs

342− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, template-haskell, transformers, aeson, conduit, either, path-pieces, http-api-data, stm-containers, list-t, project-m36

357+

343− GHC-Options: -Wall -threaded

358+

359+Test-Suite test-prettyprinter

360+ import: commontest

361+ type: exitcode-stdio-1.0

362+ main-is: TutorialD/PrinterTest.hs

363+ Other-Modules: TutorialD.Printer, TutorialD.Interpreter.Base, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.Types

344

364

345benchmark bench

365benchmark bench

346− Default-Language: Haskell2010

366+ import: commontest

347− Default-Extensions: OverloadedStrings

348 type: exitcode-stdio-1.0

367 type: exitcode-stdio-1.0

349 main-is: benchmark/Relation.hs

368 main-is: benchmark/Relation.hs

350− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, criterion, stm-containers, project-m36

351− GHC-Options: -Wall -rtsopts -threaded

352− Hs-Source-Dirs: ./src/bin

353

369

354Test-Suite test-server

370Test-Suite test-server

355− Default-Language: Haskell2010

371+ import: commontest

356− Default-Extensions: OverloadedStrings

357 type: exitcode-stdio-1.0

372 type: exitcode-stdio-1.0

358− main-is: test/Server/Main.hs

373+ main-is: Server/Main.hs

359− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, network-transport-tcp, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, project-m36, network-transport, semigroups

374+

360− HS-Source-Dirs: ., ./src/bin

361− GHC-Options: -Wall -threaded

362

375

363Executable Example-SimpleClient

376Executable Example-SimpleClient

364 Default-Language: Haskell2010

377 Default-Language: Haskell2010

365 Default-Extensions: OverloadedStrings

378 Default-Extensions: OverloadedStrings

366− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, ghc, ghc-paths, project-m36, random, MonadRandom

379+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, ghc, ghc-paths, project-m36, random, MonadRandom

367 Main-Is: examples/SimpleClient.hs

380 Main-Is: examples/SimpleClient.hs

368 GHC-Options: -Wall -threaded

381 GHC-Options: -Wall -threaded

369

382

370Executable Example-OutOfTheTarpit

383Executable Example-OutOfTheTarpit

371 Default-Language: Haskell2010

384 Default-Language: Haskell2010

372 Default-Extensions: OverloadedStrings

385 Default-Extensions: OverloadedStrings

373− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, aeson, path-pieces, either, conduit, http-api-data, template-haskell, ghc, ghc-paths, project-m36

386+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, aeson, path-pieces, either, conduit, http-api-data, template-haskell, ghc, ghc-paths, project-m36, winery

374 Main-Is: examples/out_of_the_tarpit.hs

387 Main-Is: examples/out_of_the_tarpit.hs

375 GHC-Options: -Wall -threaded

388 GHC-Options: -Wall -threaded

376

389

377Executable Example-Blog

390Executable Example-Blog

378 Default-Language: Haskell2010

391 Default-Language: Haskell2010

379 Default-Extensions: OverloadedStrings

392 Default-Extensions: OverloadedStrings

380− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, aeson, path-pieces, either, conduit, http-api-data, template-haskell, ghc, ghc-paths, project-m36, scotty, blaze-html, http-types

393+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, aeson, path-pieces, either, conduit, http-api-data, template-haskell, ghc, ghc-paths, project-m36, scotty, blaze-html, http-types, winery

381 Main-Is: examples/blog.hs

394 Main-Is: examples/blog.hs

382 GHC-Options: -Wall -threaded

395 GHC-Options: -Wall -threaded

383

396

384−

385Executable Example-Hair

397Executable Example-Hair

386 Default-Language: Haskell2010

398 Default-Language: Haskell2010

387 Default-Extensions: OverloadedStrings

399 Default-Extensions: OverloadedStrings

388− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, aeson, path-pieces, either, conduit, http-api-data, template-haskell, ghc, ghc-paths, project-m36

400+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, aeson, path-pieces, either, conduit, http-api-data, template-haskell, ghc, ghc-paths, project-m36, winery

389 Main-Is: examples/hair.hs

401 Main-Is: examples/hair.hs

390 GHC-Options: -Wall -threaded

402 GHC-Options: -Wall -threaded

391

403

404+Executable Example-Plantfarm

405+ Default-Language: Haskell2010

406+ Default-Extensions: OverloadedStrings

407+ Build-Depends: aeson, barbies, base, binary, containers, deepseq, hashable, project-m36, random, scotty, text, winery

408+ Main-Is: examples/Plantfarm.hs

409+ GHC-Options: -Wall -threaded

410+

392Executable Example-CustomTupleable

411Executable Example-CustomTupleable

393 Default-Language: Haskell2010

412 Default-Language: Haskell2010

394 Default-Extensions: OverloadedStrings

413 Default-Extensions: OverloadedStrings

395− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, aeson, path-pieces, either, conduit, http-api-data, template-haskell, ghc, ghc-paths, project-m36

414+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, aeson, path-pieces, either, conduit, http-api-data, template-haskell, ghc, ghc-paths, project-m36, winery

396 Main-Is: examples/CustomTupleable.hs

415 Main-Is: examples/CustomTupleable.hs

397 GHC-Options: -Wall -threaded

416 GHC-Options: -Wall -threaded

398

417

399−Test-Suite test-scripts

418+Executable Example-DerivingCustomTupleable

419+ if impl(ghc>=8.6)

420+ Buildable: True

421+ else

422+ Buildable: False

400 Default-Language: Haskell2010

423 Default-Language: Haskell2010

401− Default-Extensions: OverloadedStrings

424+ Build-Depends: base, text, deepseq, project-m36, winery

402− type: exitcode-stdio-1.0

425+ Main-Is: examples/DerivingCustomTupleable.hs

403− main-is: test/scripts.hs

404− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, network-transport-tcp, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, project-m36, random, MonadRandom, semigroups

405− Other-Modules: TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.Types, TutorialD.Interpreter.Import.BasicExamples

406 GHC-Options: -Wall -threaded

426 GHC-Options: -Wall -threaded

407− Hs-Source-Dirs: ., ./src/bin

427+

428+Test-Suite test-scripts

429+ import: commontest

430+ type: exitcode-stdio-1.0

431+ main-is: scripts.hs

432+ Other-Modules: TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.Types, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Printer

408

433

409Executable project-m36-websocket-server

434Executable project-m36-websocket-server

410 Default-Language: Haskell2010

435 Default-Language: Haskell2010

411− Build-Depends: base, aeson, path-pieces, either, conduit, http-api-data, template-haskell, websockets, aeson, optparse-applicative, project-m36, containers, bytestring, text, vector, uuid, megaparsec, haskeline, mtl, directory, base64-bytestring, random, MonadRandom, time, network-transport-tcp, semigroups, attoparsec

436+ Build-Depends: base, aeson, path-pieces, either, conduit, http-api-data, template-haskell, websockets, aeson, optparse-applicative, project-m36, containers, bytestring, text, vector, uuid, megaparsec, haskeline, mtl, directory, base64-bytestring, random, MonadRandom, time, semigroups, attoparsec, parser-combinators, prettyprinter, network, modern-uri, http-conduit, base16-bytestring, http-types, cryptohash-sha256, wai, wai-websockets, warp, warp-tls

412 Main-Is: ProjectM36/Server/WebSocket/websocket-server.hs

437 Main-Is: ProjectM36/Server/WebSocket/websocket-server.hs

413− Other-Modules: ProjectM36.Client.Json, ProjectM36.Server.RemoteCallTypes.Json, ProjectM36.Server.WebSocket, TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.SchemaOperator

438+ Other-Modules: ProjectM36.Client.Json, ProjectM36.Server.RemoteCallTypes.Json, ProjectM36.Server.WebSocket, TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.SchemaOperator, TutorialD.Printer

414 GHC-Options: -Wall -threaded

439 GHC-Options: -Wall -threaded

415 Hs-Source-Dirs: ./src/bin

440 Hs-Source-Dirs: ./src/bin

416 Default-Extensions: OverloadedStrings

441 Default-Extensions: OverloadedStrings

417

442

418Test-Suite test-websocket-server

443Test-Suite test-websocket-server

419− Default-Language: Haskell2010

444+ import: commontest

420 type: exitcode-stdio-1.0

445 type: exitcode-stdio-1.0

421− main-is: test/Server/WebSocket.hs

446+ main-is: Server/WebSocket.hs

422− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36, random, MonadRandom, network-transport-tcp, semigroups

423− Other-Modules: TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.TransactionGraphOperator, ProjectM36.Client.Json, ProjectM36.Server.RemoteCallTypes.Json, ProjectM36.Server.WebSocket, TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.Types, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.SchemaOperator

447+ Other-Modules: TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.TransactionGraphOperator, ProjectM36.Client.Json, ProjectM36.Server.RemoteCallTypes.Json, ProjectM36.Server.WebSocket, TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.Types, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.SchemaOperator, TutorialD.Printer

424− Default-Extensions: OverloadedStrings

425− GHC-Options: -Wall -threaded

426− Hs-Source-Dirs: ./src/bin, .

427

448

428Test-Suite test-isomorphic-schemas

449Test-Suite test-isomorphic-schemas

429− Default-Language: Haskell2010

450+ import: commontest

430 type: exitcode-stdio-1.0

451 type: exitcode-stdio-1.0

431− main-is: test/IsomorphicSchema.hs

452+ main-is: IsomorphicSchema.hs

432− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36

433− Default-Extensions: OverloadedStrings

434− GHC-Options: -Wall -threaded

435− Hs-Source-Dirs: ./src/bin, .

436

453

437Test-Suite test-atomable

454Test-Suite test-atomable

438− Default-Language: Haskell2010

455+ import: commontest

439 type: exitcode-stdio-1.0

456 type: exitcode-stdio-1.0

440− main-is: test/Relation/Atomable.hs

457+ main-is: Relation/Atomable.hs

441− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36, random, MonadRandom, semigroups

442− Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.SchemaOperator, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types

458+ Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.SchemaOperator, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Printer

443− Default-Extensions: OverloadedStrings

444− GHC-Options: -Wall -threaded

445− Hs-Source-Dirs: ./src/bin, ., test/

446

459

447Test-Suite test-multiprocess-access

460Test-Suite test-multiprocess-access

448− Default-Language: Haskell2010

461+ import: commontest

449 type: exitcode-stdio-1.0

462 type: exitcode-stdio-1.0

450− main-is: test/MultiProcessDatabaseAccess.hs

463+ main-is: MultiProcessDatabaseAccess.hs

451− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36, random, MonadRandom

452− Default-Extensions: OverloadedStrings

453− GHC-Options: -Wall -threaded

454− Hs-Source-Dirs: ./src/bin, ., test/

455

464

456Test-Suite test-transactiongraph-automerge

465Test-Suite test-transactiongraph-automerge

457− Default-Language: Haskell2010

466+ import: commontest

458 type: exitcode-stdio-1.0

467 type: exitcode-stdio-1.0

459− main-is: test/TransactionGraph/Automerge.hs

468+ main-is: TransactionGraph/Automerge.hs

460− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36, random, MonadRandom, semigroups

461− Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.SchemaOperator, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types

469+ Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.SchemaOperator, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Printer

462− Default-Extensions: OverloadedStrings

463− GHC-Options: -Wall -threaded

464− Hs-Source-Dirs: ./src/bin, ., test/

465

470

466Test-Suite test-tupleable

471Test-Suite test-tupleable

467− Default-Language: Haskell2010

472+ import: commontest

468 type: exitcode-stdio-1.0

473 type: exitcode-stdio-1.0

469− main-is: test/Relation/Tupleable.hs

474+ main-is: Relation/Tupleable.hs

470− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36, random, MonadRandom, semigroups

471− Default-Extensions: OverloadedStrings

472− GHC-Options: -Wall -threaded

473− Hs-Source-Dirs: ./src/bin, ., test/

474

475

475Test-Suite test-client-simple

476Test-Suite test-client-simple

476− Default-Language: Haskell2010

477+ import: commontest

477− Main-Is: test/Client/Simple.hs

478+ Main-Is: Client/Simple.hs

478 type: exitcode-stdio-1.0

479 type: exitcode-stdio-1.0

479− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36, random, MonadRandom, semigroups

480− Default-Extensions: OverloadedStrings

481− GHC-Options: -Wall -threaded

482− Hs-Source-Dirs: ./src/bin, ., test/

483

480

484-- test for file handle leaks

481-- test for file handle leaks

485Executable handles

482Executable handles

486 Default-Language: Haskell2010

483 Default-Language: Haskell2010

487 Default-Extensions: OverloadedStrings

484 Default-Extensions: OverloadedStrings

488− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, optparse-applicative, stm-containers, list-t, ghc, ghc-paths, transformers, project-m36, random, MonadRandom, semigroups

485+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, optparse-applicative, stm-containers, list-t, ghc, ghc-paths, transformers, project-m36, random, MonadRandom, semigroups, parser-combinators, prettyprinter, modern-uri, http-types, http-conduit, base16-bytestring, cryptohash-sha256

489 main-is: benchmark/Handles.hs

486 main-is: benchmark/Handles.hs

490 Other-Modules: TutorialD.Interpreter,

487 Other-Modules: TutorialD.Interpreter,

491 TutorialD.Interpreter.Base,

488 TutorialD.Interpreter.Base,

@@ -504,17 +501,14 @@ Executable handles

504 TutorialD.Interpreter.TransGraphRelationalOperator,

501 TutorialD.Interpreter.TransGraphRelationalOperator,

505 TutorialD.Interpreter.TransactionGraphOperator,

502 TutorialD.Interpreter.TransactionGraphOperator,

506 TutorialD.Interpreter.Types

503 TutorialD.Interpreter.Types

504+ TutorialD.Printer

507 GHC-Options: -Wall -threaded -rtsopts

505 GHC-Options: -Wall -threaded -rtsopts

508 HS-Source-Dirs: ./src/bin

506 HS-Source-Dirs: ./src/bin

509 if flag(profiler)

507 if flag(profiler)

510 GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall

508 GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall

511−

509+

512Test-Suite test-dataframe

510Test-Suite test-dataframe

513− Default-Language: Haskell2010

511+ import: commontest

514− Main-Is: test/DataFrame.hs

515 type: exitcode-stdio-1.0

512 type: exitcode-stdio-1.0

513+ Main-Is: DataFrame.hs

516− Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.SchemaOperator, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types

514+ Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.SchemaOperator, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Printer

517− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36, random, MonadRandom, semigroups

518− Default-Extensions: OverloadedStrings

519− GHC-Options: -Wall -threaded

520− Hs-Source-Dirs: ./src/bin, ., test/

release.nixnew file+36

@@ -0,0 +1,36 @@

1+{ compiler ? "ghc8104"

2+, sources ? import ./nix/sources.nix

3+, pkgs ? import sources.nixpkgs { }

4+}:

5+let

6+ doJailbreak = pkgs.haskell.lib.doJailbreak;

7+ needsCocoa = drv:

8+ if pkgs.stdenv.isDarwin

9+ then drv.overrideDerivation (old:

10+ { buildInputs = [ pkgs.darwin.apple_sdk.frameworks.Cocoa ] ++ old.buildInputs; }

11+ )

12+ else drv;

13+

14+ haskellPackages = pkgs.haskell.packages.${compiler}.override {

15+ overrides = self: super: {

16+ curryer-rpc = self.callCabal2nix "curryer-rpc" sources.curryer { };

17+ streamly = doJailbreak (needsCocoa (self.callCabal2nix "streamly" sources.streamly { }));

18+ project-m36 = ((self.callCabal2nixWithOptions "project-m36" ./. "-f-haskell-scripting" { }));

19+ };

20+ };

21+in

22+{

23+ project = haskellPackages.project-m36;

24+

25+ shell = haskellPackages.shellFor {

26+ packages = p: [

27+ p.project-m36

28+ ];

29+ buildInputs = [

30+ haskellPackages.ghcid

31+ haskellPackages.hlint

32+ pkgs.docker

33+ ];

34+ withHoogle = true;

35+ };

36+}

scripts/DateExamples.tutd+2−2

@@ -20,7 +20,7 @@ sp := relation{tuple{s# "S1",p# "P1",qty 300},

20 tuple{s# "S3",p# "P2",qty 200},

21 tuple{s# "S4",p# "P4",qty 300},

22 tuple{s# "S4",p# "P5",qty 400}};

23−key s_pkey {s#} s

23+key s_pkey {s#} s;

24−key p_key {p#} p

24+key p_key {p#} p;

25foreign key s_sp_fk sp{s#} in s{s#};

26foreign key p_sp_fk sp{p#} in p{p#};

scripts/multiline.tutdnew file+2

@@ -0,0 +1,2 @@

1+x:=relation{

2+tuple{ x 2}} -- nice

shell.nixnew file+1

@@ -0,0 +1 @@

1+(import ./release.nix { }).shell

src/bin/ProjectM36/Client/Json.hs+4−1

@@ -3,6 +3,7 @@ module ProjectM36.Client.Json where

3import Data.Aeson

4import ProjectM36.Server.RemoteCallTypes.Json ()

5import ProjectM36.Client

6+import ProjectM36.TransactionGraph

6import Control.Exception (IOException)

7import Control.Exception (IOException)

7

8

8instance ToJSON EvaluatedNotification

9instance ToJSON EvaluatedNotification

@@ -11,4 +12,6 @@ instance FromJSON EvaluatedNotification

11instance ToJSON ConnectionError

12instance ToJSON ConnectionError

12

13

13instance ToJSON IOException where

14instance ToJSON IOException where

14− toJSON err = object ["IOException" .= show err]

15+ toJSON err = object ["IOException" .= show err]

16+

17+instance ToJSON MerkleValidationError

src/bin/ProjectM36/Server/RemoteCallTypes/Json.hs+36−2

@@ -10,6 +10,8 @@ import ProjectM36.DataTypes.Primitive

10import ProjectM36.Error

11import ProjectM36.IsomorphicSchema

12import ProjectM36.Server.RemoteCallTypes

13+import ProjectM36.MerkleHash

14+import ProjectM36.Attribute as A

13

15

14import Data.Aeson

16import Data.Aeson

15import Data.ByteString.Base64 as B64

17import Data.ByteString.Base64 as B64

@@ -22,6 +24,9 @@ instance FromJSON RelationalExpr

22instance ToJSON TupleExpr

24instance ToJSON TupleExpr

23instance FromJSON TupleExpr

25instance FromJSON TupleExpr

24

26

27+instance ToJSON TupleExprs

28+instance FromJSON TupleExprs

29+

25instance ToJSON RestrictionPredicateExpr

30instance ToJSON RestrictionPredicateExpr

26instance FromJSON RestrictionPredicateExpr

31instance FromJSON RestrictionPredicateExpr

27

32

@@ -40,8 +45,11 @@ instance FromJSON ExecuteRelationalExpr

40instance ToJSON Relation

45instance ToJSON Relation

41instance FromJSON Relation

46instance FromJSON Relation

42

47

43−instance ToJSON Attribute

48+instance ToJSON Attribute where

49+ toJSON (Attribute attrName aType) = object [ "name" .= attrName

50+ , "type" .= toJSON aType ]

44−instance FromJSON Attribute

51+instance FromJSON Attribute where

52+ parseJSON = withObject "Attribute" $ \v -> Attribute <$> v .: "name" <*> v .: "type"

45

53

46instance ToJSON ExtendTupleExpr

54instance ToJSON ExtendTupleExpr

47instance FromJSON ExtendTupleExpr

55instance FromJSON ExtendTupleExpr

@@ -95,6 +103,8 @@ instance ToJSON Atom where

95 "val" .= i ]

103 "val" .= i ]

96 toJSON atom@(RelationAtom i) = object [ "type" .= atomTypeForAtom atom,

104 toJSON atom@(RelationAtom i) = object [ "type" .= atomTypeForAtom atom,

97 "val" .= i ]

105 "val" .= i ]

106+ toJSON atom@(RelationalExprAtom i) = object [ "type" .= atomTypeForAtom atom,

107+ "val" .= i ]

98 toJSON (ConstructedAtom dConsName atomtype atomlist) = object [

108 toJSON (ConstructedAtom dConsName atomtype atomlist) = object [

99 "dataconstructorname" .= dConsName,

109 "dataconstructorname" .= dConsName,

100 "type" .= toJSON atomtype,

110 "type" .= toJSON atomtype,

@@ -122,6 +132,7 @@ instance FromJSON Atom where

122 Left err -> fail ("Failed to parse base64-encoded ByteString: " ++ err)

132 Left err -> fail ("Failed to parse base64-encoded ByteString: " ++ err)

123 Right bs -> pure (ByteStringAtom bs)

133 Right bs -> pure (ByteStringAtom bs)

124 BoolAtomType -> BoolAtom <$> o .: "val"

134 BoolAtomType -> BoolAtom <$> o .: "val"

135+ RelationalExprAtomType -> RelationalExprAtom <$> o .: "val"

125

136

126instance ToJSON Notification

137instance ToJSON Notification

127instance FromJSON Notification

138instance FromJSON Notification

@@ -129,6 +140,21 @@ instance FromJSON Notification

129instance ToJSON ScriptCompilationError

140instance ToJSON ScriptCompilationError

130instance FromJSON ScriptCompilationError

141instance FromJSON ScriptCompilationError

131

142

143+instance ToJSON MerkleHash where

144+ toJSON h = object [ "merklehash" .= decodeUtf8 (B64.encode (_unMerkleHash h))]

145+instance FromJSON MerkleHash where

146+ parseJSON = withObject "merklehash" $ \o -> do

147+ b64bs <- encodeUtf8 <$> o .: "merklehash"

148+ case B64.decode b64bs of

149+ Left err -> fail ("Failed to parse merkle hash: " ++ err)

150+ Right bs -> pure (MerkleHash bs)

151+

152+instance ToJSON Attributes where

153+ toJSON attrs = object ["attributes" .= map toJSON (A.toList attrs)]

154+instance FromJSON Attributes where

155+ parseJSON = withObject "Attributes" $ \o ->

156+ A.attributesFromList <$> o .: "attributes"

157+

132instance ToJSON RelationalError

158instance ToJSON RelationalError

133instance FromJSON RelationalError

159instance FromJSON RelationalError

134

160

@@ -138,6 +164,9 @@ instance FromJSON SchemaError

138instance ToJSON MergeError

164instance ToJSON MergeError

139instance FromJSON MergeError

165instance FromJSON MergeError

140

166

167+instance ToJSON ImportError'

168+instance FromJSON ImportError'

169+

141instance ToJSON DatabaseContextFunctionError

170instance ToJSON DatabaseContextFunctionError

142instance FromJSON DatabaseContextFunctionError

171instance FromJSON DatabaseContextFunctionError

143

172

@@ -149,3 +178,8 @@ instance FromJSON PersistenceError

149

178

150instance ToJSON AtomFunctionError

179instance ToJSON AtomFunctionError

151instance FromJSON AtomFunctionError

180instance FromJSON AtomFunctionError

181+

182+instance ToJSON WithNameExpr

183+instance FromJSON WithNameExpr

184+

185+

src/bin/ProjectM36/Server/WebSocket.hs+33−21

@@ -1,4 +1,4 @@

1−{-# LANGUAGE LambdaCase #-}

1+{-# LANGUAGE LambdaCase, CPP #-}

2module ProjectM36.Server.WebSocket where

3-- while the tutd client performs TutorialD parsing on the client, the websocket server will pass tutd to be parsed and executed on the server- otherwise I have to pull in ghcjs as a dependency to allow client-side parsing- that's not appealing because then the frontend is not language-agnostic, but this could change in the future, perhaps by sending different messages over the websocket

4-- ideally, the wire protocol should not be exposed to a straight string-based API ala SQL, so we could make perhaps a javascript DSL which compiles to the necessary JSON- anaylyze tradeoffs

@@ -22,9 +22,14 @@ import Data.Attoparsec.Text

22import Control.Applicative

23import Text.Megaparsec.Error

24import Data.Functor

25+import Data.Either (fromRight)

26+

27+#if MIN_VERSION_megaparsec(7,0,0)

28+import Data.List.NonEmpty as NE

29+#endif

25

30

26websocketProxyServer :: Port -> Hostname -> WS.ServerApp

31websocketProxyServer :: Port -> Hostname -> WS.ServerApp

27−websocketProxyServer port host pending = do

32+websocketProxyServer port host pending = do

28 conn <- WS.acceptRequest pending

33 conn <- WS.acceptRequest pending

29 let unexpectedMsg = WS.sendTextData conn ("messagenotexpected" :: T.Text)

34 let unexpectedMsg = WS.sendTextData conn ("messagenotexpected" :: T.Text)

30 --phase 1- accept database name for connection

35 --phase 1- accept database name for connection

@@ -33,10 +38,10 @@ websocketProxyServer port host pending = do

33 if not (connectdbmsg `T.isPrefixOf` dbmsg) then unexpectedMsg >> WS.sendClose conn ("" :: T.Text)

38 if not (connectdbmsg `T.isPrefixOf` dbmsg) then unexpectedMsg >> WS.sendClose conn ("" :: T.Text)

34 else do

39 else do

35 let dbname = T.unpack $ T.drop (T.length connectdbmsg) dbmsg

40 let dbname = T.unpack $ T.drop (T.length connectdbmsg) dbmsg

36− bracket (createConnection conn dbname port host)

41+ bracket (createConnection conn dbname port host)

37 (\case

42 (\case

38 Right dbconn -> close dbconn

43 Right dbconn -> close dbconn

39− Left _ -> pure ()) $ \case

44+ Left _ -> pure ()) $ \case

40 Left err -> sendError conn err

45 Left err -> sendError conn err

41 Right dbconn -> do

46 Right dbconn -> do

42 eSessionId <- createSessionAtHead dbconn "master"

47 eSessionId <- createSessionAtHead dbconn "master"

@@ -47,34 +52,41 @@ websocketProxyServer port host pending = do

47 _ <- forever $ do

52 _ <- forever $ do

48 pInfo <- promptInfo sessionId dbconn

53 pInfo <- promptInfo sessionId dbconn

49 --figure out why sending three times during startup is necessary

54 --figure out why sending three times during startup is necessary

50− sendPromptInfo pInfo conn

55+ sendPromptInfo pInfo conn

51 sendPromptInfo pInfo conn

56 sendPromptInfo pInfo conn

52 msg <- WS.receiveData conn :: IO T.Text

57 msg <- WS.receiveData conn :: IO T.Text

53 case parseOnly parseExecuteMessage msg of

58 case parseOnly parseExecuteMessage msg of

54 Left _ -> unexpectedMsg

59 Left _ -> unexpectedMsg

55 Right (presentation, tutdString) ->

60 Right (presentation, tutdString) ->

56 case parseTutorialD tutdString of

61 case parseTutorialD tutdString of

62+ Left err -> handleOpResult conn dbconn presentation

63+#if MIN_VERSION_megaparsec(7,0,0)

64+ (DisplayErrorResult

65+ ("parse error: " `T.append` T.pack

66+ (parseErrorPretty . NE.head . bundleErrors $ err)))

67+#else

57− Left err -> handleOpResult conn dbconn presentation (DisplayErrorResult ("parse error: " `T.append` T.pack (parseErrorPretty err)))

68+ (DisplayErrorResult ("parse error: " `T.append` T.pack (parseErrorPretty err)))

69+#endif

58 Right parsed -> do

70 Right parsed -> do

59− let timeoutFilter exc = if exc == RequestTimeoutException

71+ let timeoutFilter exc = if exc == RequestTimeoutException

60− then Just exc

72+ then Just exc

61 else Nothing

73 else Nothing

62 responseHandler = do

74 responseHandler = do

63 result <- evalTutorialD sessionId dbconn SafeEvaluation parsed

75 result <- evalTutorialD sessionId dbconn SafeEvaluation parsed

64 pInfo' <- promptInfo sessionId dbconn

76 pInfo' <- promptInfo sessionId dbconn

65− sendPromptInfo pInfo' conn

77+ sendPromptInfo pInfo' conn

66 handleOpResult conn dbconn presentation result

78 handleOpResult conn dbconn presentation result

67 catchJust timeoutFilter responseHandler (\_ -> handleOpResult conn dbconn presentation (DisplayErrorResult "Request Timed Out."))

79 catchJust timeoutFilter responseHandler (\_ -> handleOpResult conn dbconn presentation (DisplayErrorResult "Request Timed Out."))

68 pure ()

80 pure ()

69−

81+

70−notificationCallback :: WS.Connection -> NotificationCallback

82+notificationCallback :: WS.Connection -> NotificationCallback

71notificationCallback conn notifName evaldNotif = WS.sendTextData conn (encode (object ["notificationname" .= notifName,

83notificationCallback conn notifName evaldNotif = WS.sendTextData conn (encode (object ["notificationname" .= notifName,

72 "evaldnotification" .= evaldNotif

84 "evaldnotification" .= evaldNotif

73 ]))

85 ]))

74−

86+

75--this creates a new database for each connection- perhaps not what we want (?)

87--this creates a new database for each connection- perhaps not what we want (?)

76createConnection :: WS.Connection -> DatabaseName -> Port -> Hostname -> IO (Either ConnectionError Connection)

88createConnection :: WS.Connection -> DatabaseName -> Port -> Hostname -> IO (Either ConnectionError Connection)

77−createConnection wsconn dbname port host = connectProjectM36 (RemoteProcessConnectionInfo dbname (createNodeId host port) (notificationCallback wsconn))

89+createConnection wsconn dbname port host = connectProjectM36 (RemoteConnectionInfo dbname host (show port) (notificationCallback wsconn))

78

90

79sendError :: (ToJSON a) => WS.Connection -> a -> IO ()

91sendError :: (ToJSON a) => WS.Connection -> a -> IO ()

80sendError conn err = WS.sendTextData conn (encode (object ["displayerror" .= err]))

92sendError conn err = WS.sendTextData conn (encode (object ["displayerror" .= err]))

@@ -100,32 +112,32 @@ handleOpResult conn _ presentation (DisplayDataFrameResult df) = do

100 texto = ["text" .= showDataFrame df | textPresentation presentation]

112 texto = ["text" .= showDataFrame df | textPresentation presentation]

101 htmlo = ["html" .= dataFrameAsHTML df | htmlPresentation presentation]

113 htmlo = ["html" .= dataFrameAsHTML df | htmlPresentation presentation]

102 WS.sendTextData conn (encode (object ["displaydataframe" .= object (jsono ++ texto ++ htmlo)]))

114 WS.sendTextData conn (encode (object ["displaydataframe" .= object (jsono ++ texto ++ htmlo)]))

103−

115+

104-- get current schema and head name for client

116-- get current schema and head name for client

105promptInfo :: SessionId -> Connection -> IO (HeadName, SchemaName)

117promptInfo :: SessionId -> Connection -> IO (HeadName, SchemaName)

106promptInfo sessionId conn = do

118promptInfo sessionId conn = do

107− eHeadName <- headName sessionId conn

119+ eHeadName <- headName sessionId conn

108 eSchemaName <- currentSchemaName sessionId conn

120 eSchemaName <- currentSchemaName sessionId conn

109− pure (either (const "<unknown>") id eHeadName, either (const "<no schema>") id eSchemaName)

121+ pure (fromRight "<unknown>" eHeadName, fromRight "<no schema>" eSchemaName)

110−

122+

111sendPromptInfo :: (HeadName, SchemaName) -> WS.Connection -> IO ()

123sendPromptInfo :: (HeadName, SchemaName) -> WS.Connection -> IO ()

112sendPromptInfo (hName, sName) conn = WS.sendTextData conn (encode (object ["promptInfo" .= object ["headname" .= hName, "schemaname" .= sName]]))

124sendPromptInfo (hName, sName) conn = WS.sendTextData conn (encode (object ["promptInfo" .= object ["headname" .= hName, "schemaname" .= sName]]))

113

125

114--a returning relation can be returned as JSON, Text (for consoles), or HTML

126--a returning relation can be returned as JSON, Text (for consoles), or HTML

115data Presentation = Presentation {

127data Presentation = Presentation {

116− jsonPresentation :: Bool,

128+ jsonPresentation :: Bool,

117 textPresentation :: Bool,

129 textPresentation :: Bool,

118 htmlPresentation :: Bool }

130 htmlPresentation :: Bool }

119−

131+

120data PresentationFlag = JSONFlag | TextFlag | HTMLFlag

132data PresentationFlag = JSONFlag | TextFlag | HTMLFlag

121−

133+

122parseExecuteMessage :: Parser (Presentation, T.Text)

134parseExecuteMessage :: Parser (Presentation, T.Text)

123parseExecuteMessage = do

135parseExecuteMessage = do

124 _ <- string "executetutd/"

136 _ <- string "executetutd/"

125 flags <- sepBy ((string "json" $> JSONFlag) <|>

137 flags <- sepBy ((string "json" $> JSONFlag) <|>

126 (string "text" $> TextFlag) <|>

138 (string "text" $> TextFlag) <|>

127 (string "html" $> HTMLFlag)) "+"

139 (string "html" $> HTMLFlag)) "+"

128− let presentation = foldr (\flag acc -> case flag of

140+ let presentation = foldr (\flag acc -> case flag of

129 JSONFlag -> acc {jsonPresentation = True}

141 JSONFlag -> acc {jsonPresentation = True}

130 TextFlag -> acc {textPresentation = True}

142 TextFlag -> acc {textPresentation = True}

131 HTMLFlag -> acc {htmlPresentation = True}) (Presentation False False False) flags

143 HTMLFlag -> acc {htmlPresentation = True}) (Presentation False False False) flags

src/bin/ProjectM36/Server/WebSocket/websocket-client.html+1−1

@@ -126,7 +126,7 @@ margin-bottom: 5pt;

126 <li>:showrelvars</li>

127 <li>:showexpr true</li>

128 <li>:showexpr false</li>

129− <li>:importexample date</li>

129+ <li>:importexample cjdate</li>

130 <li>:showexpr s join sp</li>

131 <li>update s where city="Paris" (status:=10)</li>

132 <li>:showexpr s</li>

src/bin/ProjectM36/Server/WebSocket/websocket-server.hs+48−18

@@ -1,33 +1,63 @@

1{-# LANGUAGE CPP #-}

2−import ProjectM36.Server.WebSocket

3−import ProjectM36.Server.Config

4−import ProjectM36.Server.ParseArgs

5−import ProjectM36.Server

6−import Control.Concurrent

7−import qualified Network.WebSockets as WS

8−

9−#if MIN_VERSION_network_transport_tcp(0,6,0)

10−import Network.Transport.TCP.Internal (decodeEndPointAddress)

11−#else

12−import Network.Transport.TCP (decodeEndPointAddress)

13−#endif

14

2

3+import Control.Concurrent

15import Control.Exception

4import Control.Exception

5+import Control.Monad (when)

6+import Data.Maybe (isJust)

7+import Data.String (fromString)

8+import Network.HTTP.Types (status400)

9+import Network.Socket

10+import Network.Wai (Application, responseLBS)

11+import Network.Wai.Handler.Warp

12+import Network.Wai.Handler.WarpTLS (runTLS, tlsSettings)

13+import qualified Network.Wai.Handler.WebSockets as WS

14+import Network.WebSockets (defaultConnectionOptions)

15+import ProjectM36.Server

16+import ProjectM36.Server.Config

17+import ProjectM36.Server.ParseArgs

18+import ProjectM36.Server.WebSocket

16

19

17main :: IO ()

20main :: IO ()

18main = do

21main = do

19 -- launch normal project-m36-server

22 -- launch normal project-m36-server

20 addressMVar <- newEmptyMVar

23 addressMVar <- newEmptyMVar

21− serverConfig <- parseConfigWithDefaults (defaultServerConfig { bindPort = 8000, bindHost = "127.0.0.1" })

24+ wsConfig <- parseWSConfigWithDefaults (defaultServerConfig {bindPort = 8000, bindHost = "127.0.0.1"})

25+

22 --usurp the serverConfig for our websocket server and make the proxied server run locally

26 --usurp the serverConfig for our websocket server and make the proxied server run locally

27+ let serverConfig = wsServerConfig wsConfig

23− let wsHost = bindHost serverConfig

28+ wsHost = bindHost serverConfig

24 wsPort = bindPort serverConfig

29 wsPort = bindPort serverConfig

25 serverHost = "127.0.0.1"

30 serverHost = "127.0.0.1"

26 serverConfig' = serverConfig {bindPort = 0, bindHost = serverHost}

31 serverConfig' = serverConfig {bindPort = 0, bindHost = serverHost}

32+ configCertificateFile = tlsCertificatePath wsConfig

33+ configKeyFile = tlsKeyPath wsConfig

34+

35+ when (isJust configCertificateFile /= isJust configKeyFile) $

36+ throwIO $ ErrorCall "TLS_CERTIFICATE_PATH and TLS_KEY_PATH must be set in tandem"

37+

27 _ <- forkFinally (launchServer serverConfig' (Just addressMVar) >> pure ()) (either throwIO pure)

38 _ <- forkFinally (launchServer serverConfig' (Just addressMVar) >> pure ()) (either throwIO pure)

28 --wait for server to be listening

39 --wait for server to be listening

29− address <- takeMVar addressMVar

40+ addr <- takeMVar addressMVar

30− let Just (_, serverPort, _) = decodeEndPointAddress address

41+ let port =

31− --this built-in server is apparently not meant for production use, but it's easier to test than starting up the wai or snap interfaces

42+ case addr of

32− WS.runServer wsHost (fromIntegral wsPort) (websocketProxyServer (read serverPort) serverHost)

43+ SockAddrInet port' _ -> fromIntegral port'

44+ _ -> error "unsupported socket address (IPv4 only currently)"

45+ wsApp = websocketProxyServer port serverHost

46+ waiApp = WS.websocketsOr defaultConnectionOptions wsApp backupApp

47+ settings = warpSettings wsHost (fromIntegral wsPort)

48+

49+ case (configCertificateFile, configKeyFile) of

50+ (Just certificate, Just key) -> runTLS (tlsSettings certificate key) settings waiApp

51+ _ -> runSettings settings waiApp

52+

53+backupApp :: Application

54+backupApp _ respond = respond $ responseLBS status400 [] "Not a WebSocket request"

33

55

56+warpSettings :: HostName -> Port -> Settings

57+warpSettings host port =

58+ setHost (fromString host)

59+ . setPort port

60+ . setServerName "project-m36"

61+ . setTimeout 3600

62+ . setGracefulShutdownTimeout (Just 5)

63+ $ defaultSettings

src/bin/TutorialD/Interpreter.hs+32−28

@@ -1,4 +1,4 @@

1−{-# LANGUAGE GADTs, LambdaCase #-}

1+{-# LANGUAGE GADTs, LambdaCase, CPP #-}

2module TutorialD.Interpreter where

3import TutorialD.Interpreter.Base

4import TutorialD.Interpreter.RODatabaseContextOperator

@@ -28,10 +28,13 @@ import System.Console.Haskeline

28import System.Directory (getHomeDirectory)

29import qualified Data.Text as T

30import System.IO (hPutStrLn, stderr)

31+#if __GLASGOW_HASKELL__ < 804

31import Data.Monoid

32import Data.Monoid

33+#endif

32import Data.List (isPrefixOf)

34import Data.List (isPrefixOf)

33import Control.Exception

35import Control.Exception

34import System.Exit

36import System.Exit

37+import Data.Either (fromRight)

35

38

36{-

39{-

37context ops are read-only operations which only operate on the database context (relvars and constraints)

40context ops are read-only operations which only operate on the database context (relvars and constraints)

@@ -59,7 +62,7 @@ interpreterParserP = safeInterpreterParserP <|>

59 fmap ImportDBContextOp (tutdImportP <* eof) <|>

62 fmap ImportDBContextOp (tutdImportP <* eof) <|>

60 fmap RelVarExportOp (exportCSVP <* eof) <|>

63 fmap RelVarExportOp (exportCSVP <* eof) <|>

61 fmap DatabaseContextIOExprOp (dbContextIOExprP <* eof)

64 fmap DatabaseContextIOExprOp (dbContextIOExprP <* eof)

62−

65+

63-- the safe interpreter never reads or writes the file system

66-- the safe interpreter never reads or writes the file system

64safeInterpreterParserP :: Parser ParsedOperation

67safeInterpreterParserP :: Parser ParsedOperation

65safeInterpreterParserP = fmap RODatabaseContextOp (roDatabaseContextOperatorP <* eof) <|>

68safeInterpreterParserP = fmap RODatabaseContextOp (roDatabaseContextOperatorP <* eof) <|>

@@ -75,8 +78,8 @@ safeInterpreterParserP = fmap RODatabaseContextOp (roDatabaseContextOperatorP <*

75promptText :: Either RelationalError HeadName -> Either RelationalError SchemaName -> StringType

78promptText :: Either RelationalError HeadName -> Either RelationalError SchemaName -> StringType

76promptText eHeadName eSchemaName = "TutorialD (" <> transInfo <> "): "

79promptText eHeadName eSchemaName = "TutorialD (" <> transInfo <> "): "

77 where

80 where

78− transInfo = either (const "<unknown>") id eHeadName <> "/" <> either (const "<no schema>") id eSchemaName

81+ transInfo = fromRight "<unknown>" eHeadName <> "/" <> fromRight "<no schema>" eSchemaName

79−

82+

80parseTutorialD :: T.Text -> Either ParserError ParsedOperation

83parseTutorialD :: T.Text -> Either ParserError ParsedOperation

81parseTutorialD = parse interpreterParserP ""

84parseTutorialD = parse interpreterParserP ""

82

85

@@ -104,20 +107,20 @@ evalTutorialDInteractive sessionId conn safe interactive expr = case expr of

104 else

107 else

105 pure res

108 pure res

106 _ -> pure res

109 _ -> pure res

107−

110+

108− (DatabaseContextExprOp execOp) ->

111+ (DatabaseContextExprOp execOp) ->

109− eHandler $ C.executeDatabaseContextExpr sessionId conn execOp

112+ eHandler $ C.executeDatabaseContextExpr sessionId conn execOp

110−

113+

111− (DatabaseContextIOExprOp execOp) ->

114+ (DatabaseContextIOExprOp execOp) ->

112 if needsSafe then

115 if needsSafe then

113 unsafeError

116 unsafeError

114 else

117 else

115 eHandler $ C.executeDatabaseContextIOExpr sessionId conn execOp

118 eHandler $ C.executeDatabaseContextIOExpr sessionId conn execOp

116−

119+

117 (GraphOp execOp) -> do

120 (GraphOp execOp) -> do

118 -- warn if the graph op could cause uncommited changes to be discarded

121 -- warn if the graph op could cause uncommited changes to be discarded

119 eIsDirty <- C.disconnectedTransactionIsDirty sessionId conn

122 eIsDirty <- C.disconnectedTransactionIsDirty sessionId conn

120− let runGraphOp = eHandler $ C.executeGraphExpr sessionId conn execOp

123+ let runGraphOp = eHandler $ C.executeGraphExpr sessionId conn execOp

121 settings = Settings {complete = noCompletion,

124 settings = Settings {complete = noCompletion,

122 historyFile = Nothing,

125 historyFile = Nothing,

123 autoAddHistory = False}

126 autoAddHistory = False}

@@ -141,20 +144,20 @@ evalTutorialDInteractive sessionId conn safe interactive expr = case expr of

141 pure (DisplayErrorResult "Graph operation cancelled.")

144 pure (DisplayErrorResult "Graph operation cancelled.")

142 else

145 else

143 runGraphOp

146 runGraphOp

144−

147+

145 (ConvenienceGraphOp execOp) ->

148 (ConvenienceGraphOp execOp) ->

146 eHandler $ evalConvenienceGraphOp sessionId conn execOp

149 eHandler $ evalConvenienceGraphOp sessionId conn execOp

147

150

148 (ROGraphOp execOp) -> do

151 (ROGraphOp execOp) -> do

149 opResult <- evalROGraphOp sessionId conn execOp

152 opResult <- evalROGraphOp sessionId conn execOp

150− case opResult of

153+ case opResult of

151 Left err -> barf err

154 Left err -> barf err

152 Right rel -> pure (DisplayRelationResult rel)

155 Right rel -> pure (DisplayRelationResult rel)

153−

156+

154 (SchemaOp execOp) ->

157 (SchemaOp execOp) ->

155 eHandler $ evalSchemaOperator sessionId conn execOp

158 eHandler $ evalSchemaOperator sessionId conn execOp

156−

159+

157− (ImportRelVarOp execOp@(RelVarDataImportOperator relVarName _ _)) ->

160+ (ImportRelVarOp execOp@(RelVarDataImportOperator relVarName _ _)) ->

158 if needsSafe then

161 if needsSafe then

159 unsafeError

162 unsafeError

160 else do

163 else do

@@ -172,8 +175,8 @@ evalTutorialDInteractive sessionId conn safe interactive expr = case expr of

172 case exprErr of

175 case exprErr of

173 Left err -> barf err

176 Left err -> barf err

174 Right dbexpr -> evalTutorialD sessionId conn safe (DatabaseContextExprOp dbexpr)

177 Right dbexpr -> evalTutorialD sessionId conn safe (DatabaseContextExprOp dbexpr)

175−

178+

176− (ImportDBContextOp execOp) ->

179+ (ImportDBContextOp execOp) ->

177 if needsSafe then

180 if needsSafe then

178 unsafeError

181 unsafeError

179 else do

182 else do

@@ -181,15 +184,15 @@ evalTutorialDInteractive sessionId conn safe interactive expr = case expr of

181 case eErr of

184 case eErr of

182 Left err -> barf err

185 Left err -> barf err

183 Right dbexprs -> evalTutorialD sessionId conn safe (DatabaseContextExprOp dbexprs)

186 Right dbexprs -> evalTutorialD sessionId conn safe (DatabaseContextExprOp dbexprs)

184−

187+

185− (InfoOp execOp) ->

188+ (InfoOp execOp) ->

186 if needsSafe then

189 if needsSafe then

187 unsafeError

190 unsafeError

188 else

191 else

189 case evalInformationOperator execOp of

192 case evalInformationOperator execOp of

190 Left err -> pure (DisplayErrorResult err)

193 Left err -> pure (DisplayErrorResult err)

191 Right info -> pure (DisplayResult info)

194 Right info -> pure (DisplayResult info)

192−

195+

193 (RelVarExportOp execOp@(RelVarDataExportOperator relExpr _ _)) ->

196 (RelVarExportOp execOp@(RelVarDataExportOperator relExpr _ _)) ->

194 --eval relexpr to relation and pass to export function

197 --eval relexpr to relation and pass to export function

195 if needsSafe then

198 if needsSafe then

@@ -213,19 +216,20 @@ evalTutorialDInteractive sessionId conn safe interactive expr = case expr of

213 unsafeError = pure $ DisplayErrorResult "File I/O operation prohibited."

216 unsafeError = pure $ DisplayErrorResult "File I/O operation prohibited."

214 barf :: RelationalError -> IO TutorialDOperatorResult

217 barf :: RelationalError -> IO TutorialDOperatorResult

215 barf (ScriptError (OtherScriptCompilationError errStr)) = pure (DisplayErrorResult (T.pack errStr))

218 barf (ScriptError (OtherScriptCompilationError errStr)) = pure (DisplayErrorResult (T.pack errStr))

219+ barf (ParseError err) = pure (DisplayErrorResult err)

216 barf err = return $ DisplayErrorResult (T.pack (show err))

220 barf err = return $ DisplayErrorResult (T.pack (show err))

217 eHandler io = do

221 eHandler io = do

218 eErr <- io

222 eErr <- io

219 case eErr of

223 case eErr of

220 Left err -> barf err

224 Left err -> barf err

221 Right () -> return QuietSuccessResult

225 Right () -> return QuietSuccessResult

222−

226+

223−type GhcPkgPath = String

227+type GhcPkgPath = String

224type TutorialDExec = String

228type TutorialDExec = String

225type CheckFS = Bool

229type CheckFS = Bool

226−

230+

227data InterpreterConfig = LocalInterpreterConfig PersistenceStrategy HeadName (Maybe TutorialDExec) [GhcPkgPath] CheckFS |

231data InterpreterConfig = LocalInterpreterConfig PersistenceStrategy HeadName (Maybe TutorialDExec) [GhcPkgPath] CheckFS |

228− RemoteInterpreterConfig C.NodeId C.DatabaseName HeadName (Maybe TutorialDExec) CheckFS

232+ RemoteInterpreterConfig C.Hostname C.Port C.DatabaseName HeadName (Maybe TutorialDExec) CheckFS

229

233

230outputNotificationCallback :: C.NotificationCallback

234outputNotificationCallback :: C.NotificationCallback

231outputNotificationCallback notName evaldNot = hPutStrLn stderr $ "Notification received " ++ show notName ++ ":\n" ++ "\n" ++ prettyEvaluatedNotification evaldNot

235outputNotificationCallback notName evaldNot = hPutStrLn stderr $ "Notification received " ++ show notName ++ ":\n" ++ "\n" ++ prettyEvaluatedNotification evaldNot

@@ -254,12 +258,12 @@ reprLoop config sessionId conn = do

254 Just line -> do

258 Just line -> do

255 runTutorialD sessionId conn (Just (T.length prompt)) (T.pack line)

259 runTutorialD sessionId conn (Just (T.length prompt)) (T.pack line)

256 reprLoop config sessionId conn

260 reprLoop config sessionId conn

257−

261+

258

262

259runTutorialD :: C.SessionId -> C.Connection -> Maybe PromptLength -> T.Text -> IO ()

263runTutorialD :: C.SessionId -> C.Connection -> Maybe PromptLength -> T.Text -> IO ()

260−runTutorialD sessionId conn mPromptLength tutd =

264+runTutorialD sessionId conn mPromptLength tutd =

261 case parseTutorialD tutd of

265 case parseTutorialD tutd of

262− Left err ->

266+ Left err ->

263 displayOpResult $ DisplayParseErrorResult mPromptLength err

267 displayOpResult $ DisplayParseErrorResult mPromptLength err

264 Right parsed ->

268 Right parsed ->

265 catchJust (\exc -> if exc == C.RequestTimeoutException then Just exc else Nothing) (do

269 catchJust (\exc -> if exc == C.RequestTimeoutException then Just exc else Nothing) (do

src/bin/TutorialD/Interpreter/Base.hs+68−38

@@ -1,8 +1,8 @@

1{-# LANGUAGE DeriveGeneric, CPP #-}

2module TutorialD.Interpreter.Base (

3− module TutorialD.Interpreter.Base,

3+ module TutorialD.Interpreter.Base,

4 module Text.Megaparsec,

5−#if MIN_VERSION_megaparsec(6,0,0)

5+#if MIN_VERSION_megaparsec(6,0,0)

6 module Text.Megaparsec.Char,

7 module Control.Applicative

8#else

@@ -12,11 +12,12 @@ module TutorialD.Interpreter.Base (

12 where

13import ProjectM36.Base

14import ProjectM36.AtomType

15+import ProjectM36.Attribute as A

15import ProjectM36.Relation

16import ProjectM36.Relation

16import ProjectM36.DataFrame

17import ProjectM36.DataFrame

17

18

18#if MIN_VERSION_megaparsec(6,0,0)

19#if MIN_VERSION_megaparsec(6,0,0)

19−import Text.Megaparsec.Char

20+import Text.Megaparsec.Char

20import qualified Text.Megaparsec.Char.Lexer as Lex

21import qualified Text.Megaparsec.Char.Lexer as Lex

21import Text.Megaparsec

22import Text.Megaparsec

22import Data.Void

23import Data.Void

@@ -30,24 +31,31 @@ import Data.Text hiding (count)

30import System.Random

31import System.Random

31import qualified Data.Text as T

32import qualified Data.Text as T

32import qualified Data.List as L

33import qualified Data.List as L

33−import qualified Data.Vector as V

34import qualified Data.Text.IO as TIO

35import System.IO

36import ProjectM36.Relation.Show.Term

37import GHC.Generics

38+#if __GLASGOW_HASKELL__ < 804

38import Data.Monoid

39import Data.Monoid

40+#endif

39import qualified Data.UUID as U

41import qualified Data.UUID as U

40import Control.Monad.Random

42import Control.Monad.Random

41import Data.List.NonEmpty as NE

43import Data.List.NonEmpty as NE

42import Data.Time.Clock

44import Data.Time.Clock

43import Data.Time.Format

45import Data.Time.Format

44import Control.Monad (void)

46import Control.Monad (void)

47+import Data.Char

48+

49+#if !MIN_VERSION_megaparsec(7,0,0)

50+anySingle :: Parsec Void Text (Token Text)

51+anySingle = anyChar

52+#endif

45

53

46displayOpResult :: TutorialDOperatorResult -> IO ()

54displayOpResult :: TutorialDOperatorResult -> IO ()

47displayOpResult QuitResult = return ()

55displayOpResult QuitResult = return ()

48displayOpResult (DisplayResult out) = TIO.putStrLn out

56displayOpResult (DisplayResult out) = TIO.putStrLn out

49displayOpResult (DisplayIOResult ioout) = ioout

57displayOpResult (DisplayIOResult ioout) = ioout

50−displayOpResult (DisplayErrorResult err) = let outputf = if T.length err > 0 && T.last err /= '\n' then TIO.hPutStrLn else TIO.hPutStr in

58+displayOpResult (DisplayErrorResult err) = let outputf = if T.length err > 0 && T.last err /= '\n' then TIO.hPutStrLn else TIO.hPutStr in

51 outputf stderr ("ERR: " <> err)

59 outputf stderr ("ERR: " <> err)

52displayOpResult QuietSuccessResult = return ()

60displayOpResult QuietSuccessResult = return ()

53displayOpResult (DisplayRelationResult rel) = do

61displayOpResult (DisplayRelationResult rel) = do

@@ -55,8 +63,13 @@ displayOpResult (DisplayRelationResult rel) = do

55 let randomlySortedRel = evalRand (randomizeTupleOrder rel) gen

63 let randomlySortedRel = evalRand (randomizeTupleOrder rel) gen

56 TIO.putStrLn (showRelation randomlySortedRel)

64 TIO.putStrLn (showRelation randomlySortedRel)

57displayOpResult (DisplayParseErrorResult mPromptLength err) = do

65displayOpResult (DisplayParseErrorResult mPromptLength err) = do

66+#if MIN_VERSION_megaparsec(7,0,0)

67+ let errorIndent = errorOffset . NE.head . bundleErrors $ err

58− let errString = T.pack (parseErrorPretty err)

68+ errString = T.pack (parseErrorPretty . NE.head . bundleErrors $ err)

69+#else

59− errorIndent = unPos (sourceColumn (NE.head (errorPos err)))

70+ let errorIndent = unPos (sourceColumn (NE.head (errorPos err)))

71+ errString = T.pack (parseErrorPretty err)

72+#endif

60 pointyString len = T.justifyRight (len + fromIntegral errorIndent) '_' "^"

73 pointyString len = T.justifyRight (len + fromIntegral errorIndent) '_' "^"

61 maybe (pure ()) (TIO.putStrLn . pointyString) mPromptLength

74 maybe (pure ()) (TIO.putStrLn . pointyString) mPromptLength

62 TIO.putStr ("ERR:" <> errString)

75 TIO.putStr ("ERR:" <> errString)

@@ -69,9 +82,10 @@ type ParseStr = Text

69type ParseStr = String

82type ParseStr = String

70#endif

83#endif

71

84

85+-- consumes only horizontal spaces

72spaceConsumer :: Parser ()

86spaceConsumer :: Parser ()

73−spaceConsumer = Lex.space (void spaceChar) (Lex.skipLineComment "--") (Lex.skipBlockComment "{-" "-}")

87+spaceConsumer = Lex.space space1 (Lex.skipLineComment "--") (Lex.skipBlockComment "{-" "-}")

74−

88+

75opChar :: Parser Char

89opChar :: Parser Char

76opChar = oneOf (":!#$%&*+./<=>?\\^|-~" :: String)-- remove "@" so it can be used as attribute marker without spaces

90opChar = oneOf (":!#$%&*+./<=>?\\^|-~" :: String)-- remove "@" so it can be used as attribute marker without spaces

77

91

@@ -90,9 +104,13 @@ braces = between (symbol "{") (symbol "}")

90identifier :: Parser Text

104identifier :: Parser Text

91identifier = do

105identifier = do

92 istart <- letterChar <|> char '_'

106 istart <- letterChar <|> char '_'

107+ identifierRemainder istart

108+

109+identifierRemainder :: Char -> Parser Text

110+identifierRemainder c = do

93− irest <- many (alphaNumChar <|> char '_' <|> char '#')

111+ rest <- many (alphaNumChar <|> char '_' <|> char '#')

94 spaceConsumer

112 spaceConsumer

95− pure (pack (istart:irest))

113+ pure (pack (c:rest))

96

114

97symbol :: ParseStr -> Parser Text

115symbol :: ParseStr -> Parser Text

98#if MIN_VERSION_megaparsec(6,0,0)

116#if MIN_VERSION_megaparsec(6,0,0)

@@ -119,11 +137,14 @@ arrow = symbol "->"

119semi :: Parser Text

137semi :: Parser Text

120semi = symbol ";"

138semi = symbol ";"

121

139

140+nline :: Parser Text

141+nline = (T.singleton <$> newline) <|> crlf

142+

122integer :: Parser Integer

143integer :: Parser Integer

123#if MIN_VERSION_megaparsec(6,0,0)

144#if MIN_VERSION_megaparsec(6,0,0)

124−integer = Lex.signed spaceConsumer Lex.decimal

145+integer = Lex.signed (pure ()) Lex.decimal <* spaceConsumer

125#else

146#else

126−integer = Lex.signed spaceConsumer Lex.integer

147+integer = Lex.signed (pure ()) Lex.integer <* spaceConsumer

127#endif

148#endif

128

149

129natural :: Parser Integer

150natural :: Parser Integer

@@ -134,36 +155,30 @@ natural = Lex.integer <* spaceConsumer

134#endif

155#endif

135

156

136float :: Parser Double

157float :: Parser Double

137−float = Lex.float

158+float = Lex.float <* spaceConsumer

138

159

139capitalizedIdentifier :: Parser Text

160capitalizedIdentifier :: Parser Text

140−capitalizedIdentifier = do

161+capitalizedIdentifier =

141− fletter <- upperChar

162+ upperChar >>= identifierRemainder

142− restOfIdentifier_ fletter

163+

143−

144−restOfIdentifier_ :: Char -> Parser Text

145−restOfIdentifier_ fletter = do

146− rest <- option "" identifier

147− spaceConsumer

148− pure (T.cons fletter rest)

149−

150uncapitalizedIdentifier :: Parser Text

164uncapitalizedIdentifier :: Parser Text

151−uncapitalizedIdentifier = do

165+uncapitalizedIdentifier =

152− fletter <- lowerChar

166+ lowerChar >>= identifierRemainder

153− restOfIdentifier_ fletter

154

167

155showRelationAttributes :: Attributes -> Text

168showRelationAttributes :: Attributes -> Text

156showRelationAttributes attrs = "{" <> T.concat (L.intersperse ", " $ L.map showAttribute attrsL) <> "}"

169showRelationAttributes attrs = "{" <> T.concat (L.intersperse ", " $ L.map showAttribute attrsL) <> "}"

157 where

170 where

158− showAttribute (Attribute name atomType) = name <> " " <> prettyAtomType atomType

171+ showAttribute (Attribute name atomType') = name <> " " <> prettyAtomType atomType'

159− attrsL = V.toList attrs

172+ attrsL = A.toList attrs

160

173

161−type PromptLength = Int

174+type PromptLength = Int

162

175

163−#if MIN_VERSION_megaparsec(6,0,0)

176+#if MIN_VERSION_megaparsec(7,0,0)

177+type ParserError = ParseErrorBundle T.Text Void

178+#elif MIN_VERSION_megaparsec(6,0,0)

164type ParserError = ParseError Char Void

179type ParserError = ParseError Char Void

165−#else

180+#else

166−type ParserError = ParseError Char Dec

181+type ParserError = ParseError Char Dec

167#endif

182#endif

168

183

169data TutorialDOperatorResult = QuitResult |

184data TutorialDOperatorResult = QuitResult |

@@ -175,24 +190,27 @@ data TutorialDOperatorResult = QuitResult |

175 DisplayParseErrorResult (Maybe PromptLength) ParserError | -- PromptLength refers to length of prompt text

190 DisplayParseErrorResult (Maybe PromptLength) ParserError | -- PromptLength refers to length of prompt text

176 QuietSuccessResult

191 QuietSuccessResult

177 deriving (Generic)

192 deriving (Generic)

178−

193+

179type TransactionGraphWasUpdated = Bool

194type TransactionGraphWasUpdated = Bool

180

195

181--allow for python-style triple quoting because guessing the correct amount of escapes in different contexts is annoying

196--allow for python-style triple quoting because guessing the correct amount of escapes in different contexts is annoying

182tripleQuotedString :: Parser Text

197tripleQuotedString :: Parser Text

183tripleQuotedString = do

198tripleQuotedString = do

184 _ <- tripleQuote

199 _ <- tripleQuote

185− pack <$> manyTill anyChar (try (tripleQuote >> notFollowedBy quote))

200+ pack <$> manyTill anySingle (try (tripleQuote >> notFollowedBy quote))

186−

201+

187normalQuotedString :: Parser Text

202normalQuotedString :: Parser Text

188normalQuotedString = quote *> (T.pack <$> manyTill Lex.charLiteral quote)

203normalQuotedString = quote *> (T.pack <$> manyTill Lex.charLiteral quote)

189

204

190quotedString :: Parser Text

205quotedString :: Parser Text

191quotedString = try tripleQuotedString <|> normalQuotedString

206quotedString = try tripleQuotedString <|> normalQuotedString

192

207

208+quoted :: Parser a -> Parser a

209+quoted = between quote quote

210+

193uuidP :: Parser U.UUID

211uuidP :: Parser U.UUID

194uuidP = do

212uuidP = do

195− uuidStart <- count 8 hexDigitChar

213+ uuidStart <- count 8 hexDigitChar

196 _ <- char '-' -- min 28 with no dashes, maximum 4 dashes

214 _ <- char '-' -- min 28 with no dashes, maximum 4 dashes

197 uuidMid1 <- count 4 hexDigitChar

215 uuidMid1 <- count 4 hexDigitChar

198 _ <- char '-'

216 _ <- char '-'

@@ -211,5 +229,17 @@ utcTimeP = do

211 timeStr <- quotedString

229 timeStr <- quotedString

212 case parseTimeM True defaultTimeLocale "%Y-%m-%d %H:%M:%S" (T.unpack timeStr) of

230 case parseTimeM True defaultTimeLocale "%Y-%m-%d %H:%M:%S" (T.unpack timeStr) of

213 Nothing -> fail "invalid datetime input, use \"YYYY-MM-DD HH:MM:SS\""

231 Nothing -> fail "invalid datetime input, use \"YYYY-MM-DD HH:MM:SS\""

214− Just stamp -> pure stamp

232+ Just stamp' -> pure stamp'

233+

234+

235+colonOp :: Text -> Parser ()

236+colonOp opStr = do

237+ _ <- string opStr <* (void spaceChar <|> eof) <* spaceConsumer

238+ pure ()

239+

240+hex :: Parser Text

241+hex = takeWhileP (Just "hexadecimal")

242+ (\c ->

243+ isDigit c

244+ || (c >= 'a' && c <= 'f'))

215

245

src/bin/TutorialD/Interpreter/DatabaseContextExpr.hs+24−16

@@ -1,3 +1,4 @@

1+{-# LANGUAGE CPP #-}

1module TutorialD.Interpreter.DatabaseContextExpr where

2module TutorialD.Interpreter.DatabaseContextExpr where

2import ProjectM36.Base

3import ProjectM36.Base

3import TutorialD.Interpreter.Base

4import TutorialD.Interpreter.Base

@@ -5,14 +6,15 @@ import qualified Data.Text as T

5import TutorialD.Interpreter.RelationalExpr

6import TutorialD.Interpreter.RelationalExpr

6import TutorialD.Interpreter.Types

7import TutorialD.Interpreter.Types

7import qualified Data.Map as M

8import qualified Data.Map as M

8−import Control.Monad.State

9import ProjectM36.StaticOptimizer

10import qualified ProjectM36.Error as PM36E

11import ProjectM36.Error

12import qualified ProjectM36.RelationalExpression as RE

13import ProjectM36.Key

14import ProjectM36.FunctionalDependency

15+#if __GLASGOW_HASKELL__ < 804

15import Data.Monoid

16import Data.Monoid

17+#endif

16import Data.Functor

18import Data.Functor

17

19

18--parsers which create "database expressions" which modify the database context (such as relvar assignment)

20--parsers which create "database expressions" which modify the database context (such as relvar assignment)

@@ -42,7 +44,7 @@ nothingP = spaceConsumer >> pure NoOperation

42assignP :: Parser DatabaseContextExpr

44assignP :: Parser DatabaseContextExpr

43assignP = do

45assignP = do

44 relVarName <- try $ do

46 relVarName <- try $ do

45− relVarName <- identifier

47+ relVarName <- relVarNameP

46 reservedOp ":="

48 reservedOp ":="

47 return relVarName

49 return relVarName

48 Assign relVarName <$> relExprP

50 Assign relVarName <$> relExprP

@@ -51,19 +53,20 @@ multilineSep :: Parser T.Text

51multilineSep = newline >> pure "\n"

53multilineSep = newline >> pure "\n"

52

54

53multipleDatabaseContextExprP :: Parser DatabaseContextExpr

55multipleDatabaseContextExprP :: Parser DatabaseContextExpr

54−multipleDatabaseContextExprP =

56+multipleDatabaseContextExprP = do

55− MultipleExpr <$> sepBy1 databaseContextExprP semi

57+ exprs <- filter (/= NoOperation) <$> sepBy1 databaseContextExprP semi

58+ pure (MultipleExpr exprs)

56

59

57insertP :: Parser DatabaseContextExpr

60insertP :: Parser DatabaseContextExpr

58insertP = do

61insertP = do

59 reservedOp "insert"

62 reservedOp "insert"

60− relvar <- identifier

63+ relvar <- relVarNameP

61 Insert relvar <$> relExprP

64 Insert relvar <$> relExprP

62

65

63defineP :: Parser DatabaseContextExpr

66defineP :: Parser DatabaseContextExpr

64defineP = do

67defineP = do

65 relVarName <- try $ do

68 relVarName <- try $ do

66− relVarName <- identifier

69+ relVarName <- relVarNameP

67 reservedOp "::"

70 reservedOp "::"

68 return relVarName

71 return relVarName

69 Define relVarName <$> makeAttributeExprsP

72 Define relVarName <$> makeAttributeExprsP

@@ -71,17 +74,17 @@ defineP = do

71undefineP :: Parser DatabaseContextExpr

74undefineP :: Parser DatabaseContextExpr

72undefineP = do

75undefineP = do

73 reservedOp "undefine"

76 reservedOp "undefine"

74− Undefine <$> identifier

77+ Undefine <$> relVarNameP

75

78

76deleteP :: Parser DatabaseContextExpr

79deleteP :: Parser DatabaseContextExpr

77deleteP = do

80deleteP = do

78 reservedOp "delete"

81 reservedOp "delete"

79− Delete <$> identifier <*> option TruePredicate (reservedOp "where" *> restrictionPredicateP)

82+ Delete <$> relVarNameP <*> option TruePredicate (reservedOp "where" *> restrictionPredicateP)

80

83

81updateP :: Parser DatabaseContextExpr

84updateP :: Parser DatabaseContextExpr

82updateP = do

85updateP = do

83 reservedOp "update"

86 reservedOp "update"

84− relVarName <- identifier

87+ relVarName <- relVarNameP

85 predicate <- option TruePredicate (reservedOp "where" *> restrictionPredicateP <* spaceConsumer)

88 predicate <- option TruePredicate (reservedOp "where" *> restrictionPredicateP <* spaceConsumer)

86 attributeAssignments <- M.fromList <$> parens (sepBy attributeAssignmentP comma)

89 attributeAssignments <- M.fromList <$> parens (sepBy attributeAssignmentP comma)

87 return $ Update relVarName attributeAssignments predicate

90 return $ Update relVarName attributeAssignments predicate

@@ -164,7 +167,7 @@ addTypeConstructorP = do

164removeTypeConstructorP :: Parser DatabaseContextExpr

167removeTypeConstructorP :: Parser DatabaseContextExpr

165removeTypeConstructorP = do

168removeTypeConstructorP = do

166 reserved "undata"

169 reserved "undata"

167− RemoveTypeConstructor <$> identifier

170+ RemoveTypeConstructor <$> typeConstructorNameP

168

171

169removeAtomFunctionP :: Parser DatabaseContextExpr

172removeAtomFunctionP :: Parser DatabaseContextExpr

170removeAtomFunctionP = do

173removeAtomFunctionP = do

@@ -176,10 +179,13 @@ removeDatabaseContextFunctionP = do

176 reserved "removedatabasecontextfunction"

179 reserved "removedatabasecontextfunction"

177 RemoveDatabaseContextFunction <$> quotedString

180 RemoveDatabaseContextFunction <$> quotedString

178

181

182+functionNameP :: Parser AtomFunctionName

183+functionNameP = uncapitalizedIdentifier

184+

179executeDatabaseContextFunctionP :: Parser DatabaseContextExpr

185executeDatabaseContextFunctionP :: Parser DatabaseContextExpr

180executeDatabaseContextFunctionP = do

186executeDatabaseContextFunctionP = do

181 reserved "execute"

187 reserved "execute"

182− funcName <- identifier

188+ funcName <- functionNameP

183 args <- parens (sepBy atomExprP comma)

189 args <- parens (sepBy atomExprP comma)

184 pure (ExecuteDatabaseContextFunction funcName args)

190 pure (ExecuteDatabaseContextFunction funcName args)

185

191

@@ -195,11 +201,13 @@ evalDatabaseContextExpr useOptimizer context expr = do

195 (Left err, _) -> Left err

201 (Left err, _) -> Left err

196-}

202-}

197

203

198−interpretDatabaseContextExpr :: DatabaseContext -> T.Text -> Either RelationalError DatabaseContext

204+interpretDatabaseContextExpr :: DatabaseContext -> TransactionId -> TransactionGraph -> T.Text -> Either RelationalError DatabaseContext

199−interpretDatabaseContextExpr context tutdstring = case parse databaseExprOpP "" tutdstring of

205+interpretDatabaseContextExpr context transId graph tutdstring =

206+ case parse databaseExprOpP "" tutdstring of

200− Left err -> Left $ PM36E.ParseError (T.pack (show err))

207+ Left err -> Left $ PM36E.ParseError (T.pack (show err))

201− Right parsed ->

208+ Right parsed -> do

202− evalDatabaseContextExpr True context parsed

209+ let env = RE.mkDatabaseContextEvalEnv transId graph

210+ RE.dbc_context <$> RE.runDatabaseContextEvalMonad context env (optimizeAndEvalDatabaseContextExpr True parsed)

203

211

204{-

212{-

205--no optimization

213--no optimization

src/bin/TutorialD/Interpreter/Export/Base.hs+3

@@ -1,7 +1,10 @@

1+{-# LANGUAGE CPP #-}

1module TutorialD.Interpreter.Export.Base where

2module TutorialD.Interpreter.Export.Base where

2import ProjectM36.Base

3import ProjectM36.Base

3import ProjectM36.Error

4import ProjectM36.Error

5+#if __GLASGOW_HASKELL__ < 804

4import Data.Monoid

6import Data.Monoid

7+#endif

5

8

6data RelVarDataExportOperator = RelVarDataExportOperator RelationalExpr FilePath (RelVarDataExportOperator -> Relation -> IO (Maybe RelationalError))

9data RelVarDataExportOperator = RelVarDataExportOperator RelationalExpr FilePath (RelVarDataExportOperator -> Relation -> IO (Maybe RelationalError))

7

10

src/bin/TutorialD/Interpreter/Import/Base.hs+11−3

@@ -1,7 +1,12 @@

1+{-# LANGUAGE CPP #-}

1module TutorialD.Interpreter.Import.Base where

2module TutorialD.Interpreter.Import.Base where

2import ProjectM36.Base

3import ProjectM36.Base

3import ProjectM36.Error

4import ProjectM36.Error

5+import Text.URI (URI)

6+import Data.Text (Text)

7+#if __GLASGOW_HASKELL__ < 804

4import Data.Monoid

8import Data.Monoid

9+#endif

5

10

6-- | import data into a relation variable

11-- | import data into a relation variable

7data RelVarDataImportOperator = RelVarDataImportOperator RelVarName FilePath (RelVarName -> TypeConstructorMapping -> Attributes -> FilePath -> IO (Either RelationalError DatabaseContextExpr))

12data RelVarDataImportOperator = RelVarDataImportOperator RelVarName FilePath (RelVarName -> TypeConstructorMapping -> Attributes -> FilePath -> IO (Either RelationalError DatabaseContextExpr))

@@ -9,11 +14,14 @@ data RelVarDataImportOperator = RelVarDataImportOperator RelVarName FilePath (Re

9instance Show RelVarDataImportOperator where

14instance Show RelVarDataImportOperator where

10 show (RelVarDataImportOperator rv path _) = "RelVarDataImportOperator " <> show rv <> " " <> path

15 show (RelVarDataImportOperator rv path _) = "RelVarDataImportOperator " <> show rv <> " " <> path

11

16

17+type HashVerification = Maybe Text

18+

12-- | import data into a database context

19-- | import data into a database context

13−data DatabaseContextDataImportOperator = DatabaseContextDataImportOperator FilePath (FilePath -> IO (Either RelationalError DatabaseContextExpr))

20+data DatabaseContextDataImportOperator = DatabaseContextDataImportOperator URI HashVerification (URI -> HashVerification -> IO (Either RelationalError DatabaseContextExpr))

14

21

15instance Show DatabaseContextDataImportOperator where

22instance Show DatabaseContextDataImportOperator where

16− show (DatabaseContextDataImportOperator path _) = "DatabaseContextDataImportOperator " <> path

23+ show (DatabaseContextDataImportOperator uri hash _) =

24+ "DatabaseContextDataImportOperator " <> show uri <> " " <> show hash

17

25

18-- perhaps create a structure to import a whole transaction graph section in the future

26-- perhaps create a structure to import a whole transaction graph section in the future

19

27

@@ -21,4 +29,4 @@ evalRelVarDataImportOperator :: RelVarDataImportOperator -> TypeConstructorMappi

21evalRelVarDataImportOperator (RelVarDataImportOperator relVarName path importFunc) tConsMap attrs = importFunc relVarName tConsMap attrs path

29evalRelVarDataImportOperator (RelVarDataImportOperator relVarName path importFunc) tConsMap attrs = importFunc relVarName tConsMap attrs path

22

30

23evalDatabaseContextDataImportOperator :: DatabaseContextDataImportOperator -> IO (Either RelationalError DatabaseContextExpr)

31evalDatabaseContextDataImportOperator :: DatabaseContextDataImportOperator -> IO (Either RelationalError DatabaseContextExpr)

24−evalDatabaseContextDataImportOperator (DatabaseContextDataImportOperator path importFunc) = importFunc path

32+evalDatabaseContextDataImportOperator (DatabaseContextDataImportOperator uri hash importFunc) = importFunc uri hash

src/bin/TutorialD/Interpreter/Import/BasicExamples.hs+2−2

@@ -20,8 +20,8 @@ importBasicExampleOperatorP :: Parser ImportBasicExampleOperator

20importBasicExampleOperatorP = do

21 reservedOp ":importexample"

22 example <- identifier

23− if example == "date" then

23+ if example == "cjdate" then

24 pure ImportBasicDateExampleOperator

25 else

26 fail "Unknown example name"

27−

27+

src/bin/TutorialD/Interpreter/Import/CSV.hs+3−3

@@ -14,10 +14,10 @@ importCSVRelation relVarName tConsMap attrs pathIn = do

14 --TODO: handle filesystem errors

15 csvData <- try (BS.readFile pathIn) :: IO (Either IOError BS.ByteString)

16 case csvData of

17− Left err -> return $ Left (ImportError $ T.pack (show err))

17+ Left err -> pure $ Left (ImportError (ImportFileError (T.pack (show err))))

18 Right csvData' -> case csvAsRelation attrs tConsMap csvData' of

19− Left err -> return $ Left (ParseError $ T.pack (show err))

19+ Left err -> pure $ Left (ParseError $ T.pack (show err))

20− Right csvRel -> return $ Right (Insert relVarName (ExistingRelation csvRel))

20+ Right csvRel -> pure $ Right (Insert relVarName (ExistingRelation csvRel))

21

22importCSVP :: Parser RelVarDataImportOperator

23importCSVP = do

src/bin/TutorialD/Interpreter/Import/TutorialD.hs+70−17

@@ -9,25 +9,78 @@ import qualified Data.Text as T

9import Control.Exception

10import qualified Data.ByteString as BS

11import qualified Data.Text.Encoding as TE

12+import qualified Text.URI as URI

13+import Text.URI (URI)

14+import Crypto.Hash.SHA256

15+import Data.ByteString.Base16 as B16

16+import Network.HTTP.Simple

17+import Network.HTTP.Types

12−--import a file containing TutorialD database context expressions

18+--import a file containing TutorialD database context expressions via local files or HTTP/HTTPS

13

19

14−importTutorialD :: FilePath -> IO (Either RelationalError DatabaseContextExpr)

20+importTutorialDFromFile :: URI -> HashVerification -> IO (Either RelationalError DatabaseContextExpr)

15−importTutorialD pathIn = do

21+importTutorialDFromFile fileURI mHash = do

22+ case URI.uriPath fileURI of

23+ Just (False, _) -> do

16− eTutdBytes <- try (BS.readFile pathIn) :: IO (Either IOError BS.ByteString)

24+ eTutdBytes <- try (BS.readFile filePath) :: IO (Either IOError BS.ByteString)

17− case eTutdBytes of

25+ case eTutdBytes of

18− Left err -> return $ Left (ImportError $ T.pack (show err))

26+ Left err -> pure $ Left (ImportError (ImportFileError (T.pack (show err))))

27+ Right tutdBytes ->

28+ case validateBytes tutdBytes mHash of

29+ Left err -> pure (Left err)

19− Right tutdBytes ->

30+ Right tutdBytes' -> importTutorialDBytes tutdBytes'

31+ _ -> pure (Left (ImportError (InvalidFileURIError (URI.render fileURI))))

32+ where

33+ filePath = drop (length ("file://" :: String)) (URI.renderStr fileURI)

34+

35+

36+importTutorialDBytes :: BS.ByteString -> IO (Either RelationalError DatabaseContextExpr)

37+importTutorialDBytes tutdBytes =

20− case TE.decodeUtf8' tutdBytes of

38+ case TE.decodeUtf8' tutdBytes of

21− Left err -> pure (Left (ImportError $ T.pack (show err)))

39+ Left err -> pure (Left (ImportError (ImportFileDecodeError (T.pack (show err)))))

22− Right tutdUtf8 ->

40+ Right tutdUtf8 ->

23− case parse multipleDatabaseContextExprP "import" tutdUtf8 of

41+ case parse (multipleDatabaseContextExprP <* eof) "import" tutdUtf8 of

24− --parseErrorPretty is new in megaparsec 5

42+ --parseErrorPretty is new in megaparsec 5

25− Left err -> pure (Left (PM36E.ParseError (T.pack (show err))))

43+ Left err -> pure (Left (PM36E.ParseError (T.pack (errorBundlePretty err))))

26− Right expr -> pure (Right expr)

44+ Right expr -> pure (Right expr)

27−

45+

46+importTutorialDViaHTTP :: URI -> HashVerification -> IO (Either RelationalError DatabaseContextExpr)

47+importTutorialDViaHTTP uri mHash = do

48+ reqURI <- parseRequest (URI.renderStr uri)

49+ response <- httpBS reqURI

50+ let scode = getResponseStatus response

51+ if scode == ok200 then

52+ let byteBody = getResponseBody response in

53+ case validateBytes byteBody mHash of

54+ Right byteBody' -> do

55+ importTutorialDBytes byteBody'

56+ Left err -> pure (Left err)

57+ else

58+ pure (Left (ImportError (ImportDownloadError (T.pack ("download failed: " <> show scode)))))

59+

60+validateBytes :: BS.ByteString -> HashVerification -> Either RelationalError BS.ByteString

61+validateBytes tutdBytes mHash =

62+ case mHash of

63+ Nothing -> pure tutdBytes

64+ Just expectedHashText ->

65+ case B16.decode (TE.encodeUtf8 expectedHashText) of

66+ Left _ -> Left (ImportError (InvalidSHA256Error expectedHashText))

67+ Right expectedHash | hashBytes == expectedHash -> pure tutdBytes

68+ | otherwise ->

69+ let p = TE.decodeUtf8 . B16.encode in

70+ Left (ImportError (SHA256MismatchError (p expectedHash) (p hashBytes)))

71+ where

72+ hashBytes = hash tutdBytes

73+

74+

28tutdImportP :: Parser DatabaseContextDataImportOperator

75tutdImportP :: Parser DatabaseContextDataImportOperator

29tutdImportP = do

76tutdImportP = do

30 reserved ":importtutd"

77 reserved ":importtutd"

31− path <- quotedString

78+ uri <- quoted URI.parser

32 spaceConsumer

79 spaceConsumer

80+ mhash <- optional (quoted hex)

81+ handler <- case URI.unRText <$> URI.uriScheme uri of

82+ Nothing -> fail "URI scheme missing"

83+ Just "file" -> pure importTutorialDFromFile

84+ Just scheme | scheme `elem` ["http", "https"] -> pure importTutorialDViaHTTP

85+ | otherwise -> fail ( "unsupported URI scheme: " <> show scheme)

33− return $ DatabaseContextDataImportOperator (T.unpack path) importTutorialD

86+ pure $ DatabaseContextDataImportOperator uri mhash handler

src/bin/TutorialD/Interpreter/RODatabaseContextOperator.hs+33−16

@@ -1,13 +1,16 @@

1{-# LANGUAGE GADTs #-}

2module TutorialD.Interpreter.RODatabaseContextOperator where

3import ProjectM36.Base

4+import ProjectM36.Relation

4import qualified ProjectM36.DataFrame as DF

5import qualified ProjectM36.DataFrame as DF

5import ProjectM36.Error

6import ProjectM36.Error

7+import ProjectM36.Tuple

6import ProjectM36.InclusionDependency

8import ProjectM36.InclusionDependency

7import qualified ProjectM36.Client as C

9import qualified ProjectM36.Client as C

8import TutorialD.Interpreter.Base

10import TutorialD.Interpreter.Base

9import TutorialD.Interpreter.RelationalExpr

11import TutorialD.Interpreter.RelationalExpr

10import TutorialD.Interpreter.DatabaseContextExpr

12import TutorialD.Interpreter.DatabaseContextExpr

13+import TutorialD.Printer

11import Control.Monad.State

14import Control.Monad.State

12import qualified Data.Text as T

15import qualified Data.Text as T

13import ProjectM36.Relation.Show.Gnuplot

16import ProjectM36.Relation.Show.Gnuplot

@@ -19,7 +22,7 @@ data RODatabaseContextOperator where

19 ShowRelation :: RelationalExpr -> RODatabaseContextOperator

22 ShowRelation :: RelationalExpr -> RODatabaseContextOperator

20 PlotRelation :: RelationalExpr -> RODatabaseContextOperator

23 PlotRelation :: RelationalExpr -> RODatabaseContextOperator

21 ShowRelationType :: RelationalExpr -> RODatabaseContextOperator

24 ShowRelationType :: RelationalExpr -> RODatabaseContextOperator

22− ShowConstraint :: StringType -> RODatabaseContextOperator

25+ ShowConstraints :: StringType -> RODatabaseContextOperator

23 ShowPlan :: DatabaseContextExpr -> RODatabaseContextOperator

26 ShowPlan :: DatabaseContextExpr -> RODatabaseContextOperator

24 ShowTypes :: RODatabaseContextOperator

27 ShowTypes :: RODatabaseContextOperator

25 ShowRelationVariables :: RODatabaseContextOperator

28 ShowRelationVariables :: RODatabaseContextOperator

@@ -31,44 +34,44 @@ data RODatabaseContextOperator where

31

34

32typeP :: Parser RODatabaseContextOperator

35typeP :: Parser RODatabaseContextOperator

33typeP = do

36typeP = do

34− reservedOp ":type"

37+ colonOp ":type"

35 ShowRelationType <$> relExprP

38 ShowRelationType <$> relExprP

36

39

37showRelP :: Parser RODatabaseContextOperator

40showRelP :: Parser RODatabaseContextOperator

38showRelP = do

41showRelP = do

39− reservedOp ":showexpr"

42+ colonOp ":showexpr"

40 ShowRelation <$> relExprP

43 ShowRelation <$> relExprP

41

44

42showPlanP :: Parser RODatabaseContextOperator

45showPlanP :: Parser RODatabaseContextOperator

43showPlanP = do

46showPlanP = do

44− reservedOp ":showplan"

47+ colonOp ":showplan"

45 ShowPlan <$> databaseContextExprP

48 ShowPlan <$> databaseContextExprP

46

49

47showTypesP :: Parser RODatabaseContextOperator

50showTypesP :: Parser RODatabaseContextOperator

48−showTypesP = reserved ":showtypes" >> pure ShowTypes

51+showTypesP = colonOp ":showtypes" >> pure ShowTypes

49

52

50showRelationVariables :: Parser RODatabaseContextOperator

53showRelationVariables :: Parser RODatabaseContextOperator

51−showRelationVariables = reserved ":showrelvars" >> pure ShowRelationVariables

54+showRelationVariables = colonOp ":showrelvars" >> pure ShowRelationVariables

52

55

53showAtomFunctionsP :: Parser RODatabaseContextOperator

56showAtomFunctionsP :: Parser RODatabaseContextOperator

54−showAtomFunctionsP = reserved ":showatomfunctions" >> pure ShowAtomFunctions

57+showAtomFunctionsP = colonOp ":showatomfunctions" >> pure ShowAtomFunctions

55

58

56showDatabaseContextFunctionsP :: Parser RODatabaseContextOperator

59showDatabaseContextFunctionsP :: Parser RODatabaseContextOperator

57−showDatabaseContextFunctionsP = reserved ":showdatabasecontextfunctions" >> pure ShowDatabaseContextFunctions

60+showDatabaseContextFunctionsP = colonOp ":showdatabasecontextfunctions" >> pure ShowDatabaseContextFunctions

58

61

59quitP :: Parser RODatabaseContextOperator

62quitP :: Parser RODatabaseContextOperator

60quitP = do

63quitP = do

61− reservedOp ":quit"

64+ colonOp ":quit"

62 return Quit

65 return Quit

63

66

64showConstraintsP :: Parser RODatabaseContextOperator

67showConstraintsP :: Parser RODatabaseContextOperator

65showConstraintsP = do

68showConstraintsP = do

66− reservedOp ":constraints"

69+ colonOp ":constraints"

67− ShowConstraint <$> option "" identifier

70+ ShowConstraints <$> option "" identifier

68

71

69plotRelExprP :: Parser RODatabaseContextOperator

72plotRelExprP :: Parser RODatabaseContextOperator

70plotRelExprP = do

73plotRelExprP = do

71− reserved ":plotexpr"

74+ colonOp ":plotexpr"

72 PlotRelation <$> relExprP

75 PlotRelation <$> relExprP

73

76

74roDatabaseContextOperatorP :: Parser RODatabaseContextOperator

77roDatabaseContextOperatorP :: Parser RODatabaseContextOperator

@@ -106,15 +109,16 @@ evalRODatabaseContextOp sessionId conn (PlotRelation expr) = do

106 err <- plotRelation rel

109 err <- plotRelation rel

107 when (isJust err) $ print err

110 when (isJust err) $ print err

108

111

109−evalRODatabaseContextOp sessionId conn (ShowConstraint name) = do

112+evalRODatabaseContextOp sessionId conn (ShowConstraints name) = do

110 eIncDeps <- C.inclusionDependencies sessionId conn

113 eIncDeps <- C.inclusionDependencies sessionId conn

111 let val = case eIncDeps of

114 let val = case eIncDeps of

112 Left err -> Left err

115 Left err -> Left err

113 Right incDeps -> case name of

116 Right incDeps -> case name of

114− "" -> inclusionDependenciesAsRelation incDeps

117+ "" -> inclusionDependenciesAsRelation incDeps >>= renderRelExprsInIncDeps

115 depName -> case M.lookup depName incDeps of

118 depName -> case M.lookup depName incDeps of

116 Nothing -> Left (InclusionDependencyNameNotInUseError depName)

119 Nothing -> Left (InclusionDependencyNameNotInUseError depName)

120+ Just dep ->

117− Just dep -> inclusionDependenciesAsRelation (M.singleton depName dep)

121+ inclusionDependenciesAsRelation (M.singleton depName dep) >>= renderRelExprsInIncDeps

118 pure $ case val of

122 pure $ case val of

119 Left err -> DisplayErrorResult (T.pack (show err))

123 Left err -> DisplayErrorResult (T.pack (show err))

120 Right rel -> DisplayRelationResult rel

124 Right rel -> DisplayRelationResult rel

@@ -164,7 +168,7 @@ interpretRODatabaseContextOp sessionId conn tutdstring = case parse roDatabaseCo

164

168

165showDataFrameP :: Parser RODatabaseContextOperator

169showDataFrameP :: Parser RODatabaseContextOperator

166showDataFrameP = do

170showDataFrameP = do

167− reservedOp ":showdataframe"

171+ colonOp ":showdataframe"

168 relExpr <- relExprP

172 relExpr <- relExprP

169 reservedOp "orderby"

173 reservedOp "orderby"

170 attrOrdersExpr <- attrOrdersExprP

174 attrOrdersExpr <- attrOrdersExprP

@@ -191,3 +195,16 @@ attrOrderExprP = DF.AttributeOrderExpr <$> identifier <*> orderP

191

195

192orderP :: Parser DF.Order

196orderP :: Parser DF.Order

193orderP = try (reservedOp "ascending" >> pure DF.AscendingOrder) <|> try (reservedOp "descending" >> pure DF.DescendingOrder) <|> pure DF.AscendingOrder

197orderP = try (reservedOp "ascending" >> pure DF.AscendingOrder) <|> try (reservedOp "descending" >> pure DF.DescendingOrder) <|> pure DF.AscendingOrder

198+

199+-- render RelationalExprAtoms as TutorialD

200+renderRelExprsInIncDeps :: Relation -> Either RelationalError Relation

201+renderRelExprsInIncDeps = relMogrify tupMapper attrs

202+ where

203+ tupMapper tup = pure $ mkRelationTupleFromMap (M.map mapper (tupleToMap tup))

204+ mapper (RelationalExprAtom expr) = TextAtom (T.pack (show (prettyRelationalExpr expr)))

205+ mapper atom = atom

206+ attrs = C.attributesFromList [Attribute "name" TextAtomType,

207+ Attribute "sub" TextAtomType,

208+ Attribute "super" TextAtomType

209+ ]

210+

src/bin/TutorialD/Interpreter/RelationalExpr.hs+77−44

@@ -1,6 +1,11 @@

1+{-# LANGUAGE CPP #-}

1module TutorialD.Interpreter.RelationalExpr where

2module TutorialD.Interpreter.RelationalExpr where

2import Text.Megaparsec

3import Text.Megaparsec

4+#if MIN_VERSION_megaparsec(7,0,0)

5+import Control.Monad.Combinators.Expr

6+#else

3import Text.Megaparsec.Expr

7import Text.Megaparsec.Expr

8+#endif

4import ProjectM36.Base

9import ProjectM36.Base

5import TutorialD.Interpreter.Base

10import TutorialD.Interpreter.Base

6import TutorialD.Interpreter.Types

11import TutorialD.Interpreter.Types

@@ -12,26 +17,36 @@ import ProjectM36.MiscUtils

12

17

13--used in projection

18--used in projection

14attributeListP :: RelationalMarkerExpr a => Parser (AttributeNamesBase a)

19attributeListP :: RelationalMarkerExpr a => Parser (AttributeNamesBase a)

15−attributeListP =

20+attributeListP =

16 (reservedOp "all but" >>

21 (reservedOp "all but" >>

17− InvertedAttributeNames . S.fromList <$> sepBy identifier comma) <|>

22+ InvertedAttributeNames . S.fromList <$> sepBy attributeNameP comma) <|>

23+

18 (reservedOp "all from" >>

24 (reservedOp "all from" >>

19 RelationalExprAttributeNames <$> relExprP) <|>

25 RelationalExprAttributeNames <$> relExprP) <|>

26+

27+ (reservedOp "union of" >>

28+ UnionAttributeNames <$> braces attributeListP <*> braces attributeListP) <|>

29+

30+ (reservedOp "intersection of" >>

31+ IntersectAttributeNames <$> braces attributeListP <*> braces attributeListP) <|>

32+

20− (AttributeNames . S.fromList <$> sepBy identifier comma)

33+ (AttributeNames . S.fromList <$> sepBy attributeNameP comma)

34+

21

35

22makeRelationP :: RelationalMarkerExpr a => Parser (RelationalExprBase a)

36makeRelationP :: RelationalMarkerExpr a => Parser (RelationalExprBase a)

23makeRelationP = do

37makeRelationP = do

24 reserved "relation"

38 reserved "relation"

25 attrExprs <- try (fmap Just makeAttributeExprsP) <|> pure Nothing

39 attrExprs <- try (fmap Just makeAttributeExprsP) <|> pure Nothing

26 tupleExprs <- braces (sepBy tupleExprP comma) <|> pure []

40 tupleExprs <- braces (sepBy tupleExprP comma) <|> pure []

41+ marker <- parseMarkerP

27− pure $ MakeRelationFromExprs attrExprs tupleExprs

42+ pure $ MakeRelationFromExprs attrExprs (TupleExprs marker tupleExprs)

43+

28

44

29−

30--abstract data type parser- in this context, the type constructor must not include any type arguments

45--abstract data type parser- in this context, the type constructor must not include any type arguments

31--Either Text Int

46--Either Text Int

32adTypeConstructorP :: Parser TypeConstructor

47adTypeConstructorP :: Parser TypeConstructor

33adTypeConstructorP = do

48adTypeConstructorP = do

34− tConsName <- capitalizedIdentifier

49+ tConsName <- typeConstructorNameP

35 tConsArgs <- many typeConstructorP

50 tConsArgs <- many typeConstructorP

36 pure $ ADTypeConstructor tConsName tConsArgs

51 pure $ ADTypeConstructor tConsName tConsArgs

37

52

@@ -41,25 +56,25 @@ tupleExprP = do

41 attrAssocs <- braces (sepBy tupleAtomExprP comma)

56 attrAssocs <- braces (sepBy tupleAtomExprP comma)

42 --detect duplicate attribute names

57 --detect duplicate attribute names

43 let dupAttrNames = dupes (sort (map fst attrAssocs))

58 let dupAttrNames = dupes (sort (map fst attrAssocs))

44− if not (null dupAttrNames) then

59+ if not (null dupAttrNames) then

45 fail ("Attribute names duplicated: " ++ show dupAttrNames)

60 fail ("Attribute names duplicated: " ++ show dupAttrNames)

46 else

61 else

47 pure (TupleExpr (M.fromList attrAssocs))

62 pure (TupleExpr (M.fromList attrAssocs))

48

63

49tupleAtomExprP :: RelationalMarkerExpr a => Parser (AttributeName, AtomExprBase a)

64tupleAtomExprP :: RelationalMarkerExpr a => Parser (AttributeName, AtomExprBase a)

50tupleAtomExprP = do

65tupleAtomExprP = do

51− attributeName <- identifier

66+ attributeName <- attributeNameP

52 atomExpr <- atomExprP

67 atomExpr <- atomExprP

53 pure (attributeName, atomExpr)

68 pure (attributeName, atomExpr)

54−

69+

55projectP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a)

70projectP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a)

56projectP = Project <$> braces attributeListP

71projectP = Project <$> braces attributeListP

57

72

58renameClauseP :: Parser (T.Text, T.Text)

73renameClauseP :: Parser (T.Text, T.Text)

59renameClauseP = do

74renameClauseP = do

60− oldAttr <- identifier

75+ oldAttr <- attributeNameP

61 reservedOp "as"

76 reservedOp "as"

62− newAttr <- identifier

77+ newAttr <- attributeNameP

63 pure (oldAttr, newAttr)

78 pure (oldAttr, newAttr)

64

79

65renameP :: Parser (RelationalExprBase a -> RelationalExprBase a)

80renameP :: Parser (RelationalExprBase a -> RelationalExprBase a)

@@ -68,7 +83,7 @@ renameP = do

68 renameList <- braces (sepBy renameClauseP comma)

83 renameList <- braces (sepBy renameClauseP comma)

69 case renameList of

84 case renameList of

70 [] -> pure (Restrict TruePredicate) --no-op when rename list is empty

85 [] -> pure (Restrict TruePredicate) --no-op when rename list is empty

71− renames ->

86+ renames ->

72 pure $ \expr -> foldl (\acc (oldAttr, newAttr) -> Rename oldAttr newAttr acc) expr renames

87 pure $ \expr -> foldl (\acc (oldAttr, newAttr) -> Rename oldAttr newAttr acc) expr renames

73

88

74whereClauseP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a)

89whereClauseP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a)

@@ -78,7 +93,7 @@ groupClauseP :: RelationalMarkerExpr a => Parser (AttributeNamesBase a, T.Text)

78groupClauseP = do

93groupClauseP = do

79 attrs <- braces attributeListP

94 attrs <- braces attributeListP

80 reservedOp "as"

95 reservedOp "as"

81− newAttrName <- identifier

96+ newAttrName <- attributeNameP

82 pure (attrs, newAttrName)

97 pure (attrs, newAttrName)

83

98

84groupP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a)

99groupP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a)

@@ -91,26 +106,30 @@ groupP = do

91ungroupP :: Parser (RelationalExprBase a -> RelationalExprBase a)

106ungroupP :: Parser (RelationalExprBase a -> RelationalExprBase a)

92ungroupP = do

107ungroupP = do

93 reservedOp "ungroup"

108 reservedOp "ungroup"

94− Ungroup <$> identifier

109+ Ungroup <$> attributeNameP

95

110

96extendP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a)

111extendP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a)

97extendP = do

112extendP = do

98 reservedOp ":"

113 reservedOp ":"

99− Extend <$> braces extendTupleExpressionP

114+ extends <- braces (sepBy extendTupleExpressionP comma)

100−

115+ case extends of

116+ [] -> pure (Restrict TruePredicate)

117+ extends' ->

118+ pure $ \expr -> foldl (flip Extend) expr extends'

119+

101semijoinP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a -> RelationalExprBase a)

120semijoinP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a -> RelationalExprBase a)

102semijoinP = do

121semijoinP = do

103 reservedOp "semijoin" <|> reservedOp "matching"

122 reservedOp "semijoin" <|> reservedOp "matching"

104− pure (\exprA exprB ->

123+ pure (\exprA exprB ->

105 Project (RelationalExprAttributeNames exprA) (Join exprA exprB))

124 Project (RelationalExprAttributeNames exprA) (Join exprA exprB))

106−

125+

107−antijoinP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a -> RelationalExprBase a)

126+antijoinP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a -> RelationalExprBase a)

108antijoinP = do

127antijoinP = do

109 reservedOp "not matching" <|> reservedOp "antijoin"

128 reservedOp "not matching" <|> reservedOp "antijoin"

110 pure (\exprA exprB ->

129 pure (\exprA exprB ->

111 Difference exprA (

130 Difference exprA (

112 Project (RelationalExprAttributeNames exprA) (Join exprA exprB)))

131 Project (RelationalExprAttributeNames exprA) (Join exprA exprB)))

113−

132+

114relOperators :: RelationalMarkerExpr a => [[Operator Parser (RelationalExprBase a)]]

133relOperators :: RelationalMarkerExpr a => [[Operator Parser (RelationalExprBase a)]]

115relOperators = [

134relOperators = [

116 [Postfix projectP],

135 [Postfix projectP],

@@ -123,15 +142,23 @@ relOperators = [

123 [InfixL antijoinP],

142 [InfixL antijoinP],

124 [InfixL (reservedOp "union" >> return Union)],

143 [InfixL (reservedOp "union" >> return Union)],

125 [InfixL (reservedOp "minus" >> return Difference)],

144 [InfixL (reservedOp "minus" >> return Difference)],

126− [InfixN (reservedOp "=" >> return Equals)],

145+ [InfixN (reservedOp "=" >> return Equals),

146+ InfixN (reservedOp "/=" >> return NotEquals)],

127 [Postfix extendP]

147 [Postfix extendP]

128 ]

148 ]

129

149

130relExprP :: RelationalMarkerExpr a => Parser (RelationalExprBase a)

150relExprP :: RelationalMarkerExpr a => Parser (RelationalExprBase a)

131relExprP = try withMacroExprP <|> makeExprParser relTerm relOperators

151relExprP = try withMacroExprP <|> makeExprParser relTerm relOperators

132

152

153+--allow for additional characters

154+attributeNameP :: Parser AttributeName

155+attributeNameP = uncapitalizedIdentifier

156+

157+relVarNameP :: Parser RelVarName

158+relVarNameP = uncapitalizedIdentifier

159+

133relVarP :: RelationalMarkerExpr a => Parser (RelationalExprBase a)

160relVarP :: RelationalMarkerExpr a => Parser (RelationalExprBase a)

134−relVarP = RelationVariable <$> identifier <*> parseMarkerP

161+relVarP = RelationVariable <$> relVarNameP <*> parseMarkerP

135

162

136relTerm :: RelationalMarkerExpr a => Parser (RelationalExprBase a)

163relTerm :: RelationalMarkerExpr a => Parser (RelationalExprBase a)

137relTerm = parens relExprP

164relTerm = parens relExprP

@@ -152,13 +179,13 @@ restrictionPredicateP = makeExprParser predicateTerm predicateOperators

152 <|> relationalBooleanExprP

179 <|> relationalBooleanExprP

153

180

154relationalBooleanExprP :: RelationalMarkerExpr a => Parser (RestrictionPredicateExprBase a)

181relationalBooleanExprP :: RelationalMarkerExpr a => Parser (RestrictionPredicateExprBase a)

155−relationalBooleanExprP =

182+relationalBooleanExprP =

156 --we can't actually detect if the type is relational boolean, so we just pass it to the next phase

183 --we can't actually detect if the type is relational boolean, so we just pass it to the next phase

157 RelationalExprPredicate <$> (parens relExprP <|> relTerm)

184 RelationalExprPredicate <$> (parens relExprP <|> relTerm)

158−

185+

159restrictionAttributeEqualityP :: RelationalMarkerExpr a => Parser (RestrictionPredicateExprBase a)

186restrictionAttributeEqualityP :: RelationalMarkerExpr a => Parser (RestrictionPredicateExprBase a)

160restrictionAttributeEqualityP = do

187restrictionAttributeEqualityP = do

161− attributeName <- identifier

188+ attributeName <- attributeNameP

162 reservedOp "="

189 reservedOp "="

163 AttributeEqualityPredicate attributeName <$> atomExprP

190 AttributeEqualityPredicate attributeName <$> atomExprP

164

191

@@ -175,7 +202,7 @@ extendTupleExpressionP = attributeExtendTupleExpressionP

175

202

176attributeExtendTupleExpressionP :: RelationalMarkerExpr a => Parser (ExtendTupleExprBase a)

203attributeExtendTupleExpressionP :: RelationalMarkerExpr a => Parser (ExtendTupleExprBase a)

177attributeExtendTupleExpressionP = do

204attributeExtendTupleExpressionP = do

178− newAttr <- identifier

205+ newAttr <- attributeNameP

179 reservedOp ":="

206 reservedOp ":="

180 AttributeExtendTupleExpr newAttr <$> atomExprP

207 AttributeExtendTupleExpr newAttr <$> atomExprP

181

208

@@ -187,33 +214,34 @@ consumeAtomExprP consume = try functionAtomExprP <|>

187 try (parens (constructedAtomExprP True)) <|>

214 try (parens (constructedAtomExprP True)) <|>

188 constructedAtomExprP consume <|>

215 constructedAtomExprP consume <|>

189 attributeAtomExprP <|>

216 attributeAtomExprP <|>

190− nakedAtomExprP <|>

217+ try nakedAtomExprP <|>

191 relationalAtomExprP

218 relationalAtomExprP

219+

192

220

193attributeAtomExprP :: Parser (AtomExprBase a)

221attributeAtomExprP :: Parser (AtomExprBase a)

194attributeAtomExprP = do

222attributeAtomExprP = do

195 _ <- string "@"

223 _ <- string "@"

196− AttributeAtomExpr <$> identifier

224+ AttributeAtomExpr <$> attributeNameP

197

225

198nakedAtomExprP :: Parser (AtomExprBase a)

226nakedAtomExprP :: Parser (AtomExprBase a)

199nakedAtomExprP = NakedAtomExpr <$> atomP

227nakedAtomExprP = NakedAtomExpr <$> atomP

200

228

201constructedAtomExprP :: RelationalMarkerExpr a => Bool -> Parser (AtomExprBase a)

229constructedAtomExprP :: RelationalMarkerExpr a => Bool -> Parser (AtomExprBase a)

202constructedAtomExprP consume = do

230constructedAtomExprP consume = do

203− dConsName <- capitalizedIdentifier

231+ dConsName <- dataConstructorNameP

204 dConsArgs <- if consume then sepBy (consumeAtomExprP False) spaceConsumer else pure []

232 dConsArgs <- if consume then sepBy (consumeAtomExprP False) spaceConsumer else pure []

205 ConstructedAtomExpr dConsName dConsArgs <$> parseMarkerP

233 ConstructedAtomExpr dConsName dConsArgs <$> parseMarkerP

206−

234+

207-- used only for primitive type parsing ?

235-- used only for primitive type parsing ?

208atomP :: Parser Atom

236atomP :: Parser Atom

209−atomP = stringAtomP <|>

237+atomP = stringAtomP <|>

210− doubleAtomP <|>

238+ try doubleAtomP <|>

211− integerAtomP <|>

239+ integerAtomP <|>

212 boolAtomP

240 boolAtomP

213−

241+

214functionAtomExprP :: RelationalMarkerExpr a => Parser (AtomExprBase a)

242functionAtomExprP :: RelationalMarkerExpr a => Parser (AtomExprBase a)

215−functionAtomExprP =

243+functionAtomExprP =

216− FunctionAtomExpr <$> identifier <*> parens (sepBy atomExprP comma) <*> parseMarkerP

244+ FunctionAtomExpr <$> uncapitalizedIdentifier <*> parens (sepBy atomExprP comma) <*> parseMarkerP

217

245

218relationalAtomExprP :: RelationalMarkerExpr a => Parser (AtomExprBase a)

246relationalAtomExprP :: RelationalMarkerExpr a => Parser (AtomExprBase a)

219relationalAtomExprP = RelationAtomExpr <$> relExprP

247relationalAtomExprP = RelationAtomExpr <$> relExprP

@@ -221,25 +249,29 @@ relationalAtomExprP = RelationAtomExpr <$> relExprP

221stringAtomP :: Parser Atom

249stringAtomP :: Parser Atom

222stringAtomP = TextAtom <$> quotedString

250stringAtomP = TextAtom <$> quotedString

223

251

224−doubleAtomP :: Parser Atom

252+doubleAtomP :: Parser Atom

225−doubleAtomP = DoubleAtom <$> try float

253+doubleAtomP = DoubleAtom <$> float

226

254

227integerAtomP :: Parser Atom

255integerAtomP :: Parser Atom

228integerAtomP = IntegerAtom <$> integer

256integerAtomP = IntegerAtom <$> integer

229

257

230boolAtomP :: Parser Atom

258boolAtomP :: Parser Atom

231boolAtomP = do

259boolAtomP = do

232− val <- char 't' <|> char 'f'

260+ v <- identifier

261+ if v == "t" || v == "f" then

233− return $ BoolAtom (val == 't')

262+ pure $ BoolAtom (v == "t")

234−

263+ else

264+ fail "invalid boolAtom"

265+

266+

235relationAtomExprP :: RelationalMarkerExpr a => Parser (AtomExprBase a)

267relationAtomExprP :: RelationalMarkerExpr a => Parser (AtomExprBase a)

236relationAtomExprP = RelationAtomExpr <$> makeRelationP

268relationAtomExprP = RelationAtomExpr <$> makeRelationP

237

269

238withMacroExprP :: RelationalMarkerExpr a => Parser (RelationalExprBase a)

270withMacroExprP :: RelationalMarkerExpr a => Parser (RelationalExprBase a)

239withMacroExprP = do

271withMacroExprP = do

240 reservedOp "with"

272 reservedOp "with"

241− macros <- parens (sepBy1 createMacroP comma)

273+ views <- parens (sepBy1 createMacroP comma)

242− With macros <$> relExprP

274+ With views <$> relExprP

243

275

244createMacroP :: RelationalMarkerExpr a => Parser (WithNameExprBase a, RelationalExprBase a)

276createMacroP :: RelationalMarkerExpr a => Parser (WithNameExprBase a, RelationalExprBase a)

245createMacroP = do

277createMacroP = do

@@ -248,4 +280,5 @@ createMacroP = do

248 expr <- relExprP

280 expr <- relExprP

249 marker <- parseMarkerP

281 marker <- parseMarkerP

250 pure (WithNameExpr name marker, expr)

282 pure (WithNameExpr name marker, expr)

251−

283+

284+

src/bin/TutorialD/Interpreter/SchemaOperator.hs+3−3

@@ -42,7 +42,7 @@ isoRestrictP = do

42 reserved "isorestrict"

43 relVarIn <- qrelVarP

44 relvarsOut <- isoRestrictOutRelVarsP

45− IsoRestrict <$> pure relVarIn <*> restrictionPredicateP <*> pure relvarsOut

45+ IsoRestrict relVarIn <$> restrictionPredicateP <*> pure relvarsOut

46

47isoRestrictOutRelVarsP :: Parser (RelVarName, RelVarName)

48isoRestrictOutRelVarsP = (,) <$> qrelVarP <*> qrelVarP

@@ -55,7 +55,7 @@ isoUnionP = do

55 reserved "isounion"

56 relVarsIn <- isoUnionInRelVarsP

57 relVarsOut <- qrelVarP

58− IsoUnion <$> pure relVarsIn <*> restrictionPredicateP <*> pure relVarsOut

58+ IsoUnion relVarsIn <$> restrictionPredicateP <*> pure relVarsOut

59

60isoRenameP :: Parser SchemaIsomorph

61isoRenameP = do

@@ -74,4 +74,4 @@ isoUnionInRelVarsP = (,) <$> qrelVarP <*> qrelVarP

74evalSchemaOperator :: SessionId -> Connection -> SchemaOperator -> IO (Either RelationalError ())

75evalSchemaOperator sessionId conn (ModifySchemaExpr expr) = executeSchemaExpr sessionId conn expr

76evalSchemaOperator sessionId conn (SetCurrentSchema sname) = setCurrentSchemaName sessionId conn sname

77−

77+

src/bin/TutorialD/Interpreter/TransactionGraphOperator.hs+12−3

@@ -2,8 +2,9 @@

2module TutorialD.Interpreter.TransactionGraphOperator where

3import TutorialD.Interpreter.Base

4import ProjectM36.TransactionGraph hiding (autoMergeToHead)

5−import ProjectM36.Client

5+import ProjectM36.Client as C

6import ProjectM36.Base

7+import ProjectM36.Relation (relationTrue)

7import Data.Functor

8import Data.Functor

8

9

9data ConvenienceTransactionGraphOperator = AutoMergeToHead MergeStrategy HeadName

10data ConvenienceTransactionGraphOperator = AutoMergeToHead MergeStrategy HeadName

@@ -71,6 +72,9 @@ mergeTransactionsP = do

71 reservedOp ":mergetrans"

72 reservedOp ":mergetrans"

72 MergeTransactions <$> mergeTransactionStrategyP <*> identifier <*> identifier

73 MergeTransactions <$> mergeTransactionStrategyP <*> identifier <*> identifier

73

74

75+validateMerkleHashesP :: Parser ROTransactionGraphOperator

76+validateMerkleHashesP = reservedOp ":validatemerklehashes" $> ValidateMerkleHashes

77+

74transactionGraphOpP :: Parser TransactionGraphOperator

78transactionGraphOpP :: Parser TransactionGraphOperator

75transactionGraphOpP =

79transactionGraphOpP =

76 jumpToHeadP

80 jumpToHeadP

@@ -83,7 +87,7 @@ transactionGraphOpP =

83 <|> mergeTransactionsP

87 <|> mergeTransactionsP

84

88

85roTransactionGraphOpP :: Parser ROTransactionGraphOperator

89roTransactionGraphOpP :: Parser ROTransactionGraphOperator

86−roTransactionGraphOpP = showGraphP

90+roTransactionGraphOpP = showGraphP <|> validateMerkleHashesP

87

91

88

92

89

93

@@ -101,6 +105,11 @@ interpretOps newUUID trans@(DisconnectedTransaction _ context) transGraph instri

101

105

102evalROGraphOp :: SessionId -> Connection -> ROTransactionGraphOperator -> IO (Either RelationalError Relation)

106evalROGraphOp :: SessionId -> Connection -> ROTransactionGraphOperator -> IO (Either RelationalError Relation)

103evalROGraphOp sessionId conn ShowGraph = transactionGraphAsRelation sessionId conn

107evalROGraphOp sessionId conn ShowGraph = transactionGraphAsRelation sessionId conn

108+evalROGraphOp sessionId conn ValidateMerkleHashes = do

109+ eVal <- C.validateMerkleHashes sessionId conn

110+ case eVal of

111+ Left err -> pure (Left err)

112+ Right _ -> pure (Right relationTrue)

104

113

105evalConvenienceGraphOp :: SessionId -> Connection -> ConvenienceTransactionGraphOperator -> IO (Either RelationalError ())

114evalConvenienceGraphOp :: SessionId -> Connection -> ConvenienceTransactionGraphOperator -> IO (Either RelationalError ())

106−evalConvenienceGraphOp sessionId conn (AutoMergeToHead strat head') = autoMergeToHead sessionId conn strat head'

115+evalConvenienceGraphOp sessionId conn (AutoMergeToHead strat head') = autoMergeToHead sessionId conn strat head'

src/bin/TutorialD/Interpreter/Types.hs+10−4

@@ -9,18 +9,24 @@ class RelationalMarkerExpr a where

9

10instance RelationalMarkerExpr () where

11 parseMarkerP = pure ()

12−

12+

13+typeConstructorNameP :: Parser TypeConstructorName

14+typeConstructorNameP = capitalizedIdentifier

15+

16+dataConstructorNameP :: Parser DataConstructorName

17+dataConstructorNameP = capitalizedIdentifier

18+

13-- | Upper case names are type names while lower case names are polymorphic typeconstructor arguments.

19-- | Upper case names are type names while lower case names are polymorphic typeconstructor arguments.

14-- data *Either a b* = Left a | Right b

20-- data *Either a b* = Left a | Right b

15typeConstructorDefP :: Parser TypeConstructorDef

21typeConstructorDefP :: Parser TypeConstructorDef

16−typeConstructorDefP = ADTypeConstructorDef <$> capitalizedIdentifier <*> typeVarNamesP

22+typeConstructorDefP = ADTypeConstructorDef <$> typeConstructorNameP <*> typeVarNamesP

17

23

18typeVarNamesP :: Parser [TypeVarName]

24typeVarNamesP :: Parser [TypeVarName]

19typeVarNamesP = many uncapitalizedIdentifier

25typeVarNamesP = many uncapitalizedIdentifier

20

26

21-- data Either a b = *Left a* | *Right b*

27-- data Either a b = *Left a* | *Right b*

22dataConstructorDefP :: Parser DataConstructorDef

28dataConstructorDefP :: Parser DataConstructorDef

23−dataConstructorDefP = DataConstructorDef <$> capitalizedIdentifier <*> many dataConstructorDefArgP

29+dataConstructorDefP = DataConstructorDef <$> typeConstructorNameP <*> many dataConstructorDefArgP

24

30

25-- data *Either a b* = Left *a* | Right *b*

31-- data *Either a b* = Left *a* | Right *b*

26dataConstructorDefArgP :: Parser DataConstructorDefArg

32dataConstructorDefArgP :: Parser DataConstructorDefArg

@@ -47,7 +53,7 @@ typeConstructorP = relationTypeConstructorP <|>

47 monoTypeConstructorP

53 monoTypeConstructorP

48

54

49monoTypeConstructorP :: Parser TypeConstructor

55monoTypeConstructorP :: Parser TypeConstructor

50−monoTypeConstructorP = ADTypeConstructor <$> capitalizedIdentifier <*> pure [] <|>

56+monoTypeConstructorP = ADTypeConstructor <$> typeConstructorNameP <*> pure [] <|>

51 TypeVariable <$> uncapitalizedIdentifier

57 TypeVariable <$> uncapitalizedIdentifier

52

58

53

59

src/bin/TutorialD/Printer.hsnew file+165

@@ -0,0 +1,165 @@

1+{-# OPTIONS_GHC -fno-warn-orphans #-}

2+{-# LANGUAGE FlexibleInstances #-}

3+{-# LANGUAGE OverloadedStrings #-}

4+{-# LANGUAGE ScopedTypeVariables #-}

5+{-# LANGUAGE TypeApplications #-}

6+module TutorialD.Printer where

7+import ProjectM36.Base

8+import ProjectM36.Attribute as A hiding (null)

9+import Data.Text.Prettyprint.Doc

10+import qualified Data.Set as S hiding (fromList)

11+import qualified Data.Vector as V

12+import qualified Data.Map.Strict as M

13+import Data.Time.Calendar

14+import Data.Time.Clock.POSIX

15+import qualified Data.ByteString.Base64 as B64

16+import qualified Data.Text.Encoding as TE

17+

18+instance Pretty Atom where

19+ pretty (IntegerAtom x) = pretty x

20+ pretty (IntAtom x) = "int" <> parensList [pretty x]

21+ pretty (DoubleAtom x) = pretty x

22+ pretty (TextAtom x) = dquotes (pretty x)

23+ pretty (DayAtom x) = "fromGregorian" <> parensList [pretty a, pretty b, pretty c]

24+ where

25+ (a,b,c) = toGregorian x

26+ pretty (DateTimeAtom time) = "dateTimeFromEpochSeconds" <> parensList [pretty @Integer (round (utcTimeToPOSIXSeconds time))]

27+ pretty (ByteStringAtom bs) = "bytestring" <> parensList [dquotes (pretty (TE.decodeUtf8 (B64.encode bs)))]

28+ pretty (BoolAtom x) = if x then "t" else "f"

29+ pretty (RelationAtom x) = pretty x

30+ pretty (RelationalExprAtom re) = pretty re

31+ pretty (ConstructedAtom n _ as) = pretty n <+> prettyList as

32+

33+instance Pretty AtomExpr where

34+ pretty (AttributeAtomExpr attrName) = pretty attrName

35+ pretty (NakedAtomExpr atom) = pretty atom

36+ pretty (FunctionAtomExpr atomFuncName' atomExprs _) = pretty atomFuncName' <> prettyAtomExprsAsArguments atomExprs

37+ pretty (RelationAtomExpr relExpr) = pretty relExpr

38+ pretty (ConstructedAtomExpr dName [] _) = pretty dName

39+ pretty (ConstructedAtomExpr dName atomExprs _) = pretty dName <+> hsep (map prettyAtomExpr atomExprs)

40+

41+prettyAtomExpr :: AtomExpr -> Doc ann

42+prettyAtomExpr atomExpr =

43+ case atomExpr of

44+ AttributeAtomExpr attrName -> "@" <> pretty attrName

45+ ConstructedAtomExpr dConsName [] () -> pretty dConsName

46+ ConstructedAtomExpr dConsName atomExprs () -> parens (pretty dConsName <+> hsep (map prettyAtomExpr atomExprs))

47+ _ -> pretty atomExpr

48+

49+prettyAtomExprsAsArguments :: [AtomExpr] -> Doc ann

50+prettyAtomExprsAsArguments = align . parensList . map addAt

51+ where addAt (atomExpr :: AtomExpr) =

52+ case atomExpr of

53+ AttributeAtomExpr attrName -> "@" <> pretty attrName

54+ _ -> pretty atomExpr

55+

56+instance Pretty TupleExpr where

57+ pretty (TupleExpr map') = "tuple" <> bracesList (Prelude.map (\(attrName,atom)-> pretty attrName <+> pretty atom) (M.toList map'))

58+

59+instance Pretty RelationTuple where

60+ pretty (RelationTuple attrs atoms) = "tuple" <> bracesList (zipWith (\x y-> pretty x <+> pretty y) (V.toList (attributeNames attrs)) (V.toList atoms))

61+

62+instance Pretty Relation where

63+ pretty (Relation attrs tupSet) | attrs == mempty && null (asList tupSet) = "false"

64+ pretty (Relation attrs tupSet) | attrs == mempty && asList tupSet == [RelationTuple mempty mempty] = "true"

65+ pretty (Relation attrs tupSet) = "relation" <> prettyBracesList (A.toList attrs) <> prettyBracesList (asList tupSet)

66+

67+instance Pretty Attribute where

68+ pretty (Attribute n aTy) = pretty n <+> pretty (show aTy) -- workaround

69+

70+instance Pretty RelationalExpr where

71+ pretty (RelationVariable n _) = pretty n

72+ pretty (ExistingRelation r) = pretty r

73+ pretty (NotEquals a b) = pretty' a <+> "!=" <+> pretty' b

74+ pretty (Equals a b) = pretty' a <+> "==" <+> pretty' b

75+ pretty (Project ns r) = pretty' (ignoreProjects r) <> pretty ns

76+ pretty (Extend ext r) = collectExtends r <> pretty ext <> "}"

77+ pretty (MakeRelationFromExprs Nothing (TupleExprs () tupExprs)) = "relation" <> prettyBracesList tupExprs

78+ pretty (MakeRelationFromExprs (Just attrExprs) (TupleExprs () tupExprs)) = "relation" <> prettyBracesList attrExprs <> prettyBracesList tupExprs

79+ pretty (MakeStaticRelation attrs tupSet) = "relation" <> prettyBracesList (A.toList attrs) <> prettyBracesList (asList tupSet)

80+ pretty (Union a b) = parens $ pretty' a <+> "union" <+> pretty' b

81+ pretty (Join a b) = parens $ pretty' a <+> "join" <+> pretty' b

82+ pretty (Rename n1 n2 relExpr) = parens $ pretty relExpr <+> "rename" <+> braces (pretty n1 <+> "as" <+> pretty n2)

83+ pretty (Difference a b) = parens $ pretty' a <+> "minus" <+> pretty' b

84+ pretty (Group attrNames attrName relExpr) = parens $ pretty relExpr <+> "group" <+> parens (pretty attrNames <+> "as" <+> pretty attrName)

85+ pretty (Ungroup attrName relExpr) = parens $ pretty' relExpr <+> "ungroup" <+> pretty attrName

86+ pretty (Restrict resPreExpr relExpr) = parens $ pretty' relExpr <+> "where" <+> pretty resPreExpr

87+ pretty (With pairs a) = "with" <+> parensList (map (\(name,expr)-> pretty name <+> "as" <+> pretty expr) pairs) <+> pretty' a

88+

89+-- relvar:{a:=?}:{b:=?}:... in ADTs => relvar:{a:=?, b:=?, ...} in Doc ann

90+collectExtends :: RelationalExpr -> Doc ann

91+collectExtends (Extend ext r) = collectExtends r <> pretty ext <> ", "

92+collectExtends r = pretty r <> ":{"

93+

94+--relvar{a,b,c,...}{a,b,...}..{a} => relvar{a}

95+ignoreProjects :: RelationalExpr -> RelationalExpr

96+ignoreProjects (Project _ r) = ignoreProjects r

97+ignoreProjects r = r

98+

99+prettyRelationalExpr :: RelationalExpr -> Doc n

100+prettyRelationalExpr (RelationVariable n _) = pretty n

101+prettyRelationalExpr r = parens (pretty r)

102+

103+pretty' :: RelationalExpr -> Doc n

104+pretty' = prettyRelationalExpr

105+

106+instance Pretty AttributeNames where

107+ pretty (AttributeNames attrNames) = prettyBracesList (S.toList attrNames)

108+ pretty (InvertedAttributeNames attrNames) = braces $ "all but" <+> concatWith (surround ", ") (map pretty (S.toList attrNames))

109+ pretty (RelationalExprAttributeNames relExpr) = braces $ "all from" <+> pretty relExpr

110+ pretty (UnionAttributeNames aAttrNames bAttrNames) = braces ("union of" <+> pretty aAttrNames <+> pretty bAttrNames)

111+ pretty (IntersectAttributeNames aAttrNames bAttrNames) = braces ("intersection of" <+> pretty aAttrNames <+> pretty bAttrNames)

112+

113+instance Pretty AttributeExpr where

114+ pretty (NakedAttributeExpr attr) = pretty attr

115+ pretty (AttributeAndTypeNameExpr name typeCons _) = pretty name <+> pretty typeCons

116+

117+instance Pretty TypeConstructor where

118+ pretty (ADTypeConstructor tcName []) = pretty tcName

119+ pretty (ADTypeConstructor tcName tConsArgs) = pretty tcName <+> hsep (map pretty tConsArgs)

120+ pretty (PrimitiveTypeConstructor tcName atomType') = pretty tcName <+> pretty atomType'

121+ pretty (RelationAtomTypeConstructor attrExprs) = "relation" <> prettyBracesList attrExprs

122+ pretty (TypeVariable x) = pretty x

123+

124+instance Pretty AtomType where

125+ pretty IntAtomType = "Int"

126+ pretty IntegerAtomType = "Integer"

127+ pretty DoubleAtomType = "Double"

128+ pretty TextAtomType = "Text"

129+ pretty DayAtomType = "Day"

130+ pretty DateTimeAtomType = "DateTime"

131+ pretty ByteStringAtomType = "ByteString"

132+ pretty BoolAtomType = "Bool"

133+ pretty (RelationAtomType attrs) = "relation " <+> prettyBracesList (A.toList attrs)

134+ pretty (ConstructedAtomType tcName tvMap) = pretty tcName <+> hsep (map pretty (M.toList tvMap)) --order matters

135+ pretty RelationalExprAtomType = "RelationalExpr"

136+ pretty (TypeVariableType x) = pretty x

137+

138+instance Pretty ExtendTupleExpr where

139+ pretty (AttributeExtendTupleExpr attrName atomExpr) = pretty attrName <> ":=" <> pretty atomExpr

140+

141+

142+instance Pretty RestrictionPredicateExpr where

143+ pretty TruePredicate = "true"

144+ pretty (AndPredicate a b) = pretty a <+> "and" <+> pretty b

145+ pretty (OrPredicate a b) = pretty a <+> "or" <+> pretty b

146+ pretty (NotPredicate a) = "not" <+> pretty a

147+ pretty (RelationalExprPredicate relExpr) = pretty relExpr

148+ pretty (AtomExprPredicate atomExpr) = pretty atomExpr

149+ pretty (AttributeEqualityPredicate attrName atomExpr) = pretty attrName <> "=" <> pretty atomExpr

150+

151+instance Pretty WithNameExpr where

152+ pretty (WithNameExpr name _) = pretty name

153+

154+bracesList :: [Doc ann] -> Doc ann

155+bracesList = group . encloseSep (flatAlt "{ " "{") (flatAlt " }" "}") ", "

156+

157+prettyBracesList :: Pretty a => [a] -> Doc ann

158+prettyBracesList = align . bracesList . map pretty

159+

160+parensList :: [Doc ann] -> Doc ann

161+parensList = group . encloseSep (flatAlt "( " "(") (flatAlt " )" ")") ", "

162+

163+prettyParensList :: Pretty a => [a] -> Doc ann

164+prettyParensList = align . parensList . map pretty

165+

src/bin/TutorialD/tutd.hs+16−18

@@ -5,9 +5,13 @@ import ProjectM36.Client

5import ProjectM36.Server.ParseArgs

6import ProjectM36.Server

7import System.IO

8+import GHC.IO.Encoding

8import Options.Applicative

9import Options.Applicative

9import System.Exit

10import System.Exit

11+import Control.Monad

12+#if __GLASGOW_HASKELL__ < 804

10import Data.Monoid

13import Data.Monoid

14+#endif

11import Data.Maybe

15import Data.Maybe

12import qualified Data.Text as T

16import qualified Data.Text as T

13

17

@@ -18,7 +22,7 @@ import qualified Data.Text as T

18

22

19parseArgs :: Parser InterpreterConfig

23parseArgs :: Parser InterpreterConfig

20parseArgs = LocalInterpreterConfig <$> parsePersistenceStrategy <*> parseHeadName <*> parseTutDExec <*> many parseGhcPkgPath <*> parseCheckFS <|>

24parseArgs = LocalInterpreterConfig <$> parsePersistenceStrategy <*> parseHeadName <*> parseTutDExec <*> many parseGhcPkgPath <*> parseCheckFS <|>

21− RemoteInterpreterConfig <$> parseNodeId <*> parseDatabaseName <*> parseHeadName <*> parseTutDExec <*> parseCheckFS

25+ RemoteInterpreterConfig <$> parseHostname "127.0.0.1" <*> parsePort defaultServerPort <*> parseDatabaseName <*> parseHeadName <*> parseTutDExec <*> parseCheckFS

22

26

23parseHeadName :: Parser HeadName

27parseHeadName :: Parser HeadName

24parseHeadName = option auto (long "head" <>

28parseHeadName = option auto (long "head" <>

@@ -27,19 +31,6 @@ parseHeadName = option auto (long "head" <>

27 value "master"

31 value "master"

28 )

32 )

29

33

30−parseNodeId :: Parser NodeId

31−parseNodeId = createNodeId <$>

32− strOption (long "host" <>

33− short 'h' <>

34− help "Remote host name" <>

35− metavar "HOSTNAME" <>

36− value "127.0.0.1") <*>

37− option auto (long "port" <>

38− metavar "PORT NUMBER" <>

39− short 'p' <>

40− help "Remote port" <>

41− value defaultServerPort)

42−

43--just execute some tutd and exit

34--just execute some tutd and exit

44parseTutDExec :: Parser (Maybe TutorialDExec)

35parseTutDExec :: Parser (Maybe TutorialDExec)

45parseTutDExec = optional $ strOption (long "exec-tutd" <>

36parseTutDExec = optional $ strOption (long "exec-tutd" <>

@@ -53,19 +44,19 @@ opts = info (parseArgs <**> helpOption) idm

53

44

54connectionInfoForConfig :: InterpreterConfig -> ConnectionInfo

45connectionInfoForConfig :: InterpreterConfig -> ConnectionInfo

55connectionInfoForConfig (LocalInterpreterConfig pStrategy _ _ ghcPkgPaths _) = InProcessConnectionInfo pStrategy outputNotificationCallback ghcPkgPaths

46connectionInfoForConfig (LocalInterpreterConfig pStrategy _ _ ghcPkgPaths _) = InProcessConnectionInfo pStrategy outputNotificationCallback ghcPkgPaths

56−connectionInfoForConfig (RemoteInterpreterConfig remoteNodeId remoteDBName _ _ _) = RemoteProcessConnectionInfo remoteDBName remoteNodeId outputNotificationCallback

47+connectionInfoForConfig (RemoteInterpreterConfig remoteHost remotePort remoteDBName _ _ _) = RemoteConnectionInfo remoteDBName remoteHost (show remotePort) outputNotificationCallback

57

48

58headNameForConfig :: InterpreterConfig -> HeadName

49headNameForConfig :: InterpreterConfig -> HeadName

59headNameForConfig (LocalInterpreterConfig _ headn _ _ _) = headn

50headNameForConfig (LocalInterpreterConfig _ headn _ _ _) = headn

60−headNameForConfig (RemoteInterpreterConfig _ _ headn _ _) = headn

51+headNameForConfig (RemoteInterpreterConfig _ _ _ headn _ _) = headn

61

52

62execTutDForConfig :: InterpreterConfig -> Maybe String

53execTutDForConfig :: InterpreterConfig -> Maybe String

63execTutDForConfig (LocalInterpreterConfig _ _ t _ _) = t

54execTutDForConfig (LocalInterpreterConfig _ _ t _ _) = t

64−execTutDForConfig (RemoteInterpreterConfig _ _ _ t _) = t

55+execTutDForConfig (RemoteInterpreterConfig _ _ _ _ t _) = t

65

56

66checkFSForConfig :: InterpreterConfig -> Bool

57checkFSForConfig :: InterpreterConfig -> Bool

67checkFSForConfig (LocalInterpreterConfig _ _ _ _ c) = c

58checkFSForConfig (LocalInterpreterConfig _ _ _ _ c) = c

68−checkFSForConfig (RemoteInterpreterConfig _ _ _ _ c) = c

59+checkFSForConfig (RemoteInterpreterConfig _ _ _ _ _ c) = c

69

60

70persistenceStrategyForConfig :: InterpreterConfig -> Maybe PersistenceStrategy

61persistenceStrategyForConfig :: InterpreterConfig -> Maybe PersistenceStrategy

71persistenceStrategyForConfig (LocalInterpreterConfig strat _ _ _ _) = Just strat

62persistenceStrategyForConfig (LocalInterpreterConfig strat _ _ _ _) = Just strat

@@ -84,8 +75,15 @@ printWelcome = do

84 putStrLn "A full tutorial is available at:"

75 putStrLn "A full tutorial is available at:"

85 putStrLn "https://github.com/agentm/project-m36/blob/master/docs/tutd_tutorial.markdown"

76 putStrLn "https://github.com/agentm/project-m36/blob/master/docs/tutd_tutorial.markdown"

86

77

78+-- | If the locale is set to ASCII, upgrade it to UTF-8 because tutd outputs UTF-8-encoded attributes. This is especially important in light docker images where the locale data may be missing.

79+setLocaleIfNecessary :: IO ()

80+setLocaleIfNecessary = do

81+ l <- getLocaleEncoding

82+ when (textEncodingName l == "ASCII") (setLocaleEncoding utf8)

83+

87main :: IO ()

84main :: IO ()

88main = do

85main = do

86+ setLocaleIfNecessary

89 interpreterConfig <- execParser opts

87 interpreterConfig <- execParser opts

90 let connInfo = connectionInfoForConfig interpreterConfig

88 let connInfo = connectionInfoForConfig interpreterConfig

91 fscheck <- checkFSType (checkFSForConfig interpreterConfig) (fromMaybe NoPersistence (persistenceStrategyForConfig interpreterConfig))

89 fscheck <- checkFSType (checkFSForConfig interpreterConfig) (fromMaybe NoPersistence (persistenceStrategyForConfig interpreterConfig))

src/bin/benchmark/Handles.hs+25−14

@@ -6,13 +6,15 @@ import Options.Applicative

6import TutorialD.Interpreter

7import TutorialD.Interpreter.Base hiding (Parser, option)

8import qualified Data.Text as T

9+#if __GLASGOW_HASKELL__ < 804

9import Data.Monoid

10import Data.Monoid

11+#endif

10import Control.Monad

12import Control.Monad

11

13

12data HandlesArgs = HandlesArgs {

14data HandlesArgs = HandlesArgs {

13 openCloseCount :: Int,

15 openCloseCount :: Int,

14 transactionCount :: Int,

16 transactionCount :: Int,

15− dbdir :: FilePath,

17+ dbdir :: FilePath,

16 tutdSetup :: String,

18 tutdSetup :: String,

17 tutdIterate :: String

19 tutdIterate :: String

18 }

20 }

@@ -38,13 +40,13 @@ parseTutdIterate = strOption (short 'i' <> long "iterate-tutd" <> value "update

38main :: IO ()

40main :: IO ()

39main = do

41main = do

40 args <- execParser $ info (helper <*> parseArgs) fullDesc

42 args <- execParser $ info (helper <*> parseArgs) fullDesc

41− replicateM_ (openCloseCount args) (runOpenClose

43+ replicateM_ (openCloseCount args) (runOpenClose

42 (T.pack (tutdSetup args))

44 (T.pack (tutdSetup args))

43 (T.pack (tutdIterate args))

45 (T.pack (tutdIterate args))

44− (transactionCount args)

46+ (transactionCount args)

45 (dbdir args))

47 (dbdir args))

46−

48+

47−runOpenClose :: T.Text -> T.Text -> Int -> FilePath -> IO ()

49+runOpenClose :: T.Text -> T.Text -> Int -> FilePath -> IO ()

48runOpenClose tutdSetup' tutdIterate' tCount dbdir' = do

50runOpenClose tutdSetup' tutdIterate' tCount dbdir' = do

49 let connInfo = InProcessConnectionInfo (MinimalPersistence dbdir') emptyNotificationCallback []

51 let connInfo = InProcessConnectionInfo (MinimalPersistence dbdir') emptyNotificationCallback []

50 eConn <- connectProjectM36 connInfo

52 eConn <- connectProjectM36 connInfo

@@ -54,7 +56,7 @@ runOpenClose tutdSetup' tutdIterate' tCount dbdir' = do

54 eSess <- createSessionAtHead conn "master"

56 eSess <- createSessionAtHead conn "master"

55 case eSess of

57 case eSess of

56 Left err -> error (show err)

58 Left err -> error (show err)

57− Right session ->

59+ Right session ->

58 --database setup

60 --database setup

59 case parseTutorialD tutdSetup' of

61 case parseTutorialD tutdSetup' of

60 Left err -> error (show err)

62 Left err -> error (show err)

@@ -62,14 +64,19 @@ runOpenClose tutdSetup' tutdIterate' tCount dbdir' = do

62 res <- evalTutorialD session conn UnsafeEvaluation parsed

64 res <- evalTutorialD session conn UnsafeEvaluation parsed

63 case res of

65 case res of

64 DisplayErrorResult err -> error (T.unpack err)

66 DisplayErrorResult err -> error (T.unpack err)

65− DisplayParseErrorResult _ err -> error (parseErrorPretty err)

67+ DisplayParseErrorResult _ err ->

68+#if MIN_VERSION_megaparsec(7,0,0)

69+ error (errorBundlePretty err)

70+#else

71+ error (parseErrorPretty err)

72+#endif

66− _ -> do

73+ _ -> do

67 replicateM_ tCount (runTransaction tutdIterate' session conn)

74 replicateM_ tCount (runTransaction tutdIterate' session conn)

68 close conn

75 close conn

69 printFdCount

76 printFdCount

70−

77+

71runTransaction :: T.Text -> SessionId -> Connection -> IO ()

78runTransaction :: T.Text -> SessionId -> Connection -> IO ()

72−runTransaction tutdIterate' sess conn =

79+runTransaction tutdIterate' sess conn =

73 --run tutd on every iteration

80 --run tutd on every iteration

74 case parseTutorialD tutdIterate' of

81 case parseTutorialD tutdIterate' of

75 Left err -> error (show err)

82 Left err -> error (show err)

@@ -77,10 +84,14 @@ runTransaction tutdIterate' sess conn =

77 res <- evalTutorialD sess conn UnsafeEvaluation parsed

84 res <- evalTutorialD sess conn UnsafeEvaluation parsed

78 case res of

85 case res of

79 DisplayErrorResult err -> error (T.unpack err)

86 DisplayErrorResult err -> error (T.unpack err)

80− DisplayParseErrorResult _ err -> error (parseErrorPretty err)

87+ DisplayParseErrorResult _ err ->

88+#if MIN_VERSION_megaparsec(7,0,0)

89+ error (errorBundlePretty err)

90+#else

91+ error (parseErrorPretty err)

92+#endif

81− _ -> do

93+ _ -> do

82− eErr <- commit sess conn

94+ eErr <- commit sess conn

83 case eErr of

95 case eErr of

84 Left err -> error (show err)

96 Left err -> error (show err)

85 Right _ -> printFdCount

97 Right _ -> printFdCount

86−

src/bin/benchmark/bigrel.hs+19−8

@@ -1,28 +1,32 @@

1−{-# LANGUAGE FlexibleInstances #-}

1+{-# LANGUAGE FlexibleInstances, CPP #-}

2{-# OPTIONS_GHC -fno-warn-orphans #-}

3import ProjectM36.Base

4import ProjectM36.Relation

5import ProjectM36.DateExamples

6import ProjectM36.Error

7+import ProjectM36.StaticOptimizer

7import qualified ProjectM36.Attribute as A

8import qualified ProjectM36.Attribute as A

8import qualified Data.Text as T

9import qualified Data.Text as T

9--import ProjectM36.Relation.Show.CSV

10--import ProjectM36.Relation.Show.CSV

10import ProjectM36.Relation.Show.HTML

11import ProjectM36.Relation.Show.HTML

11−import TutorialD.Interpreter.DatabaseContextExpr (interpretDatabaseContextExpr)

12import ProjectM36.RelationalExpression

13+import ProjectM36.TransactionGraph

13--import qualified Data.HashSet as HS

14--import qualified Data.HashSet as HS

14--import qualified Data.ByteString.Lazy.Char8 as BS

15--import qualified Data.ByteString.Lazy.Char8 as BS

15--import qualified Data.IntMap as IM

16--import qualified Data.IntMap as IM

16--import qualified Data.Hashable as Hash

17--import qualified Data.Hashable as Hash

17import qualified Data.Vector as V

18import qualified Data.Vector as V

18import Options.Applicative

19import Options.Applicative

19−import qualified Data.Map as M

20import qualified Data.Text.IO as TIO

21import System.IO

22−import Control.Monad.State

23import Control.DeepSeq

22import Control.DeepSeq

24import Data.Text hiding (map)

23import Data.Text hiding (map)

24+import Data.Time.Clock

25+import Data.UUID.V4

26+#if __GLASGOW_HASKELL__ < 804

25import Data.Monoid

27import Data.Monoid

28+#endif

29+

26

30

27{-

31{-

28dumpcsv :: Relation -> IO ()

32dumpcsv :: Relation -> IO ()

@@ -60,13 +64,20 @@ matrixRun (BigrelArgs attributeCount tupleCount tutd) =

60 Right rel -> if tutd == "" then

64 Right rel -> if tutd == "" then

61 putStrLn "Done."

65 putStrLn "Done."

62 else do

66 else do

67+ now <- getCurrentTime

68+ tid <- nextRandom

63 let setx = Assign "x" (ExistingRelation (force rel))

69 let setx = Assign "x" (ExistingRelation (force rel))

64− (context,_,_) = execState (evalDatabaseContextExpr setx) (freshDatabaseState dateExamples)

70+ graph = bootstrapTransactionGraph now tid dateExamples

65− interpreted = interpretDatabaseContextExpr context tutd

71+ env = mkDatabaseContextEvalEnv tid graph

72+ eNewState = runDatabaseContextEvalMonad dateExamples env (optimizeAndEvalDatabaseContextExpr True setx)

66 --plan = interpretRODatabaseContextOp context $ ":showplan " ++ tutd

73 --plan = interpretRODatabaseContextOp context $ ":showplan " ++ tutd

67 --displayOpResult plan

74 --displayOpResult plan

68− case interpreted of

75+ case eNewState of

76+ Right newState -> do

77+ let ctx = dbc_context newState

78+ Right x = optimizeAndEvalRelationalExpr env' (RelationVariable "x" ())

79+ env' = RelationalExprEnv ctx graph Nothing

69− Right context' -> TIO.putStrLn $ relationAsHTML (relationVariables context' M.! "x")

80+ TIO.putStrLn $ relationAsHTML x

70 Left err -> hPrint stderr err

81 Left err -> hPrint stderr err

71

82

72{-

83{-

src/lib/ProjectM36/Arbitrary.hs+6−1

@@ -9,6 +9,7 @@ import ProjectM36.AtomType

9import ProjectM36.Attribute (atomType)

10import ProjectM36.DataConstructorDef as DCD

11import ProjectM36.DataTypes.Interval

12+import ProjectM36.Relation

12import qualified Data.Vector as V

13import qualified Data.Vector as V

13import Data.Text (Text)

14import Data.Text (Text)

14import Test.QuickCheck

15import Test.QuickCheck

@@ -48,6 +49,10 @@ arbitrary' ByteStringAtomType =

48

49

49arbitrary' BoolAtomType =

50arbitrary' BoolAtomType =

50 Right . BoolAtom <$> lift (arbitrary :: Gen Bool)

51 Right . BoolAtom <$> lift (arbitrary :: Gen Bool)

52+

53+arbitrary' RelationalExprAtomType =

54+ pure (Right (RelationalExprAtom (ExistingRelation relationTrue))) -- don't bother with arbitrary relational expressions

55+

51arbitrary' constructedAtomType@(ConstructedAtomType tcName tvMap)

56arbitrary' constructedAtomType@(ConstructedAtomType tcName tvMap)

52 --special-casing for Interval type

57 --special-casing for Interval type

53 | isIntervalAtomType constructedAtomType = createArbitraryInterval (intervalSubType constructedAtomType)

58 | isIntervalAtomType constructedAtomType = createArbitraryInterval (intervalSubType constructedAtomType)

@@ -79,7 +84,7 @@ maybeToRight y Nothing = Left y

79arbitraryRelationTuple :: Attributes -> WithTCMap Gen (Either RelationalError RelationTuple)

84arbitraryRelationTuple :: Attributes -> WithTCMap Gen (Either RelationalError RelationTuple)

80arbitraryRelationTuple attris = do

85arbitraryRelationTuple attris = do

81 tcMap <- ask

86 tcMap <- ask

82− listOfMaybeAType <- lift $ mapM ((\aTy -> runReaderT (arbitrary' aTy) tcMap) . atomType) (V.toList attris)

87+ listOfMaybeAType <- lift $ mapM ((\aTy -> runReaderT (arbitrary' aTy) tcMap) . atomType) (V.toList (attributesVec attris))

83 case sequence listOfMaybeAType of

88 case sequence listOfMaybeAType of

84 Left err -> pure $ Left err

89 Left err -> pure $ Left err

85 Right listOfAttr -> do

90 Right listOfAttr -> do

src/lib/ProjectM36/Atom.hs+2−1

@@ -3,7 +3,7 @@ import ProjectM36.Base

3import ProjectM36.Error

4import ProjectM36.DataTypes.Interval

5import qualified Data.Text as T

6−#if __GLASGOW_HASKELL__ <= 802

6+#if __GLASGOW_HASKELL__ < 804

7import Data.Monoid

8#endif

9

@@ -20,6 +20,7 @@ atomToText (DayAtom i) = (T.pack . show) i

20atomToText (DateTimeAtom i) = (T.pack . show) i

21atomToText (ByteStringAtom i) = (T.pack . show) i

22atomToText (BoolAtom i) = (T.pack . show) i

23+atomToText (RelationalExprAtom re) = (T.pack . show) re

23

24

24atomToText (RelationAtom i) = (T.pack . show) i

25atomToText (RelationAtom i) = (T.pack . show) i

25atomToText (ConstructedAtom dConsName typ atoms)

26atomToText (ConstructedAtom dConsName typ atoms)

src/lib/ProjectM36/AtomFunction.hs+19−2

@@ -1,5 +1,7 @@

1+{-# LANGUAGE CPP #-}

1module ProjectM36.AtomFunction where

2module ProjectM36.AtomFunction where

2import ProjectM36.Base

3import ProjectM36.Base

4+import ProjectM36.Serialise.Base ()

3import ProjectM36.Error

5import ProjectM36.Error

4import ProjectM36.Relation

6import ProjectM36.Relation

5import ProjectM36.AtomType

7import ProjectM36.AtomType

@@ -8,7 +10,8 @@ import ProjectM36.ScriptSession

8import qualified ProjectM36.Attribute as A

10import qualified ProjectM36.Attribute as A

9import qualified Data.HashSet as HS

11import qualified Data.HashSet as HS

10import qualified Data.Text as T

12import qualified Data.Text as T

11−

13+import qualified Data.ByteString.Lazy as BL

14+import Codec.Winery

12

15

13foldAtomFuncType :: AtomType -> AtomType -> [AtomType]

16foldAtomFuncType :: AtomType -> AtomType -> [AtomType]

14--the underscore in the attribute name means that any attributes are acceptable

17--the underscore in the attribute name means that any attributes are acceptable

@@ -72,7 +75,11 @@ createScriptedAtomFunction funcName argsType retType = AddAtomFunction funcName

72 retType]])

75 retType]])

73

76

74loadAtomFunctions :: ModName -> FuncName -> FilePath -> IO (Either LoadSymbolError [AtomFunction])

77loadAtomFunctions :: ModName -> FuncName -> FilePath -> IO (Either LoadSymbolError [AtomFunction])

78+#ifdef PM36_HASKELL_SCRIPTING

75loadAtomFunctions = loadFunction

79loadAtomFunctions = loadFunction

80+#else

81+loadAtomFunctions _ _ _ = pure (Left LoadSymbolError)

82+#endif

76

83

77atomFunctionsAsRelation :: AtomFunctions -> Either RelationalError Relation

84atomFunctionsAsRelation :: AtomFunctions -> Either RelationalError Relation

78atomFunctionsAsRelation funcs = mkRelationFromList attrs tups

85atomFunctionsAsRelation funcs = mkRelationFromList attrs tups

@@ -81,4 +88,14 @@ atomFunctionsAsRelation funcs = mkRelationFromList attrs tups

81 Attribute "arguments" TextAtomType]

88 Attribute "arguments" TextAtomType]

82 atomFuncToTuple aFunc = [TextAtom (atomFuncName aFunc),

89 atomFuncToTuple aFunc = [TextAtom (atomFuncName aFunc),

83 TextAtom (atomFuncTypeToText aFunc)]

90 TextAtom (atomFuncTypeToText aFunc)]

84− atomFuncTypeToText aFunc = T.intercalate " -> " (map prettyAtomType (atomFuncType aFunc))

91+ atomFuncTypeToText aFunc = T.intercalate " -> " (map prettyAtomType (atomFuncType aFunc))

92+

93+--for calculating the merkle hash

94+hashBytes :: AtomFunction -> BL.ByteString

95+hashBytes func = BL.fromChunks [serialise (atomFuncName func),

96+ serialise (atomFuncType func),

97+ bodyBin

98+ ]

99+ where

100+ bodyBin = case atomFuncBody func of

101+ AtomFunctionBody mScript _ -> serialise mScript

src/lib/ProjectM36/AtomFunctionError.hs+1−2

@@ -1,6 +1,5 @@

1{-# LANGUAGE DeriveGeneric, DeriveAnyClass #-}

2module ProjectM36.AtomFunctionError where

3−import Data.Binary

4import GHC.Generics

3import GHC.Generics

5import Control.DeepSeq

4import Control.DeepSeq

6import Data.Text

5import Data.Text

@@ -14,5 +13,5 @@ data AtomFunctionError = AtomFunctionUserError String |

14 AtomTypeDoesNotSupportOrderingError Text |

13 AtomTypeDoesNotSupportOrderingError Text |

15 AtomTypeDoesNotSupportIntervalError Text |

14 AtomTypeDoesNotSupportIntervalError Text |

16 AtomFunctionBytesDecodingError String

15 AtomFunctionBytesDecodingError String

17− deriving(Generic, Eq, Show, Binary, NFData)

16+ deriving(Generic, Eq, Show, NFData)

18

17

src/lib/ProjectM36/AtomType.hs+86−14

@@ -139,14 +139,37 @@ resolveAttributeExprTypeVars (AttributeAndTypeNameExpr _ tCons _) aType tConsMap

139

140-- check that type vars on the right also appear on the left

141-- check that the data constructor names are unique

142−validateTypeConstructorDef :: TypeConstructorDef -> [DataConstructorDef] -> [RelationalError]

142+validateTypeConstructorDef :: TypeConstructorDef -> [DataConstructorDef] -> TypeConstructorMapping -> Either RelationalError ()

143−validateTypeConstructorDef tConsDef dConsList = execWriter $ do

143+validateTypeConstructorDef tConsDef dConsList tConsMap = do

144 let duplicateDConsNames = dupes (L.sort (map DCD.name dConsList))

145− mapM_ tell [map DataConstructorNameInUseError duplicateDConsNames]

145+ unless (null duplicateDConsNames) (Left (someErrors (map DataConstructorNameInUseError duplicateDConsNames)))

146 let leftSideVars = S.fromList (TCD.typeVars tConsDef)

147 rightSideVars = S.unions (map DCD.typeVars dConsList)

148 varsDiff = S.difference leftSideVars rightSideVars

149− mapM_ tell [map DataConstructorUsesUndeclaredTypeVariable (S.toList varsDiff)]

149+ when (S.size varsDiff > 0) (Left (someErrors (map DataConstructorUsesUndeclaredTypeVariable (S.toList varsDiff))))

150+ mapM_ (\dConsDef -> validateDataConstructorDef dConsDef tConsDef tConsMap) dConsList

151+

152+--check that the data constructor names are not in use (recursively)

153+validateDataConstructorDef :: DataConstructorDef -> TypeConstructorDef -> TypeConstructorMapping -> Either RelationalError ()

154+validateDataConstructorDef (DataConstructorDef dConsName dConsDefArgs) tConsDef tConsMap =

155+ case findDataConstructor dConsName tConsMap of

156+ Just _ -> Left (DataConstructorNameInUseError dConsName)

157+ Nothing ->

158+ mapM_ (\arg -> validateDataConstructorDefArg arg tConsDef tConsMap) dConsDefArgs

159+

160+

161+validateDataConstructorDefArg :: DataConstructorDefArg -> TypeConstructorDef -> TypeConstructorMapping -> Either RelationalError ()

162+validateDataConstructorDefArg (DataConstructorDefTypeConstructorArg (PrimitiveTypeConstructor _ _)) _ _ = Right ()

163+validateDataConstructorDefArg (DataConstructorDefTypeConstructorArg (TypeVariable _)) _ _ = Right ()

164+validateDataConstructorDefArg (DataConstructorDefTypeConstructorArg tCons) tConsDef tConsMap = case findTypeConstructor (TC.name tCons) tConsMap of

165+ Nothing ->

166+ when (TC.name tCons /= TCD.name tConsDef) (Left (NoSuchTypeConstructorName (TC.name tCons))) --allows for recursively-defined types

167+ Just (ADTypeConstructorDef _ tConsArgs, _) -> do --validate that the argument count matches- type matching can occur later

168+ let existingCount = length tConsArgs

169+ newCount = length (TC.arguments tCons)

170+ when (newCount /= existingCount) (Left (ConstructedAtomArgumentCountMismatchError existingCount newCount))

171+ Just (PrimitiveTypeConstructorDef _ _, _) -> pure ()

172+validateDataConstructorDefArg (DataConstructorDefTypeVarNameArg _) _ _ = Right ()

150

173

151atomTypeForTypeConstructor :: TypeConstructor -> TypeConstructorMapping -> TypeVarMap -> Either RelationalError AtomType

174atomTypeForTypeConstructor :: TypeConstructor -> TypeConstructorMapping -> TypeVarMap -> Either RelationalError AtomType

152atomTypeForTypeConstructor = atomTypeForTypeConstructorValidate False

175atomTypeForTypeConstructor = atomTypeForTypeConstructorValidate False

@@ -188,7 +211,7 @@ isValidAtomTypeForTypeConstructor (ConstructedAtomType tConsName _) (ADTypeConst

188

211

189isValidAtomTypeForTypeConstructor (RelationAtomType attrs) (RelationAtomTypeConstructor attrExprs) tConsMap = do

212isValidAtomTypeForTypeConstructor (RelationAtomType attrs) (RelationAtomTypeConstructor attrExprs) tConsMap = do

190 evaldAtomTypes <- mapM (\expr -> atomTypeForAttributeExpr expr tConsMap M.empty) attrExprs

213 evaldAtomTypes <- mapM (\expr -> atomTypeForAttributeExpr expr tConsMap M.empty) attrExprs

191− mapM_ (uncurry resolveAtomType) (zip (map A.atomType (V.toList attrs)) evaldAtomTypes)

214+ mapM_ (uncurry resolveAtomType) (zip (A.atomTypesList attrs) evaldAtomTypes)

192isValidAtomTypeForTypeConstructor aType tCons _ = Left (AtomTypeTypeConstructorReconciliationError aType (TC.name tCons))

215isValidAtomTypeForTypeConstructor aType tCons _ = Left (AtomTypeTypeConstructorReconciliationError aType (TC.name tCons))

193

216

194findTypeConstructor :: TypeConstructorName -> TypeConstructorMapping -> Maybe (TypeConstructorDef, [DataConstructorDef])

217findTypeConstructor :: TypeConstructorName -> TypeConstructorMapping -> Maybe (TypeConstructorDef, [DataConstructorDef])

@@ -198,10 +221,18 @@ findTypeConstructor name = foldr tConsFolder Nothing

198 Just (tCons, dConsList)

221 Just (tCons, dConsList)

199 else

222 else

200 accum

223 accum

201−

224+

225+resolveAttributes :: Attribute -> Attribute -> Either RelationalError Attribute

226+resolveAttributes attrA attrB =

227+ if A.attributeName attrA /= A.attributeName attrB then

228+ Left $ AttributeNamesMismatchError (S.fromList (map A.attributeName [attrA, attrB]))

229+ else

230+ Attribute (A.attributeName attrA) <$> resolveAtomType (A.atomType attrA) (A.atomType attrB)

231+

232+--given two atom types, try to resolve type variables

202resolveAtomType :: AtomType -> AtomType -> Either RelationalError AtomType

233resolveAtomType :: AtomType -> AtomType -> Either RelationalError AtomType

203resolveAtomType (ConstructedAtomType tConsName resolvedTypeVarMap) (ConstructedAtomType _ unresolvedTypeVarMap) =

234resolveAtomType (ConstructedAtomType tConsName resolvedTypeVarMap) (ConstructedAtomType _ unresolvedTypeVarMap) =

204− ConstructedAtomType tConsName <$> resolveAtomTypesInTypeVarMap resolvedTypeVarMap unresolvedTypeVarMap

235+ ConstructedAtomType tConsName <$> resolveAtomTypesInTypeVarMap resolvedTypeVarMap unresolvedTypeVarMap

205resolveAtomType typeFromRelation unresolvedType = if typeFromRelation == unresolvedType then

236resolveAtomType typeFromRelation unresolvedType = if typeFromRelation == unresolvedType then

206 Right typeFromRelation

237 Right typeFromRelation

207 else

238 else

@@ -229,12 +260,16 @@ resolveAtomTypesInTypeVarMap resolvedTypeMap unresolvedTypeMap = do

229 let resolveTypePair resKey resType =

260 let resolveTypePair resKey resType =

230 -- if the key is missing in the unresolved type map, then fill it in with the value from the resolved map

261 -- if the key is missing in the unresolved type map, then fill it in with the value from the resolved map

231 case M.lookup resKey unresolvedTypeMap of

262 case M.lookup resKey unresolvedTypeMap of

232− Just unresType -> case unresType of

263+ Just unresType -> case unresType of

233 --do we need to recurse for RelationAtomType?

264 --do we need to recurse for RelationAtomType?

234 subType@(ConstructedAtomType _ _) -> do

265 subType@(ConstructedAtomType _ _) -> do

235 resSubType <- resolveAtomType resType subType

266 resSubType <- resolveAtomType resType subType

236 pure (resKey, resSubType)

267 pure (resKey, resSubType)

237− _ -> pure (resKey, resType)

268+ TypeVariableType _ -> pure (resKey, resType)

269+ typ -> if typ == resType then

270+ pure (resKey, resType)

271+ else

272+ Left $ AtomTypeMismatchError typ resType

238 Nothing ->

273 Nothing ->

239 pure (resKey, resType) --swipe the missing type var from the expected map

274 pure (resKey, resType) --swipe the missing type var from the expected map

240 tVarList <- mapM (uncurry resolveTypePair) (M.toList resolvedTypeMap)

275 tVarList <- mapM (uncurry resolveTypePair) (M.toList resolvedTypeMap)

@@ -260,7 +295,7 @@ resolveTypeInAtom _ atom _ = Right atom

260-- Example: "Nothing" does not specify the the argument in "Maybe a", so allow delayed resolution in the tuple before it is added to the relation. Note that this resolution could cause a type error. Hardly a Hindley-Milner system.

295-- Example: "Nothing" does not specify the the argument in "Maybe a", so allow delayed resolution in the tuple before it is added to the relation. Note that this resolution could cause a type error. Hardly a Hindley-Milner system.

261resolveTypesInTuple :: Attributes -> TypeConstructorMapping -> RelationTuple -> Either RelationalError RelationTuple

296resolveTypesInTuple :: Attributes -> TypeConstructorMapping -> RelationTuple -> Either RelationalError RelationTuple

262resolveTypesInTuple resolvedAttrs tConss (RelationTuple _ tupAtoms) = do

297resolveTypesInTuple resolvedAttrs tConss (RelationTuple _ tupAtoms) = do

263− newAtoms <- mapM (\(atom, resolvedType) -> resolveTypeInAtom resolvedType atom tConss) (zip (V.toList tupAtoms) $ map A.atomType (V.toList resolvedAttrs))

298+ newAtoms <- mapM (\(atom, resolvedType) -> resolveTypeInAtom resolvedType atom tConss) (zip (V.toList tupAtoms) $ A.atomTypesList resolvedAttrs)

264 Right (RelationTuple resolvedAttrs (V.fromList newAtoms))

299 Right (RelationTuple resolvedAttrs (V.fromList newAtoms))

265

300

266-- | Validate that the type is provided with complete type variables for type constructors.

301-- | Validate that the type is provided with complete type variables for type constructors.

@@ -279,10 +314,19 @@ validateAtomType typ@(ConstructedAtomType tConsName tVarMap) tConss =

279 _ -> Right ()

314 _ -> Right ()

280validateAtomType (RelationAtomType attrs) tConss =

315validateAtomType (RelationAtomType attrs) tConss =

281 mapM_ (\attr ->

316 mapM_ (\attr ->

282− validateAtomType (A.atomType attr) tConss) (V.toList attrs)

317+ validateAtomType (A.atomType attr) tConss) (attributesVec attrs)

283validateAtomType (TypeVariableType x) _ = Left (TypeConstructorTypeVarMissing x)

318validateAtomType (TypeVariableType x) _ = Left (TypeConstructorTypeVarMissing x)

284validateAtomType _ _ = pure ()

319validateAtomType _ _ = pure ()

285

320

321+validateAttributes :: TypeConstructorMapping -> Attributes -> Either RelationalError ()

322+validateAttributes tConss attrs =

323+ if not (null errs) then

324+ Left (someErrors errs)

325+ else

326+ pure ()

327+ where

328+ errs = lefts $ map (`validateAtomType` tConss) (A.atomTypesList attrs)

329+

286--ensure that all type vars are fully resolved

330--ensure that all type vars are fully resolved

287validateTypeVarMap :: TypeVarMap -> TypeConstructorMapping -> Either RelationalError ()

331validateTypeVarMap :: TypeVarMap -> TypeConstructorMapping -> Either RelationalError ()

288validateTypeVarMap tvMap tConss = mapM_ (`validateAtomType` tConss) $ M.elems tvMap

332validateTypeVarMap tvMap tConss = mapM_ (`validateAtomType` tConss) $ M.elems tvMap

@@ -314,7 +358,7 @@ atomTypeVerify x@(RelationAtomType attrs1) y@(RelationAtomType attrs2) = do

314 if notElem "_" [name1, name2] && name1 /= name2 then

358 if notElem "_" [name1, name2] && name1 /= name2 then

315 Left $ AtomTypeMismatchError x y

359 Left $ AtomTypeMismatchError x y

316 else

360 else

317− atomTypeVerify (A.atomType attr1) (A.atomType attr2)) $ V.toList (V.zip attrs1 attrs2)

361+ atomTypeVerify (A.atomType attr1) (A.atomType attr2)) $ V.toList (V.zip (attributesVec attrs1) (attributesVec attrs2))

318 return x

362 return x

319atomTypeVerify x y = if x == y then

363atomTypeVerify x y = if x == y then

320 Right x

364 Right x

@@ -323,10 +367,15 @@ atomTypeVerify x y = if x == y then

323

367

324-- | Determine if two typeVars are logically compatible.

368-- | Determine if two typeVars are logically compatible.

325typeVarMapsVerify :: TypeVarMap -> TypeVarMap -> Bool

369typeVarMapsVerify :: TypeVarMap -> TypeVarMap -> Bool

326−typeVarMapsVerify a b = M.keysSet a == M.keysSet b && (length . rights) (map (\((_,v1),(_,v2)) -> atomTypeVerify v1 v2) (zip (M.toAscList a) (M.toAscList b))) == M.size a

370+typeVarMapsVerify a b = M.keysSet a == M.keysSet b && (length . rights) zipped == M.size a

371+ where

372+ zipped = zipWith

373+ (curry (\ ((_, v1), (_, v2)) -> atomTypeVerify v1 v2))

374+ (M.toAscList a)

375+ (M.toAscList b)

327

376

328prettyAtomType :: AtomType -> T.Text

377prettyAtomType :: AtomType -> T.Text

329−prettyAtomType (RelationAtomType attrs) = "relation {" `T.append` T.intercalate "," (map prettyAttribute (V.toList attrs)) `T.append` "}"

378+prettyAtomType (RelationAtomType attrs) = "relation {" `T.append` T.intercalate "," (map prettyAttribute (V.toList (attributesVec attrs))) `T.append` "}"

330prettyAtomType (ConstructedAtomType tConsName typeVarMap) = tConsName `T.append` T.concat (map showTypeVars (M.toList typeVarMap))

379prettyAtomType (ConstructedAtomType tConsName typeVarMap) = tConsName `T.append` T.concat (map showTypeVars (M.toList typeVarMap))

331 where

380 where

332 showTypeVars (_, TypeVariableType x) = " " <> x

381 showTypeVars (_, TypeVariableType x) = " " <> x

@@ -382,3 +431,26 @@ resolvedAtomTypeForDataConstructorDefArg _ tvMap (DataConstructorDefTypeVarNameA

382 Nothing -> Left (DataConstructorUsesUndeclaredTypeVariable tvName)

431 Nothing -> Left (DataConstructorUsesUndeclaredTypeVariable tvName)

383 Just typ -> Right typ

432 Just typ -> Right typ

384

433

434+isResolvedType :: AtomType -> Bool

435+isResolvedType typ =

436+ case typ of

437+ IntAtomType -> True

438+ IntegerAtomType -> True

439+ DoubleAtomType -> True

440+ TextAtomType -> True

441+ DayAtomType -> True

442+ DateTimeAtomType -> True

443+ ByteStringAtomType -> True

444+ BoolAtomType -> True

445+ RelationalExprAtomType -> True

446+ RelationAtomType attrs -> isResolvedAttributes attrs

447+ ConstructedAtomType _ tvMap -> all isResolvedType (M.elems tvMap)

448+ TypeVariableType _ -> False

449+

450+isResolvedAttributes :: Attributes -> Bool

451+isResolvedAttributes attrs = all isResolvedAttribute (V.toList (attributesVec attrs))

452+

453+isResolvedAttribute :: Attribute -> Bool

454+isResolvedAttribute = isResolvedType . A.atomType

455+

456+--given two AtomTypes x,y

src/lib/ProjectM36/Atomable.hs+33−49

@@ -13,29 +13,16 @@ import qualified Data.Map as M

13import qualified Data.Text as T

14import qualified Data.Vector as V

15import Control.DeepSeq (NFData)

16−import Data.Binary

17import Control.Applicative

16import Control.Applicative

18import Data.Time.Calendar

17import Data.Time.Calendar

19import Data.ByteString (ByteString)

18import Data.ByteString (ByteString)

20import Data.Time.Clock

19import Data.Time.Clock

21import Data.Proxy

20import Data.Proxy

22import qualified Data.List.NonEmpty as NE

21import qualified Data.List.NonEmpty as NE

22+import Codec.Winery

23

24−--also add haskell scripting atomable support

25−--rename this module to Atomable along with test

26−

27−{-

28−data Test1T = Test1C Int

29− deriving (Generic, Show, Eq, Binary, NFData, Atomable)

30−

31−data Test2T = Test2C Int Int

32− deriving (Generic, Show, Eq, Binary, NFData, Atomable)

33−

34−data Test3T = Test3Ca | Test3Cb

35− deriving (Generic, Show, Eq, Binary, NFData, Atomable)

36−-}

37-- | All database values ("atoms") adhere to the 'Atomable' typeclass. This class is derivable allowing new datatypes to be easily marshaling between Haskell values and database values.

24-- | All database values ("atoms") adhere to the 'Atomable' typeclass. This class is derivable allowing new datatypes to be easily marshaling between Haskell values and database values.

38−class (Eq a, NFData a, Binary a, Show a) => Atomable a where

25+class (Eq a, NFData a, Serialise a, Show a) => Atomable a where

39 toAtom :: a -> Atom

26 toAtom :: a -> Atom

40 default toAtom :: (Generic a, AtomableG (Rep a)) => a -> Atom

27 default toAtom :: (Generic a, AtomableG (Rep a)) => a -> Atom

41 toAtom v = toAtomG (from v) (toAtomTypeG (from v))

28 toAtom v = toAtomG (from v) (toAtomTypeG (from v))

@@ -56,7 +43,7 @@ class (Eq a, NFData a, Binary a, Show a) => Atomable a where

56 -- | Creates DatabaseContextExpr necessary to load the type constructor and data constructor into the database.

43 -- | Creates DatabaseContextExpr necessary to load the type constructor and data constructor into the database.

57 toAddTypeExpr :: proxy a -> DatabaseContextExpr

44 toAddTypeExpr :: proxy a -> DatabaseContextExpr

58 default toAddTypeExpr :: (Generic a, AtomableG (Rep a)) => proxy a -> DatabaseContextExpr

45 default toAddTypeExpr :: (Generic a, AtomableG (Rep a)) => proxy a -> DatabaseContextExpr

59− toAddTypeExpr _ = toAddTypeExprG (from (undefined :: a)) (toAtomType (Proxy :: Proxy a))

46+ toAddTypeExpr _ = toAddTypeExprG (from (error "insufficient laziness" :: a)) (toAtomType (Proxy :: Proxy a))

60

47

61instance Atomable Integer where

48instance Atomable Integer where

62 toAtom = IntegerAtom

49 toAtom = IntegerAtom

@@ -148,10 +135,10 @@ instance (Atomable a, Atomable b) => Atomable (Either a b) where

148--convert to ADT list

135--convert to ADT list

149instance Atomable a => Atomable [a] where

136instance Atomable a => Atomable [a] where

150 toAtom [] = ConstructedAtom "Empty" (listAtomType (toAtomType (Proxy :: Proxy a))) []

137 toAtom [] = ConstructedAtom "Empty" (listAtomType (toAtomType (Proxy :: Proxy a))) []

151− toAtom (x:xs) = ConstructedAtom "Cons" (listAtomType (toAtomType (Proxy :: Proxy a))) (map toAtom (x:xs))

138+ toAtom (x:xs) = ConstructedAtom "Cons" (listAtomType (toAtomType (Proxy :: Proxy a))) (toAtom x: [toAtom xs])

152

139

153 fromAtom (ConstructedAtom "Empty" _ _) = []

140 fromAtom (ConstructedAtom "Empty" _ _) = []

154− fromAtom (ConstructedAtom "Cons" _ (x:xs)) = fromAtom x:map fromAtom xs

141+ fromAtom (ConstructedAtom "Cons" _ [x,y]) = fromAtom x:fromAtom y

155 fromAtom _ = error "improper fromAtom [a]"

142 fromAtom _ = error "improper fromAtom [a]"

156

143

157 toAtomType _ = ConstructedAtomType "List" (M.singleton "a" (toAtomType (Proxy :: Proxy a)))

144 toAtomType _ = ConstructedAtomType "List" (M.singleton "a" (toAtomType (Proxy :: Proxy a)))

@@ -165,10 +152,6 @@ instance Atomable a => Atomable (NE.NonEmpty a) where

165 toAtomType _ = ConstructedAtomType "NonEmptyList" (M.singleton "a" (toAtomType (Proxy :: Proxy a)))

152 toAtomType _ = ConstructedAtomType "NonEmptyList" (M.singleton "a" (toAtomType (Proxy :: Proxy a)))

166 toAddTypeExpr _ = NoOperation

153 toAddTypeExpr _ = NoOperation

167

154

168−#if !MIN_VERSION_binary(0,8,4)

169−instance Binary a => Binary (NE.NonEmpty a)

170−#endif

171−

172-- Generics

155-- Generics

173class AtomableG g where

156class AtomableG g where

174 --type AtomTG g

157 --type AtomTG g

@@ -184,17 +167,17 @@ class AtomableG g where

184instance (Datatype c, AtomableG a) => AtomableG (M1 D c a) where

167instance (Datatype c, AtomableG a) => AtomableG (M1 D c a) where

185 toAtomG (M1 v) = toAtomG v

168 toAtomG (M1 v) = toAtomG v

186 fromAtomG atom args = M1 <$> fromAtomG atom args

169 fromAtomG atom args = M1 <$> fromAtomG atom args

187− toAtomsG = undefined

170+ toAtomsG = error "invalid toAtomsG in M1 D"

188 toAtomTypeG _ = ConstructedAtomType (T.pack typeName) M.empty -- generics don't allow us to get the type constructor variables- alternatives?

171 toAtomTypeG _ = ConstructedAtomType (T.pack typeName) M.empty -- generics don't allow us to get the type constructor variables- alternatives?

189 where

172 where

190 typeName = datatypeName (undefined :: M1 D c a x)

173 typeName = datatypeName (undefined :: M1 D c a x)

191− toAddTypeExprG (M1 v) (ConstructedAtomType tcName _) = AddTypeConstructor tcDef dataConstructors

174+ toAddTypeExprG ~(M1 v) (ConstructedAtomType tcName _) = AddTypeConstructor tcDef dataConstructors

192 where

175 where

193 tcDef = ADTypeConstructorDef tcName []

176 tcDef = ADTypeConstructorDef tcName []

194 dataConstructors = getConstructorsG v

177 dataConstructors = getConstructorsG v

195 toAddTypeExprG _ _ = NoOperation

178 toAddTypeExprG _ _ = NoOperation

196− getConstructorsG (M1 v) = getConstructorsG v

179+ getConstructorsG ~(M1 v) = getConstructorsG v

197− getConstructorArgsG = undefined

180+ getConstructorArgsG = error "invalid getConstructorArgsG in M1 D"

198

181

199--constructor metadata

182--constructor metadata

200instance (Constructor c, AtomableG a) => AtomableG (M1 C c a) where

183instance (Constructor c, AtomableG a) => AtomableG (M1 C c a) where

@@ -209,11 +192,11 @@ instance (Constructor c, AtomableG a) => AtomableG (M1 C c a) where

209 Nothing

192 Nothing

210 where

193 where

211 dName = T.pack (conName (undefined :: M1 C c a x))

194 dName = T.pack (conName (undefined :: M1 C c a x))

212− fromAtomG _ _ = error "unsupported generic traversal"

195+ fromAtomG _ _ = error "invalid fromAtomG in M1 C"

213− toAtomsG = undefined

196+ toAtomsG = error "invalid toAtomsG in M1 C"

214− toAtomTypeG = undefined

197+ toAtomTypeG = error "invalid toAtomTypeG in M1 C"

215− toAddTypeExprG = undefined

198+ toAddTypeExprG = error "invalid toAddTypeExprG in M1 C"

216− getConstructorsG (M1 v) = [DataConstructorDef (T.pack dName) dArgs]

199+ getConstructorsG ~(M1 v) = [DataConstructorDef (T.pack dName) dArgs]

217 where

200 where

218 dName = conName (undefined :: M1 C c a x)

201 dName = conName (undefined :: M1 C c a x)

219 dArgs = getConstructorArgsG v

202 dArgs = getConstructorArgsG v

@@ -225,9 +208,9 @@ instance (Selector c, AtomableG a) => AtomableG (M1 S c a) where

225 fromAtomG atom args = M1 <$> fromAtomG atom args

208 fromAtomG atom args = M1 <$> fromAtomG atom args

226 toAtomsG (M1 v) = toAtomsG v

209 toAtomsG (M1 v) = toAtomsG v

227 toAtomTypeG (M1 v) = toAtomTypeG v

210 toAtomTypeG (M1 v) = toAtomTypeG v

228− toAddTypeExprG _ _ = undefined

211+ toAddTypeExprG = error "invalid toAddTypeExprG in M1 S"

229− getConstructorsG = undefined

212+ getConstructorsG = error "invalid getConstructorsG in M1 S"

230− getConstructorArgsG (M1 v) = getConstructorArgsG v

213+ getConstructorArgsG ~(M1 v) = getConstructorArgsG v

231

214

232-- field data metadata

215-- field data metadata

233instance (Atomable a) => AtomableG (K1 c a) where

216instance (Atomable a) => AtomableG (K1 c a) where

@@ -237,9 +220,9 @@ instance (Atomable a) => AtomableG (K1 c a) where

237 headatom [] = error "no more atoms for constructor!"

220 headatom [] = error "no more atoms for constructor!"

238 toAtomsG (K1 v) = [toAtom v]

221 toAtomsG (K1 v) = [toAtom v]

239 toAtomTypeG _ = toAtomType (Proxy :: Proxy a)

222 toAtomTypeG _ = toAtomType (Proxy :: Proxy a)

240− toAddTypeExprG _ _ = undefined

223+ toAddTypeExprG = error "invalid toAddTypeExprG in K1"

241− getConstructorsG = undefined

224+ getConstructorsG = error "invalid getConstructorsG in K1"

242− getConstructorArgsG (K1 _) = [DataConstructorDefTypeConstructorArg tCons]

225+ getConstructorArgsG ~(K1 _) = [DataConstructorDefTypeConstructorArg tCons]

243 where

226 where

244 tCons = typeToTypeConstructor $ toAtomType (Proxy :: Proxy a)

227 tCons = typeToTypeConstructor $ toAtomType (Proxy :: Proxy a)

245

228

@@ -252,8 +235,9 @@ typeToTypeConstructor x@DayAtomType = PrimitiveTypeConstructor "Day" x

252typeToTypeConstructor x@DateTimeAtomType = PrimitiveTypeConstructor "DateTime" x

235typeToTypeConstructor x@DateTimeAtomType = PrimitiveTypeConstructor "DateTime" x

253typeToTypeConstructor x@ByteStringAtomType = PrimitiveTypeConstructor "ByteString" x

236typeToTypeConstructor x@ByteStringAtomType = PrimitiveTypeConstructor "ByteString" x

254typeToTypeConstructor x@BoolAtomType = PrimitiveTypeConstructor "Bool" x

237typeToTypeConstructor x@BoolAtomType = PrimitiveTypeConstructor "Bool" x

238+typeToTypeConstructor x@RelationalExprAtomType = PrimitiveTypeConstructor "RelationalExpr" x

255typeToTypeConstructor (RelationAtomType attrs)

239typeToTypeConstructor (RelationAtomType attrs)

256− = RelationAtomTypeConstructor $ map attrToAttrExpr $ V.toList attrs

240+ = RelationAtomTypeConstructor $ map attrToAttrExpr $ V.toList (attributesVec attrs)

257 where

241 where

258 attrToAttrExpr (Attribute n t) = AttributeAndTypeNameExpr n (typeToTypeConstructor t) ()

242 attrToAttrExpr (Attribute n t) = AttributeAndTypeNameExpr n (typeToTypeConstructor t) ()

259typeToTypeConstructor (ConstructedAtomType tcName tvMap)

243typeToTypeConstructor (ConstructedAtomType tcName tvMap)

@@ -261,12 +245,12 @@ typeToTypeConstructor (ConstructedAtomType tcName tvMap)

261typeToTypeConstructor (TypeVariableType tvName) = TypeVariable tvName

245typeToTypeConstructor (TypeVariableType tvName) = TypeVariable tvName

262

246

263instance AtomableG U1 where

247instance AtomableG U1 where

264− toAtomG = undefined

248+ toAtomG = error "invalid toAtomG in U1"

265 fromAtomG _ _ = pure U1

249 fromAtomG _ _ = pure U1

266 toAtomsG _ = []

250 toAtomsG _ = []

267− toAtomTypeG = undefined

251+ toAtomTypeG = error "invalid toAtomTypeG in U1"

268− toAddTypeExprG = undefined

252+ toAddTypeExprG = error "invalid toAddTypeExprG in U1"

269− getConstructorsG = undefined

253+ getConstructorsG = error "invalid getConstructorsG in U1"

270 getConstructorArgsG _ = []

254 getConstructorArgsG _ = []

271

255

272-- product types

256-- product types

@@ -276,23 +260,23 @@ instance (AtomableG a, AtomableG b) => AtomableG (a :*: b) where

276 where splitargs1 = take splitpoint args

260 where splitargs1 = take splitpoint args

277 splitargs2 = drop splitpoint args

261 splitargs2 = drop splitpoint args

278 splitpoint = length args `div` 2

262 splitpoint = length args `div` 2

279− toAtomTypeG = undefined

263+ toAtomTypeG = error "invalid toAtomTypeG in :*:"

280 toAtomsG (x :*: y) = toAtomsG x ++ toAtomsG y

264 toAtomsG (x :*: y) = toAtomsG x ++ toAtomsG y

281− toAddTypeExprG _ _ = undefined

265+ toAddTypeExprG = error "invalid toAddTypeExprG in :*:"

282− getConstructorsG = undefined

266+ getConstructorsG = error "invalid getConstructorsG in :*:"

283− getConstructorArgsG (x :*: y) = getConstructorArgsG x ++ getConstructorArgsG y

267+ getConstructorArgsG ~(x :*: y) = getConstructorArgsG x ++ getConstructorArgsG y

284

268

285-- sum types

269-- sum types

286instance (AtomableG a, AtomableG b) => AtomableG (a :+: b) where

270instance (AtomableG a, AtomableG b) => AtomableG (a :+: b) where

287 toAtomG (L1 x) = toAtomG x

271 toAtomG (L1 x) = toAtomG x

288 toAtomG (R1 x) = toAtomG x

272 toAtomG (R1 x) = toAtomG x

289 fromAtomG atom args = (L1 <$> fromAtomG atom args) <|> (R1 <$> fromAtomG atom args)

273 fromAtomG atom args = (L1 <$> fromAtomG atom args) <|> (R1 <$> fromAtomG atom args)

290− toAtomTypeG = undefined

274+ toAtomTypeG = error "invalid toAtomTypeG in :+:"

291 toAtomsG (L1 x) = toAtomsG x

275 toAtomsG (L1 x) = toAtomsG x

292 toAtomsG (R1 x) = toAtomsG x

276 toAtomsG (R1 x) = toAtomsG x

293− toAddTypeExprG _ _ = undefined

277+ toAddTypeExprG = error "invalid toAddTypeExprG in :+:"

294 getConstructorsG _ = getConstructorsG (undefined :: a x) ++ getConstructorsG (undefined :: b x)

278 getConstructorsG _ = getConstructorsG (undefined :: a x) ++ getConstructorsG (undefined :: b x)

295− getConstructorArgsG = undefined

279+ getConstructorArgsG = error "invalid getConstructorArgsG in :+:"

296

280

297--this represents the unimplemented generics traversals which should never be called

281--this represents the unimplemented generics traversals which should never be called

298{-

282{-

src/lib/ProjectM36/Attribute.hs+148−29

@@ -1,3 +1,4 @@

1+{-# OPTIONS_GHC -fno-warn-orphans #-}

1module ProjectM36.Attribute where

2module ProjectM36.Attribute where

2import ProjectM36.Base

3import ProjectM36.Base

3import ProjectM36.Error

4import ProjectM36.Error

@@ -10,16 +11,54 @@ import qualified Data.Map as M

10import Data.Either

11import Data.Either

11

12

12arity :: Attributes -> Int

13arity :: Attributes -> Int

13−arity = V.length

14+arity a = V.length (attributesVec a)

15+

16+instance Semigroup Attributes where

17+ attrsA <> attrsB =

18+ case joinAttributes attrsA attrsB of

19+ Left err -> error (show err)

20+ Right attrs' -> attrs'

21+

22+instance Monoid Attributes where

23+ mempty = Attributes {

24+ attributesVec = mempty

25+ --,attributeSet = mempty

26+ }

14

27

15emptyAttributes :: Attributes

28emptyAttributes :: Attributes

16−emptyAttributes = V.empty

29+emptyAttributes = mempty

17

30

18null :: Attributes -> Bool

31null :: Attributes -> Bool

19−null = V.null

32+null a = V.null (attributesVec a)

33+

34+singleton :: Attribute -> Attributes

35+singleton attr = Attributes {

36+ attributesVec = V.singleton attr

37+ --,attributesSet = HS.singleton attr

38+ }

39+

40+toList :: Attributes -> [Attribute]

41+toList attrs = V.toList (attributesVec attrs)

20

42

21attributesFromList :: [Attribute] -> Attributes

43attributesFromList :: [Attribute] -> Attributes

22−attributesFromList = V.fromList -- . L.nub --too expensive

44+attributesFromList attrsL = Attributes {

45+ attributesVec = vec

46+ --,attributesSet = hset

47+ }

48+ where

49+ vec = if length attrsL == HS.size hset then

50+ --fast path- no duplicates

51+ V.fromList attrsL

52+ else

53+ --duplicate detected, uniqueify while maintaining original ordering

54+ V.fromList uniquedL

55+ hset = HS.fromList attrsL

56+ uniquedL = fst $ foldr (\attr acc@(l,s) ->

57+ if HS.member attr s then

58+ acc

59+ else

60+ (l ++ [attr], HS.insert attr s))

61+ ([],mempty) attrsL

23

62

24attributeName :: Attribute -> AttributeName

63attributeName :: Attribute -> AttributeName

25attributeName (Attribute name _) = name

64attributeName (Attribute name _) = name

@@ -28,17 +67,16 @@ atomType :: Attribute -> AtomType

28atomType (Attribute _ atype) = atype

67atomType (Attribute _ atype) = atype

29

68

30atomTypes :: Attributes -> V.Vector AtomType

69atomTypes :: Attributes -> V.Vector AtomType

31−atomTypes = V.map atomType

70+atomTypes attrs = V.map atomType (attributesVec attrs)

32

71

33atomTypesList :: Attributes -> [AtomType]

72atomTypesList :: Attributes -> [AtomType]

34atomTypesList = V.toList . atomTypes

73atomTypesList = V.toList . atomTypes

35

74

36−--hm- no error-checking here

37addAttribute :: Attribute -> Attributes -> Attributes

75addAttribute :: Attribute -> Attributes -> Attributes

38−addAttribute attr attrs = attrs `V.snoc` attr

76+addAttribute attr attrs = attrs <> singleton attr

39

77

40--if some attribute names overlap but the types do not, then spit back an error

78--if some attribute names overlap but the types do not, then spit back an error

41−joinAttributes :: Attributes -> Attributes -> Either RelationalError Attributes

79+{-joinAttributes :: Attributes -> Attributes -> Either RelationalError Attributes

42joinAttributes attrs1 attrs2 | V.length uniqueOverlappingAttributes /= V.length overlappingAttributes = Left (TupleAttributeTypeMismatchError overlappingAttributes)

80joinAttributes attrs1 attrs2 | V.length uniqueOverlappingAttributes /= V.length overlappingAttributes = Left (TupleAttributeTypeMismatchError overlappingAttributes)

43 | V.length overlappingAttrsDifferentTypes > 0 = Left (TupleAttributeTypeMismatchError overlappingAttrsDifferentTypes)

81 | V.length overlappingAttrsDifferentTypes > 0 = Left (TupleAttributeTypeMismatchError overlappingAttrsDifferentTypes)

44 | otherwise = Right $ vectorUniqueify (attrs1 V.++ attrs2)

82 | otherwise = Right $ vectorUniqueify (attrs1 V.++ attrs2)

@@ -47,20 +85,52 @@ joinAttributes attrs1 attrs2 | V.length uniqueOverlappingAttributes /= V.length

47 attrNames2 = V.map attributeName attrs2

85 attrNames2 = V.map attributeName attrs2

48 uniqueOverlappingAttributes = vectorUniqueify overlappingAttributes

86 uniqueOverlappingAttributes = vectorUniqueify overlappingAttributes

49 overlappingAttributes = V.filter (`V.elem` attrs2) attrs1

87 overlappingAttributes = V.filter (`V.elem` attrs2) attrs1

88+-}

89+joinAttributes :: Attributes -> Attributes -> Either RelationalError Attributes

90+joinAttributes attrs1 attrs2

91+ | S.size overlappingNames == 0 = -- fast path, no overlapping names

92+ pure (concated id)

93+ | attributesForNames overlappingNames attrs1 == attributesForNames overlappingNames attrs2 = -- that atomtypes match

94+ pure (concated vectorUniqueify)

95+ | otherwise =

96+ --special handling to validate that overlapping names have the same atom types

97+ Left (TupleAttributeTypeMismatchError (attributesForNames overlappingNames attrs1))

98+ where

99+ nameSet1 = attributeNameSet attrs1

100+ nameSet2 = attributeNameSet attrs2

101+ overlappingNames = S.intersection nameSet1 nameSet2

102+ concated f = Attributes {

103+ attributesVec = f (attributesVec attrs1 <> attributesVec attrs2)

104+ --,attributesSet = attributesSet attrs1 <> attributesSet attrs2

105+ }

50

106

51addAttributes :: Attributes -> Attributes -> Attributes

107addAttributes :: Attributes -> Attributes -> Attributes

52−addAttributes = (V.++)

108+addAttributes = (<>)

109+

110+member :: Attribute -> Attributes -> Bool

111+member attr attrs = HS.member attr (attributesSet attrs)

53

112

54deleteAttributeName :: AttributeName -> Attributes -> Attributes

113deleteAttributeName :: AttributeName -> Attributes -> Attributes

55−deleteAttributeName attrName = V.filter (\attr -> attributeName attr /= attrName)

114+deleteAttributeName attrName = deleteAttributeNames (S.singleton attrName)

115+

116+deleteAttributeNames :: S.Set AttributeName -> Attributes -> Attributes

117+deleteAttributeNames attrNames attrs = Attributes {

118+ attributesVec = vec

119+ }

120+ where

121+ vec = V.filter attrFilter (attributesVec attrs)

122+ attrFilter attr = S.notMember (attributeName attr) attrNames

56

123

57renameAttribute :: AttributeName -> Attribute -> Attribute

124renameAttribute :: AttributeName -> Attribute -> Attribute

58renameAttribute newAttrName (Attribute _ typeo) = Attribute newAttrName typeo

125renameAttribute newAttrName (Attribute _ typeo) = Attribute newAttrName typeo

59

126

60renameAttributes :: AttributeName -> AttributeName -> Attributes -> Attributes

127renameAttributes :: AttributeName -> AttributeName -> Attributes -> Attributes

61−renameAttributes oldAttrName newAttrName = V.map renamer

128+renameAttributes oldAttrName newAttrName attrs = Attributes {

129+ attributesVec = vec

130+ }

62 where

131 where

132+ vec = V.map renamer (attributesVec attrs)

63− renamer attr = if attributeName attr == oldAttrName then

133+ renamer attr = if attributeName attr == oldAttrName then

64 renameAttribute newAttrName attr

134 renameAttribute newAttrName attr

65 else

135 else

66 attr

136 attr

@@ -71,7 +141,7 @@ atomTypeForAttributeName attrName attrs = do

71 return atype

141 return atype

72

142

73attributeForName :: AttributeName -> Attributes -> Either RelationalError Attribute

143attributeForName :: AttributeName -> Attributes -> Either RelationalError Attribute

74−attributeForName attrName attrs = case V.find (\attr -> attributeName attr == attrName) attrs of

144+attributeForName attrName attrs = case V.find (\attr -> attributeName attr == attrName) (attributesVec attrs) of

75 Nothing -> Left (NoSuchAttributeNamesError (S.singleton attrName))

145 Nothing -> Left (NoSuchAttributeNamesError (S.singleton attrName))

76 Just attr -> Right attr

146 Just attr -> Right attr

77

147

@@ -89,15 +159,18 @@ projectionAttributesForNames names attrsIn =

89 missingNames = attributeNamesNotContained names (S.fromList (V.toList (attributeNames attrsIn)))

159 missingNames = attributeNamesNotContained names (S.fromList (V.toList (attributeNames attrsIn)))

90

160

91attributesForNames :: S.Set AttributeName -> Attributes -> Attributes

161attributesForNames :: S.Set AttributeName -> Attributes -> Attributes

92−attributesForNames attrNameSet = V.filter filt

162+attributesForNames attrNameSet attrs = Attributes {

163+ attributesVec = vec

164+ }

93 where

165 where

166+ vec = V.filter filt (attributesVec attrs)

94 filt attr = S.member (attributeName attr) attrNameSet

167 filt attr = S.member (attributeName attr) attrNameSet

95

168

96attributeNameSet :: Attributes -> S.Set AttributeName

169attributeNameSet :: Attributes -> S.Set AttributeName

97−attributeNameSet attrVec = S.fromList $ V.toList $ V.map (\(Attribute name _) -> name) attrVec

170+attributeNameSet attrs = S.fromList $ V.toList $ V.map (\(Attribute name _) -> name) (attributesVec attrs)

98

171

99attributeNames :: Attributes -> V.Vector AttributeName

172attributeNames :: Attributes -> V.Vector AttributeName

100−attributeNames = V.map attributeName

173+attributeNames attrs = V.map attributeName (attributesVec attrs)

101

174

102--checks if set s1 is wholly contained in the set s2

175--checks if set s1 is wholly contained in the set s2

103attributesContained :: Attributes -> Attributes -> Bool

176attributesContained :: Attributes -> Attributes -> Bool

@@ -118,42 +191,88 @@ attributeNamesNotContained subset superset = S.filter (`S.notMember` superset) s

118

191

119-- useful for display

192-- useful for display

120orderedAttributes :: Attributes -> [Attribute]

193orderedAttributes :: Attributes -> [Attribute]

121−orderedAttributes attrs = L.sortBy (\a b -> attributeName a `compare` attributeName b) (V.toList attrs)

194+orderedAttributes attrs = L.sortBy (\a b -> attributeName a `compare` attributeName b) (V.toList (attributesVec attrs))

122

195

123orderedAttributeNames :: Attributes -> [AttributeName]

196orderedAttributeNames :: Attributes -> [AttributeName]

124orderedAttributeNames attrs = map attributeName (orderedAttributes attrs)

197orderedAttributeNames attrs = map attributeName (orderedAttributes attrs)

125

198

126-- take two attribute sets and return an attribute set with the attributes which do not match

199-- take two attribute sets and return an attribute set with the attributes which do not match

200+--this is the function which benefits the most from the HashSet representation- this turned up in the insert performance test

127attributesDifference :: Attributes -> Attributes -> Attributes

201attributesDifference :: Attributes -> Attributes -> Attributes

128−attributesDifference attrsA attrsB = V.fromList $ diff (V.toList attrsA) (V.toList attrsB)

202+{-attributesDifference attrsA attrsB = V.fromList $ diff (V.toList attrsA) (V.toList attrsB)

129 where

203 where

130 diff a b = (a L.\\ b) ++ (b L.\\ a)

204 diff a b = (a L.\\ b) ++ (b L.\\ a)

205+-}

206+attributesDifference attrsA attrsB =

207+ if attributesSet attrsA == attributesSet attrsB then

208+ mempty

209+ else

210+ Attributes {

211+ attributesVec = vec

212+ --,attributesSet = hset

213+ }

214+ where

215+ hset = HS.difference setA setB <> HS.difference setB setA

216+ setA = attributesSet attrsA

217+ setB = attributesSet attrsB

218+ vec = V.filter (`HS.member` hset) (attributesVec attrsA <> attributesVec attrsB)

131

219

132vectorUniqueify :: (Hash.Hashable a, Eq a) => V.Vector a -> V.Vector a

220vectorUniqueify :: (Hash.Hashable a, Eq a) => V.Vector a -> V.Vector a

133vectorUniqueify vecIn = V.fromList $ HS.toList $ HS.fromList $ V.toList vecIn

221vectorUniqueify vecIn = V.fromList $ HS.toList $ HS.fromList $ V.toList vecIn

134

222

135--check that each attribute only appears once

223--check that each attribute only appears once

136verifyAttributes :: Attributes -> Either RelationalError Attributes

224verifyAttributes :: Attributes -> Either RelationalError Attributes

137−verifyAttributes attrs = if collapsedAttrs /= attrs then

225+verifyAttributes attrs =

226+ if vecSet == attributesSet attrs then

227+ pure attrs

228+ else

138− Left (TupleAttributeTypeMismatchError (attributesDifference collapsedAttrs attrs))

229+ Left (TupleAttributeTypeMismatchError diffAttrs)

139− else

140− Right attrs

141 where

230 where

142− collapsedAttrs = vectorUniqueify attrs

231+ vecSet = V.foldr' HS.insert HS.empty (attributesVec attrs)

232+ diffSet = HS.difference vecSet (attributesSet attrs) <> HS.difference (attributesSet attrs) vecSet

233+ diffAttrs = Attributes {

234+ attributesVec = V.fromList (HS.toList diffSet)

235+ --,attributesSet = diffSet

236+ }

237+

238+--used in Generics derivation for ADTs without named attributes- not to be used elsewhere

239+--drop first n attributes from vector representation

240+drop :: Int -> Attributes -> Attributes

241+drop c attrs = Attributes { attributesVec = vec

242+ }

243+ where

244+ vec = V.drop c (attributesVec attrs)

245+

246+

247+-- use this in preference to attributesEqual when the attribute ordering matters such as during tuple unions

248+attributesAndOrderEqual :: Attributes -> Attributes -> Bool

249+attributesAndOrderEqual a b = attributesVec a == attributesVec b

143

250

251+-- use to determine if the same attributes are contained (but ordering is irrelevant)

144attributesEqual :: Attributes -> Attributes -> Bool

252attributesEqual :: Attributes -> Attributes -> Bool

145−attributesEqual attrs1 attrs2 = V.null (attributesDifference attrs1 attrs2)

253+attributesEqual attrsA attrsB =

254+ attributesVec attrsA == attributesVec attrsB ||

255+ attributesSet attrsA == attributesSet attrsB

146

256

147attributesAsMap :: Attributes -> M.Map AttributeName Attribute

257attributesAsMap :: Attributes -> M.Map AttributeName Attribute

148−attributesAsMap attrs = (M.fromList . V.toList) (V.map (\attr -> (attributeName attr, attr)) attrs)

258+attributesAsMap attrs = V.foldr' (\attr acc -> M.insert (attributeName attr) attr acc) mempty (attributesVec attrs)

259+

149

260

150-- | Left-biased union of attributes.

261-- | Left-biased union of attributes.

151union :: Attributes -> Attributes -> Attributes

262union :: Attributes -> Attributes -> Attributes

152−union attrsA attrsB = V.fromList (M.elems unioned)

263+union attrsA attrsB = Attributes {

264+ attributesVec = vec

265+ --,attributesSet = hset

266+ }

153 where

267 where

154− unioned = M.union (attributesAsMap attrsA) (attributesAsMap attrsB)

268+ hset = HS.union (attributesSet attrsA) (attributesSet attrsB)

269+ vec = HS.foldr (flip V.snoc) mempty hset

155

270

156intersection :: Attributes -> Attributes -> Attributes

271intersection :: Attributes -> Attributes -> Attributes

157−intersection attrsA attrsB = V.fromList (M.elems intersected)

272+intersection attrsA attrsB = Attributes {

273+ attributesVec = vec

274+ --,attributesSet = hset

275+ }

158 where

276 where

159− intersected = M.intersection (attributesAsMap attrsA) (attributesAsMap attrsB)

277+ hset = HS.intersection (attributesSet attrsA) (attributesSet attrsB)

278+ vec = HS.foldr (flip V.snoc) mempty hset

src/lib/ProjectM36/Base.hs+127−115

@@ -1,10 +1,12 @@

1−{-# LANGUAGE ExistentialQuantification,DeriveGeneric,DeriveAnyClass,FlexibleInstances,OverloadedStrings, DeriveFoldable, DeriveFunctor #-}

1+{-# LANGUAGE ExistentialQuantification,DeriveGeneric,DeriveAnyClass,FlexibleInstances,OverloadedStrings, DeriveTraversable, DerivingVia, TemplateHaskell, TypeFamilies #-}

2{-# OPTIONS_GHC -fno-warn-orphans #-}

3

4module ProjectM36.Base where

5import ProjectM36.DatabaseContextFunctionError

6import ProjectM36.AtomFunctionError

7+import ProjectM36.MerkleHash

7

8

9+import Data.Functor.Foldable.TH

8import qualified Data.Map as M

10import qualified Data.Map as M

9import qualified Data.HashSet as HS

11import qualified Data.HashSet as HS

10import Data.Hashable (Hashable, hashWithSalt)

12import Data.Hashable (Hashable, hashWithSalt)

@@ -13,19 +15,21 @@ import Data.UUID (UUID)

13import Control.DeepSeq (NFData, rnf)

15import Control.DeepSeq (NFData, rnf)

14import Control.DeepSeq.Generics (genericRnf)

16import Control.DeepSeq.Generics (genericRnf)

15import GHC.Generics (Generic)

17import GHC.Generics (Generic)

18+import GHC.Stack

16import qualified Data.Vector as V

19import qualified Data.Vector as V

17import qualified Data.List as L

20import qualified Data.List as L

18import Data.Text (Text,unpack)

21import Data.Text (Text,unpack)

19−import Data.Binary

20−import Data.Vector.Binary()

21import Data.Time.Clock

22import Data.Time.Clock

22−import Data.Time.Clock.POSIX

23−import Data.Time.Calendar (Day,toGregorian,fromGregorian)

24import Data.Hashable.Time ()

23import Data.Hashable.Time ()

24+import Data.Time.Calendar (Day)

25import Data.Typeable

26import Data.ByteString (ByteString)

27import qualified Data.List.NonEmpty as NE

28+import Data.Vector.Instances ()

29+

28type StringType = Text

30type StringType = Text

31+

32+type DatabaseName = String

29

33

30-- | Database atoms are the smallest, undecomposable units of a tuple. Common examples are integers, text, or unique identity keys.

34-- | Database atoms are the smallest, undecomposable units of a tuple. Common examples are integers, text, or unique identity keys.

31data Atom = IntegerAtom Integer |

35data Atom = IntegerAtom Integer |

@@ -37,8 +41,9 @@ data Atom = IntegerAtom Integer |

37 ByteStringAtom ByteString |

41 ByteStringAtom ByteString |

38 BoolAtom Bool |

42 BoolAtom Bool |

39 RelationAtom Relation |

43 RelationAtom Relation |

44+ RelationalExprAtom RelationalExpr | --used for returning inc deps

40 ConstructedAtom DataConstructorName AtomType [Atom]

45 ConstructedAtom DataConstructorName AtomType [Atom]

41− deriving (Eq, Show, Binary, Typeable, NFData, Generic)

46+ deriving (Eq, Show, Typeable, NFData, Generic, Read)

42

47

43instance Hashable Atom where

48instance Hashable Atom where

44 hashWithSalt salt (ConstructedAtom dConsName _ atoms) = salt `hashWithSalt` atoms

49 hashWithSalt salt (ConstructedAtom dConsName _ atoms) = salt `hashWithSalt` atoms

@@ -52,16 +57,7 @@ instance Hashable Atom where

52 hashWithSalt salt (ByteStringAtom bs) = salt `hashWithSalt` bs

57 hashWithSalt salt (ByteStringAtom bs) = salt `hashWithSalt` bs

53 hashWithSalt salt (BoolAtom b) = salt `hashWithSalt` b

58 hashWithSalt salt (BoolAtom b) = salt `hashWithSalt` b

54 hashWithSalt salt (RelationAtom r) = salt `hashWithSalt` r

59 hashWithSalt salt (RelationAtom r) = salt `hashWithSalt` r

55−

60+ hashWithSalt salt (RelationalExprAtom re) = salt `hashWithSalt` re

56−instance Binary UTCTime where

57− put utc = put $ toRational (utcTimeToPOSIXSeconds utc)

58− get = posixSecondsToUTCTime . fromRational <$> (get :: Get Rational)

59−

60−instance Binary Day where

61− put day = put $ toGregorian day

62− get = do

63− (y,m,d) <- get :: Get (Integer, Int, Int)

64− return (fromGregorian y m d)

65

61

66-- I suspect the definition of ConstructedAtomType with its name alone is insufficient to disambiguate the cases; for example, one could create a type named X, remove a type named X, and re-add it using different constructors. However, as long as requests are served from only one DatabaseContext at-a-time, the type name is unambiguous. This will become a problem for time-travel, however.

62-- I suspect the definition of ConstructedAtomType with its name alone is insufficient to disambiguate the cases; for example, one could create a type named X, remove a type named X, and re-add it using different constructors. However, as long as requests are served from only one DatabaseContext at-a-time, the type name is unambiguous. This will become a problem for time-travel, however.

67-- | The AtomType uniquely identifies the type of a atom.

63-- | The AtomType uniquely identifies the type of a atom.

@@ -75,12 +71,15 @@ data AtomType = IntAtomType |

75 BoolAtomType |

71 BoolAtomType |

76 RelationAtomType Attributes |

72 RelationAtomType Attributes |

77 ConstructedAtomType TypeConstructorName TypeVarMap |

73 ConstructedAtomType TypeConstructorName TypeVarMap |

74+ RelationalExprAtomType |

78 TypeVariableType TypeVarName

75 TypeVariableType TypeVarName

79 --wildcard used in Atom Functions and tuples for data constructors which don't provide all arguments to the type constructor

76 --wildcard used in Atom Functions and tuples for data constructors which don't provide all arguments to the type constructor

80− deriving (Eq, NFData, Generic, Binary, Show)

77+ deriving (Eq, NFData, Generic, Show, Read, Hashable)

81

78

82instance Ord AtomType where

79instance Ord AtomType where

83− compare = undefined

80+ compare = undefined

81+

82+-- this should probably be an ordered dictionary in order to be able to round-trip these arguments

84type TypeVarMap = M.Map TypeVarName AtomType

83type TypeVarMap = M.Map TypeVarName AtomType

85

84

86instance Hashable TypeVarMap where

85instance Hashable TypeVarMap where

@@ -95,25 +94,37 @@ isRelationAtomType _ = False

95type AttributeName = StringType

94type AttributeName = StringType

96

95

97-- | A relation's type is composed of attribute names and types.

96-- | A relation's type is composed of attribute names and types.

98−data Attribute = Attribute AttributeName AtomType deriving (Eq, Show, Generic, NFData, Binary)

97+data Attribute = Attribute AttributeName AtomType deriving (Eq, Show, Read, Generic, NFData)

99

98

100instance Hashable Attribute where

99instance Hashable Attribute where

101 hashWithSalt salt (Attribute attrName _) = hashWithSalt salt attrName

100 hashWithSalt salt (Attribute attrName _) = hashWithSalt salt attrName

102

101

102+type AttributesHash = Int

103+

103-- | 'Attributes' represent the head of a relation.

104-- | 'Attributes' represent the head of a relation.

105+newtype Attributes = Attributes {

104−type Attributes = V.Vector Attribute

106+ attributesVec :: V.Vector Attribute

107+ --,attributesSet :: HS.HashSet Attribute --compare with this generated in heap profile and benchmarks

108+ }

109+ deriving (NFData, Read, Hashable, Generic)

110+

111+attributesSet :: Attributes -> HS.HashSet Attribute

112+attributesSet = HS.fromList . V.toList . attributesVec

113+

114+instance Show Attributes where

115+ show attrs = "attributesFromList [" <> L.intercalate ", " (map (\attr -> "(" <> show attr <> ")") (V.toList (attributesVec attrs))) <> "]"

116+

117+--when attribute ordering is irrelevant

118+instance Eq Attributes where

119+ attrsA == attrsB =

120+ attributesVec attrsA == attributesVec attrsB ||

121+ attributesSet attrsA == attributesSet attrsB

105

122

106−-- | Equality function for a set of attributes.

107−attributesEqual :: Attributes -> Attributes -> Bool

108−attributesEqual attrs1 attrs2 = attrsAsSet attrs1 == attrsAsSet attrs2

109− where

110− attrsAsSet = HS.fromList . V.toList

111−

112sortedAttributesIndices :: Attributes -> [(Int, Attribute)]

123sortedAttributesIndices :: Attributes -> [(Int, Attribute)]

113−sortedAttributesIndices attrs = L.sortBy (\(_, Attribute name1 _) (_,Attribute name2 _) -> compare name1 name2) $ V.toList (V.indexed attrs)

124+sortedAttributesIndices attrs = L.sortBy (\(_, Attribute name1 _) (_,Attribute name2 _) -> compare name1 name2) $ V.toList (V.indexed (attributesVec attrs))

114

125

115-- | The relation's tuple set is the body of the relation.

126-- | The relation's tuple set is the body of the relation.

116−newtype RelationTupleSet = RelationTupleSet { asList :: [RelationTuple] } deriving (Hashable, Show, Generic, Binary)

127+newtype RelationTupleSet = RelationTupleSet { asList :: [RelationTuple] } deriving (Hashable, Show, Generic, Read)

117

128

118instance Read Relation where

129instance Read Relation where

119 readsPrec = error "relation read not supported"

130 readsPrec = error "relation read not supported"

@@ -129,8 +140,8 @@ instance NFData RelationTupleSet where rnf = genericRnf

129instance Hashable RelationTuple where

140instance Hashable RelationTuple where

130 --sanity check the tuple for attribute and tuple counts

141 --sanity check the tuple for attribute and tuple counts

131 --this bit me when tuples were being hashed before being verified

142 --this bit me when tuples were being hashed before being verified

132− hashWithSalt salt (RelationTuple attrs tupVec) = if V.length attrs /= V.length tupVec then

143+ hashWithSalt salt (RelationTuple attrs tupVec) = if V.length (attributesVec attrs) /= V.length tupVec then

133− error "invalid tuple: attributes and tuple count mismatch"

144+ error ("invalid tuple: attributes and tuple count mismatch " <> show (attributesVec attrs, tupVec))

134 else

145 else

135 salt `hashWithSalt`

146 salt `hashWithSalt`

136 sortedAttrs `hashWithSalt`

147 sortedAttrs `hashWithSalt`

@@ -141,25 +152,23 @@ instance Hashable RelationTuple where

141 sortedTupVec = V.map (\(index, _) -> tupVec V.! index) $ V.fromList sortedAttrsIndices

152 sortedTupVec = V.map (\(index, _) -> tupVec V.! index) $ V.fromList sortedAttrsIndices

142

153

143-- | A tuple is a set of attributes mapped to their 'Atom' values.

154-- | A tuple is a set of attributes mapped to their 'Atom' values.

144−data RelationTuple = RelationTuple Attributes (V.Vector Atom) deriving (Show, Generic)

155+data RelationTuple = RelationTuple Attributes (V.Vector Atom) deriving (Show, Read, Generic)

145−

146−instance Binary RelationTuple

147

156

148instance Eq RelationTuple where

157instance Eq RelationTuple where

149− (==) tuple1@(RelationTuple attrs1 _) tuple2@(RelationTuple attrs2 _) = attributesEqual attrs1 attrs2 && atomsEqual

158+ tuple1@(RelationTuple attrs1 _) == tuple2@(RelationTuple attrs2 _) =

159+ attrs1 == attrs2 && atomsEqual

150 where

160 where

151− atomForAttribute attr (RelationTuple attrs tupVec) = case V.findIndex (== attr) attrs of

161+ atomForAttribute attr (RelationTuple attrs tupVec) = case V.findIndex (== attr) (attributesVec attrs) of

152 Nothing -> Nothing

162 Nothing -> Nothing

153 Just index -> tupVec V.!? index

163 Just index -> tupVec V.!? index

154− atomsEqual = V.all (== True) $ V.map (\attr -> atomForAttribute attr tuple1 == atomForAttribute attr tuple2) attrs1

164+ atomsEqual = V.all (== True) $ V.map (\attr -> atomForAttribute attr tuple1 == atomForAttribute attr tuple2) (attributesVec attrs1)

155

165

156instance NFData RelationTuple where rnf = genericRnf

166instance NFData RelationTuple where rnf = genericRnf

157

167

158−

159data Relation = Relation Attributes RelationTupleSet deriving (Show, Generic,Typeable)

168data Relation = Relation Attributes RelationTupleSet deriving (Show, Generic,Typeable)

160

169

161instance Eq Relation where

170instance Eq Relation where

162− Relation attrs1 tupSet1 == Relation attrs2 tupSet2 = attributesEqual attrs1 attrs2 && tupSet1 == tupSet2

171+ Relation attrs1 tupSet1 == Relation attrs2 tupSet2 = attrs1 == attrs2 && tupSet1 == tupSet2

163

172

164instance NFData Relation where rnf = genericRnf

173instance NFData Relation where rnf = genericRnf

165

174

@@ -170,8 +179,6 @@ instance Hashable Relation where

170 where

179 where

171 sortedAttrs = map snd (sortedAttributesIndices attrs)

180 sortedAttrs = map snd (sortedAttributesIndices attrs)

172

181

173−instance Binary Relation

174−

175-- | Used to represent the number of tuples in a relation.

182-- | Used to represent the number of tuples in a relation.

176data RelationCardinality = Countable | Finite Int deriving (Eq, Show, Generic, Ord)

183data RelationCardinality = Countable | Finite Int deriving (Eq, Show, Generic, Ord)

177

184

@@ -183,7 +190,7 @@ type RelationalExpr = RelationalExprBase ()

183-- | A relational expression represents query (read) operations on a database.

190-- | A relational expression represents query (read) operations on a database.

184data RelationalExprBase a =

191data RelationalExprBase a =

185 --- | Create a relation from tuple expressions.

192 --- | Create a relation from tuple expressions.

186− MakeRelationFromExprs (Maybe [AttributeExprBase a]) [TupleExprBase a] |

193+ MakeRelationFromExprs (Maybe [AttributeExprBase a]) (TupleExprsBase a) |

187 --- | Create and reference a relation from attributes and a tuple set.

194 --- | Create and reference a relation from attributes and a tuple set.

188 MakeStaticRelation Attributes RelationTupleSet |

195 MakeStaticRelation Attributes RelationTupleSet |

189 --- | Reference an existing relation in Haskell-space.

196 --- | Reference an existing relation in Haskell-space.

@@ -216,21 +223,17 @@ data RelationalExprBase a =

216 --Summarize :: AtomExpr -> AttributeName -> RelationalExpr -> RelationalExpr -> RelationalExpr -- a special case of Extend

223 --Summarize :: AtomExpr -> AttributeName -> RelationalExpr -> RelationalExpr -> RelationalExpr -- a special case of Extend

217 --Evaluate relationalExpr with scoped views

224 --Evaluate relationalExpr with scoped views

218 With [(WithNameExprBase a, RelationalExprBase a)] (RelationalExprBase a)

225 With [(WithNameExprBase a, RelationalExprBase a)] (RelationalExprBase a)

219− deriving (Show, Eq, Generic, NFData, Foldable, Functor)

226+ deriving (Show, Read, Eq, Generic, NFData, Foldable, Functor, Traversable)

220−

221−instance Binary RelationalExpr

222

227

228+instance Hashable RelationalExpr

229+

223data WithNameExprBase a = WithNameExpr RelVarName a

230data WithNameExprBase a = WithNameExpr RelVarName a

224− deriving (Show, Eq, Generic, NFData, Foldable, Functor)

231+ deriving (Show, Read, Eq, Generic, NFData, Foldable, Functor, Traversable, Hashable)

225

232

226type WithNameExpr = WithNameExprBase ()

233type WithNameExpr = WithNameExprBase ()

227

234

228−instance Binary WithNameExpr

235+type GraphRefWithNameExpr = WithNameExprBase GraphRefTransactionMarker

229

236

230−type GraphRefWithNameExpr = WithNameExprBase TransactionId

231−

232−instance Binary GraphRefWithNameExpr

233−

234type NotificationName = StringType

237type NotificationName = StringType

235type Notifications = M.Map NotificationName Notification

238type Notifications = M.Map NotificationName Notification

236

239

@@ -240,22 +243,22 @@ data Notification = Notification {

240 reportOldExpr :: RelationalExpr, --run the expression in the pre-change context

243 reportOldExpr :: RelationalExpr, --run the expression in the pre-change context

241 reportNewExpr :: RelationalExpr --run the expression in the post-change context

244 reportNewExpr :: RelationalExpr --run the expression in the post-change context

242 }

245 }

243− deriving (Show, Eq, Binary, Generic, NFData)

246+ deriving (Show, Eq, Generic, NFData)

244

247

245type TypeVarName = StringType

248type TypeVarName = StringType

246

249

247-- | Metadata definition for type constructors such as @data Either a b@.

250-- | Metadata definition for type constructors such as @data Either a b@.

248data TypeConstructorDef = ADTypeConstructorDef TypeConstructorName [TypeVarName] |

251data TypeConstructorDef = ADTypeConstructorDef TypeConstructorName [TypeVarName] |

249 PrimitiveTypeConstructorDef TypeConstructorName AtomType

252 PrimitiveTypeConstructorDef TypeConstructorName AtomType

250− deriving (Show, Generic, Binary, Eq, NFData)

253+ deriving (Show, Generic, Eq, NFData, Hashable, Read)

251

254

252-- | Found in data constructors and type declarations: Left (Either Int Text) | Right Int

255-- | Found in data constructors and type declarations: Left (Either Int Text) | Right Int

253type TypeConstructor = TypeConstructorBase ()

256type TypeConstructor = TypeConstructorBase ()

254data TypeConstructorBase a = ADTypeConstructor TypeConstructorName [TypeConstructor] |

257data TypeConstructorBase a = ADTypeConstructor TypeConstructorName [TypeConstructor] |

255− PrimitiveTypeConstructor TypeConstructorName AtomType |

258+ PrimitiveTypeConstructor TypeConstructorName AtomType |

256− RelationAtomTypeConstructor [AttributeExprBase a] |

259+ RelationAtomTypeConstructor [AttributeExprBase a] |

257− TypeVariable TypeVarName

260+ TypeVariable TypeVarName

258− deriving (Show, Generic, Binary, Eq, NFData)

261+ deriving (Show, Generic, Eq, NFData, Hashable, Read)

259

262

260type TypeConstructorMapping = [(TypeConstructorDef, DataConstructorDefs)]

263type TypeConstructorMapping = [(TypeConstructorDef, DataConstructorDefs)]

261

264

@@ -265,19 +268,23 @@ type DataConstructorName = StringType

265type AtomTypeName = StringType

268type AtomTypeName = StringType

266

269

267-- | Used to define a data constructor in a type constructor context such as @Left a | Right b@

270-- | Used to define a data constructor in a type constructor context such as @Left a | Right b@

268−data DataConstructorDef = DataConstructorDef DataConstructorName [DataConstructorDefArg] deriving (Eq, Show, Binary, Generic, NFData)

271+data DataConstructorDef = DataConstructorDef DataConstructorName [DataConstructorDefArg] deriving (Eq, Show, Generic, NFData, Hashable, Read)

269

272

270type DataConstructorDefs = [DataConstructorDef]

273type DataConstructorDefs = [DataConstructorDef]

271

274

272data DataConstructorDefArg = DataConstructorDefTypeConstructorArg TypeConstructor |

275data DataConstructorDefArg = DataConstructorDefTypeConstructorArg TypeConstructor |

273 DataConstructorDefTypeVarNameArg TypeVarName

276 DataConstructorDefTypeVarNameArg TypeVarName

274− deriving (Show, Generic, Binary, Eq, NFData)

277+ deriving (Show, Generic, Eq, NFData, Hashable, Read)

275

278

276type InclusionDependencies = M.Map IncDepName InclusionDependency

279type InclusionDependencies = M.Map IncDepName InclusionDependency

277type RelationVariables = M.Map RelVarName GraphRefRelationalExpr

280type RelationVariables = M.Map RelVarName GraphRefRelationalExpr

278

281

282+data GraphRefTransactionMarker = TransactionMarker TransactionId |

283+ UncommittedContextMarker

284+ deriving (Eq, Show, Generic, NFData, Ord)

285+

279-- a fundamental relational expr to which other relational expressions compile

286-- a fundamental relational expr to which other relational expressions compile

280−type GraphRefRelationalExpr = RelationalExprBase TransactionId

287+type GraphRefRelationalExpr = RelationalExprBase GraphRefTransactionMarker

281

288

282type SchemaName = StringType

289type SchemaName = StringType

283

290

@@ -285,17 +292,18 @@ type Subschemas = M.Map SchemaName Schema

285

292

286-- | Every transaction has one concrete database context and any number of isomorphic subschemas.

293-- | Every transaction has one concrete database context and any number of isomorphic subschemas.

287data Schemas = Schemas DatabaseContext Subschemas

294data Schemas = Schemas DatabaseContext Subschemas

295+ deriving (Generic)

288

296

289-- | The DatabaseContext is a snapshot of a database's evolving state and contains everything a database client can change over time.

297-- | The DatabaseContext is a snapshot of a database's evolving state and contains everything a database client can change over time.

290-- I spent some time thinking about whether the VirtualDatabaseContext/Schema and DatabaseContext data constructors should be the same constructor, but that would allow relation variables to be created in a "virtual" context which would appear to defeat the isomorphisms of the contexts. It should be possible to switch to an alternative schema to view the same equivalent information without information loss. However, allowing all contexts to reference another context while maintaining its own relation variables, new types, etc. could be interesting from a security perspective. For example, if a user creates a new relvar in a virtual context, then does it necessarily appear in all linked contexts? After deliberation, I think the relvar should appear in *all* linked contexts to retain the isomorphic properties, even when the isomorphism is for a subset of the context. This hints that the IsoMorphs should allow for "fall-through"; that is, when a relvar is not defined in the virtual context (for morphing), then the lookup should fall through to the underlying context.

298-- I spent some time thinking about whether the VirtualDatabaseContext/Schema and DatabaseContext data constructors should be the same constructor, but that would allow relation variables to be created in a "virtual" context which would appear to defeat the isomorphisms of the contexts. It should be possible to switch to an alternative schema to view the same equivalent information without information loss. However, allowing all contexts to reference another context while maintaining its own relation variables, new types, etc. could be interesting from a security perspective. For example, if a user creates a new relvar in a virtual context, then does it necessarily appear in all linked contexts? After deliberation, I think the relvar should appear in *all* linked contexts to retain the isomorphic properties, even when the isomorphism is for a subset of the context. This hints that the IsoMorphs should allow for "fall-through"; that is, when a relvar is not defined in the virtual context (for morphing), then the lookup should fall through to the underlying context.

291newtype Schema = Schema SchemaIsomorphs

299newtype Schema = Schema SchemaIsomorphs

292− deriving (Generic, Binary)

300+ deriving (Generic)

293

301

294data SchemaIsomorph = IsoRestrict RelVarName RestrictionPredicateExpr (RelVarName, RelVarName) |

302data SchemaIsomorph = IsoRestrict RelVarName RestrictionPredicateExpr (RelVarName, RelVarName) |

295 IsoRename RelVarName RelVarName |

303 IsoRename RelVarName RelVarName |

296 IsoUnion (RelVarName, RelVarName) RestrictionPredicateExpr RelVarName --maps two relvars to one relvar

304 IsoUnion (RelVarName, RelVarName) RestrictionPredicateExpr RelVarName --maps two relvars to one relvar

297 -- IsoTypeConstructor in morphAttrExpr

305 -- IsoTypeConstructor in morphAttrExpr

298− deriving (Generic, Binary, Show)

306+ deriving (Generic, Show)

299

307

300type SchemaIsomorphs = [SchemaIsomorph]

308type SchemaIsomorphs = [SchemaIsomorph]

301

309

@@ -311,9 +319,7 @@ data DatabaseContext = DatabaseContext {

311type IncDepName = StringType

319type IncDepName = StringType

312

320

313-- | Inclusion dependencies represent every possible database constraint. Constraints enforce specific, arbitrarily-complex rules to which the database context's relation variables must adhere unconditionally.

321-- | Inclusion dependencies represent every possible database constraint. Constraints enforce specific, arbitrarily-complex rules to which the database context's relation variables must adhere unconditionally.

314−data InclusionDependency = InclusionDependency RelationalExpr RelationalExpr deriving (Show, Eq, Generic, NFData)

322+data InclusionDependency = InclusionDependency RelationalExpr RelationalExpr deriving (Show, Eq, Generic, NFData, Hashable, Read)

315−

316−instance Binary InclusionDependency

317

323

318type AttributeNameAtomExprMap = M.Map AttributeName AtomExpr

324type AttributeNameAtomExprMap = M.Map AttributeName AtomExpr

319

325

@@ -322,9 +328,9 @@ type DatabaseContextExprName = StringType

322

328

323type DatabaseContextExpr = DatabaseContextExprBase ()

329type DatabaseContextExpr = DatabaseContextExprBase ()

324

330

325−type GraphRefDatabaseContextExpr = DatabaseContextExprBase TransactionId

331+instance Hashable DatabaseContextExpr

326

332

327−instance Binary GraphRefDatabaseContextExpr

333+type GraphRefDatabaseContextExpr = DatabaseContextExprBase GraphRefTransactionMarker

328

334

329-- | Database context expressions modify the database context.

335-- | Database context expressions modify the database context.

330data DatabaseContextExprBase a =

336data DatabaseContextExprBase a =

@@ -353,9 +359,10 @@ data DatabaseContextExprBase a =

353 ExecuteDatabaseContextFunction DatabaseContextFunctionName [AtomExprBase a] |

359 ExecuteDatabaseContextFunction DatabaseContextFunctionName [AtomExprBase a] |

354

360

355 MultipleExpr [DatabaseContextExprBase a]

361 MultipleExpr [DatabaseContextExprBase a]

356− deriving (Show, Eq, Generic)

362+ deriving (Show, Read, Eq, Generic, NFData)

357

363

358−instance Binary DatabaseContextExpr

364+instance Hashable (M.Map AttributeName AtomExpr) where

365+ hashWithSalt salt m = salt `hashWithSalt` M.toList m

359

366

360type ObjModuleName = StringType

367type ObjModuleName = StringType

361type ObjFunctionName = StringType

368type ObjFunctionName = StringType

@@ -367,15 +374,17 @@ data DatabaseContextIOExprBase a =

367 AddDatabaseContextFunction DatabaseContextFunctionName [TypeConstructor] DatabaseContextFunctionBodyScript |

374 AddDatabaseContextFunction DatabaseContextFunctionName [TypeConstructor] DatabaseContextFunctionBodyScript |

368 LoadDatabaseContextFunctions ObjModuleName ObjFunctionName FilePath |

375 LoadDatabaseContextFunctions ObjModuleName ObjFunctionName FilePath |

369 CreateArbitraryRelation RelVarName [AttributeExprBase a] Range

376 CreateArbitraryRelation RelVarName [AttributeExprBase a] Range

370− deriving (Show, Eq, Generic, Binary)

377+ deriving (Show, Eq, Generic)

371

378

372−type GraphRefDatabaseContextIOExpr = DatabaseContextIOExprBase TransactionId

379+type GraphRefDatabaseContextIOExpr = DatabaseContextIOExprBase GraphRefTransactionMarker

373

380

374type DatabaseContextIOExpr = DatabaseContextIOExprBase ()

381type DatabaseContextIOExpr = DatabaseContextIOExprBase ()

375

382

376type RestrictionPredicateExpr = RestrictionPredicateExprBase ()

383type RestrictionPredicateExpr = RestrictionPredicateExprBase ()

377

384

385+instance Hashable RestrictionPredicateExpr

386+

378−type GraphRefRestrictionPredicateExpr = RestrictionPredicateExprBase TransactionId

387+type GraphRefRestrictionPredicateExpr = RestrictionPredicateExprBase GraphRefTransactionMarker

379

388

380-- | Restriction predicates are boolean algebra components which, when composed, indicate whether or not a tuple should be retained during a restriction (filtering) operation.

389-- | Restriction predicates are boolean algebra components which, when composed, indicate whether or not a tuple should be retained during a restriction (filtering) operation.

381data RestrictionPredicateExprBase a =

390data RestrictionPredicateExprBase a =

@@ -386,9 +395,7 @@ data RestrictionPredicateExprBase a =

386 RelationalExprPredicate (RelationalExprBase a) | --type must be same as true and false relations (no attributes)

395 RelationalExprPredicate (RelationalExprBase a) | --type must be same as true and false relations (no attributes)

387 AtomExprPredicate (AtomExprBase a) | --atom must evaluate to boolean

396 AtomExprPredicate (AtomExprBase a) | --atom must evaluate to boolean

388 AttributeEqualityPredicate AttributeName (AtomExprBase a) -- relationalexpr must result in relation with single tuple

397 AttributeEqualityPredicate AttributeName (AtomExprBase a) -- relationalexpr must result in relation with single tuple

389− deriving (Show, Eq, Generic, NFData, Foldable, Functor)

398+ deriving (Show, Read, Eq, Generic, NFData, Foldable, Functor, Traversable)

390−

391−instance Binary RestrictionPredicateExpr

392

399

393-- child + parent links

400-- child + parent links

394-- | A transaction graph's head name references the leaves of the transaction graph and can be used during session creation to indicate at which point in the graph commits should persist.

401-- | A transaction graph's head name references the leaves of the transaction graph and can be used during session creation to indicate at which point in the graph commits should persist.

@@ -398,6 +405,7 @@ type TransactionHeads = M.Map HeadName Transaction

398

405

399-- | The transaction graph is the global database's state which references every committed transaction.

406-- | The transaction graph is the global database's state which references every committed transaction.

400data TransactionGraph = TransactionGraph TransactionHeads (S.Set Transaction)

407data TransactionGraph = TransactionGraph TransactionHeads (S.Set Transaction)

408+ deriving Generic

401

409

402transactionHeadsForGraph :: TransactionGraph -> TransactionHeads

410transactionHeadsForGraph :: TransactionGraph -> TransactionHeads

403transactionHeadsForGraph (TransactionGraph hs _) = hs

411transactionHeadsForGraph (TransactionGraph hs _) = hs

@@ -409,7 +417,8 @@ transactionsForGraph (TransactionGraph _ ts) = ts

409-- The `TransactionDiff`s represent child/edge relationships to previous transactions (branches or continuations of the same branch).

417-- The `TransactionDiff`s represent child/edge relationships to previous transactions (branches or continuations of the same branch).

410data TransactionInfo = TransactionInfo {

418data TransactionInfo = TransactionInfo {

411 parents :: TransactionParents,

419 parents :: TransactionParents,

412− stamp :: UTCTime

420+ stamp :: UTCTime,

421+ merkleHash :: MerkleHash

413 } deriving (Show, Generic)

422 } deriving (Show, Generic)

414

423

415type TransactionParents = NE.NonEmpty TransactionId

424type TransactionParents = NE.NonEmpty TransactionId

@@ -419,16 +428,15 @@ data TransactionInfo = TransactionInfo TransactionId TransactionDiffs UTCTime |

419 deriving (Show, Generic)

428 deriving (Show, Generic)

420-}

429-}

421

430

422−instance Binary TransactionInfo

423−

424-- | Every set of modifications made to the database are atomically committed to the transaction graph as a transaction.

431-- | Every set of modifications made to the database are atomically committed to the transaction graph as a transaction.

425type TransactionId = UUID

432type TransactionId = UUID

426

433

427data Transaction = Transaction TransactionId TransactionInfo Schemas

434data Transaction = Transaction TransactionId TransactionInfo Schemas

435+ deriving Generic

428

436

429-- | The disconnected transaction represents an in-progress workspace used by sessions before changes are committed. This is similar to git's "index". After a transaction is committed, it is "connected" in the transaction graph and can no longer be modified.

437-- | The disconnected transaction represents an in-progress workspace used by sessions before changes are committed. This is similar to git's "index". After a transaction is committed, it is "connected" in the transaction graph and can no longer be modified.

430−data DisconnectedTransaction = DisconnectedTransaction TransactionId Schemas DatabaseContextExpr

438+data DisconnectedTransaction = DisconnectedTransaction TransactionId Schemas DirtyFlag

431−--the database context expression represents a difference between the disconnected transaction and its immutable parent transaction

439+--the database context expression represents a difference between the disconnected transaction and its immutable parent transaction- is this diff expr used at all?

432

440

433type DirtyFlag = Bool

441type DirtyFlag = Bool

434

442

@@ -448,7 +456,9 @@ instance Ord Transaction where

448

456

449type AtomExpr = AtomExprBase ()

457type AtomExpr = AtomExprBase ()

450

458

459+instance Hashable AtomExpr

460+

451−type GraphRefAtomExpr = AtomExprBase TransactionId

461+type GraphRefAtomExpr = AtomExprBase GraphRefTransactionMarker

452

462

453-- | An atom expression represents an action to take when extending a relation or when statically defining a relation or a new tuple.

463-- | An atom expression represents an action to take when extending a relation or when statically defining a relation or a new tuple.

454data AtomExprBase a = AttributeAtomExpr AttributeName |

464data AtomExprBase a = AttributeAtomExpr AttributeName |

@@ -456,18 +466,17 @@ data AtomExprBase a = AttributeAtomExpr AttributeName |

456 FunctionAtomExpr AtomFunctionName [AtomExprBase a] a |

466 FunctionAtomExpr AtomFunctionName [AtomExprBase a] a |

457 RelationAtomExpr (RelationalExprBase a) |

467 RelationAtomExpr (RelationalExprBase a) |

458 ConstructedAtomExpr DataConstructorName [AtomExprBase a] a

468 ConstructedAtomExpr DataConstructorName [AtomExprBase a] a

459− deriving (Eq,Show,Generic, NFData, Foldable, Functor)

469+ deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable)

460

470

461−instance Binary AtomExpr

462−

463-- | Used in tuple creation when creating a relation.

471-- | Used in tuple creation when creating a relation.

464data ExtendTupleExprBase a = AttributeExtendTupleExpr AttributeName (AtomExprBase a)

472data ExtendTupleExprBase a = AttributeExtendTupleExpr AttributeName (AtomExprBase a)

465− deriving (Show, Eq, Generic, NFData, Foldable, Functor)

473+ deriving (Show, Read, Eq, Generic, NFData, Foldable, Functor, Traversable)

466

474

467type ExtendTupleExpr = ExtendTupleExprBase ()

475type ExtendTupleExpr = ExtendTupleExprBase ()

468−type GraphRefExtendTupleExpr = ExtendTupleExprBase TransactionId

469

476

470−instance Binary ExtendTupleExpr

477+instance Hashable ExtendTupleExpr

478+

479+type GraphRefExtendTupleExpr = ExtendTupleExprBase GraphRefTransactionMarker

471

480

472--enumerates the list of functions available to be run as part of tuple expressions

481--enumerates the list of functions available to be run as part of tuple expressions

473type AtomFunctions = HS.HashSet AtomFunction

482type AtomFunctions = HS.HashSet AtomFunction

@@ -479,6 +488,7 @@ type AtomFunctionBodyScript = StringType

479type AtomFunctionBodyType = [Atom] -> Either AtomFunctionError Atom

488type AtomFunctionBodyType = [Atom] -> Either AtomFunctionError Atom

480

489

481data AtomFunctionBody = AtomFunctionBody (Maybe AtomFunctionBodyScript) AtomFunctionBodyType

490data AtomFunctionBody = AtomFunctionBody (Maybe AtomFunctionBodyScript) AtomFunctionBodyType

491+ deriving Generic

482

492

483instance NFData AtomFunctionBody where

493instance NFData AtomFunctionBody where

484 rnf (AtomFunctionBody mScript _) = rnf mScript

494 rnf (AtomFunctionBody mScript _) = rnf mScript

@@ -513,14 +523,17 @@ data AttributeNamesBase a = AttributeNames (S.Set AttributeName) |

513 UnionAttributeNames (AttributeNamesBase a) (AttributeNamesBase a) |

523 UnionAttributeNames (AttributeNamesBase a) (AttributeNamesBase a) |

514 IntersectAttributeNames (AttributeNamesBase a) (AttributeNamesBase a) |

524 IntersectAttributeNames (AttributeNamesBase a) (AttributeNamesBase a) |

515 RelationalExprAttributeNames (RelationalExprBase a) -- use attribute names from the relational expression's type

525 RelationalExprAttributeNames (RelationalExprBase a) -- use attribute names from the relational expression's type

516− deriving (Eq, Show, Generic, NFData, Foldable, Functor)

526+ deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable)

527+

528+instance Hashable AttributeNames

529+

530+instance Hashable (S.Set AttributeName) where

531+ hashWithSalt salt s = salt `hashWithSalt` S.toList s

517

532

518type AttributeNames = AttributeNamesBase ()

533type AttributeNames = AttributeNamesBase ()

519

534

520−type GraphRefAttributeNames = AttributeNamesBase TransactionId

535+type GraphRefAttributeNames = AttributeNamesBase GraphRefTransactionMarker

521

536

522−instance Binary AttributeNames

523−

524-- | The persistence strategy is a global database option which represents how to persist the database in the filesystem, if at all.

537-- | The persistence strategy is a global database option which represents how to persist the database in the filesystem, if at all.

525data PersistenceStrategy = NoPersistence | -- ^ no filesystem persistence/memory-only database

538data PersistenceStrategy = NoPersistence | -- ^ no filesystem persistence/memory-only database

526 MinimalPersistence FilePath | -- ^ fsync off, not crash-safe

539 MinimalPersistence FilePath | -- ^ fsync off, not crash-safe

@@ -528,22 +541,31 @@ data PersistenceStrategy = NoPersistence | -- ^ no filesystem persistence/memory

528 deriving (Show, Read)

541 deriving (Show, Read)

529

542

530type AttributeExpr = AttributeExprBase ()

543type AttributeExpr = AttributeExprBase ()

531−type GraphRefAttributeExpr = AttributeExprBase TransactionId

544+type GraphRefAttributeExpr = AttributeExprBase GraphRefTransactionMarker

532

545

533-- | Create attributes dynamically.

546-- | Create attributes dynamically.

534data AttributeExprBase a = AttributeAndTypeNameExpr AttributeName TypeConstructor a |

547data AttributeExprBase a = AttributeAndTypeNameExpr AttributeName TypeConstructor a |

535 NakedAttributeExpr Attribute

548 NakedAttributeExpr Attribute

536− deriving (Eq, Show, Generic, Binary, NFData, Foldable, Functor)

549+ deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable, Hashable)

537

550

538-- | Dynamically create a tuple from attribute names and 'AtomExpr's.

551-- | Dynamically create a tuple from attribute names and 'AtomExpr's.

539newtype TupleExprBase a = TupleExpr (M.Map AttributeName (AtomExprBase a))

552newtype TupleExprBase a = TupleExpr (M.Map AttributeName (AtomExprBase a))

540− deriving (Eq, Show, Generic, NFData, Foldable, Functor)

553+ deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable)

541−

554+

542−instance Binary TupleExpr

555+instance Hashable TupleExpr

543

556

544type TupleExpr = TupleExprBase ()

557type TupleExpr = TupleExprBase ()

545

558

546−type GraphRefTupleExpr = TupleExprBase TransactionId

559+type GraphRefTupleExpr = TupleExprBase GraphRefTransactionMarker

560+

561+data TupleExprsBase a = TupleExprs a [TupleExprBase a]

562+ deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable)

563+

564+instance Hashable TupleExprs

565+

566+type GraphRefTupleExprs = TupleExprsBase GraphRefTransactionMarker

567+

568+type TupleExprs = TupleExprsBase ()

547

569

548data MergeStrategy =

570data MergeStrategy =

549 -- | After a union merge, the merge transaction is a result of union'ing relvars of the same name, introducing all uniquely-named relvars, union of constraints, union of atom functions, notifications, and types (unless the names and definitions collide, e.g. two types of the same name with different definitions)

571 -- | After a union merge, the merge transaction is a result of union'ing relvars of the same name, introducing all uniquely-named relvars, union of constraints, union of atom functions, notifications, and types (unless the names and definitions collide, e.g. two types of the same name with different definitions)

@@ -552,7 +574,7 @@ data MergeStrategy =

552 UnionPreferMergeStrategy HeadName |

574 UnionPreferMergeStrategy HeadName |

553 -- | Similar to the our/theirs merge strategy in git, the merge transaction's context is identical to that of the last transaction in the selected branch.

575 -- | Similar to the our/theirs merge strategy in git, the merge transaction's context is identical to that of the last transaction in the selected branch.

554 SelectedBranchMergeStrategy HeadName

576 SelectedBranchMergeStrategy HeadName

555− deriving (Eq, Show, Binary, Generic, NFData)

577+ deriving (Eq, Show, Generic, NFData)

556

578

557type DatabaseContextFunctionName = StringType

579type DatabaseContextFunctionName = StringType

558

580

@@ -589,7 +611,8 @@ attrTypeVars (Attribute _ aType) = case aType of

589 DateTimeAtomType -> S.empty

611 DateTimeAtomType -> S.empty

590 ByteStringAtomType -> S.empty

612 ByteStringAtomType -> S.empty

591 BoolAtomType -> S.empty

613 BoolAtomType -> S.empty

614+ RelationalExprAtomType -> S.empty

592− (RelationAtomType attrs) -> S.unions (map attrTypeVars (V.toList attrs))

615+ (RelationAtomType attrs) -> S.unions (map attrTypeVars (V.toList (attributesVec attrs)))

593 (ConstructedAtomType _ tvMap) -> M.keysSet tvMap

616 (ConstructedAtomType _ tvMap) -> M.keysSet tvMap

594 (TypeVariableType nam) -> S.singleton nam

617 (TypeVariableType nam) -> S.singleton nam

595

618

@@ -612,23 +635,12 @@ atomTypeVars DayAtomType = S.empty

612atomTypeVars DateTimeAtomType = S.empty

635atomTypeVars DateTimeAtomType = S.empty

613atomTypeVars ByteStringAtomType = S.empty

636atomTypeVars ByteStringAtomType = S.empty

614atomTypeVars BoolAtomType = S.empty

637atomTypeVars BoolAtomType = S.empty

638+atomTypeVars RelationalExprAtomType = S.empty

615−atomTypeVars (RelationAtomType attrs) = S.unions (map attrTypeVars (V.toList attrs))

639+atomTypeVars (RelationAtomType attrs) = S.unions (map attrTypeVars (V.toList (attributesVec attrs)))

616atomTypeVars (ConstructedAtomType _ tvMap) = M.keysSet tvMap

640atomTypeVars (ConstructedAtomType _ tvMap) = M.keysSet tvMap

617atomTypeVars (TypeVariableType nam) = S.singleton nam

641atomTypeVars (TypeVariableType nam) = S.singleton nam

618

642

619−unimplemented :: a

643+unimplemented :: HasCallStack => a

620−unimplemented = undefined

644+unimplemented = error "unimplemented"

621−

645+

622−--for serializing GraphRefRelationalExpr as part of transaction serialization

646+makeBaseFunctor ''RelationalExprBase

623−instance Binary (TupleExprBase TransactionId)

624−

625−instance Binary GraphRefRelationalExpr

626−

627−instance Binary (AtomExprBase TransactionId)

628−

629−instance Binary (AttributeNamesBase TransactionId)

630−

631−instance Binary (RestrictionPredicateExprBase TransactionId)

632−

633−instance Binary (ExtendTupleExprBase TransactionId)

634−

src/lib/ProjectM36/Client.hs+211−317

@@ -1,4 +1,4 @@

1−{-# LANGUAGE DeriveAnyClass, DeriveGeneric, ScopedTypeVariables, BangPatterns, PackageImports #-}

1+{-# LANGUAGE DeriveGeneric, ScopedTypeVariables, MonoLocalBinds, DerivingVia #-}

2{-|

3Module: ProjectM36.Client

4

@@ -9,6 +9,7 @@ module ProjectM36.Client

9 Connection(..),

10 Port,

11 Hostname,

12+ ServiceName,

12 DatabaseName,

13 DatabaseName,

13 ConnectionError(..),

14 ConnectionError(..),

14 connectProjectM36,

15 connectProjectM36,

@@ -43,6 +44,7 @@ module ProjectM36.Client

43 defaultDatabaseName,

44 defaultDatabaseName,

44 defaultRemoteConnectionInfo,

45 defaultRemoteConnectionInfo,

45 defaultHeadName,

46 defaultHeadName,

47+ addClientNode,

46 PersistenceStrategy(..),

48 PersistenceStrategy(..),

47 RelationalExpr,

49 RelationalExpr,

48 RelationalExprBase(..),

50 RelationalExprBase(..),

@@ -53,11 +55,9 @@ module ProjectM36.Client

53 Attribute(..),

55 Attribute(..),

54 MergeStrategy(..),

56 MergeStrategy(..),

55 attributesFromList,

57 attributesFromList,

56− createNodeId,

57 createSessionAtCommit,

58 createSessionAtCommit,

58 createSessionAtHead,

59 createSessionAtHead,

59 closeSession,

60 closeSession,

60− addClientNode,

61 callTestTimeout_,

62 RelationCardinality(..),

63 TransactionGraphOperator(..),

@@ -67,7 +67,6 @@ module ProjectM36.Client

67 TransGraphRelationalExpr,

68 TransactionIdLookup(..),

69 TransactionIdHeadBacktrack(..),

70− NodeId(..),

71 Atom(..),

70 Atom(..),

72 Session,

71 Session,

73 SessionId,

72 SessionId,

@@ -80,6 +79,7 @@ module ProjectM36.Client

80 databaseContextExprForUniqueKey,

79 databaseContextExprForUniqueKey,

81 databaseContextExprForForeignKey,

80 databaseContextExprForForeignKey,

82 createScriptedAtomFunction,

81 createScriptedAtomFunction,

82+ ProjectM36.Client.validateMerkleHashes,

83 AttributeExprBase(..),

84 TypeConstructorBase(..),

85 TypeConstructorDef(..),

@@ -99,12 +99,14 @@ module ProjectM36.Client

99 AtomType(..),

100 Atomable(..),

101 TupleExprBase(..),

102+ TupleExprsBase(..),

102 AtomExprBase(..),

103 AtomExprBase(..),

103 RestrictionPredicateExprBase(..),

104 RestrictionPredicateExprBase(..),

104 withTransaction

105 withTransaction

105 ) where

106 ) where

106import ProjectM36.Base hiding (inclusionDependencies) --defined in this module as well

107import ProjectM36.Base hiding (inclusionDependencies) --defined in this module as well

107import qualified ProjectM36.Base as B

108import qualified ProjectM36.Base as B

109+import ProjectM36.Serialise.Error ()

108import ProjectM36.Error

110import ProjectM36.Error

109import ProjectM36.Atomable

111import ProjectM36.Atomable

110import ProjectM36.AtomFunction as AF

112import ProjectM36.AtomFunction as AF

@@ -117,7 +119,7 @@ import Control.Monad.State

117import qualified ProjectM36.RelationalExpression as RE

119import qualified ProjectM36.RelationalExpression as RE

118import ProjectM36.DatabaseContext (basicDatabaseContext)

120import ProjectM36.DatabaseContext (basicDatabaseContext)

119import qualified ProjectM36.TransactionGraph as Graph

121import qualified ProjectM36.TransactionGraph as Graph

120−import ProjectM36.TransactionGraph

122+import ProjectM36.TransactionGraph as TG

121import qualified ProjectM36.Transaction as Trans

123import qualified ProjectM36.Transaction as Trans

122import ProjectM36.TransactionGraph.Persist

124import ProjectM36.TransactionGraph.Persist

123import ProjectM36.Attribute

125import ProjectM36.Attribute

@@ -132,26 +134,16 @@ import ProjectM36.Relation (typesAsRelation)

132import ProjectM36.ScriptSession (initScriptSession, ScriptSession)

134import ProjectM36.ScriptSession (initScriptSession, ScriptSession)

133import qualified ProjectM36.Relation as R

135import qualified ProjectM36.Relation as R

134import Control.Exception.Base

136import Control.Exception.Base

135−import GHC.Conc.Sync

137+import Control.Concurrent.STM

136−

138+import Control.Concurrent.Async

137−import Network.Transport (Transport(closeTransport))

138

139

139−#if MIN_VERSION_network_transport_tcp(0,6,0)

140−import Network.Transport.TCP (createTransport, defaultTCPParameters)

141−import Network.Transport.TCP.Internal (encodeEndPointAddress)

142−#else

143−import Network.Transport.TCP (encodeEndPointAddress, createTransport, defaultTCPParameters)

144−#endif

145−

146−import Control.Distributed.Process.Node (newLocalNode, initRemoteTable, runProcess, LocalNode, forkProcess, closeLocalNode)

147−import Control.Distributed.Process.Extras.Internal.Types (whereisRemote)

148−import Control.Distributed.Process.ManagedProcess.Client (call, safeCall)

149import Data.Either (isRight)

140import Data.Either (isRight)

150import Data.UUID.V4 (nextRandom)

141import Data.UUID.V4 (nextRandom)

151import Data.Word

142import Data.Word

152−import Control.Distributed.Process (ProcessId, Process, receiveWait, send, match, NodeId(..), reconnect)

143+import Data.Hashable

153import Control.Exception (IOException, handle, AsyncException, throwIO, fromException, Exception)

144import Control.Exception (IOException, handle, AsyncException, throwIO, fromException, Exception)

154import Control.Concurrent.MVar

145import Control.Concurrent.MVar

146+import Codec.Winery hiding (Schema, schema)

155import qualified Data.Map as M

147import qualified Data.Map as M

156#if MIN_VERSION_stm_containers(1,0,0)

148#if MIN_VERSION_stm_containers(1,0,0)

157import qualified StmContainers.Map as StmMap

149import qualified StmContainers.Map as StmMap

@@ -163,20 +155,19 @@ import qualified STMContainers.Set as StmSet

163import qualified ProjectM36.Session as Sess

155import qualified ProjectM36.Session as Sess

164import ProjectM36.Session

156import ProjectM36.Session

165import ProjectM36.Sessions

157import ProjectM36.Sessions

166−--import "list-t" ListT

167−import Data.Binary (Binary)

168import GHC.Generics (Generic)

158import GHC.Generics (Generic)

169import Control.DeepSeq (force)

159import Control.DeepSeq (force)

170import System.IO

160import System.IO

171import Data.Time.Clock

161import Data.Time.Clock

172−import Data.Typeable

162+import qualified Network.RPC.Curryer.Client as RPC

163+import qualified Network.RPC.Curryer.Server as RPC

164+import Network.Socket (Socket, AddrInfo(..), getAddrInfo, defaultHints, AddrInfoFlag(..), SocketType(..), ServiceName, hostAddressToTuple, SockAddr(..))

165+import GHC.Conc (unsafeIOToSTM)

173

166

174type Hostname = String

167type Hostname = String

175

168

176type Port = Word16

169type Port = Word16

177

170

178−type DatabaseName = String

179−

180-- | The type for notifications callbacks in the client. When a registered notification fires due to a changed relational expression evaluation, the server propagates the notifications to the clients in the form of the callback.

171-- | The type for notifications callbacks in the client. When a registered notification fires due to a changed relational expression evaluation, the server propagates the notifications to the clients in the form of the callback.

181type NotificationCallback = NotificationName -> EvaluatedNotification -> IO ()

172type NotificationCallback = NotificationName -> EvaluatedNotification -> IO ()

182

173

@@ -196,15 +187,16 @@ data RequestTimeoutException = RequestTimeoutException

196

187

197instance Exception RequestTimeoutException

188instance Exception RequestTimeoutException

198

189

199−-- | Construct a 'ConnectionInfo' to describe how to make the 'Connection'. The database can be run within the current process or running remotely via distributed-process.

190+-- | Construct a 'ConnectionInfo' to describe how to make the 'Connection'. The database can be run within the current process or running remotely via RPC.

200−data ConnectionInfo = InProcessConnectionInfo PersistenceStrategy NotificationCallback [GhcPkgPath]|

191+data ConnectionInfo = InProcessConnectionInfo PersistenceStrategy NotificationCallback [GhcPkgPath] |

201− RemoteProcessConnectionInfo DatabaseName NodeId NotificationCallback

192+ RemoteConnectionInfo DatabaseName Hostname ServiceName NotificationCallback

202

193

203type EvaluatedNotifications = M.Map NotificationName EvaluatedNotification

194type EvaluatedNotifications = M.Map NotificationName EvaluatedNotification

204

195

205-- | Used for callbacks from the server when monitored changes have been made.

196-- | Used for callbacks from the server when monitored changes have been made.

206newtype NotificationMessage = NotificationMessage EvaluatedNotifications

197newtype NotificationMessage = NotificationMessage EvaluatedNotifications

207− deriving (Binary, Eq, Show, Generic)

198+ deriving (Eq, Show, Generic)

199+ deriving Serialise via WineryVariant NotificationMessage

208

200

209-- | When a notification is fired, the 'reportOldExpr' is evaluated in the commit's pre-change context while the 'reportNewExpr' is evaluated in the post-change context and they are returned along with the original notification.

201-- | When a notification is fired, the 'reportOldExpr' is evaluated in the commit's pre-change context while the 'reportNewExpr' is evaluated in the post-change context and they are returned along with the original notification.

210data EvaluatedNotification = EvaluatedNotification {

202data EvaluatedNotification = EvaluatedNotification {

@@ -212,13 +204,10 @@ data EvaluatedNotification = EvaluatedNotification {

212 reportOldRelation :: Either RelationalError Relation,

204 reportOldRelation :: Either RelationalError Relation,

213 reportNewRelation :: Either RelationalError Relation

205 reportNewRelation :: Either RelationalError Relation

214 }

206 }

215− deriving(Binary, Eq, Show, Generic)

207+ deriving (Eq, Show, Generic)

208+ deriving Serialise via WineryRecord EvaluatedNotification

216

209

217

210

218−-- | Create a 'NodeId' for use in connecting to a remote server using distributed-process.

219−createNodeId :: Hostname -> Port -> NodeId

220−createNodeId host port = NodeId $ encodeEndPointAddress host (show port) 1

221−

222-- | Use this for connecting to remote servers on the default port.

211-- | Use this for connecting to remote servers on the default port.

223defaultServerPort :: Port

212defaultServerPort :: Port

224defaultServerPort = 6543

213defaultServerPort = 6543

@@ -233,80 +222,36 @@ defaultHeadName = "master"

233

222

234-- | Create a connection configuration which connects to the localhost on the default server port and default server database name. The configured notification callback is set to ignore all events.

223-- | Create a connection configuration which connects to the localhost on the default server port and default server database name. The configured notification callback is set to ignore all events.

235defaultRemoteConnectionInfo :: ConnectionInfo

224defaultRemoteConnectionInfo :: ConnectionInfo

225+defaultRemoteConnectionInfo =

236−defaultRemoteConnectionInfo = RemoteProcessConnectionInfo defaultDatabaseName (createNodeId "127.0.0.1" defaultServerPort) emptyNotificationCallback

226+ RemoteConnectionInfo defaultDatabaseName defaultServerHostname (show defaultServerPort) emptyNotificationCallback

237−

238−-- | The 'Connection' represents either local or remote access to a database. All operations flow through the connection.

239−type ClientNodes = StmSet.Set ProcessId

240

227

241−-- internal structure specific to in-process connections

228+defaultServerHostname :: Hostname

242−data InProcessConnectionConf = InProcessConnectionConf {

229+defaultServerHostname = "localhost"

243− ipPersistenceStrategy :: PersistenceStrategy,

244− ipClientNodes :: ClientNodes,

245− ipSessions :: Sessions,

246− ipTransactionGraph :: TVar TransactionGraph,

247− ipScriptSession :: Maybe ScriptSession,

248− ipLocalNode :: LocalNode,

249− ipTransport :: Transport, -- we hold onto this so that we can close it gracefully

250− ipLocks :: Maybe (LockFile, MVar LockFileHash) -- nothing when NoPersistence

251− }

252

230

253−data RemoteProcessConnectionConf = RemoteProcessConnectionConf {

231+newtype RemoteConnectionConf = RemoteConnectionConf RPC.Connection

254− rLocalNode :: LocalNode,

255− rProcessId :: ProcessId, --remote processId

256− rTransport :: Transport --the TCP socket transport

257− }

258

232

259data Connection = InProcessConnection InProcessConnectionConf |

233data Connection = InProcessConnection InProcessConnectionConf |

260− RemoteProcessConnection RemoteProcessConnectionConf

234+ RemoteConnection RemoteConnectionConf

261

235

262-- | There are several reasons why a connection can fail.

236-- | There are several reasons why a connection can fail.

263data ConnectionError = SetupDatabaseDirectoryError PersistenceError |

237data ConnectionError = SetupDatabaseDirectoryError PersistenceError |

264 IOExceptionError IOException |

238 IOExceptionError IOException |

265 NoSuchDatabaseByNameError DatabaseName |

239 NoSuchDatabaseByNameError DatabaseName |

240+ DatabaseValidationError [MerkleValidationError] |

266 LoginError

241 LoginError

267 deriving (Show, Eq, Generic)

242 deriving (Show, Eq, Generic)

268

243

269remoteDBLookupName :: DatabaseName -> String

244remoteDBLookupName :: DatabaseName -> String

270remoteDBLookupName = (++) "db-"

245remoteDBLookupName = (++) "db-"

271

246

272−createLocalNode :: IO (LocalNode, Transport)

273−createLocalNode = do

274−#if MIN_VERSION_network_transport_tcp(0,6,0)

275− eLocalTransport <- createTransport "127.0.0.1" "0" (\sn -> ("127.0.0.1", sn)) defaultTCPParameters

276−#else

277− eLocalTransport <- createTransport "127.0.0.1" "0" defaultTCPParameters

278−#endif

279− case eLocalTransport of

280− Left err -> error ("failed to create transport: " ++ show err)

281− Right localTransport -> do

282− localNode <- newLocalNode localTransport initRemoteTable

283− pure (localNode, localTransport)

284−

285−notificationListener :: NotificationCallback -> Process ()

286−notificationListener callback = do

287− --pid <- getSelfPid

288− --liftIO $ putStrLn $ "LISTENER THREAD START " ++ show pid

289− _ <- forever $

290− receiveWait [

291− match (\(NotificationMessage eNots) ->

292− --say $ "NOTIFICATION: " ++ show eNots

293− -- when notifications are thrown, they are not adjusted for the current schema which could be problematic, but we don't have access to the current session here

294− liftIO $ mapM_ (uncurry callback) (M.toList eNots)

295− )

296− ]

297− --say "LISTENER THREAD EXIT"

298− pure ()

299−

300−startNotificationListener :: LocalNode -> NotificationCallback -> IO ProcessId

301−startNotificationListener localNode callback = forkProcess localNode (notificationListener callback)

302−

303createScriptSession :: [String] -> IO (Maybe ScriptSession)

247createScriptSession :: [String] -> IO (Maybe ScriptSession)

304createScriptSession ghcPkgPaths = do

248createScriptSession ghcPkgPaths = do

305 eScriptSession <- initScriptSession ghcPkgPaths

249 eScriptSession <- initScriptSession ghcPkgPaths

306 case eScriptSession of

250 case eScriptSession of

307− Left err -> hPutStrLn stderr ("Failed to load scripting engine- scripting disabled: " ++ show err) >> pure Nothing --not a fatal error, but the scripting feature must be disabled

251+ Left err -> hPutStrLn stderr ("Warning: Haskell scripting disabled: " ++ show err) >> pure Nothing --not a fatal error, but the scripting feature must be disabled

308 Right s -> pure (Just s)

252 Right s -> pure (Just s)

309

253

254+

310-- | To create a 'Connection' to a remote or local database, create a 'ConnectionInfo' and call 'connectProjectM36'.

255-- | To create a 'Connection' to a remote or local database, create a 'ConnectionInfo' and call 'connectProjectM36'.

311connectProjectM36 :: ConnectionInfo -> IO (Either ConnectionError Connection)

256connectProjectM36 :: ConnectionInfo -> IO (Either ConnectionError Connection)

312--create a new in-memory database/transaction graph

257--create a new in-memory database/transaction graph

@@ -321,42 +266,63 @@ connectProjectM36 (InProcessConnectionInfo strat notificationCallback ghcPkgPath

321 graphTvar <- newTVarIO freshGraph

266 graphTvar <- newTVarIO freshGraph

322 clientNodes <- StmSet.newIO

267 clientNodes <- StmSet.newIO

323 sessions <- StmMap.newIO

268 sessions <- StmMap.newIO

324− (localNode, transport) <- createLocalNode

325− notificationPid <- startNotificationListener localNode notificationCallback

326 mScriptSession <- createScriptSession ghcPkgPaths

269 mScriptSession <- createScriptSession ghcPkgPaths

327−

270+ notifAsync <- startNotificationListener clientNodes notificationCallback

328 let conn = InProcessConnection InProcessConnectionConf {

271 let conn = InProcessConnection InProcessConnectionConf {

329 ipPersistenceStrategy = strat,

272 ipPersistenceStrategy = strat,

330 ipClientNodes = clientNodes,

273 ipClientNodes = clientNodes,

331 ipSessions = sessions,

274 ipSessions = sessions,

332 ipTransactionGraph = graphTvar,

275 ipTransactionGraph = graphTvar,

333 ipScriptSession = mScriptSession,

276 ipScriptSession = mScriptSession,

334− ipLocalNode = localNode,

335− ipTransport = transport,

336− ipLocks = Nothing}

277+ ipLocks = Nothing,

337− addClientNode conn notificationPid

278+ ipCallbackAsync = notifAsync

279+ }

338 pure (Right conn)

280 pure (Right conn)

339 MinimalPersistence dbdir -> connectPersistentProjectM36 strat NoDiskSync dbdir freshGraph notificationCallback ghcPkgPaths

281 MinimalPersistence dbdir -> connectPersistentProjectM36 strat NoDiskSync dbdir freshGraph notificationCallback ghcPkgPaths

340 CrashSafePersistence dbdir -> connectPersistentProjectM36 strat FsyncDiskSync dbdir freshGraph notificationCallback ghcPkgPaths

282 CrashSafePersistence dbdir -> connectPersistentProjectM36 strat FsyncDiskSync dbdir freshGraph notificationCallback ghcPkgPaths

341

283

342−connectProjectM36 (RemoteProcessConnectionInfo databaseName serverNodeId notificationCallback) = do

284+connectProjectM36 (RemoteConnectionInfo dbName hostName servicePort notificationCallback) = do

343− connStatus <- newEmptyMVar

285+ --TODO- add notification callback thread

344− (localNode, transport) <- createLocalNode

286+ let resolutionHints = defaultHints { addrFlags = [AI_NUMERICHOST, AI_NUMERICSERV],

345− let dbName = remoteDBLookupName databaseName

287+ addrSocketType = Stream

346− --putStrLn $ "Connecting to " ++ show serverNodeId ++ " " ++ dbName

288+ }

347− notificationListenerPid <- startNotificationListener localNode notificationCallback

289+ resolved <- getAddrInfo (Just resolutionHints) (Just hostName) (Just servicePort)

348− runProcess localNode $ do

290+ case resolved of

349− --even a failed connection retains an open socket!

291+ [] -> error ("DNS resolution failed for" <> hostName <> ":" <> servicePort)

350− mServerProcessId <- whereisRemote serverNodeId dbName

292+ addrInfo:_ -> do

351− case mServerProcessId of

293+ --supports IPv4 only for now

352− Nothing -> liftIO $ putMVar connStatus $ Left (NoSuchDatabaseByNameError databaseName)

294+ let (SockAddrInet port addr) = addrAddress addrInfo

353− Just serverProcessId -> do

295+ notificationHandlers =

354− loginConfirmation <- safeLogin (Login notificationListenerPid) serverProcessId

296+ [RPC.ClientAsyncRequestHandler $

355− if not loginConfirmation then

297+ \(NotificationMessage notifications') ->

356− liftIO $ putMVar connStatus (Left LoginError)

298+ forM_ (M.toList notifications') (uncurry notificationCallback)

357− else

299+ ]

358− liftIO $ putMVar connStatus (Right $ RemoteProcessConnection RemoteProcessConnectionConf {rLocalNode = localNode, rProcessId = serverProcessId, rTransport = transport})

300+ let connectExcHandler (e :: IOException) = pure $ Left (IOExceptionError e)

359− takeMVar connStatus

301+ eConn <- (Right <$> RPC.connect notificationHandlers (hostAddressToTuple addr) port) `catch` connectExcHandler

302+ case eConn of

303+ Left err -> pure (Left err)

304+ Right conn -> do

305+ eRet <- RPC.call conn (Login dbName)

306+ case eRet of

307+ Left err -> error (show err)

308+ Right False -> error "wtf"

309+ Right True ->

310+ --TODO handle connection errors!

311+ pure (Right (RemoteConnection (RemoteConnectionConf conn)))

312+

313+--convert RPC errors into exceptions

314+convertRPCErrors :: RPC.ConnectionError -> IO a

315+convertRPCErrors err =

316+ case err of

317+ RPC.TimeoutError -> throw RequestTimeoutException

318+ RPC.CodecError msg -> error $ "decoding message failed on server: " <> msg

319+ RPC.ExceptionError msg -> error $ "server threw exception: " <> msg

320+

321+addClientNode :: Connection -> RPC.Locking Socket -> IO ()

322+addClientNode (RemoteConnection _) _ = error "addClientNode called on remote connection"

323+addClientNode (InProcessConnection conf) lockSock = atomically (StmSet.insert clientInfo (ipClientNodes conf))

324+ where

325+ clientInfo = RemoteClientInfo lockSock

360

326

361connectPersistentProjectM36 :: PersistenceStrategy ->

327connectPersistentProjectM36 :: PersistenceStrategy ->

362 DiskSync ->

328 DiskSync ->

@@ -375,32 +341,40 @@ connectPersistentProjectM36 strat sync dbdir freshGraph notificationCallback ghc

375 case graph of

341 case graph of

376 Left err' -> return $ Left (SetupDatabaseDirectoryError err')

342 Left err' -> return $ Left (SetupDatabaseDirectoryError err')

377 Right graph' -> do

343 Right graph' -> do

344+ case TG.validateMerkleHashes graph' of

345+ Left merkleErrs -> pure (Left (DatabaseValidationError merkleErrs))

346+ Right _ -> do

378− tvarGraph <- newTVarIO graph'

347+ tvarGraph <- newTVarIO graph'

379− sessions <- StmMap.newIO

348+ sessions <- StmMap.newIO

380− clientNodes <- StmSet.newIO

349+ clientNodes <- StmSet.newIO

381− (localNode, transport) <- createLocalNode

382− lockMVar <- newMVar digest

350+ lockMVar <- newMVar digest

351+ notifAsync <- startNotificationListener clientNodes notificationCallback

383− let conn = InProcessConnection InProcessConnectionConf {

352+ let conn = InProcessConnection InProcessConnectionConf {

384 ipPersistenceStrategy = strat,

353 ipPersistenceStrategy = strat,

385 ipClientNodes = clientNodes,

354 ipClientNodes = clientNodes,

386 ipSessions = sessions,

355 ipSessions = sessions,

387 ipTransactionGraph = tvarGraph,

356 ipTransactionGraph = tvarGraph,

388 ipScriptSession = mScriptSession,

357 ipScriptSession = mScriptSession,

389− ipLocalNode = localNode,

390− ipTransport = transport,

391− ipLocks = Just (lockFileH, lockMVar)

358+ ipLocks = Just (lockFileH, lockMVar),

359+ ipCallbackAsync = notifAsync

392 }

360 }

361+ pure (Right conn)

362+

363+--startup local async process to handle notification callbacks

364+startNotificationListener :: ClientNodes -> NotificationCallback -> IO (Async ())

365+startNotificationListener cNodes notificationCallback = do

366+ inProcessClientInfo@(InProcessClientInfo notifMVar) <- InProcessClientInfo <$> newEmptyMVar

367+ atomically $ StmSet.insert inProcessClientInfo cNodes

368+ async $ forever $ do

369+ notifs <- takeMVar notifMVar

370+ forM_ (M.toList notifs) $ uncurry notificationCallback

393

371

394− notificationPid <- startNotificationListener localNode notificationCallback

395− addClientNode conn notificationPid

396− pure (Right conn)

397−

398-- | Create a new session at the transaction id and return the session's Id.

372-- | Create a new session at the transaction id and return the session's Id.

399createSessionAtCommit :: Connection -> TransactionId -> IO (Either RelationalError SessionId)

373createSessionAtCommit :: Connection -> TransactionId -> IO (Either RelationalError SessionId)

400createSessionAtCommit conn@(InProcessConnection _) commitId = do

374createSessionAtCommit conn@(InProcessConnection _) commitId = do

401 newSessionId <- nextRandom

375 newSessionId <- nextRandom

402 atomically $ createSessionAtCommit_ commitId newSessionId conn

376 atomically $ createSessionAtCommit_ commitId newSessionId conn

403−createSessionAtCommit conn@(RemoteProcessConnection _) uuid = remoteCall conn (CreateSessionAtCommit uuid)

377+createSessionAtCommit conn@(RemoteConnection _) uuid = remoteCall conn (CreateSessionAtCommit uuid)

404

378

405createSessionAtCommit_ :: TransactionId -> SessionId -> Connection -> STM (Either RelationalError SessionId)

379createSessionAtCommit_ :: TransactionId -> SessionId -> Connection -> STM (Either RelationalError SessionId)

406createSessionAtCommit_ commitId newSessionId (InProcessConnection conf) = do

380createSessionAtCommit_ commitId newSessionId (InProcessConnection conf) = do

@@ -410,14 +384,14 @@ createSessionAtCommit_ commitId newSessionId (InProcessConnection conf) = do

410 case RE.transactionForId commitId graph of

384 case RE.transactionForId commitId graph of

411 Left err -> pure (Left err)

385 Left err -> pure (Left err)

412 Right transaction -> do

386 Right transaction -> do

413− let freshDiscon = DisconnectedTransaction commitId (Trans.schemas transaction) NoOperation

387+ let freshDiscon = DisconnectedTransaction commitId (Trans.schemas transaction) False

414 keyDuplication <- StmMap.lookup newSessionId sessions

388 keyDuplication <- StmMap.lookup newSessionId sessions

415 case keyDuplication of

389 case keyDuplication of

416 Just _ -> pure $ Left (SessionIdInUseError newSessionId)

390 Just _ -> pure $ Left (SessionIdInUseError newSessionId)

417 Nothing -> do

391 Nothing -> do

418 StmMap.insert (Session freshDiscon defaultSchemaName) newSessionId sessions

392 StmMap.insert (Session freshDiscon defaultSchemaName) newSessionId sessions

419 pure $ Right newSessionId

393 pure $ Right newSessionId

420−createSessionAtCommit_ _ _ (RemoteProcessConnection _) = error "createSessionAtCommit_ called on remote connection"

394+createSessionAtCommit_ _ _ (RemoteConnection _) = error "createSessionAtCommit_ called on remote connection"

421

395

422-- | Call 'createSessionAtHead' with a transaction graph's head's name to create a new session pinned to that head. This function returns a 'SessionId' which can be used in other function calls to reference the point in the transaction graph.

396-- | Call 'createSessionAtHead' with a transaction graph's head's name to create a new session pinned to that head. This function returns a 'SessionId' which can be used in other function calls to reference the point in the transaction graph.

423createSessionAtHead :: Connection -> HeadName -> IO (Either RelationalError SessionId)

397createSessionAtHead :: Connection -> HeadName -> IO (Either RelationalError SessionId)

@@ -429,22 +403,18 @@ createSessionAtHead conn@(InProcessConnection conf) headn = do

429 case transactionForHead headn graph of

403 case transactionForHead headn graph of

430 Nothing -> pure $ Left (NoSuchHeadNameError headn)

404 Nothing -> pure $ Left (NoSuchHeadNameError headn)

431 Just trans -> createSessionAtCommit_ (transactionId trans) newSessionId conn

405 Just trans -> createSessionAtCommit_ (transactionId trans) newSessionId conn

432−createSessionAtHead conn@(RemoteProcessConnection _) headn = remoteCall conn (CreateSessionAtHead headn)

406+createSessionAtHead conn@(RemoteConnection _) headn = remoteCall conn (CreateSessionAtHead headn)

433−

434−-- | Used internally for server connections to keep track of remote nodes for the purpose of sending notifications later.

435−addClientNode :: Connection -> ProcessId -> IO ()

436−addClientNode (RemoteProcessConnection _) _ = error "addClientNode called on remote connection"

437−addClientNode (InProcessConnection conf) newProcessId = atomically (StmSet.insert newProcessId (ipClientNodes conf))

438

407

439-- | Discards a session, eliminating any uncommitted changes present in the session.

408-- | Discards a session, eliminating any uncommitted changes present in the session.

440closeSession :: SessionId -> Connection -> IO ()

409closeSession :: SessionId -> Connection -> IO ()

441closeSession sessionId (InProcessConnection conf) =

410closeSession sessionId (InProcessConnection conf) =

442 atomically $ StmMap.delete sessionId (ipSessions conf)

411 atomically $ StmMap.delete sessionId (ipSessions conf)

443−closeSession sessionId conn@(RemoteProcessConnection _) = remoteCall conn (CloseSession sessionId)

412+closeSession sessionId conn@(RemoteConnection _) = remoteCall conn (CloseSession sessionId)

444

413

445-- | 'close' cleans up the database access connection and closes any relevant sockets.

414-- | 'close' cleans up the database access connection and closes any relevant sockets.

446close :: Connection -> IO ()

415close :: Connection -> IO ()

447close (InProcessConnection conf) = do

416close (InProcessConnection conf) = do

417+ cancel (ipCallbackAsync conf)

448 atomically $ do

418 atomically $ do

449 let sessions = ipSessions conf

419 let sessions = ipSessions conf

450#if MIN_VERSION_stm_containers(1,0,0)

420#if MIN_VERSION_stm_containers(1,0,0)

@@ -453,22 +423,18 @@ close (InProcessConnection conf) = do

453 StmMap.deleteAll sessions

423 StmMap.deleteAll sessions

454#endif

424#endif

455 pure ()

425 pure ()

456− closeLocalNode (ipLocalNode conf)

457− closeTransport (ipTransport conf)

458 let mLocks = ipLocks conf

426 let mLocks = ipLocks conf

459 case mLocks of

427 case mLocks of

460 Nothing -> pure ()

428 Nothing -> pure ()

461 Just (lockFileH, _) -> closeLockFile lockFileH

429 Just (lockFileH, _) -> closeLockFile lockFileH

462

430

463−close conn@(RemoteProcessConnection conf) = do

431+close (RemoteConnection (RemoteConnectionConf conn)) =

464− _ <- remoteCall conn Logout :: IO Bool

432+ RPC.close conn

465− closeLocalNode (rLocalNode conf)

466− closeTransport (rTransport conf)

467

433

468--used only by the server EntryPoints

434--used only by the server EntryPoints

469closeRemote_ :: Connection -> IO ()

435closeRemote_ :: Connection -> IO ()

470closeRemote_ (InProcessConnection _) = error "invalid call of closeRemote_ on InProcessConnection"

436closeRemote_ (InProcessConnection _) = error "invalid call of closeRemote_ on InProcessConnection"

471−closeRemote_ (RemoteProcessConnection conf) = runProcess (rLocalNode conf) (reconnect (rProcessId conf))

437+closeRemote_ (RemoteConnection (RemoteConnectionConf conn)) = RPC.close conn

472

438

473 --we need to actually close the localNode's connection to the remote

439 --we need to actually close the localNode's connection to the remote

474--within the database server, we must catch and handle all exception lest they take down the database process- this handling might be different for other use-cases

440--within the database server, we must catch and handle all exception lest they take down the database process- this handling might be different for other use-cases

@@ -479,35 +445,15 @@ excEither = handle handler

479 where

445 where

480 handler exc | Just (_ :: AsyncException) <- fromException exc = throwIO exc

446 handler exc | Just (_ :: AsyncException) <- fromException exc = throwIO exc

481 | otherwise = pure (Left (UnhandledExceptionError (show exc)))

447 | otherwise = pure (Left (UnhandledExceptionError (show exc)))

482−

483−runProcessResult :: LocalNode -> Process a -> IO a

484−runProcessResult localNode proc = do

485− ret <- newEmptyMVar

486− runProcess localNode $ do

487− val <- proc

488− liftIO $ putMVar ret val

489− takeMVar ret

490−

491−safeLogin :: Login -> ProcessId -> Process Bool

492−safeLogin login procId = do

493− ret <- call procId login

494− case ret of

495− Left (_ :: ServerError) -> pure False

496− Right val -> pure val

497

448

449+

498−remoteCall :: (Binary a, Binary b, Typeable a, Typeable b) => Connection -> a -> IO b

450+remoteCall :: (Serialise a, Serialise b) => Connection -> a -> IO b

499remoteCall (InProcessConnection _ ) _ = error "remoteCall called on local connection"

451remoteCall (InProcessConnection _ ) _ = error "remoteCall called on local connection"

500−remoteCall (RemoteProcessConnection conf) arg = runProcessResult localNode $ do

452+remoteCall (RemoteConnection (RemoteConnectionConf rpcConn)) arg = do

501− ret <- safeCall serverProcessId arg

453+ eRet <- RPC.call rpcConn arg

502− case ret of

454+ case eRet of

503− Left err -> error ("server died: " ++ show err)

455+ Left err -> convertRPCErrors err

504− Right ret' -> case ret' of

505− Left RequestTimeoutError -> liftIO (throwIO RequestTimeoutException)

506− Left (ProcessDiedError _) -> liftIO (throwIO RemoteProcessDiedException)

507− Right val -> pure val

456+ Right val -> pure val

508− where

509− localNode = rLocalNode conf

510− serverProcessId = rProcessId conf

511

457

512sessionForSessionId :: SessionId -> Sessions -> STM (Either RelationalError Session)

458sessionForSessionId :: SessionId -> Sessions -> STM (Either RelationalError Session)

513sessionForSessionId sessionId sessions =

459sessionForSessionId sessionId sessions =

@@ -542,7 +488,7 @@ currentSchemaName sessionId (InProcessConnection conf) = atomically $ do

542 case eSession of

488 case eSession of

543 Left err -> pure (Left err)

489 Left err -> pure (Left err)

544 Right session -> pure (Right (Sess.schemaName session))

490 Right session -> pure (Right (Sess.schemaName session))

545−currentSchemaName sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveCurrentSchemaName sessionId)

491+currentSchemaName sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveCurrentSchemaName sessionId)

546

492

547-- | Switch to the named isomorphic schema.

493-- | Switch to the named isomorphic schema.

548setCurrentSchemaName :: SessionId -> Connection -> SchemaName -> IO (Either RelationalError ())

494setCurrentSchemaName :: SessionId -> Connection -> SchemaName -> IO (Either RelationalError ())

@@ -554,7 +500,7 @@ setCurrentSchemaName sessionId (InProcessConnection conf) sname = atomically $ d

554 Right session -> case Sess.setSchemaName sname session of

500 Right session -> case Sess.setSchemaName sname session of

555 Left err -> pure (Left err)

501 Left err -> pure (Left err)

556 Right newSession -> StmMap.insert newSession sessionId sessions >> pure (Right ())

502 Right newSession -> StmMap.insert newSession sessionId sessions >> pure (Right ())

557−setCurrentSchemaName sessionId conn@(RemoteProcessConnection _) sname = remoteCall conn (ExecuteSetCurrentSchema sessionId sname)

503+setCurrentSchemaName sessionId conn@(RemoteConnection _) sname = remoteCall conn (ExecuteSetCurrentSchema sessionId sname)

558

504

559-- | Execute a relational expression in the context of the session and connection. Relational expressions are queries and therefore cannot alter the database.

505-- | Execute a relational expression in the context of the session and connection. Relational expressions are queries and therefore cannot alter the database.

560executeRelationalExpr :: SessionId -> Connection -> RelationalExpr -> IO (Either RelationalError Relation)

506executeRelationalExpr :: SessionId -> Connection -> RelationalExpr -> IO (Either RelationalError Relation)

@@ -573,12 +519,12 @@ executeRelationalExpr sessionId (InProcessConnection conf) expr = excEither $ at

573 Right expr'' -> do

519 Right expr'' -> do

574 let graphTvar = ipTransactionGraph conf

520 let graphTvar = ipTransactionGraph conf

575 graph <- readTVar graphTvar

521 graph <- readTVar graphTvar

576− let reEnv = RE.mkRelationalExprEnv (Sess.concreteDatabaseContext session) (Sess.parentId session) graph

522+ let reEnv = RE.mkRelationalExprEnv (Sess.concreteDatabaseContext session) graph

577 case optimizeAndEvalRelationalExpr reEnv expr'' of

523 case optimizeAndEvalRelationalExpr reEnv expr'' of

578 Right rel -> pure (force (Right rel)) -- this is necessary so that any undefined/error exceptions are spit out here

524 Right rel -> pure (force (Right rel)) -- this is necessary so that any undefined/error exceptions are spit out here

579 Left err -> pure (Left err)

525 Left err -> pure (Left err)

580

526

581−executeRelationalExpr sessionId conn@(RemoteProcessConnection _) relExpr = remoteCall conn (ExecuteRelationalExpr sessionId relExpr)

527+executeRelationalExpr sessionId conn@(RemoteConnection _) relExpr = remoteCall conn (ExecuteRelationalExpr sessionId relExpr)

582

528

583-- | Execute a database context expression in the context of the session and connection. Database expressions modify the current session's disconnected transaction but cannot modify the transaction graph.

529-- | Execute a database context expression in the context of the session and connection. Database expressions modify the current session's disconnected transaction but cannot modify the transaction graph.

584executeDatabaseContextExpr :: SessionId -> Connection -> DatabaseContextExpr -> IO (Either RelationalError ())

530executeDatabaseContextExpr :: SessionId -> Connection -> DatabaseContextExpr -> IO (Either RelationalError ())

@@ -605,14 +551,14 @@ executeDatabaseContextExpr sessionId (InProcessConnection conf) expr = excEither

605 if not (RE.dbc_dirty newState) then --nothing dirtied, nothing to do

551 if not (RE.dbc_dirty newState) then --nothing dirtied, nothing to do

606 pure (Right ())

552 pure (Right ())

607 else do

553 else do

608− let newDiscon = DisconnectedTransaction (Sess.parentId session) newSchemas NoOperation

554+ let newDiscon = DisconnectedTransaction (Sess.parentId session) newSchemas True

609 context' = RE.dbc_context newState

555 context' = RE.dbc_context newState

610 newSubschemas = Schema.processDatabaseContextExprSchemasUpdate (Sess.subschemas session) expr

556 newSubschemas = Schema.processDatabaseContextExprSchemasUpdate (Sess.subschemas session) expr

611 newSchemas = Schemas context' newSubschemas

557 newSchemas = Schemas context' newSubschemas

612 newSession = Session newDiscon (Sess.schemaName session)

558 newSession = Session newDiscon (Sess.schemaName session)

613 StmMap.insert newSession sessionId sessions

559 StmMap.insert newSession sessionId sessions

614 pure (Right ())

560 pure (Right ())

615−executeDatabaseContextExpr sessionId conn@(RemoteProcessConnection _) dbExpr = remoteCall conn (ExecuteDatabaseContextExpr sessionId dbExpr)

561+executeDatabaseContextExpr sessionId conn@(RemoteConnection _) dbExpr = remoteCall conn (ExecuteDatabaseContextExpr sessionId dbExpr)

616

562

617-- | Similar to a git rebase, 'autoMergeToHead' atomically creates a temporary branch and merges it to the latest commit of the branch referred to by the 'HeadName' and commits the merge. This is useful to reduce incidents of 'TransactionIsNotAHeadError's but at the risk of merge errors (thus making it similar to rebasing). Alternatively, as an optimization, if a simple commit is possible (meaning that the head has not changed), then a fast-forward commit takes place instead.

563-- | Similar to a git rebase, 'autoMergeToHead' atomically creates a temporary branch and merges it to the latest commit of the branch referred to by the 'HeadName' and commits the merge. This is useful to reduce incidents of 'TransactionIsNotAHeadError's but at the risk of merge errors (thus making it similar to rebasing). Alternatively, as an optimization, if a simple commit is possible (meaning that the head has not changed), then a fast-forward commit takes place instead.

618autoMergeToHead :: SessionId -> Connection -> MergeStrategy -> HeadName -> IO (Either RelationalError ())

564autoMergeToHead :: SessionId -> Connection -> MergeStrategy -> HeadName -> IO (Either RelationalError ())

@@ -641,7 +587,7 @@ autoMergeToHead sessionId (InProcessConnection conf) strat headName' = do

641 Left err -> pure (Left err)

587 Left err -> pure (Left err)

642 Right ((discon', graph'), transactionIdsAdded) ->

588 Right ((discon', graph'), transactionIdsAdded) ->

643 pure (Right (discon', graph', transactionIdsAdded))

589 pure (Right (discon', graph', transactionIdsAdded))

644−autoMergeToHead sessionId conn@(RemoteProcessConnection _) strat headName' = remoteCall conn (ExecuteAutoMergeToHead sessionId strat headName')

590+autoMergeToHead sessionId conn@(RemoteConnection _) strat headName' = remoteCall conn (ExecuteAutoMergeToHead sessionId strat headName')

645

591

646-- | Execute a database context IO-monad-based expression for the given session and connection. `DatabaseContextIOExpr`s modify the DatabaseContext but cannot be purely implemented.

592-- | Execute a database context IO-monad-based expression for the given session and connection. `DatabaseContextIOExpr`s modify the DatabaseContext but cannot be purely implemented.

647--this is almost completely identical to executeDatabaseContextExpr above

593--this is almost completely identical to executeDatabaseContextExpr above

@@ -661,41 +607,26 @@ executeDatabaseContextIOExpr sessionId (InProcessConnection conf) expr = excEith

661 case res of

607 case res of

662 Left err -> pure (Left err)

608 Left err -> pure (Left err)

663 Right newState -> do

609 Right newState -> do

664− let newDiscon = DisconnectedTransaction (Sess.parentId session) newSchemas NoOperation

610+ let newDiscon = DisconnectedTransaction (Sess.parentId session) newSchemas False

665 newSchemas = Schemas context' (Sess.subschemas session)

611 newSchemas = Schemas context' (Sess.subschemas session)

666 newSession = Session newDiscon (Sess.schemaName session)

612 newSession = Session newDiscon (Sess.schemaName session)

667 context' = RE.dbc_context newState

613 context' = RE.dbc_context newState

668 atomically $ StmMap.insert newSession sessionId sessions

614 atomically $ StmMap.insert newSession sessionId sessions

669 pure (Right ())

615 pure (Right ())

670−executeDatabaseContextIOExpr sessionId conn@(RemoteProcessConnection _) dbExpr = remoteCall conn (ExecuteDatabaseContextIOExpr sessionId dbExpr)

616+executeDatabaseContextIOExpr sessionId conn@(RemoteConnection _) dbExpr = remoteCall conn (ExecuteDatabaseContextIOExpr sessionId dbExpr)

671

617

672−{-

673−executeGraphExprSTM_ :: TransactionId -> SessionId -> Session -> Sessions -> TransactionGraphOperator -> TransactionGraph -> TVar TransactionGraph -> STM (Either RelationalError (TransactionGraph, DisconnectedTransaction)

674−executeGraphExprSTM_ freshId sessionId session sessions graphExpr graph graphTVar= do

675− case evalGraphOp freshId (Sess.disconnectedTransaction session) graph graphExpr of

676− Left err -> do

677− when updateGraphOnError (writeTVar graphTVar graph)

678− pure $ Left err

679− Right (discon', graph') -> do

680− writeTVar graphTVar graph'

681− let newSession = Session discon' (Sess.schemaName session)

682− STMMap.insert newSession sessionId sessions

683− pure $ Right graph'

684−-}

685−

686-- process notifications for commits

618-- process notifications for commits

687executeCommitExprSTM_

619executeCommitExprSTM_

688− :: TransactionId

689− -> TransactionGraph

620+ :: TransactionGraph

690 -> DatabaseContext

621 -> DatabaseContext

691 -> DatabaseContext

622 -> DatabaseContext

692 -> ClientNodes

623 -> ClientNodes

693 -> STM (EvaluatedNotifications, ClientNodes)

624 -> STM (EvaluatedNotifications, ClientNodes)

694−executeCommitExprSTM_ transId graph oldContext newContext nodes = do

625+executeCommitExprSTM_ graph oldContext newContext nodes = do

695 let nots = notifications oldContext

626 let nots = notifications oldContext

696− fireNots = notificationChanges nots transId graph oldContext newContext

627+ fireNots = notificationChanges nots graph oldContext newContext

697 evaldNots = M.map mkEvaldNot fireNots

628 evaldNots = M.map mkEvaldNot fireNots

698− evalInContext expr ctx = optimizeAndEvalRelationalExpr (RE.mkRelationalExprEnv ctx transId graph) expr

629+ evalInContext expr ctx = optimizeAndEvalRelationalExpr (RE.mkRelationalExprEnv ctx graph) expr

699

630

700 mkEvaldNot notif = EvaluatedNotification { notification = notif,

631 mkEvaldNot notif = EvaluatedNotification { notification = notif,

701 reportOldRelation = evalInContext (reportOldExpr notif) oldContext,

632 reportOldRelation = evalInContext (reportOldExpr notif) oldContext,

@@ -724,78 +655,8 @@ executeGraphExpr sessionId (InProcessConnection conf) graphExpr = excEither $ do

724 --if freshId appears in the graph, then we need to pass it on

655 --if freshId appears in the graph, then we need to pass it on

725 let transIds = [freshId | isRight (RE.transactionForId freshId graph')]

656 let transIds = [freshId | isRight (RE.transactionForId freshId graph')]

726 pure (Right (discon', graph', transIds))

657 pure (Right (discon', graph', transIds))

727−{-

658+

728−executeGraphExpr sessionId (InProcessConnection conf) graphExpr = excEither $ do

729− let strat = ipPersistenceStrategy conf

730− clientNodes = ipClientNodes conf

731− sessions = ipSessions conf

732− graphTvar = ipTransactionGraph conf

733− mLockFileH = ipLocks conf

734− lockHandler body = case graphExpr of

735− Commit -> case mLockFileH of

736− Nothing -> body False

737− Just (lockFileH, lockMVar) -> let acquireLocks = do

738− lastWrittenDigest <- takeMVar lockMVar

739− lockFile lockFileH WriteLock

740− latestDigest <- readGraphTransactionIdDigest strat

741− pure (latestDigest /= lastWrittenDigest)

742−

743− releaseLocks _ = do

744− --still holding the lock- get the latest digest

745− gDigest <- readGraphTransactionIdDigest strat

746− unlockFile lockFileH

747− putMVar lockMVar gDigest

748− in bracket acquireLocks releaseLocks body

749− _ -> body False

750− freshId <- nextRandom

751− lockHandler $ \dbWrittenByOtherProcess -> do

752− --if the database file has been updated since we wrote it last, load it before trying to sync our version done- this can result in TransactionNotAHeadErrors

753− --read transaction data and compare to existing graph

754− --in the future, we can detect if updated transaction graph can be safely merged (such as with a transaction on a separate head) (rebase-able commits should force the user to rebase from the client to confirm that the action makes sense)

755− manip <- atomically $ do

756− eSession <- sessionForSessionId sessionId sessions

757− --handle graph update by other process

758− oldGraph <- readTVar graphTvar

759− case eSession of

760− Left err -> pure (Left err)

761− Right session -> do

762− let mScriptSession = ipScriptSession conf

763− dbdir = case strat of

764− MinimalPersistence x -> x

765− CrashSafePersistence x -> x

766− _ -> error "accessing dbdir on non-persisted connection"

767− eRefreshedGraph <- if dbWrittenByOtherProcess then

768− unsafeIOToSTM (transactionGraphLoad dbdir oldGraph mScriptSession)

769− else

770− pure (Right oldGraph)

771− case eRefreshedGraph of

772− Left err -> pure (Left (DatabaseLoadError err))

773− Right refreshedGraph -> do

774− --snip it

775− eGraph <- executeGraphExprSTM_ dbWrittenByOtherProcess freshId sessionId session sessions graphExpr refreshedGraph graphTvar

776− --snip it

777− case eGraph of

778− Left err -> pure (Left err)

779− Right newGraph -> do

780− --handle commit

781− if isCommit graphExpr then do

782− case transactionForId (Sess.parentId session) oldGraph of

783− Left err -> pure $ Left err

784− Right previousTrans -> do

785− (evaldNots, nodes) <- executeCommitExprSTM_ (Trans.concreteDatabaseContext previousTrans) (Sess.concreteDatabaseContext session) clientNodes

786− nodesToNotify <- toList (StmSet.stream nodes)

787− pure $ Right (evaldNots, nodesToNotify, newGraph)

788− else

789− pure $ Right (M.empty, [], newGraph)

790− case manip of

791− Left err -> return $ Just err

792− Right (notsToFire, nodesToNotify, newGraph) -> do

793− --update filesystem database, if necessary

794− processTransactionGraphPersistence strat newGraph

795− sendNotifications nodesToNotify (ipLocalNode conf) notsToFire

796− pure Nothing

797−-}

798−executeGraphExpr sessionId conn@(RemoteProcessConnection _) graphExpr = remoteCall conn (ExecuteGraphExpr sessionId graphExpr)

659+executeGraphExpr sessionId conn@(RemoteConnection _) graphExpr = remoteCall conn (ExecuteGraphExpr sessionId graphExpr)

799

660

800-- | A trans-graph expression is a relational query executed against the entirety of a transaction graph.

661-- | A trans-graph expression is a relational query executed against the entirety of a transaction graph.

801executeTransGraphRelationalExpr :: SessionId -> Connection -> TransGraphRelationalExpr -> IO (Either RelationalError Relation)

662executeTransGraphRelationalExpr :: SessionId -> Connection -> TransGraphRelationalExpr -> IO (Either RelationalError Relation)

@@ -803,10 +664,7 @@ executeTransGraphRelationalExpr _ (InProcessConnection conf) tgraphExpr = excEit

803 let graphTvar = ipTransactionGraph conf

664 let graphTvar = ipTransactionGraph conf

804 graph <- readTVar graphTvar

665 graph <- readTVar graphTvar

805 pure $ force $ optimizeAndEvalTransGraphRelationalExpr graph tgraphExpr

666 pure $ force $ optimizeAndEvalTransGraphRelationalExpr graph tgraphExpr

806−{- case runReader (RE.evalRelationalExpr relExpr) (RE.mkRelationalExprState DBC.empty) of

807− Left err -> pure (Left err)

808− Right rel -> pure (force (Right rel))-}

809−executeTransGraphRelationalExpr sessionId conn@(RemoteProcessConnection _) tgraphExpr = remoteCall conn (ExecuteTransGraphRelationalExpr sessionId tgraphExpr)

667+executeTransGraphRelationalExpr sessionId conn@(RemoteConnection _) tgraphExpr = remoteCall conn (ExecuteTransGraphRelationalExpr sessionId tgraphExpr)

810

668

811-- | Schema expressions manipulate the isomorphic schemas for the current 'DatabaseContext'.

669-- | Schema expressions manipulate the isomorphic schemas for the current 'DatabaseContext'.

812executeSchemaExpr :: SessionId -> Connection -> Schema.SchemaExpr -> IO (Either RelationalError ())

670executeSchemaExpr :: SessionId -> Connection -> Schema.SchemaExpr -> IO (Either RelationalError ())

@@ -826,26 +684,27 @@ executeSchemaExpr sessionId (InProcessConnection conf) schemaExpr = atomically $

826 --hm- maybe we should start using lenses

684 --hm- maybe we should start using lenses

827 let discon = Sess.disconnectedTransaction session

685 let discon = Sess.disconnectedTransaction session

828 newSchemas = Schemas newContext newSubschemas

686 newSchemas = Schemas newContext newSubschemas

829− newSession = Session (DisconnectedTransaction (Discon.parentId discon) newSchemas NoOperation) (Sess.schemaName session)

687+ newSession = Session (DisconnectedTransaction (Discon.parentId discon) newSchemas False) (Sess.schemaName session)

830 StmMap.insert newSession sessionId sessions

688 StmMap.insert newSession sessionId sessions

831 pure (Right ())

689 pure (Right ())

832−executeSchemaExpr sessionId conn@(RemoteProcessConnection _) schemaExpr = remoteCall conn (ExecuteSchemaExpr sessionId schemaExpr)

690+executeSchemaExpr sessionId conn@(RemoteConnection _) schemaExpr = remoteCall conn (ExecuteSchemaExpr sessionId schemaExpr)

833

691

834-- | After modifying a 'DatabaseContext', 'commit' the transaction to the transaction graph at the head which the session is referencing. This will also trigger checks for any notifications which need to be propagated.

692-- | After modifying a 'DatabaseContext', 'commit' the transaction to the transaction graph at the head which the session is referencing. This will also trigger checks for any notifications which need to be propagated.

835commit :: SessionId -> Connection -> IO (Either RelationalError ())

693commit :: SessionId -> Connection -> IO (Either RelationalError ())

836commit sessionId conn@(InProcessConnection _) = executeGraphExpr sessionId conn Commit

694commit sessionId conn@(InProcessConnection _) = executeGraphExpr sessionId conn Commit

837−commit sessionId conn@(RemoteProcessConnection _) = remoteCall conn (ExecuteGraphExpr sessionId Commit)

695+commit sessionId conn@(RemoteConnection _) = remoteCall conn (ExecuteGraphExpr sessionId Commit)

838−

696+

839−sendNotifications :: [ProcessId] -> LocalNode -> EvaluatedNotifications -> IO ()

697+sendNotifications :: [ClientInfo] -> EvaluatedNotifications -> IO ()

840−sendNotifications pids localNode nots = mapM_ sendNots pids

698+sendNotifications clients notifs =

841− where

699+ unless (M.null notifs) $ forM_ clients sender

842− sendNots remoteClientPid =

700+ where

843− unless (M.null nots) $ runProcess localNode $ send remoteClientPid (NotificationMessage nots)

701+ sender (RemoteClientInfo sock) = RPC.sendMessage sock (NotificationMessage notifs)

844−

702+ sender (InProcessClientInfo tvar) = putMVar tvar notifs

703+

845-- | Discard any changes made in the current 'Session' and 'DatabaseContext'. This resets the disconnected transaction to reference the original database context of the parent transaction and is a very cheap operation.

704-- | Discard any changes made in the current 'Session' and 'DatabaseContext'. This resets the disconnected transaction to reference the original database context of the parent transaction and is a very cheap operation.

846rollback :: SessionId -> Connection -> IO (Either RelationalError ())

705rollback :: SessionId -> Connection -> IO (Either RelationalError ())

847rollback sessionId conn@(InProcessConnection _) = executeGraphExpr sessionId conn Rollback

706rollback sessionId conn@(InProcessConnection _) = executeGraphExpr sessionId conn Rollback

848−rollback sessionId conn@(RemoteProcessConnection _) = remoteCall conn (ExecuteGraphExpr sessionId Rollback)

707+rollback sessionId conn@(RemoteConnection _) = remoteCall conn (ExecuteGraphExpr sessionId Rollback)

849

708

850-- | Write the transaction graph to disk. This function can be used to incrementally write new transactions to disk.

709-- | Write the transaction graph to disk. This function can be used to incrementally write new transactions to disk.

851processTransactionGraphPersistence :: PersistenceStrategy -> [TransactionId] -> TransactionGraph -> IO ()

710processTransactionGraphPersistence :: PersistenceStrategy -> [TransactionId] -> TransactionGraph -> IO ()

@@ -861,7 +720,7 @@ readGraphTransactionIdDigest (CrashSafePersistence dbdir) = readGraphTransaction

861-- | Return a relation whose type would match that of the relational expression if it were executed. This is useful for checking types and validating a relational expression's types.

720-- | Return a relation whose type would match that of the relational expression if it were executed. This is useful for checking types and validating a relational expression's types.

862typeForRelationalExpr :: SessionId -> Connection -> RelationalExpr -> IO (Either RelationalError Relation)

721typeForRelationalExpr :: SessionId -> Connection -> RelationalExpr -> IO (Either RelationalError Relation)

863typeForRelationalExpr sessionId conn@(InProcessConnection _) relExpr = atomically $ typeForRelationalExprSTM sessionId conn relExpr

722typeForRelationalExpr sessionId conn@(InProcessConnection _) relExpr = atomically $ typeForRelationalExprSTM sessionId conn relExpr

864−typeForRelationalExpr sessionId conn@(RemoteProcessConnection _) relExpr = remoteCall conn (ExecuteTypeForRelationalExpr sessionId relExpr)

723+typeForRelationalExpr sessionId conn@(RemoteConnection _) relExpr = remoteCall conn (ExecuteTypeForRelationalExpr sessionId relExpr)

865

724

866typeForRelationalExprSTM :: SessionId -> Connection -> RelationalExpr -> STM (Either RelationalError Relation)

725typeForRelationalExprSTM :: SessionId -> Connection -> RelationalExpr -> STM (Either RelationalError Relation)

867typeForRelationalExprSTM sessionId (InProcessConnection conf) relExpr = do

726typeForRelationalExprSTM sessionId (InProcessConnection conf) relExpr = do

@@ -878,8 +737,7 @@ typeForRelationalExprSTM sessionId (InProcessConnection conf) relExpr = do

878 Left err -> pure (Left err)

737 Left err -> pure (Left err)

879 Right relExpr' -> do

738 Right relExpr' -> do

880 graph <- readTVar (ipTransactionGraph conf)

739 graph <- readTVar (ipTransactionGraph conf)

881− let transId = Sess.parentId session

882− reEnv = RE.mkRelationalExprEnv (Sess.concreteDatabaseContext session) transId graph

740+ let reEnv = RE.mkRelationalExprEnv (Sess.concreteDatabaseContext session) graph

883 pure $ RE.runRelationalExprM reEnv (RE.typeForRelationalExpr relExpr')

741 pure $ RE.runRelationalExprM reEnv (RE.typeForRelationalExpr relExpr')

884

742

885typeForRelationalExprSTM _ _ _ = error "typeForRelationalExprSTM called on non-local connection"

743typeForRelationalExprSTM _ _ _ = error "typeForRelationalExprSTM called on non-local connection"

@@ -899,7 +757,7 @@ inclusionDependencies sessionId (InProcessConnection conf) = do

899 else

757 else

900 pure (Schema.inclusionDependenciesInSchema schema (B.inclusionDependencies context))

758 pure (Schema.inclusionDependenciesInSchema schema (B.inclusionDependencies context))

901

759

902−inclusionDependencies sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveInclusionDependencies sessionId)

760+inclusionDependencies sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveInclusionDependencies sessionId)

903

761

904typeConstructorMapping :: SessionId -> Connection -> IO (Either RelationalError TypeConstructorMapping)

762typeConstructorMapping :: SessionId -> Connection -> IO (Either RelationalError TypeConstructorMapping)

905typeConstructorMapping sessionId (InProcessConnection conf) = do

763typeConstructorMapping sessionId (InProcessConnection conf) = do

@@ -910,7 +768,7 @@ typeConstructorMapping sessionId (InProcessConnection conf) = do

910 Left err -> pure $ Left err

768 Left err -> pure $ Left err

911 Right (session, _) -> --warning, no schema support for typeconstructors

769 Right (session, _) -> --warning, no schema support for typeconstructors

912 pure (Right (B.typeConstructorMapping (Sess.concreteDatabaseContext session)))

770 pure (Right (B.typeConstructorMapping (Sess.concreteDatabaseContext session)))

913−typeConstructorMapping sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveTypeConstructorMapping sessionId)

771+typeConstructorMapping sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveTypeConstructorMapping sessionId)

914

772

915-- | Return an optimized database expression which is logically equivalent to the input database expression. This function can be used to determine which expression will actually be evaluated.

773-- | Return an optimized database expression which is logically equivalent to the input database expression. This function can be used to determine which expression will actually be evaluated.

916planForDatabaseContextExpr :: SessionId -> Connection -> DatabaseContextExpr -> IO (Either RelationalError GraphRefDatabaseContextExpr)

774planForDatabaseContextExpr :: SessionId -> Connection -> DatabaseContextExpr -> IO (Either RelationalError GraphRefDatabaseContextExpr)

@@ -923,13 +781,14 @@ planForDatabaseContextExpr sessionId (InProcessConnection conf) dbExpr = do

923 Left err -> pure $ Left err

781 Left err -> pure $ Left err

924 Right (session, _) ->

782 Right (session, _) ->

925 if schemaName session == defaultSchemaName then do

783 if schemaName session == defaultSchemaName then do

784+ let ctx = Sess.concreteDatabaseContext session

926− let transId = Sess.parentId session

785+ transId = Sess.parentId session

927− gfExpr = runProcessExprM transId graph (processDatabaseContextExpr dbExpr)

786+ gfExpr = runProcessExprM UncommittedContextMarker (processDatabaseContextExpr dbExpr)

928− pure $ runGraphRefStaticOptimizerMonad graph (optimizeGraphRefDatabaseContextExpr gfExpr)

787+ pure $ runGraphRefSOptDatabaseContextExprM transId ctx graph (optimizeGraphRefDatabaseContextExpr gfExpr)

929 else -- don't show any optimization because the current optimization infrastructure relies on access to the base context- this probably underscores the need for each schema to have its own DatabaseContext, even if it is generated on-the-fly-}

788 else -- don't show any optimization because the current optimization infrastructure relies on access to the base context- this probably underscores the need for each schema to have its own DatabaseContext, even if it is generated on-the-fly-}

930 pure (Left NonConcreteSchemaPlanError)

789 pure (Left NonConcreteSchemaPlanError)

931

790

932−planForDatabaseContextExpr sessionId conn@(RemoteProcessConnection _) dbExpr = remoteCall conn (RetrievePlanForDatabaseContextExpr sessionId dbExpr)

791+planForDatabaseContextExpr sessionId conn@(RemoteConnection _) dbExpr = remoteCall conn (RetrievePlanForDatabaseContextExpr sessionId dbExpr)

933

792

934-- | Return a relation which represents the current state of the global transaction graph. The attributes are

793-- | Return a relation which represents the current state of the global transaction graph. The attributes are

935-- * current- boolean attribute representing whether or not the current session references this transaction

794-- * current- boolean attribute representing whether or not the current session references this transaction

@@ -947,7 +806,7 @@ transactionGraphAsRelation sessionId (InProcessConnection conf) = do

947 Right session ->

806 Right session ->

948 graphAsRelation (Sess.disconnectedTransaction session) <$> readTVar tvar

807 graphAsRelation (Sess.disconnectedTransaction session) <$> readTVar tvar

949

808

950−transactionGraphAsRelation sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveTransactionGraph sessionId)

809+transactionGraphAsRelation sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveTransactionGraph sessionId)

951

810

952-- | Returns the names and types of the relation variables in the current 'Session'.

811-- | Returns the names and types of the relation variables in the current 'Session'.

953relationVariablesAsRelation :: SessionId -> Connection -> IO (Either RelationalError Relation)

812relationVariablesAsRelation :: SessionId -> Connection -> IO (Either RelationalError Relation)

@@ -960,15 +819,16 @@ relationVariablesAsRelation sessionId (InProcessConnection conf) = do

960 Left err -> pure (Left err)

819 Left err -> pure (Left err)

961 Right (session, schema) -> do

820 Right (session, schema) -> do

962 let context = Sess.concreteDatabaseContext session

821 let context = Sess.concreteDatabaseContext session

963− transId = Sess.parentId session

964 if Sess.schemaName session == defaultSchemaName then

822 if Sess.schemaName session == defaultSchemaName then

965− pure $ RE.relationVariablesAsRelation (relationVariables context) graph

823+ pure $ RE.relationVariablesAsRelation context graph

966 else

824 else

967− case Schema.relationVariablesInSchema schema context transId graph of

825+ case Schema.relationVariablesInSchema schema of

968 Left err -> pure (Left err)

826 Left err -> pure (Left err)

827+ Right relvars -> do

828+ let schemaContext = context {relationVariables = relvars }

969− Right relvars -> pure $ RE.relationVariablesAsRelation relvars graph

829+ pure $ RE.relationVariablesAsRelation schemaContext graph

970

830

971−relationVariablesAsRelation sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveRelationVariableSummary sessionId)

831+relationVariablesAsRelation sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveRelationVariableSummary sessionId)

972

832

973-- | Returns the names and types of the atom functions in the current 'Session'.

833-- | Returns the names and types of the atom functions in the current 'Session'.

974atomFunctionsAsRelation :: SessionId -> Connection -> IO (Either RelationalError Relation)

834atomFunctionsAsRelation :: SessionId -> Connection -> IO (Either RelationalError Relation)

@@ -981,7 +841,7 @@ atomFunctionsAsRelation sessionId (InProcessConnection conf) = do

981 Right (session, _) ->

841 Right (session, _) ->

982 pure (AF.atomFunctionsAsRelation (atomFunctions (concreteDatabaseContext session)))

842 pure (AF.atomFunctionsAsRelation (atomFunctions (concreteDatabaseContext session)))

983

843

984−atomFunctionsAsRelation sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveAtomFunctionSummary sessionId)

844+atomFunctionsAsRelation sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveAtomFunctionSummary sessionId)

985

845

986databaseContextFunctionsAsRelation :: SessionId -> Connection -> IO (Either RelationalError Relation)

846databaseContextFunctionsAsRelation :: SessionId -> Connection -> IO (Either RelationalError Relation)

987databaseContextFunctionsAsRelation sessionId (InProcessConnection conf) = do

847databaseContextFunctionsAsRelation sessionId (InProcessConnection conf) = do

@@ -993,7 +853,7 @@ databaseContextFunctionsAsRelation sessionId (InProcessConnection conf) = do

993 Right (session, _) ->

853 Right (session, _) ->

994 pure (DCF.databaseContextFunctionsAsRelation (dbcFunctions (concreteDatabaseContext session)))

854 pure (DCF.databaseContextFunctionsAsRelation (dbcFunctions (concreteDatabaseContext session)))

995

855

996−databaseContextFunctionsAsRelation sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveDatabaseContextFunctionSummary sessionId)

856+databaseContextFunctionsAsRelation sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveDatabaseContextFunctionSummary sessionId)

997

857

998-- | Returns the transaction id for the connection's disconnected transaction committed parent transaction.

858-- | Returns the transaction id for the connection's disconnected transaction committed parent transaction.

999headTransactionId :: SessionId -> Connection -> IO (Either RelationalError TransactionId)

859headTransactionId :: SessionId -> Connection -> IO (Either RelationalError TransactionId)

@@ -1004,7 +864,7 @@ headTransactionId sessionId (InProcessConnection conf) = do

1004 case eSession of

864 case eSession of

1005 Left err -> pure (Left err)

865 Left err -> pure (Left err)

1006 Right session -> pure $ Right (Sess.parentId session)

866 Right session -> pure $ Right (Sess.parentId session)

1007−headTransactionId sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveHeadTransactionId sessionId)

867+headTransactionId sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveHeadTransactionId sessionId)

1008

868

1009headNameSTM_ :: SessionId -> Sessions -> TVar TransactionGraph -> STM (Either RelationalError HeadName)

869headNameSTM_ :: SessionId -> Sessions -> TVar TransactionGraph -> STM (Either RelationalError HeadName)

1010headNameSTM_ sessionId sessions graphTvar = do

870headNameSTM_ sessionId sessions graphTvar = do

@@ -1024,7 +884,7 @@ headName sessionId (InProcessConnection conf) = do

1024 let sessions = ipSessions conf

884 let sessions = ipSessions conf

1025 graphTvar = ipTransactionGraph conf

885 graphTvar = ipTransactionGraph conf

1026 atomically (headNameSTM_ sessionId sessions graphTvar)

886 atomically (headNameSTM_ sessionId sessions graphTvar)

1027−headName sessionId conn@(RemoteProcessConnection _) = remoteCall conn (ExecuteHeadName sessionId)

887+headName sessionId conn@(RemoteConnection _) = remoteCall conn (ExecuteHeadName sessionId)

1028

888

1029-- | Returns a listing of all available atom types.

889-- | Returns a listing of all available atom types.

1030atomTypesAsRelation :: SessionId -> Connection -> IO (Either RelationalError Relation)

890atomTypesAsRelation :: SessionId -> Connection -> IO (Either RelationalError Relation)

@@ -1038,7 +898,7 @@ atomTypesAsRelation sessionId (InProcessConnection conf) = do

1038 case typesAsRelation (B.typeConstructorMapping (Sess.concreteDatabaseContext session)) of

898 case typesAsRelation (B.typeConstructorMapping (Sess.concreteDatabaseContext session)) of

1039 Left err -> pure (Left err)

899 Left err -> pure (Left err)

1040 Right rel -> pure (Right rel)

900 Right rel -> pure (Right rel)

1041−atomTypesAsRelation sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveAtomTypesAsRelation sessionId)

901+atomTypesAsRelation sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveAtomTypesAsRelation sessionId)

1042

902

1043disconnectedTransactionIsDirty :: SessionId -> Connection -> IO (Either RelationalError Bool)

903disconnectedTransactionIsDirty :: SessionId -> Connection -> IO (Either RelationalError Bool)

1044disconnectedTransactionIsDirty sessionId (InProcessConnection conf) = do

904disconnectedTransactionIsDirty sessionId (InProcessConnection conf) = do

@@ -1049,12 +909,12 @@ disconnectedTransactionIsDirty sessionId (InProcessConnection conf) = do

1049 Left err -> pure (Left err)

909 Left err -> pure (Left err)

1050 Right session ->

910 Right session ->

1051 pure (Right (isDirty session))

911 pure (Right (isDirty session))

1052−disconnectedTransactionIsDirty sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveSessionIsDirty sessionId)

912+disconnectedTransactionIsDirty sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveSessionIsDirty sessionId)

1053

913

1054--used only for testing- we expect this to throw an exception

914--used only for testing- we expect this to throw an exception

1055callTestTimeout_ :: SessionId -> Connection -> IO Bool

915callTestTimeout_ :: SessionId -> Connection -> IO Bool

1056callTestTimeout_ _ (InProcessConnection _) = error "bad testing call"

916callTestTimeout_ _ (InProcessConnection _) = error "bad testing call"

1057−callTestTimeout_ sessionId conn@(RemoteProcessConnection _) = remoteCall conn (TestTimeout sessionId)

917+callTestTimeout_ sessionId conn@(RemoteConnection _) = remoteCall conn (TestTimeout sessionId)

1058

918

1059--used in tests only

919--used in tests only

1060transactionGraph_ :: Connection -> IO TransactionGraph

920transactionGraph_ :: Connection -> IO TransactionGraph

@@ -1128,8 +988,7 @@ commitLock_ sessionId conf stmBlock = do

1128 Left err -> pure $ Left err

988 Left err -> pure $ Left err

1129 Right previousTrans ->

989 Right previousTrans ->

1130 if not (Prelude.null transactionIdsToPersist) then do

990 if not (Prelude.null transactionIdsToPersist) then do

1131− let transId = Sess.parentId newSession

1132− (evaldNots, nodes) <- executeCommitExprSTM_ transId graph' (Trans.concreteDatabaseContext previousTrans) (Sess.concreteDatabaseContext session) clientNodes

991+ (evaldNots, nodes) <- executeCommitExprSTM_ graph' (Trans.concreteDatabaseContext previousTrans) (Sess.concreteDatabaseContext session) clientNodes

1133 nodesToNotify <- stmSetToList nodes

992 nodesToNotify <- stmSetToList nodes

1134 pure $ Right (evaldNots, nodesToNotify, graph', transactionIdsToPersist)

993 pure $ Right (evaldNots, nodesToNotify, graph', transactionIdsToPersist)

1135 else pure (Right (M.empty, [], graph', []))

994 else pure (Right (M.empty, [], graph', []))

@@ -1140,15 +999,8 @@ commitLock_ sessionId conf stmBlock = do

1140 Right (notsToFire, nodesToNotify, newGraph, transactionIdsToPersist) -> do

999 Right (notsToFire, nodesToNotify, newGraph, transactionIdsToPersist) -> do

1141 --update filesystem database, if necessary

1000 --update filesystem database, if necessary

1142 processTransactionGraphPersistence strat transactionIdsToPersist newGraph

1001 processTransactionGraphPersistence strat transactionIdsToPersist newGraph

1143− sendNotifications nodesToNotify (ipLocalNode conf) notsToFire

1002+ sendNotifications nodesToNotify notsToFire

1144 pure (Right ())

1003 pure (Right ())

1145−{-

1146−writeDisconAndGraph_ :: TVar TransactionGraph -> SessionId -> Session -> Sessions -> DisconnectedTransaction -> TransactionGraph -> STM ()

1147−writeDisconAndGraph_ graphTvar sessionId session sessions discon graph = do

1148− writeTVar graphTvar graph

1149− let newSession = Session discon (Sess.schemaName session)

1150− StmMap.insert newSession sessionId sessions

1151−-}

1152

1004

1153-- | Runs an IO monad, commits the result when the monad returns no errors, otherwise, rolls back the changes and the error.

1005-- | Runs an IO monad, commits the result when the monad returns no errors, otherwise, rolls back the changes and the error.

1154withTransaction :: SessionId -> Connection -> IO (Either RelationalError a) -> IO (Either RelationalError ()) -> IO (Either RelationalError a)

1006withTransaction :: SessionId -> Connection -> IO (Either RelationalError a) -> IO (Either RelationalError ()) -> IO (Either RelationalError a)

@@ -1190,12 +1042,54 @@ executeDataFrameExpr sessionId conn@(InProcessConnection _) dfExpr = do

1190 case verified of

1042 case verified of

1191 Left err -> pure (Left err)

1043 Left err -> pure (Left err)

1192 Right attrs -> do

1044 Right attrs -> do

1045+ let attrOrders = zipWith

1193− let attrOrders = map (\(attr',order') -> DF.AttributeOrder (attributeName attr') order') (zip attrs orders)

1046+ (DF.AttributeOrder . attributeName)

1047+ attrs

1048+ orders

1194 case DF.sortDataFrameBy attrOrders . DF.toDataFrame $ rel of

1049 case DF.sortDataFrameBy attrOrders . DF.toDataFrame $ rel of

1195 Left err -> pure (Left err)

1050 Left err -> pure (Left err)

1196 Right dFrame -> do

1051 Right dFrame -> do

1197 let dFrame' = maybe dFrame (`DF.drop'` dFrame) (DF.offset dfExpr)

1052 let dFrame' = maybe dFrame (`DF.drop'` dFrame) (DF.offset dfExpr)

1198 dFrame'' = maybe dFrame' (`DF.take'` dFrame') (DF.limit dfExpr)

1053 dFrame'' = maybe dFrame' (`DF.take'` dFrame') (DF.limit dfExpr)

1199 pure (Right dFrame'')

1054 pure (Right dFrame'')

1200−executeDataFrameExpr sessionId conn@(RemoteProcessConnection _) dfExpr = remoteCall conn (ExecuteDataFrameExpr sessionId dfExpr)

1055+executeDataFrameExpr sessionId conn@(RemoteConnection _) dfExpr = remoteCall conn (ExecuteDataFrameExpr sessionId dfExpr)

1201

1056

1057+validateMerkleHashes :: SessionId -> Connection -> IO (Either RelationalError ())

1058+validateMerkleHashes sessionId (InProcessConnection conf) = do

1059+ let sessions = ipSessions conf

1060+ atomically $ do

1061+ eSession <- sessionForSessionId sessionId sessions

1062+ case eSession of

1063+ Left err -> pure (Left err)

1064+ Right _ -> do

1065+ graph <- readTVar (ipTransactionGraph conf)

1066+ case Graph.validateMerkleHashes graph of

1067+ Left merkleErrs -> pure $ Left $ someErrors (map (\(MerkleValidationError tid expected actual) -> MerkleHashValidationError tid expected actual) merkleErrs)

1068+ Right () -> pure (Right ())

1069+validateMerkleHashes sessionId conn@RemoteConnection{} = remoteCall conn (ExecuteValidateMerkleHashes sessionId)

1070+

1071+type ClientNodes = StmSet.Set ClientInfo

1072+

1073+-- internal structure specific to in-process connections

1074+data InProcessConnectionConf = InProcessConnectionConf {

1075+ ipPersistenceStrategy :: PersistenceStrategy,

1076+ ipClientNodes :: ClientNodes,

1077+ ipSessions :: Sessions,

1078+ ipTransactionGraph :: TVar TransactionGraph,

1079+ ipScriptSession :: Maybe ScriptSession,

1080+ ipLocks :: Maybe (LockFile, MVar LockFileHash), -- nothing when NoPersistence

1081+ ipCallbackAsync :: Async ()

1082+ }

1083+

1084+-- clients may connect associate one socket/mvar with the server to register for change callbacks

1085+data ClientInfo = RemoteClientInfo (RPC.Locking Socket) |

1086+ InProcessClientInfo (MVar EvaluatedNotifications)

1087+

1088+instance Eq ClientInfo where

1089+ (RemoteClientInfo a) == (RemoteClientInfo b) = RPC.lockless a == RPC.lockless b

1090+ (InProcessClientInfo a) == (InProcessClientInfo b) = a == b

1091+ _ == _ = False

1092+

1093+instance Hashable ClientInfo where

1094+ hashWithSalt salt (RemoteClientInfo sock) = hashWithSalt salt (show (RPC.lockless sock))

1095+ hashWithSalt salt (InProcessClientInfo _) = hashWithSalt salt (1::Int)

src/lib/ProjectM36/DataFrame.hs+23−15

@@ -1,8 +1,8 @@

1−{-# LANGUAGE DeriveGeneric, DeriveAnyClass #-}

1+{-# LANGUAGE DeriveGeneric, DerivingVia #-}

2{- A dataframe is a strongly-typed, ordered list of named tuples. A dataframe differs from a relation in that its tuples are ordered.-}

3module ProjectM36.DataFrame where

4import ProjectM36.Base

5−import ProjectM36.Attribute as A

5+import ProjectM36.Attribute as A hiding (drop)

6import ProjectM36.Error

7import qualified ProjectM36.Relation as R

8import ProjectM36.Relation.Show.Term

@@ -16,15 +16,19 @@ import qualified Data.List as L

16import qualified Data.Set as S

17import Data.Maybe

18import qualified Data.Text as T

19−import Data.Binary

20import Control.Arrow

19import Control.Arrow

21−#if __GLASGOW_HASKELL__ <= 802

20+#if __GLASGOW_HASKELL__ < 804

22import Data.Monoid

21import Data.Monoid

23#endif

22#endif

24

23

25−data AttributeOrderExpr = AttributeOrderExpr AttributeName Order deriving (Show, Generic, Binary)

24+data AttributeOrderExpr = AttributeOrderExpr AttributeName Order

25+ deriving (Show, Generic)

26+

26−data AttributeOrder = AttributeOrder AttributeName Order deriving (Show, Generic, Binary)

27+data AttributeOrder = AttributeOrder AttributeName Order

28+ deriving (Show, Generic)

29+

27−data Order = AscendingOrder | DescendingOrder deriving (Eq, Show, Generic, Binary)

30+data Order = AscendingOrder | DescendingOrder

31+ deriving (Eq, Show, Generic)

28

32

29ascending :: T.Text

33ascending :: T.Text

30ascending = "⬆"

34ascending = "⬆"

@@ -39,9 +43,11 @@ data DataFrame = DataFrame {

39 orders :: [AttributeOrder],

43 orders :: [AttributeOrder],

40 attributes :: Attributes,

44 attributes :: Attributes,

41 tuples :: [DataFrameTuple]

45 tuples :: [DataFrameTuple]

46+ }

42− } deriving (Show, Generic, Binary)

47+ deriving (Show, Generic)

43

48

44−data DataFrameTuple = DataFrameTuple Attributes (V.Vector Atom) deriving (Eq, Show, Generic, Binary)

49+data DataFrameTuple = DataFrameTuple Attributes (V.Vector Atom)

50+ deriving (Eq, Show, Generic)

45

51

46sortDataFrameBy :: [AttributeOrder] -> DataFrame -> Either RelationalError DataFrame

52sortDataFrameBy :: [AttributeOrder] -> DataFrame -> Either RelationalError DataFrame

47sortDataFrameBy attrOrders frame = do

53sortDataFrameBy attrOrders frame = do

@@ -75,7 +81,7 @@ compareTupleByOneAttributeName attr tuple1 tuple2 =

75 Right atom2 -> compareAtoms atom1 atom2

81 Right atom2 -> compareAtoms atom1 atom2

76

82

77atomForAttributeName :: AttributeName -> DataFrameTuple -> Either RelationalError Atom

83atomForAttributeName :: AttributeName -> DataFrameTuple -> Either RelationalError Atom

78−atomForAttributeName attrName (DataFrameTuple tupAttrs tupVec) = case V.findIndex (\attr -> attributeName attr == attrName) tupAttrs of

84+atomForAttributeName attrName (DataFrameTuple tupAttrs tupVec) = case V.findIndex (\attr -> attributeName attr == attrName) (attributesVec tupAttrs) of

79 Nothing -> Left (NoSuchAttributeNamesError (S.singleton attrName))

85 Nothing -> Left (NoSuchAttributeNamesError (S.singleton attrName))

80 Just index -> case tupVec V.!? index of

86 Just index -> case tupVec V.!? index of

81 Nothing -> Left (NoSuchAttributeNamesError (S.singleton attrName))

87 Nothing -> Left (NoSuchAttributeNamesError (S.singleton attrName))

@@ -122,17 +128,18 @@ data DataFrameExpr = DataFrameExpr {

122 orderExprs :: [AttributeOrderExpr],

128 orderExprs :: [AttributeOrderExpr],

123 offset :: Maybe Integer,

129 offset :: Maybe Integer,

124 limit :: Maybe Integer

130 limit :: Maybe Integer

131+ }

125− } deriving (Show, Binary, Generic)

132+ deriving (Show, Generic)

126

133

127dataFrameAsHTML :: DataFrame -> T.Text

134dataFrameAsHTML :: DataFrame -> T.Text

128-- web browsers don't display tables with empty cells or empty headers, so we have to insert some placeholders- it's not technically the same, but looks as expected in the browser

135-- web browsers don't display tables with empty cells or empty headers, so we have to insert some placeholders- it's not technically the same, but looks as expected in the browser

129dataFrameAsHTML df

136dataFrameAsHTML df

130− | length (tuples df) == 1 && L.null (attributes df) = style <>

137+ | length (tuples df) == 1 && A.null (attributes df) = style <>

131 tablestart <>

138 tablestart <>

132 "<tr><th></th></tr>" <>

139 "<tr><th></th></tr>" <>

133 "<tr><td></td></tr>" <>

140 "<tr><td></td></tr>" <>

134 tablefooter <> "</table>"

141 tablefooter <> "</table>"

135− | L.null (tuples df) && L.null (attributes df) = style <>

142+ | L.null (tuples df) && A.null (attributes df) = style <>

136 tablestart <>

143 tablestart <>

137 "<tr><th></th></tr>" <>

144 "<tr><th></th></tr>" <>

138 tablefooter <>

145 tablefooter <>

@@ -155,7 +162,7 @@ tuplesAsHTML = foldr folder ""

155 folder tuple acc = acc <> tupleAsHTML tuple

162 folder tuple acc = acc <> tupleAsHTML tuple

156

163

157tupleAssocs :: DataFrameTuple -> [(AttributeName, Atom)]

164tupleAssocs :: DataFrameTuple -> [(AttributeName, Atom)]

158−tupleAssocs (DataFrameTuple attrVec tupVec) = V.toList $ V.map (first attributeName) (V.zip attrVec tupVec)

165+tupleAssocs (DataFrameTuple attrs tupVec) = V.toList $ V.map (first attributeName) (V.zip (attributesVec attrs) tupVec)

159

166

160

167

161tupleAsHTML :: DataFrameTuple -> T.Text

168tupleAsHTML :: DataFrameTuple -> T.Text

@@ -163,10 +170,11 @@ tupleAsHTML tuple = "<tr>" <> T.concat (L.map tupleFrag (tupleAssocs tuple)) <>

163 where

170 where

164 tupleFrag tup = "<td>" <> atomAsHTML (snd tup) <> "</td>"

171 tupleFrag tup = "<td>" <> atomAsHTML (snd tup) <> "</td>"

165 atomAsHTML (RelationAtom rel) = RelHTML.relationAsHTML rel

172 atomAsHTML (RelationAtom rel) = RelHTML.relationAsHTML rel

173+ atomAsHTML (TextAtom t) = """ <> t <> """

166 atomAsHTML atom = atomToText atom

174 atomAsHTML atom = atomToText atom

167

175

168attributesAsHTML :: Attributes -> [AttributeOrder] -> T.Text

176attributesAsHTML :: Attributes -> [AttributeOrder] -> T.Text

169−attributesAsHTML attrs orders' = "<tr>" <> T.concat (map oneAttrHTML (V.toList attrs)) <> "</tr>"

177+attributesAsHTML attrs orders' = "<tr>" <> T.concat (map oneAttrHTML (A.toList attrs)) <> "</tr>"

170 where

178 where

171 oneAttrHTML attr = "<th>" <> prettyAttribute attr <> ordering (attributeName attr) <> "</th>"

179 oneAttrHTML attr = "<th>" <> prettyAttribute attr <> ordering (attributeName attr) <> "</th>"

172 ordering attrName = " " <> case L.find (\(AttributeOrder nam _) -> nam == attrName) orders' of

180 ordering attrName = " " <> case L.find (\(AttributeOrder nam _) -> nam == attrName) orders' of

src/lib/ProjectM36/DataTypes/Interval.hs+2

@@ -37,6 +37,7 @@ supportsInterval typ = case typ of

37 BoolAtomType -> False

38 RelationAtomType _ -> False

39 ConstructedAtomType _ _ -> False --once we support an interval-style typeclass, we might enable this

40+ RelationalExprAtomType -> False

40 TypeVariableType _ -> False

41 TypeVariableType _ -> False

41

42

42supportsOrdering :: AtomType -> Bool

43supportsOrdering :: AtomType -> Bool

@@ -50,6 +51,7 @@ supportsOrdering typ = case typ of

50 ByteStringAtomType -> False

51 ByteStringAtomType -> False

51 BoolAtomType -> False

52 BoolAtomType -> False

52 RelationAtomType _ -> False

53 RelationAtomType _ -> False

54+ RelationalExprAtomType -> False

53 ConstructedAtomType _ _ -> False --once we support an interval-style typeclass, we might enable this

55 ConstructedAtomType _ _ -> False --once we support an interval-style typeclass, we might enable this

54 TypeVariableType _ -> False

56 TypeVariableType _ -> False

55

57

src/lib/ProjectM36/DataTypes/Primitive.hs+1

@@ -42,3 +42,4 @@ atomTypeForAtom (ByteStringAtom _) = ByteStringAtomType

42atomTypeForAtom (BoolAtom _) = BoolAtomType

43atomTypeForAtom (RelationAtom (Relation attrs _)) = RelationAtomType attrs

44atomTypeForAtom (ConstructedAtom _ aType _) = aType

45+atomTypeForAtom (RelationalExprAtom _) = RelationalExprAtomType

src/lib/ProjectM36/DataTypes/Sorting.hs+1

@@ -24,6 +24,7 @@ isSortableAtomType typ = case typ of

24 DateTimeAtomType -> True

25 ByteStringAtomType -> False

26 BoolAtomType -> True

27+ RelationalExprAtomType -> False

27 RelationAtomType _ -> False

28 RelationAtomType _ -> False

28 ConstructedAtomType _ _ -> False

29 ConstructedAtomType _ _ -> False

29 TypeVariableType _ -> False

30 TypeVariableType _ -> False

src/lib/ProjectM36/DatabaseContext.hs+22−3

@@ -1,11 +1,15 @@

1module ProjectM36.DatabaseContext where

2import ProjectM36.Base

3+import Control.Monad (void)

3import qualified Data.Map as M

4import qualified Data.Map as M

4import qualified Data.HashSet as HS

5import qualified Data.HashSet as HS

5import ProjectM36.DataTypes.Basic

6import ProjectM36.DataTypes.Basic

6import ProjectM36.AtomFunctions.Basic

7import ProjectM36.AtomFunctions.Basic

7−import ProjectM36.DatabaseContextFunction

8import ProjectM36.Relation

9+import qualified Data.ByteString.Lazy as BL

10+import ProjectM36.AtomFunction as AF

11+import ProjectM36.DatabaseContextFunction as DBCF

12+import Codec.Winery

9

13

10empty :: DatabaseContext

14empty :: DatabaseContext

11empty = DatabaseContext { inclusionDependencies = M.empty,

15empty = DatabaseContext { inclusionDependencies = M.empty,

@@ -14,12 +18,16 @@ empty = DatabaseContext { inclusionDependencies = M.empty,

14 atomFunctions = HS.empty,

18 atomFunctions = HS.empty,

15 dbcFunctions = HS.empty,

19 dbcFunctions = HS.empty,

16 typeConstructorMapping = [] }

20 typeConstructorMapping = [] }

21+

22+-- | Remove TransactionId markers on GraphRefRelationalExpr

23+stripGraphRefRelationalExpr :: GraphRefRelationalExpr -> RelationalExpr

24+stripGraphRefRelationalExpr = void

17

25

18-- | convert an existing database context into its constituent expression.

26-- | convert an existing database context into its constituent expression.

19databaseContextAsDatabaseContextExpr :: DatabaseContext -> DatabaseContextExpr

27databaseContextAsDatabaseContextExpr :: DatabaseContext -> DatabaseContextExpr

20−databaseContextAsDatabaseContextExpr _ = unimplemented {-MultipleExpr $ relVarsExprs ++ incDepsExprs ++ funcsExprs

28+databaseContextAsDatabaseContextExpr context = MultipleExpr $ relVarsExprs ++ incDepsExprs ++ funcsExprs

21 where

29 where

22− relVarsExprs = map (\(name, rel) -> --Assign name (ExistingRelation rel)) (M.toList (relationVariables context))

30+ relVarsExprs = map (\(name, rel) -> Assign name (stripGraphRefRelationalExpr rel)) (M.toList (relationVariables context))

23 incDepsExprs :: [DatabaseContextExpr]

31 incDepsExprs :: [DatabaseContextExpr]

24 incDepsExprs = map (uncurry AddInclusionDependency) (M.toList (inclusionDependencies context))

32 incDepsExprs = map (uncurry AddInclusionDependency) (M.toList (inclusionDependencies context))

25 funcsExprs = [] -- map (\func -> ) (HS.toList funcs) -- there are no databaseExprs to add atom functions yet-}

33 funcsExprs = [] -- map (\func -> ) (HS.toList funcs) -- there are no databaseExprs to add atom functions yet-}

@@ -33,3 +41,14 @@ basicDatabaseContext = DatabaseContext { inclusionDependencies = M.empty,

33 notifications = M.empty,

41 notifications = M.empty,

34 typeConstructorMapping = basicTypeConstructorMapping

42 typeConstructorMapping = basicTypeConstructorMapping

35 }

43 }

44+

45+--for building the Merkle hash

46+hashBytes :: DatabaseContext -> BL.ByteString

47+hashBytes ctx = BL.fromChunks [incDeps, rvs, nots, tConsMap] <> atomFs <> dbcFs

48+ where

49+ incDeps = serialise (inclusionDependencies ctx)

50+ rvs = serialise (relationVariables ctx)

51+ atomFs = HS.foldr (mappend . AF.hashBytes) mempty (atomFunctions ctx)

52+ dbcFs = HS.foldr (mappend . DBCF.hashBytes) mempty (dbcFunctions ctx)

53+ nots = serialise (notifications ctx)

54+ tConsMap = serialise (typeConstructorMapping ctx)

src/lib/ProjectM36/DatabaseContextFunction.hs+17−1

@@ -1,7 +1,9 @@

1+{-# LANGUAGE CPP #-}

1module ProjectM36.DatabaseContextFunction where

2module ProjectM36.DatabaseContextFunction where

2--implements functions which operate as: [Atom] -> DatabaseContextExpr -> Either RelationalError DatabaseContextExpr

3--implements functions which operate as: [Atom] -> DatabaseContextExpr -> Either RelationalError DatabaseContextExpr

3import ProjectM36.Base

4import ProjectM36.Base

4import ProjectM36.Error

5import ProjectM36.Error

6+import ProjectM36.Serialise.Base ()

5import ProjectM36.Attribute as A

7import ProjectM36.Attribute as A

6import ProjectM36.Relation

8import ProjectM36.Relation

7import ProjectM36.AtomType

9import ProjectM36.AtomType

@@ -9,6 +11,8 @@ import qualified Data.HashSet as HS

9import qualified Data.Map as M

11import qualified Data.Map as M

10import ProjectM36.ScriptSession

12import ProjectM36.ScriptSession

11import qualified Data.Text as T

13import qualified Data.Text as T

14+import qualified Data.ByteString.Lazy as BL

15+import Codec.Winery

12

16

13emptyDatabaseContextFunction :: DatabaseContextFunctionName -> DatabaseContextFunction

17emptyDatabaseContextFunction :: DatabaseContextFunctionName -> DatabaseContextFunction

14emptyDatabaseContextFunction name = DatabaseContextFunction {

18emptyDatabaseContextFunction name = DatabaseContextFunction {

@@ -61,7 +65,11 @@ createScriptedDatabaseContextFunction :: DatabaseContextFunctionName -> [TypeCon

61createScriptedDatabaseContextFunction funcName argsIn retArg = AddDatabaseContextFunction funcName (argsIn ++ [databaseContextFunctionReturnType retArg])

65createScriptedDatabaseContextFunction funcName argsIn retArg = AddDatabaseContextFunction funcName (argsIn ++ [databaseContextFunctionReturnType retArg])

62

66

63loadDatabaseContextFunctions :: ModName -> FuncName -> FilePath -> IO (Either LoadSymbolError [DatabaseContextFunction])

67loadDatabaseContextFunctions :: ModName -> FuncName -> FilePath -> IO (Either LoadSymbolError [DatabaseContextFunction])

68+#ifdef PM36_HASKELL_SCRIPTING

64loadDatabaseContextFunctions = loadFunction

69loadDatabaseContextFunctions = loadFunction

70+#else

71+loadDatabaseContextFunctions _ _ _ = pure (Left LoadSymbolError)

72+#endif

65

73

66databaseContextFunctionsAsRelation :: DatabaseContextFunctions -> Either RelationalError Relation

74databaseContextFunctionsAsRelation :: DatabaseContextFunctions -> Either RelationalError Relation

67databaseContextFunctionsAsRelation dbcFuncs = mkRelationFromList attrs tups

75databaseContextFunctionsAsRelation dbcFuncs = mkRelationFromList attrs tups

@@ -72,4 +80,12 @@ databaseContextFunctionsAsRelation dbcFuncs = mkRelationFromList attrs tups

72 dbcFuncToTuple func = [TextAtom (dbcFuncName func),

80 dbcFuncToTuple func = [TextAtom (dbcFuncName func),

73 TextAtom (dbcTextType (dbcFuncType func))]

81 TextAtom (dbcTextType (dbcFuncType func))]

74 dbcTextType typ = T.intercalate " -> " (map prettyAtomType typ ++ ["DatabaseContext", "DatabaseContext"])

82 dbcTextType typ = T.intercalate " -> " (map prettyAtomType typ ++ ["DatabaseContext", "DatabaseContext"])

75−

83+

84+-- for merkle hash

85+hashBytes :: DatabaseContextFunction -> BL.ByteString

86+hashBytes func = BL.fromChunks [fname, ftype, fbody]

87+ where

88+ fname = serialise (dbcFuncName func)

89+ ftype = serialise (dbcFuncType func)

90+ fbody = case dbcFuncBody func of

91+ DatabaseContextFunctionBody mBody _ -> serialise mBody

src/lib/ProjectM36/DatabaseContextFunctionError.hs+1−2

@@ -1,9 +1,8 @@

1{-# LANGUAGE DeriveGeneric, DeriveAnyClass #-}

2module ProjectM36.DatabaseContextFunctionError where

3import GHC.Generics

4−import Data.Binary

5import Control.DeepSeq

4import Control.DeepSeq

6

5

7{-# ANN module ("HLint: ignore Use newtype instead of data" :: String) #-}

6{-# ANN module ("HLint: ignore Use newtype instead of data" :: String) #-}

8data DatabaseContextFunctionError = DatabaseContextFunctionUserError String

7data DatabaseContextFunctionError = DatabaseContextFunctionUserError String

9− deriving (Generic, Eq, Show, Binary, NFData)

8+ deriving (Generic, Eq, Show, NFData)

src/lib/ProjectM36/DatabaseContextFunctionUtils.hs+3−3

@@ -14,9 +14,9 @@ executeDatabaseContextExpr expr transId graph context' =

14 env = mkDatabaseContextEvalEnv transId graph

15 run = runDatabaseContextEvalMonad context' env (optimizeAndEvalDatabaseContextExpr True expr)

16

17−executeRelationalExpr :: RelationalExpr -> DatabaseContext -> TransactionId -> TransactionGraph -> Either RelationalError Relation

17+executeRelationalExpr :: RelationalExpr -> DatabaseContext -> TransactionGraph -> Either RelationalError Relation

18−executeRelationalExpr expr context transId graph =

18+executeRelationalExpr expr context graph =

19 run

20 where

21− env = mkRelationalExprEnv context transId graph

21+ env = mkRelationalExprEnv context graph

22 run = optimizeAndEvalRelationalExpr env expr

src/lib/ProjectM36/DisconnectedTransaction.hs+2−6

@@ -11,11 +11,7 @@ parentId :: DisconnectedTransaction -> TransactionId

11parentId (DisconnectedTransaction pid _ _) = pid

12

13isDirty :: DisconnectedTransaction -> Bool

14−isDirty (DisconnectedTransaction _ _ NoOperation) = False

14+isDirty (DisconnectedTransaction _ _ flag) = flag

15−isDirty _ = True

16−

17−diffExpr :: DisconnectedTransaction -> DatabaseContextExpr

18−diffExpr (DisconnectedTransaction _ _ expr) = expr

19

15

20freshTransaction :: TransactionId -> Schemas -> DisconnectedTransaction

16freshTransaction :: TransactionId -> Schemas -> DisconnectedTransaction

21−freshTransaction tid schemas' = DisconnectedTransaction tid schemas' NoOperation

17+freshTransaction tid schemas' = DisconnectedTransaction tid schemas' False

src/lib/ProjectM36/Error.hs+22−14

@@ -1,6 +1,7 @@

1{-# LANGUAGE DeriveGeneric, DeriveAnyClass #-}

2module ProjectM36.Error where

3import ProjectM36.Base

4+import ProjectM36.MerkleHash

4import ProjectM36.DatabaseContextFunctionError

5import ProjectM36.DatabaseContextFunctionError

5import ProjectM36.AtomFunctionError

6import ProjectM36.AtomFunctionError

6import qualified Data.Set as S

7import qualified Data.Set as S

@@ -8,7 +9,6 @@ import Control.DeepSeq (NFData, rnf)

8import Control.DeepSeq.Generics (genericRnf)

9import Control.DeepSeq.Generics (genericRnf)

9import GHC.Generics (Generic)

10import GHC.Generics (Generic)

10import qualified Data.Text as T

11import qualified Data.Text as T

11−import Data.Binary

12import Data.Typeable

13import Control.Exception

14

@@ -81,7 +81,7 @@ data RelationalError = NoSuchAttributeNamesError (S.Set AttributeName)

81 | RelationValuedAttributesNotSupportedError [AttributeName]

82 | NotificationNameInUseError NotificationName

83 | NotificationNameNotInUseError NotificationName

84− | ImportError T.Text -- really? This should be broken out into some other error type- this has nothing to do with relational algebra

84+ | ImportError ImportError'

85 | ExportError T.Text

86 | UnhandledExceptionError String

87 | MergeTransactionError MergeError

@@ -98,14 +98,19 @@ data RelationalError = NoSuchAttributeNamesError (S.Set AttributeName)

98 | ImproperDatabaseStateError

99

100 | NonConcreteSchemaPlanError

101−

101+

102+ | NoUncommittedContextInEvalError

103+ | TupleExprsReferenceMultipleMarkersError

104+

105+ | MerkleHashValidationError TransactionId MerkleHash MerkleHash

106+

102 | MultipleErrors [RelationalError]

107 | MultipleErrors [RelationalError]

103− deriving (Show,Eq,Generic,Binary,Typeable, NFData)

108+ deriving (Show,Eq,Generic,Typeable, NFData)

104

109

105data PersistenceError = InvalidDirectoryError FilePath |

110data PersistenceError = InvalidDirectoryError FilePath |

106 MissingTransactionError TransactionId |

111 MissingTransactionError TransactionId |

107 WrongDatabaseFormatVersionError String String

112 WrongDatabaseFormatVersionError String String

108− deriving (Show, Eq, Generic, Binary, NFData)

113+ deriving (Show, Eq, Generic, NFData)

109

114

110--collapse list of errors into normal error- if there is just one, just return one

115--collapse list of errors into normal error- if there is just one, just return one

111someErrors :: [RelationalError] -> RelationalError

116someErrors :: [RelationalError] -> RelationalError

@@ -123,7 +128,7 @@ data MergeError = SelectedHeadMismatchMergeError |

123 StrategyViolatesComponentMergeError | --failed merge in inc deps, relvars, etc.

128 StrategyViolatesComponentMergeError | --failed merge in inc deps, relvars, etc.

124 StrategyViolatesRelationVariableMergeError |

129 StrategyViolatesRelationVariableMergeError |

125 StrategyViolatesTypeConstructorMergeError

130 StrategyViolatesTypeConstructorMergeError

126− deriving (Show, Eq, Generic, Binary, Typeable)

131+ deriving (Show, Eq, Generic, Typeable)

127

132

128instance NFData MergeError where rnf = genericRnf

133instance NFData MergeError where rnf = genericRnf

129

134

@@ -131,17 +136,20 @@ data ScriptCompilationError = TypeCheckCompilationError String String | --expect

131 SyntaxErrorCompilationError String |

136 SyntaxErrorCompilationError String |

132 ScriptCompilationDisabledError |

137 ScriptCompilationDisabledError |

133 OtherScriptCompilationError String

138 OtherScriptCompilationError String

134− deriving (Show, Eq, Generic, Binary, Typeable, NFData)

139+ deriving (Show, Eq, Generic, Typeable, NFData)

135

140

136instance Exception ScriptCompilationError

141instance Exception ScriptCompilationError

137

142

138data SchemaError = RelVarReferencesMissing (S.Set RelVarName) |

143data SchemaError = RelVarReferencesMissing (S.Set RelVarName) |

139 RelVarInReferencedMoreThanOnce RelVarName |

144 RelVarInReferencedMoreThanOnce RelVarName |

140 RelVarOutReferencedMoreThanOnce RelVarName

145 RelVarOutReferencedMoreThanOnce RelVarName

141− deriving (Show, Eq, Generic, Binary, Typeable, NFData)

146+ deriving (Show, Eq, Generic, Typeable, NFData)

142−

147+

143−

148+

144−-- errors returned from the distributed-process call handlers

149+data ImportError' = InvalidSHA256Error T.Text

145−data ServerError = RequestTimeoutError |

150+ | SHA256MismatchError T.Text T.Text

146− ProcessDiedError String

151+ | InvalidFileURIError T.Text

152+ | ImportFileDecodeError T.Text

153+ | ImportFileError T.Text

154+ | ImportDownloadError T.Text

147− deriving (Generic, Binary, Eq)

155+ deriving (Show, Eq, Generic, Typeable, NFData)

src/lib/ProjectM36/FileLock.hs+1−1

@@ -1,4 +1,4 @@

1−{-# LANGUAGE CPP, NamedFieldPuns #-}

1+{-# LANGUAGE CPP #-}

2--cross-platform file locking utilizing POSIX file locking on Unix/Linux and Windows file locking

3--hackage's System.FileLock doesn't support POSIX advisory locks nor locking file based on file descriptors, hence this needless rewrite

4module ProjectM36.FileLock where

src/lib/ProjectM36/GraphRefRelationalExpr.hs+26−27

@@ -1,46 +1,45 @@

1module ProjectM36.GraphRefRelationalExpr where

2--evaluate relational expressions across the entire transaction graph to support cross-transaction referencing

3import ProjectM36.Base

4−import ProjectM36.Error

5import qualified Data.Set as S

4import qualified Data.Set as S

6

5

7−-- core evaluation function- all other relational expr forms compile to GraphRefRelationalExpr

6+--import Debug.Trace

8−eval :: GraphRefRelationalExpr -> TransactionGraph -> Either RelationalError Relation

9−eval = undefined

10−{-eval (MakeRelationFromExprs mAttrExprs tupleExprs) graph = do

11− mAttrs <- case mAttrExprs of

12− Just _ ->

13− Just . A.attributesFromList <$> mapM (evalAttrExpr tConss) (fromMaybe [] mAttrExprs)

14− Nothing -> pure Nothing

15− tuples <- mapM (evalTupleExpr mAttrs) tupleExprs

16− let attrs = fromMaybe firstTupleAttrs mAttrs

17− firstTupleAttrs = if null tuples then A.emptyAttributes else tupleAttributes (head tuples)

18− mkRelation attrs (RelationTupleSet tuples)

19−

20

7

21−-}

22−

23−data SingularTransactionRef = SingularTransactionRef TransactionId |

8+data SingularTransactionRef = SingularTransactionRef GraphRefTransactionMarker |

24 MultipleTransactionsRef |

9 MultipleTransactionsRef |

25 NoTransactionsRef

10 NoTransactionsRef

26 deriving (Eq, Show)

11 deriving (Eq, Show)

12+

13+instance Semigroup SingularTransactionRef where

14+ NoTransactionsRef <> x = x

15+ MultipleTransactionsRef <> _ = MultipleTransactionsRef

16+ SingularTransactionRef tidA <> s@(SingularTransactionRef tidB) =

17+ if tidA == tidB then

18+ s

19+ else

20+ MultipleTransactionsRef

21+ s@SingularTransactionRef{} <> NoTransactionsRef = s

22+ _ <> MultipleTransactionsRef = MultipleTransactionsRef

23+

24+instance Monoid SingularTransactionRef where

25+ mempty = NoTransactionsRef

27

26

28-- | return `Just transid` if this GraphRefRelationalExpr refers to just one transaction in the graph. This is useful for determining if certain optimizations can apply.

27-- | return `Just transid` if this GraphRefRelationalExpr refers to just one transaction in the graph. This is useful for determining if certain optimizations can apply.

29−singularTransaction :: GraphRefRelationalExpr -> SingularTransactionRef

28+singularTransaction :: Foldable t => t GraphRefTransactionMarker -> SingularTransactionRef

30−singularTransaction expr =

29+singularTransaction expr

31− if S.null transSet then

32− NoTransactionsRef

30+ | S.null transSet = NoTransactionsRef

33− else if S.size transSet == 1 then

34− SingularTransactionRef (head (S.toList transSet))

31+ | S.size transSet == 1 = SingularTransactionRef (head (S.toList transSet))

35− else

36− MultipleTransactionsRef

32+ | otherwise = MultipleTransactionsRef

37 where

33 where

38− transSet = foldr (\transId acc -> S.insert transId acc) S.empty expr

34+ transSet = foldr S.insert S.empty expr

39

35

40-- | Return True if two 'GraphRefRelationalExpr's both refer exclusively to the same transaction (or none at all).

36-- | Return True if two 'GraphRefRelationalExpr's both refer exclusively to the same transaction (or none at all).

41−inSameTransaction :: GraphRefRelationalExpr -> GraphRefRelationalExpr -> Maybe TransactionId

37+inSameTransaction :: GraphRefRelationalExpr -> GraphRefRelationalExpr -> Maybe GraphRefTransactionMarker

42inSameTransaction exprA exprB = case (stA, stB) of

38inSameTransaction exprA exprB = case (stA, stB) of

43 (SingularTransactionRef tA, SingularTransactionRef tB) | tA == tB -> Just tA

39 (SingularTransactionRef tA, SingularTransactionRef tB) | tA == tB -> Just tA

44 _ -> Nothing

40 _ -> Nothing

45 where stA = singularTransaction exprA

41 where stA = singularTransaction exprA

46 stB = singularTransaction exprB

42 stB = singularTransaction exprB

43+

44+singularTransactions :: (Foldable f, Foldable t) => f (t GraphRefTransactionMarker) -> SingularTransactionRef

45+singularTransactions = foldMap singularTransaction

src/lib/ProjectM36/InclusionDependency.hs+5−6

@@ -4,17 +4,16 @@ import ProjectM36.Attribute

4import ProjectM36.Error

5import ProjectM36.Relation

6import qualified Data.Map as M

7−import qualified Data.Text as T

8

7

9inclusionDependenciesAsRelation :: InclusionDependencies -> Either RelationalError Relation

8inclusionDependenciesAsRelation :: InclusionDependencies -> Either RelationalError Relation

10inclusionDependenciesAsRelation incDeps =

9inclusionDependenciesAsRelation incDeps =

11 mkRelationFromList attrs (map incDepAsAtoms (M.toList incDeps))

10 mkRelationFromList attrs (map incDepAsAtoms (M.toList incDeps))

12 where

11 where

13 attrs = attributesFromList [Attribute "name" TextAtomType,

12 attrs = attributesFromList [Attribute "name" TextAtomType,

14− Attribute "sub" TextAtomType,

13+ Attribute "sub" RelationalExprAtomType,

15− Attribute "super" TextAtomType

14+ Attribute "super" RelationalExprAtomType

16 ]

15 ]

17 incDepAsAtoms (name, InclusionDependency exprA exprB) = [TextAtom name,

16 incDepAsAtoms (name, InclusionDependency exprA exprB) = [TextAtom name,

18− TextAtom (T.pack (show exprA)),

17+ RelationalExprAtom exprA,

19− TextAtom (T.pack (show exprB))]

18+ RelationalExprAtom exprB]

20−

19+

src/lib/ProjectM36/IsomorphicSchema.hs+6−9

@@ -1,4 +1,4 @@

1−{-# LANGUAGE DeriveGeneric, DeriveAnyClass, LambdaCase #-}

1+{-# LANGUAGE DeriveGeneric, LambdaCase, DerivingVia #-}

2module ProjectM36.IsomorphicSchema where

3import ProjectM36.Base

4import ProjectM36.Error

@@ -9,14 +9,12 @@ import ProjectM36.RelationalExpression

9import qualified ProjectM36.AttributeNames as AN

10import Control.Monad

11import GHC.Generics

12−import Data.Binary

13import qualified Data.Map as M

12import qualified Data.Map as M

14import qualified Data.Set as S

13import qualified Data.Set as S

15import qualified Data.List as L

14import qualified Data.List as L

16−#if __GLASGOW_HASKELL__ <= 802

15+#if __GLASGOW_HASKELL__ < 804

17import Data.Monoid

16import Data.Monoid

18#endif

17#endif

19−

20-- isomorphic schemas offer bi-directional functors between two schemas

18-- isomorphic schemas offer bi-directional functors between two schemas

21

19

22--TODO: note that renaming a relvar should alter any stored isomorphisms as well

20--TODO: note that renaming a relvar should alter any stored isomorphisms as well

@@ -29,8 +27,7 @@ import Data.Monoid

29

27

30data SchemaExpr = AddSubschema SchemaName SchemaIsomorphs |

28data SchemaExpr = AddSubschema SchemaName SchemaIsomorphs |

31 RemoveSubschema SchemaName

29 RemoveSubschema SchemaName

32− deriving (Generic, Binary, Show)

30+ deriving (Generic, Show)

33−

34

31

35isomorphs :: Schema -> SchemaIsomorphs

32isomorphs :: Schema -> SchemaIsomorphs

36isomorphs (Schema i) = i

33isomorphs (Schema i) = i

@@ -256,14 +253,14 @@ inclusionDependencyInSchema schema (InclusionDependency rexprA rexprB) = do

256inclusionDependenciesInSchema :: Schema -> InclusionDependencies -> Either RelationalError InclusionDependencies

253inclusionDependenciesInSchema :: Schema -> InclusionDependencies -> Either RelationalError InclusionDependencies

257inclusionDependenciesInSchema schema incDeps = M.fromList <$> mapM (\(depName, dep) -> inclusionDependencyInSchema schema dep >>= \newDep -> pure (depName, newDep)) (M.toList incDeps)

254inclusionDependenciesInSchema schema incDeps = M.fromList <$> mapM (\(depName, dep) -> inclusionDependencyInSchema schema dep >>= \newDep -> pure (depName, newDep)) (M.toList incDeps)

258

255

259−relationVariablesInSchema :: Schema -> DatabaseContext -> TransactionId -> TransactionGraph -> Either RelationalError RelationVariables

256+relationVariablesInSchema :: Schema -> Either RelationalError RelationVariables

260−relationVariablesInSchema schema@(Schema morphs) context transId graph = foldM transform M.empty morphs

257+relationVariablesInSchema schema@(Schema morphs) = foldM transform M.empty morphs

261 where

258 where

262 transform newRvMap morph = do

259 transform newRvMap morph = do

263 let rvNames = isomorphInRelVarNames morph

260 let rvNames = isomorphInRelVarNames morph

264 rvAssocs <- mapM (\rv -> do

261 rvAssocs <- mapM (\rv -> do

265 expr' <- processRelationalExprInSchema schema (RelationVariable rv ())

262 expr' <- processRelationalExprInSchema schema (RelationVariable rv ())

266− let gfExpr = runProcessExprM transId graph (processRelationalExpr expr')

263+ let gfExpr = runProcessExprM UncommittedContextMarker (processRelationalExpr expr')

267 pure (rv, gfExpr)) rvNames

264 pure (rv, gfExpr)) rvNames

268 pure (M.union newRvMap (M.fromList rvAssocs))

265 pure (M.union newRvMap (M.fromList rvAssocs))

269

266

src/lib/ProjectM36/Key.hs+1−1

@@ -2,7 +2,7 @@ module ProjectM36.Key where

2import ProjectM36.Base

3import ProjectM36.Relation

4import qualified Data.Set as S

5−#if __GLASGOW_HASKELL__ <= 802

5+#if __GLASGOW_HASKELL__ < 804

6import Data.Monoid

7#endif

8

src/lib/ProjectM36/MerkleHash.hsnew file+9

@@ -0,0 +1,9 @@

1+{-# LANGUAGE GeneralizedNewtypeDeriving, DeriveGeneric, DerivingVia #-}

2+module ProjectM36.MerkleHash where

3+import Data.ByteString (ByteString)

4+import GHC.Generics

5+import Control.DeepSeq (NFData)

6+

7+newtype MerkleHash = MerkleHash { _unMerkleHash :: ByteString }

8+ deriving (Show, Eq, Generic, Monoid, Semigroup, NFData)

9+

src/lib/ProjectM36/NormalizeExpr.hs+17−15

@@ -5,18 +5,15 @@ import Control.Monad.Trans.Reader as R

5import qualified Data.Map as M

6

7--used to process/normalize exprs to their respective graph ref forms

8−type ProcessExprM a = Reader (TransactionGraph, TransactionId) a

8+type ProcessExprM a = Reader GraphRefTransactionMarker a

9

10type CurrentTransactionId = TransactionId

11

12−runProcessExprM :: CurrentTransactionId -> TransactionGraph -> ProcessExprM a -> a

12+runProcessExprM :: GraphRefTransactionMarker -> ProcessExprM a -> a

13−runProcessExprM tid graph m = runReader m (graph, tid)

13+runProcessExprM mtid m = runReader m mtid

14

15−askGraph :: ProcessExprM TransactionGraph

15+askMarker :: ProcessExprM GraphRefTransactionMarker

16−askGraph = fst <$> R.ask

16+askMarker = R.ask

17−

18−askTid :: ProcessExprM CurrentTransactionId

19−askTid = snd <$> R.ask

20

17

21-- convert a RelationalExpr into a GraphRefRelationalExpr using the current trans Id

18-- convert a RelationalExpr into a GraphRefRelationalExpr using the current trans Id

22processRelationalExpr :: RelationalExpr -> ProcessExprM GraphRefRelationalExpr

19processRelationalExpr :: RelationalExpr -> ProcessExprM GraphRefRelationalExpr

@@ -24,11 +21,11 @@ processRelationalExpr (MakeRelationFromExprs mAttrs tupleExprs) = do

24 mAttrs' <- case mAttrs of

21 mAttrs' <- case mAttrs of

25 Nothing -> pure Nothing

22 Nothing -> pure Nothing

26 Just mAttrs'' -> Just <$> mapM processAttributeExpr mAttrs''

23 Just mAttrs'' -> Just <$> mapM processAttributeExpr mAttrs''

27− MakeRelationFromExprs mAttrs' <$> mapM processTupleExpr tupleExprs

24+ MakeRelationFromExprs mAttrs' <$> processTupleExprs tupleExprs

28processRelationalExpr (MakeStaticRelation attrs tupSet) = pure (MakeStaticRelation attrs tupSet)

25processRelationalExpr (MakeStaticRelation attrs tupSet) = pure (MakeStaticRelation attrs tupSet)

29processRelationalExpr (ExistingRelation rel) = pure (ExistingRelation rel)

26processRelationalExpr (ExistingRelation rel) = pure (ExistingRelation rel)

30--requires current trans id and graph

27--requires current trans id and graph

31−processRelationalExpr (RelationVariable rv ()) = RelationVariable rv <$> askTid

28+processRelationalExpr (RelationVariable rv ()) = RelationVariable rv <$> askMarker

32processRelationalExpr (Project attrNames expr) = Project <$> processAttributeNames attrNames <*> processRelationalExpr expr

29processRelationalExpr (Project attrNames expr) = Project <$> processAttributeNames attrNames <*> processRelationalExpr expr

33processRelationalExpr (Union exprA exprB) = Union <$> processRelationalExpr exprA <*> processRelationalExpr exprB

30processRelationalExpr (Union exprA exprB) = Union <$> processRelationalExpr exprA <*> processRelationalExpr exprB

34processRelationalExpr (Join exprA exprB) = Join <$> processRelationalExpr exprA <*> processRelationalExpr exprB

31processRelationalExpr (Join exprA exprB) = Join <$> processRelationalExpr exprA <*> processRelationalExpr exprB

@@ -49,7 +46,7 @@ processRelationalExpr (With macros expr) =

49

46

50processWithNameExpr :: WithNameExpr -> ProcessExprM GraphRefWithNameExpr

47processWithNameExpr :: WithNameExpr -> ProcessExprM GraphRefWithNameExpr

51processWithNameExpr (WithNameExpr rvname ()) =

48processWithNameExpr (WithNameExpr rvname ()) =

52− WithNameExpr rvname <$> askTid

49+ WithNameExpr rvname <$> askMarker

53

50

54processAttributeNames :: AttributeNames -> ProcessExprM GraphRefAttributeNames

51processAttributeNames :: AttributeNames -> ProcessExprM GraphRefAttributeNames

55processAttributeNames (AttributeNames nameSet) = pure $ AttributeNames nameSet

52processAttributeNames (AttributeNames nameSet) = pure $ AttributeNames nameSet

@@ -114,17 +111,22 @@ processAtomExpr :: AtomExpr -> ProcessExprM GraphRefAtomExpr

114processAtomExpr (AttributeAtomExpr nam) = pure $ AttributeAtomExpr nam

111processAtomExpr (AttributeAtomExpr nam) = pure $ AttributeAtomExpr nam

115processAtomExpr (NakedAtomExpr atom) = pure $ NakedAtomExpr atom

112processAtomExpr (NakedAtomExpr atom) = pure $ NakedAtomExpr atom

116processAtomExpr (FunctionAtomExpr fName atomExprs ()) =

113processAtomExpr (FunctionAtomExpr fName atomExprs ()) =

117− FunctionAtomExpr fName <$> mapM processAtomExpr atomExprs <*> askTid

114+ FunctionAtomExpr fName <$> mapM processAtomExpr atomExprs <*> askMarker

118processAtomExpr (RelationAtomExpr expr) = RelationAtomExpr <$> processRelationalExpr expr

115processAtomExpr (RelationAtomExpr expr) = RelationAtomExpr <$> processRelationalExpr expr

119−processAtomExpr (ConstructedAtomExpr dConsName atomExprs ()) = ConstructedAtomExpr dConsName <$> mapM processAtomExpr atomExprs <*> askTid

116+processAtomExpr (ConstructedAtomExpr dConsName atomExprs ()) = ConstructedAtomExpr dConsName <$> mapM processAtomExpr atomExprs <*> askMarker

120

117

118+processTupleExprs :: TupleExprs -> ProcessExprM GraphRefTupleExprs

119+processTupleExprs (TupleExprs () tupleExprs) = do

120+ marker <- askMarker

121+ TupleExprs marker <$> mapM processTupleExpr tupleExprs

122+

121processTupleExpr :: TupleExpr -> ProcessExprM GraphRefTupleExpr

123processTupleExpr :: TupleExpr -> ProcessExprM GraphRefTupleExpr

122−processTupleExpr (TupleExpr tMap) =

124+processTupleExpr (TupleExpr tMap) =

123 TupleExpr . M.fromList <$> mapM (\(k,v) -> (,) k <$> processAtomExpr v) (M.toList tMap)

125 TupleExpr . M.fromList <$> mapM (\(k,v) -> (,) k <$> processAtomExpr v) (M.toList tMap)

124

126

125--convert AttributeExpr to GraphRefAttributeExpr

127--convert AttributeExpr to GraphRefAttributeExpr

126processAttributeExpr :: AttributeExpr -> ProcessExprM GraphRefAttributeExpr

128processAttributeExpr :: AttributeExpr -> ProcessExprM GraphRefAttributeExpr

127processAttributeExpr (AttributeAndTypeNameExpr nam tCons ()) =

129processAttributeExpr (AttributeAndTypeNameExpr nam tCons ()) =

128− AttributeAndTypeNameExpr nam tCons <$> askTid

130+ AttributeAndTypeNameExpr nam tCons <$> askMarker

129processAttributeExpr (NakedAttributeExpr attr) = pure $ NakedAttributeExpr attr

131processAttributeExpr (NakedAttributeExpr attr) = pure $ NakedAttributeExpr attr

130

132

src/lib/ProjectM36/Notifications.hs+4−4

@@ -7,13 +7,13 @@ import qualified Data.Map as M

7import Data.Either (isRight)

8

9-- | Returns the notifications which should be triggered based on the transition from the first 'DatabaseContext' to the second 'DatabaseContext'.

10−notificationChanges :: Notifications -> TransactionId -> TransactionGraph -> DatabaseContext -> DatabaseContext -> Notifications

10+notificationChanges :: Notifications -> TransactionGraph -> DatabaseContext -> DatabaseContext -> Notifications

11−notificationChanges nots tid graph context1 context2 = M.filter notificationFilter nots

11+notificationChanges nots graph context1 context2 = M.filter notificationFilter nots

12 where

13 notificationFilter (Notification chExpr _ _) = oldChangeEval /= newChangeEval && isRight oldChangeEval

14 where

15− oldChangeEval = evalChangeExpr chExpr (mkRelationalExprEnv context1 tid graph)

15+ oldChangeEval = evalChangeExpr chExpr (mkRelationalExprEnv context1 graph)

16− newChangeEval = evalChangeExpr chExpr (mkRelationalExprEnv context2 tid graph)

16+ newChangeEval = evalChangeExpr chExpr (mkRelationalExprEnv context2 graph)

17

18 evalChangeExpr :: RelationalExpr -> RelationalExprEnv -> Either RelationalError Relation

19 evalChangeExpr chExpr env =

src/lib/ProjectM36/Persist.hs+3−4

@@ -36,7 +36,6 @@ import Foreign.C

36#endif

37

38import System.IO (withFile, IOMode(WriteMode), Handle)

39−import qualified Data.ByteString.Lazy as BS

40import qualified Data.ByteString as BS'

39import qualified Data.ByteString as BS'

41import qualified Data.Text.Encoding as TE

40import qualified Data.Text.Encoding as TE

42

41

@@ -100,10 +99,10 @@ syncDirectory :: DiskSync -> FilePath -> IO ()

100syncDirectory FsyncDiskSync path = directoryFsync path

99syncDirectory FsyncDiskSync path = directoryFsync path

101syncDirectory NoDiskSync _ = pure ()

100syncDirectory NoDiskSync _ = pure ()

102

101

103−writeBSFileSync :: DiskSync -> FilePath -> BS.ByteString -> IO ()

102+writeBSFileSync :: DiskSync -> FilePath -> BS'.ByteString -> IO ()

104writeBSFileSync sync path bstring =

103writeBSFileSync sync path bstring =

105 withFile path WriteMode $ \handle -> do

104 withFile path WriteMode $ \handle -> do

106− BS.hPut handle bstring

105+ BS'.hPut handle bstring

107 syncHandle sync handle

106 syncHandle sync handle

108

107

109directoryFsync :: FilePath -> IO ()

108directoryFsync :: FilePath -> IO ()

@@ -131,4 +130,4 @@ fdCount = do

131 fds <- getDirectoryContents FDDIR

130 fds <- getDirectoryContents FDDIR

132 pure ((length fds) - 2)

131 pure ((length fds) - 2)

133--not supported on non-linux

132--not supported on non-linux

134−#endif

133+#endif

src/lib/ProjectM36/Relation.hs+17−22

@@ -9,7 +9,6 @@ import ProjectM36.Tuple

9import qualified ProjectM36.Attribute as A

10import ProjectM36.TupleSet

11import ProjectM36.Error

12−import ProjectM36.MiscUtils

13--import qualified Control.Parallel.Strategies as P

12--import qualified Control.Parallel.Strategies as P

14import qualified ProjectM36.TypeConstructorDef as TCD

13import qualified ProjectM36.TypeConstructorDef as TCD

15import qualified ProjectM36.DataConstructorDef as DCD

14import qualified ProjectM36.DataConstructorDef as DCD

@@ -17,7 +16,6 @@ import qualified Data.Text as T

17import Data.Either (isRight)

16import Data.Either (isRight)

18import System.Random.Shuffle

17import System.Random.Shuffle

19import Control.Monad.Random

18import Control.Monad.Random

20−import Data.List (sort)

21

19

22attributes :: Relation -> Attributes

20attributes :: Relation -> Attributes

23attributes (Relation attrs _ ) = attrs

21attributes (Relation attrs _ ) = attrs

@@ -35,7 +33,7 @@ atomTypeForName :: AttributeName -> Relation -> Either RelationalError AtomType

35atomTypeForName attrName (Relation attrs _) = A.atomTypeForAttributeName attrName attrs

33atomTypeForName attrName (Relation attrs _) = A.atomTypeForAttributeName attrName attrs

36

34

37mkRelationFromList :: Attributes -> [[Atom]] -> Either RelationalError Relation

35mkRelationFromList :: Attributes -> [[Atom]] -> Either RelationalError Relation

38−mkRelationFromList attrs atomMatrix =

36+mkRelationFromList attrs atomMatrix = do

39 Relation attrs <$> mkTupleSetFromList attrs atomMatrix

37 Relation attrs <$> mkTupleSetFromList attrs atomMatrix

40

38

41emptyRelationWithAttrs :: Attributes -> Relation

39emptyRelationWithAttrs :: Attributes -> Relation

@@ -43,11 +41,6 @@ emptyRelationWithAttrs attrs = Relation attrs emptyTupleSet

43

41

44mkRelation :: Attributes -> RelationTupleSet -> Either RelationalError Relation

42mkRelation :: Attributes -> RelationTupleSet -> Either RelationalError Relation

45mkRelation attrs tupleSet =

43mkRelation attrs tupleSet =

46− --check that all attributes are unique- this cannot be done when creating attributes because the check can become expensive

47− let duplicateAttrNames = dupes (sort (map A.attributeName (V.toList attrs))) in

48− if not (null duplicateAttrNames) then

49− Left (DuplicateAttributeNamesError (S.fromList duplicateAttrNames))

50− else

51 --check that all tuples have the same keys

44 --check that all tuples have the same keys

52 --check that all tuples have keys (1-N) where N is the attribute count

45 --check that all tuples have keys (1-N) where N is the attribute count

53 case verifyTupleSet attrs tupleSet of

46 case verifyTupleSet attrs tupleSet of

@@ -93,13 +86,12 @@ union (Relation attrs1 tupSet1) (Relation attrs2 tupSet2) =

93 else

86 else

94 Right $ Relation attrs1 newtuples

87 Right $ Relation attrs1 newtuples

95 where

88 where

96− newtuples = RelationTupleSet $ HS.toList . HS.fromList $ asList tupSet1 ++ map (reorderTuple attrs1) (asList tupSet2)

89+ newtuples = tupleSetUnion attrs1 tupSet1 tupSet2

97−

90+

98project :: S.Set AttributeName -> Relation -> Either RelationalError Relation

91project :: S.Set AttributeName -> Relation -> Either RelationalError Relation

99project attrNames rel@(Relation _ tupSet) = do

92project attrNames rel@(Relation _ tupSet) = do

100 newAttrs <- A.projectionAttributesForNames attrNames (attributes rel)

93 newAttrs <- A.projectionAttributesForNames attrNames (attributes rel)

101− let newAttrNameSet = A.attributeNameSet newAttrs

102− newTupleList = map (tupleProject newAttrNameSet) (asList tupSet)

94+ newTupleList <- mapM (tupleProject newAttrs) (asList tupSet)

103 pure (Relation newAttrs (RelationTupleSet (HS.toList (HS.fromList newTupleList))))

95 pure (Relation newAttrs (RelationTupleSet (HS.toList (HS.fromList newTupleList))))

104

96

105rename :: AttributeName -> AttributeName -> Relation -> Either RelationalError Relation

97rename :: AttributeName -> AttributeName -> Relation -> Either RelationalError Relation

@@ -154,7 +146,7 @@ group groupAttrNames newAttrName rel = do

154 groupProjectionAttributes <- A.projectionAttributesForNames groupAttrNames (attributes rel)

146 groupProjectionAttributes <- A.projectionAttributesForNames groupAttrNames (attributes rel)

155 let groupAttr = Attribute newAttrName (RelationAtomType groupProjectionAttributes)

147 let groupAttr = Attribute newAttrName (RelationAtomType groupProjectionAttributes)

156 matchingRelTuple tupIn = case imageRelationFor tupIn rel of

148 matchingRelTuple tupIn = case imageRelationFor tupIn rel of

157− Right rel2 -> RelationTuple (V.singleton groupAttr) (V.singleton (RelationAtom rel2))

149+ Right rel2 -> RelationTuple (A.singleton groupAttr) (V.singleton (RelationAtom rel2))

158 Left _ -> undefined

150 Left _ -> undefined

159 mogrifier tupIn = pure (tupleExtend tupIn (matchingRelTuple tupIn))

151 mogrifier tupIn = pure (tupleExtend tupIn (matchingRelTuple tupIn))

160 newAttrs = A.addAttribute groupAttr nonGroupProjectionAttributes

152 newAttrs = A.addAttribute groupAttr nonGroupProjectionAttributes

@@ -168,7 +160,8 @@ restrictEq :: RelationTuple -> Relation -> Either RelationalError Relation

168restrictEq tuple = restrict rfilter

160restrictEq tuple = restrict rfilter

169 where

161 where

170 rfilter :: RelationTuple -> Either RelationalError Bool

162 rfilter :: RelationTuple -> Either RelationalError Bool

163+ rfilter tupleIn = do

171− rfilter tupleIn = pure (tupleIntersection tuple tupleIn == tuple)

164+ pure (tupleIntersection tuple tupleIn == tuple)

172

165

173-- unwrap relation-valued attribute

166-- unwrap relation-valued attribute

174-- return error if relval attrs and nongroup attrs overlap

167-- return error if relval attrs and nongroup attrs overlap

@@ -190,13 +183,13 @@ ungroup relvalAttrName rel = case attributesForRelval relvalAttrName rel of

190tupleUngroup :: AttributeName -> Attributes -> RelationTuple -> Either RelationalError Relation

183tupleUngroup :: AttributeName -> Attributes -> RelationTuple -> Either RelationalError Relation

191tupleUngroup relvalAttrName newAttrs tuple = do

184tupleUngroup relvalAttrName newAttrs tuple = do

192 relvalRelation <- relationForAttributeName relvalAttrName tuple

185 relvalRelation <- relationForAttributeName relvalAttrName tuple

186+ let nonGroupAttrs = A.intersection newAttrs (tupleAttributes tuple)

187+ nonGroupTupleProjection <- tupleProject nonGroupAttrs tuple

188+ let folder tupleIn acc = case acc of

189+ Left err -> Left err

190+ Right accRel ->

191+ union accRel $ Relation newAttrs (RelationTupleSet [tupleExtend nonGroupTupleProjection tupleIn])

193 relFold folder (Right $ Relation newAttrs emptyTupleSet) relvalRelation

192 relFold folder (Right $ Relation newAttrs emptyTupleSet) relvalRelation

194− where

195− nonGroupTupleProjection = tupleProject nonGroupAttrNames tuple

196− nonGroupAttrNames = A.attributeNameSet newAttrs

197− folder tupleIn acc = case acc of

198− Left err -> Left err

199− Right accRel -> union accRel $ Relation newAttrs (RelationTupleSet [tupleExtend nonGroupTupleProjection tupleIn])

200

193

201attributesForRelval :: AttributeName -> Relation -> Either RelationalError Attributes

194attributesForRelval :: AttributeName -> Relation -> Either RelationalError Attributes

202attributesForRelval relvalAttrName (Relation attrs _) = do

195attributesForRelval relvalAttrName (Relation attrs _) = do

@@ -251,7 +244,8 @@ relMap mapper (Relation attrs tupleSet) =

251

244

252relMogrify :: (RelationTuple -> Either RelationalError RelationTuple) -> Attributes -> Relation -> Either RelationalError Relation

245relMogrify :: (RelationTuple -> Either RelationalError RelationTuple) -> Attributes -> Relation -> Either RelationalError Relation

253relMogrify mapper newAttributes (Relation _ tupSet) = do

246relMogrify mapper newAttributes (Relation _ tupSet) = do

254− newTuples <- mapM mapper (asList tupSet)

247+ newTuples <- mapM (fmap (reorderTuple newAttributes) . mapper) (asList tupSet)

248+

255 mkRelationFromTuples newAttributes newTuples

249 mkRelationFromTuples newAttributes newTuples

256

250

257relFold :: (RelationTuple -> a -> a) -> a -> Relation -> a

251relFold :: (RelationTuple -> a -> a) -> a -> Relation -> a

@@ -297,7 +291,8 @@ typesAsRelation types = mkRelationFromTuples attrs tuples

297 dConsType = RelationAtomType subAttrs

291 dConsType = RelationAtomType subAttrs

298 tuples = map mkTypeConsDescription types

292 tuples = map mkTypeConsDescription types

299

293

294+ mkTypeConsDescription (tCons, dConsList) =

300− mkTypeConsDescription (tCons, dConsList) = RelationTuple attrs (V.fromList [TextAtom (TCD.name tCons), mkDataConsRelation dConsList])

295+ RelationTuple attrs (V.fromList [TextAtom (TCD.name tCons), mkDataConsRelation dConsList])

301

296

302 mkDataConsRelation dConsList = case mkRelationFromTuples subAttrs $ map (\dCons -> RelationTuple subAttrs (V.singleton $ TextAtom $ T.intercalate " " (DCD.name dCons:map (T.pack . show) (DCD.fields dCons)))) dConsList of

297 mkDataConsRelation dConsList = case mkRelationFromTuples subAttrs $ map (\dCons -> RelationTuple subAttrs (V.singleton $ TextAtom $ T.intercalate " " (DCD.name dCons:map (T.pack . show) (DCD.fields dCons)))) dConsList of

303 Left err -> error ("mkRelationFromTuples pooped " ++ show err)

298 Left err -> error ("mkRelationFromTuples pooped " ++ show err)

src/lib/ProjectM36/Relation/Parse/CSV.hs+7−3

@@ -38,8 +38,7 @@ csvAsRelation attrs tConsMap inString = case APBL.parse (csvWithHeader csvDecode

38 let strHeader = V.map decodeUtf8 headerRaw

39 strMapRecords = V.map convertMap vecMapsRaw

40 convertMap hmap = HM.fromList $ L.map (decodeUtf8 *** (T.unpack . decodeUtf8)) (HM.toList hmap)

41− attrNames = V.map A.attributeName attrs

41+ attrNameSet = A.attributeNameSet attrs

42− attrNameSet = S.fromList (V.toList attrNames)

43 headerSet = S.fromList (V.toList strHeader)

42 headerSet = S.fromList (V.toList strHeader)

44 parseAtom attrName aType textIn = case APT.parseOnly (parseCSVAtomP attrName tConsMap aType <* APT.endOfInput) textIn of

43 parseAtom attrName aType textIn = case APT.parseOnly (parseCSVAtomP attrName tConsMap aType <* APT.endOfInput) textIn of

45 Left err -> Left (ParseError (T.pack err))

44 Left err -> Left (ParseError (T.pack err))

@@ -47,7 +46,7 @@ csvAsRelation attrs tConsMap inString = case APBL.parse (csvWithHeader csvDecode

47 makeTupleList :: HM.HashMap AttributeName String -> [Either CsvImportError Atom]

46 makeTupleList :: HM.HashMap AttributeName String -> [Either CsvImportError Atom]

48 makeTupleList tupMap = V.toList $ V.map (\attr ->

47 makeTupleList tupMap = V.toList $ V.map (\attr ->

49 either (Left . AttributeMappingError) Right $

48 either (Left . AttributeMappingError) Right $

50− parseAtom (A.attributeName attr) (A.atomType attr) (T.pack $ tupMap HM.! A.attributeName attr)) attrs

49+ parseAtom (A.attributeName attr) (A.atomType attr) (T.pack $ tupMap HM.! A.attributeName attr)) (attributesVec attrs)

51 if attrNameSet == headerSet then do

50 if attrNameSet == headerSet then do

52 tupleList <- mapM sequence $ V.toList (V.map makeTupleList strMapRecords)

51 tupleList <- mapM sequence $ V.toList (V.map makeTupleList strMapRecords)

53 case mkRelationFromList attrs tupleList of

52 case mkRelationFromList attrs tupleList of

@@ -83,6 +82,11 @@ parseCSVAtomP _ _ BoolAtomType = do

83 case readMaybe bString of

82 case readMaybe bString of

84 Nothing -> fail ("invalid BoolAtom string: " ++ bString)

83 Nothing -> fail ("invalid BoolAtom string: " ++ bString)

85 Just b -> pure (Right (BoolAtom b))

84 Just b -> pure (Right (BoolAtom b))

85+parseCSVAtomP _ _ RelationalExprAtomType = do

86+ reString <- T.unpack <$> takeToEndOfData

87+ case readMaybe reString of

88+ Nothing -> fail ("invalid RelationalExprAtom string: " ++ reString)

89+ Just b -> pure (Right (RelationalExprAtom b))

86parseCSVAtomP attrName tConsMap typ@(ConstructedAtomType _ tvmap)

90parseCSVAtomP attrName tConsMap typ@(ConstructedAtomType _ tvmap)

87 | isIntervalAtomType typ = do

91 | isIntervalAtomType typ = do

88 begin <- (APT.char '[' >> pure False) <|> (APT.char '(' >> pure True)

92 begin <- (APT.char '[' >> pure False) <|> (APT.char '(' >> pure True)

src/lib/ProjectM36/Relation/Show/CSV.hs+5−5

@@ -1,7 +1,7 @@

1{-# OPTIONS_GHC -fno-warn-orphans #-}

2module ProjectM36.Relation.Show.CSV where

3import ProjectM36.Base

4−import ProjectM36.Attribute

4+import ProjectM36.Attribute as A

5import Data.Csv

6import ProjectM36.Tuple

7import qualified Data.ByteString.Lazy as BS

@@ -17,13 +17,13 @@ relationAsCSV (Relation attrs tupleSet)

17 | relValAttrs /= [] =

18 Left $ RelationValuedAttributesNotSupportedError (map attributeName relValAttrs)

19 --check that there is at least one attribute

20− | V.null attrs =

20+ | A.null attrs =

21 Left $ TupleAttributeCountMismatchError 0

22 | otherwise =

23 Right $ encodeByName bsAttrNames $ map RecordRelationTuple (asList tupleSet)

24 where

25− relValAttrs = V.toList $ V.filter (isRelationAtomType . atomType) attrs

25+ relValAttrs = V.toList $ V.filter (isRelationAtomType . atomType) (attributesVec attrs)

26− bsAttrNames = V.map (TE.encodeUtf8 . attributeName) attrs

26+ bsAttrNames = V.map (TE.encodeUtf8 . attributeName) (attributesVec attrs)

27

28{-

29instance ToRecord RelationTuple where

@@ -36,7 +36,7 @@ instance ToNamedRecord RecordRelationTuple where

36 toNamedRecord rTuple = namedRecord $ map (\(k,v) -> TE.encodeUtf8 k .= RecordAtom v) (tupleAssocs $ unTuple rTuple)

37

38instance DefaultOrdered RecordRelationTuple where

39− headerOrder (RecordRelationTuple tuple) = V.map (TE.encodeUtf8 . attributeName) (tupleAttributes tuple)

39+ headerOrder (RecordRelationTuple tuple) = V.map (TE.encodeUtf8 . attributeName) (attributesVec (tupleAttributes tuple))

40

41newtype RecordAtom = RecordAtom {unAtom :: Atom}

42

src/lib/ProjectM36/Relation/Show/HTML.hs+4−3

@@ -3,18 +3,18 @@ import ProjectM36.Base

3import ProjectM36.Relation

4import ProjectM36.Tuple

5import ProjectM36.Atom

6+import ProjectM36.Attribute as A

6import ProjectM36.AtomType

7import ProjectM36.AtomType

7import qualified Data.List as L

8import qualified Data.List as L

8import Data.Text (Text, pack)

9import Data.Text (Text, pack)

9import qualified Data.Text as T

10import qualified Data.Text as T

10import qualified Data.Text.IO as TIO

11import qualified Data.Text.IO as TIO

11−import qualified Data.Vector as V

12−#if __GLASGOW_HASKELL__ <= 802

12+#if __GLASGOW_HASKELL__ < 804

13import Data.Monoid

14#endif

15

16attributesAsHTML :: Attributes -> Text

17−attributesAsHTML attrs = "<tr>" <> T.concat (map oneAttrHTML (V.toList attrs)) <> "</tr>"

17+attributesAsHTML attrs = "<tr>" <> T.concat (map oneAttrHTML (A.toList attrs)) <> "</tr>"

18 where

19 oneAttrHTML attr = "<th>" <> prettyAttribute attr <> "</th>"

20

@@ -53,6 +53,7 @@ tupleAsHTML tuple = "<tr>" <> T.concat (L.map tupleFrag (tupleAssocs tuple)) <>

53 where

54 tupleFrag tup = "<td>" <> atomAsHTML (snd tup) <> "</td>"

55 atomAsHTML (RelationAtom rel) = relationAsHTML rel

56+ atomAsHTML (TextAtom t) = """ <> t <> """

56 atomAsHTML atom = atomToText atom

57 atomAsHTML atom = atomToText atom

57

58

58tupleSetAsHTML :: RelationTupleSet -> Text

59tupleSetAsHTML :: RelationTupleSet -> Text

src/lib/ProjectM36/Relation/Show/Term.hs+4−1

@@ -9,7 +9,9 @@ import ProjectM36.Attribute hiding (null)

9import qualified Data.List as L

10import qualified Data.Text as T

11import Control.Arrow hiding (left)

12+import Data.ByteString.Base64 as B64

13+import qualified Data.Text.Encoding as TE

12−#if __GLASGOW_HASKELL__ <= 802

14+#if __GLASGOW_HASKELL__ < 804

13import Data.Monoid

15import Data.Monoid

14#endif

16#endif

15import ProjectM36.WCWidth --guess the width that the character will appear as in the terminal

17import ProjectM36.WCWidth --guess the width that the character will appear as in the terminal

@@ -97,6 +99,7 @@ showAtom :: Int -> Atom -> StringType

97showAtom _ (RelationAtom rel) = renderTable $ relationAsTable rel

99showAtom _ (RelationAtom rel) = renderTable $ relationAsTable rel

98showAtom level (ConstructedAtom dConsName _ atoms) = showParens (level >= 1 && not (null atoms)) $ T.concat (L.intersperse " " (dConsName : map (showAtom 1) atoms))

100showAtom level (ConstructedAtom dConsName _ atoms) = showParens (level >= 1 && not (null atoms)) $ T.concat (L.intersperse " " (dConsName : map (showAtom 1) atoms))

99showAtom _ (TextAtom t) = "\"" <> t <> "\""

101showAtom _ (TextAtom t) = "\"" <> t <> "\""

102+showAtom _ (ByteStringAtom bs) = TE.decodeUtf8 (B64.encode bs)

100showAtom _ atom = atomToText atom

103showAtom _ atom = atomToText atom

101

104

102renderTable :: Table -> StringType

105renderTable :: Table -> StringType

src/lib/ProjectM36/RelationalExpression.hs+413−416

@@ -1,4 +1,7 @@

1{-# LANGUAGE ScopedTypeVariables #-}

2+{-# LANGUAGE FlexibleInstances #-}

3+{-# LANGUAGE FlexibleContexts #-}

4+{-# LANGUAGE OverloadedStrings #-}

2module ProjectM36.RelationalExpression where

5module ProjectM36.RelationalExpression where

3import ProjectM36.Relation

6import ProjectM36.Relation

4import ProjectM36.Tuple

7import ProjectM36.Tuple

@@ -13,32 +16,38 @@ import ProjectM36.DataTypes.Primitive

13import ProjectM36.AtomFunction

16import ProjectM36.AtomFunction

14import ProjectM36.DatabaseContextFunction

17import ProjectM36.DatabaseContextFunction

15import ProjectM36.Arbitrary

18import ProjectM36.Arbitrary

19+import ProjectM36.GraphRefRelationalExpr

16import ProjectM36.Transaction

20import ProjectM36.Transaction

17import qualified ProjectM36.Attribute as A

21import qualified ProjectM36.Attribute as A

18import qualified Data.Map as M

22import qualified Data.Map as M

19import qualified Data.HashSet as HS

23import qualified Data.HashSet as HS

20import qualified Data.Set as S

24import qualified Data.Set as S

21−import Control.Monad.RWS.Strict as RWS hiding (join)

25+import Control.Monad.State hiding (join)

22−import Control.Monad.Trans.Class (lift)

26+import Data.Bifunctor (second)

23−import Control.Exception

24import Data.Maybe

27import Data.Maybe

25import Data.Either

28import Data.Either

26import Data.Char (isUpper)

29import Data.Char (isUpper)

30+import Data.Time

31+import qualified Data.List.NonEmpty as NE

32+import Data.Functor.Identity

27import qualified Data.Text as T

33import qualified Data.Text as T

28import qualified Data.Vector as V

34import qualified Data.Vector as V

29import qualified ProjectM36.TypeConstructorDef as TCD

35import qualified ProjectM36.TypeConstructorDef as TCD

36+import qualified Control.Monad.RWS.Strict as RWS

37+import Control.Monad.RWS.Strict (RWST, execRWST, runRWST)

30import Control.Monad.Except hiding (join)

38import Control.Monad.Except hiding (join)

31import Control.Monad.Trans.Except (except)

39import Control.Monad.Trans.Except (except)

32import Control.Monad.Reader as R hiding (join)

40import Control.Monad.Reader as R hiding (join)

33import ProjectM36.NormalizeExpr

41import ProjectM36.NormalizeExpr

34import ProjectM36.WithNameExpr

42import ProjectM36.WithNameExpr

35import Test.QuickCheck

43import Test.QuickCheck

36−import GHC

44+import qualified Data.Functor.Foldable as Fold

45+import Control.Applicative

46+#ifdef PM36_HASKELL_SCRIPTING

47+import GHC hiding (getContext)

48+import Control.Exception

37import GHC.Paths

49import GHC.Paths

38−import Data.Time.Clock

50+#endif

39−import Data.Time.Calendar

40−import qualified Data.List.NonEmpty as NE

41−import Data.Functor.Identity

42

51

43data DatabaseContextExprDetails = CountUpdatedTuples

52data DatabaseContextExprDetails = CountUpdatedTuples

44

53

@@ -66,7 +75,6 @@ mkDatabaseContextEvalState context = DatabaseContextEvalState {

66data RelationalExprEnv = RelationalExprEnv {

75data RelationalExprEnv = RelationalExprEnv {

67 re_context :: DatabaseContext,

76 re_context :: DatabaseContext,

68 re_graph :: TransactionGraph,

77 re_graph :: TransactionGraph,

69− re_currentTransId :: TransactionId,

70 re_extra :: Maybe (Either RelationTuple Attributes)

78 re_extra :: Maybe (Either RelationTuple Attributes)

71 }

79 }

72

80

@@ -86,36 +94,29 @@ runRelationalExprM :: RelationalExprEnv -> RelationalExprM a -> Either Relationa

86runRelationalExprM env m = runIdentity (runExceptT (runReaderT m env))

94runRelationalExprM env m = runIdentity (runExceptT (runReaderT m env))

87

95

88reGraph :: RelationalExprM TransactionGraph

96reGraph :: RelationalExprM TransactionGraph

89−reGraph = re_graph <$> R.ask

90−

91−currentTrans :: RelationalExprM Transaction

92−currentTrans = do

93− tid <- re_currentTransId <$> R.ask

94− graph <- re_graph <$> R.ask

97+reGraph = asks re_graph

95− lift $ except $ transactionForId tid graph

96

98

97−reTransId :: RelationalExprM TransactionId

99+reContext :: RelationalExprM DatabaseContext

98−reTransId = re_currentTransId <$> R.ask

100+reContext = asks re_context

99

101

100−mkRelationalExprEnv :: DatabaseContext -> TransactionId -> TransactionGraph -> RelationalExprEnv

102+mkRelationalExprEnv :: DatabaseContext -> TransactionGraph -> RelationalExprEnv

101−mkRelationalExprEnv ctx currentTransId graph =

103+mkRelationalExprEnv ctx graph =

102 RelationalExprEnv

104 RelationalExprEnv

103 { re_context = ctx,

105 { re_context = ctx,

104 re_graph = graph,

106 re_graph = graph,

105− re_currentTransId = currentTransId,

106 re_extra = Nothing }

107 re_extra = Nothing }

107

108

108askEnv :: GraphRefRelationalExprM GraphRefRelationalExprEnv

109askEnv :: GraphRefRelationalExprM GraphRefRelationalExprEnv

109askEnv = R.ask

110askEnv = R.ask

110

111

111mergeTuplesIntoGraphRefRelationalExprEnv :: RelationTuple -> GraphRefRelationalExprEnv -> GraphRefRelationalExprEnv

112mergeTuplesIntoGraphRefRelationalExprEnv :: RelationTuple -> GraphRefRelationalExprEnv -> GraphRefRelationalExprEnv

112−mergeTuplesIntoGraphRefRelationalExprEnv tupIn e =

113+mergeTuplesIntoGraphRefRelationalExprEnv tupIn env =

113− e{ gre_extra = new_elems }

114+ env { gre_extra = new_elems }

114 where

115 where

115 new_elems = Just (Left newTuple)

116 new_elems = Just (Left newTuple)

116− mergedTupMap = M.union (tupleToMap tupIn) (tupleToMap (envTuple e))

117+ mergedTupMap = M.union (tupleToMap tupIn) (tupleToMap (envTuple env))

117 newTuple = mkRelationTupleFromMap mergedTupMap

118 newTuple = mkRelationTupleFromMap mergedTupMap

118−

119+

119mergeAttributesIntoGraphRefRelationalExprEnv :: Attributes -> GraphRefRelationalExprEnv -> GraphRefRelationalExprEnv

120mergeAttributesIntoGraphRefRelationalExprEnv :: Attributes -> GraphRefRelationalExprEnv -> GraphRefRelationalExprEnv

120mergeAttributesIntoGraphRefRelationalExprEnv attrsIn e = e { gre_extra = newattrs }

121mergeAttributesIntoGraphRefRelationalExprEnv attrsIn e = e { gre_extra = newattrs }

121 where

122 where

@@ -141,12 +142,12 @@ data DatabaseContextEvalEnv = DatabaseContextEvalEnv

141 }

142 }

142

143

143mkDatabaseContextEvalEnv :: TransactionId -> TransactionGraph -> DatabaseContextEvalEnv

144mkDatabaseContextEvalEnv :: TransactionId -> TransactionGraph -> DatabaseContextEvalEnv

144−mkDatabaseContextEvalEnv tid graph = DatabaseContextEvalEnv tid graph

145+mkDatabaseContextEvalEnv = DatabaseContextEvalEnv

145

146

146type DatabaseContextEvalMonad a = RWST DatabaseContextEvalEnv () DatabaseContextEvalState (ExceptT RelationalError Identity) a

147type DatabaseContextEvalMonad a = RWST DatabaseContextEvalEnv () DatabaseContextEvalState (ExceptT RelationalError Identity) a

147

148

148runDatabaseContextEvalMonad :: DatabaseContext -> DatabaseContextEvalEnv -> DatabaseContextEvalMonad () -> Either RelationalError DatabaseContextEvalState

149runDatabaseContextEvalMonad :: DatabaseContext -> DatabaseContextEvalEnv -> DatabaseContextEvalMonad () -> Either RelationalError DatabaseContextEvalState

149−runDatabaseContextEvalMonad ctx env m = runIdentity (runExceptT (fst <$> (execRWST m env freshEnv)))

150+runDatabaseContextEvalMonad ctx env m = runIdentity (runExceptT (fst <$> execRWST m env freshEnv))

150 where

151 where

151 freshEnv = mkDatabaseContextEvalState ctx

152 freshEnv = mkDatabaseContextEvalState ctx

152

153

@@ -159,18 +160,20 @@ dbcGraph = dce_graph <$> RWS.ask

159

160

160dbcRelationalExprEnv :: DatabaseContextEvalMonad RelationalExprEnv

161dbcRelationalExprEnv :: DatabaseContextEvalMonad RelationalExprEnv

161dbcRelationalExprEnv =

162dbcRelationalExprEnv =

162− mkRelationalExprEnv <$> getStateContext <*> dbcTransId <*> dbcGraph

163+ mkRelationalExprEnv <$> getStateContext <*> dbcGraph

163

164

164getStateContext :: DatabaseContextEvalMonad DatabaseContext

165getStateContext :: DatabaseContextEvalMonad DatabaseContext

165−getStateContext = dbc_context <$> get

166+getStateContext = gets dbc_context

166

167

167putStateContext :: DatabaseContext -> DatabaseContextEvalMonad ()

168putStateContext :: DatabaseContext -> DatabaseContextEvalMonad ()

168putStateContext ctx' = do

169putStateContext ctx' = do

169 s <- get

170 s <- get

170− put (s {dbc_context = ctx'})

171+ put (s {dbc_context = ctx', dbc_dirty = True})

171−

172+

173+-- | The context is optionally passed down along in cases where the current context is uncommitted.

172data GraphRefRelationalExprEnv =

174data GraphRefRelationalExprEnv =

173 GraphRefRelationalExprEnv {

175 GraphRefRelationalExprEnv {

176+ gre_context :: Maybe DatabaseContext,

174 gre_graph :: TransactionGraph,

177 gre_graph :: TransactionGraph,

175 gre_extra :: Maybe (Either RelationTuple Attributes)

178 gre_extra :: Maybe (Either RelationTuple Attributes)

176 }

179 }

@@ -182,17 +185,26 @@ gfTransForId tid = do

182 graph <- gfGraph

185 graph <- gfGraph

183 lift $ except $ transactionForId tid graph

186 lift $ except $ transactionForId tid graph

184

187

188+gfDatabaseContextForMarker :: GraphRefTransactionMarker -> GraphRefRelationalExprM DatabaseContext

189+gfDatabaseContextForMarker (TransactionMarker transId) = concreteDatabaseContext <$> gfTransForId transId

190+gfDatabaseContextForMarker UncommittedContextMarker = do

191+ mctx <- gre_context <$> askEnv

192+ case mctx of

193+ Nothing -> throwError NoUncommittedContextInEvalError

194+ Just ctx -> pure ctx

195+

185runGraphRefRelationalExprM :: GraphRefRelationalExprEnv -> GraphRefRelationalExprM a -> Either RelationalError a

196runGraphRefRelationalExprM :: GraphRefRelationalExprEnv -> GraphRefRelationalExprM a -> Either RelationalError a

186runGraphRefRelationalExprM env m = runIdentity (runExceptT (runReaderT m env))

197runGraphRefRelationalExprM env m = runIdentity (runExceptT (runReaderT m env))

187

198

188−freshGraphRefRelationalExprEnv :: TransactionGraph -> GraphRefRelationalExprEnv

199+freshGraphRefRelationalExprEnv :: Maybe DatabaseContext -> TransactionGraph -> GraphRefRelationalExprEnv

189−freshGraphRefRelationalExprEnv graph = GraphRefRelationalExprEnv {

200+freshGraphRefRelationalExprEnv mctx graph = GraphRefRelationalExprEnv {

201+ gre_context = mctx,

190 gre_graph = graph,

202 gre_graph = graph,

191 gre_extra = Nothing

203 gre_extra = Nothing

192 }

204 }

193

205

194gfGraph :: GraphRefRelationalExprM TransactionGraph

206gfGraph :: GraphRefRelationalExprM TransactionGraph

195−gfGraph = gre_graph <$> R.ask

207+gfGraph = asks gre_graph

196

208

197envContext :: RelationalExprEnv -> DatabaseContext

209envContext :: RelationalExprEnv -> DatabaseContext

198envContext = re_context

210envContext = re_context

@@ -200,173 +212,27 @@ envContext = re_context

200setEnvContext :: RelationalExprEnv -> DatabaseContext -> RelationalExprEnv

212setEnvContext :: RelationalExprEnv -> DatabaseContext -> RelationalExprEnv

201setEnvContext e ctx = e { re_context = ctx }

213setEnvContext e ctx = e { re_context = ctx }

202

214

203−{-

204−--full evaluation down the graph

205−eval :: RelationalExpr -> RelationalExprState (Either RelationalError Relation)

206−eval expr = do

207− env <- askEnv

208− eGfExpr <- processRelationalExpr expr

209− case eGfExpr of

210− Left err -> pure (Left err)

211− Right gfExpr -> pure $ evalGraphRefRelationalExpr gfExpr (re_graph env)

212−-}

213−{-

214−--relvar state is needed in evaluation of relational expression but only as read-only in order to extract current relvar values

215−evalRelationalExpr :: RelationalExpr -> RelationalExprState (Either RelationalError GraphRefRelationalExpr)

216−evalRelationalExpr (RelationVariable name _) = do

217− relvarTable <- fmap (relationVariables . envContext) askEnv

218− return $ case M.lookup name relvarTable of

219− Just res -> Right res

220− Nothing -> Left $ RelVarNotDefinedError name

221−

222−evalRelationalExpr (Project attrNames expr) = do

223− eAttrNameSet <- evalAttributeNames attrNames expr

224− case eAttrNameSet of

225− Left err -> pure (Left err)

226− Right attrNameSet -> do

227− rel <- evalRelationalExpr expr

228− case rel of

229− Right rel2 -> pure $ Right (Project (AttributeNames attrNameSet) rel2)

230− Left err -> pure $ Left err

231−

232−evalRelationalExpr (Union exprA exprB) = do

233− relA <- evalRelationalExpr exprA

234− relB <- evalRelationalExpr exprB

235− case relA of

236− Left err -> return $ Left err

237− Right relA2 -> case relB of

238− Left err -> return $ Left err

239− Right relB2 -> return $ Right (Union relA2 relB2)

240−

241−evalRelationalExpr (Join exprA exprB) = do

242− relA <- evalRelationalExpr exprA

243− relB <- evalRelationalExpr exprB

244− case relA of

245− Left err -> return $ Left err

246− Right relA2 -> case relB of

247− Left err -> return $ Left err

248− Right relB2 -> return $ Right (Join relA2 relB2)

249−

250−evalRelationalExpr (Difference exprA exprB) = do

251− relA <- evalRelationalExpr exprA

252− relB <- evalRelationalExpr exprB

253− case relA of

254− Left err -> return $ Left err

255− Right relA2 -> case relB of

256− Left err -> return $ Left err

257− Right relB2 -> return $ Right (Difference relA2 relB2)

258−

259−evalRelationalExpr (MakeStaticRelation attributeSet tupleSet) =

260− case mkRelation attributeSet tupleSet of

261− Right rel -> return $ Right (ExistingRelation rel)

262− Left err -> return $ Left err

263−

264−evalRelationalExpr (MakeRelationFromExprs mAttrExprs tupleExprs) = do

265− currentContext <- fmap envContext askEnv

266− let tConss = typeConstructorMapping currentContext

267− -- if the mAttrExprs is Nothing, then we should attempt to infer the tuple attributes from the first tuple itself- note that this is not always possible

268− runExceptT $ do

269− mAttrs <- case mAttrExprs of

270− Just _ ->

271− Just . A.attributesFromList <$> mapM evalGraphRefAttrExpr (fromMaybe [] mAttrExprs)

272− Nothing -> pure Nothing

273− tuples <- mapM (liftE . evalTupleExpr mAttrs) tupleExprs

274− let attrs = fromMaybe firstTupleAttrs mAttrs

275− firstTupleAttrs = if null tuples then A.emptyAttributes else tupleAttributes (head tuples)

276− expr <- either throwE pure (mkRelation attrs (RelationTupleSet tuples))

277− pure (ExistingRelation expr)

278−

279−evalRelationalExpr (ExistingRelation rel) = pure (Right (ExistingRelation rel))

280−

281−evalRelationalExpr (Rename oldAttrName newAttrName relExpr) = do

282− evald <- evalRelationalExpr relExpr

283− case evald of

284− Right expr -> return $ Right (Rename oldAttrName newAttrName expr)

285− Left err -> return $ Left err

286−

287−evalRelationalExpr (Group oldAttrNames newAttrName relExpr) = do

288− eOldAttrNameSet <- evalAttributeNames oldAttrNames relExpr

289− case eOldAttrNameSet of

290− Left err -> pure (Left err)

291− Right oldAttrNameSet -> do

292− evald <- evalRelationalExpr relExpr

293− case evald of

294− Right expr -> return $ Right (Group (AttributeNames oldAttrNameSet) newAttrName expr)

295− Left err -> return $ Left err

296−

297−evalRelationalExpr (Ungroup attrName relExpr) = do

298− evald <- evalRelationalExpr relExpr

299− case evald of

300− Right expr -> return $ Right (Ungroup attrName expr)

301− Left err -> return $ Left err

302−

303−evalRelationalExpr (Restrict predicateExpr relExpr) = do

304− evald <- evalRelationalExpr relExpr

305− pred <- processRestrictionPredicateExpr predicateExpr

306− case evald of

307− Left err -> return $ Left err

308− Right expr ->

309− pure $ Right (Restrict pred expr)

310−

311−evalRelationalExpr (Equals relExprA relExprB) = do

312− evaldA <- evalRelationalExpr relExprA

313− evaldB <- evalRelationalExpr relExprB

314− case evaldA of

315− Left err -> return $ Left err

316− Right exprA -> case evaldB of

317− Left err -> return $ Left err

318− Right exprB -> return $ Right (Equals exprA exprB)

319−{-

320−evalRelationalExpr (With views mainExpr) = do

321− rstate <- ask

322−

323− let addScopedView ctx (vname,vexpr) = if vname `M.member` relationVariables ctx then

324− Left (RelVarAlreadyDefinedError vname)

325− else

326− case runState (evalDatabaseContextExpr (Assign vname vexpr)) (freshDatabaseState ctx) of

327− (Left err,_) -> Left err

328− (Right (), (ctx',_,_)) -> Right ctx'

329−

330− case foldM addScopedView (stateElemsContext rstate) views of

331− Left err -> return $ Left err

332− Right ctx'' -> do

333− let evalMainExpr expr = runReader (evalRelationalExpr expr) (RelationalExprEnv ctx'')

334− case evalMainExpr mainExpr of

335− Left err -> return $ Left err

336− Right rel -> return $ Right rel

337−-}

338−--warning: copy-pasta from above- refactor

339−evalRelationalExpr (NotEquals relExprA relExprB) = do

340− evaldA <- evalRelationalExpr relExprA

341− evaldB <- evalRelationalExpr relExprB

342− case evaldA of

343− Left err -> return $ Left err

344− Right exprA -> case evaldB of

345− Left err -> return $ Left err

346− Right exprB -> return $ Right (NotEquals exprA exprB)

347−

348−-- extending a relation adds a single attribute with the results of the per-tuple expression evaluated

349−evalRelationalExpr (Extend tupleExpression relExpr) = do

350− eExpr <- evalRelationalExpr relExpr

351− case eExpr of

352− Left err -> pure (Left err)

353− Right expr -> do

354− tupProc <- processExtendTupleExpr tupleExpression

355− pure (Right (Extend tupProc expr))

356−-}

357--helper function to process relation variable creation/assignment

215--helper function to process relation variable creation/assignment

358setRelVar :: RelVarName -> GraphRefRelationalExpr -> DatabaseContextEvalMonad ()

216setRelVar :: RelVarName -> GraphRefRelationalExpr -> DatabaseContextEvalMonad ()

359setRelVar relVarName relExpr = do

217setRelVar relVarName relExpr = do

360−

361 currentContext <- getStateContext

218 currentContext <- getStateContext

219+ --prevent recursive relvar definition by resolving references to relvars in previous states

220+ relExpr' <- resolve relExpr

362− let newRelVars = M.insert relVarName relExpr $ relationVariables currentContext

221+ let newRelVars = M.insert relVarName relExpr' $ relationVariables currentContext

363 potentialContext = currentContext { relationVariables = newRelVars }

222 potentialContext = currentContext { relationVariables = newRelVars }

223+ --optimization: if the relexpr is unchanged, skip the update

224+ if M.lookup relVarName (relationVariables currentContext) == Just relExpr then

225+ pure ()

226+ else do

364− --determine when to check constraints

227+ --determine when to check constraints

365− graph <- dbcGraph

228+ graph <- dbcGraph

366− tid <- dbcTransId

229+ tid <- dbcTransId

367− case checkConstraints potentialContext tid graph of

230+ case checkConstraints potentialContext tid graph of

368− Left err -> dbErr err

231+ Left err -> dbErr err

369− Right _ -> putStateContext potentialContext

232+ Right _ -> putStateContext potentialContext

233+

234+--fast-path insertion- we already know that the previous relvar validated correctly, so we can validate just the relation that is being inserted for attribute matches- without this, even a single tuple relation inserted causes the entire relation to be re-validated unnecessarily

235+--insertIntoRelVar :: RelVarName -> GraphRefRelationalExpr -> DatabaseContextEvalMonad ()

370

236

371-- it is not an error to delete a relvar which does not exist, just like it is not an error to insert a pre-existing tuple into a relation

237-- it is not an error to delete a relvar which does not exist, just like it is not an error to insert a pre-existing tuple into a relation

372deleteRelVar :: RelVarName -> DatabaseContextEvalMonad ()

238deleteRelVar :: RelVarName -> DatabaseContextEvalMonad ()

@@ -385,19 +251,17 @@ evalGraphRefDatabaseContextExpr :: GraphRefDatabaseContextExpr -> DatabaseContex

385evalGraphRefDatabaseContextExpr NoOperation = pure ()

251evalGraphRefDatabaseContextExpr NoOperation = pure ()

386

252

387evalGraphRefDatabaseContextExpr (Define relVarName attrExprs) = do

253evalGraphRefDatabaseContextExpr (Define relVarName attrExprs) = do

254+ context <- getStateContext

388 relvars <- fmap relationVariables getStateContext

255 relvars <- fmap relationVariables getStateContext

389 tConss <- fmap typeConstructorMapping getStateContext

256 tConss <- fmap typeConstructorMapping getStateContext

390 graph <- dbcGraph

257 graph <- dbcGraph

391 let eAttrs = runGraphRefRelationalExprM gfEnv (mapM evalGraphRefAttrExpr attrExprs)

258 let eAttrs = runGraphRefRelationalExprM gfEnv (mapM evalGraphRefAttrExpr attrExprs)

392− gfEnv = freshGraphRefRelationalExprEnv graph

259+ gfEnv = freshGraphRefRelationalExprEnv (Just context) graph

393 case eAttrs of

260 case eAttrs of

394− Left err -> dbErr err

261+ Left err -> dbErr err

395 Right attrsList -> do

262 Right attrsList -> do

396− let atomTypeErrs = lefts $ map ((`validateAtomType` tConss) . A.atomType) attrsList

263+ lift $ except $ validateAttributes tConss (A.attributesFromList attrsList)

397− if not (null atomTypeErrs) then

398− dbErr (someErrors atomTypeErrs)

399− else

400− case M.member relVarName relvars of

264+ case M.member relVarName relvars of

401 True -> dbErr (RelVarAlreadyDefinedError relVarName)

265 True -> dbErr (RelVarAlreadyDefinedError relVarName)

402 False -> setRelVar relVarName (ExistingRelation emptyRelation)

266 False -> setRelVar relVarName (ExistingRelation emptyRelation)

403 where

267 where

@@ -410,13 +274,17 @@ evalGraphRefDatabaseContextExpr (Assign relVarName expr) = do

410 graph <- re_graph <$> dbcRelationalExprEnv

274 graph <- re_graph <$> dbcRelationalExprEnv

411 context <- getStateContext

275 context <- getStateContext

412 let existingRelVar = M.lookup relVarName (relationVariables context)

276 let existingRelVar = M.lookup relVarName (relationVariables context)

277+ reEnv = freshGraphRefRelationalExprEnv (Just context) graph

278+ eNewExprType = runGraphRefRelationalExprM reEnv (typeForGraphRefRelationalExpr expr)

413 case existingRelVar of

279 case existingRelVar of

414 Nothing -> do

280 Nothing -> do

281+ case runGraphRefRelationalExprM reEnv (typeForGraphRefRelationalExpr expr) of

282+ Left err -> dbErr err

283+ Right reltype -> do

284+ lift $ except $ validateAttributes (typeConstructorMapping context) (attributes reltype)

415− setRelVar relVarName expr

285+ setRelVar relVarName expr

416 Just existingRel -> do

286 Just existingRel -> do

417 let eExpectedType = runGraphRefRelationalExprM reEnv (typeForGraphRefRelationalExpr existingRel)

287 let eExpectedType = runGraphRefRelationalExprM reEnv (typeForGraphRefRelationalExpr existingRel)

418− eNewExprType = runGraphRefRelationalExprM reEnv (typeForGraphRefRelationalExpr expr)

419− reEnv = freshGraphRefRelationalExprEnv graph

420 case eExpectedType of

288 case eExpectedType of

421 Left err -> dbErr err

289 Left err -> dbErr err

422 Right expectedType ->

290 Right expectedType ->

@@ -424,44 +292,53 @@ evalGraphRefDatabaseContextExpr (Assign relVarName expr) = do

424 Left err -> dbErr err

292 Left err -> dbErr err

425 Right newExprType -> do

293 Right newExprType -> do

426 if newExprType == expectedType then do

294 if newExprType == expectedType then do

295+ lift $ except $ validateAttributes (typeConstructorMapping context) (attributes newExprType)

427 setRelVar relVarName expr

296 setRelVar relVarName expr

428 else

297 else

429 dbErr (RelationTypeMismatchError (attributes expectedType) (attributes newExprType))

298 dbErr (RelationTypeMismatchError (attributes expectedType) (attributes newExprType))

430

299

431evalGraphRefDatabaseContextExpr (Insert relVarName relExpr) = do

300evalGraphRefDatabaseContextExpr (Insert relVarName relExpr) = do

432− transId <- dbcTransId

301+ gfExpr <- relVarByName relVarName

433− evalGraphRefDatabaseContextExpr (Assign relVarName

302+ let optExpr = applyUnionCollapse (Union

434− (Union

435− (RelationVariable relVarName transId)

436− relExpr))

303+ relExpr

304+ gfExpr)

305+ evalGraphRefDatabaseContextExpr (Assign relVarName optExpr)

437

306

438evalGraphRefDatabaseContextExpr (Delete relVarName predicate) = do

307evalGraphRefDatabaseContextExpr (Delete relVarName predicate) = do

439− transId <- dbcTransId

308+ gfExpr <- relVarByName relVarName

440− let rv = RelationVariable relVarName transId

441− setRelVar relVarName (Restrict (NotPredicate predicate) rv)

309+ let optExpr = applyRestrictionCollapse (Restrict (NotPredicate predicate) gfExpr)

310+ setRelVar relVarName optExpr

442

311

443--union of restricted+updated portion and the unrestricted+unupdated portion

312--union of restricted+updated portion and the unrestricted+unupdated portion

444evalGraphRefDatabaseContextExpr (Update relVarName atomExprMap pred') = do

313evalGraphRefDatabaseContextExpr (Update relVarName atomExprMap pred') = do

314+ rvExpr <- relVarByName relVarName

315+ graph <- re_graph <$> dbcRelationalExprEnv

445 context <- getStateContext

316 context <- getStateContext

446− transId <- dbcTransId

317+ let reEnv = freshGraphRefRelationalExprEnv (Just context) graph

447− graph <- dbcGraph

318+ --get the current attributes name in the relvar to ensure that we don't conflict when renaming

448− let relVarMap = relationVariables context

319+ eExprType = runGraphRefRelationalExprM reEnv (typeForGraphRefRelationalExpr rvExpr)

449− case M.lookup relVarName relVarMap of

320+ exprType' <- case eExprType of

450− Nothing -> dbErr (RelVarNotDefinedError relVarName)

321+ Left err -> throwError err

451− Just _ -> do

322+ Right t -> pure t

452− let unrestrictedPortion = Restrict (NotPredicate pred') rv

323+ let unrestrictedPortion = Restrict (NotPredicate pred') rvExpr

453− rv = RelationVariable relVarName transId

324+ tmpAttr = tmpAttrC 1

454− tmpAttr attr = "_tmp_" <> attr --this could certainly be improved to verify that there is no attribute name conflict

325+ tmpAttrC :: Int -> AttributeName -> AttributeName

326+ tmpAttrC c attr =

327+ let tmpAttrName = "_tmp_" <> T.pack (show c) <> attr in

328+ if tmpAttrName `S.member` A.attributeNameSet (attributes exprType') then

329+ tmpAttrC (c+1) attr

330+ else

331+ tmpAttrName

455− updateAttr nam atomExpr = Extend (AttributeExtendTupleExpr (tmpAttr nam) atomExpr)

332+ updateAttr nam atomExpr = Extend (AttributeExtendTupleExpr (tmpAttr nam) atomExpr)

456− projectAndRename attr expr = Rename (tmpAttr attr) attr (Project (InvertedAttributeNames (S.singleton attr)) expr)

333+ projectAndRename attr expr = Rename (tmpAttr attr) attr (Project (InvertedAttributeNames (S.singleton attr)) expr)

457− --TODO restrictedPortion = Restrict pred'

334+ restrictedPortion = Restrict pred' rvExpr

458− updated = foldr (\(oldname, atomExpr) accum ->

335+ updated = foldr (\(oldname, atomExpr) accum ->

459− let procAtomExpr = runProcessExprM transId graph (processAtomExpr atomExpr) in

336+ let procAtomExpr = runProcessExprM UncommittedContextMarker (processAtomExpr atomExpr) in

460 updateAttr oldname procAtomExpr accum

337 updateAttr oldname procAtomExpr accum

461− ) rv (M.toList atomExprMap)

338+ ) restrictedPortion (M.toList atomExprMap)

462 -- the atomExprMap could reference other attributes, so we must perform multi-pass folds

339 -- the atomExprMap could reference other attributes, so we must perform multi-pass folds

463− updatedPortion = foldr projectAndRename updated (M.keys atomExprMap)

340+ updatedPortion = foldr projectAndRename updated (M.keys atomExprMap)

464− setRelVar relVarName (Union unrestrictedPortion updatedPortion)

341+ setRelVar relVarName (Union unrestrictedPortion updatedPortion)

465

342

466evalGraphRefDatabaseContextExpr (AddInclusionDependency newDepName newDep) = do

343evalGraphRefDatabaseContextExpr (AddInclusionDependency newDepName newDep) = do

467 currContext <- getStateContext

344 currContext <- getStateContext

@@ -473,6 +350,8 @@ evalGraphRefDatabaseContextExpr (AddInclusionDependency newDepName newDep) = do

473 dbErr (InclusionDependencyNameInUseError newDepName)

350 dbErr (InclusionDependencyNameInUseError newDepName)

474 else do

351 else do

475 let potentialContext = currContext { inclusionDependencies = newDeps }

352 let potentialContext = currContext { inclusionDependencies = newDeps }

353+ -- if the potential context passes all constraints, then save it

354+ -- potential optimization: validate only the new constraint- all old constraints must already hold

476 case checkConstraints potentialContext transId graph of

355 case checkConstraints potentialContext transId graph of

477 Left err -> dbErr err

356 Left err -> dbErr err

478 Right _ ->

357 Right _ ->

@@ -517,9 +396,9 @@ evalGraphRefDatabaseContextExpr (AddTypeConstructor tConsDef dConsDefList) = do

517 let oldTypes = typeConstructorMapping currentContext

396 let oldTypes = typeConstructorMapping currentContext

518 tConsName = TCD.name tConsDef

397 tConsName = TCD.name tConsDef

519 -- validate that the constructor's types exist

398 -- validate that the constructor's types exist

520− case validateTypeConstructorDef tConsDef dConsDefList of

399+ case validateTypeConstructorDef tConsDef dConsDefList oldTypes of

521− errs@(_:_) -> dbErr (someErrors errs)

400+ Left err -> throwError err

522− [] | T.null tConsName || not (isUpper (T.head tConsName)) -> dbErr (InvalidAtomTypeName tConsName)

401+ Right () | T.null tConsName || not (isUpper (T.head tConsName)) -> dbErr (InvalidAtomTypeName tConsName)

523 | isJust (findTypeConstructor tConsName oldTypes) -> dbErr (AtomTypeNameInUseError tConsName)

402 | isJust (findTypeConstructor tConsName oldTypes) -> dbErr (AtomTypeNameInUseError tConsName)

524 | otherwise -> do

403 | otherwise -> do

525 let newTypes = oldTypes ++ [(tConsDef, dConsDefList)]

404 let newTypes = oldTypes ++ [(tConsDef, dConsDefList)]

@@ -535,15 +414,10 @@ evalGraphRefDatabaseContextExpr (RemoveTypeConstructor tConsName) = do

535 let newTypes = filter (\(tCons, _) -> TCD.name tCons /= tConsName) oldTypes

414 let newTypes = filter (\(tCons, _) -> TCD.name tCons /= tConsName) oldTypes

536 putStateContext $ currentContext { typeConstructorMapping = newTypes }

415 putStateContext $ currentContext { typeConstructorMapping = newTypes }

537

416

538−evalGraphRefDatabaseContextExpr (MultipleExpr _) = do

417+evalGraphRefDatabaseContextExpr (MultipleExpr exprs) =

539 --the multiple expressions must pass the same context around- not the old unmodified context

418 --the multiple expressions must pass the same context around- not the old unmodified context

540− unimplemented

541−{- evald <- forM exprs (\expr -> evalGraphRefDatabaseContextExpr expr)

419+ mapM_ evalGraphRefDatabaseContextExpr exprs

542− --some lifting magic needed here

420+

543− case lefts evald of

544− [] -> pure ()

545− errs -> dbErr (someErrors errs)

546− -}

547evalGraphRefDatabaseContextExpr (RemoveAtomFunction funcName) = do

421evalGraphRefDatabaseContextExpr (RemoveAtomFunction funcName) = do

548 currentContext <- getStateContext

422 currentContext <- getStateContext

549 let atomFuncs = atomFunctions currentContext

423 let atomFuncs = atomFunctions currentContext

@@ -572,9 +446,9 @@ evalGraphRefDatabaseContextExpr (ExecuteDatabaseContextFunction funcName atomArg

572 context <- getStateContext

446 context <- getStateContext

573 graph <- dbcGraph

447 graph <- dbcGraph

574 --resolve atom arguments

448 --resolve atom arguments

575− let eAtomTypes = mapM (\atomExpr -> runGraphRefRelationalExprM gfEnv (typeForGraphRefAtomExpr emptyAttributes atomExpr)) atomArgExprs

449+ let eAtomTypes = mapM (runGraphRefRelationalExprM gfEnv . typeForGraphRefAtomExpr emptyAttributes) atomArgExprs

576 eFunc = databaseContextFunctionForName funcName (dbcFunctions context)

450 eFunc = databaseContextFunctionForName funcName (dbcFunctions context)

577− gfEnv = freshGraphRefRelationalExprEnv graph

451+ gfEnv = freshGraphRefRelationalExprEnv (Just context) graph

578 case eFunc of

452 case eFunc of

579 Left err -> dbErr err

453 Left err -> dbErr err

580 Right func -> do

454 Right func -> do

@@ -587,12 +461,13 @@ evalGraphRefDatabaseContextExpr (ExecuteDatabaseContextFunction funcName atomArg

587 case eAtomTypes of

461 case eAtomTypes of

588 Left err -> dbErr err

462 Left err -> dbErr err

589 Right atomTypes -> do

463 Right atomTypes -> do

464+ let mValidTypes = zipWith (\ expType actType

590− let mValidTypes = map (\(expType, actType) -> case atomTypeVerify expType actType of

465+ -> case atomTypeVerify expType actType of

591− Left err -> Just err

466+ Left err -> Just err

467+ Right _ -> Nothing)

592− Right _ -> Nothing) (zip (dbcFuncType func) atomTypes)

468+ (dbcFuncType func) atomTypes

593 typeErrors = catMaybes mValidTypes

469 typeErrors = catMaybes mValidTypes

594− eAtomArgs = unimplemented

470+ eAtomArgs = map (runGraphRefRelationalExprM gfEnv . evalGraphRefAtomExpr emptyTuple) atomArgExprs

595− --eAtomArgs = map (\arg -> runReader (evalAtomExpr emptyTuple arg) relExprState) atomArgExprs

596 if length (lefts eAtomArgs) > 1 then

471 if length (lefts eAtomArgs) > 1 then

597 dbErr (someErrors (lefts eAtomArgs))

472 dbErr (someErrors (lefts eAtomArgs))

598 else if not (null typeErrors) then

473 else if not (null typeErrors) then

@@ -601,7 +476,6 @@ evalGraphRefDatabaseContextExpr (ExecuteDatabaseContextFunction funcName atomArg

601 case evalDatabaseContextFunction func (rights eAtomArgs) context of

476 case evalDatabaseContextFunction func (rights eAtomArgs) context of

602 Left err -> dbErr err

477 Left err -> dbErr err

603 Right newContext -> putStateContext newContext

478 Right newContext -> putStateContext newContext

604−

605data DatabaseContextIOEvalEnv = DatabaseContextIOEvalEnv

479data DatabaseContextIOEvalEnv = DatabaseContextIOEvalEnv

606 { dbcio_transId :: TransactionId,

480 { dbcio_transId :: TransactionId,

607 dbcio_graph :: TransactionGraph,

481 dbcio_graph :: TransactionGraph,

@@ -637,10 +511,15 @@ getDBCIOContext = dbc_context <$> RWS.get

637getDBCIORelationalExprEnv :: DatabaseContextIOEvalMonad RelationalExprEnv

511getDBCIORelationalExprEnv :: DatabaseContextIOEvalMonad RelationalExprEnv

638getDBCIORelationalExprEnv = do

512getDBCIORelationalExprEnv = do

639 context <- getDBCIOContext

513 context <- getDBCIOContext

640− env <- RWS.ask

641− pure $ mkRelationalExprEnv context (dbcio_transId env) (dbcio_graph env)

514+ mkRelationalExprEnv context . dbcio_graph <$> RWS.ask

642

515

643evalGraphRefDatabaseContextIOExpr :: GraphRefDatabaseContextIOExpr -> DatabaseContextIOEvalMonad (Either RelationalError ())

516evalGraphRefDatabaseContextIOExpr :: GraphRefDatabaseContextIOExpr -> DatabaseContextIOEvalMonad (Either RelationalError ())

517+#if !defined(PM36_HASKELL_SCRIPTING)

518+evalGraphRefDatabaseContextIOExpr AddAtomFunction{} = pure (Left (ScriptError ScriptCompilationDisabledError))

519+evalGraphRefDatabaseContextIOExpr AddDatabaseContextFunction{} = pure (Left (ScriptError ScriptCompilationDisabledError))

520+evalGraphRefDatabaseContextIOExpr LoadAtomFunctions{} = pure (Left (ScriptError ScriptCompilationDisabledError))

521+evalGraphRefDatabaseContextIOExpr LoadDatabaseContextFunctions{} = pure (Left (ScriptError ScriptCompilationDisabledError))

522+#else

644evalGraphRefDatabaseContextIOExpr (AddAtomFunction funcName funcType script) = do

523evalGraphRefDatabaseContextIOExpr (AddAtomFunction funcName funcType script) = do

645 eScriptSession <- requireScriptSession

524 eScriptSession <- requireScriptSession

646 currentContext <- getDBCIOContext

525 currentContext <- getDBCIOContext

@@ -674,7 +553,6 @@ evalGraphRefDatabaseContextIOExpr (AddAtomFunction funcName funcType script) = d

674 Right eContext -> case eContext of

553 Right eContext -> case eContext of

675 Left err -> pure (Left err)

554 Left err -> pure (Left err)

676 Right context' -> putDBCIOContext context'

555 Right context' -> putDBCIOContext context'

677−

678evalGraphRefDatabaseContextIOExpr (AddDatabaseContextFunction funcName funcType script) = do

556evalGraphRefDatabaseContextIOExpr (AddDatabaseContextFunction funcName funcType script) = do

679 eScriptSession <- requireScriptSession

557 eScriptSession <- requireScriptSession

680 currentContext <- getDBCIOContext

558 currentContext <- getDBCIOContext

@@ -716,7 +594,6 @@ evalGraphRefDatabaseContextIOExpr (AddDatabaseContextFunction funcName funcType

716 Right eContext -> case eContext of

594 Right eContext -> case eContext of

717 Left err -> pure (Left err)

595 Left err -> pure (Left err)

718 Right context' -> putDBCIOContext context'

596 Right context' -> putDBCIOContext context'

719−

720evalGraphRefDatabaseContextIOExpr (LoadAtomFunctions modName funcName modPath) = do

597evalGraphRefDatabaseContextIOExpr (LoadAtomFunctions modName funcName modPath) = do

721 currentContext <- getDBCIOContext

598 currentContext <- getDBCIOContext

722 eLoadFunc <- liftIO $ loadAtomFunctions (T.unpack modName) (T.unpack funcName) modPath

599 eLoadFunc <- liftIO $ loadAtomFunctions (T.unpack modName) (T.unpack funcName) modPath

@@ -733,7 +610,7 @@ evalGraphRefDatabaseContextIOExpr (LoadDatabaseContextFunctions modName funcName

733 Right dbcListFunc -> let newContext = currentContext { dbcFunctions = mergedFuncs }

610 Right dbcListFunc -> let newContext = currentContext { dbcFunctions = mergedFuncs }

734 mergedFuncs = HS.union (dbcFunctions currentContext) (HS.fromList dbcListFunc)

611 mergedFuncs = HS.union (dbcFunctions currentContext) (HS.fromList dbcListFunc)

735 in putDBCIOContext newContext

612 in putDBCIOContext newContext

736−

613+#endif

737evalGraphRefDatabaseContextIOExpr (CreateArbitraryRelation relVarName attrExprs range) = do

614evalGraphRefDatabaseContextIOExpr (CreateArbitraryRelation relVarName attrExprs range) = do

738 --Define

615 --Define

739 currentContext <- getDBCIOContext

616 currentContext <- getDBCIOContext

@@ -751,7 +628,7 @@ evalGraphRefDatabaseContextIOExpr (CreateArbitraryRelation relVarName attrExprs

751 case existingRelVar of

628 case existingRelVar of

752 Nothing -> pure $ Left (RelVarNotDefinedError relVarName)

629 Nothing -> pure $ Left (RelVarNotDefinedError relVarName)

753 Just existingRel -> do

630 Just existingRel -> do

754− let gfEnv = freshGraphRefRelationalExprEnv graph

631+ let gfEnv = freshGraphRefRelationalExprEnv (Just currentContext) graph

755 case runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr existingRel) of

632 case runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr existingRel) of

756 Left err -> pure (Left err)

633 Left err -> pure (Left err)

757 Right relType -> do

634 Right relType -> do

@@ -765,44 +642,36 @@ evalGraphRefDatabaseContextIOExpr (CreateArbitraryRelation relVarName attrExprs

765 Left err -> pure (Left err)

642 Left err -> pure (Left err)

766 Right dbstate' -> putDBCIOContext (dbc_context dbstate')

643 Right dbstate' -> putDBCIOContext (dbc_context dbstate')

767

644

768−{-

769−updateTupleWithAtomExprs :: M.Map AttributeName AtomExpr -> DatabaseContext -> TransactionGraph -> RelationTuple -> Either RelationalError RelationTuple

770−updateTupleWithAtomExprs exprMap context graph tupIn = do

771− --resolve all atom exprs

772− let

773− atomsAssoc <- mapM (\(attrName, atomExpr) -> do

774− let atom = unimplemented

775− --atom <- runReader (evalAtomExpr tupIn atomExpr) (mkRelationalExprState context graph)

776− pure (attrName, atom)

777− ) (M.toList exprMap)

778− pure (updateTupleWithAtoms (M.fromList atomsAssoc) tupIn)

779−-}

780--run verification on all constraints

645--run verification on all constraints

781checkConstraints :: DatabaseContext -> TransactionId -> TransactionGraph -> Either RelationalError ()

646checkConstraints :: DatabaseContext -> TransactionId -> TransactionGraph -> Either RelationalError ()

782−checkConstraints context transId graph@(TransactionGraph graphHeads transSet) =

647+checkConstraints context transId graph@(TransactionGraph graphHeads transSet) = do

783 mapM_ (uncurry checkIncDep) (M.toList deps)

648 mapM_ (uncurry checkIncDep) (M.toList deps)

784 where

649 where

785 potentialGraph = TransactionGraph graphHeads (S.insert tempTrans transSet)

650 potentialGraph = TransactionGraph graphHeads (S.insert tempTrans transSet)

786 tempStamp = UTCTime { utctDay = fromGregorian 2000 1 1,

651 tempStamp = UTCTime { utctDay = fromGregorian 2000 1 1,

787 utctDayTime = secondsToDiffTime 0 }

652 utctDayTime = secondsToDiffTime 0 }

788 tempSchemas = Schemas context M.empty

653 tempSchemas = Schemas context M.empty

654+ tempTrans = Transaction U.nil tempTransInfo tempSchemas

789− tempTrans = Transaction U.nil (TransactionInfo (transId NE.:| []) tempStamp) tempSchemas

655+ tempTransInfo = TransactionInfo { parents = transId NE.:| [],

656+ stamp = tempStamp,

657+ merkleHash = mempty

658+ }

790

659

791 deps = inclusionDependencies context

660 deps = inclusionDependencies context

792 -- no optimization available here, really? perhaps the optimizer should be passed down to here or the eval function should be passed through the environment

661 -- no optimization available here, really? perhaps the optimizer should be passed down to here or the eval function should be passed through the environment

793 checkIncDep depName (InclusionDependency subsetExpr supersetExpr) = do

662 checkIncDep depName (InclusionDependency subsetExpr supersetExpr) = do

794− let process = runProcessExprM transId graph

663+ let process = runProcessExprM UncommittedContextMarker

795 gfSubsetExpr = process (processRelationalExpr subsetExpr)

664 gfSubsetExpr = process (processRelationalExpr subsetExpr)

796 gfSupersetExpr = process (processRelationalExpr supersetExpr)

665 gfSupersetExpr = process (processRelationalExpr supersetExpr)

797 --if both expressions are of a single-attribute (such as with a simple foreign key), the names of the attributes are irrelevant (they need not match) because the expression is unambiguous, but special-casing this to rename the attribute automatically would not be orthogonal behavior and probably cause confusion. Instead, special case the error to make it clear.

666 --if both expressions are of a single-attribute (such as with a simple foreign key), the names of the attributes are irrelevant (they need not match) because the expression is unambiguous, but special-casing this to rename the attribute automatically would not be orthogonal behavior and probably cause confusion. Instead, special case the error to make it clear.

798− let gfEnv = freshGraphRefRelationalExprEnv graph

667+ let gfEnv = freshGraphRefRelationalExprEnv (Just context) graph

799 runGfRel = runGraphRefRelationalExprM gfEnv

668 runGfRel = runGraphRefRelationalExprM gfEnv

800 typeSub <- runGfRel (typeForGraphRefRelationalExpr gfSubsetExpr)

669 typeSub <- runGfRel (typeForGraphRefRelationalExpr gfSubsetExpr)

801 typeSuper <- runGfRel (typeForGraphRefRelationalExpr gfSupersetExpr)

670 typeSuper <- runGfRel (typeForGraphRefRelationalExpr gfSupersetExpr)

802 when (typeSub /= typeSuper) (Left (RelationTypeMismatchError (attributes typeSub) (attributes typeSuper)))

671 when (typeSub /= typeSuper) (Left (RelationTypeMismatchError (attributes typeSub) (attributes typeSuper)))

803 let checkExpr = Equals gfSupersetExpr (Union gfSubsetExpr gfSupersetExpr)

672 let checkExpr = Equals gfSupersetExpr (Union gfSubsetExpr gfSupersetExpr)

804 gfEvald = runGraphRefRelationalExprM gfEnv' (evalGraphRefRelationalExpr checkExpr)

673 gfEvald = runGraphRefRelationalExprM gfEnv' (evalGraphRefRelationalExpr checkExpr)

805− gfEnv' = freshGraphRefRelationalExprEnv potentialGraph

674+ gfEnv' = freshGraphRefRelationalExprEnv (Just context) potentialGraph

806 case gfEvald of

675 case gfEvald of

807 Left err -> Left err

676 Left err -> Left err

808 Right resultRel -> if resultRel == relationTrue then

677 Right resultRel -> if resultRel == relationTrue then

@@ -818,20 +687,11 @@ typeForRelationalExpr expr = do

818 --replace the relationVariables context element with a cloned set of relation devoid of tuples

687 --replace the relationVariables context element with a cloned set of relation devoid of tuples

819 --evalRelationalExpr could still return an existing relation with tuples, so strip them

688 --evalRelationalExpr could still return an existing relation with tuples, so strip them

820 graph <- reGraph

689 graph <- reGraph

821− transId <- reTransId

690+ context <- reContext

822− let gfExpr = runProcessExprM transId graph (processRelationalExpr expr)

691+ let gfExpr = runProcessExprM UncommittedContextMarker (processRelationalExpr expr)

823− gfEnv = freshGraphRefRelationalExprEnv graph

692+ gfEnv = freshGraphRefRelationalExprEnv (Just context) graph

824 runGf = runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr gfExpr)

693 runGf = runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr gfExpr)

825− lift $ except $ runGf

694+ lift $ except runGf

826−

827−--returns a database context with all tuples removed

828−--this is useful for type checking and optimization

829−{-

830−contextWithEmptyTupleSets :: DatabaseContext -> DatabaseContext

831−contextWithEmptyTupleSets contextIn = contextIn { relationVariables = relVars }

832− where

833− relVars = M.map (\rel -> ExistingRelation (Relation (attributes rel) emptyTupleSet)) (relationVariables contextIn)

834−-}

835

695

836liftE :: (Monad m) => m (Either a b) -> ExceptT a m b

696liftE :: (Monad m) => m (Either a b) -> ExceptT a m b

837liftE v = do

697liftE v = do

@@ -880,7 +740,7 @@ predicateRestrictionFilter _ (RelationalExprPredicate relExpr) = do

880

740

881predicateRestrictionFilter attrs (AttributeEqualityPredicate attrName atomExpr) = do

741predicateRestrictionFilter attrs (AttributeEqualityPredicate attrName atomExpr) = do

882 env <- askEnv

742 env <- askEnv

883− let attrs' = envAttributes env

743+ let attrs' = A.union attrs (envAttributes env)

884 ctxtup' = envTuple env

744 ctxtup' = envTuple env

885 atomExprType <- typeForGraphRefAtomExpr attrs' atomExpr

745 atomExprType <- typeForGraphRefAtomExpr attrs' atomExpr

886 attr <- lift $ except $ case A.attributeForName attrName attrs of

746 attr <- lift $ except $ case A.attributeForName attrName attrs of

@@ -924,7 +784,7 @@ tupleExprCheckNewAttrName attrName rel = if isRight (attributeForName attrName r

924 Right rel

784 Right rel

925

785

926extendGraphRefTupleExpressionProcessor :: Relation -> GraphRefExtendTupleExpr -> GraphRefRelationalExprM (Attributes, RelationTuple -> Either RelationalError RelationTuple)

786extendGraphRefTupleExpressionProcessor :: Relation -> GraphRefExtendTupleExpr -> GraphRefRelationalExprM (Attributes, RelationTuple -> Either RelationalError RelationTuple)

927−extendGraphRefTupleExpressionProcessor relIn (AttributeExtendTupleExpr newAttrName atomExpr) = do

787+extendGraphRefTupleExpressionProcessor relIn (AttributeExtendTupleExpr newAttrName atomExpr) =

928-- renv <- askEnv

788-- renv <- askEnv

929 -- check that the attribute name is not in use

789 -- check that the attribute name is not in use

930 case tupleExprCheckNewAttrName newAttrName relIn of

790 case tupleExprCheckNewAttrName newAttrName relIn of

@@ -934,66 +794,60 @@ extendGraphRefTupleExpressionProcessor relIn (AttributeExtendTupleExpr newAttrNa

934 atomExprType' <- verifyGraphRefAtomExprTypes relIn atomExpr atomExprType

794 atomExprType' <- verifyGraphRefAtomExprTypes relIn atomExpr atomExprType

935 let newAttrs = A.attributesFromList [Attribute newAttrName atomExprType']

795 let newAttrs = A.attributesFromList [Attribute newAttrName atomExprType']

936 newAndOldAttrs = A.addAttributes (attributes relIn) newAttrs

796 newAndOldAttrs = A.addAttributes (attributes relIn) newAttrs

797+ env <- ask

937− pure (newAndOldAttrs, \tup ->

798+ pure (newAndOldAttrs, \tup -> do

938− --let substate = mergeTuplesIntoGraphRefRelationalExprEnv tup renv in

799+ let gfEnv = mergeTuplesIntoGraphRefRelationalExprEnv tup env

939− case unimplemented {-runReader (evalAtomExpr tup atomExpr) substate-} of

800+ atom <- runGraphRefRelationalExprM gfEnv (evalGraphRefAtomExpr tup atomExpr)

940− Left err -> Left err

941− Right atom -> Right (tupleAtomExtend newAttrName atom tup)

801+ Right (tupleAtomExtend newAttrName atom tup)

942 )

802 )

943

803

944evalGraphRefAtomExpr :: RelationTuple -> GraphRefAtomExpr -> GraphRefRelationalExprM Atom

804evalGraphRefAtomExpr :: RelationTuple -> GraphRefAtomExpr -> GraphRefRelationalExprM Atom

945−evalGraphRefAtomExpr = unimplemented

805+evalGraphRefAtomExpr tupIn (AttributeAtomExpr attrName) =

946−

947−evalAtomExpr :: RelationTuple -> AtomExpr -> RelationalExprM Atom

948−evalAtomExpr = unimplemented

949−{-

950−

951−evalAtomExpr tupIn (AttributeAtomExpr attrName) = case atomForAttributeName attrName tupIn of

806+ case atomForAttributeName attrName tupIn of

952− Right atom -> pure (Right atom)

807+ Right atom -> pure atom

953− err@(Left (NoSuchAttributeNamesError _)) -> do

808+ Left err@(NoSuchAttributeNamesError _) -> do

954− rstate <- ask

809+ env <- askEnv

955− let stateTup = stateTuple rstate

810+ case gre_extra env of

811+ Nothing -> throwError err

956− pure (atomForAttributeName attrName stateTup)

812+ Just (Left ctxtup) -> lift $ except $ atomForAttributeName attrName ctxtup

813+ Just (Right _) -> throwError err

957− Left err -> pure (Left err)

814+ Left err -> throwError err

958−evalAtomExpr _ (NakedAtomExpr atom) = pure (Right atom)

815+evalGraphRefAtomExpr _ (NakedAtomExpr atom) = pure atom

959−evalAtomExpr tupIn (FunctionAtomExpr funcName arguments ()) = do

816+evalGraphRefAtomExpr tupIn (FunctionAtomExpr funcName arguments tid) = do

960− argTypes <- mapM (typeFromAtomExpr (tupleAttributes tupIn)) arguments

817+ argTypes <- mapM (typeForGraphRefAtomExpr (tupleAttributes tupIn)) arguments

961− context <- fmap stateElemsContext ask

818+ context <- gfDatabaseContextForMarker tid

962− runExceptT $ do

963− let functions = atomFunctions context

819+ let functions = atomFunctions context

964− func <- either throwE pure (atomFunctionForName funcName functions)

820+ func <- lift $ except (atomFunctionForName funcName functions)

965− let expectedArgCount = length (atomFuncType func) - 1

821+ let expectedArgCount = length (atomFuncType func) - 1

966− actualArgCount = length argTypes

822+ actualArgCount = length argTypes

967− safeInit [] = [] -- different behavior from normal init

823+ safeInit [] = [] -- different behavior from normal init

968− safeInit xs = init xs

824+ safeInit xs = init xs

969− if expectedArgCount /= actualArgCount then

825+ if expectedArgCount /= actualArgCount then

970− throwE (FunctionArgumentCountMismatchError expectedArgCount actualArgCount)

826+ throwError (FunctionArgumentCountMismatchError expectedArgCount actualArgCount)

971− else do

827+ else do

972 let zippedArgs = zip (safeInit (atomFuncType func)) argTypes

828 let zippedArgs = zip (safeInit (atomFuncType func)) argTypes

973− mapM_ (\(expType, eActType) -> do

829+ mapM_ (\(expType, actType) ->

974− actType <- either throwE pure eActType

975− either throwE pure (atomTypeVerify expType actType)) zippedArgs

830+ lift $ except (atomTypeVerify expType actType)) zippedArgs

976− evaldArgs <- mapM (liftE . evalAtomExpr tupIn) arguments

831+ evaldArgs <- mapM (evalGraphRefAtomExpr tupIn) arguments

977 case evalAtomFunction func evaldArgs of

832 case evalAtomFunction func evaldArgs of

978− Left err -> throwE (AtomFunctionUserError err)

833+ Left err -> throwError (AtomFunctionUserError err)

979 Right result -> do

834 Right result -> do

980 --validate that the result matches the expected type

835 --validate that the result matches the expected type

981− _ <- either throwE pure (atomTypeVerify (last (atomFuncType func)) (atomTypeForAtom result))

836+ _ <- lift $ except (atomTypeVerify (last (atomFuncType func)) (atomTypeForAtom result))

982 pure result

837 pure result

983−evalAtomExpr tupIn (RelationAtomExpr relExpr) = do

838+evalGraphRefAtomExpr tupIn (RelationAtomExpr relExpr) = do

984 --merge existing state tuple context into new state tuple context to support an arbitrary number of levels, but new attributes trounce old attributes

839 --merge existing state tuple context into new state tuple context to support an arbitrary number of levels, but new attributes trounce old attributes

985− rstate <- ask

840+ env <- ask

986− runExceptT $ do

841+ let gfEnv = mergeTuplesIntoGraphRefRelationalExprEnv tupIn env

987− let newState = mergeTuplesIntoRelationalExprState tupIn rstate

842+ relAtom <- lift $ except $ runGraphRefRelationalExprM gfEnv (evalGraphRefRelationalExpr relExpr)

988− relAtom <- either throwE pure (runReader (evalRelationalExpr relExpr) newState)

989− pure (RelationAtom relAtom)

843+ pure (RelationAtom relAtom)

990−evalAtomExpr tupIn cons@(ConstructedAtomExpr dConsName dConsArgs ()) = runExceptT $ do

844+evalGraphRefAtomExpr tupIn cons@(ConstructedAtomExpr dConsName dConsArgs _) = do --why is the tid unused here? suspicious

991− rstate <- lift ask

845+ let mergeEnv = mergeTuplesIntoGraphRefRelationalExprEnv tupIn

992− let newState = mergeTuplesIntoRelationalExprState tupIn rstate

993− aType <- either throwE pure (runReader (typeFromAtomExpr (tupleAttributes tupIn) cons) newState)

846+ aType <- local mergeEnv (typeForGraphRefAtomExpr (tupleAttributes tupIn) cons)

994− argAtoms <- mapM (\arg -> either throwE pure (runReader (evalAtomExpr tupIn arg) newState)) dConsArgs

847+ argAtoms <- local mergeEnv $

848+ mapM (evalGraphRefAtomExpr tupIn) dConsArgs

995 pure (ConstructedAtom dConsName aType argAtoms)

849 pure (ConstructedAtom dConsName aType argAtoms)

996−-}

850+

997typeForGraphRefAtomExpr :: Attributes -> GraphRefAtomExpr -> GraphRefRelationalExprM AtomType

851typeForGraphRefAtomExpr :: Attributes -> GraphRefAtomExpr -> GraphRefRelationalExprM AtomType

998typeForGraphRefAtomExpr attrs (AttributeAtomExpr attrName) = do

852typeForGraphRefAtomExpr attrs (AttributeAtomExpr attrName) = do

999 renv <- askEnv

853 renv <- askEnv

@@ -1006,12 +860,13 @@ typeForGraphRefAtomExpr attrs (AttributeAtomExpr attrName) = do

1006 Right attr -> pure (A.atomType attr)

860 Right attr -> pure (A.atomType attr)

1007 Left _ -> case atomForAttributeName attrName envTup of

861 Left _ -> case atomForAttributeName attrName envTup of

1008 Right atom -> pure (atomTypeForAtom atom)

862 Right atom -> pure (atomTypeForAtom atom)

863+ Left _ -> --throwError (traceStack (show ("typeForGRAtomExpr", attrs, envTup)) err)

1009− Left _ -> throwError err

864+ throwError err

1010 Left err -> throwError err

865 Left err -> throwError err

1011

866

1012typeForGraphRefAtomExpr _ (NakedAtomExpr atom) = pure (atomTypeForAtom atom)

867typeForGraphRefAtomExpr _ (NakedAtomExpr atom) = pure (atomTypeForAtom atom)

1013typeForGraphRefAtomExpr attrs (FunctionAtomExpr funcName atomArgs transId) = do

868typeForGraphRefAtomExpr attrs (FunctionAtomExpr funcName atomArgs transId) = do

1014− funcs <- atomFunctions . concreteDatabaseContext <$> gfTransForId transId

869+ funcs <- atomFunctions <$> gfDatabaseContextForMarker transId

1015 case atomFunctionForName funcName funcs of

870 case atomFunctionForName funcName funcs of

1016 Left err -> throwError err

871 Left err -> throwError err

1017 Right func -> do

872 Right func -> do

@@ -1029,7 +884,7 @@ typeForGraphRefAtomExpr attrs (RelationAtomExpr relExpr) = do

1029typeForGraphRefAtomExpr attrs (ConstructedAtomExpr dConsName dConsArgs tid) =

884typeForGraphRefAtomExpr attrs (ConstructedAtomExpr dConsName dConsArgs tid) =

1030 do

885 do

1031 argsTypes <- mapM (typeForGraphRefAtomExpr attrs) dConsArgs

886 argsTypes <- mapM (typeForGraphRefAtomExpr attrs) dConsArgs

1032− tConsMap <- typeConstructorMapping . concreteDatabaseContext <$> gfTransForId tid

887+ tConsMap <- typeConstructorMapping <$> gfDatabaseContextForMarker tid

1033 lift $ except $ atomTypeForDataConstructor tConsMap dConsName argsTypes

888 lift $ except $ atomTypeForDataConstructor tConsMap dConsName argsTypes

1034

889

1035-- | Validate that the type of the AtomExpr matches the expected type.

890-- | Validate that the type of the AtomExpr matches the expected type.

@@ -1051,7 +906,7 @@ verifyGraphRefAtomExprTypes relIn (AttributeAtomExpr attrName) expectedType = do

1051verifyGraphRefAtomExprTypes _ (NakedAtomExpr atom) expectedType =

906verifyGraphRefAtomExprTypes _ (NakedAtomExpr atom) expectedType =

1052 lift $ except $ atomTypeVerify expectedType (atomTypeForAtom atom)

907 lift $ except $ atomTypeVerify expectedType (atomTypeForAtom atom)

1053verifyGraphRefAtomExprTypes relIn (FunctionAtomExpr funcName funcArgExprs tid) expectedType = do

908verifyGraphRefAtomExprTypes relIn (FunctionAtomExpr funcName funcArgExprs tid) expectedType = do

1054− context <- concreteDatabaseContext <$> gfTransForId tid

909+ context <- gfDatabaseContextForMarker tid

1055 let functions = atomFunctions context

910 let functions = atomFunctions context

1056 func <- lift $ except $ atomFunctionForName funcName functions

911 func <- lift $ except $ atomFunctionForName funcName functions

1057 let expectedArgTypes = atomFuncType func

912 let expectedArgTypes = atomFuncType func

@@ -1059,7 +914,7 @@ verifyGraphRefAtomExprTypes relIn (FunctionAtomExpr funcName funcArgExprs tid) e

1059 let handler :: RelationalError -> GraphRefRelationalExprM AtomType

914 let handler :: RelationalError -> GraphRefRelationalExprM AtomType

1060 handler (AtomTypeMismatchError expSubType actSubType) = throwError (AtomFunctionTypeError funcName argCount expSubType actSubType)

915 handler (AtomTypeMismatchError expSubType actSubType) = throwError (AtomFunctionTypeError funcName argCount expSubType actSubType)

1061 handler err = throwError err

916 handler err = throwError err

1062− verifyGraphRefAtomExprTypes relIn atomExpr expectedType2 `catchError` handler

917+ verifyGraphRefAtomExprTypes relIn atomExpr expectedType2 `catchError` handler

1063 funcArgTypes <- mapM funcArgVerifier $ zip3 funcArgExprs expectedArgTypes [1..]

918 funcArgTypes <- mapM funcArgVerifier $ zip3 funcArgExprs expectedArgTypes [1..]

1064 if length funcArgTypes /= length expectedArgTypes - 1 then

919 if length funcArgTypes /= length expectedArgTypes - 1 then

1065 throwError (AtomTypeCountError funcArgTypes expectedArgTypes)

920 throwError (AtomTypeCountError funcArgTypes expectedArgTypes)

@@ -1077,13 +932,61 @@ verifyGraphRefAtomExprTypes rel cons@ConstructedAtomExpr{} expectedType = do

1077-- | Look up the type's name and create a new attribute.

932-- | Look up the type's name and create a new attribute.

1078evalGraphRefAttrExpr :: GraphRefAttributeExpr -> GraphRefRelationalExprM Attribute

933evalGraphRefAttrExpr :: GraphRefAttributeExpr -> GraphRefRelationalExprM Attribute

1079evalGraphRefAttrExpr (AttributeAndTypeNameExpr attrName tCons transId) = do

934evalGraphRefAttrExpr (AttributeAndTypeNameExpr attrName tCons transId) = do

1080− tConsMap <- typeConstructorMapping . concreteDatabaseContext <$> gfTransForId transId

935+ tConsMap <- typeConstructorMapping <$> gfDatabaseContextForMarker transId

1081 aType <- lift $ except $ atomTypeForTypeConstructorValidate True tCons tConsMap M.empty

936 aType <- lift $ except $ atomTypeForTypeConstructorValidate True tCons tConsMap M.empty

1082 lift $ except $ validateAtomType aType tConsMap

937 lift $ except $ validateAtomType aType tConsMap

1083 pure $ Attribute attrName aType

938 pure $ Attribute attrName aType

1084

939

1085evalGraphRefAttrExpr (NakedAttributeExpr attr) = pure attr

940evalGraphRefAttrExpr (NakedAttributeExpr attr) = pure attr

1086−

941+

942+-- for tuple type concrete resolution (Nothing ==> Maybe Int) when the attributes hint is Nothing, we need to first process all the tuples, then extract the concrete types on a per-attribute basis, then reprocess the tuples to include the concrete types

943+evalGraphRefTupleExprs :: Maybe Attributes -> GraphRefTupleExprs -> GraphRefRelationalExprM [RelationTuple]

944+evalGraphRefTupleExprs _ (TupleExprs _ []) = pure []

945+evalGraphRefTupleExprs mAttrs (TupleExprs fixedMarker tupleExprL) = do

946+ tuples <- mapM (evalGraphRefTupleExpr mAttrs) tupleExprL

947+ finalAttrs <- case mAttrs of

948+ Just attrs -> pure attrs

949+ Nothing ->

950+ case tuples of

951+ [] -> pure emptyAttributes

952+ (headTuple:tailTuples) -> do

953+ --gather up resolved atom types or throw an error if an attribute cannot be made concrete from the inferred types- this could still fail if the type cannot be inferred (e.g. from [Nothing, Nothing])

954+ let

955+ processTupleAttrs (tupAttr, accAttr) =

956+ --if the attribute is a constructedatomtype, we can recurse into it to potentially resolve type variables

957+ if isResolvedAttribute accAttr && tupAttr == accAttr then

958+ pure accAttr

959+ else

960+ lift $ except $ resolveAttributes accAttr tupAttr

961+ mostResolvedTypes <-

962+ foldM (\acc tup -> do

963+ let zipped = zip (V.toList . attributesVec $ tupleAttributes tup) acc

964+ accNames = S.fromList $ map A.attributeName acc

965+ tupNames = A.attributeNameSet (tupleAttributes tup)

966+ attrNamesDiff = S.union (S.difference accNames tupNames) (S.difference tupNames accNames)

967+ unless (null attrNamesDiff) (throwError (AttributeNamesMismatchError attrNamesDiff))

968+ nextTupleAttrs <- mapM processTupleAttrs zipped

969+ let diff = A.attributesDifference (A.attributesFromList nextTupleAttrs) (A.attributesFromList acc)

970+ if diff == A.emptyAttributes then

971+ pure nextTupleAttrs

972+ else

973+ throwError (TupleAttributeTypeMismatchError diff)

974+ ) (V.toList . attributesVec $ tupleAttributes headTuple) tailTuples

975+ pure (A.attributesFromList mostResolvedTypes)

976+ --strategy: if all the tuple expr transaction markers refer to one location, then we can pass the type constructor mapping from that location, otherwise, we cannot assume that the types are the same

977+ tConsMap <- case singularTransactions tupleExprL of

978+ SingularTransactionRef commonTransId ->

979+ typeConstructorMapping <$> gfDatabaseContextForMarker commonTransId

980+ NoTransactionsRef ->

981+ typeConstructorMapping <$> gfDatabaseContextForMarker fixedMarker

982+ -- if there are multiple transaction markers in the TupleExprs, then we can't assume a single type constructor mapping- this could be improved in the future, but if all the tuples are fully resolved, then we don't need further resolution

983+ _ -> throwError TupleExprsReferenceMultipleMarkersError

984+ lift $ except $ validateAttributes tConsMap finalAttrs

985+ mapM (lift . except . resolveTypesInTuple finalAttrs tConsMap) tuples

986+

987+

988+--resolveAttributes (Attribute "gonk" (ConstructedAtomType "Either" (fromList [("a",IntegerAtomType),("b",TypeVariableType "b")]))) (Attribute "gonk" (ConstructedAtomType "Either" (fromList [("a",TypeVariableType "a"),("b",TextAtomType)])))

989+

1087evalGraphRefTupleExpr :: Maybe Attributes -> GraphRefTupleExpr -> GraphRefRelationalExprM RelationTuple

990evalGraphRefTupleExpr :: Maybe Attributes -> GraphRefTupleExpr -> GraphRefRelationalExprM RelationTuple

1088evalGraphRefTupleExpr mAttrs (TupleExpr tupMap) = do

991evalGraphRefTupleExpr mAttrs (TupleExpr tupMap) = do

1089 -- it's not possible for AtomExprs in tuple constructors to reference other Attributes' atoms due to the necessary order-of-operations (need a tuple to pass to evalAtomExpr)- it may be possible with some refactoring of type usage or delayed evaluation- needs more thought, but not a priority

992 -- it's not possible for AtomExprs in tuple constructors to reference other Attributes' atoms due to the necessary order-of-operations (need a tuple to pass to evalAtomExpr)- it may be possible with some refactoring of type usage or delayed evaluation- needs more thought, but not a priority

@@ -1108,62 +1011,12 @@ evalGraphRefTupleExpr mAttrs (TupleExpr tupMap) = do

1108 --verify that the attributes match

1011 --verify that the attributes match

1109 when (A.attributeNameSet finalAttrs /= A.attributeNameSet tupAttrs) $ throwError (TupleAttributeTypeMismatchError tupAttrs)

1012 when (A.attributeNameSet finalAttrs /= A.attributeNameSet tupAttrs) $ throwError (TupleAttributeTypeMismatchError tupAttrs)

1110 --we can't resolve types here- they have to be resolved at the atom level where the graph ref is held

1013 --we can't resolve types here- they have to be resolved at the atom level where the graph ref is held

1111−-- tup' <- lift $ except (resolveTypesInTuple finalAttrs tConss (reorderTuple finalAttrs tup))

1014+ --tup' <- lift $ except (resolveTypesInTuple finalAttrs tConss (reorderTuple finalAttrs tup))

1112 let tup' = reorderTuple finalAttrs tup

1015 let tup' = reorderTuple finalAttrs tup

1113 --TODO: restore type resolution

1016 --TODO: restore type resolution

1114-- _ <- lift $ except (validateTuple tup' tConss)

1017-- _ <- lift $ except (validateTuple tup' tConss)

1115 pure tup'

1018 pure tup'

1116

1019

1117−{-

1118−evalAttributeNames :: AttributeNames -> RelationalExpr -> RelationalExprM (Either RelationalError (S.Set AttributeName))

1119−evalAttributeNames attrNames expr = do

1120− eExprType <- typeForRelationalExpr expr

1121− case eExprType of

1122− Left err -> throwError err

1123− Right exprTyp -> do

1124− let typeNameSet = S.fromList (V.toList (A.attributeNames (attributes exprTyp)))

1125− case attrNames of

1126− AttributeNames names ->

1127− case A.projectionAttributesForNames names (attributes exprTyp) of

1128− Left err -> pure (Left err)

1129− Right attrs -> pure (Right (S.fromList (V.toList (A.attributeNames attrs))))

1130−

1131− InvertedAttributeNames names -> do

1132− let nonExistentAttributeNames = A.attributeNamesNotContained names typeNameSet

1133− if not (S.null nonExistentAttributeNames) then

1134− pure (Left (AttributeNamesMismatchError nonExistentAttributeNames))

1135− else

1136− pure (Right (A.nonMatchingAttributeNameSet names typeNameSet))

1137−

1138− UnionAttributeNames namesA namesB -> do

1139− eNameSetA <- evalAttributeNames namesA expr

1140− case eNameSetA of

1141− Left err -> pure (Left err)

1142− Right nameSetA -> do

1143− eNameSetB <- evalAttributeNames namesB expr

1144− case eNameSetB of

1145− Left err -> pure (Left err)

1146− Right nameSetB ->

1147− pure (Right (S.union nameSetA nameSetB))

1148−

1149− IntersectAttributeNames namesA namesB -> do

1150− eNameSetA <- evalAttributeNames namesA expr

1151− case eNameSetA of

1152− Left err -> pure (Left err)

1153− Right nameSetA -> do

1154− eNameSetB <- evalAttributeNames namesB expr

1155− case eNameSetB of

1156− Left err -> pure (Left err)

1157− Right nameSetB ->

1158− pure (Right (S.intersection nameSetA nameSetB))

1159−

1160− RelationalExprAttributeNames attrExpr -> do

1161− eAttrExprType <- typeForRelationalExpr attrExpr

1162− case eAttrExprType of

1163− Left err -> pure (Left err)

1164− Right attrExprType -> pure (Right (A.attributeNameSet (attributes attrExprType)))

1165−-}

1166−

1167--temporary implementation until we have a proper planner+executor

1020--temporary implementation until we have a proper planner+executor

1168evalGraphRefRelationalExpr :: GraphRefRelationalExpr -> GraphRefRelationalExprM Relation

1021evalGraphRefRelationalExpr :: GraphRefRelationalExpr -> GraphRefRelationalExprM Relation

1169evalGraphRefRelationalExpr (MakeRelationFromExprs mAttrExprs tupleExprs) = do

1022evalGraphRefRelationalExpr (MakeRelationFromExprs mAttrExprs tupleExprs) = do

@@ -1171,7 +1024,7 @@ evalGraphRefRelationalExpr (MakeRelationFromExprs mAttrExprs tupleExprs) = do

1171 Just _ ->

1024 Just _ ->

1172 Just . A.attributesFromList <$> mapM evalGraphRefAttrExpr (fromMaybe [] mAttrExprs)

1025 Just . A.attributesFromList <$> mapM evalGraphRefAttrExpr (fromMaybe [] mAttrExprs)

1173 Nothing -> pure Nothing

1026 Nothing -> pure Nothing

1174− tuples <- mapM (evalGraphRefTupleExpr mAttrs) tupleExprs

1027+ tuples <- evalGraphRefTupleExprs mAttrs tupleExprs

1175 let attrs = fromMaybe firstTupleAttrs mAttrs

1028 let attrs = fromMaybe firstTupleAttrs mAttrs

1176 firstTupleAttrs = if null tuples then A.emptyAttributes else tupleAttributes (head tuples)

1029 firstTupleAttrs = if null tuples then A.emptyAttributes else tupleAttributes (head tuples)

1177 lift $ except $ mkRelation attrs (RelationTupleSet tuples)

1030 lift $ except $ mkRelation attrs (RelationTupleSet tuples)

@@ -1179,7 +1032,7 @@ evalGraphRefRelationalExpr (MakeStaticRelation attributeSet tupleSet) =

1179 lift $ except $ mkRelation attributeSet tupleSet

1032 lift $ except $ mkRelation attributeSet tupleSet

1180evalGraphRefRelationalExpr (ExistingRelation rel) = pure rel

1033evalGraphRefRelationalExpr (ExistingRelation rel) = pure rel

1181evalGraphRefRelationalExpr (RelationVariable name tid) = do

1034evalGraphRefRelationalExpr (RelationVariable name tid) = do

1182− ctx <- concreteDatabaseContext <$> gfTransForId tid

1035+ ctx <- gfDatabaseContextForMarker tid

1183 case M.lookup name (relationVariables ctx) of

1036 case M.lookup name (relationVariables ctx) of

1184 Nothing -> throwError (RelVarNotDefinedError name)

1037 Nothing -> throwError (RelVarNotDefinedError name)

1185 Just rv -> evalGraphRefRelationalExpr rv

1038 Just rv -> evalGraphRefRelationalExpr rv

@@ -1225,7 +1078,7 @@ evalGraphRefRelationalExpr (Extend extendTupleExpr expr) = do

1225 rel <- evalGraphRefRelationalExpr expr

1078 rel <- evalGraphRefRelationalExpr expr

1226 (newAttrs, tupProc) <- extendGraphRefTupleExpressionProcessor rel extendTupleExpr

1079 (newAttrs, tupProc) <- extendGraphRefTupleExpressionProcessor rel extendTupleExpr

1227 lift $ except $ relMogrify tupProc newAttrs rel

1080 lift $ except $ relMogrify tupProc newAttrs rel

1228−evalGraphRefRelationalExpr expr@With{} = do

1081+evalGraphRefRelationalExpr expr@With{} =

1229 --strategy A: add relation variables to the contexts in the graph

1082 --strategy A: add relation variables to the contexts in the graph

1230 --strategy B: drop in macros in place (easier programmatically)

1083 --strategy B: drop in macros in place (easier programmatically)

1231 --strategy B implementation

1084 --strategy B implementation

@@ -1253,20 +1106,21 @@ typeForGraphRefRelationalExpr (ExistingRelation rel) = pure (emptyRelationWithAt

1253typeForGraphRefRelationalExpr (MakeRelationFromExprs mAttrExprs tupleExprs) = do

1106typeForGraphRefRelationalExpr (MakeRelationFromExprs mAttrExprs tupleExprs) = do

1254 mAttrs <- case mAttrExprs of

1107 mAttrs <- case mAttrExprs of

1255 Just attrExprs -> do

1108 Just attrExprs -> do

1256− attrs <- mapM (\e -> evalGraphRefAttributeExpr e) attrExprs

1109+ attrs <- mapM evalGraphRefAttributeExpr attrExprs

1257 pure (Just (attributesFromList attrs))

1110 pure (Just (attributesFromList attrs))

1258 Nothing -> pure Nothing

1111 Nothing -> pure Nothing

1259− tuples <- mapM (evalGraphRefTupleExpr mAttrs) tupleExprs

1112+ tuples <- evalGraphRefTupleExprs mAttrs tupleExprs

1260 let retAttrs = case tuples of

1113 let retAttrs = case tuples of

1261 (tup:_) -> tupleAttributes tup

1114 (tup:_) -> tupleAttributes tup

1262 [] -> fromMaybe A.emptyAttributes mAttrs

1115 [] -> fromMaybe A.emptyAttributes mAttrs

1263 pure $ emptyRelationWithAttrs retAttrs

1116 pure $ emptyRelationWithAttrs retAttrs

1264

1117

1265typeForGraphRefRelationalExpr (RelationVariable rvName tid) = do

1118typeForGraphRefRelationalExpr (RelationVariable rvName tid) = do

1266− relVars <- relationVariables . concreteDatabaseContext <$> gfTransForId tid

1119+ relVars <- relationVariables <$> gfDatabaseContextForMarker tid

1267 case M.lookup rvName relVars of

1120 case M.lookup rvName relVars of

1268 Nothing -> throwError (RelVarNotDefinedError rvName)

1121 Nothing -> throwError (RelVarNotDefinedError rvName)

1122+ Just rvExpr ->

1269− Just rvExpr -> typeForGraphRefRelationalExpr rvExpr

1123+ typeForGraphRefRelationalExpr rvExpr

1270typeForGraphRefRelationalExpr (Project attrNames expr) = do

1124typeForGraphRefRelationalExpr (Project attrNames expr) = do

1271 exprType' <- typeForGraphRefRelationalExpr expr

1125 exprType' <- typeForGraphRefRelationalExpr expr

1272 projectionAttrs <- evalGraphRefAttributeNames attrNames expr

1126 projectionAttrs <- evalGraphRefAttributeNames attrNames expr

@@ -1297,15 +1151,21 @@ typeForGraphRefRelationalExpr (Restrict pred' expr) = do

1297 expr' <- typeForGraphRefRelationalExpr expr

1151 expr' <- typeForGraphRefRelationalExpr expr

1298 filt <- predicateRestrictionFilter (attributes expr') pred'

1152 filt <- predicateRestrictionFilter (attributes expr') pred'

1299 lift $ except $ restrict filt expr'

1153 lift $ except $ restrict filt expr'

1300−typeForGraphRefRelationalExpr Equals{} = do

1154+typeForGraphRefRelationalExpr Equals{} =

1301 pure relationFalse

1155 pure relationFalse

1302−typeForGraphRefRelationalExpr NotEquals{} = do

1156+typeForGraphRefRelationalExpr NotEquals{} =

1303 pure relationFalse

1157 pure relationFalse

1304typeForGraphRefRelationalExpr (Extend extendTupleExpr expr) = do

1158typeForGraphRefRelationalExpr (Extend extendTupleExpr expr) = do

1305 rel <- typeForGraphRefRelationalExpr expr

1159 rel <- typeForGraphRefRelationalExpr expr

1306 evalGraphRefRelationalExpr (Extend extendTupleExpr (ExistingRelation rel))

1160 evalGraphRefRelationalExpr (Extend extendTupleExpr (ExistingRelation rel))

1307−typeForGraphRefRelationalExpr expr@With{} = do

1161+typeForGraphRefRelationalExpr expr@(With withs _) = do

1308 let expr' = substituteWithNameMacros [] expr

1162 let expr' = substituteWithNameMacros [] expr

1163+ checkMacroName (WithNameExpr macroName tid) = do

1164+ rvs <- relationVariables <$> gfDatabaseContextForMarker tid

1165+ case M.lookup macroName rvs of

1166+ Just _ -> lift $ except $ Left (RelVarAlreadyDefinedError macroName) --this error does not include the transaction marker, but should be good enough to identify the cause

1167+ Nothing -> pure ()

1168+ mapM_ (checkMacroName . fst) withs

1309 typeForGraphRefRelationalExpr expr'

1169 typeForGraphRefRelationalExpr expr'

1310

1170

1311evalGraphRefAttributeNames :: GraphRefAttributeNames -> GraphRefRelationalExpr -> GraphRefRelationalExprM (S.Set AttributeName)

1171evalGraphRefAttributeNames :: GraphRefAttributeNames -> GraphRefRelationalExpr -> GraphRefRelationalExprM (S.Set AttributeName)

@@ -1321,7 +1181,7 @@ evalGraphRefAttributeNames attrNames expr = do

1321 InvertedAttributeNames names -> do

1181 InvertedAttributeNames names -> do

1322 let nonExistentAttributeNames = A.attributeNamesNotContained names typeNameSet

1182 let nonExistentAttributeNames = A.attributeNamesNotContained names typeNameSet

1323 if not (S.null nonExistentAttributeNames) then

1183 if not (S.null nonExistentAttributeNames) then

1324− throwError (AttributeNamesMismatchError nonExistentAttributeNames)

1184+ throwError $ AttributeNamesMismatchError nonExistentAttributeNames

1325 else

1185 else

1326 pure (A.nonMatchingAttributeNameSet names typeNameSet)

1186 pure (A.nonMatchingAttributeNameSet names typeNameSet)

1327

1187

@@ -1341,7 +1201,7 @@ evalGraphRefAttributeNames attrNames expr = do

1341

1201

1342evalGraphRefAttributeExpr :: GraphRefAttributeExpr -> GraphRefRelationalExprM Attribute

1202evalGraphRefAttributeExpr :: GraphRefAttributeExpr -> GraphRefRelationalExprM Attribute

1343evalGraphRefAttributeExpr (AttributeAndTypeNameExpr attrName tCons tid) = do

1203evalGraphRefAttributeExpr (AttributeAndTypeNameExpr attrName tCons tid) = do

1344− tConsMap <- typeConstructorMapping . concreteDatabaseContext <$> gfTransForId tid

1204+ tConsMap <- typeConstructorMapping <$> gfDatabaseContextForMarker tid

1345 case atomTypeForTypeConstructorValidate True tCons tConsMap M.empty of

1205 case atomTypeForTypeConstructorValidate True tCons tConsMap M.empty of

1346 Left err -> throwError err

1206 Left err -> throwError err

1347 Right aType -> do

1207 Right aType -> do

@@ -1351,9 +1211,9 @@ evalGraphRefAttributeExpr (AttributeAndTypeNameExpr attrName tCons tid) = do

1351evalGraphRefAttributeExpr (NakedAttributeExpr attr) = pure attr

1211evalGraphRefAttributeExpr (NakedAttributeExpr attr) = pure attr

1352

1212

1353mkEmptyRelVars :: RelationVariables -> RelationVariables

1213mkEmptyRelVars :: RelationVariables -> RelationVariables

1354−mkEmptyRelVars rvMap = M.map mkEmptyRelVar rvMap

1214+mkEmptyRelVars = M.map mkEmptyRelVar

1355 where

1215 where

1356− mkEmptyRelVar (MakeRelationFromExprs mAttrs _) = MakeRelationFromExprs mAttrs []

1216+ mkEmptyRelVar expr@MakeRelationFromExprs{} = expr --do not truncate here because we might lose essential type information in emptying the tuples

1357 mkEmptyRelVar (MakeStaticRelation attrs _) = MakeStaticRelation attrs emptyTupleSet

1217 mkEmptyRelVar (MakeStaticRelation attrs _) = MakeStaticRelation attrs emptyTupleSet

1358 mkEmptyRelVar (ExistingRelation rel) = ExistingRelation (emptyRelationWithAttrs (attributes rel))

1218 mkEmptyRelVar (ExistingRelation rel) = ExistingRelation (emptyRelationWithAttrs (attributes rel))

1359 mkEmptyRelVar rv@RelationVariable{} = Restrict (NotPredicate TruePredicate) rv

1219 mkEmptyRelVar rv@RelationVariable{} = Restrict (NotPredicate TruePredicate) rv

@@ -1368,28 +1228,165 @@ mkEmptyRelVars rvMap = M.map mkEmptyRelVar rvMap

1368 mkEmptyRelVar (Equals exprA exprB) = Equals (mkEmptyRelVar exprA) (mkEmptyRelVar exprB)

1228 mkEmptyRelVar (Equals exprA exprB) = Equals (mkEmptyRelVar exprA) (mkEmptyRelVar exprB)

1369 mkEmptyRelVar (NotEquals exprA exprB) = NotEquals (mkEmptyRelVar exprA) (mkEmptyRelVar exprB)

1229 mkEmptyRelVar (NotEquals exprA exprB) = NotEquals (mkEmptyRelVar exprA) (mkEmptyRelVar exprB)

1370 mkEmptyRelVar (Extend extTuple expr) = Extend extTuple (mkEmptyRelVar expr)

1230 mkEmptyRelVar (Extend extTuple expr) = Extend extTuple (mkEmptyRelVar expr)

1371− mkEmptyRelVar (With macros expr) = With (map (\(rv, expr') -> (rv, mkEmptyRelVar expr')) macros) (mkEmptyRelVar expr)

1231+ mkEmptyRelVar (With macros expr) = With (map (second mkEmptyRelVar) macros) (mkEmptyRelVar expr)

1372

1232

1373

1233

1374dbErr :: RelationalError -> DatabaseContextEvalMonad ()

1234dbErr :: RelationalError -> DatabaseContextEvalMonad ()

1375dbErr err = lift (except (Left err))

1235dbErr err = lift (except (Left err))

1376

1236

1377-- | Return a Relation describing the relation variables.

1237-- | Return a Relation describing the relation variables.

1378−relationVariablesAsRelation :: RelationVariables -> TransactionGraph -> Either RelationalError Relation

1238+relationVariablesAsRelation :: DatabaseContext -> TransactionGraph -> Either RelationalError Relation

1379−relationVariablesAsRelation relVarMap graph = do

1239+relationVariablesAsRelation ctx graph = do

1380 let subrelAttrs = A.attributesFromList [Attribute "attribute" TextAtomType, Attribute "type" TextAtomType]

1240 let subrelAttrs = A.attributesFromList [Attribute "attribute" TextAtomType, Attribute "type" TextAtomType]

1381 attrs = A.attributesFromList [Attribute "name" TextAtomType,

1241 attrs = A.attributesFromList [Attribute "name" TextAtomType,

1382 Attribute "attributes" (RelationAtomType subrelAttrs)]

1242 Attribute "attributes" (RelationAtomType subrelAttrs)]

1243+ relVars = relationVariables ctx

1383 mkRvDesc (rvName, gfExpr) = do

1244 mkRvDesc (rvName, gfExpr) = do

1384− let gfEnv = freshGraphRefRelationalExprEnv graph

1245+ let gfEnv = freshGraphRefRelationalExprEnv (Just ctx) graph

1385 gfType <- runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr gfExpr)

1246 gfType <- runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr gfExpr)

1386 pure (rvName, gfType)

1247 pure (rvName, gfType)

1387− relVarToAtomList (rvName, rel) = [TextAtom rvName, attributesToRel (attributes rel)]

1248+ relVarToAtomList (rvName, rel) = [TextAtom rvName, attributesToRel (attributesVec (attributes rel))]

1388 attrAtoms a = [TextAtom (A.attributeName a), TextAtom (prettyAtomType (A.atomType a))]

1249 attrAtoms a = [TextAtom (A.attributeName a), TextAtom (prettyAtomType (A.atomType a))]

1389 attributesToRel attrl = case mkRelationFromList subrelAttrs (map attrAtoms (V.toList attrl)) of

1250 attributesToRel attrl = case mkRelationFromList subrelAttrs (map attrAtoms (V.toList attrl)) of

1390 Left err -> error ("relationVariablesAsRelation pooped " ++ show err)

1251 Left err -> error ("relationVariablesAsRelation pooped " ++ show err)

1391 Right rel -> RelationAtom rel

1252 Right rel -> RelationAtom rel

1392− rvs <- mapM mkRvDesc (M.toList relVarMap)

1253+ rvs <- mapM mkRvDesc (M.toList relVars)

1393 let tups = map relVarToAtomList rvs

1254 let tups = map relVarToAtomList rvs

1394 mkRelationFromList attrs tups

1255 mkRelationFromList attrs tups

1395

1256

1257+-- | An unoptimized variant of evalGraphRefRelationalExpr for testing.

1258+evalRelationalExpr :: RelationalExpr -> RelationalExprM Relation

1259+evalRelationalExpr expr = do

1260+ graph <- reGraph

1261+ context <- reContext

1262+ let expr' = runProcessExprM UncommittedContextMarker (processRelationalExpr expr)

1263+ gfEnv = freshGraphRefRelationalExprEnv (Just context) graph

1264+ case runGraphRefRelationalExprM gfEnv (evalGraphRefRelationalExpr expr') of

1265+ Left err -> throwError err

1266+ Right rel -> pure rel

1267+

1268+class (MonadError RelationalError m, Monad m) => DatabaseContextM m where

1269+ getContext :: m DatabaseContext

1270+

1271+instance DatabaseContextM (ReaderT GraphRefRelationalExprEnv (ExceptT RelationalError Identity)) where

1272+ getContext = gfDatabaseContextForMarker UncommittedContextMarker

1273+

1274+instance DatabaseContextM (RWST DatabaseContextEvalEnv () DatabaseContextEvalState (ExceptT RelationalError Identity)) where

1275+ getContext = getStateContext

1276+

1277+relVarByName :: DatabaseContextM m => RelVarName -> m GraphRefRelationalExpr

1278+relVarByName rvName = do

1279+ relvars <- relationVariables <$> getContext

1280+ case M.lookup rvName relvars of

1281+ Nothing -> throwError (RelVarNotDefinedError rvName)

1282+ Just gfexpr -> pure gfexpr

1283+

1284+-- | resolve UncommittedTransactionMarker whenever possible- this is important in the DatabaseContext in order to mitigate self-referencing loops for updates

1285+class ResolveGraphRefTransactionMarker a where

1286+ resolve :: a -> DatabaseContextEvalMonad a

1287+

1288+-- s := s union t

1289+instance ResolveGraphRefTransactionMarker GraphRefRelationalExpr where

1290+ resolve (MakeRelationFromExprs mAttrs tupleExprs) =

1291+ MakeRelationFromExprs mAttrs <$> resolve tupleExprs

1292+ resolve orig@MakeStaticRelation{} = pure orig

1293+ resolve orig@ExistingRelation{} = pure orig

1294+ resolve orig@(RelationVariable rvName UncommittedContextMarker) = do

1295+ rvMap <- relationVariables <$> getStateContext

1296+ case M.lookup rvName rvMap of

1297+ Nothing -> pure orig

1298+ Just resolvedRv -> resolve resolvedRv

1299+ resolve orig@RelationVariable{} = pure orig

1300+ resolve (Project attrNames relExpr) = Project <$> resolve attrNames <*> resolve relExpr

1301+ resolve (Union exprA exprB) = Union <$> resolve exprA <*> resolve exprB

1302+ resolve (Join exprA exprB) = Join <$> resolve exprA <*> resolve exprB

1303+ resolve (Rename attrA attrB expr) = Rename attrA attrB <$> resolve expr

1304+ resolve (Difference exprA exprB) = Difference <$> resolve exprA <*> resolve exprB

1305+ resolve (Group namesA nameB expr) = Group <$> resolve namesA <*> pure nameB <*> resolve expr

1306+ resolve (Ungroup nameA expr) = Ungroup nameA <$> resolve expr

1307+ resolve (Restrict restrictExpr relExpr) = Restrict <$> resolve restrictExpr <*> resolve relExpr

1308+ resolve (Equals exprA exprB) = Equals <$> resolve exprA <*> resolve exprB

1309+ resolve (NotEquals exprA exprB) = NotEquals <$> resolve exprA <*> resolve exprB

1310+ resolve (Extend extendExpr relExpr) = Extend <$> resolve extendExpr <*> resolve relExpr

1311+ resolve (With withExprs relExpr) = With <$> mapM (\(nam, expr) -> (,) <$> resolve nam <*> resolve expr) withExprs <*> resolve relExpr

1312+

1313+instance ResolveGraphRefTransactionMarker GraphRefTupleExprs where

1314+ resolve (TupleExprs marker tupleExprs) =

1315+ TupleExprs marker <$> mapM resolve tupleExprs

1316+

1317+instance ResolveGraphRefTransactionMarker GraphRefTupleExpr where

1318+ resolve (TupleExpr tupMap) = do

1319+ tupMap' <- mapM (\(attrName, expr) -> (,) attrName <$> resolve expr ) (M.toList tupMap)

1320+ pure (TupleExpr (M.fromList tupMap'))

1321+

1322+instance ResolveGraphRefTransactionMarker GraphRefAttributeNames where

1323+ resolve orig@AttributeNames{} = pure orig

1324+ resolve orig@InvertedAttributeNames{} = pure orig

1325+ resolve (UnionAttributeNames namesA namesB) = UnionAttributeNames <$> resolve namesA <*> resolve namesB

1326+ resolve (IntersectAttributeNames namesA namesB) = IntersectAttributeNames <$> resolve namesA <*> resolve namesB

1327+ resolve (RelationalExprAttributeNames expr) = RelationalExprAttributeNames <$> resolve expr

1328+

1329+instance ResolveGraphRefTransactionMarker GraphRefRestrictionPredicateExpr where

1330+ resolve TruePredicate = pure TruePredicate

1331+ resolve (AndPredicate exprA exprB) = AndPredicate <$> resolve exprA <*> resolve exprB

1332+ resolve (OrPredicate exprA exprB) = OrPredicate <$> resolve exprA <*> resolve exprB

1333+ resolve (NotPredicate expr) = NotPredicate <$> resolve expr

1334+ resolve (RelationalExprPredicate expr) = RelationalExprPredicate <$> resolve expr

1335+ resolve (AtomExprPredicate expr) = AtomExprPredicate <$> resolve expr

1336+ resolve (AttributeEqualityPredicate nam expr)= AttributeEqualityPredicate nam <$> resolve expr

1337+

1338+instance ResolveGraphRefTransactionMarker GraphRefExtendTupleExpr where

1339+ resolve (AttributeExtendTupleExpr nam atomExpr) = AttributeExtendTupleExpr nam <$> resolve atomExpr

1340+

1341+instance ResolveGraphRefTransactionMarker GraphRefWithNameExpr where

1342+ resolve orig@WithNameExpr{} = pure orig -- match uncommitted marker?

1343+

1344+instance ResolveGraphRefTransactionMarker GraphRefAtomExpr where

1345+ resolve orig@AttributeAtomExpr{} = pure orig

1346+ resolve orig@NakedAtomExpr{} = pure orig

1347+ resolve (FunctionAtomExpr nam atomExprs marker) =

1348+ FunctionAtomExpr nam <$> mapM resolve atomExprs <*> pure marker

1349+ resolve (RelationAtomExpr expr) = RelationAtomExpr <$> resolve expr

1350+ resolve (ConstructedAtomExpr dConsName atomExprs marker) =

1351+ ConstructedAtomExpr dConsName <$> mapM resolve atomExprs <*> pure marker

1352+

1353+--convert series of simple Union queries into MakeStaticRelation

1354+-- this is especially useful for long, nested applications of Union with simple tuples

1355+-- Union (MakeRelation x y) (MakeRelation x y') -> MakeRelation x (y + y')

1356+

1357+--MakeRelationFromExprs Nothing (TupleExprs UncommittedContextMarker [TupleExpr (fromList [("name", NakedAtomExpr (TextAtom "steve"))])])

1358+

1359+applyUnionCollapse :: GraphRefRelationalExpr -> GraphRefRelationalExpr

1360+applyUnionCollapse = Fold.cata opt

1361+ where

1362+ opt :: RelationalExprBaseF GraphRefTransactionMarker GraphRefRelationalExpr -> GraphRefRelationalExpr

1363+ opt (UnionF exprA exprB) | exprA == exprB = exprA

1364+ opt (UnionF

1365+ exprA@(MakeRelationFromExprs mAttrs1 tupExprs1)

1366+ exprB@(MakeRelationFromExprs mAttrs2 tupExprs2)) | tupExprs1 == tupExprs2 = MakeRelationFromExprs (mAttrs1 <|> mAttrs2) tupExprs1

1367+ | tupExprsNull tupExprs1 = exprB

1368+ | tupExprsNull tupExprs2 = exprA

1369+ opt x = Fold.embed x

1370+ tupExprsNull (TupleExprs _ []) = True

1371+ tupExprsNull _ = False

1372+

1373+

1374+--UPDATE optimization- find matching where clause in "lower" levels of renaming

1375+--update x where y=1 set (x:=5,z:=10); update x where y=1 set(x:=6,z:=11)

1376+-- =>

1377+-- update x where y=1 set (x:=6,z:=11)

1378+-- future opt: match individual attributes update x where y=1 set (x:=5); update x where y=1 set (z:=11) => update x where y=1 set (x:=5,z:=11)

1379+

1380+--strategy: try to collapse the top-level update (union (restrict pred MakeRelationFromExpr) expr) if it contains the same predicate and resultant relation

1381+

1382+--DELETE optimization

1383+-- if a restriction matches a previous restriction, combine them

1384+-- O(1) since it only scans at the top level, critical in benchmarks generating redundant deletions

1385+applyRestrictionCollapse :: GraphRefRelationalExpr -> GraphRefRelationalExpr

1386+applyRestrictionCollapse orig@(Restrict npred@(NotPredicate _) expr) =

1387+ case expr of

1388+ orig'@(Restrict npred'@(NotPredicate _) _) | npred == npred' -> orig'

1389+ _ -> orig

1390+applyRestrictionCollapse expr = expr

1391+

1392+

src/lib/ProjectM36/ScriptSession.hs+72−44

@@ -1,8 +1,12 @@

1−{-# LANGUAGE MagicHash, UnboxedTuples #-}

1+{-# LANGUAGE UnboxedTuples, KindSignatures, DataKinds #-}

2+#ifdef PM36_HASKELL_SCRIPTING

3+{-# LANGUAGE MagicHash #-}

4+#endif

2module ProjectM36.ScriptSession where

5module ProjectM36.ScriptSession where

3

6

7+#ifdef PM36_HASKELL_SCRIPTING

4import ProjectM36.Error

8import ProjectM36.Error

5−

9+import GHC

6import Control.Exception

10import Control.Exception

7import Control.Monad

11import Control.Monad

8import System.IO.Error

12import System.IO.Error

@@ -13,9 +17,8 @@ import System.FilePath

13import System.Info (os, arch)

17import System.Info (os, arch)

14import Data.Text (Text, unpack)

18import Data.Text (Text, unpack)

15import Data.Maybe

19import Data.Maybe

16−

17−import GHC

18import GHC.Paths (libdir)

20import GHC.Paths (libdir)

21+import System.Environment

19#if __GLASGOW_HASKELL__ >= 800

22#if __GLASGOW_HASKELL__ >= 800

20import GHC.LanguageExtensions

23import GHC.LanguageExtensions

21import GHCi.ObjLink

24import GHCi.ObjLink

@@ -33,25 +36,41 @@ import Unsafe.Coerce

33#if __GLASGOW_HASKELL__ >= 802

36#if __GLASGOW_HASKELL__ >= 802

34import Type

37import Type

35#elif __GLASGOW_HASKELL__ >= 710

38#elif __GLASGOW_HASKELL__ >= 710

36−import Type hiding (pprTyThing)

39+import Type hiding (pprTyThing)

37#else

40#else

38#endif

41#endif

39−

40import GHC.Exts (addrToAny#)

42import GHC.Exts (addrToAny#)

41import GHC.Ptr (Ptr(..))

43import GHC.Ptr (Ptr(..))

42import Encoding

44import Encoding

45+#endif

46+

43

47

44data ScriptSession = ScriptSession {

48data ScriptSession = ScriptSession {

49+#ifdef PM36_HASKELL_SCRIPTING

45− hscEnv :: HscEnv,

50+ hscEnv :: HscEnv,

46 atomFunctionBodyType :: Type,

51 atomFunctionBodyType :: Type,

47 dbcFunctionBodyType :: Type

52 dbcFunctionBodyType :: Type

53+#endif

48 }

54 }

49−

55+

56+#ifdef PM36_HASKELL_SCRIPTING

50−newtype ScriptSessionError = ScriptSessionLoadError GhcException

57+data ScriptSessionError = ScriptSessionLoadError GhcException

58+ | ScriptingDisabled

51 deriving (Show)

59 deriving (Show)

60+#else

61+data ScriptSessionError = ScriptingDisabled

62+ deriving (Show)

63+#endif

64+

65+data LoadSymbolError = LoadSymbolError

66+type ModName = String

67+type FuncName = String

52

68

53-- | Configure a GHC environment/session which we will use for all script compilation.

69-- | Configure a GHC environment/session which we will use for all script compilation.

54initScriptSession :: [String] -> IO (Either ScriptSessionError ScriptSession)

70initScriptSession :: [String] -> IO (Either ScriptSessionError ScriptSession)

71+#if !defined(PM36_HASKELL_SCRIPTING)

72+initScriptSession _ = pure (Left ScriptingDisabled)

73+#else

55initScriptSession ghcPkgPaths = do

74initScriptSession ghcPkgPaths = do

56 --for the sake of convenience, for developers' builds, include the local cabal sandbox package database and the cabal new-build package database

75 --for the sake of convenience, for developers' builds, include the local cabal sandbox package database and the cabal new-build package database

57 eHomeDir <- tryJust (guard . isDoesNotExistError) getHomeDirectory

76 eHomeDir <- tryJust (guard . isDoesNotExistError) getHomeDirectory

@@ -60,28 +79,30 @@ initScriptSession ghcPkgPaths = do

60 handleGhcException excHandler $ runGhc (Just libdir) $ do

79 handleGhcException excHandler $ runGhc (Just libdir) $ do

61 dflags <- getSessionDynFlags

80 dflags <- getSessionDynFlags

62 let ghcVersion = projectVersion dflags

81 let ghcVersion = projectVersion dflags

82+ -- get nix packages dir, if available

83+ mNixLibDir <- liftIO $ lookupEnv "NIX_GHC_LIBDIR"

63

84

64 sandboxPkgPaths <- liftIO $ concat <$> mapM glob [

85 sandboxPkgPaths <- liftIO $ concat <$> mapM glob [

65− "./dist-newstyle/packagedb/ghc-" ++ ghcVersion,

86+ --"./dist-newstyle/packagedb/ghc-" ++ ghcVersion, --rely on cabal 3's ghc.environment install: "cabal install --lib project-m36"

66 ".cabal-sandbox/*ghc-" ++ ghcVersion ++ "-packages.conf.d",

87 ".cabal-sandbox/*ghc-" ++ ghcVersion ++ "-packages.conf.d",

67 ".stack-work/install/*/*/" ++ ghcVersion ++ "/pkgdb",

88 ".stack-work/install/*/*/" ++ ghcVersion ++ "/pkgdb",

68 ".stack-work/install/*/pkgdb/", --windows stack build

89 ".stack-work/install/*/pkgdb/", --windows stack build

69 "C:/sr/snapshots/b201cfe6/pkgdb", --windows stack build- ideally, we could run `stack path --snapshot-pkg-db, but this is sufficient to pass CI

90 "C:/sr/snapshots/b201cfe6/pkgdb", --windows stack build- ideally, we could run `stack path --snapshot-pkg-db, but this is sufficient to pass CI

70− homeDir </> ".stack/snapshots/*/*/" ++ ghcVersion ++ "/pkgdb",

91+ homeDir </> ".stack/snapshots/*/*/" ++ ghcVersion ++ "/pkgdb"

71− homeDir </> ".cabal/store/ghc-" ++ ghcVersion ++ "/package.db"

92+ --homeDir </> ".cabal/store/ghc-" ++ ghcVersion ++ "/package.db"

72 ]

93 ]

73−

94+

74− let localPkgPaths = map PkgConfFile (ghcPkgPaths ++ sandboxPkgPaths)

95+ let localPkgPaths = map PkgConfFile (ghcPkgPaths ++ sandboxPkgPaths ++ maybeToList mNixLibDir)

75−

96+

76− let dflags' = applyGopts . applyXopts $ dflags { hscTarget = HscInterpreted ,

97+ let dflags' = applyGopts . applyXopts $ dflags { hscTarget = HscInterpreted ,

77− ghcLink = LinkInMemory,

98+ ghcLink = LinkInMemory,

78 safeHaskell = Sf_Trustworthy,

99 safeHaskell = Sf_Trustworthy,

79 safeInfer = True,

100 safeInfer = True,

80 safeInferred = True,

101 safeInferred = True,

81 --verbosity = 3,

102 --verbosity = 3,

82−#if __GLASGOW_HASKELL__ >= 800

103+#if __GLASGOW_HASKELL__ >= 800

83 trustFlags = map TrustPackage required_packages,

104 trustFlags = map TrustPackage required_packages,

84−#endif

105+#endif

85 packageFlags = packageFlags dflags ++ packages,

106 packageFlags = packageFlags dflags ++ packages,

86#if __GLASGOW_HASKELL__ >= 802

107#if __GLASGOW_HASKELL__ >= 802

87 packageDBFlags = map PackageDB localPkgPaths

108 packageDBFlags = map PackageDB localPkgPaths

@@ -94,11 +115,11 @@ initScriptSession ghcPkgPaths = do

94 applyXopts flags = foldl xopt_set flags xopts

115 applyXopts flags = foldl xopt_set flags xopts

95#if __GLASGOW_HASKELL__ >= 800

116#if __GLASGOW_HASKELL__ >= 800

96 xopts = [OverloadedStrings, ExtendedDefaultRules, ImplicitPrelude, ScopedTypeVariables]

117 xopts = [OverloadedStrings, ExtendedDefaultRules, ImplicitPrelude, ScopedTypeVariables]

97−#else

118+#else

98 xopts = [Opt_OverloadedStrings, Opt_ExtendedDefaultRules, Opt_ImplicitPrelude, Opt_ScopedTypeVariables]

119 xopts = [Opt_OverloadedStrings, Opt_ExtendedDefaultRules, Opt_ImplicitPrelude, Opt_ScopedTypeVariables]

99#endif

120#endif

100 gopts = [] --[Opt_DistrustAllPackages, Opt_PackageTrust]

121 gopts = [] --[Opt_DistrustAllPackages, Opt_PackageTrust]

101− required_packages = ["base",

122+ required_packages = ["base",

102 "containers",

123 "containers",

103 "Glob",

124 "Glob",

104 "directory",

125 "directory",

@@ -107,8 +128,6 @@ initScriptSession ghcPkgPaths = do

107 "uuid",

128 "uuid",

108 "vector",

129 "vector",

109 "text",

130 "text",

110− "binary",

111− "vector-binary-instances",

112 "time",

131 "time",

113 "project-m36",

132 "project-m36",

114 "bytestring"]

133 "bytestring"]

@@ -120,20 +139,33 @@ initScriptSession ghcPkgPaths = do

120 --liftIO $ traceShowM (showSDoc dflags' (ppr packages))

139 --liftIO $ traceShowM (showSDoc dflags' (ppr packages))

121 _ <- setSessionDynFlags dflags'

140 _ <- setSessionDynFlags dflags'

122 let safeImportDecl mn mQual = ImportDecl {

141 let safeImportDecl mn mQual = ImportDecl {

123−#if __GLASGOW_HASKELL__ >= 802

142+#if __GLASGOW_HASKELL__ >= 802

124 ideclSourceSrc = NoSourceText,

143 ideclSourceSrc = NoSourceText,

125#else

144#else

126 ideclSourceSrc = Nothing,

145 ideclSourceSrc = Nothing,

127#endif

146#endif

147+

148+#if __GLASGOW_HASKELL__ >= 810

149+ ideclExt = noExtField,

150+#elif __GLASGOW_HASKELL__ >= 806

151+ ideclExt = NoExt,

152+#endif

128 ideclName = noLoc mn,

153 ideclName = noLoc mn,

129 ideclPkgQual = Nothing,

154 ideclPkgQual = Nothing,

130 ideclSource = False,

155 ideclSource = False,

131 ideclSafe = True,

156 ideclSafe = True,

132 ideclImplicit = False,

157 ideclImplicit = False,

158+#if __GLASGOW_HASKELL__ >= 810

159+ ideclQualified = if isJust mQual then QualifiedPre else NotQualified,

160+#else

133 ideclQualified = isJust mQual,

161 ideclQualified = isJust mQual,

162+#endif

134 ideclAs = mQual,

163 ideclAs = mQual,

135 ideclHiding = Nothing

164 ideclHiding = Nothing

136 }

165 }

166+#if __GLASGOW_HASKELL__ >= 806

167+ :: ImportDecl (GhcPass (c :: Pass))

168+#endif

137 unqualifiedModules = map (\modn -> IIDecl $ safeImportDecl (mkModuleName modn) Nothing) [

169 unqualifiedModules = map (\modn -> IIDecl $ safeImportDecl (mkModuleName modn) Nothing) [

138 "Prelude",

170 "Prelude",

139 "Data.Map",

171 "Data.Map",

@@ -150,7 +182,7 @@ initScriptSession ghcPkgPaths = do

150 mkModName = noLoc . mkModuleName

182 mkModName = noLoc . mkModuleName

151#else

183#else

152 mkModName = mkModuleName

184 mkModName = mkModuleName

153−#endif

185+#endif

154 qualifiedModules = map (\(modn, qualNam) -> IIDecl $ safeImportDecl (mkModuleName modn) (Just (mkModName qualNam))) [

186 qualifiedModules = map (\(modn, qualNam) -> IIDecl $ safeImportDecl (mkModuleName modn) (Just (mkModName qualNam))) [

155 ("Data.Text", "T")

187 ("Data.Text", "T")

156 ]

188 ]

@@ -163,8 +195,8 @@ initScriptSession ghcPkgPaths = do

163addImport :: String -> Ghc ()

195addImport :: String -> Ghc ()

164addImport moduleNam = do

196addImport moduleNam = do

165 ctx <- getContext

197 ctx <- getContext

166− setContext ( (IIDecl $ simpleImportDecl (mkModuleName moduleNam)) : ctx )

198+ setContext (IIDecl (simpleImportDecl (mkModuleName moduleNam)) : ctx)

167−

199+

168showType :: DynFlags -> Type -> String

200showType :: DynFlags -> Type -> String

169showType dflags ty = showSDocForUser dflags alwaysQualify (pprTypeForUser ty)

201showType dflags ty = showSDocForUser dflags alwaysQualify (pprTypeForUser ty)

170

202

@@ -189,41 +221,36 @@ compileScript funcType script = do

189 mErr <- typeCheckScript funcType script

221 mErr <- typeCheckScript funcType script

190 case mErr of

222 case mErr of

191 Just err -> pure (Left err)

223 Just err -> pure (Left err)

192− Nothing ->

224+ Nothing ->

193 --catch exception here

225 --catch exception here

194 --we could potentially wrap the script with Atom pattern matching so that the script doesn't have to do it, but the change to an Atom ADT should make it easier. Still, it would be nice if the script didn't have to handle a list of arguments, for example.

226 --we could potentially wrap the script with Atom pattern matching so that the script doesn't have to do it, but the change to an Atom ADT should make it easier. Still, it would be nice if the script didn't have to handle a list of arguments, for example.

195 -- we can't use dynCompileExpr here because

227 -- we can't use dynCompileExpr here because

196 Right . unsafeCoerce <$> compileExpr sScript

228 Right . unsafeCoerce <$> compileExpr sScript

197−

229+

198−typeCheckScript :: Type -> Text -> Ghc (Maybe ScriptCompilationError)

230+typeCheckScript :: Type -> Text -> Ghc (Maybe ScriptCompilationError)

199typeCheckScript expectedType inp = do

231typeCheckScript expectedType inp = do

200− dflags <- getSessionDynFlags

232+ dflags <- getSessionDynFlags

201 --catch exception for SyntaxError

233 --catch exception for SyntaxError

202#if __GLASGOW_HASKELL__ >= 802

234#if __GLASGOW_HASKELL__ >= 802

203− funcType <- GHC.exprType TM_Inst (unpack inp)

235+ funcType <- GHC.exprType TM_Inst (unpack inp)

204−#else

236+#else

205 funcType <- GHC.exprType (unpack inp)

237 funcType <- GHC.exprType (unpack inp)

206#endif

238#endif

207− --liftIO $ putStrLn $ showType dflags expectedType ++ ":::" ++ showType dflags funcType

239+ --liftIO $ putStrLn $ showType dflags expectedType ++ ":::" ++ showType dflags funcType

208 if eqType funcType expectedType then

240 if eqType funcType expectedType then

209 pure Nothing

241 pure Nothing

210 else

242 else

211 pure (Just (TypeCheckCompilationError (showType dflags expectedType) (showType dflags funcType)))

243 pure (Just (TypeCheckCompilationError (showType dflags expectedType) (showType dflags funcType)))

212−

244+

213mangleSymbol :: Maybe String -> String -> String -> String

245mangleSymbol :: Maybe String -> String -> String -> String

214mangleSymbol pkg module' valsym =

246mangleSymbol pkg module' valsym =

215 prefixUnderscore ++

247 prefixUnderscore ++

216 maybe "" (\p -> zEncodeString p ++ "_") pkg ++

248 maybe "" (\p -> zEncodeString p ++ "_") pkg ++

217 zEncodeString module' ++ "_" ++ zEncodeString valsym ++ "_closure"

249 zEncodeString module' ++ "_" ++ zEncodeString valsym ++ "_closure"

218−

219−type ModName = String

220−type FuncName = String

221−

222−data LoadSymbolError = LoadSymbolError

223

250

224loadFunction :: ModName -> FuncName -> FilePath -> IO (Either LoadSymbolError a)

251loadFunction :: ModName -> FuncName -> FilePath -> IO (Either LoadSymbolError a)

225loadFunction modName funcName objPath = do

252loadFunction modName funcName objPath = do

226−#if __GLASGOW_HASKELL__ >= 802

253+#if __GLASGOW_HASKELL__ >= 802

227 initObjLinker RetainCAFs

254 initObjLinker RetainCAFs

228#else

255#else

229 initObjLinker

256 initObjLinker

@@ -235,8 +262,8 @@ loadFunction modName funcName objPath = do

235 Nothing -> pure (Left LoadSymbolError)

262 Nothing -> pure (Left LoadSymbolError)

236 Just (Ptr addr) -> case addrToAny# addr of

263 Just (Ptr addr) -> case addrToAny# addr of

237 (# hval #) -> pure (Right hval)

264 (# hval #) -> pure (Right hval)

238−

265+

239−prefixUnderscore :: String

266+prefixUnderscore :: String

240prefixUnderscore =

267prefixUnderscore =

241 case (os,arch) of

268 case (os,arch) of

242 ("mingw32","x86_64") -> ""

269 ("mingw32","x86_64") -> ""

@@ -244,4 +271,5 @@ prefixUnderscore =

244 ("mingw32",_) -> "_"

271 ("mingw32",_) -> "_"

245 ("darwin",_) -> "_"

272 ("darwin",_) -> "_"

246 ("cygwin",_) -> "_"

273 ("cygwin",_) -> "_"

247− _ -> ""

274+ _ -> ""

275+#endif

src/lib/ProjectM36/Serialise/AtomFunctionError.hsnew file+7

@@ -0,0 +1,7 @@

1+{-# LANGUAGE DerivingVia, StandaloneDeriving #-}

2+{-# OPTIONS_GHC -fno-warn-orphans #-}

3+module ProjectM36.Serialise.AtomFunctionError where

4+import Codec.Winery

5+import ProjectM36.AtomFunctionError

6+

7+deriving via WineryVariant AtomFunctionError instance Serialise AtomFunctionError

src/lib/ProjectM36/Serialise/Base.hsnew file+85

@@ -0,0 +1,85 @@

1+{-# LANGUAGE StandaloneDeriving, DerivingVia, TypeApplications, TypeSynonymInstances, ScopedTypeVariables #-}

2+{-# OPTIONS_GHC -fno-warn-orphans #-}

3+--Serialise instances for ProjectM36.Base data types- orphan instance city

4+module ProjectM36.Serialise.Base where

5+import Codec.Winery hiding (Schema)

6+import Codec.Winery.Internal

7+import Control.Monad

8+import ProjectM36.Base

9+import ProjectM36.MerkleHash

10+import Data.UUID

11+import Data.Proxy

12+import Data.Word

13+import ProjectM36.Attribute as A

14+import qualified Data.List.NonEmpty as NE

15+import qualified Data.Vector as V

16+import Data.Time.Calendar (Day,toGregorian,fromGregorian)

17+

18+deriving via WineryVariant Atom instance Serialise Atom

19+deriving via WineryVariant AtomType instance Serialise AtomType

20+deriving via WineryVariant Attribute instance Serialise Attribute

21+deriving via WineryVariant RelationTupleSet instance Serialise RelationTupleSet

22+deriving via WineryVariant RelationTuple instance Serialise RelationTuple

23+deriving via WineryVariant Relation instance Serialise Relation

24+deriving via WineryVariant RelationCardinality instance Serialise RelationCardinality

25+deriving via WineryVariant (RelationalExprBase a) instance Serialise a => Serialise (RelationalExprBase a)

26+deriving via WineryVariant (WithNameExprBase a) instance Serialise a => Serialise (WithNameExprBase a)

27+deriving via WineryVariant Notification instance Serialise Notification

28+deriving via WineryVariant TypeConstructorDef instance Serialise TypeConstructorDef

29+deriving via WineryVariant (TypeConstructorBase a) instance Serialise a => Serialise (TypeConstructorBase a)

30+deriving via WineryVariant DataConstructorDef instance Serialise DataConstructorDef

31+deriving via WineryVariant DataConstructorDefArg instance Serialise DataConstructorDefArg

32+deriving via WineryVariant GraphRefTransactionMarker instance Serialise GraphRefTransactionMarker

33+deriving via WineryVariant SchemaIsomorph instance Serialise SchemaIsomorph

34+deriving via WineryVariant InclusionDependency instance Serialise InclusionDependency

35+deriving via WineryVariant (DatabaseContextExprBase a) instance Serialise a => Serialise (DatabaseContextExprBase a)

36+deriving via WineryVariant (DatabaseContextIOExprBase a) instance Serialise a => Serialise (DatabaseContextIOExprBase a)

37+deriving via WineryVariant (RestrictionPredicateExprBase a) instance Serialise a => Serialise (RestrictionPredicateExprBase a)

38+deriving via WineryVariant TransactionInfo instance Serialise TransactionInfo

39+deriving via WineryVariant (AtomExprBase a) instance Serialise a => Serialise (AtomExprBase a)

40+deriving via WineryVariant MerkleHash instance Serialise MerkleHash

41+deriving via WineryVariant (AttributeExprBase a) instance Serialise a => Serialise (AttributeExprBase a)

42+deriving via WineryVariant (TupleExprsBase a) instance Serialise a => Serialise (TupleExprsBase a)

43+deriving via WineryVariant (TupleExprBase a) instance Serialise a => Serialise (TupleExprBase a)

44+deriving via WineryVariant (AttributeNamesBase a) instance Serialise a => Serialise (AttributeNamesBase a)

45+deriving via WineryVariant (ExtendTupleExprBase a) instance Serialise a => Serialise (ExtendTupleExprBase a)

46+deriving via WineryVariant Schema instance Serialise Schema

47+deriving via WineryVariant MergeStrategy instance Serialise MergeStrategy

48+

49+fromWordsTup :: (Word32, Word32, Word32, Word32) -> TransactionId

50+fromWordsTup (a,b,c,d) = fromWords a b c d

51+

52+instance Serialise TransactionId where

53+ schemaGen _ = getSchema (Proxy @(Word32, Word32, Word32, Word32))

54+ toBuilder uuid = toBuilder (toWords uuid)

55+ extractor = fromWordsTup <$> extractor

56+ decodeCurrent = fromWordsTup <$> decodeCurrent

57+

58+instance Serialise a => Serialise (NE.NonEmpty a) where

59+ schemaGen _ = SVector <$> getSchema (Proxy @a)

60+ toBuilder xs = varInt (length xs) <> foldMap toBuilder xs

61+ extractor = NE.fromList . V.toList <$> extractListBy extractor --use nonempty instead to replace error with winery error

62+ decodeCurrent = do

63+ n <- decodeVarInt

64+ l <- replicateM n decodeCurrent

65+ pure (NE.fromList l)

66+

67+fromGregorianTup :: (Integer, Int, Int) -> Day

68+fromGregorianTup (a, b, c) = fromGregorian a b c

69+

70+instance Serialise Day where

71+ schemaGen _ = getSchema (Proxy @(Integer, Int, Int))

72+ toBuilder day = toBuilder (toGregorian day)

73+ extractor = fromGregorianTup <$> extractor

74+ decodeCurrent = fromGregorianTup <$> decodeCurrent

75+

76+instance Serialise Attributes where

77+ schemaGen _ = SVector <$> getSchema (Proxy @Attribute)

78+ toBuilder attrs = varInt (V.length (attributesVec attrs)) <> foldMap toBuilder (V.toList (attributesVec attrs))

79+ extractor =

80+ attributesFromList . V.toList <$> extractListBy extractor

81+

82+ decodeCurrent = do

83+ n <- decodeVarInt

84+ l <- replicateM n decodeCurrent

85+ pure (A.attributesFromList l)

src/lib/ProjectM36/Serialise/DataFrame.hsnew file+13

@@ -0,0 +1,13 @@

1+{-# LANGUAGE DerivingVia, StandaloneDeriving #-}

2+{-# OPTIONS_GHC -fno-warn-orphans #-}

3+module ProjectM36.Serialise.DataFrame where

4+import Codec.Winery

5+import ProjectM36.DataFrame

6+import ProjectM36.Serialise.Base ()

7+

8+deriving via WineryVariant AttributeOrderExpr instance Serialise AttributeOrderExpr

9+deriving via WineryVariant AttributeOrder instance Serialise AttributeOrder

10+deriving via WineryVariant Order instance Serialise Order

11+deriving via WineryRecord DataFrame instance Serialise DataFrame

12+deriving via WineryVariant DataFrameTuple instance Serialise DataFrameTuple

13+deriving via WineryRecord DataFrameExpr instance Serialise DataFrameExpr

src/lib/ProjectM36/Serialise/DatabaseContextFunctionError.hsnew file+7

@@ -0,0 +1,7 @@

1+{-# LANGUAGE DerivingVia, StandaloneDeriving #-}

2+{-# OPTIONS_GHC -fno-warn-orphans #-}

3+module ProjectM36.Serialise.DatabaseContextFunctionError where

4+import Codec.Winery

5+import ProjectM36.DatabaseContextFunctionError

6+

7+deriving via WineryVariant DatabaseContextFunctionError instance Serialise DatabaseContextFunctionError

src/lib/ProjectM36/Serialise/Error.hsnew file+15

@@ -0,0 +1,15 @@

1+{-# LANGUAGE DerivingVia, StandaloneDeriving #-}

2+{-# OPTIONS_GHC -fno-warn-orphans #-}

3+module ProjectM36.Serialise.Error where

4+import ProjectM36.Error

5+import Codec.Winery

6+import ProjectM36.Serialise.Base ()

7+import ProjectM36.Serialise.AtomFunctionError ()

8+import ProjectM36.Serialise.DatabaseContextFunctionError ()

9+

10+deriving via WineryVariant RelationalError instance Serialise RelationalError

11+deriving via WineryVariant MergeError instance Serialise MergeError

12+deriving via WineryVariant ScriptCompilationError instance Serialise ScriptCompilationError

13+deriving via WineryVariant PersistenceError instance Serialise PersistenceError

14+deriving via WineryVariant SchemaError instance Serialise SchemaError

15+deriving via WineryVariant ImportError' instance Serialise ImportError'

src/lib/ProjectM36/Serialise/IsomorphicSchema.hsnew file+7

@@ -0,0 +1,7 @@

1+{-# LANGUAGE StandaloneDeriving, DerivingVia, TypeSynonymInstances, ScopedTypeVariables #-}

2+{-# OPTIONS_GHC -fno-warn-orphans #-}

3+module ProjectM36.Serialise.IsomorphicSchema where

4+import Codec.Winery

5+import ProjectM36.IsomorphicSchema

6+

7+deriving via WineryVariant SchemaExpr instance Serialise SchemaExpr

src/lib/ProjectM36/Serialise/MergeError.hsnew file+1

@@ -0,0 +1 @@

1+

src/lib/ProjectM36/Server.hs+166−88

@@ -7,76 +7,119 @@ import ProjectM36.Server.RemoteCallTypes

7import ProjectM36.Server.Config (ServerConfig(..))

8import ProjectM36.FSType

9

10−import Control.Monad.IO.Class (liftIO)

11−import Network.Transport.TCP (createTransport, defaultTCPParameters)

12−import Network.Transport (EndPointAddress(..), newEndPoint, address)

13−import Control.Distributed.Process.Node (initRemoteTable, runProcess, newLocalNode, initRemoteTable)

14−import Control.Distributed.Process.Extras.Time (Delay(..))

15−import Control.Distributed.Process (Process, register, getSelfPid)

16−import Control.Distributed.Process.ManagedProcess (defaultProcess, UnhandledMessagePolicy(..), ProcessDefinition(..), handleCall, serve, InitHandler, InitResult(..))

17−import Control.Concurrent.MVar (putMVar, MVar)

10+import Control.Concurrent.MVar (MVar)

18import System.IO (stderr, hPutStrLn)

11import System.IO (stderr, hPutStrLn)

19import System.FilePath (takeDirectory)

12import System.FilePath (takeDirectory)

20import System.Directory (doesDirectoryExist)

13import System.Directory (doesDirectoryExist)

14+import Network.RPC.Curryer.Server

15+import Network.Socket

16+import qualified StmContainers.Map as StmMap

17+import Control.Concurrent.STM

21

18

22−-- the state should be a mapping of remote connection to the disconnected transaction- the graph should be the same, so discon must be removed from the stm tuple

19+type TestMode = Bool

23−--trying to refactor this for less repetition is very challenging because the return type cannot be polymorphic or the distributed-process call gets confused and drops messages

24−serverDefinition :: Bool -> Timeout -> ProcessDefinition Connection

25−serverDefinition testBool ti = defaultProcess {

26− apiHandlers = [

27− handleCall (\conn (ExecuteHeadName sessionId) -> handleExecuteHeadName ti sessionId conn),

28− handleCall (\conn (ExecuteRelationalExpr sessionId expr) -> handleExecuteRelationalExpr ti sessionId conn expr),

29− handleCall (\conn (ExecuteDataFrameExpr sessionId expr) -> handleExecuteDataFrameExpr ti sessionId conn expr),

30− handleCall (\conn (ExecuteDatabaseContextExpr sessionId expr) -> handleExecuteDatabaseContextExpr ti sessionId conn expr),

31− handleCall (\conn (ExecuteDatabaseContextIOExpr sessionId expr) -> handleExecuteDatabaseContextIOExpr ti sessionId conn expr),

32− handleCall (\conn (ExecuteGraphExpr sessionId expr) -> handleExecuteGraphExpr ti sessionId conn expr),

33− handleCall (\conn (ExecuteTransGraphRelationalExpr sessionId expr) -> handleExecuteTransGraphRelationalExpr ti sessionId conn expr),

34− handleCall (\conn (ExecuteTypeForRelationalExpr sessionId expr) -> handleExecuteTypeForRelationalExpr ti sessionId conn expr),

35− handleCall (\conn (RetrieveInclusionDependencies sessionId) -> handleRetrieveInclusionDependencies ti sessionId conn),

36− handleCall (\conn (RetrievePlanForDatabaseContextExpr sessionId dbExpr) -> handleRetrievePlanForDatabaseContextExpr ti sessionId conn dbExpr),

37− handleCall (\conn (RetrieveHeadTransactionId sessionId) -> handleRetrieveHeadTransactionId ti sessionId conn),

38− handleCall (\conn (RetrieveTransactionGraph sessionId) -> handleRetrieveTransactionGraph ti sessionId conn),

39− handleCall (\conn (Login procId) -> handleLogin ti conn procId),

40− handleCall (\conn (CreateSessionAtHead headn) -> handleCreateSessionAtHead ti conn headn),

41− handleCall (\conn (CreateSessionAtCommit commitId) -> handleCreateSessionAtCommit ti conn commitId),

42− handleCall (\conn (CloseSession sessionId) -> handleCloseSession ti sessionId conn),

43− handleCall (\conn (RetrieveAtomTypesAsRelation sessionId) -> handleRetrieveAtomTypesAsRelation ti sessionId conn),

44− handleCall (\conn (RetrieveRelationVariableSummary sessionId) -> handleRetrieveRelationVariableSummary ti sessionId conn),

45− handleCall (\conn (RetrieveAtomFunctionSummary sessionId) -> handleRetrieveAtomFunctionSummary ti sessionId conn),

46− handleCall (\conn (RetrieveDatabaseContextFunctionSummary sessionId) -> handleRetrieveDatabaseContextFunctionSummary ti sessionId conn),

47− handleCall (\conn (RetrieveCurrentSchemaName sessionId) -> handleRetrieveCurrentSchemaName ti sessionId conn),

48− handleCall (\conn (ExecuteSchemaExpr sessionId schemaExpr) -> handleExecuteSchemaExpr ti sessionId conn schemaExpr),

49− handleCall (\conn (RetrieveSessionIsDirty sessionId) -> handleRetrieveSessionIsDirty ti sessionId conn),

50− handleCall (\conn (ExecuteAutoMergeToHead sessionId strat headName') -> handleExecuteAutoMergeToHead ti sessionId conn strat headName'),

51− handleCall (\conn (RetrieveTypeConstructorMapping sessionId) -> handleRetrieveTypeConstructorMapping ti sessionId conn),

52− handleCall (\conn Logout -> handleLogout ti conn)

53− ] ++ testModeHandlers,

54− unhandledMessagePolicy = Terminate

55− --unhandledMessagePolicy = Log

56− }

57− where

58− testModeHandlers = if not testBool then

59− []

60− else

61− [handleCall (\conn (TestTimeout sessionId) -> handleTestTimeout ti sessionId conn)]

62−

63−

64−initServer :: InitHandler (Connection, DatabaseName, Maybe (MVar EndPointAddress), EndPointAddress) Connection

65−initServer (conn, dbname, mAddressMVar, saddress) = do

66− registerDB dbname

67− case mAddressMVar of

68− Nothing -> pure ()

69− Just addressMVar -> liftIO $ putMVar addressMVar saddress

70− --traceShowM ("server started on " ++ show saddress)

71− pure $ InitOk conn Infinity

72

20

73−registerDB :: DatabaseName -> Process ()

21+requestHandlers :: TestMode -> Maybe Timeout -> RequestHandlers ServerState

74−registerDB dbname = do

22+requestHandlers testFlag ti =

75− self <- getSelfPid

23+ [

76− let dbname' = remoteDBLookupName dbname

24+ RequestHandler (\sState (Login dbName) -> do

77− register dbname' self

25+ addClientLogin dbName sState

78− --liftIO $ putStrLn $ "registered " ++ (show self) ++ " " ++ dbname'

26+ conn <- getConn sState

79−

27+ handleLogin conn (connectionSocket sState)),

28+ RequestHandler (\sState Logout -> do

29+ conn <- getConn sState

30+ handleLogout ti conn),

31+ RequestHandler $ \sState (ExecuteHeadName sessionId) -> do

32+ --socket -> dbname --maybe create a socket->client state mapping in the server state, too

33+ conn <- getConn sState

34+ handleExecuteHeadName ti sessionId conn,

35+ RequestHandler (\sState (ExecuteRelationalExpr sessionId expr) -> do

36+ conn <- getConn sState

37+ handleExecuteRelationalExpr ti sessionId conn expr),

38+ RequestHandler (\sState (ExecuteDataFrameExpr sessionId expr) -> do

39+ conn <- getConn sState

40+ handleExecuteDataFrameExpr ti sessionId conn expr),

41+ RequestHandler (\sState (ExecuteDatabaseContextExpr sessionId expr) -> do

42+ conn <- getConn sState

43+ handleExecuteDatabaseContextExpr ti sessionId conn expr),

44+ RequestHandler (\sState (ExecuteDatabaseContextIOExpr sessionId expr) -> do

45+ conn <- getConn sState

46+ handleExecuteDatabaseContextIOExpr ti sessionId conn expr),

47+ RequestHandler (\sState (ExecuteGraphExpr sessionId expr) -> do

48+ conn <- getConn sState

49+ handleExecuteGraphExpr ti sessionId conn expr),

50+ RequestHandler (\sState (ExecuteTransGraphRelationalExpr sessionId expr) -> do

51+ conn <- getConn sState

52+ handleExecuteTransGraphRelationalExpr ti sessionId conn expr),

53+ RequestHandler (\sState (ExecuteTypeForRelationalExpr sessionId expr) -> do

54+ conn <- getConn sState

55+ handleExecuteTypeForRelationalExpr ti sessionId conn expr),

56+ RequestHandler (\sState (RetrieveInclusionDependencies sessionId) -> do

57+ conn <- getConn sState

58+ handleRetrieveInclusionDependencies ti sessionId conn),

59+ RequestHandler (\sState (RetrievePlanForDatabaseContextExpr sessionId dbExpr) -> do

60+ conn <- getConn sState

61+ handleRetrievePlanForDatabaseContextExpr ti sessionId conn dbExpr),

62+ RequestHandler (\sState (RetrieveHeadTransactionId sessionId) -> do

63+ conn <- getConn sState

64+ handleRetrieveHeadTransactionId ti sessionId conn),

65+ RequestHandler (\sState (RetrieveTransactionGraph sessionId) -> do

66+ conn <- getConn sState

67+ handleRetrieveTransactionGraph ti sessionId conn),

68+ RequestHandler (\sState (CreateSessionAtHead headn) -> do

69+ conn <- getConn sState

70+ handleCreateSessionAtHead ti conn headn),

71+ RequestHandler (\sState (CreateSessionAtCommit commitId) -> do

72+ conn <- getConn sState

73+ handleCreateSessionAtCommit ti conn commitId),

74+ RequestHandler (\sState (CloseSession sessionId) -> do

75+ conn <- getConn sState

76+ handleCloseSession sessionId conn),

77+ RequestHandler (\sState (RetrieveAtomTypesAsRelation sessionId) -> do

78+ conn <- getConn sState

79+ handleRetrieveAtomTypesAsRelation ti sessionId conn),

80+ RequestHandler (\sState (RetrieveRelationVariableSummary sessionId) -> do

81+ conn <- getConn sState

82+ handleRetrieveRelationVariableSummary ti sessionId conn),

83+ RequestHandler (\sState (RetrieveAtomFunctionSummary sessionId) -> do

84+ conn <- getConn sState

85+ handleRetrieveAtomFunctionSummary ti sessionId conn),

86+ RequestHandler (\sState (RetrieveDatabaseContextFunctionSummary sessionId) -> do

87+ conn <- getConn sState

88+ handleRetrieveDatabaseContextFunctionSummary ti sessionId conn), RequestHandler (\sState (RetrieveCurrentSchemaName sessionId) -> do

89+ conn <- getConn sState

90+ handleRetrieveCurrentSchemaName ti sessionId conn),

91+ RequestHandler (\sState (ExecuteSchemaExpr sessionId schemaExpr) -> do

92+ conn <- getConn sState

93+ handleExecuteSchemaExpr ti sessionId conn schemaExpr),

94+ RequestHandler (\sState (RetrieveSessionIsDirty sessionId) -> do

95+ conn <- getConn sState

96+ handleRetrieveSessionIsDirty ti sessionId conn),

97+ RequestHandler (\sState (ExecuteAutoMergeToHead sessionId strat headName') -> do

98+ conn <- getConn sState

99+ handleExecuteAutoMergeToHead ti sessionId conn strat headName'),

100+ RequestHandler (\sState (RetrieveTypeConstructorMapping sessionId) -> do

101+ conn <- getConn sState

102+ handleRetrieveTypeConstructorMapping ti sessionId conn),

103+ RequestHandler (\sState (ExecuteValidateMerkleHashes sessionId) -> do

104+ conn <- getConn sState

105+ handleValidateMerkleHashes ti sessionId conn)

106+ ] ++ if testFlag then testModeHandlers ti else []

107+

108+getConn :: ConnectionState ServerState -> IO Connection

109+getConn connState = do

110+ let sock = lockless (connectionSocket connState)

111+ sState = connectionServerState connState

112+ mConn <- connectionForClient sock sState

113+ case mConn of

114+ Nothing -> error "failed to find socket in client map"

115+ Just conn -> pure conn

116+

117+testModeHandlers :: Maybe Timeout -> RequestHandlers ServerState

118+testModeHandlers ti = [RequestHandler (\sState (TestTimeout sessionId) -> do

119+ conn <- getConn sState

120+ handleTestTimeout ti sessionId conn)]

121+

122+

80-- | A notification callback which logs the notification to stderr and does nothing else.

123-- | A notification callback which logs the notification to stderr and does nothing else.

81loggingNotificationCallback :: NotificationCallback

124loggingNotificationCallback :: NotificationCallback

82loggingNotificationCallback notName evaldNot = hPutStrLn stderr $ "Notification received \"" ++ show notName ++ "\": " ++ show evaldNot

125loggingNotificationCallback notName evaldNot = hPutStrLn stderr $ "Notification received \"" ++ show notName ++ "\": " ++ show evaldNot

@@ -101,9 +144,47 @@ checkFSType performCheck strat =

101checkFSErrorMsg :: String

144checkFSErrorMsg :: String

102checkFSErrorMsg = "The filesystem does not support journaling so writes may not be crash-safe. Use --disable-fscheck to disable this fatal error."

145checkFSErrorMsg = "The filesystem does not support journaling so writes may not be crash-safe. Use --disable-fscheck to disable this fatal error."

103

146

147+-- Sockets do not implement hashable, so we just use their string values as keys

148+type SocketString = String

149+

150+data ServerState =

151+ ServerState {

152+ --map available databases to local database configurations

153+ stateDBMap :: StmMap.Map DatabaseName Connection,

154+ --map clients to database names- after logging in, clients are afixed to specific database names

155+ stateClientMap :: StmMap.Map SocketString DatabaseName

156+ }

157+

158+-- add a client socket to the database mapping

159+addClientLogin :: DatabaseName -> ConnectionState ServerState -> IO ()

160+addClientLogin dbName cState = do

161+ let clientMap = stateClientMap (connectionServerState cState)

162+ sock = lockless (connectionSocket cState)

163+ atomically $ do

164+ mVal <- StmMap.lookup (show sock) clientMap

165+ case mVal of

166+ Nothing -> StmMap.insert dbName (show sock) clientMap

167+ Just _ -> pure () --TODO: throw exception- user already logged in

168+

169+connectionForClient :: Socket -> ServerState -> IO (Maybe Connection)

170+connectionForClient sock sState =

171+ atomically $ do

172+ mdbname <- StmMap.lookup (show sock) (stateClientMap sState)

173+ case mdbname of

174+ Nothing -> pure Nothing

175+ Just dbname ->

176+ StmMap.lookup dbname (stateDBMap sState)

177+

178+initialServerState :: DatabaseName -> Connection -> IO ServerState

179+initialServerState dbName conn =

180+ atomically $ do

181+ dbmap <- StmMap.new

182+ clientMap <- StmMap.new

183+ StmMap.insert conn dbName dbmap

184+ pure (ServerState { stateDBMap = dbmap, stateClientMap = clientMap })

104-- | A synchronous function to start the project-m36 daemon given an appropriate 'ServerConfig'. Note that this function only returns if the server exits. Returns False if the daemon exited due to an error. If the second argument is not Nothing, the port is put after the server is ready to service the port.

185-- | A synchronous function to start the project-m36 daemon given an appropriate 'ServerConfig'. Note that this function only returns if the server exits. Returns False if the daemon exited due to an error. If the second argument is not Nothing, the port is put after the server is ready to service the port.

105−launchServer :: ServerConfig -> Maybe (MVar EndPointAddress) -> IO Bool

186+launchServer :: ServerConfig -> Maybe (MVar SockAddr) -> IO Bool

106−launchServer daemonConfig mAddressMVar = do

187+launchServer daemonConfig mAddr = do

107 checkFSResult <- checkFSType (checkFS daemonConfig) (persistenceStrategy daemonConfig)

188 checkFSResult <- checkFSType (checkFS daemonConfig) (persistenceStrategy daemonConfig)

108 if not checkFSResult then do

189 if not checkFSResult then do

109 hPutStrLn stderr checkFSErrorMsg

190 hPutStrLn stderr checkFSErrorMsg

@@ -116,24 +197,21 @@ launchServer daemonConfig mAddressMVar = do

116 pure False

197 pure False

117 Right conn -> do

198 Right conn -> do

118 let hostname = bindHost daemonConfig

199 let hostname = bindHost daemonConfig

119− port = bindPort daemonConfig

200+ port = fromIntegral (bindPort daemonConfig)

120−#if MIN_VERSION_network_transport_tcp(0,6,0)

201+

121− etransport <- createTransport hostname (show port) (\nam -> (hostname, nam)) defaultTCPParameters

202+

122−#else

203+ --curryer only supports IPv4 for now

123− etransport <- createTransport hostname (show port) defaultTCPParameters

204+ let addrHints = defaultHints { addrSocketType = Stream, addrFamily = AF_INET }

124−#endif

205+ hostAddrs <- getAddrInfo (Just addrHints) (Just hostname) Nothing

125− case etransport of

126− Left err -> error ("failed to create transport: " ++ show err)

127− Right transport -> do

128− eEndpoint <- newEndPoint transport

129− case eEndpoint of

206+ case hostAddrs of

130− Left err -> hPutStrLn stderr ("Failed to create transport: " ++ show err) >> pure False

207+ [] -> hPutStrLn stderr ("Failed to resolve: " <> hostname) >> pure False

131− Right endpoint -> do

208+ (AddrInfo _ _ _ _ (SockAddrInet _ addr32) _):_ -> do

132− localTCPNode <- newLocalNode transport initRemoteTable

209+ let hostAddr = hostAddressToTuple addr32

133− --traceShowM ("newLocalNode in Server " ++ show (localNodeId localTCPNode))

134− runProcess localTCPNode $ do

135− let testBool = testMode daemonConfig

136− reqTimeout = perRequestTimeout daemonConfig

210+ mTimeout = fromIntegral <$> case perRequestTimeout daemonConfig of

137− serve (conn, databaseName daemonConfig, mAddressMVar, address endpoint) initServer (serverDefinition testBool reqTimeout)

211+ 0 -> Nothing

138− liftIO $ putStrLn "serve returned"

212+ v -> Just v

139− pure True

213+

214+ sState <- initialServerState (databaseName daemonConfig) conn

215+ serve (requestHandlers (testMode daemonConfig) mTimeout) sState hostAddr port mAddr

216+ _ -> error "unsupported socket addressing mode (IPv4 only currently)"

217+

src/lib/ProjectM36/Server/Config.hs+6

@@ -12,6 +12,12 @@ data ServerConfig = ServerConfig { persistenceStrategy :: PersistenceStrategy,

12 }

13 deriving (Show)

14

15+data WebsocketServerConfig = WebsocketServerConfig { wsServerConfig :: ServerConfig,

16+ tlsCertificatePath :: Maybe String,

17+ tlsKeyPath :: Maybe String

18+ }

19+ deriving (Show)

20+

15defaultServerConfig :: ServerConfig

21defaultServerConfig :: ServerConfig

16defaultServerConfig = ServerConfig { persistenceStrategy = NoPersistence,

22defaultServerConfig = ServerConfig { persistenceStrategy = NoPersistence,

17 checkFS = True,

23 checkFS = True,

src/lib/ProjectM36/Server/EntryPoints.hs+126−153

@@ -1,173 +1,146 @@

1+{-# LANGUAGE MonoLocalBinds #-}

1module ProjectM36.Server.EntryPoints where

2module ProjectM36.Server.EntryPoints where

2import ProjectM36.Base hiding (inclusionDependencies)

3import ProjectM36.Base hiding (inclusionDependencies)

3import ProjectM36.IsomorphicSchema

4import ProjectM36.IsomorphicSchema

4import ProjectM36.Client as C

5import ProjectM36.Client as C

5−import ProjectM36.Error

6−import Control.Distributed.Process (Process, ProcessId)

7−import Control.Distributed.Process.ManagedProcess (ProcessReply)

8−import Control.Distributed.Process.ManagedProcess.Server (reply)

9−import Control.Distributed.Process.Async (async, task, waitCancelTimeout, AsyncResult(..))

10−import Control.Monad.IO.Class (liftIO)

11import Data.Map

6import Data.Map

12import Control.Concurrent (threadDelay)

7import Control.Concurrent (threadDelay)

13−import Data.Typeable

8+import Network.RPC.Curryer.Server

14−import Data.Binary

9+import System.Timeout hiding (Timeout)

10+import Network.Socket

11+import Control.Exception

15

12

16−timeoutOrDie :: (Binary a, Typeable a) => Timeout -> IO a -> Process (Either ServerError a)

13+timeoutOrDie :: Maybe Timeout -> IO a -> IO (Maybe a)

17−timeoutOrDie micros act =

14+timeoutOrDie mMicros act =

18− if micros == 0 then

19− liftIO act >>= \x -> pure (Right x)

20− else do

21− asyncUnit <- async (task (liftIO act))

22− asyncRes <- waitCancelTimeout micros asyncUnit

23− case asyncRes of

15+ case mMicros of

24− AsyncDone x -> pure (Right x)

16+ Nothing -> Just <$> act

25− AsyncCancelled -> pure (Left RequestTimeoutError)

17+ Just micros ->

26− AsyncFailed reason -> pure (Left (ProcessDiedError (show reason)))

18+ timeout (fromIntegral micros) act

27− AsyncLinkFailed reason -> pure (Left (ProcessDiedError (show reason)))

28− AsyncPending -> pure (Left (ProcessDiedError "process pending"))

29−

30−type Timeout = Int

31−

32−type Reply a = Process (ProcessReply (Either ServerError a) Connection)

33−

34−handleExecuteRelationalExpr :: Timeout -> SessionId -> Connection -> RelationalExpr -> Reply (Either RelationalError Relation)

35−handleExecuteRelationalExpr ti sessionId conn expr = do

36− ret <- timeoutOrDie ti (executeRelationalExpr sessionId conn expr)

37− reply ret conn

38

19

39−handleExecuteDataFrameExpr :: Timeout -> SessionId -> Connection -> DataFrameExpr -> Reply (Either RelationalError DataFrame)

20+timeoutRelErr :: Maybe Timeout -> IO (Either RelationalError a) -> IO (Either RelationalError a)

40−handleExecuteDataFrameExpr ti sessionId conn expr = do

21+timeoutRelErr mMicros act = do

41− ret <- timeoutOrDie ti (executeDataFrameExpr sessionId conn expr)

22+ ret <- timeoutOrDie mMicros act

42− reply ret conn

43−

44−handleExecuteDatabaseContextExpr :: Timeout -> SessionId -> Connection -> DatabaseContextExpr -> Reply (Either RelationalError ())

45−handleExecuteDatabaseContextExpr ti sessionId conn dbexpr = do

46− ret <- timeoutOrDie ti (executeDatabaseContextExpr sessionId conn dbexpr)

47− reply ret conn

48−

49−handleExecuteDatabaseContextIOExpr :: Timeout -> SessionId -> Connection -> DatabaseContextIOExpr -> Reply (Either RelationalError ())

50−handleExecuteDatabaseContextIOExpr ti sessionId conn dbexpr = do

51− ret <- timeoutOrDie ti (executeDatabaseContextIOExpr sessionId conn dbexpr)

52− reply ret conn

53−

54−handleExecuteHeadName :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError HeadName)

55−handleExecuteHeadName ti sessionId conn = do

56− ret <- timeoutOrDie ti (headName sessionId conn)

57− reply ret conn

58−

59−handleLogin :: Timeout -> Connection -> ProcessId -> Reply Bool

60−handleLogin ti conn newClientProcessId = do

61− ret <- timeoutOrDie ti (addClientNode conn newClientProcessId)

62 case ret of

23 case ret of

63− Right () -> reply (Right True) conn

24+ Nothing -> throw TimeoutException

64− Left err -> reply (Left err) conn

25+ Just v -> pure v

65−

26+

66−handleExecuteGraphExpr :: Timeout -> SessionId -> Connection -> TransactionGraphOperator -> Reply (Either RelationalError ())

67−handleExecuteGraphExpr ti sessionId conn graphExpr = do

68− ret <- timeoutOrDie ti (executeGraphExpr sessionId conn graphExpr)

69− reply ret conn

70−

71−handleExecuteTransGraphRelationalExpr :: Timeout -> SessionId -> Connection -> TransGraphRelationalExpr -> Reply (Either RelationalError Relation)

72−handleExecuteTransGraphRelationalExpr ti sessionId conn graphExpr = do

73− ret <- timeoutOrDie ti (executeTransGraphRelationalExpr sessionId conn graphExpr)

74− reply ret conn

75

27

76−handleExecuteTypeForRelationalExpr :: Timeout -> SessionId -> Connection -> RelationalExpr -> Reply (Either RelationalError Relation)

28+handleExecuteRelationalExpr :: Maybe Timeout -> SessionId -> Connection -> RelationalExpr -> IO (Either RelationalError Relation)

77−handleExecuteTypeForRelationalExpr ti sessionId conn relExpr = do

29+handleExecuteRelationalExpr ti sessionId conn expr =

30+ timeoutRelErr ti (executeRelationalExpr sessionId conn expr)

31+

32+handleExecuteDataFrameExpr :: Maybe Timeout -> SessionId -> Connection -> DataFrameExpr -> IO (Either RelationalError DataFrame)

33+handleExecuteDataFrameExpr ti sessionId conn expr =

34+ timeoutRelErr ti (executeDataFrameExpr sessionId conn expr)

35+

36+handleExecuteDatabaseContextExpr :: Maybe Timeout -> SessionId -> Connection -> DatabaseContextExpr -> IO (Either RelationalError ())

37+handleExecuteDatabaseContextExpr ti sessionId conn dbexpr =

38+ timeoutRelErr ti (executeDatabaseContextExpr sessionId conn dbexpr)

39+

40+handleExecuteDatabaseContextIOExpr :: Maybe Timeout -> SessionId -> Connection -> DatabaseContextIOExpr -> IO (Either RelationalError ())

41+handleExecuteDatabaseContextIOExpr ti sessionId conn dbexpr =

42+ timeoutRelErr ti (executeDatabaseContextIOExpr sessionId conn dbexpr)

43+

44+handleExecuteHeadName :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError HeadName)

45+handleExecuteHeadName ti sessionId conn =

46+ timeoutRelErr ti (headName sessionId conn)

47+

48+handleLogin :: Connection -> Locking Socket -> IO Bool

49+handleLogin conn lockSock = do

50+ addClientNode conn lockSock

51+ pure True

52+

53+handleExecuteGraphExpr :: Maybe Timeout -> SessionId -> Connection -> TransactionGraphOperator -> IO (Either RelationalError ())

54+handleExecuteGraphExpr ti sessionId conn graphExpr =

55+ timeoutRelErr ti (executeGraphExpr sessionId conn graphExpr)

56+

57+handleExecuteTransGraphRelationalExpr :: Maybe Timeout -> SessionId -> Connection -> TransGraphRelationalExpr -> IO (Either RelationalError Relation)

58+handleExecuteTransGraphRelationalExpr ti sessionId conn graphExpr =

59+ timeoutRelErr ti (executeTransGraphRelationalExpr sessionId conn graphExpr)

60+

61+handleExecuteTypeForRelationalExpr :: Maybe Timeout -> SessionId -> Connection -> RelationalExpr -> IO (Either RelationalError Relation)

62+handleExecuteTypeForRelationalExpr ti sessionId conn relExpr =

78− ret <- timeoutOrDie ti (typeForRelationalExpr sessionId conn relExpr)

63+ timeoutRelErr ti (typeForRelationalExpr sessionId conn relExpr)

79− reply ret conn

64+

80−

81−handleRetrieveInclusionDependencies :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError (Map IncDepName InclusionDependency))

65+handleRetrieveInclusionDependencies :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError (Map IncDepName InclusionDependency))

82−handleRetrieveInclusionDependencies ti sessionId conn = do

66+handleRetrieveInclusionDependencies ti sessionId conn =

83− ret <- timeoutOrDie ti (inclusionDependencies sessionId conn)

67+ timeoutRelErr ti (inclusionDependencies sessionId conn)

84− reply ret conn

68+

85−

86−handleRetrievePlanForDatabaseContextExpr :: Timeout -> SessionId -> Connection -> DatabaseContextExpr -> Reply (Either RelationalError GraphRefDatabaseContextExpr)

69+handleRetrievePlanForDatabaseContextExpr :: Maybe Timeout -> SessionId -> Connection -> DatabaseContextExpr -> IO (Either RelationalError GraphRefDatabaseContextExpr)

87−handleRetrievePlanForDatabaseContextExpr ti sessionId conn dbExpr = do

70+handleRetrievePlanForDatabaseContextExpr ti sessionId conn dbExpr =

88− ret <- timeoutOrDie ti (planForDatabaseContextExpr sessionId conn dbExpr)

71+ timeoutRelErr ti (planForDatabaseContextExpr sessionId conn dbExpr)

89− reply ret conn

72+

90−

91−handleRetrieveTransactionGraph :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError Relation)

73+handleRetrieveTransactionGraph :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Relation)

92−handleRetrieveTransactionGraph ti sessionId conn = do

74+handleRetrieveTransactionGraph ti sessionId conn =

93− ret <- timeoutOrDie ti (transactionGraphAsRelation sessionId conn)

75+ timeoutRelErr ti (transactionGraphAsRelation sessionId conn)

94− reply ret conn

76+

95−

96−handleRetrieveHeadTransactionId :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError TransactionId)

77+handleRetrieveHeadTransactionId :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError TransactionId)

97−handleRetrieveHeadTransactionId ti sessionId conn = do

78+handleRetrieveHeadTransactionId ti sessionId conn =

98− ret <- timeoutOrDie ti (headTransactionId sessionId conn)

79+ timeoutRelErr ti (headTransactionId sessionId conn)

99− reply ret conn

100−

101−handleCreateSessionAtCommit :: Timeout -> Connection -> TransactionId -> Reply (Either RelationalError SessionId)

102−handleCreateSessionAtCommit ti conn commitId = do

103− ret <- timeoutOrDie ti (createSessionAtCommit conn commitId)

104− reply ret conn

105−

106−handleCreateSessionAtHead :: Timeout -> Connection -> HeadName -> Reply (Either RelationalError SessionId)

107−handleCreateSessionAtHead ti conn headn = do

108− ret <- timeoutOrDie ti (createSessionAtHead conn headn)

109− reply ret conn

110−

111−handleCloseSession :: Timeout -> SessionId -> Connection -> Reply ()

112−handleCloseSession ti sessionId conn = do

113− ret <- timeoutOrDie ti (closeSession sessionId conn)

114− case ret of

115− Right () -> reply (Right ()) conn

116− Left err -> reply (Left err) conn

117

80

81+handleCreateSessionAtCommit :: Maybe Timeout -> Connection -> TransactionId -> IO (Either RelationalError SessionId)

82+handleCreateSessionAtCommit ti conn commitId =

83+ timeoutRelErr ti (createSessionAtCommit conn commitId)

84+

85+handleCreateSessionAtHead :: Maybe Timeout -> Connection -> HeadName -> IO (Either RelationalError SessionId)

86+handleCreateSessionAtHead ti conn headn =

87+ timeoutRelErr ti (createSessionAtHead conn headn)

88+

89+handleCloseSession :: SessionId -> Connection -> IO ()

90+handleCloseSession =

91+ closeSession

92+

118−handleRetrieveAtomTypesAsRelation :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError Relation)

93+handleRetrieveAtomTypesAsRelation :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Relation)

119−handleRetrieveAtomTypesAsRelation ti sessionId conn = do

94+handleRetrieveAtomTypesAsRelation ti sessionId conn =

120− ret <- timeoutOrDie ti (atomTypesAsRelation sessionId conn)

95+ timeoutRelErr ti (atomTypesAsRelation sessionId conn)

121− reply ret conn

122

96

123-- | Returns a relation which lists the names of relvars in the current session as well as its types.

97-- | Returns a relation which lists the names of relvars in the current session as well as its types.

124−handleRetrieveRelationVariableSummary :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError Relation)

98+handleRetrieveRelationVariableSummary :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Relation)

125−handleRetrieveRelationVariableSummary ti sessionId conn = do

99+handleRetrieveRelationVariableSummary ti sessionId conn =

126− ret <- timeoutOrDie ti (relationVariablesAsRelation sessionId conn)

100+ timeoutRelErr ti (relationVariablesAsRelation sessionId conn)

127− reply ret conn

101+

128−

129−handleRetrieveAtomFunctionSummary :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError Relation)

102+handleRetrieveAtomFunctionSummary :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Relation)

130−handleRetrieveAtomFunctionSummary ti sessionId conn = do

103+handleRetrieveAtomFunctionSummary ti sessionId conn =

131− ret <- timeoutOrDie ti (atomFunctionsAsRelation sessionId conn)

104+ timeoutRelErr ti (atomFunctionsAsRelation sessionId conn)

132− reply ret conn

105+

133−

134−handleRetrieveDatabaseContextFunctionSummary :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError Relation)

106+handleRetrieveDatabaseContextFunctionSummary :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Relation)

135−handleRetrieveDatabaseContextFunctionSummary ti sessionId conn = do

107+handleRetrieveDatabaseContextFunctionSummary ti sessionId conn =

136− ret <- timeoutOrDie ti (databaseContextFunctionsAsRelation sessionId conn)

108+ timeoutRelErr ti (databaseContextFunctionsAsRelation sessionId conn)

137− reply ret conn

109+

138−

139−handleRetrieveCurrentSchemaName :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError SchemaName)

110+handleRetrieveCurrentSchemaName :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError SchemaName)

140−handleRetrieveCurrentSchemaName ti sessionId conn = do

111+handleRetrieveCurrentSchemaName ti sessionId conn =

141− ret <- timeoutOrDie ti (currentSchemaName sessionId conn)

112+ timeoutRelErr ti (currentSchemaName sessionId conn)

142− reply ret conn

143

113

144−handleExecuteSchemaExpr :: Timeout -> SessionId -> Connection -> SchemaExpr -> Reply (Either RelationalError ())

114+handleExecuteSchemaExpr :: Maybe Timeout -> SessionId -> Connection -> SchemaExpr -> IO (Either RelationalError ())

145−handleExecuteSchemaExpr ti sessionId conn schemaExpr = do

115+handleExecuteSchemaExpr ti sessionId conn schemaExpr =

146− ret <- timeoutOrDie ti (executeSchemaExpr sessionId conn schemaExpr)

116+ timeoutRelErr ti (executeSchemaExpr sessionId conn schemaExpr)

147− reply ret conn

148

117

149−handleLogout :: Timeout -> Connection -> Reply Bool

118+handleLogout :: Maybe Timeout -> Connection -> IO Bool

150−handleLogout _ =

119+handleLogout _ _ =

151 --liftIO $ closeRemote_ conn

120 --liftIO $ closeRemote_ conn

152− reply (pure True)

121+ pure True

153

122

154−handleTestTimeout :: Timeout -> SessionId -> Connection -> Reply Bool

123+handleTestTimeout :: Maybe Timeout -> SessionId -> Connection -> IO Bool

155−handleTestTimeout ti _ conn = do

124+handleTestTimeout ti _ _ = do

156− ret <- timeoutOrDie ti (threadDelay 100000 >> pure True)

125+ ret <- timeoutRelErr ti (threadDelay 100000 >> pure (Right ()))

157− reply ret conn

126+ case ret of

127+ Right () -> pure True

128+ Left _ -> pure False

158

129

130+

131+

159−handleRetrieveSessionIsDirty :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError Bool)

132+handleRetrieveSessionIsDirty :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Bool)

160−handleRetrieveSessionIsDirty ti sessionId conn = do

133+handleRetrieveSessionIsDirty ti sessionId conn =

161− ret <- timeoutOrDie ti (disconnectedTransactionIsDirty sessionId conn)

134+ timeoutRelErr ti (disconnectedTransactionIsDirty sessionId conn)

162− reply ret conn

135+

163−

164−handleExecuteAutoMergeToHead :: Timeout -> SessionId -> Connection -> MergeStrategy -> HeadName -> Reply (Either RelationalError ())

136+handleExecuteAutoMergeToHead :: Maybe Timeout -> SessionId -> Connection -> MergeStrategy -> HeadName -> IO (Either RelationalError ())

165−handleExecuteAutoMergeToHead ti sessionId conn strat headName' = do

137+handleExecuteAutoMergeToHead ti sessionId conn strat headName' =

166− ret <- timeoutOrDie ti (autoMergeToHead sessionId conn strat headName')

138+ timeoutRelErr ti (autoMergeToHead sessionId conn strat headName')

167− reply ret conn

168

139

169−handleRetrieveTypeConstructorMapping :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError TypeConstructorMapping)

140+handleRetrieveTypeConstructorMapping :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError TypeConstructorMapping)

170−handleRetrieveTypeConstructorMapping ti sessionId conn = do

141+handleRetrieveTypeConstructorMapping ti sessionId conn =

171− ret <- timeoutOrDie ti (C.typeConstructorMapping sessionId conn)

142+ timeoutRelErr ti (C.typeConstructorMapping sessionId conn)

172− reply ret conn

173

143

144+handleValidateMerkleHashes :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError ())

145+handleValidateMerkleHashes ti sessionId conn =

146+ timeoutRelErr ti (C.validateMerkleHashes sessionId conn)

src/lib/ProjectM36/Server/ParseArgs.hs+39−16

@@ -3,7 +3,7 @@ import ProjectM36.Base

3import ProjectM36.Client

4import Options.Applicative

5import ProjectM36.Server.Config

6−#if __GLASGOW_HASKELL__ <= 802

6+#if __GLASGOW_HASKELL__ < 804

7import Data.Monoid

8#endif

9

@@ -17,14 +17,14 @@ parseArgsWithDefaults defaults = ServerConfig <$>

17 many parseGhcPkgPath <*>

18 parseTimeout (perRequestTimeout defaults) <*>

19 parseTestMode

20−

20+

21parsePersistenceStrategy :: Parser PersistenceStrategy

22parsePersistenceStrategy = CrashSafePersistence <$> (dbdirOpt <* fsyncOpt) <|>

23 MinimalPersistence <$> dbdirOpt <|>

24 pure NoPersistence

25− where

25+ where

26− dbdirOpt = strOption (short 'd' <>

26+ dbdirOpt = strOption (short 'd' <>

27− long "database-directory" <>

27+ long "database-directory" <>

28 metavar "DIRECTORY" <>

29 showDefaultWith show

30 )

@@ -34,46 +34,69 @@ parsePersistenceStrategy = CrashSafePersistence <$> (dbdirOpt <* fsyncOpt) <|>

34

35parseTestMode :: Parser Bool

36parseTestMode = flag True False (long "test-mode" <> hidden)

37−

37+

38−parseCheckFS :: Parser Bool

38+parseCheckFS :: Parser Bool

39parseCheckFS = flag True False (long "disable-fscheck" <>

40 help "Disable filesystem check for journaling.")

41−

41+

42parseDatabaseName :: Parser DatabaseName

43parseDatabaseName = strOption (short 'n' <>

44 long "database" <>

45 metavar "DATABASE_NAME")

46

47−parseHostname :: Hostname -> Parser Hostname

47+parseHostname :: Hostname -> Parser Hostname

48parseHostname defHostname = strOption (short 'h' <>

49 long "hostname" <>

50 metavar "HOST_NAME" <>

51 value defHostname)

52−

52+

53−parsePort :: Port -> Parser Port

53+parsePort :: Port -> Parser Port

54parsePort defPort = option auto (short 'p' <>

55 long "port" <>

56 metavar "PORT_NUMBER" <>

57 value defPort)

58−

58+

59parseGhcPkgPath :: Parser String

60parseGhcPkgPath = strOption (long "ghc-pkg-dir" <>

61 metavar "GHC_PACKAGE_DIRECTORY")

62−

62+

63−parseTimeout :: Int -> Parser Int

63+parseTimeout :: Int -> Parser Int

64parseTimeout defTimeout = option auto (long "timeout" <>

65 metavar "MICROSECONDS" <>

66 value defTimeout)

67

68parseConfig :: IO ServerConfig

69parseConfig = parseConfigWithDefaults defaultServerConfig

70−

70+

71parseConfigWithDefaults :: ServerConfig -> IO ServerConfig

72parseConfigWithDefaults defaults = execParser (info (parseArgsWithDefaults defaults <**> helpOption) idm)

73

74+parseWSConfigWithDefaults :: ServerConfig -> IO WebsocketServerConfig

75+parseWSConfigWithDefaults defaults = execParser (info (parseWSArgsWithDefaults defaults <**> helpOption) idm)

76+

77+parseWSArgsWithDefaults :: ServerConfig -> Parser WebsocketServerConfig

78+parseWSArgsWithDefaults defaults = WebsocketServerConfig <$>

79+ parseArgsWithDefaults defaults <*>

80+ parseTlsCertificatePath <*>

81+ parseTlsKeyPath

82+

83+

84+parseTlsCertificatePath :: Parser (Maybe String)

85+parseTlsCertificatePath = optional $ strOption (long "tls-certificate-path" <>

86+ metavar "TLS_CERTIFICATE_PATH")

87+

88+parseTlsKeyPath :: Parser (Maybe String)

89+parseTlsKeyPath = optional $ strOption (long "tls-key-path" <>

90+ metavar "TLS_KEY_PATH")

74

91

75helpOption :: Parser (a -> a)

92helpOption :: Parser (a -> a)

76−helpOption = abortOption ShowHelpText $ mconcat

93+helpOption = abortOption helpText $ mconcat

77 [ long "help"

94 [ long "help"

78 , help "Show this help text"

95 , help "Show this help text"

79 , hidden ]

96 , hidden ]

97+ where

98+#if MIN_VERSION_optparse_applicative(0,16,0)

99+ helpText = ShowHelpText Nothing

100+#else

101+ helpText = ShowHelpText

102+#endif

src/lib/ProjectM36/Server/RemoteCallTypes.hs+67−35

@@ -1,4 +1,4 @@

1−{-# LANGUAGE DeriveAnyClass, DeriveGeneric #-}

1+{-# LANGUAGE DeriveGeneric, DerivingVia, CPP #-}

2module ProjectM36.Server.RemoteCallTypes where

3import ProjectM36.Base

4import ProjectM36.IsomorphicSchema

@@ -6,66 +6,98 @@ import ProjectM36.TransactionGraph

6import ProjectM36.DataFrame

7import ProjectM36.TransGraphRelationalExpression

8import ProjectM36.Session

9+import ProjectM36.Serialise.DataFrame ()

10+import ProjectM36.Serialise.IsomorphicSchema ()

9import GHC.Generics

11import GHC.Generics

10−import Data.Binary

12+import Codec.Winery

11−import Control.Distributed.Process (ProcessId)

13+

14+#define RPCData(typeName) deriving Generic \

15+ deriving Serialise via WineryVariant typeName

12

16

13{-# ANN module ("HLint: ignore Use newtype instead of data" :: String) #-}

17{-# ANN module ("HLint: ignore Use newtype instead of data" :: String) #-}

14-- | The initial login message. The argument should be the process id of the initiating client. This ProcessId will receive notification callbacks.

18-- | The initial login message. The argument should be the process id of the initiating client. This ProcessId will receive notification callbacks.

15−data Login = Login ProcessId

19+data Login = Login DatabaseName

16− deriving (Binary, Generic)

20+ RPCData(Login)

17

21

18data Logout = Logout

22data Logout = Logout

19− deriving (Binary, Generic)

23+ RPCData(Logout)

24+

20−data ExecuteRelationalExpr = ExecuteRelationalExpr SessionId RelationalExpr

25+data ExecuteRelationalExpr = ExecuteRelationalExpr SessionId RelationalExpr

21− deriving (Binary, Generic)

26+ RPCData(ExecuteRelationalExpr)

27+

22data ExecuteDataFrameExpr = ExecuteDataFrameExpr SessionId DataFrameExpr

28data ExecuteDataFrameExpr = ExecuteDataFrameExpr SessionId DataFrameExpr

23− deriving (Binary, Generic)

29+ RPCData(ExecuteDataFrameExpr)

30+

24data ExecuteDatabaseContextExpr = ExecuteDatabaseContextExpr SessionId DatabaseContextExpr

31data ExecuteDatabaseContextExpr = ExecuteDatabaseContextExpr SessionId DatabaseContextExpr

25− deriving (Binary, Generic)

32+ RPCData(ExecuteDatabaseContextExpr)

33+

26data ExecuteDatabaseContextIOExpr = ExecuteDatabaseContextIOExpr SessionId DatabaseContextIOExpr

34data ExecuteDatabaseContextIOExpr = ExecuteDatabaseContextIOExpr SessionId DatabaseContextIOExpr

27− deriving (Binary, Generic)

35+ RPCData(ExecuteDatabaseContextIOExpr)

36+

28data ExecuteGraphExpr = ExecuteGraphExpr SessionId TransactionGraphOperator

37data ExecuteGraphExpr = ExecuteGraphExpr SessionId TransactionGraphOperator

29− deriving (Binary, Generic)

38+ RPCData(ExecuteGraphExpr)

39+

30data ExecuteTransGraphRelationalExpr = ExecuteTransGraphRelationalExpr SessionId TransGraphRelationalExpr

40data ExecuteTransGraphRelationalExpr = ExecuteTransGraphRelationalExpr SessionId TransGraphRelationalExpr

31− deriving (Binary, Generic)

41+ RPCData(ExecuteTransGraphRelationalExpr)

42+

32data ExecuteHeadName = ExecuteHeadName SessionId

43data ExecuteHeadName = ExecuteHeadName SessionId

33− deriving (Binary, Generic)

44+ RPCData(ExecuteHeadName)

45+

34data ExecuteTypeForRelationalExpr = ExecuteTypeForRelationalExpr SessionId RelationalExpr

46data ExecuteTypeForRelationalExpr = ExecuteTypeForRelationalExpr SessionId RelationalExpr

35− deriving (Binary, Generic)

47+ RPCData(ExecuteTypeForRelationalExpr)

48+

36−data ExecuteSchemaExpr = ExecuteSchemaExpr SessionId SchemaExpr

49+data ExecuteSchemaExpr = ExecuteSchemaExpr SessionId SchemaExpr RPCData(ExecuteSchemaExpr)

37− deriving (Binary, Generic)

50+

38data ExecuteSetCurrentSchema = ExecuteSetCurrentSchema SessionId SchemaName

51data ExecuteSetCurrentSchema = ExecuteSetCurrentSchema SessionId SchemaName

39− deriving (Binary, Generic)

52+ RPCData(ExecuteSetCurrentSchema)

53+

40data RetrieveInclusionDependencies = RetrieveInclusionDependencies SessionId

54data RetrieveInclusionDependencies = RetrieveInclusionDependencies SessionId

41− deriving (Binary, Generic)

55+ RPCData(RetrieveInclusionDependencies)

56+

42data RetrievePlanForDatabaseContextExpr = RetrievePlanForDatabaseContextExpr SessionId DatabaseContextExpr

57data RetrievePlanForDatabaseContextExpr = RetrievePlanForDatabaseContextExpr SessionId DatabaseContextExpr

43− deriving (Binary, Generic)

58+ RPCData(RetrievePlanForDatabaseContextExpr)

59+

44data RetrieveTransactionGraph = RetrieveTransactionGraph SessionId

60data RetrieveTransactionGraph = RetrieveTransactionGraph SessionId

45− deriving (Binary, Generic)

61+ RPCData(RetrieveTransactionGraph)

62+

46data RetrieveHeadTransactionId = RetrieveHeadTransactionId SessionId

63data RetrieveHeadTransactionId = RetrieveHeadTransactionId SessionId

47− deriving (Binary, Generic)

64+ RPCData(RetrieveHeadTransactionId)

65+

48data CreateSessionAtCommit = CreateSessionAtCommit TransactionId

66data CreateSessionAtCommit = CreateSessionAtCommit TransactionId

49− deriving (Binary, Generic)

67+ RPCData(CreateSessionAtCommit)

68+

50data CreateSessionAtHead = CreateSessionAtHead HeadName

69data CreateSessionAtHead = CreateSessionAtHead HeadName

51− deriving (Binary, Generic)

70+ RPCData(CreateSessionAtHead)

71+

52data CloseSession = CloseSession SessionId

72data CloseSession = CloseSession SessionId

53− deriving (Binary, Generic)

73+ RPCData(CloseSession)

74+

54data RetrieveAtomTypesAsRelation = RetrieveAtomTypesAsRelation SessionId

75data RetrieveAtomTypesAsRelation = RetrieveAtomTypesAsRelation SessionId

55− deriving (Binary, Generic)

76+ RPCData(RetrieveAtomTypesAsRelation)

77+

56data RetrieveRelationVariableSummary = RetrieveRelationVariableSummary SessionId

78data RetrieveRelationVariableSummary = RetrieveRelationVariableSummary SessionId

57− deriving (Binary, Generic)

79+ RPCData(RetrieveRelationVariableSummary)

80+

58data RetrieveAtomFunctionSummary = RetrieveAtomFunctionSummary SessionId

81data RetrieveAtomFunctionSummary = RetrieveAtomFunctionSummary SessionId

59− deriving (Binary, Generic)

82+ RPCData(RetrieveAtomFunctionSummary)

83+

60data RetrieveDatabaseContextFunctionSummary = RetrieveDatabaseContextFunctionSummary SessionId

84data RetrieveDatabaseContextFunctionSummary = RetrieveDatabaseContextFunctionSummary SessionId

61− deriving (Binary, Generic)

85+ RPCData(RetrieveDatabaseContextFunctionSummary)

86+

62data RetrieveCurrentSchemaName = RetrieveCurrentSchemaName SessionId

87data RetrieveCurrentSchemaName = RetrieveCurrentSchemaName SessionId

63− deriving (Binary, Generic)

88+ RPCData(RetrieveCurrentSchemaName)

89+

64data TestTimeout = TestTimeout SessionId

90data TestTimeout = TestTimeout SessionId

65− deriving (Binary, Generic)

91+ RPCData(TestTimeout)

92+

66−data RetrieveSessionIsDirty = RetrieveSessionIsDirty SessionId

93+data RetrieveSessionIsDirty = RetrieveSessionIsDirty SessionId

67− deriving (Binary, Generic)

94+ RPCData(RetrieveSessionIsDirty)

95+

68data ExecuteAutoMergeToHead = ExecuteAutoMergeToHead SessionId MergeStrategy HeadName

96data ExecuteAutoMergeToHead = ExecuteAutoMergeToHead SessionId MergeStrategy HeadName

69− deriving (Binary, Generic)

97+ RPCData(ExecuteAutoMergeToHead)

98+

70data RetrieveTypeConstructorMapping = RetrieveTypeConstructorMapping SessionId

99data RetrieveTypeConstructorMapping = RetrieveTypeConstructorMapping SessionId

71− deriving (Binary, Generic)

100+ RPCData(RetrieveTypeConstructorMapping)

101+

102+data ExecuteValidateMerkleHashes = ExecuteValidateMerkleHashes SessionId

103+ RPCData(ExecuteValidateMerkleHashes)

src/lib/ProjectM36/Sessions.hs+3−3

@@ -14,9 +14,11 @@ import ProjectM36.Session

14import ProjectM36.Relation

15import ProjectM36.Error

16import qualified Data.UUID as U

17−import qualified Control.Foldl as Foldl

18#if MIN_VERSION_stm_containers(1,0,0)

17#if MIN_VERSION_stm_containers(1,0,0)

18+import qualified Control.Foldl as Foldl

19import qualified DeferredFolds.UnfoldlM as UF

20+#else

21+import "list-t" ListT

20#endif

22#endif

21

23

22type Sessions = StmMap.Map SessionId Session

24type Sessions = StmMap.Map SessionId Session

@@ -45,5 +47,3 @@ sessionsAsRelation sessions = do

45 let atomMatrix = map (\(sessionId, session) -> [uuidAtom sessionId, uuidAtom (parentId session)]) sessionAssocs

47 let atomMatrix = map (\(sessionId, session) -> [uuidAtom sessionId, uuidAtom (parentId session)]) sessionAssocs

46 pure $ mkRelationFromList (attributesFromList [Attribute "sessionid" TextAtomType,

48 pure $ mkRelationFromList (attributesFromList [Attribute "sessionid" TextAtomType,

47 Attribute "parentCommit" TextAtomType]) atomMatrix

49 Attribute "parentCommit" TextAtomType]) atomMatrix

48−

49−

src/lib/ProjectM36/Shortcuts.hsnew file+247

@@ -0,0 +1,247 @@

1+{-# OPTIONS_GHC -fno-warn-orphans #-}

2+{-# LANGUAGE ScopedTypeVariables #-}

3+{-# LANGUAGE TypeApplications #-}

4+{-# LANGUAGE FlexibleInstances #-}

5+{-# LANGUAGE MultiParamTypeClasses #-}

6+{-# LANGUAGE TypeFamilies #-}

7+{-# LANGUAGE ExtendedDefaultRules #-}

8+{-# LANGUAGE ExistentialQuantification #-}

9+{-# LANGUAGE FlexibleContexts #-}

10+{-# LANGUAGE GADTs #-}

11+{-# LANGUAGE UndecidableInstances #-}

12+module ProjectM36.Shortcuts where

13+-- users need OverloadedLabels, OverloadedLists, and default(Int,Text) to use these shortcuts.

14+import Data.Text hiding (foldl, map)

15+import ProjectM36.Base

16+import ProjectM36.Relation

17+import ProjectM36.Atomable

18+import Prelude hiding ((!!))

19+import Data.Proxy

20+import GHC.OverloadedLabels

21+import GHC.TypeLits hiding (Text)

22+import qualified Data.Text as T

23+import qualified Data.Map as M

24+import qualified Data.Set as S

25+import GHC.Exts (IsList(..))

26+import Data.Convertible

27+

28+default (Text)

29+

30+instance IsList (AttributeNamesBase ()) where

31+ type Item (AttributeNamesBase ()) = AttributeName

32+ fromList = AttributeNames . S.fromList

33+ toList (AttributeNames ns) = S.toList ns

34+ toList _ = error "needs AttributeNames"

35+

36+instance IsList (TupleExprsBase ()) where

37+ type Item TupleExprs = TupleExpr

38+ fromList ts = TupleExprs () ts

39+ toList (TupleExprs _ ts) = ts

40+

41+instance IsList TupleExpr where

42+ type Item TupleExpr = (AttributeName, AtomExpr)

43+ fromList attributeValues = TupleExpr (M.fromList attributeValues)

44+ toList (TupleExpr attributeValues) = M.toList attributeValues

45+

46+

47+-- #xxx :: Text

48+instance KnownSymbol x => IsLabel x Text where

49+ fromLabel = T.pack $ symbolVal @x Proxy

50+

51+-- #relvarName :: RelationalExpr

52+instance KnownSymbol x => IsLabel x RelationalExpr where

53+ fromLabel = RelationVariable (T.pack $ symbolVal @x Proxy) ()

54+

55+-- *Main> #a Int :: AttributeExpr

56+-- NakedAttributeExpr (Attribute "a" IntAtomType)

57+-- *Main> #a (Attr @[Int]) :: AttributeExpr

58+-- NakedAttributeExpr (Attribute "a" (ConstructedAtomType "List" (fromList [("a",IntAtomType)])))

59+-- can't offer a Relation atomtype -- don't know how to express a Relation type in haskell type. Maybe something a HList of (Text, a) ?

60+--

61+-- ps. I don't understand the usage of "AttributeAndTypeNameExpr AttributeName TypeConstructor a"

62+instance (KnownSymbol x, Atomable a)=> IsLabel x (HaskAtomType a -> AttributeExpr) where

63+ fromLabel = (NakedAttributeExpr . Attribute name) . toAtomType''

64+ where name = T.pack $ symbolVal @x Proxy

65+

66+-- (#a 1) :: ExtendTupleExpr

67+-- no need for :=

68+instance (Convertible a AtomExpr, KnownSymbol x) => IsLabel x (a -> ExtendTupleExpr) where

69+ fromLabel x = AttributeExtendTupleExpr name (convert x)

70+ where name = T.pack $ symbolVal @x Proxy

71+

72+-- #name AtomExpr

73+-- ex. tuple [ #name 3 ]

74+-- default(Text) is needed in client code to avoid `no Atomable Char`

75+instance (Convertible a AtomExpr, KnownSymbol x) => IsLabel x (a -> (AttributeName, AtomExpr)) where

76+ fromLabel = \x -> (name, convert x)

77+ where name = T.pack $ symbolVal @x Proxy

78+

79+-- *Main> #a [1] :: AtomExpr

80+-- FunctionAtomExpr "a" [NakedAtomExpr (IntegerAtom 1)] ()

81+--

82+-- This usage is not working in RestrictionPredicateExpr and AttributeExtendTupleExpr. Use f "a" [1] instead.

83+instance (KnownSymbol x, Convertible a AtomExpr) => IsLabel x ([a] -> AtomExpr) where

84+ fromLabel = \as' -> FunctionAtomExpr name (map convert as') ()

85+ where name = T.pack $ symbolVal @x Proxy

86+

87+instance (KnownSymbol x) => IsLabel x AtomExpr where

88+ fromLabel = AttributeAtomExpr name

89+ where name = T.pack $ symbolVal @x Proxy

90+

91+

92+data HaskAtomType a where

93+ Int :: HaskAtomType Int

94+ Integer :: HaskAtomType Integer

95+ Double :: HaskAtomType Double

96+ Text :: HaskAtomType Text

97+-- Day :: HaskAtomType Day

98+-- DateTime :: HaskAtomType DateTime

99+-- ByteString :: HaskAtomType ByteString

100+ Bool :: HaskAtomType Bool

101+ Attr :: Atomable a => HaskAtomType a -- a Proxy-like value for type application.

102+

103+toAtomType'' :: Atomable a => HaskAtomType a -> AtomType

104+toAtomType'' (_ :: HaskAtomType a) = toAtomType (Proxy @a)

105+

106+-- usage: relation [tuple [#a 1, #b "b"], tuple [#a 2, #b "b"]]

107+relation :: [TupleExpr] -> RelationalExpr

108+relation ts = MakeRelationFromExprs Nothing (TupleExprs () ts)

109+

110+relation' :: [AttributeExprBase ()] -> [TupleExpr] -> RelationalExpr

111+relation' as' ts = MakeRelationFromExprs (Just as') (TupleExprs () ts)

112+

113+-- usage: tuple [#name "Mike",#age 6]

114+tuple :: [(AttributeName, AtomExpr)] -> TupleExprBase ()

115+tuple as' = TupleExpr (M.fromList as')

116+

117+-- #a rename [#b `as` #c]

118+rename :: RelationalExpr -> [(AttributeName,AttributeName)] -> RelationalExpr

119+rename relExpr renameList = case renameList of

120+ [] -> Restrict TruePredicate relExpr

121+ renames ->

122+ foldl (\acc (old,new) -> Rename old new acc) relExpr renames

123+

124+--project !!

125+-- #a !! [#b,#c]

126+infix 9 !!

127+(!!) :: RelationalExpr -> AttributeNames -> RelationalExpr

128+relExpr !! xs = Project xs relExpr

129+

130+--join ><

131+-- #a >< #b

132+(><) :: RelationalExpr -> RelationalExpr -> RelationalExpr

133+a >< b = Join a b

134+

135+allBut :: AttributeNames -> AttributeNames

136+allBut (AttributeNames ns) = InvertedAttributeNames ns

137+allBut _ = error "give allBut something other than attribute names."

138+

139+allFrom :: RelationalExpr -> AttributeNames

140+allFrom = RelationalExprAttributeNames

141+

142+as :: AttributeNames -> AttributeName -> (AttributeNames, AttributeName)

143+as = (,)

144+

145+-- #a `group` ([#b,#c] `as` #d)

146+group :: RelationalExpr -> (AttributeNames, AttributeName) -> RelationalExpr

147+group relExpr (aNames, aName) = Group aNames aName relExpr

148+

149+-- #a `ungroup` #b

150+ungroup :: RelationalExpr -> AttributeName -> RelationalExpr

151+ungroup relExpr aName = Ungroup aName relExpr

152+

153+-- *Main> #a #:= true #: ( #b (f "count" [1,2]))

154+-- Assign "a" (Extend (AttributeExtendTupleExpr "b" (FunctionAtomExpr "count" [NakedAtomExpr (IntegerAtom 1),NakedAtomExpr (IntegerAtom 2)] ())) (ExistingRelation (Relation attributesFromList [] (RelationTupleSet {asList = [RelationTuple attributesFromList [] []]}))))

155+(#:) :: RelationalExpr -> ExtendTupleExpr -> RelationalExpr

156+a #: b = Extend b a

157+infix 8 #:

158+

159+instance Convertible AtomExpr AtomExpr where

160+ safeConvert n = Right n

161+

162+instance Convertible RelVarName AtomExpr where

163+ safeConvert n = Right $ RelationAtomExpr (RelationVariable n ())

164+

165+instance Convertible RelationalExpr AtomExpr where

166+ safeConvert relExpr = Right $ RelationAtomExpr relExpr

167+

168+instance Convertible RelVarName RelationalExpr where

169+ safeConvert n = Right $ RelationVariable n ()

170+

171+-- @ in tutd

172+-- (@@) "aaa"

173+(@@) :: AttributeName -> AtomExpr

174+(@@) = AttributeAtomExpr

175+

176+-- works in RestrictedPredicateExpr and AttributeExtendTupleExpr

177+-- usage: f "gte" [1]

178+f :: Convertible a AtomExpr => AtomFunctionName -> [a] -> AtomExpr

179+f n as' = FunctionAtomExpr n (map convert as') ()

180+

181+-- DatabaseContextExpr

182+-- define

183+(#::) :: RelVarName -> [AttributeExpr] -> DatabaseContextExpr

184+s #:: xs = Define s xs

185+infix 5 #::

186+

187+-- assign

188+(#:=) :: RelVarName -> RelationalExpr -> DatabaseContextExpr

189+s #:= r = Assign s r

190+infix 5 #:=

191+

192+class Boolean a b where

193+ (&&&) :: a -> b -> RestrictionPredicateExpr

194+ infixl 6 &&&

195+ (|||) :: a -> b -> RestrictionPredicateExpr

196+ infixl 5 |||

197+

198+-- where: @~ mimics the restriction symbol in algebra

199+-- usage: true #: (#a 1) @~ #a ?= 1 &&& not' false ||| (f "gte" [1])

200+(@~) :: Convertible a RestrictionPredicateExpr => RelationalExpr -> a -> RelationalExpr

201+(@~) relExpr resPreExpr = Restrict (convert resPreExpr) relExpr

202+infix 4 @~

203+

204+true :: RelationalExpr

205+true = ExistingRelation relationTrue

206+

207+false :: RelationalExpr

208+false = ExistingRelation relationFalse

209+

210+trueP :: RestrictionPredicateExprBase a

211+trueP = TruePredicate

212+

213+falseP :: RestrictionPredicateExprBase a

214+falseP = NotPredicate TruePredicate

215+

216+(?=) :: Convertible a AtomExpr => AttributeName -> a -> RestrictionPredicateExpr

217+(?=) name a = AttributeEqualityPredicate name (convert a)

218+infix 9 ?=

219+

220+not' :: Convertible a RestrictionPredicateExpr => a -> RestrictionPredicateExpr

221+not' = NotPredicate . convert

222+

223+instance (Convertible a RestrictionPredicateExpr, Convertible b RestrictionPredicateExpr) => Boolean a b where

224+ a &&& b = AndPredicate (convert a) (convert b)

225+ a ||| b = OrPredicate (convert a) (convert b)

226+

227+instance {-# Incoherent #-} Atomable a => Convertible a RestrictionPredicateExpr where

228+ safeConvert n = Right $ AtomExprPredicate $ toAtomExpr . toAtom $ n

229+

230+instance {-# Incoherent #-} Convertible RelationalExpr RestrictionPredicateExpr where

231+ safeConvert a = Right $ RelationalExprPredicate a

232+

233+instance {-# Incoherent #-} Convertible AtomExpr RestrictionPredicateExpr where

234+ safeConvert a = Right $ AtomExprPredicate a

235+

236+instance {-# Incoherent #-} Convertible RestrictionPredicateExpr RestrictionPredicateExpr where

237+ safeConvert a = Right a

238+

239+instance {-# Incoherent #-} Atomable a => Convertible a AtomExpr where

240+ safeConvert n = Right $ toAtomExpr . toAtom $ n

241+

242+toAtomExpr :: Atom -> AtomExpr

243+toAtomExpr (ConstructedAtom n _ xs) = ConstructedAtomExpr n (toAtomExpr <$> xs) ()

244+toAtomExpr a = NakedAtomExpr a

245+

246+

247+

src/lib/ProjectM36/StaticOptimizer.hs+201−95

@@ -1,9 +1,11 @@

1+{-# LANGUAGE FlexibleInstances #-}

2+{-# LANGUAGE FlexibleContexts #-}

1module ProjectM36.StaticOptimizer where

3module ProjectM36.StaticOptimizer where

2import ProjectM36.Base

4import ProjectM36.Base

3import ProjectM36.GraphRefRelationalExpr

5import ProjectM36.GraphRefRelationalExpr

4import ProjectM36.Relation

6import ProjectM36.Relation

5import ProjectM36.RelationalExpression

7import ProjectM36.RelationalExpression

6−import ProjectM36.TransGraphRelationalExpression as TGRE

8+import ProjectM36.TransGraphRelationalExpression as TGRE hiding (askGraph)

7import ProjectM36.Error

9import ProjectM36.Error

8import ProjectM36.Transaction

10import ProjectM36.Transaction

9import ProjectM36.NormalizeExpr

11import ProjectM36.NormalizeExpr

@@ -18,67 +20,152 @@ import Data.Functor.Identity

18import qualified Data.Map as M

20import qualified Data.Map as M

19import qualified Data.Set as S

21import qualified Data.Set as S

20

22

21−type StaticOptimizerEnv = RelationalExprEnv

22−

23−type StaticOptimizerMonad a = ReaderT StaticOptimizerEnv (ExceptT RelationalError Identity) a

24-- the static optimizer performs optimizations which need not take any specific-relation statistics into account

23-- the static optimizer performs optimizations which need not take any specific-relation statistics into account

25

24

26−type GraphRefStaticOptimizerMonad a = ReaderT TransactionGraph (ExceptT RelationalError Identity) a

25+data GraphRefSOptRelationalExprEnv =

26+ GraphRefSOptRelationalExprEnv

27+ {

28+ ore_graph :: TransactionGraph,

29+ ore_mcontext :: Maybe DatabaseContext

30+ }

31+

32+type GraphRefSOptRelationalExprM a = ReaderT GraphRefSOptRelationalExprEnv (ExceptT RelationalError Identity) a

33+

34+data GraphRefSOptDatabaseContextExprEnv =

35+ GraphRefSOptDatabaseContextExprEnv

36+ {

37+ odce_graph :: TransactionGraph,

38+ odce_context :: DatabaseContext, --not optional for DatabaseContextExpr evaluation

39+ odce_transId :: TransactionId -- parent if context is committed- needed because MultipleExpr optimization requires running the DatabaseContextExprs (with empty relvars)

40+ }

41+

42+type GraphRefSOptDatabaseContextExprM a = ReaderT GraphRefSOptDatabaseContextExprEnv (ExceptT RelationalError Identity) a

27

43

28-- | A temporary function to be replaced by IO-based implementation.

44-- | A temporary function to be replaced by IO-based implementation.

29optimizeAndEvalRelationalExpr :: RelationalExprEnv -> RelationalExpr -> Either RelationalError Relation

45optimizeAndEvalRelationalExpr :: RelationalExprEnv -> RelationalExpr -> Either RelationalError Relation

30optimizeAndEvalRelationalExpr env expr = do

46optimizeAndEvalRelationalExpr env expr = do

31− let gfExpr = runProcessExprM tid graph (processRelationalExpr expr)

47+ let gfExpr = runProcessExprM UncommittedContextMarker (processRelationalExpr expr) -- references parent tid instead of context! options- I could add the context to the graph with a new transid or implement an evalRelationalExpr in RE.hs to use the context (which is what I had previously)

32− tid = re_currentTransId env

33 graph = re_graph env

48 graph = re_graph env

49+ ctx = re_context env

34− gfEnv = freshGraphRefRelationalExprEnv graph

50+ gfEnv = freshGraphRefRelationalExprEnv (Just ctx) graph

35− optExpr <- runGraphRefStaticOptimizerMonad (re_graph env) (fullOptimizeGraphRefRelationalExpr gfExpr)

51+ optExpr <- runGraphRefSOptRelationalExprM (Just ctx) (re_graph env) (fullOptimizeGraphRefRelationalExpr gfExpr)

36 runGraphRefRelationalExprM gfEnv (evalGraphRefRelationalExpr optExpr)

52 runGraphRefRelationalExprM gfEnv (evalGraphRefRelationalExpr optExpr)

37

53

54+class Monad m => AskGraphContext m where

55+ askGraph :: m TransactionGraph

56+ askContext :: m DatabaseContext

57+

58+instance AskGraphContext (ReaderT GraphRefSOptDatabaseContextExprEnv (ExceptT RelationalError Identity)) where

59+ askGraph = asks odce_graph

60+ askContext = asks odce_context

61+

62+instance AskGraphContext (ReaderT GraphRefSOptRelationalExprEnv (ExceptT RelationalError Identity)) where

63+ askGraph = asks ore_graph

64+ askContext = do

65+ mctx <- asks ore_mcontext

66+ case mctx of

67+ Nothing -> throwError NoUncommittedContextInEvalError

68+ Just ctx -> pure ctx

69+

70+askTransId :: GraphRefSOptDatabaseContextExprM TransactionId

71+askTransId = asks odce_transId

72+

73+askMaybeContext :: GraphRefSOptRelationalExprM (Maybe DatabaseContext)

74+askMaybeContext = asks ore_mcontext

75+

76+optimizeDatabaseContextExpr :: DatabaseContextExpr -> GraphRefSOptDatabaseContextExprM GraphRefDatabaseContextExpr

77+optimizeDatabaseContextExpr expr = do

78+ let gfExpr = runProcessExprM UncommittedContextMarker (processDatabaseContextExpr expr)

79+ optimizeGraphRefDatabaseContextExpr gfExpr

80+

38optimizeAndEvalDatabaseContextExpr :: Bool -> DatabaseContextExpr -> DatabaseContextEvalMonad ()

81optimizeAndEvalDatabaseContextExpr :: Bool -> DatabaseContextExpr -> DatabaseContextEvalMonad ()

39optimizeAndEvalDatabaseContextExpr optimize expr = do

82optimizeAndEvalDatabaseContextExpr optimize expr = do

83+ graph <- asks dce_graph

40− tid <- dce_transId <$> ask

84+ transId <- asks dce_transId

41− graph <- dce_graph <$> ask

85+ context <- getStateContext

42− let gfExpr = runProcessExprM tid graph (processDatabaseContextExpr expr)

86+ let gfExpr = runProcessExprM UncommittedContextMarker (processDatabaseContextExpr expr)

43 eOptExpr = if optimize then

87 eOptExpr = if optimize then

44− runGraphRefStaticOptimizerMonad graph (optimizeGraphRefDatabaseContextExpr gfExpr)

88+ runGraphRefSOptDatabaseContextExprM transId context graph (optimizeGraphRefDatabaseContextExpr gfExpr)

45 else

89 else

46 pure gfExpr

90 pure gfExpr

47 case eOptExpr of

91 case eOptExpr of

48 Left err -> throwError err

92 Left err -> throwError err

49 Right optExpr -> evalGraphRefDatabaseContextExpr optExpr

93 Right optExpr -> evalGraphRefDatabaseContextExpr optExpr

50

94

95+

51optimizeAndEvalTransGraphRelationalExpr :: TransactionGraph -> TransGraphRelationalExpr -> Either RelationalError Relation

96optimizeAndEvalTransGraphRelationalExpr :: TransactionGraph -> TransGraphRelationalExpr -> Either RelationalError Relation

52optimizeAndEvalTransGraphRelationalExpr graph tgExpr = do

97optimizeAndEvalTransGraphRelationalExpr graph tgExpr = do

53 gfExpr <- TGRE.process (TransGraphEvalEnv graph) tgExpr

98 gfExpr <- TGRE.process (TransGraphEvalEnv graph) tgExpr

54− optExpr <- runGraphRefStaticOptimizerMonad graph (fullOptimizeGraphRefRelationalExpr gfExpr)

99+ optExpr <- runGraphRefSOptRelationalExprM Nothing graph (fullOptimizeGraphRefRelationalExpr gfExpr)

55− let gfEnv = freshGraphRefRelationalExprEnv graph

100+ let gfEnv = freshGraphRefRelationalExprEnv Nothing graph

56 runGraphRefRelationalExprM gfEnv (evalGraphRefRelationalExpr optExpr)

101 runGraphRefRelationalExprM gfEnv (evalGraphRefRelationalExpr optExpr)

57

102

58optimizeAndEvalDatabaseContextIOExpr :: DatabaseContextIOExpr -> DatabaseContextIOEvalMonad (Either RelationalError ())

103optimizeAndEvalDatabaseContextIOExpr :: DatabaseContextIOExpr -> DatabaseContextIOEvalMonad (Either RelationalError ())

59optimizeAndEvalDatabaseContextIOExpr expr = do

104optimizeAndEvalDatabaseContextIOExpr expr = do

60− env <- getDBCIORelationalExprEnv

105+ transId <- asks dbcio_transId

106+ ctx <- getDBCIOContext

107+ graph <- asks dbcio_graph

61− let gfExpr = runProcessExprM tid graph (processDatabaseContextIOExpr expr)

108+ let gfExpr = runProcessExprM UncommittedContextMarker (processDatabaseContextIOExpr expr)

62− eOptExpr = runStaticOptimizerMonad env (optimizeDatabaseContextIOExpr gfExpr)

109+ eOptExpr = runGraphRefSOptDatabaseContextExprM transId ctx graph (optimizeDatabaseContextIOExpr gfExpr)

63− tid = re_currentTransId env

64− graph = re_graph env

65 case eOptExpr of

110 case eOptExpr of

66 Left err -> pure (Left err)

111 Left err -> pure (Left err)

67 Right optExpr ->

112 Right optExpr ->

68 evalGraphRefDatabaseContextIOExpr optExpr

113 evalGraphRefDatabaseContextIOExpr optExpr

69

114

70−

115+{-

71runStaticOptimizerMonad :: RelationalExprEnv -> StaticOptimizerMonad a -> Either RelationalError a

116runStaticOptimizerMonad :: RelationalExprEnv -> StaticOptimizerMonad a -> Either RelationalError a

72runStaticOptimizerMonad env m = runIdentity (runExceptT (runReaderT m env))

117runStaticOptimizerMonad env m = runIdentity (runExceptT (runReaderT m env))

118+-}

119+

120+runGraphRefSOptRelationalExprM ::

121+ Maybe DatabaseContext ->

122+ TransactionGraph ->

123+ GraphRefSOptRelationalExprM a ->

124+ Either RelationalError a

125+runGraphRefSOptRelationalExprM mctx graph m = runIdentity (runExceptT (runReaderT m env))

126+ where

127+ env = GraphRefSOptRelationalExprEnv {

128+ ore_graph = graph,

129+ ore_mcontext = mctx

130+ }

131+

73

132

74−runGraphRefStaticOptimizerMonad :: TransactionGraph -> GraphRefStaticOptimizerMonad a -> Either RelationalError a

133+runGraphRefSOptDatabaseContextExprM ::

134+ TransactionId ->

135+ DatabaseContext ->

136+ TransactionGraph ->

137+ GraphRefSOptDatabaseContextExprM a ->

138+ Either RelationalError a

139+runGraphRefSOptDatabaseContextExprM tid ctx graph m =

75−runGraphRefStaticOptimizerMonad graph m = runIdentity (runExceptT (runReaderT m graph))

140+ runIdentity (runExceptT (runReaderT m env))

76−

141+ where

77−--RelationalExprEnv should not be necessary for graph ref re optimization!

142+ env = GraphRefSOptDatabaseContextExprEnv {

78−optimizeGraphRefRelationalExpr' :: TransactionGraph -> GraphRefRelationalExpr -> Either RelationalError GraphRefRelationalExpr

143+ odce_graph = graph,

79−optimizeGraphRefRelationalExpr' graph expr = runIdentity (runExceptT (runReaderT (optimizeGraphRefRelationalExpr expr) graph))

144+ odce_context = ctx,

80−

145+ odce_transId = tid

146+ }

147+

148+optimizeGraphRefRelationalExpr' ::

149+ Maybe DatabaseContext ->

150+ TransactionGraph ->

151+ GraphRefRelationalExpr ->

152+ Either RelationalError GraphRefRelationalExpr

153+optimizeGraphRefRelationalExpr' mctx graph expr =

154+ runIdentity (runExceptT (runReaderT (optimizeGraphRefRelationalExpr expr) env))

155+ where

156+ env = GraphRefSOptRelationalExprEnv {

157+ ore_graph = graph,

158+ ore_mcontext = mctx

159+ }

160+

161+-- | optimize relational expression within database context expr monad

162+liftGraphRefRelExpr :: GraphRefSOptRelationalExprM a -> GraphRefSOptDatabaseContextExprM a

163+liftGraphRefRelExpr m = do

164+ context <- asks odce_context

165+ graph <- asks odce_graph

166+ lift $ except $ runGraphRefSOptRelationalExprM (Just context) graph m

167+

81−fullOptimizeGraphRefRelationalExpr :: GraphRefRelationalExpr -> GraphRefStaticOptimizerMonad GraphRefRelationalExpr

168+fullOptimizeGraphRefRelationalExpr :: GraphRefRelationalExpr -> GraphRefSOptRelationalExprM GraphRefRelationalExpr

82fullOptimizeGraphRefRelationalExpr expr = do

169fullOptimizeGraphRefRelationalExpr expr = do

83 optExpr <- optimizeGraphRefRelationalExpr expr

170 optExpr <- optimizeGraphRefRelationalExpr expr

84 let optExpr' = applyStaticRestrictionPushdown (applyStaticRestrictionCollapse optExpr)

171 let optExpr' = applyStaticRestrictionPushdown (applyStaticRestrictionCollapse optExpr)

@@ -87,10 +174,10 @@ fullOptimizeGraphRefRelationalExpr expr = do

87-- apply optimizations which merely remove steps to become no-ops: example: projection of a relation across all of its attributes => original relation

174-- apply optimizations which merely remove steps to become no-ops: example: projection of a relation across all of its attributes => original relation

88

175

89--should optimizations offer the possibility to pure errors? If they perform the up-front type-checking, maybe so

176--should optimizations offer the possibility to pure errors? If they perform the up-front type-checking, maybe so

90−optimizeGraphRefRelationalExpr :: GraphRefRelationalExpr -> GraphRefStaticOptimizerMonad GraphRefRelationalExpr

177+optimizeGraphRefRelationalExpr :: GraphRefRelationalExpr -> GraphRefSOptRelationalExprM GraphRefRelationalExpr

91optimizeGraphRefRelationalExpr e@(MakeStaticRelation _ _) = pure e

178optimizeGraphRefRelationalExpr e@(MakeStaticRelation _ _) = pure e

92

179

93−optimizeGraphRefRelationalExpr e@(MakeRelationFromExprs _ _) = pure e

180+optimizeGraphRefRelationalExpr e@MakeRelationFromExprs{} = pure e

94

181

95optimizeGraphRefRelationalExpr e@(ExistingRelation _) = pure e

182optimizeGraphRefRelationalExpr e@(ExistingRelation _) = pure e

96

183

@@ -98,9 +185,10 @@ optimizeGraphRefRelationalExpr e@(RelationVariable _ _) = pure e

98

185

99--remove project of attributes which removes no attributes

186--remove project of attributes which removes no attributes

100optimizeGraphRefRelationalExpr (Project attrNameSet expr) = do

187optimizeGraphRefRelationalExpr (Project attrNameSet expr) = do

101− graph <- ask

188+ graph <- askGraph

189+ mctx <- askMaybeContext

102 let relType = runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr expr)

190 let relType = runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr expr)

103− gfEnv = freshGraphRefRelationalExprEnv graph

191+ gfEnv = freshGraphRefRelationalExprEnv mctx graph

104 case relType of

192 case relType of

105 Left err -> throwError err

193 Left err -> throwError err

106 Right relType2

194 Right relType2

@@ -119,6 +207,8 @@ optimizeGraphRefRelationalExpr (Union exprA exprB) = do

119 case (optExprA, optExprB) of

207 case (optExprA, optExprB) of

120 (Restrict predA (RelationVariable nameA sA),

208 (Restrict predA (RelationVariable nameA sA),

121 Restrict predB (RelationVariable nameB sB)) | nameA == nameB && sA == sB -> pure (Restrict (AndPredicate predA predB) (RelationVariable nameA sA))

209 Restrict predB (RelationVariable nameB sB)) | nameA == nameB && sA == sB -> pure (Restrict (AndPredicate predA predB) (RelationVariable nameA sA))

210+ (exprA', exprB') | isEmptyRelationExpr exprA' -> pure exprB'

211+ | isEmptyRelationExpr exprB' -> pure exprA'

122 _ -> if optExprA == optExprB then

212 _ -> if optExprA == optExprB then

123 pure optExprA

213 pure optExprA

124 else

214 else

@@ -137,12 +227,13 @@ optimizeGraphRefRelationalExpr (Join exprA exprB) = do

137 pure (Join optExprA optExprB)

227 pure (Join optExprA optExprB)

138

228

139optimizeGraphRefRelationalExpr (Difference exprA exprB) = do

229optimizeGraphRefRelationalExpr (Difference exprA exprB) = do

140− graph <- ask

230+ graph <- askGraph

231+ context <- askMaybeContext

141 optExprA <- optimizeGraphRefRelationalExpr exprA

232 optExprA <- optimizeGraphRefRelationalExpr exprA

142 optExprB <- optimizeGraphRefRelationalExpr exprB

233 optExprB <- optimizeGraphRefRelationalExpr exprB

143 if optExprA == optExprB then do --A difference A == A where false

234 if optExprA == optExprB then do --A difference A == A where false

144 let eEmptyRel = runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr optExprA)

235 let eEmptyRel = runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr optExprA)

145− gfEnv = freshGraphRefRelationalExprEnv graph

236+ gfEnv = freshGraphRefRelationalExprEnv context graph

146 case eEmptyRel of

237 case eEmptyRel of

147 Left err -> throwError err

238 Left err -> throwError err

148 Right emptyRel -> pure (ExistingRelation emptyRel)

239 Right emptyRel -> pure (ExistingRelation emptyRel)

@@ -159,13 +250,14 @@ optimizeGraphRefRelationalExpr (Ungroup attrName expr) =

159

250

160--remove restriction of nothing

251--remove restriction of nothing

161optimizeGraphRefRelationalExpr (Restrict predicate expr) = do

252optimizeGraphRefRelationalExpr (Restrict predicate expr) = do

162− graph <- ask

253+ graph <- askGraph

254+ mctx <- askMaybeContext

163 optimizedPredicate <- applyStaticPredicateOptimization predicate

255 optimizedPredicate <- applyStaticPredicateOptimization predicate

164 case optimizedPredicate of

256 case optimizedPredicate of

165 optimizedPredicate' | isTrueExpr optimizedPredicate' -> optimizeGraphRefRelationalExpr expr -- remove predicate entirely

257 optimizedPredicate' | isTrueExpr optimizedPredicate' -> optimizeGraphRefRelationalExpr expr -- remove predicate entirely

166 optimizedPredicate' | isFalseExpr optimizedPredicate' -> do -- replace where false predicate with empty relation with attributes from relexpr

258 optimizedPredicate' | isFalseExpr optimizedPredicate' -> do -- replace where false predicate with empty relation with attributes from relexpr

167 let attributesRel = runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr expr)

259 let attributesRel = runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr expr)

168− gfEnv = freshGraphRefRelationalExprEnv graph

260+ gfEnv = freshGraphRefRelationalExprEnv mctx graph

169 case attributesRel of

261 case attributesRel of

170 Left err -> throwError err

262 Left err -> throwError err

171 Right attributesRelA -> pure $ MakeStaticRelation (attributes attributesRelA) emptyTupleSet

263 Right attributesRelA -> pure $ MakeStaticRelation (attributes attributesRelA) emptyTupleSet

@@ -182,18 +274,18 @@ optimizeGraphRefRelationalExpr e@(Extend _ _) = pure e

182optimizeGraphRefRelationalExpr e@(With _ _) = pure e

274optimizeGraphRefRelationalExpr e@(With _ _) = pure e

183

275

184-- database context expr

276-- database context expr

185−optimizeGraphRefDatabaseContextExpr :: GraphRefDatabaseContextExpr -> GraphRefStaticOptimizerMonad GraphRefDatabaseContextExpr

277+optimizeGraphRefDatabaseContextExpr :: GraphRefDatabaseContextExpr -> GraphRefSOptDatabaseContextExprM GraphRefDatabaseContextExpr

186optimizeGraphRefDatabaseContextExpr x@NoOperation = pure x

278optimizeGraphRefDatabaseContextExpr x@NoOperation = pure x

187optimizeGraphRefDatabaseContextExpr x@(Define _ _) = pure x

279optimizeGraphRefDatabaseContextExpr x@(Define _ _) = pure x

188

280

189optimizeGraphRefDatabaseContextExpr x@(Undefine _) = pure x

281optimizeGraphRefDatabaseContextExpr x@(Undefine _) = pure x

190

282

191optimizeGraphRefDatabaseContextExpr (Assign name expr) = do

283optimizeGraphRefDatabaseContextExpr (Assign name expr) = do

192− optExpr <- optimizeGraphRefRelationalExpr expr

284+ optExpr <- liftGraphRefRelExpr (fullOptimizeGraphRefRelationalExpr expr)

193 pure $ Assign name optExpr

285 pure $ Assign name optExpr

194

286

195optimizeGraphRefDatabaseContextExpr (Insert targetName expr) = do

287optimizeGraphRefDatabaseContextExpr (Insert targetName expr) = do

196− optimizedExpr <- fullOptimizeGraphRefRelationalExpr expr

288+ optimizedExpr <- liftGraphRefRelExpr (fullOptimizeGraphRefRelationalExpr expr)

197 if isEmptyRelationExpr optimizedExpr then -- if we are trying to insert an empty relation, do nothing

289 if isEmptyRelationExpr optimizedExpr then -- if we are trying to insert an empty relation, do nothing

198 pure NoOperation

290 pure NoOperation

199 else

291 else

@@ -204,10 +296,10 @@ optimizeGraphRefDatabaseContextExpr (Insert targetName expr) = do

204 _ -> pure (Insert targetName optimizedExpr)

296 _ -> pure (Insert targetName optimizedExpr)

205

297

206optimizeGraphRefDatabaseContextExpr (Delete name predicate) =

298optimizeGraphRefDatabaseContextExpr (Delete name predicate) =

207− Delete name <$> applyStaticPredicateOptimization predicate

299+ Delete name <$> liftGraphRefRelExpr (applyStaticPredicateOptimization predicate)

208

300

209optimizeGraphRefDatabaseContextExpr (Update name upmap predicate) =

301optimizeGraphRefDatabaseContextExpr (Update name upmap predicate) =

210− Update name upmap <$> applyStaticPredicateOptimization predicate

302+ Update name upmap <$> liftGraphRefRelExpr (applyStaticPredicateOptimization predicate)

211

303

212optimizeGraphRefDatabaseContextExpr dep@(AddInclusionDependency _ _) = pure dep

304optimizeGraphRefDatabaseContextExpr dep@(AddInclusionDependency _ _) = pure dep

213

305

@@ -229,14 +321,28 @@ optimizeGraphRefDatabaseContextExpr c@(ExecuteDatabaseContextFunction _ _) = pur

229

321

230--applyStaticDatabaseOptimization (MultipleExpr exprs) = pure $ Right $ MultipleExpr exprs

322--applyStaticDatabaseOptimization (MultipleExpr exprs) = pure $ Right $ MultipleExpr exprs

231--for multiple expressions, we must evaluate

323--for multiple expressions, we must evaluate

232−optimizeGraphRefDatabaseContextExpr (MultipleExpr _) = do

324+optimizeGraphRefDatabaseContextExpr (MultipleExpr exprs) = do

233 --a previous expression in the exprs list could create a relvar; we don't want to miss it, so we clear the tuples and execute the expression to get an empty relation in the relvar

325 --a previous expression in the exprs list could create a relvar; we don't want to miss it, so we clear the tuples and execute the expression to get an empty relation in the relvar

234− unimplemented

326+ context <- askContext

327+ graph <- askGraph

328+ parentId <- askTransId

329+

235−{- let processEmptyRelVars env = env { relationVariables = mkEmptyRelVars (relationVariables env) }

330+ let emptyRvs ctx = ctx { relationVariables = mkEmptyRelVars (relationVariables ctx) }

236− MultipleExpr <$> local processEmptyRelVars (mapM applyStaticDatabaseOptimization exprs)-}

331+ dbcEnv = mkDatabaseContextEvalEnv parentId graph

332+ folder (ctx, expracc) expr = do

333+ --optimize the expr and run it against empty relvars to add it to the context

334+ case runGraphRefSOptDatabaseContextExprM parentId ctx graph (optimizeGraphRefDatabaseContextExpr expr) of

335+ Left err -> throwError err

336+ Right optExpr ->

337+ case runDatabaseContextEvalMonad ctx dbcEnv (evalGraphRefDatabaseContextExpr optExpr) of

338+ Left err -> throwError err

339+ Right dbcState ->

340+ pure (emptyRvs $ dbc_context dbcState, expracc ++ [optExpr])

237

341

342+ (_, exprs') <- foldM folder (context,[]) exprs

343+ pure (MultipleExpr exprs')

238

344

239−applyStaticPredicateOptimization :: GraphRefRestrictionPredicateExpr -> GraphRefStaticOptimizerMonad GraphRefRestrictionPredicateExpr

345+applyStaticPredicateOptimization :: GraphRefRestrictionPredicateExpr -> GraphRefSOptRelationalExprM GraphRefRestrictionPredicateExpr

240applyStaticPredicateOptimization predi = do

346applyStaticPredicateOptimization predi = do

241 optPred <- case predi of

347 optPred <- case predi of

242-- where x and x => where x

348-- where x and x => where x

@@ -251,10 +357,8 @@ applyStaticPredicateOptimization predi = do

251 OrPredicate pred1 pred2 -> do

357 OrPredicate pred1 pred2 -> do

252 optPredA <- applyStaticPredicateOptimization pred1

358 optPredA <- applyStaticPredicateOptimization pred1

253 optPredB <- applyStaticPredicateOptimization pred2

359 optPredB <- applyStaticPredicateOptimization pred2

254− if optPredA == optPredB then

360+ if (optPredA == optPredB) || isTrueExpr optPredA then

255 pure optPredA

361 pure optPredA

256− else if isTrueExpr optPredA then

257− pure optPredA -- True or x -> True

258 else if isTrueExpr optPredB then

362 else if isTrueExpr optPredB then

259 pure optPredB

363 pure optPredB

260 else

364 else

@@ -286,7 +390,7 @@ isFalseExpr _ = False

286

390

287-- determine if the created relation can statically be determined to be empty

391-- determine if the created relation can statically be determined to be empty

288isEmptyRelationExpr :: RelationalExprBase a -> Bool

392isEmptyRelationExpr :: RelationalExprBase a -> Bool

289−isEmptyRelationExpr (MakeRelationFromExprs _ []) = True

393+isEmptyRelationExpr (MakeRelationFromExprs _ (TupleExprs _ [])) = True

290isEmptyRelationExpr (MakeStaticRelation _ tupSet) = null (asList tupSet)

394isEmptyRelationExpr (MakeStaticRelation _ tupSet) = null (asList tupSet)

291isEmptyRelationExpr (ExistingRelation rel) = rel == emptyRelationWithAttrs (attributes rel)

395isEmptyRelationExpr (ExistingRelation rel) = rel == emptyRelationWithAttrs (attributes rel)

292isEmptyRelationExpr _ = False

396isEmptyRelationExpr _ = False

@@ -329,58 +433,59 @@ isStaticAtomExpr FunctionAtomExpr{} = False

329isStaticAtomExpr RelationAtomExpr{} = False

433isStaticAtomExpr RelationAtomExpr{} = False

330

434

331--if the projection of a join only uses the attributes from one of the expressions and there is a foreign key relationship between the expressions, we know that the join is inconsequential and can be removed

435--if the projection of a join only uses the attributes from one of the expressions and there is a foreign key relationship between the expressions, we know that the join is inconsequential and can be removed

332−applyStaticJoinElimination :: GraphRefRelationalExpr -> GraphRefStaticOptimizerMonad GraphRefRelationalExpr

436+applyStaticJoinElimination :: GraphRefRelationalExpr -> GraphRefSOptRelationalExprM GraphRefRelationalExpr

333applyStaticJoinElimination expr@(Project attrNameSet (Join exprA exprB)) = do

437applyStaticJoinElimination expr@(Project attrNameSet (Join exprA exprB)) = do

334− graph <- ask

438+ graph <- askGraph

335 case inSameTransaction exprA exprB of

439 case inSameTransaction exprA exprB of

336 -- the sub exprs are in different transactions or none at all, so we cannot extract inclusion dependencies across transaction boundaries

440 -- the sub exprs are in different transactions or none at all, so we cannot extract inclusion dependencies across transaction boundaries

337− Nothing -> pure expr

441+ Nothing -> pure expr

338− Just commonTransId -> do

442+ Just marker -> do

443+ commonContext <- case marker of

444+ UncommittedContextMarker -> askContext

445+ TransactionMarker tid -> concreteDatabaseContext <$> lift (except (transactionForId tid graph))

339− let typeForExpr e = lift $ except $ runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr e)

446+ let typeForExpr e = lift $ except $ runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr e)

340− gfEnv = freshGraphRefRelationalExprEnv graph

447+ gfEnv = freshGraphRefRelationalExprEnv (Just commonContext) graph

448+

341− projType <- typeForExpr expr

449+ projType <- typeForExpr expr

342− typeA <- typeForExpr exprA

450+ typeA <- typeForExpr exprA

343− typeB <- typeForExpr exprB

451+ typeB <- typeForExpr exprB

344− let matchesProjectionAttributes

452+ let matchesProjectionAttributes

345− | attrNames projType `S.isSubsetOf` attrNames typeA =

453+ | attrNames projType `S.isSubsetOf` attrNames typeA =

346− Just ((exprA, typeA), (exprB, typeB))

454+ Just ((exprA, typeA), (exprB, typeB))

347− | attrNames projType `S.isSubsetOf` attrNames typeB =

455+ | attrNames projType `S.isSubsetOf` attrNames typeB =

348− Just ((exprB, typeB), (exprA, typeA))

456+ Just ((exprB, typeB), (exprA, typeA))

349− | otherwise =

457+ | otherwise =

350− Nothing

458+ Nothing

351− attrNames = A.attributeNameSet . attributes

459+ attrNames = A.attributeNameSet . attributes

352− case matchesProjectionAttributes of

460+ case matchesProjectionAttributes of

353− Nothing -> -- this optimization does not apply

461+ Nothing -> -- this optimization does not apply

354− pure expr

462+ pure expr

355− Just ((joinedExpr, joinedType), (unjoinedExpr, _)) -> do

463+ Just ((joinedExpr, joinedType), (unjoinedExpr, _)) -> do

356 --lookup transaction

464 --lookup transaction

357− trans <- lift $ except (transactionForId commonTransId graph)

358 --scan inclusion dependencies for a foreign key relationship

465 --scan inclusion dependencies for a foreign key relationship

359− let incDeps = inclusionDependencies commonContext

466+ let incDeps = inclusionDependencies commonContext

360− commonContext = concreteDatabaseContext trans

361− reEnv = mkRelationalExprEnv commonContext commonTransId graph

362− fkConstraint = foldM isFkConstraint False incDeps

467+ fkConstraint = foldM isFkConstraint False incDeps

363 --search for matching fk constraint

468 --search for matching fk constraint

364− isFkConstraint acc (InclusionDependency (Project subAttrNames subrv) (Project _ superrv)) = do

469+ isFkConstraint acc (InclusionDependency (Project subAttrNames subrv) (Project _ superrv)) = do

365− let gfSubAttrNames = processM (processAttributeNames subAttrNames)

470+ let gfSubAttrNames = processM (processAttributeNames subAttrNames)

366− gfSubRv = processM (processRelationalExpr subrv)

471+ gfSubRv = processM (processRelationalExpr subrv)

367− gfSuperRv = processM (processRelationalExpr superrv)

472+ gfSuperRv = processM (processRelationalExpr superrv)

368− processM = runProcessExprM commonTransId graph

473+ processM = runProcessExprM marker

369− case runGraphRefRelationalExprM gfEnv (evalGraphRefAttributeNames gfSubAttrNames expr) of

474+ case runGraphRefRelationalExprM gfEnv (evalGraphRefAttributeNames gfSubAttrNames expr) of

370− Left _ -> pure acc

475+ Left _ -> pure acc

371− Right subAttrNameSet ->

476+ Right subAttrNameSet ->

372− pure (acc || (joinedExpr == gfSubRv &&

477+ pure (acc || (joinedExpr == gfSubRv &&

373 unjoinedExpr == gfSuperRv &&

478 unjoinedExpr == gfSuperRv &&

374 -- the fk attribute is one of the projection attributes

479 -- the fk attribute is one of the projection attributes

375 A.attributeNamesContained subAttrNameSet (A.attributeNameSet (attributes joinedType))

480 A.attributeNamesContained subAttrNameSet (A.attributeNameSet (attributes joinedType))

376 ))

481 ))

377− isFkConstraint acc _ = pure acc

482+ isFkConstraint acc _ = pure acc

378− case fkConstraint of

483+ case fkConstraint of

379− Right True -> --join elimination optimization applies

484+ Right True -> --join elimination optimization applies

380− optimizeGraphRefRelationalExpr (Project attrNameSet joinedExpr)

485+ optimizeGraphRefRelationalExpr (Project attrNameSet joinedExpr)

381− Right False -> --join elimination optimization does not apply

486+ Right False -> --join elimination optimization does not apply

382− pure expr

487+ pure expr

383− Left err -> throwError err

488+ Left err -> throwError err

384

489

385applyStaticJoinElimination expr = pure expr

490applyStaticJoinElimination expr = pure expr

386

491

@@ -468,5 +573,6 @@ applyStaticRestrictionPushdown expr = case expr of

468 Extend n (applyStaticRestrictionPushdown sub)

573 Extend n (applyStaticRestrictionPushdown sub)

469

574

470-- no optimizations available

575-- no optimizations available

471−optimizeDatabaseContextIOExpr :: GraphRefDatabaseContextIOExpr -> StaticOptimizerMonad GraphRefDatabaseContextIOExpr

576+optimizeDatabaseContextIOExpr :: GraphRefDatabaseContextIOExpr -> GraphRefSOptDatabaseContextExprM GraphRefDatabaseContextIOExpr

472−optimizeDatabaseContextIOExpr x = pure x

577+optimizeDatabaseContextIOExpr = pure

578+

src/lib/ProjectM36/TransGraphPlanExpr.hsdeleted−5

@@ -1,5 +0,0 @@

1−module ProjectM36.TransGraphPlanExpr where

2−import ProjectM36.Base

3−-- used to create an execution plan which can potentially read from the query cache

4−

5−data TransGraphPlanExpr = ExecuteTransGraphRelationalExprPlan TransGraphRelationalExpr

src/lib/ProjectM36/TransGraphRelationalExpression.hs+11−20

@@ -10,40 +10,27 @@ import Control.Monad.Trans.Reader

10import Control.Monad.Trans.Class

11import Control.Monad.Trans.Except

12import Data.Functor.Identity

13−import Data.Binary

14

13

15-- | The TransGraphRelationalExpression is equivalent to a relational expression except that relation variables can reference points in the transaction graph (at previous points in time).

14-- | The TransGraphRelationalExpression is equivalent to a relational expression except that relation variables can reference points in the transaction graph (at previous points in time).

16type TransGraphRelationalExpr = RelationalExprBase TransactionIdLookup

15type TransGraphRelationalExpr = RelationalExprBase TransactionIdLookup

17

16

18−instance Binary TransGraphRelationalExpr

19−

20type TransGraphAttributeNames = AttributeNamesBase TransactionIdLookup

17type TransGraphAttributeNames = AttributeNamesBase TransactionIdLookup

21

18

22−instance Binary TransGraphAttributeNames

23−

24type TransGraphExtendTupleExpr = ExtendTupleExprBase TransactionIdLookup

19type TransGraphExtendTupleExpr = ExtendTupleExprBase TransactionIdLookup

25

20

26−instance Binary TransGraphExtendTupleExpr

27−

28type TransGraphTupleExpr = TupleExprBase TransactionIdLookup

21type TransGraphTupleExpr = TupleExprBase TransactionIdLookup

29

22

30−instance Binary TransGraphTupleExpr

23+type TransGraphTupleExprs = TupleExprsBase TransactionIdLookup

31

24

32type TransGraphRestrictionPredicateExpr = RestrictionPredicateExprBase TransactionIdLookup

25type TransGraphRestrictionPredicateExpr = RestrictionPredicateExprBase TransactionIdLookup

33

26

34−instance Binary TransGraphRestrictionPredicateExpr

35−

36type TransGraphAtomExpr = AtomExprBase TransactionIdLookup

27type TransGraphAtomExpr = AtomExprBase TransactionIdLookup

37

28

38−instance Binary TransGraphAtomExpr

39−

40type TransGraphAttributeExpr = AttributeExprBase TransactionIdLookup

29type TransGraphAttributeExpr = AttributeExprBase TransactionIdLookup

41

30

42type TransGraphWithNameExpr = WithNameExprBase TransactionIdLookup

31type TransGraphWithNameExpr = WithNameExprBase TransactionIdLookup

43

32

44−instance Binary TransGraphWithNameExpr

45−

46−data TransGraphEvalEnv = TransGraphEvalEnv {

33+newtype TransGraphEvalEnv = TransGraphEvalEnv {

47 tge_graph :: TransactionGraph

34 tge_graph :: TransactionGraph

48 }

35 }

49

36

@@ -58,8 +45,8 @@ liftE = lift . except

58askGraph :: TransGraphEvalMonad TransactionGraph

45askGraph :: TransGraphEvalMonad TransactionGraph

59askGraph = tge_graph <$> ask

46askGraph = tge_graph <$> ask

60

47

61−findTransId :: TransactionIdLookup -> TransGraphEvalMonad TransactionId

48+findTransId :: TransactionIdLookup -> TransGraphEvalMonad GraphRefTransactionMarker

62−findTransId tlook = transactionId <$> findTrans tlook

49+findTransId tlook = TransactionMarker . transactionId <$> findTrans tlook

63

50

64findTrans :: TransactionIdLookup -> TransGraphEvalMonad Transaction

51findTrans :: TransactionIdLookup -> TransGraphEvalMonad Transaction

65findTrans tlook = do

52findTrans tlook = do

@@ -69,7 +56,7 @@ findTrans tlook = do

69-- OUTDATED a previous attempt at this function attempted to convert TransGraphRelationalExpr to RelationalExpr by resolving the transaction lookups. However, there is no way to resolve a FunctionAtomExpr to an Atom without fully evaluating the higher levels (TupleExpr, etc.). An anonymous function expression cannot be serialized, so that workaround is out. Still, I suspect we can reuse the existing static optimizer logic to work on both structures. The current conversion reduces the chance of whole-query optimization due to full-evaluation on top of full-evaluation, so this function would benefit from some re-design.

56-- OUTDATED a previous attempt at this function attempted to convert TransGraphRelationalExpr to RelationalExpr by resolving the transaction lookups. However, there is no way to resolve a FunctionAtomExpr to an Atom without fully evaluating the higher levels (TupleExpr, etc.). An anonymous function expression cannot be serialized, so that workaround is out. Still, I suspect we can reuse the existing static optimizer logic to work on both structures. The current conversion reduces the chance of whole-query optimization due to full-evaluation on top of full-evaluation, so this function would benefit from some re-design.

70processTransGraphRelationalExpr :: TransGraphRelationalExpr -> TransGraphEvalMonad GraphRefRelationalExpr

57processTransGraphRelationalExpr :: TransGraphRelationalExpr -> TransGraphEvalMonad GraphRefRelationalExpr

71processTransGraphRelationalExpr (MakeRelationFromExprs mAttrExprs tupleExprs) = do

58processTransGraphRelationalExpr (MakeRelationFromExprs mAttrExprs tupleExprs) = do

72− tupleExprs' <- mapM processTransGraphTupleExpr tupleExprs

59+ tupleExprs' <- processTransGraphTupleExprs tupleExprs

73 case mAttrExprs of

60 case mAttrExprs of

74 Nothing -> pure (MakeRelationFromExprs Nothing tupleExprs')

61 Nothing -> pure (MakeRelationFromExprs Nothing tupleExprs')

75 Just attrExprs -> do

62 Just attrExprs -> do

@@ -119,7 +106,11 @@ processTransGraphRelationalExpr (With views expr) = do

119 ) views

106 ) views

120 expr' <- processTransGraphRelationalExpr expr

107 expr' <- processTransGraphRelationalExpr expr

121 pure (With evaldViews expr')

108 pure (With evaldViews expr')

122−

109+

110+processTransGraphTupleExprs :: TransGraphTupleExprs -> TransGraphEvalMonad GraphRefTupleExprs

111+processTransGraphTupleExprs (TupleExprs marker texprs) =

112+ TupleExprs <$> findTransId marker <*> mapM processTransGraphTupleExpr texprs

113+

123processTransGraphTupleExpr :: TransGraphTupleExpr -> TransGraphEvalMonad GraphRefTupleExpr

114processTransGraphTupleExpr :: TransGraphTupleExpr -> TransGraphEvalMonad GraphRefTupleExpr

124processTransGraphTupleExpr (TupleExpr attrMap) = do

115processTransGraphTupleExpr (TupleExpr attrMap) = do

125 let attrAssoc = mapM (\(attrName, atomExpr) -> do

116 let attrAssoc = mapM (\(attrName, atomExpr) -> do

@@ -161,7 +152,7 @@ evalTransGraphRestrictionPredicateExpr (AttributeEqualityPredicate attrName expr

161 AttributeEqualityPredicate attrName <$> expr'

152 AttributeEqualityPredicate attrName <$> expr'

162

153

163processTransGraphExtendTupleExpr :: TransGraphExtendTupleExpr -> TransGraphEvalMonad GraphRefExtendTupleExpr

154processTransGraphExtendTupleExpr :: TransGraphExtendTupleExpr -> TransGraphEvalMonad GraphRefExtendTupleExpr

164−processTransGraphExtendTupleExpr (AttributeExtendTupleExpr attrName expr) = do

155+processTransGraphExtendTupleExpr (AttributeExtendTupleExpr attrName expr) =

165 AttributeExtendTupleExpr attrName <$> processTransGraphAtomExpr expr

156 AttributeExtendTupleExpr attrName <$> processTransGraphAtomExpr expr

166

157

167processTransGraphAttributeExpr :: TransGraphAttributeExpr -> TransGraphEvalMonad GraphRefAttributeExpr

158processTransGraphAttributeExpr :: TransGraphAttributeExpr -> TransGraphEvalMonad GraphRefAttributeExpr

src/lib/ProjectM36/Transaction.hs+10−5

@@ -17,11 +17,10 @@ singleParent tid = tid NE.:| []

17-- | Return the same transaction but referencing only the specific child transactions. This is useful when traversing a graph and returning a subgraph. This doesn't filter parent transactions because it assumes a head-to-root traversal.

18filterTransactionInfoTransactions :: S.Set TransactionId -> TransactionInfo -> TransactionInfo

19filterTransactionInfoTransactions filterIds tinfo =

20− TransactionInfo { parents = case

20+ tinfo { parents = case

21− NE.filter (\parent -> S.member parent filterIds) (parents tinfo) of

21+ NE.filter (`S.member` filterIds) (parents tinfo) of

22 [] -> rootParent

23− xs -> NE.fromList xs,

23+ xs -> NE.fromList xs}

24− stamp = stamp tinfo }

25

24

26filterParent :: TransactionId -> S.Set TransactionId -> TransactionId

25filterParent :: TransactionId -> S.Set TransactionId -> TransactionId

27filterParent parentId validIds = if S.member parentId validIds then parentId else U.nil

26filterParent parentId validIds = if S.member parentId validIds then parentId else U.nil

@@ -43,7 +42,13 @@ subschemas :: Transaction -> Subschemas

43subschemas (Transaction _ _ (Schemas _ sschemas)) = sschemas

42subschemas (Transaction _ _ (Schemas _ sschemas)) = sschemas

44

43

45fresh :: TransactionId -> UTCTime -> Schemas -> Transaction

44fresh :: TransactionId -> UTCTime -> Schemas -> Transaction

46−fresh freshId stamp' newSchemas = Transaction freshId (TransactionInfo rootParent stamp') newSchemas

45+fresh freshId stamp' = Transaction freshId tinfo

46+ where

47+ tinfo = TransactionInfo {parents = rootParent,

48+ stamp = stamp',

49+ merkleHash = mempty

50+ }

47

51

48timestamp :: Transaction -> UTCTime

52timestamp :: Transaction -> UTCTime

49timestamp (Transaction _ tinfo _) = stamp tinfo

53timestamp (Transaction _ tinfo _) = stamp tinfo

54+

src/lib/ProjectM36/Transaction/Persist.hs+51−31

@@ -1,3 +1,4 @@

1+{-# LANGUAGE TypeApplications #-}

1module ProjectM36.Transaction.Persist where

2module ProjectM36.Transaction.Persist where

2import ProjectM36.Base

3import ProjectM36.Base

3import ProjectM36.Error

4import ProjectM36.Error

@@ -7,17 +8,19 @@ import ProjectM36.AtomFunction

7import ProjectM36.Persist (writeBSFileSync, DiskSync, renameSync)

8import ProjectM36.Persist (writeBSFileSync, DiskSync, renameSync)

8import qualified Data.Map as M

9import qualified Data.Map as M

9import qualified Data.HashSet as HS

10import qualified Data.HashSet as HS

10−import qualified Data.Binary as B

11−--import qualified Data.ByteString as BS

12import System.FilePath

11import System.FilePath

13import System.Directory

12import System.Directory

14import qualified Data.Text as T

13import qualified Data.Text as T

15import Control.Monad

14import Control.Monad

16import ProjectM36.ScriptSession

15import ProjectM36.ScriptSession

17import ProjectM36.AtomFunctions.Basic (precompiledAtomFunctions)

16import ProjectM36.AtomFunctions.Basic (precompiledAtomFunctions)

18−import Control.Exception

17+import Codec.Winery

18+

19+#ifdef PM36_HASKELL_SCRIPTING

19import GHC

20import GHC

21+import Control.Exception

20import GHC.Paths

22import GHC.Paths

23+#endif

21

24

22getDirectoryNames :: FilePath -> IO [FilePath]

25getDirectoryNames :: FilePath -> IO [FilePath]

23getDirectoryNames path =

26getDirectoryNames path =

@@ -59,7 +62,7 @@ readTransaction dbdir transId mScriptSession = do

59 return $ Left $ MissingTransactionError transId

62 return $ Left $ MissingTransactionError transId

60 else do

63 else do

61 relvars <- readRelVars transDir

64 relvars <- readRelVars transDir

62− transInfo <- B.decodeFile (transactionInfoPath transDir)

65+ transInfo <- readFileDeserialise (transactionInfoPath transDir)

63 incDeps <- readIncDeps transDir

66 incDeps <- readIncDeps transDir

64 typeCons <- readTypeConstructorMapping transDir

67 typeCons <- readTypeConstructorMapping transDir

65 sschemas <- readSubschemas transDir

68 sschemas <- readSubschemas transDir

@@ -89,61 +92,68 @@ writeTransaction sync dbdir trans = do

89 writeDBCFuncs sync tempTransDir (dbcFunctions context)

92 writeDBCFuncs sync tempTransDir (dbcFunctions context)

90 writeTypeConstructorMapping sync tempTransDir (typeConstructorMapping context)

93 writeTypeConstructorMapping sync tempTransDir (typeConstructorMapping context)

91 writeSubschemas sync tempTransDir (subschemas trans)

94 writeSubschemas sync tempTransDir (subschemas trans)

92− B.encodeFile (transactionInfoPath tempTransDir) (transactionInfo trans)

95+ writeFileSerialise (transactionInfoPath tempTransDir) (transactionInfo trans)

93 --move the temp directory to final location

96 --move the temp directory to final location

94 renameSync sync tempTransDir finalTransDir

97 renameSync sync tempTransDir finalTransDir

95

98

96writeRelVars :: DiskSync -> FilePath -> RelationVariables -> IO ()

99writeRelVars :: DiskSync -> FilePath -> RelationVariables -> IO ()

97writeRelVars sync transDir relvars = do

100writeRelVars sync transDir relvars = do

98 let path = relvarsPath transDir

101 let path = relvarsPath transDir

99− writeBSFileSync sync path (B.encode relvars)

102+ writeBSFileSync sync path (serialise relvars)

100

103

101readRelVars :: FilePath -> IO RelationVariables

104readRelVars :: FilePath -> IO RelationVariables

102−readRelVars transDir = do

105+readRelVars transDir =

103− B.decodeFile (relvarsPath transDir)

106+ readFileDeserialise (relvarsPath transDir)

104

107

105writeAtomFuncs :: DiskSync -> FilePath -> AtomFunctions -> IO ()

108writeAtomFuncs :: DiskSync -> FilePath -> AtomFunctions -> IO ()

106writeAtomFuncs sync transDir funcs = do

109writeAtomFuncs sync transDir funcs = do

107 let atomFuncPath = atomFuncsPath transDir

110 let atomFuncPath = atomFuncsPath transDir

108− writeBSFileSync sync atomFuncPath (B.encode $ map (\f -> (atomFuncType f, atomFuncName f, atomFunctionScript f)) (HS.toList funcs))

111+ writeBSFileSync sync atomFuncPath (serialise $ map (\f -> (atomFuncType f, atomFuncName f, atomFunctionScript f)) (HS.toList funcs))

109

112

110--all the atom functions are in one file

113--all the atom functions are in one file

111readAtomFuncs :: FilePath -> Maybe ScriptSession -> IO AtomFunctions

114readAtomFuncs :: FilePath -> Maybe ScriptSession -> IO AtomFunctions

112readAtomFuncs transDir mScriptSession = do

115readAtomFuncs transDir mScriptSession = do

113− atomFuncsList <- B.decodeFile (atomFuncsPath transDir)

116+ atomFuncsList <- readFileDeserialise (atomFuncsPath transDir)

114 --only Haskell script functions can be serialized

117 --only Haskell script functions can be serialized

115 --we always return the pre-compiled functions

118 --we always return the pre-compiled functions

116 funcs <- mapM (\(funcType, funcName, mFuncScript) -> loadAtomFunc precompiledAtomFunctions mScriptSession funcName funcType mFuncScript) atomFuncsList

119 funcs <- mapM (\(funcType, funcName, mFuncScript) -> loadAtomFunc precompiledAtomFunctions mScriptSession funcName funcType mFuncScript) atomFuncsList

117 pure (HS.union precompiledAtomFunctions (HS.fromList funcs))

120 pure (HS.union precompiledAtomFunctions (HS.fromList funcs))

118

121

119loadAtomFunc :: AtomFunctions -> Maybe ScriptSession -> AtomFunctionName -> [AtomType] -> Maybe AtomFunctionBodyScript -> IO AtomFunction

122loadAtomFunc :: AtomFunctions -> Maybe ScriptSession -> AtomFunctionName -> [AtomType] -> Maybe AtomFunctionBodyScript -> IO AtomFunction

120−loadAtomFunc precompiledFuncs mScriptSession funcName funcType mFuncScript = case mFuncScript of

123+loadAtomFunc precompiledFuncs _mScriptSession funcName _funcType mFuncScript = case mFuncScript of

121 --handle pre-compiled case- pull it from the precompiled list

124 --handle pre-compiled case- pull it from the precompiled list

122 Nothing -> case atomFunctionForName funcName precompiledFuncs of

125 Nothing -> case atomFunctionForName funcName precompiledFuncs of

123 --WARNING: possible landmine here if we remove a precompiled atom function in the future, then the transaction cannot be restored

126 --WARNING: possible landmine here if we remove a precompiled atom function in the future, then the transaction cannot be restored

124 Left _ -> error ("expected precompiled atom function: " ++ T.unpack funcName)

127 Left _ -> error ("expected precompiled atom function: " ++ T.unpack funcName)

125 Right realFunc -> pure realFunc

128 Right realFunc -> pure realFunc

126 --handle a real Haskell scripted function- compile and load

129 --handle a real Haskell scripted function- compile and load

127− Just funcScript ->

130+ Just _funcScript ->

128− case mScriptSession of

131+#ifdef PM36_HASKELL_SCRIPTING

132+ case _mScriptSession of

129 Nothing -> error "attempted to read serialized AtomFunction without scripting enabled"

133 Nothing -> error "attempted to read serialized AtomFunction without scripting enabled"

130 Just scriptSession -> do

134 Just scriptSession -> do

131 --risk of GHC exception during compilation here

135 --risk of GHC exception during compilation here

132 eCompiledScript <- runGhc (Just libdir) $ do

136 eCompiledScript <- runGhc (Just libdir) $ do

133 setSession (hscEnv scriptSession)

137 setSession (hscEnv scriptSession)

134− compileScript (atomFunctionBodyType scriptSession) funcScript

138+ compileScript (atomFunctionBodyType scriptSession) _funcScript

135 case eCompiledScript of

139 case eCompiledScript of

136 Left err -> throwIO err

140 Left err -> throwIO err

137 Right compiledScript -> pure AtomFunction { atomFuncName = funcName,

141 Right compiledScript -> pure AtomFunction { atomFuncName = funcName,

138− atomFuncType = funcType,

142+ atomFuncType = _funcType,

139− atomFuncBody = AtomFunctionBody (Just funcScript) compiledScript }

143+ atomFuncBody = AtomFunctionBody (Just _funcScript) compiledScript }

144+#else

145+ error "Haskell scripting is disabled"

146+#endif

140

147

141--if the script session is enabled, compile the script, otherwise, hard error!

148--if the script session is enabled, compile the script, otherwise, hard error!

142

149

143readAtomFunc :: FilePath -> AtomFunctionName -> Maybe ScriptSession -> AtomFunctions -> IO AtomFunction

150readAtomFunc :: FilePath -> AtomFunctionName -> Maybe ScriptSession -> AtomFunctions -> IO AtomFunction

151+#if !defined(PM36_HASKELL_SCRIPTING)

152+readAtomFunc _ _ _ _ = error "Haskell scripting is disabled"

153+#else

144readAtomFunc transDir funcName mScriptSession precompiledFuncs = do

154readAtomFunc transDir funcName mScriptSession precompiledFuncs = do

145 let atomFuncPath = atomFuncsPath transDir

155 let atomFuncPath = atomFuncsPath transDir

146− (funcType, mFuncScript) <- B.decodeFile atomFuncPath

156+ (funcType, mFuncScript) <- readFileDeserialise @([AtomType],Maybe T.Text) atomFuncPath

147 case mFuncScript of

157 case mFuncScript of

148 --handle pre-compiled case- pull it from the precompiled list

158 --handle pre-compiled case- pull it from the precompiled list

149 Nothing -> case atomFunctionForName funcName precompiledFuncs of

159 Nothing -> case atomFunctionForName funcName precompiledFuncs of

@@ -151,7 +161,8 @@ readAtomFunc transDir funcName mScriptSession precompiledFuncs = do

151 Left _ -> error ("expected precompiled atom function: " ++ T.unpack funcName)

161 Left _ -> error ("expected precompiled atom function: " ++ T.unpack funcName)

152 Right realFunc -> pure realFunc

162 Right realFunc -> pure realFunc

153 --handle a real Haskell scripted function- compile and load

163 --handle a real Haskell scripted function- compile and load

154− Just funcScript ->

164+ Just funcScript ->

165+

155 case mScriptSession of

166 case mScriptSession of

156 Nothing -> error "attempted to read serialized AtomFunction without scripting enabled"

167 Nothing -> error "attempted to read serialized AtomFunction without scripting enabled"

157 Just scriptSession -> do

168 Just scriptSession -> do

@@ -164,6 +175,7 @@ readAtomFunc transDir funcName mScriptSession precompiledFuncs = do

164 Right compiledScript -> pure AtomFunction { atomFuncName = funcName,

175 Right compiledScript -> pure AtomFunction { atomFuncName = funcName,

165 atomFuncType = funcType,

176 atomFuncType = funcType,

166 atomFuncBody = AtomFunctionBody (Just funcScript) compiledScript }

177 atomFuncBody = AtomFunctionBody (Just funcScript) compiledScript }

178+#endif

167

179

168

180

169writeDBCFuncs :: DiskSync -> FilePath -> DatabaseContextFunctions -> IO ()

181writeDBCFuncs :: DiskSync -> FilePath -> DatabaseContextFunctions -> IO ()

@@ -172,7 +184,7 @@ writeDBCFuncs sync transDir funcs = mapM_ (writeDBCFunc sync transDir) (HS.toLis

172writeDBCFunc :: DiskSync -> FilePath -> DatabaseContextFunction -> IO ()

184writeDBCFunc :: DiskSync -> FilePath -> DatabaseContextFunction -> IO ()

173writeDBCFunc sync transDir func = do

185writeDBCFunc sync transDir func = do

174 let dbcFuncPath = dbcFuncsDir transDir </> T.unpack (dbcFuncName func)

186 let dbcFuncPath = dbcFuncsDir transDir </> T.unpack (dbcFuncName func)

175− writeBSFileSync sync dbcFuncPath (B.encode (dbcFuncType func, databaseContextFunctionScript func))

187+ writeBSFileSync sync dbcFuncPath (serialise (dbcFuncType func, databaseContextFunctionScript func))

176

188

177readDBCFuncs :: FilePath -> Maybe ScriptSession -> IO DatabaseContextFunctions

189readDBCFuncs :: FilePath -> Maybe ScriptSession -> IO DatabaseContextFunctions

178readDBCFuncs transDir mScriptSession = do

190readDBCFuncs transDir mScriptSession = do

@@ -182,30 +194,38 @@ readDBCFuncs transDir mScriptSession = do

182 let funcs = mapM ((\name -> readDBCFunc transDir name mScriptSession precompiledDatabaseContextFunctions) . T.pack) funcNames

194 let funcs = mapM ((\name -> readDBCFunc transDir name mScriptSession precompiledDatabaseContextFunctions) . T.pack) funcNames

183 HS.union basicDatabaseContextFunctions . HS.fromList <$> funcs

195 HS.union basicDatabaseContextFunctions . HS.fromList <$> funcs

184

196

185−readDBCFunc :: FilePath -> DatabaseContextFunctionName -> Maybe ScriptSession -> DatabaseContextFunctions -> IO DatabaseContextFunction

197+readDBCFunc :: FilePath -> DatabaseContextFunctionName -> Maybe ScriptSession -> DatabaseContextFunctions -> IO DatabaseContextFunction

198+#if !defined(PM36_HASKELL_SCRIPTING)

199+readDBCFunc transDir funcName _ precompiledFuncs = do

200+#else

186readDBCFunc transDir funcName mScriptSession precompiledFuncs = do

201readDBCFunc transDir funcName mScriptSession precompiledFuncs = do

202+#endif

187 let dbcFuncPath = dbcFuncsDir transDir </> T.unpack funcName

203 let dbcFuncPath = dbcFuncsDir transDir </> T.unpack funcName

188− (funcType, mFuncScript) <- B.decodeFile dbcFuncPath

204+ (_funcType, mFuncScript) <- readFileDeserialise @([AtomType], Maybe T.Text) dbcFuncPath

189 case mFuncScript of

205 case mFuncScript of

190 Nothing -> case databaseContextFunctionForName funcName precompiledFuncs of

206 Nothing -> case databaseContextFunctionForName funcName precompiledFuncs of

191 Left _ -> error ("expected precompiled dbc function: " ++ T.unpack funcName)

207 Left _ -> error ("expected precompiled dbc function: " ++ T.unpack funcName)

192 Right realFunc -> pure realFunc --return precompiled function

208 Right realFunc -> pure realFunc --return precompiled function

193− Just funcScript ->

209+ Just _funcScript ->

210+#ifdef PM36_HASKELL_SCRIPTING

194 case mScriptSession of

211 case mScriptSession of

195 Nothing -> error "attempted to read serialized AtomFunction without scripting enabled"

212 Nothing -> error "attempted to read serialized AtomFunction without scripting enabled"

196 Just scriptSession -> do

213 Just scriptSession -> do

197 eCompiledScript <- runGhc (Just libdir) $ do

214 eCompiledScript <- runGhc (Just libdir) $ do

198 setSession (hscEnv scriptSession)

215 setSession (hscEnv scriptSession)

199− compileScript (dbcFunctionBodyType scriptSession) funcScript

216+ compileScript (dbcFunctionBodyType scriptSession) _funcScript

200 case eCompiledScript of

217 case eCompiledScript of

201 Left err -> throwIO err

218 Left err -> throwIO err

202 Right compiledScript -> pure DatabaseContextFunction { dbcFuncName = funcName,

219 Right compiledScript -> pure DatabaseContextFunction { dbcFuncName = funcName,

203− dbcFuncType = funcType,

220+ dbcFuncType = _funcType,

204− dbcFuncBody = DatabaseContextFunctionBody (Just funcScript) compiledScript}

221+ dbcFuncBody = DatabaseContextFunctionBody (Just _funcScript) compiledScript}

222+#else

223+ error "Haskell scripting is disabled"

224+#endif

205

225

206writeIncDep :: DiskSync -> FilePath -> (IncDepName, InclusionDependency) -> IO ()

226writeIncDep :: DiskSync -> FilePath -> (IncDepName, InclusionDependency) -> IO ()

207writeIncDep sync transDir (incDepName, incDep) =

227writeIncDep sync transDir (incDepName, incDep) =

208− writeBSFileSync sync (incDepsDir transDir </> T.unpack incDepName) $ B.encode incDep

228+ writeBSFileSync sync (incDepsDir transDir </> T.unpack incDepName) $ serialise incDep

209

229

210writeIncDeps :: DiskSync -> FilePath -> M.Map IncDepName InclusionDependency -> IO ()

230writeIncDeps :: DiskSync -> FilePath -> M.Map IncDepName InclusionDependency -> IO ()

211writeIncDeps sync transDir incdeps = mapM_ (writeIncDep sync transDir) $ M.toList incdeps

231writeIncDeps sync transDir incdeps = mapM_ (writeIncDep sync transDir) $ M.toList incdeps

@@ -213,7 +233,7 @@ writeIncDeps sync transDir incdeps = mapM_ (writeIncDep sync transDir) $ M.toLis

213readIncDep :: FilePath -> IncDepName -> IO (IncDepName, InclusionDependency)

233readIncDep :: FilePath -> IncDepName -> IO (IncDepName, InclusionDependency)

214readIncDep transDir incdepName = do

234readIncDep transDir incdepName = do

215 let incDepPath = incDepsDir transDir </> T.unpack incdepName

235 let incDepPath = incDepsDir transDir </> T.unpack incdepName

216− incDepData <- B.decodeFile incDepPath

236+ incDepData <- readFileDeserialise incDepPath

217 pure (incdepName, incDepData)

237 pure (incdepName, incDepData)

218

238

219readIncDeps :: FilePath -> IO (M.Map IncDepName InclusionDependency)

239readIncDeps :: FilePath -> IO (M.Map IncDepName InclusionDependency)

@@ -225,20 +245,20 @@ readIncDeps transDir = do

225readSubschemas :: FilePath -> IO Subschemas

245readSubschemas :: FilePath -> IO Subschemas

226readSubschemas transDir = do

246readSubschemas transDir = do

227 let sschemasPath = subschemasPath transDir

247 let sschemasPath = subschemasPath transDir

228− B.decodeFile sschemasPath

248+ readFileDeserialise sschemasPath

229

249

230writeSubschemas :: DiskSync -> FilePath -> Subschemas -> IO ()

250writeSubschemas :: DiskSync -> FilePath -> Subschemas -> IO ()

231writeSubschemas sync transDir sschemas = do

251writeSubschemas sync transDir sschemas = do

232 let sschemasPath = subschemasPath transDir

252 let sschemasPath = subschemasPath transDir

233− writeBSFileSync sync sschemasPath (B.encode sschemas)

253+ writeBSFileSync sync sschemasPath (serialise sschemas)

234

254

235writeTypeConstructorMapping :: DiskSync -> FilePath -> TypeConstructorMapping -> IO ()

255writeTypeConstructorMapping :: DiskSync -> FilePath -> TypeConstructorMapping -> IO ()

236writeTypeConstructorMapping sync path types = let atPath = typeConsPath path in

256writeTypeConstructorMapping sync path types = let atPath = typeConsPath path in

237− writeBSFileSync sync atPath $ B.encode types

257+ writeBSFileSync sync atPath $ serialise types

238

258

239readTypeConstructorMapping :: FilePath -> IO TypeConstructorMapping

259readTypeConstructorMapping :: FilePath -> IO TypeConstructorMapping

240readTypeConstructorMapping path = do

260readTypeConstructorMapping path = do

241 let atPath = typeConsPath path

261 let atPath = typeConsPath path

242− B.decodeFile atPath

262+ readFileDeserialise atPath

243

263

244

264

src/lib/ProjectM36/TransactionGraph.hs+177−82

@@ -1,4 +1,4 @@

1−{-# LANGUAGE DeriveAnyClass, DeriveGeneric #-}

1+{-# LANGUAGE DeriveGeneric, CPP, FlexibleContexts, DerivingVia #-}

2module ProjectM36.TransactionGraph where

3import ProjectM36.Base

4import ProjectM36.Error

@@ -9,42 +9,44 @@ import ProjectM36.TupleSet

9import ProjectM36.Tuple

10import ProjectM36.RelationalExpression

11import ProjectM36.TransactionGraph.Merge

12+import ProjectM36.MerkleHash

12import qualified ProjectM36.DisconnectedTransaction as Discon

13import qualified ProjectM36.DisconnectedTransaction as Discon

14+import qualified ProjectM36.Attribute as A

13

15

16+import Codec.Winery

17+import Control.Monad.Except hiding (join)

18+import Control.Monad.Reader hiding (join)

14import qualified Data.Vector as V

19import qualified Data.Vector as V

15−import qualified ProjectM36.Attribute as A

16import qualified Data.UUID as U

20import qualified Data.UUID as U

17import qualified Data.Set as S

21import qualified Data.Set as S

18import qualified Data.Map as M

22import qualified Data.Map as M

19import qualified Data.List.NonEmpty as NE

23import qualified Data.List.NonEmpty as NE

20−import Control.Monad

21import Data.Time.Clock

24import Data.Time.Clock

22import qualified Data.Text as T

25import qualified Data.Text as T

23import GHC.Generics

26import GHC.Generics

24−import Data.Binary

25import Data.Either (lefts, rights, isRight)

27import Data.Either (lefts, rights, isRight)

26−import Control.Arrow

27−import Data.Maybe

28−#if __GLASGOW_HASKELL__ <= 802

28+#if __GLASGOW_HASKELL__ < 804

29import Data.Monoid

30#endif

31−

32−{-

33−--import Debug.Trace

34−import Control.Monad.Reader

31+import Control.Arrow

35−import qualified ProjectM36.DisconnectedTransaction as D

32+import Data.Maybe

36−-}

33+import Data.UUID.V4

34+import qualified Data.ByteString.Lazy as BL

35+import ProjectM36.DatabaseContext as DBC

36+import Crypto.Hash.SHA256

37

38-- | Record a lookup for a specific transaction in the graph.

39data TransactionIdLookup = TransactionIdLookup TransactionId |

40 TransactionIdHeadNameLookup HeadName [TransactionIdHeadBacktrack]

41− deriving (Show, Eq, Binary, Generic)

41+ deriving (Show, Eq, Generic)

42+ deriving Serialise via WineryVariant TransactionIdLookup

42

43

43-- | Used for git-style head backtracking such as topic~3^2.

44-- | Used for git-style head backtracking such as topic~3^2.

44−data TransactionIdHeadBacktrack = TransactionIdHeadParentBacktrack Int | -- ^ git equivalent of ~: walk back n parents, arbitrarily choosing a parent when a choice must be made

45+data TransactionIdHeadBacktrack = TransactionIdHeadParentBacktrack Int | -- ^ git equivalent of ~v: walk back n parents, arbitrarily choosing a parent when a choice must be made

45 TransactionIdHeadBranchBacktrack Int | -- ^ git equivalent of ^: walk back one parent level to the nth arbitrarily-chosen parent

46 TransactionIdHeadBranchBacktrack Int | -- ^ git equivalent of ^: walk back one parent level to the nth arbitrarily-chosen parent

46 TransactionStampHeadBacktrack UTCTime -- ^ git equivalent of 'git-rev-list -n 1 --before X' find the first transaction which was created before the timestamp

47 TransactionStampHeadBacktrack UTCTime -- ^ git equivalent of 'git-rev-list -n 1 --before X' find the first transaction which was created before the timestamp

47− deriving (Show, Eq, Binary, Generic)

48+ deriving (Show, Eq, Generic)

49+ deriving Serialise via WineryVariant TransactionIdHeadBacktrack

48

50

49

51

50-- | Operators which manipulate a transaction graph and which transaction the current 'Session' is based upon.

52-- | Operators which manipulate a transaction graph and which transaction the current 'Session' is based upon.

@@ -56,13 +58,14 @@ data TransactionGraphOperator = JumpToHead HeadName |

56 MergeTransactions MergeStrategy HeadName HeadName |

58 MergeTransactions MergeStrategy HeadName HeadName |

57 Commit |

59 Commit |

58 Rollback

60 Rollback

59− deriving (Eq, Show, Binary, Generic)

61+ deriving (Eq, Show, Generic)

62+ deriving Serialise via WineryVariant TransactionGraphOperator

60

63

61isCommit :: TransactionGraphOperator -> Bool

64isCommit :: TransactionGraphOperator -> Bool

62isCommit Commit = True

65isCommit Commit = True

63isCommit _ = False

66isCommit _ = False

64

67

65−data ROTransactionGraphOperator = ShowGraph

68+data ROTransactionGraphOperator = ShowGraph | ValidateMerkleHashes

66 deriving Show

69 deriving Show

67

70

68bootstrapTransactionGraph :: UTCTime -> TransactionId -> DatabaseContext -> TransactionGraph

71bootstrapTransactionGraph :: UTCTime -> TransactionId -> DatabaseContext -> TransactionGraph

@@ -71,7 +74,16 @@ bootstrapTransactionGraph stamp' freshId context = TransactionGraph bootstrapHea

71 bootstrapHeads = M.singleton "master" freshTransaction

74 bootstrapHeads = M.singleton "master" freshTransaction

72 newSchemas = Schemas context M.empty

75 newSchemas = Schemas context M.empty

73 freshTransaction = fresh freshId stamp' newSchemas

76 freshTransaction = fresh freshId stamp' newSchemas

77+ hashedTransaction = Transaction freshId ((transactionInfo freshTransaction) { merkleHash = calculateMerkleHash freshTransaction emptyTransactionGraph }) newSchemas

74− bootstrapTransactions = S.singleton freshTransaction

78+ bootstrapTransactions = S.singleton hashedTransaction

79+

80+-- | Create a transaction graph from a context.

81+freshTransactionGraph :: DatabaseContext -> IO (TransactionGraph, TransactionId)

82+freshTransactionGraph ctx = do

83+ now <- getCurrentTime

84+ freshId <- nextRandom

85+ pure (bootstrapTransactionGraph now freshId ctx, freshId)

86+

75

87

76emptyTransactionGraph :: TransactionGraph

88emptyTransactionGraph :: TransactionGraph

77emptyTransactionGraph = TransactionGraph M.empty S.empty

89emptyTransactionGraph = TransactionGraph M.empty S.empty

@@ -98,9 +110,12 @@ transactionsForIds idSet graph =

98isRootTransaction :: Transaction -> Bool

110isRootTransaction :: Transaction -> Bool

99isRootTransaction trans = parentIds trans == S.singleton U.nil

111isRootTransaction trans = parentIds trans == S.singleton U.nil

100

112

113+rootTransactions :: TransactionGraph -> S.Set Transaction

114+rootTransactions graph = S.filter isRootTransaction (transactionsForGraph graph)

115+

101-- the first transaction has no parent - all other do have parents- merges have two parents

116-- the first transaction has no parent - all other do have parents- merges have two parents

102parentTransactions :: Transaction -> TransactionGraph -> Either RelationalError (S.Set Transaction)

117parentTransactions :: Transaction -> TransactionGraph -> Either RelationalError (S.Set Transaction)

103−parentTransactions trans graph = transactionsForIds (parentIds trans) graph

118+parentTransactions trans = transactionsForIds (parentIds trans)

104

119

105childTransactions :: Transaction -> TransactionGraph -> Either RelationalError (S.Set Transaction)

120childTransactions :: Transaction -> TransactionGraph -> Either RelationalError (S.Set Transaction)

106childTransactions trans graph = transactionsForIds childIds graph

121childTransactions trans graph = transactionsForIds childIds graph

@@ -118,10 +133,13 @@ addBranch stamp' newId newBranchName branchPointId graph = do

118

133

119--adds a disconnected transaction to a transaction graph at some head

134--adds a disconnected transaction to a transaction graph at some head

120addDisconnectedTransaction :: UTCTime -> TransactionId -> HeadName -> DisconnectedTransaction -> TransactionGraph -> Either RelationalError (Transaction, TransactionGraph)

135addDisconnectedTransaction :: UTCTime -> TransactionId -> HeadName -> DisconnectedTransaction -> TransactionGraph -> Either RelationalError (Transaction, TransactionGraph)

121−addDisconnectedTransaction stamp' newId headName (DisconnectedTransaction parentId schemas' _) = addTransactionToGraph headName newTrans

136+addDisconnectedTransaction stamp' newId headName (DisconnectedTransaction parentId schemas' _) graph = addTransactionToGraph headName newTrans' graph

122 where

137 where

138+ newTrans = Transaction newId newTInfo schemas'

123− newTrans = Transaction newId (TI.singleParent parentId stamp') schemas'

139+ newTInfo = TI.singleParent parentId stamp'

124−

140+ newTrans' = Transaction newId (newTInfo { merkleHash = newHash }) schemas'

141+ newHash = calculateMerkleHash newTrans graph--lookup parents in graph to calculate

142+--LOOP

125addTransactionToGraph :: HeadName -> Transaction -> TransactionGraph -> Either RelationalError (Transaction, TransactionGraph)

143addTransactionToGraph :: HeadName -> Transaction -> TransactionGraph -> Either RelationalError (Transaction, TransactionGraph)

126addTransactionToGraph headName newTrans graph = do

144addTransactionToGraph headName newTrans graph = do

127 let parentIds' = parentIds newTrans

145 let parentIds' = parentIds newTrans

@@ -139,10 +157,24 @@ addTransactionToGraph headName newTrans graph = do

139 unless (S.null childTs) (Left $ NewTransactionMayNotHaveChildrenError newId)

157 unless (S.null childTs) (Left $ NewTransactionMayNotHaveChildrenError newId)

140 --validate that the trasaction's id is unique

158 --validate that the trasaction's id is unique

141 when (isRight (transactionForId newId graph)) (Left (TransactionIdInUseError newId))

159 when (isRight (transactionForId newId graph)) (Left (TransactionIdInUseError newId))

160+ --replace all references to UncommittedTransactionMarker to new transaction id

161+ let newTrans' = newTransUncommittedReplace newTrans

162+ updatedTransSet = S.insert newTrans' (transactionsForGraph graph)

163+ updatedHeads = M.insert headName newTrans' (transactionHeadsForGraph graph)

164+ pure (newTrans', TransactionGraph updatedHeads updatedTransSet)

165+

166+--replace all occurrences of the uncommitted context marker

167+newTransUncommittedReplace :: Transaction -> Transaction

168+newTransUncommittedReplace trans@(Transaction tid tinfo (Schemas ctx sschemas)) =

169+ Transaction tid tinfo (Schemas fixedContext sschemas)

170+ where

171+ uncommittedReplace UncommittedContextMarker = TransactionMarker tid

172+ uncommittedReplace marker = marker

173+ relvars = relationVariables (concreteDatabaseContext trans)

174+ fixedRelvars = M.map (fmap uncommittedReplace) relvars

175+ fixedContext = ctx { relationVariables = fixedRelvars }

176+

142

177

143− let updatedTransSet = S.insert newTrans (transactionsForGraph graph)

144− updatedHeads = M.insert headName newTrans (transactionHeadsForGraph graph)

145− pure (newTrans, TransactionGraph updatedHeads updatedTransSet)

146

178

147validateGraph :: TransactionGraph -> Maybe [RelationalError]

179validateGraph :: TransactionGraph -> Maybe [RelationalError]

148validateGraph graph@(TransactionGraph _ transSet) = do

180validateGraph graph@(TransactionGraph _ transSet) = do

@@ -199,12 +231,12 @@ evalGraphOp _ _ _ graph (JumpToTransaction jumpId) = case transactionForId jumpI

199 Left err -> Left err

231 Left err -> Left err

200 Right parentTrans -> Right (newTrans, graph)

232 Right parentTrans -> Right (newTrans, graph)

201 where

233 where

202− newTrans = DisconnectedTransaction jumpId (schemas parentTrans) NoOperation

234+ newTrans = DisconnectedTransaction jumpId (schemas parentTrans) False

203

235

204-- switch from one head to another

236-- switch from one head to another

205evalGraphOp _ _ _ graph (JumpToHead headName) =

237evalGraphOp _ _ _ graph (JumpToHead headName) =

206 case transactionForHead headName graph of

238 case transactionForHead headName graph of

207− Just newHeadTransaction -> let disconnectedTrans = DisconnectedTransaction (transactionId newHeadTransaction) (schemas newHeadTransaction) NoOperation in

239+ Just newHeadTransaction -> let disconnectedTrans = DisconnectedTransaction (transactionId newHeadTransaction) (schemas newHeadTransaction) False in

208 Right (disconnectedTrans, graph)

240 Right (disconnectedTrans, graph)

209 Nothing -> Left $ NoSuchHeadNameError headName

241 Nothing -> Left $ NoSuchHeadNameError headName

210

242

@@ -258,7 +290,10 @@ evalGraphOp _ _ (DisconnectedTransaction parentId _ _) graph Rollback = case tra

258 where

290 where

259 newDiscon = Discon.freshTransaction parentId (schemas parentTransaction)

291 newDiscon = Discon.freshTransaction parentId (schemas parentTransaction)

260

292

261−evalGraphOp stamp' newId (DisconnectedTransaction parentId _ _) graph (MergeTransactions mergeStrategy headNameA headNameB) = mergeTransactions stamp' newId parentId mergeStrategy (headNameA, headNameB) graph

293+evalGraphOp stamp' newId (DisconnectedTransaction parentId _ _) graph (MergeTransactions mergeStrategy headNameA headNameB) =

294+ runGraphRefRelationalExprM env $ mergeTransactions stamp' newId parentId mergeStrategy (headNameA, headNameB)

295+ where

296+ env = freshGraphRefRelationalExprEnv Nothing graph

262

297

263evalGraphOp _ _ discon graph@(TransactionGraph graphHeads transSet) (DeleteBranch branchName) = case transactionForHead branchName graph of

298evalGraphOp _ _ discon graph@(TransactionGraph graphHeads transSet) (DeleteBranch branchName) = case transactionForHead branchName graph of

264 Nothing -> Left (NoSuchHeadNameError branchName)

299 Nothing -> Left (NoSuchHeadNameError branchName)

@@ -271,6 +306,7 @@ graphAsRelation (DisconnectedTransaction parentId _ _) graph@(TransactionGraph _

271 mkRelationFromList attrs tupleMatrix

306 mkRelationFromList attrs tupleMatrix

272 where

307 where

273 attrs = A.attributesFromList [Attribute "id" TextAtomType,

308 attrs = A.attributesFromList [Attribute "id" TextAtomType,

309+ Attribute "hash" ByteStringAtomType,

274 Attribute "stamp" DateTimeAtomType,

310 Attribute "stamp" DateTimeAtomType,

275 Attribute "parents" (RelationAtomType parentAttributes),

311 Attribute "parents" (RelationAtomType parentAttributes),

276 Attribute "current" BoolAtomType,

312 Attribute "current" BoolAtomType,

@@ -280,6 +316,7 @@ graphAsRelation (DisconnectedTransaction parentId _ _) graph@(TransactionGraph _

280 tupleGenerator transaction = case transactionParentsRelation transaction graph of

316 tupleGenerator transaction = case transactionParentsRelation transaction graph of

281 Left err -> Left err

317 Left err -> Left err

282 Right parentTransRel -> Right [TextAtom $ T.pack $ show (transactionId transaction),

318 Right parentTransRel -> Right [TextAtom $ T.pack $ show (transactionId transaction),

319+ ByteStringAtom $ _unMerkleHash (merkleHash (transactionInfo transaction)),

283 DateTimeAtom (timestamp transaction),

320 DateTimeAtom (timestamp transaction),

284 RelationAtom parentTransRel,

321 RelationAtom parentTransRel,

285 BoolAtom $ parentId == transactionId transaction,

322 BoolAtom $ parentId == transactionId transaction,

@@ -307,29 +344,34 @@ evalROGraphOp discon graph ShowGraph = do

307-}

344-}

308

345

309-- | Execute the merge strategy against the transactions, returning a new transaction which can be then added to the transaction graph

346-- | Execute the merge strategy against the transactions, returning a new transaction which can be then added to the transaction graph

310−createMergeTransaction :: UTCTime -> TransactionId -> MergeStrategy -> TransactionGraph -> (Transaction, Transaction) -> Either MergeError Transaction

347+createMergeTransaction :: UTCTime -> TransactionId -> MergeStrategy -> (Transaction, Transaction) -> GraphRefRelationalExprM Transaction

311−createMergeTransaction stamp' newId (SelectedBranchMergeStrategy selectedBranch) graph t2@(trans1, trans2) = do

348+createMergeTransaction stamp' newId (SelectedBranchMergeStrategy selectedBranch) t2@(trans1, trans2) = do

349+ graph <- gfGraph

312− let selectedTrans = validateHeadName selectedBranch graph t2

350+ selectedTrans <- validateHeadName selectedBranch graph t2

351+ pure $ addMerkleHash graph $

313− Transaction newId (TransactionInfo {

352+ Transaction newId (TransactionInfo {

314− parents = NE.fromList [transactionId trans1,

353+ parents = NE.fromList [transactionId trans1,

315− transactionId trans2],

354+ transactionId trans2],

355+ stamp = stamp',

316− stamp = stamp' }) . schemas <$> selectedTrans

356+ merkleHash = mempty }) (schemas selectedTrans)

317

357

318-- merge functions, relvars, individually

358-- merge functions, relvars, individually

319−createMergeTransaction stamp' newId strat@UnionMergeStrategy graph t2 = createUnionMergeTransaction stamp' newId strat graph t2

359+createMergeTransaction stamp' newId strat@UnionMergeStrategy t2 =

360+ createUnionMergeTransaction stamp' newId strat t2

320

361

321-- merge function, relvars, but, on error, just take the component from the preferred branch

362-- merge function, relvars, but, on error, just take the component from the preferred branch

322−createMergeTransaction stamp' newId strat@(UnionPreferMergeStrategy _) graph t2 = createUnionMergeTransaction stamp' newId strat graph t2

363+createMergeTransaction stamp' newId strat@(UnionPreferMergeStrategy _) t2 =

364+ createUnionMergeTransaction stamp' newId strat t2

323

365

324-- | Returns the correct Transaction for the branch name in the graph and ensures that it is one of the two transaction arguments in the tuple.

366-- | Returns the correct Transaction for the branch name in the graph and ensures that it is one of the two transaction arguments in the tuple.

325−validateHeadName :: HeadName -> TransactionGraph -> (Transaction, Transaction) -> Either MergeError Transaction

367+validateHeadName :: HeadName -> TransactionGraph -> (Transaction, Transaction) -> GraphRefRelationalExprM Transaction

326validateHeadName headName graph (t1, t2) =

368validateHeadName headName graph (t1, t2) =

327 case transactionForHead headName graph of

369 case transactionForHead headName graph of

328− Nothing -> Left SelectedHeadMismatchMergeError

370+ Nothing -> throwError (MergeTransactionError SelectedHeadMismatchMergeError)

329 Just trans -> if trans /= t1 && trans /= t2 then

371 Just trans -> if trans /= t1 && trans /= t2 then

330− Left SelectedHeadMismatchMergeError

372+ throwError (MergeTransactionError SelectedHeadMismatchMergeError)

331 else

373 else

332− Right trans

374+ pure trans

333

375

334-- Algorithm: start at one transaction and work backwards up the parents. If there is a node we have not yet visited as a child, then walk that up to its head. If that branch contains the goal transaction, then we have completed a valid subgraph traversal.

376-- Algorithm: start at one transaction and work backwards up the parents. If there is a node we have not yet visited as a child, then walk that up to its head. If that branch contains the goal transaction, then we have completed a valid subgraph traversal.

335subGraphOfFirstCommonAncestor :: TransactionGraph -> TransactionHeads -> Transaction -> Transaction -> S.Set Transaction -> Either RelationalError TransactionGraph

377subGraphOfFirstCommonAncestor :: TransactionGraph -> TransactionHeads -> Transaction -> Transaction -> S.Set Transaction -> Either RelationalError TransactionGraph

@@ -342,7 +384,7 @@ subGraphOfFirstCommonAncestor origGraph resultHeads currentTrans' goalTrans trav

342 else do

384 else do

343 currentTransChildren <- childTransactions currentTrans' origGraph

385 currentTransChildren <- childTransactions currentTrans' origGraph

344 let searchChildren = S.difference (S.insert currentTrans' traverseSet) currentTransChildren

386 let searchChildren = S.difference (S.insert currentTrans' traverseSet) currentTransChildren

345− searchChild start = pathToTransaction origGraph start goalTrans (S.insert currentTrans' traverseSet)

387+ searchChild start' = pathToTransaction origGraph start' goalTrans (S.insert currentTrans' traverseSet)

346 childSearches = map searchChild (S.toList searchChildren)

388 childSearches = map searchChild (S.toList searchChildren)

347 errors = lefts childSearches

389 errors = lefts childSearches

348 pathsFound = rights childSearches

390 pathsFound = rights childSearches

@@ -382,26 +424,28 @@ pathToTransaction graph currentTransaction targetTransaction accumTransSet = do

382 else --we have some paths!

424 else --we have some paths!

383 Right (S.unions paths)

425 Right (S.unions paths)

384

426

385−mergeTransactions :: UTCTime -> TransactionId -> TransactionId -> MergeStrategy -> (HeadName, HeadName) -> TransactionGraph -> Either RelationalError (DisconnectedTransaction, TransactionGraph)

427+mergeTransactions :: UTCTime -> TransactionId -> TransactionId -> MergeStrategy -> (HeadName, HeadName) -> GraphRefRelationalExprM (DisconnectedTransaction, TransactionGraph)

386−mergeTransactions stamp' newId parentId mergeStrategy (headNameA, headNameB) graph = do

428+mergeTransactions stamp' newId parentId mergeStrategy (headNameA, headNameB) = do

429+ graph <- gfGraph

387 let transactionForHeadErr name = case transactionForHead name graph of

430 let transactionForHeadErr name = case transactionForHead name graph of

388− Nothing -> Left (NoSuchHeadNameError name)

431+ Nothing -> throwError (NoSuchHeadNameError name)

389− Just t -> Right t

432+ Just t -> pure t

433+ runE e = case e of

434+ Left e' -> throwError e'

435+ Right v -> pure v

390− transA <- transactionForHeadErr headNameA

436+ transA <- transactionForHeadErr headNameA

391− transB <- transactionForHeadErr headNameB

437+ transB <- transactionForHeadErr headNameB

392− disconParent <- transactionForId parentId graph

438+ disconParent <- gfTransForId parentId

393 let subHeads = M.filterWithKey (\k _ -> k `elem` [headNameA, headNameB]) (transactionHeadsForGraph graph)

439 let subHeads = M.filterWithKey (\k _ -> k `elem` [headNameA, headNameB]) (transactionHeadsForGraph graph)

394− subGraph <- subGraphOfFirstCommonAncestor graph subHeads transA transB S.empty

440+ subGraph <- runE $ subGraphOfFirstCommonAncestor graph subHeads transA transB S.empty

395− subGraph' <- filterSubGraph subGraph subHeads

441+ subGraph' <- runE $ filterSubGraph subGraph subHeads

396− case createMergeTransaction stamp' newId mergeStrategy subGraph' (transA, transB) of

442+ mergedTrans <- local (const (freshGraphRefRelationalExprEnv Nothing subGraph')) $ createMergeTransaction stamp' newId mergeStrategy (transA, transB)

397− Left err -> Left (MergeTransactionError err)

398− Right mergedTrans ->

399− case headNameForTransaction disconParent graph of

443+ case headNameForTransaction disconParent graph of

400− Nothing -> Left (TransactionIsNotAHeadError parentId)

444+ Nothing -> throwError (TransactionIsNotAHeadError parentId)

401 Just headName -> do

445 Just headName -> do

402− (newTrans, newGraph) <- addTransactionToGraph headName mergedTrans graph

446+ (newTrans, newGraph) <- runE $ addTransactionToGraph headName mergedTrans graph

403 case checkConstraints (concreteDatabaseContext mergedTrans) newId graph of

447 case checkConstraints (concreteDatabaseContext mergedTrans) newId graph of

404− Left err -> Left err

448+ Left err -> throwError err

405 Right _ -> do

449 Right _ -> do

406 let newGraph' = TransactionGraph (transactionHeadsForGraph newGraph) (transactionsForGraph newGraph)

450 let newGraph' = TransactionGraph (transactionHeadsForGraph newGraph) (transactionsForGraph newGraph)

407 newDiscon = Discon.freshTransaction newId (schemas newTrans)

451 newDiscon = Discon.freshTransaction newId (schemas newTrans)

@@ -431,25 +475,29 @@ filterSubGraph graph heads = Right $ TransactionGraph newHeads newTransSet

431 newHeads = M.map (filterTransaction validIds) heads

475 newHeads = M.map (filterTransaction validIds) heads

432

476

433--helper function for commonalities in union merge

477--helper function for commonalities in union merge

434−createUnionMergeTransaction :: UTCTime -> TransactionId -> MergeStrategy -> TransactionGraph -> (Transaction, Transaction) -> Either MergeError Transaction

478+createUnionMergeTransaction :: UTCTime -> TransactionId -> MergeStrategy -> (Transaction, Transaction) -> GraphRefRelationalExprM Transaction

435−createUnionMergeTransaction stamp' newId strategy graph (t1,t2) = do

479+createUnionMergeTransaction stamp' newId strategy (t1,t2) = do

436 let contextA = concreteDatabaseContext t1

480 let contextA = concreteDatabaseContext t1

437 contextB = concreteDatabaseContext t2

481 contextB = concreteDatabaseContext t2

438−

482+ liftMergeE x = case x of

483+ Left e -> throwError (MergeTransactionError e)

484+ Right t -> pure t

485+

486+ graph <- gfGraph

439 preference <- case strategy of

487 preference <- case strategy of

440 UnionMergeStrategy -> pure PreferNeither

488 UnionMergeStrategy -> pure PreferNeither

441 UnionPreferMergeStrategy preferBranch ->

489 UnionPreferMergeStrategy preferBranch ->

442 case transactionForHead preferBranch graph of

490 case transactionForHead preferBranch graph of

443− Nothing -> Left (PreferredHeadMissingMergeError preferBranch)

491+ Nothing -> throwError (MergeTransactionError (PreferredHeadMissingMergeError preferBranch))

444 Just preferredTrans -> pure $ if t1 == preferredTrans then PreferFirst else PreferSecond

492 Just preferredTrans -> pure $ if t1 == preferredTrans then PreferFirst else PreferSecond

445− badStrat -> Left (InvalidMergeStrategyError badStrat)

493+ badStrat -> throwError (MergeTransactionError (InvalidMergeStrategyError badStrat))

446

494

447− incDeps <- unionMergeMaps preference (inclusionDependencies contextA) (inclusionDependencies contextB)

495+ incDeps <- liftMergeE $ unionMergeMaps preference (inclusionDependencies contextA) (inclusionDependencies contextB)

448 relVars <- unionMergeRelVars preference (relationVariables contextA) (relationVariables contextB)

496 relVars <- unionMergeRelVars preference (relationVariables contextA) (relationVariables contextB)

449− atomFuncs <- unionMergeAtomFunctions preference (atomFunctions contextA) (atomFunctions contextB)

497+ atomFuncs <- liftMergeE $ unionMergeAtomFunctions preference (atomFunctions contextA) (atomFunctions contextB)

450− notifs <- unionMergeMaps preference (notifications contextA) (notifications contextB)

498+ notifs <- liftMergeE $ unionMergeMaps preference (notifications contextA) (notifications contextB)

451− types <- unionMergeTypeConstructorMapping preference (typeConstructorMapping contextA) (typeConstructorMapping contextB)

499+ types <- liftMergeE $ unionMergeTypeConstructorMapping preference (typeConstructorMapping contextA) (typeConstructorMapping contextB)

452− dbcFuncs <- unionMergeDatabaseContextFunctions preference (dbcFunctions contextA) (dbcFunctions contextB)

500+ dbcFuncs <- liftMergeE $ unionMergeDatabaseContextFunctions preference (dbcFunctions contextA) (dbcFunctions contextB)

453 -- TODO: add merge of subschemas

501 -- TODO: add merge of subschemas

454 let newContext = DatabaseContext {

502 let newContext = DatabaseContext {

455 inclusionDependencies = incDeps,

503 inclusionDependencies = incDeps,

@@ -460,10 +508,12 @@ createUnionMergeTransaction stamp' newId strategy graph (t1,t2) = do

460 typeConstructorMapping = types

508 typeConstructorMapping = types

461 }

509 }

462 newSchemas = Schemas newContext (subschemas t1)

510 newSchemas = Schemas newContext (subschemas t1)

511+ pure $ addMerkleHash graph $

463− pure (Transaction newId (TransactionInfo {

512+ Transaction newId (TransactionInfo {

464− parents = NE.fromList [transactionId t1,

513+ parents = NE.fromList [transactionId t1,

465− transactionId t2],

514+ transactionId t2],

466− stamp = stamp'}) newSchemas)

515+ stamp = stamp',

516+ merkleHash = mempty }) newSchemas

467

517

468lookupTransaction :: TransactionGraph -> TransactionIdLookup -> Either RelationalError Transaction

518lookupTransaction :: TransactionGraph -> TransactionIdLookup -> Either RelationalError Transaction

469lookupTransaction graph (TransactionIdLookup tid) = transactionForId tid graph

519lookupTransaction graph (TransactionIdLookup tid) = transactionForId tid graph

@@ -480,15 +530,16 @@ backtrackGraph :: TransactionGraph -> TransactionId -> TransactionIdHeadBacktrac

480-- tilde, step back one parent link- if a choice must be made, choose the "first" link arbitrarily

530-- tilde, step back one parent link- if a choice must be made, choose the "first" link arbitrarily

481backtrackGraph graph currentTid (TransactionIdHeadParentBacktrack steps) = do

531backtrackGraph graph currentTid (TransactionIdHeadParentBacktrack steps) = do

482 trans <- transactionForId currentTid graph

532 trans <- transactionForId currentTid graph

533+

483− let parentIds' = S.toList (parentIds trans)

534+ let parentIds' = S.toAscList (parentIds trans)

484− if length parentIds' < 1 then

535+ case parentIds' of

485− Left RootTransactionTraversalError

536+ [] -> Left RootTransactionTraversalError

486− else do

537+ firstParentId:_ -> do

487− parentTrans <- transactionForId (head parentIds') graph

538+ parentTrans <- transactionForId firstParentId graph

488− if steps == 1 then

539+ if steps == 1 then

489− pure (transactionId parentTrans)

540+ pure (transactionId parentTrans)

490− else

541+ else

491− backtrackGraph graph (transactionId parentTrans) (TransactionIdHeadParentBacktrack (steps - 1))

542+ backtrackGraph graph (transactionId parentTrans) (TransactionIdHeadParentBacktrack (steps - 1))

492

543

493backtrackGraph graph currentTid (TransactionIdHeadBranchBacktrack steps) = do

544backtrackGraph graph currentTid (TransactionIdHeadBranchBacktrack steps) = do

494 trans <- transactionForId currentTid graph

545 trans <- transactionForId currentTid graph

@@ -538,3 +589,47 @@ autoMergeToHead stamp' (tempBranchTransId, tempCommitTransId, mergeTransId) disc

538 pure (discon''''', graph''''')

589 pure (discon''''', graph''''')

539

590

540

591

592+addMerkleHash :: TransactionGraph -> Transaction -> Transaction

593+addMerkleHash graph trans = Transaction (transactionId trans) newInfo (schemas trans)

594+ where

595+ newInfo = (transactionInfo trans) { merkleHash = calculateMerkleHash trans graph }

596+

597+-- the new hash includes the parents' ids, the current id, and the hash of the context, and the merkle hashes of the parent transactions

598+calculateMerkleHash :: Transaction -> TransactionGraph -> MerkleHash

599+calculateMerkleHash trans graph = MerkleHash $ hashlazy (BL.fromChunks [transIds,

600+ schemasBytes

601+ ] <> dbcBytes <> parentMerkleHashes)

602+ where

603+ parentMerkleHashes = BL.fromChunks $ map (_unMerkleHash . getMerkleHash) parentTranses

604+ parentTranses =

605+ case transactionsForIds (parentIds trans) graph of

606+ Left RootTransactionTraversalError -> []

607+ Left e -> error ("failed to find transaction in Merkle hash construction: " ++ show e)

608+ Right t -> S.toList t

609+ getMerkleHash t = merkleHash (transactionInfo t)

610+ transIds = serialise (transactionId trans : S.toList (parentIds trans))

611+ dbcBytes = DBC.hashBytes (concreteDatabaseContext trans)

612+ schemasBytes = serialise (subschemas trans)

613+

614+validateMerkleHash :: Transaction -> TransactionGraph -> Either MerkleValidationError ()

615+validateMerkleHash trans graph =

616+ if expectedHash /= actualHash then

617+ Left (MerkleValidationError (transactionId trans) expectedHash actualHash)

618+ else

619+ pure ()

620+ where

621+ expectedHash = merkleHash (transactionInfo trans)

622+ actualHash = calculateMerkleHash trans graph

623+

624+data MerkleValidationError = MerkleValidationError TransactionId MerkleHash MerkleHash

625+ deriving (Show, Eq, Generic)

626+

627+validateMerkleHashes :: TransactionGraph -> Either [MerkleValidationError] ()

628+validateMerkleHashes graph =

629+ if null errs then pure () else Left errs

630+ where

631+ errs = S.foldr validateTrans [] (transactionsForGraph graph)

632+ validateTrans trans acc =

633+ case validateMerkleHash trans graph of

634+ Left err -> err : acc

635+ _ -> acc

src/lib/ProjectM36/TransactionGraph/Merge.hs+19−15

@@ -2,10 +2,11 @@

2module ProjectM36.TransactionGraph.Merge where

3import ProjectM36.Base

4import ProjectM36.Error

5+import ProjectM36.RelationalExpression

6+import Control.Monad.Except hiding (join)

5import qualified Data.Set as S

7import qualified Data.Set as S

6import qualified Data.Map as M

8import qualified Data.Map as M

7import qualified ProjectM36.TypeConstructorDef as TCD

9import qualified ProjectM36.TypeConstructorDef as TCD

8−import ProjectM36.Relation

9import Control.Monad (foldM)

10import Control.Monad (foldM)

10import qualified Data.HashSet as HS

11import qualified Data.HashSet as HS

11

12

@@ -22,20 +23,23 @@ unionMergeMaps prefer mapA mapB = case prefer of

22 Left StrategyViolatesComponentMergeError

23 Left StrategyViolatesComponentMergeError

23

24

24-- perform the merge even if the attributes are different- is this what we want? Obviously, we need finer-grained merge options.

25-- perform the merge even if the attributes are different- is this what we want? Obviously, we need finer-grained merge options.

25−unionMergeRelation :: MergePreference -> Relation -> Relation -> Either MergeError Relation

26+unionMergeRelation :: MergePreference -> GraphRefRelationalExpr -> GraphRefRelationalExpr -> GraphRefRelationalExprM GraphRefRelationalExpr

26−unionMergeRelation prefer relA relB = case relA `union` relB of

27+unionMergeRelation prefer relA relB = do

27− Right unionRel -> pure unionRel

28+ let unioned = Union relA relB

28− Left (AttributeNamesMismatchError _) -> preferredRelVar

29− Left _ -> Left StrategyViolatesRelationVariableMergeError

29+ mergeErr = MergeTransactionError StrategyViolatesRelationVariableMergeError

30− where

31− preferredRelVar = case prefer of

30+ preferredRelVar =

31+ case prefer of

32− PreferFirst -> Right relA

32+ PreferFirst -> pure relA

33− PreferSecond -> Right relB

33+ PreferSecond -> pure relB

34− PreferNeither -> Left StrategyViolatesRelationVariableMergeError

34+ PreferNeither -> throwError mergeErr

35+ handler AttributeNamesMismatchError{} = preferredRelVar

36+ handler _err' = throwError mergeErr

37+ --typecheck first?

38+ (evalGraphRefRelationalExpr unioned >> pure (Union relA relB)) `catchError` handler

35

39

36--try to execute unions against the relvars contents -- if a relvar only appears in one context, include it

40--try to execute unions against the relvars contents -- if a relvar only appears in one context, include it

37−unionMergeRelVars :: MergePreference -> RelationVariables -> RelationVariables -> Either MergeError RelationVariables

41+unionMergeRelVars :: MergePreference -> RelationVariables -> RelationVariables -> GraphRefRelationalExprM RelationVariables

38−unionMergeRelVars _ relvarsA relvarsB = do

42+unionMergeRelVars prefer relvarsA relvarsB = do

39 let allNames = S.toList (S.union (M.keysSet relvarsA) (M.keysSet relvarsB))

43 let allNames = S.toList (S.union (M.keysSet relvarsA) (M.keysSet relvarsB))

40 foldM (\acc name -> do

44 foldM (\acc name -> do

41 mergedRel <- do

45 mergedRel <- do

@@ -43,8 +47,8 @@ unionMergeRelVars _ relvarsA relvarsB = do

43 lookupA = findRel relvarsA

47 lookupA = findRel relvarsA

44 lookupB = findRel relvarsB

48 lookupB = findRel relvarsB

45 case (lookupA, lookupB) of

49 case (lookupA, lookupB) of

46− (Just _, Just _) -> unimplemented

50+ (Just relA, Just relB) ->

47− --unionMergeRelation prefer relA relB

51+ unionMergeRelation prefer relA relB

48 (Nothing, Just relB) -> pure relB

52 (Nothing, Just relB) -> pure relB

49 (Just relA, Nothing) -> pure relA

53 (Just relA, Nothing) -> pure relA

50 (Nothing, Nothing) -> error "impossible relvar naming lookup"

54 (Nothing, Nothing) -> error "impossible relvar naming lookup"

src/lib/ProjectM36/TransactionGraph/Persist.hs+3−3

@@ -24,14 +24,14 @@ import Control.Exception.Base

24import qualified Data.ByteString as BS

25import qualified Data.Text.Encoding as TE

26import Data.ByteString (ByteString)

27+#if __GLASGOW_HASKELL__ < 804

28+import Data.Monoid

29+#endif

27import qualified Crypto.Hash.SHA256 as SHA256

30import qualified Crypto.Hash.SHA256 as SHA256

28import Control.Arrow

31import Control.Arrow

29import Data.Time.Clock

32import Data.Time.Clock

30import Data.Text.Read

33import Data.Text.Read

31import System.FilePath.Glob

34import System.FilePath.Glob

32−#if __GLASGOW_HASKELL__ <= 802

33−import Data.Monoid

34−#endif

35

36type LockFileHash = ByteString

37

src/lib/ProjectM36/TransactionInfo.hs+5−3

@@ -1,10 +1,12 @@

1module ProjectM36.TransactionInfo where

2import ProjectM36.Base

3import Data.Time.Clock

4−import Data.List.NonEmpty

4+import qualified Data.List.NonEmpty as NE

5

6-- | Create a TransactionInfo with just one parent transaction ID.

7singleParent :: TransactionId -> UTCTime -> TransactionInfo

8singleParent tid stamp' = TransactionInfo {

9− parents = tid :| [],

9+ parents = tid NE.:| [],

10− stamp = stamp' }

10+ stamp = stamp',

11+ merkleHash = mempty }

12+

src/lib/ProjectM36/Tuple.hs+47−33

@@ -1,7 +1,7 @@

1module ProjectM36.Tuple where

2import ProjectM36.Base

3import ProjectM36.Error

4−import ProjectM36.Attribute

4+import ProjectM36.Attribute as A

5import ProjectM36.Atom

6import ProjectM36.AtomType

7import ProjectM36.DataTypes.Primitive

@@ -15,19 +15,19 @@ import Control.Arrow

15import Data.Maybe

16

17emptyTuple :: RelationTuple

18−emptyTuple = RelationTuple V.empty V.empty

18+emptyTuple = RelationTuple mempty mempty

19

20tupleSize :: RelationTuple -> Int

21−tupleSize (RelationTuple tupAttrs _) = V.length tupAttrs

21+tupleSize (RelationTuple tupAttrs _) = arity tupAttrs

22

23tupleAttributeNameSet :: RelationTuple -> S.Set AttributeName

24−tupleAttributeNameSet (RelationTuple tupAttrs _) = S.fromList $ V.toList $ V.map attributeName tupAttrs

24+tupleAttributeNameSet (RelationTuple tupAttrs _) = attributeNameSet tupAttrs

25

26tupleAttributes :: RelationTuple -> Attributes

27tupleAttributes (RelationTuple tupAttrs _) = tupAttrs

28

29tupleAssocs :: RelationTuple -> [(AttributeName, Atom)]

30−tupleAssocs (RelationTuple attrVec tupVec) = V.toList $ V.map (first attributeName) (V.zip attrVec tupVec)

30+tupleAssocs (RelationTuple attrs tupVec) = V.toList $ V.map (first attributeName) (V.zip (attributesVec attrs) tupVec)

31

32orderedTupleAssocs :: RelationTuple -> [(AttributeName, Atom)]

33orderedTupleAssocs tup@(RelationTuple attrVec _) = map (\attr -> (attributeName attr, atomForAttr (attributeName attr))) oAttrs

@@ -42,7 +42,7 @@ tupleAtoms :: RelationTuple -> V.Vector Atom

42tupleAtoms (RelationTuple _ tupVec) = tupVec

43

44atomForAttributeName :: AttributeName -> RelationTuple -> Either RelationalError Atom

45−atomForAttributeName attrName (RelationTuple tupAttrs tupVec) = case V.findIndex (\attr -> attributeName attr == attrName) tupAttrs of

45+atomForAttributeName attrName (RelationTuple tupAttrs tupVec) = case V.findIndex (\attr -> attributeName attr == attrName) (attributesVec tupAttrs) of

46 Nothing -> Left (NoSuchAttributeNamesError (S.singleton attrName))

47 Just index -> case tupVec V.!? index of

48 Nothing -> Left (NoSuchAttributeNamesError (S.singleton attrName))

@@ -59,7 +59,7 @@ vectorIndicesForAttributeNames attrNameVec attrs = if not $ V.null unknownAttrNa

59 Right $ V.map mapper attrNameVec

60 where

61 unknownAttrNames = V.filter (`V.notElem` attributeNames attrs) attrNameVec

62− mapper attrName = fromMaybe (error "logic failure in vectorIndicesForAttributeNames") (V.elemIndex attrName (V.map attributeName attrs))

62+ mapper attrName = fromMaybe (error "logic failure in vectorIndicesForAttributeNames") (V.elemIndex attrName (attributeNames attrs))

63

64

65relationForAttributeName :: AttributeName -> RelationTuple -> Either RelationalError Relation

@@ -86,10 +86,10 @@ mkRelationTuples attrs = map mapper

86 mapper = mkRelationTuple attrs

87

88mkRelationTupleFromMap :: M.Map AttributeName Atom -> RelationTuple

89−mkRelationTupleFromMap attrMap = RelationTuple attrs (V.map (attrMap M.!) attrNames)

89+mkRelationTupleFromMap attrMap = RelationTuple (attributesFromList attrs) (V.map (attrMap M.!) (V.fromList attrNames))

90 where

91− attrNames = V.fromList (M.keys attrMap)

91+ attrNames = M.keys attrMap

92− attrs = V.map (\attrName -> Attribute attrName (atomTypeForAtom (attrMap M.! attrName))) attrNames

92+ attrs = map (\attrName -> Attribute attrName (atomTypeForAtom (attrMap M.! attrName))) attrNames

93

94--return error if attribute names match but their types do not

95singleTupleSetJoin :: Attributes -> RelationTuple -> RelationTupleSet -> Either RelationalError [RelationTuple]

@@ -120,8 +120,8 @@ singleTupleJoin joinedAttrs tup1@(RelationTuple tupAttrs1 _) tup2@(RelationTuple

120 return $ Just $ RelationTuple joinedAttrs newVec

121 where

122 keysIntersection = V.map attributeName attrsIntersection

123− attrsIntersection = V.filter (`V.elem` tupAttrs1) tupAttrs2

123+ attrsIntersection = V.filter (`V.elem` attributesVec tupAttrs1) (attributesVec tupAttrs2)

124− newVec = V.map (findAtomForAttributeName . attributeName) joinedAttrs

124+ newVec = V.map (findAtomForAttributeName . attributeName) (attributesVec joinedAttrs)

125 --search both tuples for the attribute

126 findAtomForAttributeName attrName = head $ rights $ fmap (atomForAttributeName attrName) [tup1, tup2]

127

@@ -138,23 +138,31 @@ vectorUnion v1 v2 = V.foldr folder v1 v2

138tupleExtend :: RelationTuple -> RelationTuple -> RelationTuple

139tupleExtend (RelationTuple tupAttrs1 tupVec1) (RelationTuple tupAttrs2 tupVec2) = RelationTuple newAttrs newVec

140 where

141− newAttrs = tupAttrs1 V.++ tupAttrs2

141+ newAttrs = tupAttrs1 <> tupAttrs2

142− newVec = tupVec1 V.++ tupVec2

142+ newVec = tupVec1 <> tupVec2

143

144tupleAtomExtend :: AttributeName -> Atom -> RelationTuple -> RelationTuple

145tupleAtomExtend newAttrName atom tupIn = tupleExtend tupIn newTup

146 where

147− newTup = RelationTuple (V.singleton $ Attribute newAttrName (atomTypeForAtom atom)) (V.singleton atom)

147+ newTup = RelationTuple (A.singleton $ Attribute newAttrName (atomTypeForAtom atom)) (V.singleton atom)

148

149−--this could be cheaper- it may not be wortwhile to update all the tuples for projection, but then the attribute management must be slightly different- perhaps the attributes should be a vector of association tuples [(name, index)]

150−tupleProject :: S.Set AttributeName -> RelationTuple -> RelationTuple

149+{-tupleProject :: S.Set AttributeName -> RelationTuple -> RelationTuple

151tupleProject projectAttrs (RelationTuple attrs tupVec) = RelationTuple newAttrs newTupVec

150tupleProject projectAttrs (RelationTuple attrs tupVec) = RelationTuple newAttrs newTupVec

152 where

151 where

153− deleteIndices = V.findIndices (\attr -> S.notMember (attributeName attr) projectAttrs) attrs

152+ deleteIndices = V.findIndices (\attr -> S.notMember (attributeName attr) projectAttrs) (attributesVec attrs)

154 indexDeleter = V.ifilter (\index _ -> V.notElem index deleteIndices)

153 indexDeleter = V.ifilter (\index _ -> V.notElem index deleteIndices)

155− newAttrs = indexDeleter attrs

154+ newAttrs = case A.projectionAttributesForNames projectAttrs attrs of

155+ Left err -> error (show (err, projectAttrs, attrs))

156+ Right attrs' -> attrs'

156 newTupVec = indexDeleter tupVec

157 newTupVec = indexDeleter tupVec

157−

158+-}

159+-- remember that the attributes order matters

160+tupleProject :: Attributes -> RelationTuple -> Either RelationalError RelationTuple

161+tupleProject projectAttrs tup = do

162+ newTupVec <- foldM (\acc attr ->

163+ V.snoc acc <$> atomForAttributeName (attributeName attr) tup

164+ ) V.empty (attributesVec projectAttrs)

165+ pure $ reorderTuple projectAttrs (RelationTuple projectAttrs newTupVec)

158--return the attributes and atoms which are equal in both vectors

166--return the attributes and atoms which are equal in both vectors

159--semi-join

167--semi-join

160tupleIntersection :: RelationTuple -> RelationTuple -> RelationTuple

168tupleIntersection :: RelationTuple -> RelationTuple -> RelationTuple

@@ -162,12 +170,14 @@ tupleIntersection tuple1 tuple2 = RelationTuple newAttrs newTupVec

162 where

170 where

163 attrs1 = tupleAttributes tuple1

171 attrs1 = tupleAttributes tuple1

164 attrs2 = tupleAttributes tuple2

172 attrs2 = tupleAttributes tuple2

173+ intersectAttrs = A.intersection attrs1 attrs2

165− matchingIndices = V.findIndices (\attr -> V.elem attr attrs2 &&

174+ matchingIndices = V.findIndices (\attr -> A.member attr intersectAttrs &&

166− atomForAttributeName (attributeName attr) tuple1 ==

175+ atomForAttributeName (attributeName attr) tuple1 ==

167− atomForAttributeName (attributeName attr) tuple2

176+ atomForAttributeName (attributeName attr) tuple2) (attributesVec attrs1)

168− ) attrs1

169 indexFilter = V.ifilter (\index _ -> V.elem index matchingIndices)

177 indexFilter = V.ifilter (\index _ -> V.elem index matchingIndices)

170− newAttrs = indexFilter attrs1

178+ newAttrs = case A.projectionAttributesForNames (A.attributeNameSet intersectAttrs) attrs1 of

179+ Left _ -> mempty

180+ Right attrs' -> attrs'

171 newTupVec = indexFilter (tupleAtoms tuple1)

181 newTupVec = indexFilter (tupleAtoms tuple1)

172

182

173-- | An optimized form of tuple update which updates vectors efficiently.

183-- | An optimized form of tuple update which updates vectors efficiently.

@@ -175,19 +185,20 @@ updateTupleWithAtoms :: M.Map AttributeName Atom -> RelationTuple -> RelationTup

175updateTupleWithAtoms updateMap (RelationTuple attrs tupVec) = RelationTuple attrs newVec

185updateTupleWithAtoms updateMap (RelationTuple attrs tupVec) = RelationTuple attrs newVec

176 where

186 where

177 updateKeysSet = M.keysSet updateMap

187 updateKeysSet = M.keysSet updateMap

178− updateKeysIVec = V.filter (\(_,attr) -> S.member (attributeName attr) updateKeysSet) (V.indexed attrs)

188+ updateKeysIVec = V.filter (\(_,attr) -> S.member (attributeName attr) updateKeysSet) (V.indexed (attributesVec attrs))

179 newVec = V.update tupVec updateVec

189 newVec = V.update tupVec updateVec

180 updateVec = V.map (\(index, attr) -> (index, updateMap M.! attributeName attr)) updateKeysIVec

190 updateVec = V.map (\(index, attr) -> (index, updateMap M.! attributeName attr)) updateKeysIVec

181

191

182tupleToMap :: RelationTuple -> M.Map AttributeName Atom

192tupleToMap :: RelationTuple -> M.Map AttributeName Atom

183tupleToMap (RelationTuple attrs tupVec) = M.fromList assocList

193tupleToMap (RelationTuple attrs tupVec) = M.fromList assocList

184 where

194 where

185− assocList = V.toList $ V.map (\(index, attr) -> (attributeName attr, tupVec V.! index)) (V.indexed attrs)

195+ assocList = V.toList $ V.map (\(index, attr) -> (attributeName attr, tupVec V.! index)) (V.indexed (attributesVec attrs))

186

196

197+-- | Validate that the tuple has the correct attributes in the correct order

187verifyTuple :: Attributes -> RelationTuple -> Either RelationalError RelationTuple

198verifyTuple :: Attributes -> RelationTuple -> Either RelationalError RelationTuple

188−verifyTuple attrs tuple = let attrsTypes = V.map atomType attrs

199+verifyTuple attrs tuple = let attrsTypes = A.atomTypes attrs

189 tupleTypes = V.map atomTypeForAtom (tupleAtoms tuple) in

200 tupleTypes = V.map atomTypeForAtom (tupleAtoms tuple) in

190− if V.length attrs /= V.length tupleTypes then

201+ if A.arity attrs /= V.length tupleTypes then

191 Left $ TupleAttributeCountMismatchError 0

202 Left $ TupleAttributeCountMismatchError 0

192 else do

203 else do

193 mapM_ (uncurry atomTypeVerify) (V.zip attrsTypes tupleTypes)

204 mapM_ (uncurry atomTypeVerify) (V.zip attrsTypes tupleTypes)

@@ -196,15 +207,18 @@ verifyTuple attrs tuple = let attrsTypes = V.map atomType attrs

196--two tuples can be equal but the vectors of attributes could be out-of-order

207--two tuples can be equal but the vectors of attributes could be out-of-order

197--reorder if necessary- this is useful during relMogrify so that all the relation's tuples have identical atom/attribute ordering

208--reorder if necessary- this is useful during relMogrify so that all the relation's tuples have identical atom/attribute ordering

198reorderTuple :: Attributes -> RelationTuple -> RelationTuple

209reorderTuple :: Attributes -> RelationTuple -> RelationTuple

199−reorderTuple attrs tupIn = if tupleAttributes tupIn == attrs then

210+reorderTuple attrs tupIn = if attributesAndOrderEqual (tupleAttributes tupIn) attrs then

200 tupIn

211 tupIn

201 else

212 else

202− RelationTuple attrs (V.map mapper attrs)

213+ RelationTuple attrs (V.map mapper (attributesVec attrs))

203 where

214 where

204 mapper attr = case atomForAttributeName (attributeName attr) tupIn of

215 mapper attr = case atomForAttributeName (attributeName attr) tupIn of

205− Left err -> error ("logic bug in reorderTuple: " ++ show err)

216+ Left err -> error ("logic bug in reorderTuple: " ++ show err <> show tupIn)

206 Right atom -> atom

217 Right atom -> atom

207

218

208--used in Generics derivation for ADTs without named attributes

219--used in Generics derivation for ADTs without named attributes

209trimTuple :: Int -> RelationTuple -> RelationTuple

220trimTuple :: Int -> RelationTuple -> RelationTuple

210−trimTuple index (RelationTuple attrs vals) = RelationTuple (V.drop index attrs) (V.drop index vals)

221+trimTuple index (RelationTuple attrs vals) =

222+ RelationTuple newAttrs (V.drop index vals)

223+ where

224+ newAttrs = A.drop index attrs

src/lib/ProjectM36/TupleSet.hs+7

@@ -31,3 +31,10 @@ mkTupleSet attrs tuples = verifyTupleSet attrs (RelationTupleSet tuples)

31

32mkTupleSetFromList :: Attributes -> [[Atom]] -> Either RelationalError RelationTupleSet

33mkTupleSetFromList attrs atomMatrix = mkTupleSet attrs $ map (mkRelationTuple attrs . V.fromList) atomMatrix

34+

35+

36+-- | Union two tuplesets while reordering their attribute/atom mapping properly.

37+tupleSetUnion :: Attributes -> RelationTupleSet -> RelationTupleSet -> RelationTupleSet

38+tupleSetUnion targetAttrs tupSet1 tupSet2 = RelationTupleSet $ HS.toList . HS.fromList $ reorder (asList tupSet1) ++ reorder (asList tupSet2)

39+ where

40+ reorder = map (reorderTuple targetAttrs)

src/lib/ProjectM36/Tupleable.hs+113−36

@@ -4,28 +4,47 @@

4{-# LANGUAGE ScopedTypeVariables #-}

5{-# LANGUAGE TypeOperators #-}

6{-# LANGUAGE UndecidableInstances #-}

7−

7+{-# LANGUAGE CPP #-}

8+

8−module ProjectM36.Tupleable where

9+module ProjectM36.Tupleable

10+ ( toInsertExpr

11+ , toDefineExpr

12+ , tupleAssocsEqualityPredicate

13+ , partitionByAttributes

14+ , toUpdateExpr

15+ , toDeleteExpr

16+ , validateAttributes

17+ , Tupleable(..)

18+

19+ -- * Generics

20+ , genericToTuple

21+ , genericFromTuple

22+ , genericToAttributes

23+ , TupleableG(..)

24+ -- ** Options

25+ , defaultTupleableOptions

26+ , TupleableOptions()

27+ , fieldModifier

28+ ) where

9

29

10import Data.Foldable

30import Data.Foldable

11import Data.List (partition)

31import Data.List (partition)

12import qualified Data.Map as Map

32import qualified Data.Map as Map

33+#if __GLASGOW_HASKELL__ < 804

13−--import Data.Monoid

34+import Data.Monoid

35+#endif

14import Data.Proxy

36import Data.Proxy

15import qualified Data.Text as T

37import qualified Data.Text as T

16import qualified Data.Vector as V

38import qualified Data.Vector as V

17import GHC.Generics

39import GHC.Generics

18import ProjectM36.Atomable

40import ProjectM36.Atomable

19−import ProjectM36.Attribute hiding (null)

41+import ProjectM36.Attribute as A hiding (null, toList)

20import ProjectM36.Base

42import ProjectM36.Base

21import ProjectM36.DataTypes.Primitive

43import ProjectM36.DataTypes.Primitive

22import ProjectM36.Error

44import ProjectM36.Error

23import ProjectM36.Tuple

45import ProjectM36.Tuple

24import ProjectM36.TupleSet

46import ProjectM36.TupleSet

25import qualified Data.Set as S

47import qualified Data.Set as S

26−#if __GLASGOW_HASKELL__ <= 802

27−import Data.Monoid

28−#endif

29

48

30{-import Data.Binary

49{-import Data.Binary

31import Control.DeepSeq

50import Control.DeepSeq

@@ -70,7 +89,7 @@ toInsertExpr vals rvName = do

70

89

71-- | Convert a 'Tupleable' to a create a 'Define' expression which can be used to create an empty relation variable. Use 'toInsertExpr' to insert the actual tuple data. This function is typically used with 'Data.Proxy'.

90-- | Convert a 'Tupleable' to a create a 'Define' expression which can be used to create an empty relation variable. Use 'toInsertExpr' to insert the actual tuple data. This function is typically used with 'Data.Proxy'.

72toDefineExpr :: forall a proxy. Tupleable a => proxy a -> RelVarName -> DatabaseContextExpr

91toDefineExpr :: forall a proxy. Tupleable a => proxy a -> RelVarName -> DatabaseContextExpr

73−toDefineExpr _ rvName = Define rvName (map NakedAttributeExpr (V.toList attrs))

92+toDefineExpr _ rvName = Define rvName (map NakedAttributeExpr (V.toList (attributesVec attrs)))

74 where

93 where

75 attrs = toAttributes (Proxy :: Proxy a)

94 attrs = toAttributes (Proxy :: Proxy a)

76

95

@@ -121,56 +140,110 @@ validateAttributes actualAttrs expectedAttrs val

121 where

140 where

122 nonMatchingAttrs = attributeNamesNotContained actualAttrs expectedAttrs

141 nonMatchingAttrs = attributeNamesNotContained actualAttrs expectedAttrs

123

142

124−

143+-- | Types that can be converted to and from 'RelationTuple'.

144+--

145+-- deriving without customization:

146+--

147+-- > data Example = Example

148+-- > { foo :: Integer

149+-- > , bar :: Text

150+-- > }

151+-- > deriving (Generic)

152+-- >

153+-- > instance Tupleable Example

154+--

155+-- deriving with customization using "ProjectM36.Tupleable.Deriving":

156+--

157+-- > data Example = Example

158+-- > { exampleFoo :: Integer

159+-- > , exampleBar :: Text

160+-- > }

161+-- > deriving stock (Generic)

162+-- > deriving (Tupleable)

163+-- > via Codec (Field (DropPrefix "example" >>> CamelCase)) Example

125class Tupleable a where

164class Tupleable a where

126 toTuple :: a -> RelationTuple

165 toTuple :: a -> RelationTuple

127

166

128 fromTuple :: RelationTuple -> Either RelationalError a

167 fromTuple :: RelationTuple -> Either RelationalError a

129

168

130− toAttributes :: proxy a -> Attributes

169+ toAttributes :: Proxy a -> Attributes

131

170

132 default toTuple :: (Generic a, TupleableG (Rep a)) => a -> RelationTuple

171 default toTuple :: (Generic a, TupleableG (Rep a)) => a -> RelationTuple

133− toTuple v = toTupleG (from v)

172+ toTuple = genericToTuple defaultTupleableOptions

134

173

135 default fromTuple :: (Generic a, TupleableG (Rep a)) => RelationTuple -> Either RelationalError a

174 default fromTuple :: (Generic a, TupleableG (Rep a)) => RelationTuple -> Either RelationalError a

175+ fromTuple = genericFromTuple defaultTupleableOptions

176+

177+ default toAttributes :: (Generic a, TupleableG (Rep a)) => Proxy a -> Attributes

178+ toAttributes = genericToAttributes defaultTupleableOptions

179+

180+-- | Options that influence deriving behavior.

181+newtype TupleableOptions = TupleableOptions {

182+ -- | A function that translates record field names into attribute names.

183+ fieldModifier :: T.Text -> T.Text

184+ }

185+

186+-- | The default options for deriving Tupleable instances.

187+--

188+-- These options can be customized by using record update syntax. For example,

189+--

190+-- > defaultTupleableOptions

191+-- > { fieldModifier = \fieldName ->

192+-- > case Data.Text.stripPrefix "example" fieldName of

193+-- > Nothing -> fieldName

194+-- > Just attributeName -> attributeName

195+-- > }

196+--

197+-- will result in record field names being translated into attribute names by

198+-- removing the prefix "example" from the field names.

199+defaultTupleableOptions :: TupleableOptions

200+defaultTupleableOptions = TupleableOptions {

201+ fieldModifier = id

202+ }

203+

204+genericToTuple :: (Generic a, TupleableG (Rep a)) => TupleableOptions -> a -> RelationTuple

205+genericToTuple opts v = toTupleG opts (from v)

206+

207+genericFromTuple :: (Generic a, TupleableG (Rep a)) => TupleableOptions -> RelationTuple -> Either RelationalError a

136− fromTuple tup = to <$> fromTupleG tup

208+genericFromTuple opts tup = to <$> fromTupleG opts tup

137

209

138− default toAttributes :: (Generic a, TupleableG (Rep a)) => proxy a -> Attributes

210+genericToAttributes :: forall a. (Generic a, TupleableG (Rep a)) => TupleableOptions -> Proxy a -> Attributes

139− toAttributes _ = toAttributesG (from (undefined :: a))

211+genericToAttributes opts _ = toAttributesG opts (from (undefined :: a))

140

212

141class TupleableG g where

213class TupleableG g where

142− toTupleG :: g a -> RelationTuple

214+ toTupleG :: TupleableOptions -> g a -> RelationTuple

143− toAttributesG :: g a -> Attributes

215+ toAttributesG :: TupleableOptions -> g a -> Attributes

144− fromTupleG :: RelationTuple -> Either RelationalError (g a)

216+ fromTupleG :: TupleableOptions -> RelationTuple -> Either RelationalError (g a)

145 isRecordTypeG :: g a -> Bool

217 isRecordTypeG :: g a -> Bool

146

218

147--data type metadata

219--data type metadata

148instance (Datatype c, TupleableG a) => TupleableG (M1 D c a) where

220instance (Datatype c, TupleableG a) => TupleableG (M1 D c a) where

149− toTupleG (M1 v) = toTupleG v

221+ toTupleG opts (M1 v) = toTupleG opts v

150− toAttributesG (M1 v) = toAttributesG v

222+ toAttributesG opts (M1 v) = toAttributesG opts v

151− fromTupleG v = M1 <$> fromTupleG v

223+ fromTupleG opts v = M1 <$> fromTupleG opts v

152 isRecordTypeG (M1 v) = isRecordTypeG v

224 isRecordTypeG (M1 v) = isRecordTypeG v

153

225

154--constructor metadata

226--constructor metadata

155instance (Constructor c, TupleableG a, AtomableG a) => TupleableG (M1 C c a) where

227instance (Constructor c, TupleableG a, AtomableG a) => TupleableG (M1 C c a) where

156− toTupleG (M1 v) = RelationTuple attrs atoms

228+ toTupleG opts (M1 v) = RelationTuple attrs atoms

157 where

229 where

158− attrsToCheck = toAttributesG v

230+ attrsToCheck = toAttributesG opts v

159− counter = V.generate (V.length attrsToCheck) id

231+ counter = V.generate (arity attrsToCheck) id

232+ attrs = attributesFromList (V.toList attrsV)

160− attrs = V.zipWith (\num attr@(Attribute name typ) -> if T.null name then

233+ attrsV = V.zipWith (\num attr@(Attribute name typ) -> if T.null name then

161 Attribute ("attr" <> T.pack (show (num + 1))) typ

234 Attribute ("attr" <> T.pack (show (num + 1))) typ

162 else

235 else

163− attr) counter attrsToCheck

236+ attr) counter (attributesVec attrsToCheck)

164 atoms = V.fromList (toAtomsG v)

237 atoms = V.fromList (toAtomsG v)

165− toAttributesG (M1 v) = toAttributesG v

238+ toAttributesG opts (M1 v) = toAttributesG opts v

166− fromTupleG tup = M1 <$> fromTupleG tup

239+ fromTupleG opts tup = M1 <$> fromTupleG opts tup

167 isRecordTypeG (M1 v) = isRecordTypeG v

240 isRecordTypeG (M1 v) = isRecordTypeG v

168

241

169-- product types

242-- product types

170instance (TupleableG a, TupleableG b) => TupleableG (a :*: b) where

243instance (TupleableG a, TupleableG b) => TupleableG (a :*: b) where

171 toTupleG = error "toTupleG"

244 toTupleG = error "toTupleG"

172− toAttributesG ~(x :*: y) = toAttributesG x V.++ toAttributesG y --a bit of extra laziness prevents whnf so that we can use toAttributes (undefined :: Test2T Int Int) without throwing an exception

245+ toAttributesG opts ~(x :*: y) = toAttributesG opts x <> toAttributesG opts y --a bit of extra laziness prevents whnf so that we can use toAttributes (undefined :: Test2T Int Int) without throwing an exception

173− fromTupleG tup = (:*:) <$> fromTupleG tup <*> fromTupleG processedTuple

246+ fromTupleG opts tup = (:*:) <$> fromTupleG opts tup <*> fromTupleG opts processedTuple

174 where

247 where

175 processedTuple = if isRecordTypeG (undefined :: a x) then

248 processedTuple = if isRecordTypeG (undefined :: a x) then

176 tup

249 tup

@@ -181,18 +254,22 @@ instance (TupleableG a, TupleableG b) => TupleableG (a :*: b) where

181--selector/record

254--selector/record

182instance (Selector c, AtomableG a) => TupleableG (M1 S c a) where

255instance (Selector c, AtomableG a) => TupleableG (M1 S c a) where

183 toTupleG = error "toTupleG"

256 toTupleG = error "toTupleG"

184− toAttributesG m@(M1 v) = V.singleton (Attribute name aType)

257+ toAttributesG opts m@(M1 v) = A.singleton (Attribute modifiedName aType)

185 where

258 where

186 name = T.pack (selName m)

259 name = T.pack (selName m)

260+ modifiedName = if T.null name then

261+ name

262+ else

263+ fieldModifier opts name

187 aType = toAtomTypeG v

264 aType = toAtomTypeG v

188− fromTupleG tup = if null name then -- non-record type, just pull off the first tuple item

265+ fromTupleG opts tup = if null name then -- non-record type, just pull off the first tuple item

189 M1 <$> atomv (V.head (tupleAtoms tup))

266 M1 <$> atomv (V.head (tupleAtoms tup))

190 else do

267 else do

191− atom <- atomForAttributeName (T.pack name) tup

268+ atom <- atomForAttributeName (fieldModifier opts (T.pack name)) tup

192 val <- atomv atom

269 val <- atomv atom

193 pure (M1 val)

270 pure (M1 val)

194 where

271 where

195− expectedAtomType = atomType (V.head (toAttributesG (undefined :: M1 S c a x)))

272+ expectedAtomType = atomType (V.head (attributesVec (toAttributesG opts (undefined :: M1 S c a x))))

196 atomv atom = maybe (Left (AtomTypeMismatchError

273 atomv atom = maybe (Left (AtomTypeMismatchError

197 expectedAtomType

274 expectedAtomType

198 (atomTypeForAtom atom)

275 (atomTypeForAtom atom)

@@ -203,8 +280,8 @@ instance (Selector c, AtomableG a) => TupleableG (M1 S c a) where

203--constructors with no arguments

280--constructors with no arguments

204--basically useless but orthoganal to relationTrue

281--basically useless but orthoganal to relationTrue

205instance TupleableG U1 where

282instance TupleableG U1 where

206− toTupleG _= emptyTuple

283+ toTupleG _ _ = emptyTuple

207− toAttributesG _ = emptyAttributes

284+ toAttributesG _ _ = emptyAttributes

208− fromTupleG _ = pure U1

285+ fromTupleG _ _ = pure U1

209 isRecordTypeG _ = False

286 isRecordTypeG _ = False

210

287

src/lib/ProjectM36/Tupleable/Deriving.hsnew file+229

@@ -0,0 +1,229 @@

1+{-# LANGUAGE ScopedTypeVariables #-}

2+{-# LANGUAGE TypeOperators #-}

3+{-# LANGUAGE KindSignatures #-}

4+{-# LANGUAGE DataKinds #-}

5+{-# LANGUAGE FlexibleContexts #-}

6+{-# LANGUAGE UndecidableInstances #-}

7+

8+-- | Newtypes for deriving Tupleable instances with customization using

9+-- @DerivingVia@.

10+--

11+-- Inspired by

12+-- [Dhall.Deriving](https://hackage.haskell.org/package/dhall-1.33.1/docs/Dhall-Deriving.html)

13+-- which in turn was inspired by Matt Parson's blog post

14+-- [Mirror Mirror: Reflection and Encoding Via](https://www.parsonsmatt.org/2020/02/04/mirror_mirror.html).

15+--

16+-- required extensions:

17+--

18+-- * DerivingVia

19+-- * DeriveGenerics

20+-- * TypeOperators (for @('<<<')@ and @('>>>')@)

21+-- * DataKinds (for types that take a string argument)

22+

23+module ProjectM36.Tupleable.Deriving

24+ ( -- * DerivingVia Newtype

25+ Codec(..)

26+

27+ -- * Type-level Options

28+ , ModifyOptions(..)

29+ , Field

30+

31+ -- * Type-level 'T.Text' -> 'T.Text' Functions

32+ , ModifyText(..)

33+ , AddPrefix

34+ , DropPrefix

35+ , AddSuffix

36+ , DropSuffix

37+ , UpperCase

38+ , LowerCase

39+ , TitleCase

40+ , CamelCase

41+ , PascalCase

42+ , SnakeCase

43+ , SpinalCase

44+ , TrainCase

45+

46+ -- * Composition

47+ , AsIs

48+ , type (<<<)

49+ , type (>>>)

50+

51+ -- * Re-Exports

52+ , Generic

53+ , module ProjectM36.Tupleable

54+ ) where

55+import Data.Maybe (fromMaybe)

56+import Data.Proxy

57+import qualified Data.Text as T

58+import Data.Text.Manipulate

59+import GHC.TypeLits

60+import GHC.Generics (Generic, Rep)

61+import ProjectM36.Tupleable

62+

63+

64+-- | A newtype wrapper to allow for easier deriving of 'Tupleable' instances

65+-- with customization.

66+--

67+-- The @tag@ type variable can be used to specify options for converting the

68+-- datatype to and from a 'RelationTuple'. For example,

69+--

70+-- > data Example = Example

71+-- > { exampleFoo :: Int

72+-- > , exampleBar :: Int

73+-- > }

74+-- > deriving stock (Generic)

75+-- > deriving (Tupleable)

76+-- > via Codec (Field (DropPrefix "example" >>> CamelCase)) Example

77+--

78+-- will derive an instance of 'Tupleable' where field names are translated into

79+-- attribute names by dropping the prefix @"example"@ and then converting the

80+-- result to camelCase. So @"exampleFoo"@ becomes @"foo"@ and @"exampleBar"@

81+-- becomes @"bar"@.

82+--

83+-- Requires the @DerivingGeneric@ and @DerivingVia@ extensions to be enabled.

84+newtype Codec tag a = Codec { unCodec :: a }

85+

86+instance (ModifyOptions tag, Generic a, TupleableG (Rep a)) => Tupleable (Codec tag a) where

87+ toTuple v = genericToTuple opts (unCodec v)

88+ where

89+ opts = modifyOptions (Proxy :: Proxy tag) defaultTupleableOptions

90+

91+ fromTuple tup = Codec <$> genericFromTuple opts tup

92+ where

93+ opts = modifyOptions (Proxy :: Proxy tag) defaultTupleableOptions

94+

95+ toAttributes _ = genericToAttributes opts (Proxy :: Proxy a)

96+ where

97+ opts = modifyOptions (Proxy :: Proxy tag) defaultTupleableOptions

98+

99+-- | Types that can be used as tags for 'Codec'.

100+class ModifyOptions a where

101+ modifyOptions :: proxy a -> TupleableOptions -> TupleableOptions

102+

103+-- | Change how record field names are translated into attribute names. For

104+-- example,

105+--

106+-- > Field SnakeCase

107+--

108+-- will translate the field name @fooBar@ into the attribute name @foo_bar@.

109+data Field a

110+

111+instance ModifyText a => ModifyOptions (Field a) where

112+ modifyOptions _ opts = opts { fieldModifier = newFieldModifier }

113+ where

114+ newFieldModifier = modifyText (Proxy :: Proxy a) . fieldModifier opts

115+

116+-- | Types that can be used in options that modify 'T.Text' such as in 'Field'.

117+class ModifyText a where

118+ modifyText :: proxy a -> T.Text -> T.Text

119+

120+-- | Add a prefix. @AddPrefix "foo"@ will transform @"bar"@ into @"foobar"@.

121+data AddPrefix (prefix :: Symbol)

122+

123+instance KnownSymbol prefix => ModifyText (AddPrefix prefix) where

124+ modifyText _ oldText = prefixText <> oldText

125+ where

126+ prefixText = T.pack (symbolVal (Proxy :: Proxy prefix))

127+

128+-- | Drop a prefix. @DropPrefix "bar"@ will transform @"foobar"@ into @"foo"@.

129+data DropPrefix (prefix :: Symbol)

130+

131+instance KnownSymbol prefix => ModifyText (DropPrefix prefix) where

132+ modifyText _ oldText = fromMaybe oldText (T.stripPrefix prefixText oldText)

133+ where

134+ prefixText = T.pack (symbolVal (Proxy :: Proxy prefix))

135+

136+-- | Add a suffix. @AddSuffix "bar"@ will transform @"foo"@ into @"foobar"@.

137+data AddSuffix (suffix :: Symbol)

138+

139+instance KnownSymbol suffix => ModifyText (AddSuffix suffix) where

140+ modifyText _ oldText = oldText <> suffixText

141+ where

142+ suffixText = T.pack (symbolVal (Proxy :: Proxy suffix))

143+

144+-- | Drop a suffix. @DropSuffix "bar"@ will transform @"foobar"@ into @"foo"@.

145+data DropSuffix (suffix :: Symbol)

146+

147+instance KnownSymbol suffix => ModifyText (DropSuffix suffix) where

148+ modifyText _ oldText = fromMaybe oldText (T.stripSuffix suffixText oldText)

149+ where

150+ suffixText = T.pack (symbolVal (Proxy :: Proxy suffix))

151+

152+-- | Convert to UPPERCASE. Will transform @"foobar"@ into @\"FOOBAR\"@.

153+data UpperCase

154+

155+instance ModifyText UpperCase where

156+ modifyText _ = T.toUpper

157+

158+-- | Convert to lowercase. Will transform @\"FOOBAR\"@ into @"foobar"@.

159+data LowerCase

160+

161+instance ModifyText LowerCase where

162+ modifyText _ = T.toLower

163+

164+-- | Convert to Title Case. Will transform @"fooBar"@ into @\"Foo Bar\"@.

165+data TitleCase

166+

167+instance ModifyText TitleCase where

168+ modifyText _ = toTitle

169+

170+-- | Convert to camelCase. Will transform @"foo_bar"@ into @"fooBar"@.

171+data CamelCase

172+

173+instance ModifyText CamelCase where

174+ modifyText _ = toCamel

175+

176+-- | Convert to PascalCase. Will transform @"foo_bar"@ into @\"FooBar\"@.

177+data PascalCase

178+

179+instance ModifyText PascalCase where

180+ modifyText _ = toPascal

181+

182+-- | Convert to snake_case. Will transform @"fooBar"@ into @"foo_bar"@.

183+data SnakeCase

184+

185+instance ModifyText SnakeCase where

186+ modifyText _ = toSnake

187+

188+-- | Convert to spinal-case. will transform @"fooBar"@ into @"foo-bar"@.

189+data SpinalCase

190+

191+instance ModifyText SpinalCase where

192+ modifyText _ = toSpinal

193+

194+-- | Convert to Train-Case. Will transform @"fooBar"@ into @\"Foo-Bar\"@.

195+data TrainCase

196+

197+instance ModifyText TrainCase where

198+ modifyText _ = toTrain

199+

200+-- | Identity option.

201+type AsIs = ()

202+

203+instance ModifyOptions () where

204+ modifyOptions _ = id

205+

206+instance ModifyText () where

207+ modifyText _ = id

208+

209+-- | Right to left composition.

210+--

211+-- Requires the @TypeOperators@ extension to be enabled.

212+data a <<< b

213+

214+instance (ModifyOptions a, ModifyOptions b) => ModifyOptions (a <<< b) where

215+ modifyOptions _ = modifyOptions (Proxy :: Proxy a) . modifyOptions (Proxy :: Proxy b)

216+

217+instance (ModifyText a, ModifyText b) => ModifyText (a <<< b) where

218+ modifyText _ = modifyText (Proxy :: Proxy a) . modifyText (Proxy :: Proxy b)

219+

220+-- | Left to right composition.

221+--

222+-- Requires the @TypeOperators@ extension to be enabled.

223+data a >>> b

224+

225+instance (ModifyOptions a, ModifyOptions b) => ModifyOptions (a >>> b) where

226+ modifyOptions _ = modifyOptions (Proxy :: Proxy b) . modifyOptions (Proxy :: Proxy a)

227+

228+instance (ModifyText a, ModifyText b) => ModifyText (a >>> b) where

229+ modifyText _ = modifyText (Proxy :: Proxy b) . modifyText (Proxy :: Proxy a)

src/lib/ProjectM36/WithNameExpr.hs+5−3

@@ -17,7 +17,7 @@ substituteWithNameMacros macros e@(RelationVariable rvname tid) =

17 macroFilt (WithNameExpr macroName macroTid, _) = rvname == macroName && tid== macroTid in

18 case filter macroFilt macros of

19 [] -> e

20− (_,replacement):[] -> replacement

20+ [(_,replacement)] -> replacement

21 _ -> error "more than one macro matched!"

22substituteWithNameMacros macros (Project attrs expr) =

23 Project attrs (substituteWithNameMacros macros expr)

@@ -42,9 +42,11 @@ substituteWithNameMacros macros (NotEquals exprA exprB) =

42substituteWithNameMacros macros (Extend extendTup expr) =

43 Extend (substituteWitNameMacrosExtendTupleExpr macros extendTup) (substituteWithNameMacros macros expr)

44substituteWithNameMacros macros (With moreMacros expr) =

45− --collect and override existing macros and recurse

45+ --collect and update nested with exprs

46 let newMacros = foldr macroFolder macros moreMacros

47− macroFolder (wnexpr, mexpr) acc = filter (\(w,_) -> w /= wnexpr) acc ++ [(wnexpr, mexpr)] in

47+ macroFolder (wnexpr, mexpr) acc =

48+ let subExpr = substituteWithNameMacros macros mexpr in

49+ filter (\(w,_) -> w /= wnexpr) acc ++ [(wnexpr, subExpr)] in

48 --scan for a match- if it exists, replace it (representing a with clause at a lower level

50 --scan for a match- if it exists, replace it (representing a with clause at a lower level

49 substituteWithNameMacros newMacros expr

51 substituteWithNameMacros newMacros expr

50

52

stack.ghc8.0.yamldeleted−50

@@ -1,50 +0,0 @@

1−# This file was automatically generated by stack init

2−# For more information, see: http://docs.haskellstack.org/en/stable/yaml_configuration/

3−

4−# Specifies the GHC version and set of packages available (e.g., lts-3.5, nightly-2015-09-21, ghc-7.10.2)

5−resolver: lts-8.5

6−

7−# Local packages, usually specified by relative directory name

8−packages:

9−- '.'

10−# Packages to be pulled from upstream that are not in the resolver (e.g., acme-missiles-0.3)

11−extra-deps:

12−- data-accessor-transformers-0.2.1.7

13−- data-interval-1.2.0

14−- extended-reals-0.2.1.0

15−- gnuplot-0.5.4.1

16−- text-1.2.2.1

17−- aeson-1.2.1.00

18−- distributed-process-0.6.6

19−- distributed-process-async-0.2.4

20−- distributed-process-client-server-0.2.3

21−- distributed-process-extras-0.3.2

22−- deferred-folds-0.6.12

23−- rset-1.0.0

24−

25−# Override default flag values for local packages and extra-deps

26−flags: {}

27−

28−# Extra package databases containing global packages

29−extra-package-dbs: []

30−

31−# Control whether we use the GHC we find on the path

32−# system-ghc: true

33−

34−# Require a specific version of stack, using version ranges

35−# require-stack-version: -any # Default

36−# require-stack-version: >= 1.0.0

37−

38−# Override the architecture used by stack, especially useful on Windows

39−# arch: i386

40−# arch: x86_64

41−

42−# Extra directories used by stack for building

43−# extra-include-dirs: [/path/to/dir]

44−# extra-lib-dirs: [/path/to/dir]

45−

46−# Allow a newer minor version of GHC than the snapshot specifies

47−# compiler-check: newer-minor

48−

49−allow-newer: true

50−

stack.ghc8.10.yamlnew file+19

@@ -0,0 +1,19 @@

1+resolver: lts-17.13

2+packages:

3+ - "."

4+

5+extra-deps:

6+ - git: https://github.com/agentm/curryer.git

7+ commit: 74ecaac619ad1165a4517d5c0f4e530493bda130

8+ - git: https://github.com/composewell/streamly.git

9+ commit: ac3af8749194f1788704dda8667d0b3807075cc2

10+ - fast-builder-0.1.2.1

11+ - rset-1.0.0

12+ - winery-1.3.2

13+ - barbies-th-0.1.8

14+ - base16-bytestring-1.0.1.0

15+

16+flags:

17+ project-m36:

18+ stack: true

19+# allow-newer: true

stack.ghc8.4.yaml → stack.ghc8.6.yamlrenamed+26−17

@@ -2,29 +2,39 @@

2# For more information, see: http://docs.haskellstack.org/en/stable/yaml_configuration/

3

4# Specifies the GHC version and set of packages available (e.g., lts-3.5, nightly-2015-09-21, ghc-7.10.2)

5−resolver: lts-12.11

5+resolver: lts-14.27

6

7# Local packages, usually specified by relative directory name

8packages:

9−- '.'

9+ - "."

10# Packages to be pulled from upstream that are not in the resolver (e.g., acme-missiles-0.3)

11extra-deps:

12−- data-accessor-transformers-0.2.1.7

12+ - git: https://github.com/agentm/curryer.git

13−- data-interval-1.2.0

13+ commit: 74ecaac619ad1165a4517d5c0f4e530493bda130

14+ - git: https://github.com/composewell/streamly.git

15+ commit: ac3af8749194f1788704dda8667d0b3807075cc2

16+ - fast-builder-0.1.2.1

17+ - winery-1.3.2

18+ - barbies-2.0.2.0

19+ - barbies-th-0.1.7

14−- extended-reals-0.2.1.0

20+ - extended-reals-0.2.3.0

15−- gnuplot-0.5.5.3

21+ - data-interval-2.0.1

16−- aeson-1.2.1.00

22+ - stm-containers-1.1.0.4

17−- distributed-process-0.7.4

23+ - stm-hamt-1.2.0.4

18−- distributed-process-async-0.2.4.1

19−- distributed-process-client-server-0.2.3

20−- distributed-process-extras-0.3.2

21−#- deferred-folds-0.9.7.1

22−- rset-1.0.0

24+ - rset-1.0.0

23−- hashable-time-0.2.0.2

25+ - hashable-time-0.2.0.2

24−- network-transport-tcp-0.6.0

26+ - network-transport-tcp-0.6.0

27+ - megaparsec-7.0.5

28+ - prettyprinter-1.7.0

29+ - prettyprinter-ansi-terminal-1.1.2

30+ - fusion-plugin-types-0.1.0

31+ - base16-bytestring-1.0.1.0

32+ - modern-uri-0.3.4.0

33+ - cryptohash-sha256-0.11.102.0

34+ - http-types-0.12.3

25

35

26# Override default flag values for local packages and extra-deps

36# Override default flag values for local packages and extra-deps

27−flags:

37+flags:

28 project-m36:

38 project-m36:

29 stack: true

39 stack: true

30

40

@@ -50,4 +60,3 @@ extra-package-dbs: []

50# compiler-check: newer-minor

60# compiler-check: newer-minor

51

61

52allow-newer: true

62allow-newer: true

53−

stack.ghc8.2.yaml → stack.ghc8.8.yamlrenamed+26−15

@@ -2,27 +2,39 @@

2# For more information, see: http://docs.haskellstack.org/en/stable/yaml_configuration/

3

4# Specifies the GHC version and set of packages available (e.g., lts-3.5, nightly-2015-09-21, ghc-7.10.2)

5−resolver: lts-11.20

5+resolver: lts-16.4

6

7# Local packages, usually specified by relative directory name

8packages:

9−- '.'

9+ - "."

10# Packages to be pulled from upstream that are not in the resolver (e.g., acme-missiles-0.3)

11extra-deps:

12−- data-accessor-transformers-0.2.1.7

12+ - git: https://github.com/agentm/curryer.git

13−- data-interval-1.2.0

13+ commit: 74ecaac619ad1165a4517d5c0f4e530493bda130

14+ - git: https://github.com/composewell/streamly.git

15+ commit: ac3af8749194f1788704dda8667d0b3807075cc2

16+ - fast-builder-0.1.2.1

17+ - winery-1.3.2

18+ - barbies-2.0.2.0

19+ - barbies-th-0.1.7

14−- extended-reals-0.2.1.0

20+ - extended-reals-0.2.3.0

15−- gnuplot-0.5.4.1

21+ - data-interval-2.0.1

16−- text-1.2.2.1

22+ - stm-containers-1.1.0.4

17−- aeson-1.2.1.00

23+ - stm-hamt-1.2.0.4

18−- distributed-process-0.7.3

24+ - rset-1.0.0

19−- distributed-process-async-0.2.4.1

25+ - hashable-time-0.2.0.2

20−- distributed-process-client-server-0.2.3

26+ - network-transport-tcp-0.7.0

21−- distributed-process-extras-0.3.2

27+ - megaparsec-7.0.5

22−- rset-1.0.0

28+ - network-2.8.0.1

29+ - primitive-extras-0.8

30+ - primitive-unlifted-0.1.3.0

31+ - prettyprinter-1.7.0

32+ - prettyprinter-ansi-terminal-1.1.2

33+ - base16-bytestring-1.0.1.0

34+ - modern-uri-0.3.4.0

23

35

24# Override default flag values for local packages and extra-deps

36# Override default flag values for local packages and extra-deps

25−flags:

37+flags:

26 project-m36:

38 project-m36:

27 stack: true

39 stack: true

28

40

@@ -48,4 +60,3 @@ extra-package-dbs: []

48# compiler-check: newer-minor

60# compiler-check: newer-minor

49

61

50allow-newer: true

62allow-newer: true

51−

test/Client/Simple.hs+1−2

@@ -9,7 +9,6 @@ import System.IO.Temp

9import System.FilePath

10import ProjectM36.TupleSet

11import ProjectM36.Attribute

12−import qualified Data.Vector as V

13import qualified Data.Map as M

12import qualified Data.Map as M

14

13

15main :: IO ()

14main :: IO ()

@@ -59,7 +58,7 @@ testSimpleCommitFailure = TestCase $ do

59 execute $ Assign "x" (ExistingRelation relationTrue)

58 execute $ Assign "x" (ExistingRelation relationTrue)

60 --cause error

59 --cause error

61 execute $ Assign "x" (MakeStaticRelation failAttrs emptyTupleSet)

60 execute $ Assign "x" (MakeStaticRelation failAttrs emptyTupleSet)

62− let expectedErr = Left (RelError (RelationTypeMismatchError V.empty failAttrs))

61+ let expectedErr = Left (RelError (RelationTypeMismatchError mempty failAttrs))

63 assertEqual "dbc error" expectedErr err

62 assertEqual "dbc error" expectedErr err

64

63

65-- #176 default merge couldn't handle Update

64-- #176 default merge couldn't handle Update

test/IsomorphicSchema.hs+37−27

@@ -4,13 +4,13 @@ import ProjectM36.Error

4import ProjectM36.IsomorphicSchema

5import ProjectM36.Relation

6import ProjectM36.RelationalExpression

7+import ProjectM36.TransactionGraph

8+import ProjectM36.StaticOptimizer

7import qualified ProjectM36.DatabaseContext as DBC

9import qualified ProjectM36.DatabaseContext as DBC

8import qualified ProjectM36.Attribute as A

10import qualified ProjectM36.Attribute as A

9import System.Exit

11import System.Exit

10import qualified Data.Map as M

12import qualified Data.Map as M

11import qualified Data.Set as S

13import qualified Data.Set as S

12−import Control.Monad.State

13−import Control.Monad.Trans.Reader

14

15testList :: Test

16testList = TestList [testIsoRename, testIsoRestrict, testIsoUnion, testSchemaValidation]

@@ -36,7 +36,7 @@ assertMaybe x msg = case x of

36testSchemaValidation :: Test

37testSchemaValidation = TestCase $ do

38 let potentialSchema = DBC.basicDatabaseContext {

39− relationVariables = M.singleton "anotherRel" relationTrue

39+ relationVariables = M.singleton "anotherRel" (ExistingRelation relationTrue)

40 }

41 -- missing relvars failure

42 morphs = [IsoRename "true" "true", IsoRename "false" "false"]

@@ -50,15 +50,17 @@ testSchemaValidation = TestCase $ do

50testIsoRename :: Test

51testIsoRename = TestCase $ do

52 -- create a schema with two relvars and rename one while the other remains the same in the isomorphic schema

53− let schemaA = mkRelationalExprState DBC.empty {

53+ let ctx = DBC.empty {

54− relationVariables = M.fromList [("employee", relationTrue),

54+ relationVariables = M.fromList [("employee", ExistingRelation relationTrue),

55− ("department", relationFalse)]

55+ ("department", ExistingRelation relationFalse)]

56 }

57+ (graph, _) <- freshTransactionGraph ctx

57− isomorphsAtoB = [IsoRename "emp" "employee",

58+ let isomorphsAtoB = [IsoRename "emp" "employee",

58 IsoRename "department" "department"]

59 IsoRename "department" "department"]

59− unionExpr = Union (RelationVariable "emp" ()) (RelationVariable "department" ())

60+ unionExpr = Union (RelationVariable "emp" ()) (RelationVariable "department" ())

61+ env = mkRelationalExprEnv ctx graph

60 relExpr <- assertEither (applyRelationalExprSchemaIsomorphs isomorphsAtoB unionExpr)

62 relExpr <- assertEither (applyRelationalExprSchemaIsomorphs isomorphsAtoB unionExpr)

61− let relResult = runReader (evalRelationalExpr relExpr) schemaA

63+ let relResult = optimizeAndEvalRelationalExpr env relExpr

62 assertEqual "employee relation morph" (Right relationTrue) relResult

64 assertEqual "employee relation morph" (Right relationTrue) relResult

63

65

64testIsoRestrict :: Test

66testIsoRestrict :: Test

@@ -67,62 +69,70 @@ testIsoRestrict = TestCase $ do

67 -- the virtual schema has an employee

69 -- the virtual schema has an employee

68 let empattrs = A.attributesFromList [Attribute "name" TextAtomType,

70 let empattrs = A.attributesFromList [Attribute "name" TextAtomType,

69 Attribute "boss" TextAtomType]

71 Attribute "boss" TextAtomType]

72+ (graph, transId) <- freshTransactionGraph DBC.empty

70 emprel <- assertEither $ mkRelationFromList empattrs

73 emprel <- assertEither $ mkRelationFromList empattrs

71 [[TextAtom "Steve", TextAtom ""],

74 [[TextAtom "Steve", TextAtom ""],

72 [TextAtom "Cindy", TextAtom "Steve"],

75 [TextAtom "Cindy", TextAtom "Steve"],

73 [TextAtom "Sam", TextAtom "Steve"]]

76 [TextAtom "Sam", TextAtom "Steve"]]

74 let predicate = AttributeEqualityPredicate "boss" (NakedAtomExpr (TextAtom ""))

77 let predicate = AttributeEqualityPredicate "boss" (NakedAtomExpr (TextAtom ""))

78+ reenv = mkRelationalExprEnv DBC.empty graph

75− bossRel <- assertEither $ runReader (evalRelationalExpr (Restrict predicate (ExistingRelation emprel))) (mkRelationalExprState DBC.empty)

79+ bossRel <- assertEither $ runRelationalExprM reenv (evalRelationalExpr (Restrict predicate (ExistingRelation emprel)))

76− nonBossRel <- assertEither $ runReader (evalRelationalExpr (Restrict (NotPredicate predicate) (ExistingRelation emprel))) (mkRelationalExprState DBC.empty)

80+ nonBossRel <- assertEither $ runRelationalExprM reenv (evalRelationalExpr (Restrict (NotPredicate predicate) (ExistingRelation emprel)))

77

81

78− let schemaA = mkRelationalExprState DBC.empty {

82+ let schemaA = mkRelationalExprEnv baseContext graph

83+ baseContext = DBC.empty {

79− relationVariables = M.fromList [("nonboss", nonBossRel),

84+ relationVariables = M.fromList [("nonboss", ExistingRelation nonBossRel),

80− ("boss", bossRel)]

85+ ("boss", ExistingRelation bossRel)]

81 }

86 }

82−

83 isomorphsAtoB = [IsoRestrict "employee" predicate ("boss", "nonboss")]

87 isomorphsAtoB = [IsoRestrict "employee" predicate ("boss", "nonboss")]

84 bossq = RelationVariable "boss" ()

88 bossq = RelationVariable "boss" ()

85 nonbossq = RelationVariable "nonboss" ()

89 nonbossq = RelationVariable "nonboss" ()

86 employeeq = RelationVariable "employee" ()

90 employeeq = RelationVariable "employee" ()

87 unionq = Union bossq nonbossq

91 unionq = Union bossq nonbossq

88 empExpr <- assertEither (applyRelationalExprSchemaIsomorphs isomorphsAtoB employeeq)

92 empExpr <- assertEither (applyRelationalExprSchemaIsomorphs isomorphsAtoB employeeq)

89− let empResult = runReader (evalRelationalExpr empExpr) schemaA

93+ let empResult = evalRelExpr (evalRelationalExpr empExpr)

90− unionResult = runReader (evalRelationalExpr unionq) schemaA

94+ unionResult = evalRelExpr (evalRelationalExpr unionq)

95+ evalRelExpr = runRelationalExprM schemaA

91 assertEqual "boss/nonboss isorestrict" unionResult empResult

96 assertEqual "boss/nonboss isorestrict" unionResult empResult

92 --execute database context expr

97 --execute database context expr

93 bobRel <- assertEither (mkRelationFromList empattrs [[TextAtom "Bob", TextAtom ""]])

98 bobRel <- assertEither (mkRelationFromList empattrs [[TextAtom "Bob", TextAtom ""]])

94 let schemaBInsertExpr = Insert "employee" (ExistingRelation bobRel)

99 let schemaBInsertExpr = Insert "employee" (ExistingRelation bobRel)

95 schemaBInsertExpr' <- assertEither (processDatabaseContextExprInSchema (Schema isomorphsAtoB) schemaBInsertExpr)

100 schemaBInsertExpr' <- assertEither (processDatabaseContextExprInSchema (Schema isomorphsAtoB) schemaBInsertExpr)

96− let (postInsertContext,_,_) = execState (evalDatabaseContextExpr schemaBInsertExpr') (freshDatabaseState (stateElemsContext schemaA))

101+ let Right dbcState = evalDBCExpr schemaBInsertExpr'

102+ postInsertContext = dbc_context dbcState

103+ evalDBCExpr expr' = runDatabaseContextEvalMonad baseContext dbcenv (optimizeAndEvalDatabaseContextExpr False expr')

104+ dbcenv = mkDatabaseContextEvalEnv transId graph

97− expectedRel = runReader (evalRelationalExpr (Union (RelationVariable "boss" ()) (RelationVariable "nonboss" ()))) (mkRelationalExprState postInsertContext)

105+ expectedRel = runRelationalExprM postInsertEnv (evalRelationalExpr (Union (RelationVariable "boss" ()) (RelationVariable "nonboss" ())))

106+ postInsertEnv = mkRelationalExprEnv postInsertContext graph

98 --execute the expression against the schema and compare against the base context

107 --execute the expression against the schema and compare against the base context

99 processedExpr <- assertEither (processRelationalExprInSchema (Schema isomorphsAtoB) (RelationVariable "employee" ()))

108 processedExpr <- assertEither (processRelationalExprInSchema (Schema isomorphsAtoB) (RelationVariable "employee" ()))

100− let processedRel = runReader (evalRelationalExpr processedExpr) (mkRelationalExprState postInsertContext)

109+ let processedRel = runRelationalExprM postInsertEnv (evalRelationalExpr processedExpr)

101 assertEqual "insert bob boss" expectedRel processedRel

110 assertEqual "insert bob boss" expectedRel processedRel

102

111

103testIsoUnion :: Test

112testIsoUnion :: Test

104testIsoUnion = TestCase $ do

113testIsoUnion = TestCase $ do

105 --create motors relation which is split into low-power (<50 horsepower) and high-power (>=50 horsepower) motors

114 --create motors relation which is split into low-power (<50 horsepower) and high-power (>=50 horsepower) motors

106 --the schema is contains the split relvars

115 --the schema is contains the split relvars

116+ (graph, _) <- freshTransactionGraph DBC.empty

107 motorsRel <- assertEither $ mkRelationFromList (A.attributesFromList [Attribute "name" TextAtomType,

117 motorsRel <- assertEither $ mkRelationFromList (A.attributesFromList [Attribute "name" TextAtomType,

108 Attribute "power" IntegerAtomType])

118 Attribute "power" IntegerAtomType])

109 [[TextAtom "Puny", IntegerAtom 10],

119 [[TextAtom "Puny", IntegerAtom 10],

110 [TextAtom "Scooter", IntegerAtom 49],

120 [TextAtom "Scooter", IntegerAtom 49],

111 [TextAtom "Auto", IntegerAtom 200],

121 [TextAtom "Auto", IntegerAtom 200],

112 [TextAtom "Tractor", IntegerAtom 500]]

122 [TextAtom "Tractor", IntegerAtom 500]]

113− let baseSchema = mkRelationalExprState DBC.basicDatabaseContext {

123+ let env = mkRelationalExprEnv DBC.basicDatabaseContext {

114− relationVariables = M.singleton "motor" motorsRel

124+ relationVariables = M.singleton "motor" (ExistingRelation motorsRel)

115− }

125+ } graph

116 splitPredicate = AtomExprPredicate (FunctionAtomExpr "lt" [AttributeAtomExpr "power", NakedAtomExpr (IntegerAtom 50)] ())

126 splitPredicate = AtomExprPredicate (FunctionAtomExpr "lt" [AttributeAtomExpr "power", NakedAtomExpr (IntegerAtom 50)] ())

117 splitIsomorphs = [IsoUnion ("lowpower", "highpower") splitPredicate "motor",

127 splitIsomorphs = [IsoUnion ("lowpower", "highpower") splitPredicate "motor",

118 IsoRename "true" "true",

128 IsoRename "true" "true",

119 IsoRename "false" "false"]

129 IsoRename "false" "false"]

120− lowmotors = runReader (evalRelationalExpr (Restrict splitPredicate (RelationVariable "motor" ()))) baseSchema

130+ lowmotors = runRelationalExprM env (evalRelationalExpr (Restrict splitPredicate (RelationVariable "motor" ())))

121− highmotors = runReader (evalRelationalExpr (Restrict (NotPredicate splitPredicate) (RelationVariable "motor" ()))) baseSchema

131+ highmotors = runRelationalExprM env (evalRelationalExpr (Restrict (NotPredicate splitPredicate) (RelationVariable "motor" ())))

122− relResult expr = runReader (evalRelationalExpr expr) baseSchema

132+ relResult expr = runRelationalExprM env (evalRelationalExpr expr)

123 lowpowerExpr <- assertEither (processRelationalExprInSchema (Schema splitIsomorphs) (RelationVariable "lowpower" ()))

133 lowpowerExpr <- assertEither (processRelationalExprInSchema (Schema splitIsomorphs) (RelationVariable "lowpower" ()))

124 lowpowerRel <- assertEither (relResult lowpowerExpr)

134 lowpowerRel <- assertEither (relResult lowpowerExpr)

125 highpowerExpr <- assertEither (processRelationalExprInSchema (Schema splitIsomorphs) (RelationVariable "highpower" ()))

135 highpowerExpr <- assertEither (processRelationalExprInSchema (Schema splitIsomorphs) (RelationVariable "highpower" ()))

126 highpowerRel <- assertEither (relResult highpowerExpr)

136 highpowerRel <- assertEither (relResult highpowerExpr)

127 assertEqual "lowpower relation difference" (Right lowpowerRel) lowmotors

137 assertEqual "lowpower relation difference" (Right lowpowerRel) lowmotors

128− assertEqual "highpower relation difference" (Right highpowerRel) highmotors

138+ assertEqual "highpower relation difference" (Right highpowerRel) highmotors

test/Relation/Atomable.hs+52−20

@@ -1,8 +1,7 @@

1--Test Atomable typeclass which allows users to use existing Haskell datatypes to marshal them to and from the database as ConstructedAtoms.

2−{-# LANGUAGE DeriveGeneric, DeriveAnyClass, OverloadedStrings #-}

2+{-# LANGUAGE DeriveGeneric, DeriveAnyClass, OverloadedStrings, TypeApplications, DerivingVia #-}

3import Test.HUnit

4import ProjectM36.Client

5−import Data.Binary

6import Control.DeepSeq

5import Control.DeepSeq

7import System.Exit

6import System.Exit

8import TutorialD.Interpreter.TestBase

7import TutorialD.Interpreter.TestBase

@@ -13,47 +12,65 @@ import Data.Time.Calendar (fromGregorian)

13import Data.Text

12import Data.Text

14import qualified Data.Map as M

13import qualified Data.Map as M

15import Data.Proxy

14import Data.Proxy

15+import Codec.Winery

16

17{-# ANN module ("Hlint: ignore Use newtype instead of data" :: String) #-}

18data Test1T = Test1C Integer

19− deriving (Generic, Show, Eq, Binary, NFData, Atomable)

19+ deriving (Generic, Show, Eq, NFData, Atomable)

20+ deriving Serialise via WineryVariant Test1T

20

21

21data Test2T x = Test2C x

22data Test2T x = Test2C x

22− deriving (Show, Generic, Eq, Binary, NFData, Atomable)

23+ deriving (Show, Generic, Eq, NFData, Atomable)

24+ deriving Serialise via WineryVariant (Test2T x)

23

25

24data Test3T = Test3C Integer Integer

26data Test3T = Test3C Integer Integer

25− deriving (Show, Generic, Eq, Binary, NFData, Atomable)

27+ deriving (Show, Generic, Eq, NFData, Atomable)

28+ deriving Serialise via WineryVariant Test3T

26

29

27data Test4T = Test4Ca Integer |

30data Test4T = Test4Ca Integer |

28 Test4Cb Integer

31 Test4Cb Integer

29− deriving (Show, Generic, Eq, Binary, NFData, Atomable)

32+ deriving (Show, Generic, Eq, NFData, Atomable)

33+ deriving Serialise via WineryVariant Test4T

30

34

31data TestListT = TestListC [Integer]

35data TestListT = TestListC [Integer]

32− deriving (Show, Generic, Eq, Binary, NFData, Atomable)

36+ deriving (Show, Generic, Eq, NFData, Atomable)

37+ deriving Serialise via WineryVariant TestListT

33

38

34data TestNonEmptyT = TestNonEmptyC [Integer]

39data TestNonEmptyT = TestNonEmptyC [Integer]

35− deriving (Show, Generic, Eq, Binary, NFData, Atomable)

40+ deriving (Show, Generic, Eq, NFData, Atomable)

41+ deriving Serialise via WineryVariant TestNonEmptyT

36

42

37data Test5T = Test5C {

43data Test5T = Test5C {

38 con1 :: Integer,

44 con1 :: Integer,

39 con2 :: Integer

45 con2 :: Integer

40− } deriving (Show, Generic, Eq, Binary, NFData, Atomable)

46+ } deriving (Show, Generic, Eq, NFData, Atomable)

47+ deriving Serialise via WineryRecord Test5T

41

48

42data Test6T = Test6C (Maybe Integer)

49data Test6T = Test6C (Maybe Integer)

43− deriving (Show, Generic, Eq, Binary, NFData, Atomable)

50+ deriving (Show, Generic, Eq, NFData, Atomable)

51+ deriving Serialise via WineryVariant Test6T

44

52

45data Test7T = Test7C (Either Integer Integer)

53data Test7T = Test7C (Either Integer Integer)

46− deriving (Show, Generic, Eq, Binary, NFData, Atomable)

54+ deriving (Show, Generic, Eq, NFData, Atomable)

55+ deriving Serialise via WineryVariant Test7T

47

56

48data Test8T = Test8C Test1T

57data Test8T = Test8C Test1T

49− deriving (Show, Generic, Eq, Binary, NFData, Atomable)

58+ deriving (Show, Generic, Eq, NFData, Atomable)

59+ deriving Serialise via WineryVariant Test8T

60+

61+data User = User

62+ { userFirstName :: Text

63+ , userLastName :: Text

64+ } deriving (Eq, Ord, Show, Generic, NFData, Atomable)

65+ deriving Serialise via WineryRecord User

50

66

51data Test9_4T = Test9_4C {

67data Test9_4T = Test9_4C {

52 f9_41 :: Int,

68 f9_41 :: Int,

53 f9_42 :: Int,

69 f9_42 :: Int,

54 f9_43 :: Int,

70 f9_43 :: Int,

55 f9_44 :: Int }

71 f9_44 :: Int }

56− deriving (Show, Generic, Eq, Binary, NFData, Atomable)

72+ deriving (Show, Generic, Eq, NFData, Atomable)

73+ deriving Serialise via WineryRecord Test9_4T

57

74

58data Test9_5T = Test9_5C {

75data Test9_5T = Test9_5C {

59 f9_51 :: Int,

76 f9_51 :: Int,

@@ -62,17 +79,16 @@ data Test9_5T = Test9_5C {

62 f9_54 :: Int,

79 f9_54 :: Int,

63 f9_55 :: Int

80 f9_55 :: Int

64 }

81 }

65− deriving (Show, Generic, Eq, Binary, NFData, Atomable)

82+ deriving (Show, Generic, Eq, NFData, Atomable)

83+ deriving Serialise via WineryRecord Test9_5T

66

84

67−

68main :: IO ()

85main :: IO ()

69main = do

86main = do

70 tcounts <- runTestTT testList

87 tcounts <- runTestTT testList

71 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

88 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

72

89

73testList :: Test

90testList :: Test

74−testList = TestList [testHaskell2DB, testADT1, testADT2, testADT3, testADT4, testADT5, testBasicMarshaling, testListInstance, testNonEmptyInstance, testADT6Maybe, testADT7Either, testNonPrimitiveValues]

91+testList = TestList [testHaskell2DB, testADT1, testADT2, testADT3, testADT4, testADT5, testBasicMarshaling, testSimpleList, testListInstance, testNonEmptyInstance, testADT6Maybe, testADT7Either, testNonPrimitiveValues, testRecordType, testManyFields]

75−

76

92

77-- test some basic data types like int, day, etc.

93-- test some basic data types like int, day, etc.

78testBasicMarshaling :: Test

94testBasicMarshaling :: Test

@@ -101,7 +117,7 @@ testHaskell2DB = TestCase $ do

101 let createRelExpr = Assign "x" rel

117 let createRelExpr = Assign "x" rel

102

118

103 rel = MakeRelationFromExprs Nothing

119 rel = MakeRelationFromExprs Nothing

104− [TupleExpr (M.singleton "a1" (NakedAtomExpr atomVal))]

120+ (TupleExprs () [TupleExpr (M.singleton "a1" (NakedAtomExpr atomVal))])

105 atomVal = toAtom exampleVal

121 atomVal = toAtom exampleVal

106 exampleVal = Test1C 10

122 exampleVal = Test1C 10

107 checkExecuteDatabaseContextExpr sessionId dbconn createRelExpr

123 checkExecuteDatabaseContextExpr sessionId dbconn createRelExpr

@@ -157,6 +173,12 @@ testListInstance = TestCase $ do

157 let example = TestListC [3,4,5]

173 let example = TestListC [3,4,5]

158 assertEqual "List instance" example (fromAtom (toAtom example))

174 assertEqual "List instance" example (fromAtom (toAtom example))

159

175

176+testSimpleList :: Test

177+testSimpleList = TestCase $ do

178+ let example = toAtom @[Integer] [1,2,3]

179+ expected = ConstructedAtom "Cons" (ConstructedAtomType "List" (M.fromList [("a",IntegerAtomType)])) [IntegerAtom 1,ConstructedAtom "Cons" (ConstructedAtomType "List" (M.fromList [("a",IntegerAtomType)])) [IntegerAtom 2,ConstructedAtom "Cons" (ConstructedAtomType "List" (M.fromList [("a",IntegerAtomType)])) [IntegerAtom 3,ConstructedAtom "Empty" (ConstructedAtomType "List" (M.fromList [("a",IntegerAtomType)])) []]]]

180+ assertEqual "simple list" expected example

181+

160testNonEmptyInstance :: Test

182testNonEmptyInstance :: Test

161testNonEmptyInstance = TestCase $ do

183testNonEmptyInstance = TestCase $ do

162 let example = TestNonEmptyC [3,4,5]

184 let example = TestNonEmptyC [3,4,5]

@@ -167,11 +189,21 @@ testNonPrimitiveValues = TestCase $ do

167 let example = Test8C (Test1C 3)

189 let example = Test8C (Test1C 3)

168 assertEqual "non-primitive values" example (fromAtom (toAtom example))

190 assertEqual "non-primitive values" example (fromAtom (toAtom example))

169

191

192+testRecordType :: Test

193+testRecordType = TestCase $ do

194+ let example = User { userFirstName = "Bob"

195+ ,userLastName = "Smith"

196+ }

197+ assertEqual "User record" example (fromAtom (toAtom example))

198+ let expected = AddTypeConstructor (ADTypeConstructorDef "User" []) [DataConstructorDef "User" [DataConstructorDefTypeConstructorArg (PrimitiveTypeConstructor "Text" TextAtomType),DataConstructorDefTypeConstructorArg (PrimitiveTypeConstructor "Text" TextAtomType)]]

199+

200+ assertEqual "User record to database context expr" expected (toAddTypeExpr (Proxy :: Proxy User))

201+

170--test both odd and even product types with more than 2 fields

202--test both odd and even product types with more than 2 fields

171testManyFields :: Test

203testManyFields :: Test

172testManyFields = TestCase $ do

204testManyFields = TestCase $ do

173− let example4 = Test9_4T 1 2 3 4

205+ let example4 = Test9_4C 1 2 3 4

174 assertEqual "four fields product type" example4 (fromAtom (toAtom example4))

206 assertEqual "four fields product type" example4 (fromAtom (toAtom example4))

175

207

176− let example5 = Test9_5T 1 2 3 4 5

208+ let example5 = Test9_5C 1 2 3 4 5

177 assertEqual "five fields product type" example5 (fromAtom (toAtom example5))

209 assertEqual "five fields product type" example5 (fromAtom (toAtom example5))

test/Relation/Basic.hs+24−17

@@ -3,13 +3,11 @@ import ProjectM36.Base

3import ProjectM36.Relation

4import ProjectM36.Error

5import ProjectM36.DateExamples

6−import ProjectM36.TupleSet

7−import ProjectM36.Attribute hiding (null, attributeNames)

8import ProjectM36.DataTypes.Primitive

6import ProjectM36.DataTypes.Primitive

9import ProjectM36.RelationalExpression

7import ProjectM36.RelationalExpression

8+import ProjectM36.TransactionGraph

10import ProjectM36.Tuple

9import ProjectM36.Tuple

11import qualified ProjectM36.DatabaseContext as DBC

10import qualified ProjectM36.DatabaseContext as DBC

12−import Control.Monad.Trans.Reader

13import qualified ProjectM36.Attribute as A

11import qualified ProjectM36.Attribute as A

14import qualified Data.Map as M

12import qualified Data.Map as M

15import qualified Data.Vector as V

13import qualified Data.Vector as V

@@ -25,8 +23,8 @@ testList = TestList [testRelation "relationTrue" relationTrue, testRelation "rel

25 testRelation "products" productsRel,

23 testRelation "products" productsRel,

26 testRelation "supplierProducts" supplierProductsRel,

24 testRelation "supplierProducts" supplierProductsRel,

27 testMkRelationFromExprsBadAttrs,

25 testMkRelationFromExprsBadAttrs,

28− testDuplicateAttributes,

26+ testExistingRelationType,

29− testExistingRelationType

27+ testReorderTuple

30 ]

28 ]

31

29

32main :: IO ()

30main :: IO ()

@@ -64,8 +62,8 @@ validateAttrTypesMatchTupleAttrTypes rel@(Relation attrs tupSet) = foldr (\tuple

64 tupleAtomCheck tuple = V.all (== True) (attrChecks tuple)

62 tupleAtomCheck tuple = V.all (== True) (attrChecks tuple)

65 attrChecks tuple = V.map (\attr -> case atomForAttributeName (A.attributeName attr) tuple of

63 attrChecks tuple = V.map (\attr -> case atomForAttributeName (A.attributeName attr) tuple of

66 Left _ -> False

64 Left _ -> False

67− Right atom -> (Right $ atomTypeForAtom atom) ==

65+ Right atom -> Right (atomTypeForAtom atom) ==

68− A.atomTypeForAttributeName (A.attributeName attr) attrs) (attributes rel)

66+ A.atomTypeForAttributeName (A.attributeName attr) attrs) (attributesVec (attributes rel))

69

67

70simpleRel :: Relation

68simpleRel :: Relation

71simpleRel = case mkRelation attrs tupleSet of

69simpleRel = case mkRelation attrs tupleSet of

@@ -94,19 +92,28 @@ testMkRelation1 = TestCase $ assertEqual "key mismatch" expectedError (mkRelatio

94

92

95testMkRelationFromExprsBadAttrs :: Test

93testMkRelationFromExprsBadAttrs :: Test

96testMkRelationFromExprsBadAttrs = TestCase $ do

94testMkRelationFromExprsBadAttrs = TestCase $ do

97− let context = DBC.empty

95+ let context = DBC.empty

96+ (graph,_) <- freshTransactionGraph context

97+ let reenv = mkRelationalExprEnv context graph

98− case runReader (evalRelationalExpr (MakeRelationFromExprs (Just [AttributeAndTypeNameExpr "badAttr1" (PrimitiveTypeConstructor "Int" IntAtomType) ()]) [TupleExpr (M.singleton "badAttr2" (NakedAtomExpr (IntAtom 1)))])) (mkRelationalExprState context) of

98+ reExpr = MakeRelationFromExprs (Just [AttributeAndTypeNameExpr "badAttr1" (PrimitiveTypeConstructor "Int" IntAtomType) ()]) (TupleExprs () [TupleExpr (M.singleton "badAttr2" (NakedAtomExpr (IntAtom 1)))])

99+ evald = runRelationalExprM reenv (evalRelationalExpr reExpr)

100+ case evald of

99 Left err -> assertEqual "tuple type mismatch" (TupleAttributeTypeMismatchError (A.attributesFromList [Attribute "badAttr2" IntAtomType])) err

101 Left err -> assertEqual "tuple type mismatch" (TupleAttributeTypeMismatchError (A.attributesFromList [Attribute "badAttr2" IntAtomType])) err

100 Right _ -> assertFailure "expected tuple type mismatch"

102 Right _ -> assertFailure "expected tuple type mismatch"

101

103

102−--creating an empty relation with duplicate attribute names should fail

103−testDuplicateAttributes :: Test

104−testDuplicateAttributes = TestCase $ do

105− let eRel = mkRelation attrs emptyTupleSet

106− attrs = attributesFromList [Attribute "a" IntAtomType, Attribute "a" TextAtomType]

107− assertEqual "duplicate attribute names" (Left (DuplicateAttributeNamesError (S.singleton "a"))) eRel

108−

109testExistingRelationType :: Test

104testExistingRelationType :: Test

110testExistingRelationType = TestCase $ do

105testExistingRelationType = TestCase $ do

106+ (graph, _) <- freshTransactionGraph dateExamples

111− let typeResult = runReader (typeForRelationalExpr (ExistingRelation relationTrue)) (RelationalExprStateElems DBC.empty)

107+ let typeResult = runRelationalExprM reenv (typeForRelationalExpr (ExistingRelation relationTrue))

108+ reenv = mkRelationalExprEnv dateExamples graph

112 assertEqual "ExistingRelation with tuples type" (Right relationFalse) typeResult

109 assertEqual "ExistingRelation with tuples type" (Right relationFalse) typeResult

110+

111+-- | Ensure that tuple reordering honors the

112+testReorderTuple :: Test

113+testReorderTuple = TestCase $ do

114+ let tup1 = mkRelationTuple attrs1 (V.fromList [IntAtom 4, TextAtom "test"])

115+ attrs1 = A.attributesFromList [Attribute "a" IntAtomType, Attribute "b" TextAtomType]

116+ attrs2 = A.attributesFromList [Attribute "b" TextAtomType, Attribute "a" IntAtomType]

117+ actual = reorderTuple attrs2 tup1

118+ expected = mkRelationTuple attrs2 (V.fromList [TextAtom "test", IntAtom 4])

119+ assertEqual "reorderTuple" expected actual

test/Relation/Export/CSV.hs+23−18

@@ -1,3 +1,5 @@

1+{-# LANGUAGE CPP #-}

2+

1import ProjectM36.Base

3import ProjectM36.Base

2import ProjectM36.Relation.Show.CSV

4import ProjectM36.Relation.Show.CSV

3import ProjectM36.Relation.Parse.CSV

5import ProjectM36.Relation.Parse.CSV

@@ -11,7 +13,11 @@ import System.Exit

11import Test.HUnit

13import Test.HUnit

12import Data.Time.Calendar

14import Data.Time.Calendar

13import Data.Time.Clock

15import Data.Time.Clock

16+

17+#if __GLASGOW_HASKELL__ < 804

14import Data.Monoid

18import Data.Monoid

19+#endif

20+

15{-

21{-

16import qualified Data.Text.Lazy as TL

22import qualified Data.Text.Lazy as TL

17import qualified Data.Text.Lazy.Encoding as TE

23import qualified Data.Text.Lazy.Encoding as TE

@@ -19,9 +25,9 @@ import ProjectM36.Relation.Show.Term

19import qualified Data.ByteString.Lazy as BS

25import qualified Data.ByteString.Lazy as BS

20-}

26-}

21

27

22−main :: IO ()

28+main :: IO ()

23−main = do

29+main = do

24− tcounts <- runTestTT $ TestList [testCSVExport,

30+ tcounts <- runTestTT $ TestList [testCSVExport,

25 testADTExport]

31 testADTExport]

26 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

32 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

27

33

@@ -31,8 +37,8 @@ assertEither x = do

31 case res of

37 case res of

32 Left err -> assertFailure (show err) >> undefined

38 Left err -> assertFailure (show err) >> undefined

33 Right val -> pure val

39 Right val -> pure val

34−

40+

35−testADTExport :: Test

41+testADTExport :: Test

36testADTExport = TestCase $ do

42testADTExport = TestCase $ do

37 let adtCSV = "a\nCons 4 (Cons 5 Empty)\n"

43 let adtCSV = "a\nCons 4 (Cons 5 Empty)\n"

38 attrs = A.attributesFromList [Attribute "a" (listAtomType IntegerAtomType)]

44 attrs = A.attributesFromList [Attribute "a" (listAtomType IntegerAtomType)]

@@ -40,17 +46,17 @@ testADTExport = TestCase $ do

40 case csvAsRelation attrs basicTypeConstructorMapping adtCSV of

46 case csvAsRelation attrs basicTypeConstructorMapping adtCSV of

41 Left err -> assertFailure ("import failure: " <> show err)

47 Left err -> assertFailure ("import failure: " <> show err)

42 Right rel -> assertEqual "import cons list" expectedRel (Right rel)

48 Right rel -> assertEqual "import cons list" expectedRel (Right rel)

43−

49+

44--round-trip various atom types through CSV export/import

50--round-trip various atom types through CSV export/import

45testCSVExport :: Test

51testCSVExport :: Test

46testCSVExport = TestCase $ do

52testCSVExport = TestCase $ do

47 now <- getCurrentTime

53 now <- getCurrentTime

48− testInterval <- assertEither $ pure (createInterval

54+ testInterval <- assertEither $ pure (createInterval

49− (DateTimeAtom now)

55+ (DateTimeAtom now)

50 (DateTimeAtom (addUTCTime 86400 now))

56 (DateTimeAtom (addUTCTime 86400 now))

51 True

57 True

52 False)

58 False)

53− let attrs = A.attributesFromList [Attribute "textattr" TextAtomType,

59+ let attrs = A.attributesFromList [Attribute "textattr" TextAtomType,

54 Attribute "integerattr" IntegerAtomType,

60 Attribute "integerattr" IntegerAtomType,

55 Attribute "dayattr" DayAtomType,

61 Attribute "dayattr" DayAtomType,

56 Attribute "datetimeattr" DateTimeAtomType,

62 Attribute "datetimeattr" DateTimeAtomType,

@@ -61,8 +67,8 @@ testCSVExport = TestCase $ do

61 ]

67 ]

62 sampleByteString = "\1\0\244\34\150"

68 sampleByteString = "\1\0\244\34\150"

63 relOrErr = mkRelationFromList attrs [

69 relOrErr = mkRelationFromList attrs [

64− [TextAtom "text atom with \"quote\"",

70+ [TextAtom "text atom with \"quote\"",

65− IntegerAtom 123,

71+ IntegerAtom 123,

66 DayAtom (fromGregorian 2017 4 10),

72 DayAtom (fromGregorian 2017 4 10),

67 DateTimeAtom now,

73 DateTimeAtom now,

68 ByteStringAtom sampleByteString,

74 ByteStringAtom sampleByteString,

@@ -70,19 +76,19 @@ testCSVExport = TestCase $ do

70 listCons TextAtomType [TextAtom "text1", TextAtom "text2"],

76 listCons TextAtomType [TextAtom "text1", TextAtom "text2"],

71 testInterval

77 testInterval

72 ],

78 ],

73− [TextAtom "second text atom with 漢字",

79+ [TextAtom "second text atom with 漢字",

74− IntegerAtom 314,

80+ IntegerAtom 314,

75 DayAtom (fromGregorian 1001 6 28),

81 DayAtom (fromGregorian 1001 6 28),

76 DateTimeAtom (addUTCTime 360 now),

82 DateTimeAtom (addUTCTime 360 now),

77− ByteStringAtom sampleByteString,

83+ ByteStringAtom sampleByteString,

78 listCons IntegerAtomType [IntegerAtom 10, IntegerAtom 11, IntegerAtom 12],

84 listCons IntegerAtomType [IntegerAtom 10, IntegerAtom 11, IntegerAtom 12],

79 listCons TextAtomType [TextAtom "text5\"", TextAtom "text6\r\n"],

85 listCons TextAtomType [TextAtom "text5\"", TextAtom "text6\r\n"],

80 testInterval

86 testInterval

81 ]]

87 ]]

82−

88+

83− case relOrErr of

89+ case relOrErr of

84 Left err -> assertFailure $ "export relation creation failure: " ++ show err

90 Left err -> assertFailure $ "export relation creation failure: " ++ show err

85− Right rel ->

91+ Right rel ->

86 case relationAsCSV rel of

92 case relationAsCSV rel of

87 Left err -> assertFailure $ "export failed: " ++ show err

93 Left err -> assertFailure $ "export failed: " ++ show err

88 Right csvData ->

94 Right csvData ->

@@ -91,4 +97,3 @@ testCSVExport = TestCase $ do

91 case csvAsRelation attrs basicTypeConstructorMapping csvData of -- import csv data back to relation

97 case csvAsRelation attrs basicTypeConstructorMapping csvData of -- import csv data back to relation

92 Left err -> assertFailure $ "re-import failed: " ++ show err

98 Left err -> assertFailure $ "re-import failed: " ++ show err

93 Right rel' -> assertEqual "relation CSV comparison" rel rel'

99 Right rel' -> assertEqual "relation CSV comparison" rel rel'

94−

test/Relation/StaticOptimizer.hs+76−51

@@ -1,13 +1,12 @@

1import ProjectM36.Base

2import ProjectM36.Relation

3−import ProjectM36.RelationalExpression

3+import ProjectM36.TransactionGraph

4import ProjectM36.DateExamples

5−import ProjectM36.Error

6import ProjectM36.TupleSet

5import ProjectM36.TupleSet

7import ProjectM36.StaticOptimizer

6import ProjectM36.StaticOptimizer

7+import ProjectM36.DatabaseContext as DBC

8import System.Exit

9import Control.Monad.State

10−import Control.Monad.Trans.Reader

11import Test.HUnit

10import Test.HUnit

12import qualified Data.Set as S

11import qualified Data.Set as S

13

12

@@ -16,100 +15,126 @@ main = do

16 tcounts <- runTestTT (TestList tests)

15 tcounts <- runTestTT (TestList tests)

17 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

16 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

18 where

17 where

19− tests = relationOptTests ++ databaseOptTests ++ [testTransitiveOptimization,

18+ tests = [testTransitiveOptimization,

20− testImpossiblePredicates,

19+ testImpossiblePredicates,

21− testJoinElimination,

20+ testJoinElimination,

22− testRestrictionPredicateCollapse,

21+ testRestrictionPredicateCollapse,

23− testPushDownRestrictionPredicate]

22+ testPushDownRestrictionPredicate,

24− optDBCTest = map (\(name, expr, unopt) -> TestCase $ assertEqual name expr (evalState (applyStaticDatabaseOptimization unopt) (freshDatabaseState dateExamples)))

23+ testOptimizeRelationalExpr,

25− relvar nam = RelationVariable nam ()

24+ testOptimizeDatabaseContextExpr]

26− startState = mkRelationalExprState dateExamples

25+

27− optRelTest = map (\(name, expr, unopt) -> TestCase $ assertEqual name expr (runReader (applyStaticRelationalOptimization unopt) startState))

26+testOptimizeDatabaseContextExpr :: Test

28− relationOptTests = optRelTest [

27+testOptimizeDatabaseContextExpr = TestCase $ do

29− ("StaticProject", Right $ relvar "s", Project (AttributeNames (attributeNames suppliersRel)) (relvar "s")),

28+ (graph, transId) <- freshTransactionGraph DBC.empty

30− ("StaticUnion", Right $ relvar "s", Union (relvar "s") (relvar "s")),

29+ let relvar nam = RelationVariable nam ()

31− ("StaticJoin", Right $ relvar "s", Join (relvar "s") (relvar "s"))

30+ relvarId nam = RelationVariable nam UncommittedContextMarker

32− ]

31+ testInfos = [

33− databaseOptTests = optDBCTest [

34− ("StaticAssign",

32+ ("StaticAssign",

35− Right $ Assign "z" (relvar "s"),

33+ Right $ Assign "z" (relvarId "s"),

36− Assign "z" (Restrict TruePredicate (relvar "s"))

34+ Assign "z" (Restrict TruePredicate (relvar "s"))

37− ),

35+ ),

38− ("StaticMultipleExpr",

36+ ("StaticMultipleExpr",

39− Right $ MultipleExpr [Assign "z" (relvar "s"),

37+ Right $ MultipleExpr [Assign "z" (relvarId "s"),

40− Assign "z" (relvar "s")],

38+ Assign "z" (relvarId "s")],

41− MultipleExpr [Assign "z" (Restrict TruePredicate (relvar "s")),

39+ MultipleExpr [Assign "z" (Restrict TruePredicate (relvar "s")),

42− Assign "z" (Restrict TruePredicate (relvar "s"))])

40+ Assign "z" (Restrict TruePredicate (relvar "s"))])

43− ]

41+ ]

42+ forM_ testInfos $ \(name, expectedExpr, unoptExpr) -> do

43+ let optExpr = runGraphRefSOptDatabaseContextExprM transId dateExamples graph (optimizeDatabaseContextExpr unoptExpr)

44+ assertEqual name expectedExpr optExpr

44

45

45testTransitiveOptimization :: Test

46testTransitiveOptimization :: Test

46testTransitiveOptimization = TestCase $ do

47testTransitiveOptimization = TestCase $ do

48+ (graph, _) <- freshTransactionGraph dateExamples

47 let expr atomexpr = AndPredicate (AttributeEqualityPredicate "a" (NakedAtomExpr (IntegerAtom 300))) (AttributeEqualityPredicate "b" atomexpr)

49 let expr atomexpr = AndPredicate (AttributeEqualityPredicate "a" (NakedAtomExpr (IntegerAtom 300))) (AttributeEqualityPredicate "b" atomexpr)

48 exprIn = expr (AttributeAtomExpr "a")

50 exprIn = expr (AttributeAtomExpr "a")

49 exprOut = expr (NakedAtomExpr (IntegerAtom 300))

51 exprOut = expr (NakedAtomExpr (IntegerAtom 300))

52+ optExpr = runGraphRefSOptRelationalExprM Nothing graph (applyStaticPredicateOptimization exprIn)

50− assertEqual "transitive property" (Right exprOut) (runReader (applyStaticPredicateOptimization exprIn) (RelationalExprStateElems dateExamples))

53+ assertEqual "transitive property" (Right exprOut) optExpr

51−

54+

52−optRelExpr :: RelationalExpr -> Either RelationalError RelationalExpr

55+

53−optRelExpr expr = runReader (applyStaticRelationalOptimization expr) (RelationalExprStateElems dateExamples)

56+testOptimizeRelationalExpr :: Test

57+testOptimizeRelationalExpr = TestCase $ do

58+ (graph, _) <- freshTransactionGraph dateExamples

59+ let relvarId nam = RelationVariable nam UncommittedContextMarker

60+ relationOptTests = [

61+ ("StaticProject",

62+ Right $ relvarId "s",

63+ Project (AttributeNames (attributeNames suppliersRel)) (relvarId "s")),

64+ ("StaticUnion",

65+ Right $ relvarId "s",

66+ Union (relvarId "s") (relvarId "s")),

67+ ("StaticJoin",

68+ Right $ relvarId "s",

69+ Join (relvarId "s") (relvarId "s"))

70+ ]

71+ forM_ relationOptTests $ \(name, expr, unoptExpr) -> do

72+ let optExpr = runGraphRefSOptRelationalExprM (Just dateExamples) graph (optimizeGraphRefRelationalExpr unoptExpr)

73+ assertEqual name expr optExpr

54

74

55testImpossiblePredicates :: Test

75testImpossiblePredicates :: Test

56testImpossiblePredicates = TestCase $ do

76testImpossiblePredicates = TestCase $ do

77+ (graph, _) <- freshTransactionGraph dateExamples

57 let tautTrue = Restrict (AtomExprPredicate (NakedAtomExpr (BoolAtom True))) rel

78 let tautTrue = Restrict (AtomExprPredicate (NakedAtomExpr (BoolAtom True))) rel

58 tautTrue2 = Restrict TruePredicate rel

79 tautTrue2 = Restrict TruePredicate rel

59 tautFalse = Restrict (AtomExprPredicate (NakedAtomExpr (BoolAtom False))) rel

80 tautFalse = Restrict (AtomExprPredicate (NakedAtomExpr (BoolAtom False))) rel

60 tautFalse2 = Restrict (NotPredicate TruePredicate) rel

81 tautFalse2 = Restrict (NotPredicate TruePredicate) rel

61 emptyRel = MakeStaticRelation (attributes suppliersRel) emptyTupleSet

82 emptyRel = MakeStaticRelation (attributes suppliersRel) emptyTupleSet

62− rel = RelationVariable "s" ()

83+ rel = RelationVariable "s" UncommittedContextMarker

84+ optRelExpr expr = optimizeGraphRefRelationalExpr' (Just dateExamples) graph expr

63 assertEqual "remove tautology where true" (Right rel) (optRelExpr tautTrue)

85 assertEqual "remove tautology where true" (Right rel) (optRelExpr tautTrue)

64 assertEqual "remove tautology where true2" (Right rel) (optRelExpr tautTrue2)

86 assertEqual "remove tautology where true2" (Right rel) (optRelExpr tautTrue2)

65 assertEqual "remove tautology where false" (Right emptyRel) (optRelExpr tautFalse)

87 assertEqual "remove tautology where false" (Right emptyRel) (optRelExpr tautFalse)

66 assertEqual "remove tautology where false2" (Right emptyRel) (optRelExpr tautFalse2)

88 assertEqual "remove tautology where false2" (Right emptyRel) (optRelExpr tautFalse2)

67−

68−optJoinExpr :: RelationalExpr -> Either RelationalError RelationalExpr

69−optJoinExpr expr = runReader (applyStaticJoinElimination expr) (RelationalExprStateElems dateExamples)

70

89

71testJoinElimination :: Test

90testJoinElimination :: Test

72testJoinElimination = TestCase $ do

91testJoinElimination = TestCase $ do

92+ (graph, _) <- freshTransactionGraph dateExamples

93+ let marker = UncommittedContextMarker

94+ optJoinExpr expr = runGraphRefSOptRelationalExprM (Just dateExamples) graph (applyStaticJoinElimination expr)

95+ relvar rv = RelationVariable rv marker

96+

73 -- (s join sp){s#,qty,p#} == sp

97 -- (s join sp){s#,qty,p#} == sp

74− let unoptExpr = Project (AttributeNames (S.fromList ["p#", "qty", "s#"])) (Join (RelationVariable "sp" ()) (RelationVariable "s" ()))

98+ let unoptExpr = Project (AttributeNames (S.fromList ["p#", "qty", "s#"])) (Join (relvar "sp") (relvar "s"))

75− assertEqual "remove extraneous join" (Right (RelationVariable "sp" ())) (optJoinExpr unoptExpr)

99+ assertEqual "remove extraneous join" (Right (relvar "sp")) (optJoinExpr unoptExpr)

76

100

77-- (sp join s){s#,qty,p#} == sp --flip relvar names

101-- (sp join s){s#,qty,p#} == sp --flip relvar names

78− let unoptExpr2 = Project (AttributeNames (S.fromList ["p#", "qty", "s#"])) (Join (RelationVariable "s" ()) (RelationVariable "sp" ()))

102+ let unoptExpr2 = Project (AttributeNames (S.fromList ["p#", "qty", "s#"])) (Join (relvar "s") (relvar "sp"))

79− assertEqual "remove extraneous join2" (Right (RelationVariable "sp" ())) (optJoinExpr unoptExpr2)

103+ assertEqual "remove extraneous join2" (Right (relvar "sp")) (optJoinExpr unoptExpr2)

80

104

81-- (sp join s){s#,qty,sname} != sp - attribute from s included

105-- (sp join s){s#,qty,sname} != sp - attribute from s included

82− let expr3 = Project (AttributeNames (S.fromList ["p#", "qty", "sname"])) (Join (RelationVariable "sp" ()) (RelationVariable "s" ()))

106+ let expr3 = Project (AttributeNames (S.fromList ["p#", "qty", "sname"])) (Join (relvar "sp") (relvar "s"))

83 assertEqual "retain join" (Right expr3) (optJoinExpr expr3)

107 assertEqual "retain join" (Right expr3) (optJoinExpr expr3)

84

108

85 -- (sp join s){qty} != sp --projection does not include foreign key attribute

109 -- (sp join s){qty} != sp --projection does not include foreign key attribute

86− let expr4 = Project (AttributeNames (S.singleton "qty")) (Join (RelationVariable "sp" ()) (RelationVariable "s" ()))

110+ let expr4 = Project (AttributeNames (S.singleton "qty")) (Join (relvar "sp") (relvar "s"))

87 assertEqual "retain join2" (Right expr4) (optJoinExpr expr4)

111 assertEqual "retain join2" (Right expr4) (optJoinExpr expr4)

88

112

89 -- (sp join s){s#,qty} == sp - a subset of attributes in the projection are in the foreign key

113 -- (sp join s){s#,qty} == sp - a subset of attributes in the projection are in the foreign key

90− let expr5 = Project (AttributeNames (S.fromList ["s#", "qty"])) (Join (RelationVariable "sp" ()) (RelationVariable "s" ()))

114+ let expr5 = Project (AttributeNames (S.fromList ["s#", "qty"])) (Join (relvar "sp") (relvar "s"))

91− let expect5 = Project (AttributeNames (S.fromList ["s#", "qty"])) (RelationVariable "sp" ())

115+ let expect5 = Project (AttributeNames (S.fromList ["s#", "qty"])) (relvar "sp")

92 assertEqual "remove extraneous join (attribute subset)" (Right expect5) (optJoinExpr expr5)

116 assertEqual "remove extraneous join (attribute subset)" (Right expect5) (optJoinExpr expr5)

93

117

94 -- (s join p){s#,p#} != sp -- no foreign key

118 -- (s join p){s#,p#} != sp -- no foreign key

95− let expr6 = Project (AttributeNames (S.fromList ["s#", "p#"])) (Join (RelationVariable "s" ()) (RelationVariable "p" ()))

119+ let expr6 = Project (AttributeNames (S.fromList ["s#", "p#"])) (Join (relvar "s") (relvar "p"))

96 assertEqual "retain join- no foreign key" (Right expr6) (optJoinExpr expr6)

120 assertEqual "retain join- no foreign key" (Right expr6) (optJoinExpr expr6)

97

121

98 -- (s join p){s#,qty,p#,sname} != sp -- all sp attributes plus one s attributes

122 -- (s join p){s#,qty,p#,sname} != sp -- all sp attributes plus one s attributes

99− let expr7 = Project (AttributeNames (S.fromList ["s#", "p#", "qty", "sname"])) (Join (RelationVariable "s" ()) (RelationVariable "sp" ()))

123+ let expr7 = Project (AttributeNames (S.fromList ["s#", "p#", "qty", "sname"])) (Join (relvar "s") (relvar "sp"))

100 assertEqual "retain join- attributes from both relvars" (Right expr7) (optJoinExpr expr7)

124 assertEqual "retain join- attributes from both relvars" (Right expr7) (optJoinExpr expr7)

101

125

102testRestrictionPredicateCollapse :: Test

126testRestrictionPredicateCollapse :: Test

103testRestrictionPredicateCollapse = TestCase $ do

127testRestrictionPredicateCollapse = TestCase $ do

104 let expr1 = Restrict (NotPredicate TruePredicate) rv

128 let expr1 = Restrict (NotPredicate TruePredicate) rv

105− rv = RelationVariable "a" ()

129+ rv = RelationVariable "a" UncommittedContextMarker

130+ relvar name = RelationVariable name UncommittedContextMarker

106 assertEqual "one restriction" expr1 (applyStaticRestrictionCollapse expr1)

131 assertEqual "one restriction" expr1 (applyStaticRestrictionCollapse expr1)

107

132

108 let attrEqualsPred = AttributeEqualityPredicate "x" (NakedAtomExpr (IntAtom 3))

133 let attrEqualsPred = AttributeEqualityPredicate "x" (NakedAtomExpr (IntAtom 3))

109− expr2 = Restrict TruePredicate (Restrict attrEqualsPred (RelationVariable "a" ()))

134+ expr2 = Restrict TruePredicate (Restrict attrEqualsPred (relvar "a"))

110− assertEqual "two restrictions" (Restrict (AndPredicate TruePredicate attrEqualsPred) (RelationVariable "a" ())) (applyStaticRestrictionCollapse expr2)

135+ assertEqual "two restrictions" (Restrict (AndPredicate TruePredicate attrEqualsPred) (relvar "a")) (applyStaticRestrictionCollapse expr2)

111

136

112− let expr3 = Restrict pred1 (Restrict pred2 (Restrict pred3 (RelationVariable "a" ())))

137+ let expr3 = Restrict pred1 (Restrict pred2 (Restrict pred3 (relvar "a")))

113 pred1 = NotPredicate TruePredicate

138 pred1 = NotPredicate TruePredicate

114 pred2 = attrEqualsPred

139 pred2 = attrEqualsPred

115 pred3 = AtomExprPredicate (NakedAtomExpr (BoolAtom True))

140 pred3 = AtomExprPredicate (NakedAtomExpr (BoolAtom True))

@@ -123,7 +148,7 @@ testRestrictionPredicateCollapse = TestCase $ do

123testPushDownRestrictionPredicate :: Test

148testPushDownRestrictionPredicate :: Test

124testPushDownRestrictionPredicate = TestCase $ do

149testPushDownRestrictionPredicate = TestCase $ do

125 -- (s union relation{tuple{city "Boston", s# "S6", sname "Stevens", status 50}}) where status = 30 == (s where status=30) union (relation{tuple{city "Boston", s# "S6", sname "Stevens", status 50}} where status=30)

150 -- (s union relation{tuple{city "Boston", s# "S6", sname "Stevens", status 50}}) where status = 30 == (s where status=30) union (relation{tuple{city "Boston", s# "S6", sname "Stevens", status 50}} where status=30)

126− let rvs = RelationVariable "s" ()

151+ let rvs = RelationVariable "s" UncommittedContextMarker

127 let status30 = AttributeEqualityPredicate "status" (NakedAtomExpr (IntAtom 30))

152 let status30 = AttributeEqualityPredicate "status" (NakedAtomExpr (IntAtom 30))

128 relationsOrError = do

153 relationsOrError = do

129 stevens <- mkRelationFromList (attributes suppliersRel) [[TextAtom "S6", TextAtom "Stevens", IntegerAtom 50, TextAtom "Boston"]]

154 stevens <- mkRelationFromList (attributes suppliersRel) [[TextAtom "S6", TextAtom "Stevens", IntegerAtom 50, TextAtom "Boston"]]

test/Relation/Tupleable.hs+187−9

@@ -1,19 +1,29 @@

1−{-# LANGUAGE DeriveGeneric, FlexibleInstances, FlexibleContexts, TypeOperators, DeriveAnyClass #-}

1+{-# LANGUAGE

2+ DeriveGeneric

3+ , FlexibleInstances

4+ , FlexibleContexts

5+ , DeriveAnyClass

6+ , ScopedTypeVariables

7+ , TypeApplications

8+ , DataKinds

9+ , TypeOperators

10+ , AllowAmbiguousTypes

11+ , DerivingVia

12+ #-}

2import Test.HUnit

13import Test.HUnit

3−import ProjectM36.Tupleable

14+import ProjectM36.Tupleable.Deriving

4import ProjectM36.Atomable

15import ProjectM36.Atomable

5−import ProjectM36.Attribute

16+import ProjectM36.Attribute as A

6import ProjectM36.Error

17import ProjectM36.Error

7−import Data.Binary

8import ProjectM36.Base

18import ProjectM36.Base

9import Control.DeepSeq (NFData)

19import Control.DeepSeq (NFData)

10−import GHC.Generics

11import qualified Data.Vector as V

20import qualified Data.Vector as V

12import qualified Data.Map as M

21import qualified Data.Map as M

13import qualified Data.Text as T

22import qualified Data.Text as T

14import qualified Data.Set as S

23import qualified Data.Set as S

15import System.Exit

24import System.Exit

16import Data.Proxy

25import Data.Proxy

26+import Codec.Winery

17

27

18{-# ANN module ("Hlint: ignore Use newtype instead of data" :: String) #-}

28{-# ANN module ("Hlint: ignore Use newtype instead of data" :: String) #-}

19

29

@@ -21,35 +31,43 @@ data Test1T = Test1C {

21 attrA :: Integer

31 attrA :: Integer

22 }

32 }

23 deriving (Generic, Eq, Show)

33 deriving (Generic, Eq, Show)

34+ deriving Serialise via WineryRecord Test1T

24

35

25data Test2T = Test2C {

36data Test2T = Test2C {

26 attrB :: Integer,

37 attrB :: Integer,

27 attrC :: Integer

38 attrC :: Integer

28 }

39 }

29 deriving (Generic, Eq, Show)

40 deriving (Generic, Eq, Show)

41+ deriving Serialise via WineryRecord Test2T

30

42

31data Test3T = Test3C Integer

43data Test3T = Test3C Integer

32 deriving (Generic, Eq, Show)

44 deriving (Generic, Eq, Show)

45+ deriving Serialise via WineryVariant Test3T

33

46

34data Test4T = Test4C

47data Test4T = Test4C

35 deriving (Generic, Eq, Show)

48 deriving (Generic, Eq, Show)

49+ deriving Serialise via WineryVariant Test4T

36

50

37data Test5T = Test5C1 Integer |

51data Test5T = Test5C1 Integer |

38 Test5C2 Integer

52 Test5C2 Integer

39 deriving (Generic, Eq, Show)

53 deriving (Generic, Eq, Show)

54+ deriving Serialise via WineryVariant Test5T

40

55

41data Test6T = Test6C T.Text Integer Double

56data Test6T = Test6C T.Text Integer Double

42 deriving (Generic, Eq, Show)

57 deriving (Generic, Eq, Show)

43

58

44data Test7A = Test7AC Integer

59data Test7A = Test7AC Integer

45− deriving (Generic, Show, Eq, Binary, NFData, Atomable)

60+ deriving (Generic, Show, Eq, NFData, Atomable)

61+ deriving Serialise via WineryVariant Test7A

46

62

47

63

48data Test7T = Test7C Test7A

64data Test7T = Test7C Test7A

49 deriving (Generic, Show, Eq)

65 deriving (Generic, Show, Eq)

66+ deriving Serialise via WineryVariant Test7T

50

67

51data Test8T = Test8C

68data Test8T = Test8C

52 deriving (Generic, Show, Eq)

69 deriving (Generic, Show, Eq)

70+ deriving Serialise via WineryVariant Test8T

53

71

54data Test9T = Test9C

72data Test9T = Test9C

55 {

73 {

@@ -58,6 +76,15 @@ data Test9T = Test9C

58 attr9C :: Double

76 attr9C :: Double

59 }

77 }

60 deriving (Generic, Show, Eq)

78 deriving (Generic, Show, Eq)

79+ deriving Serialise via WineryRecord Test9T

80+

81+data Test10T = Test10C {

82+ longAttrNameA10 :: Integer,

83+ long_attr_name_b10 :: Integer,

84+ longMixed_attr_NameC10 :: Integer

85+ }

86+ deriving (Generic, Show, Eq)

87+ deriving Serialise via WineryRecord Test10T

61

88

62instance Tupleable Test1T

89instance Tupleable Test1T

63

90

@@ -83,7 +110,7 @@ main = do

83 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

110 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

84

111

85testList :: Test

112testList :: Test

86−testList = TestList [testADT1, testADT2, testADT3, testADT4, testADT6, testADT7, testADT8, testInsertExpr, testDefineExpr, testUpdateExpr, testUpdateExprEmptyAttrs, testDeleteExpr, testUpdateExprWrongAttr, testReorderedTuple]

113+testList = TestList [testADT1, testADT2, testADT3, testADT4, testADT6, testADT7, testADT8 ,testInsertExpr, testDefineExpr, testUpdateExpr, testUpdateExprEmptyAttrs, testDeleteExpr, testUpdateExprWrongAttr, testReorderedTuple, testAddPrefixField, testDropPrefixField, testAddSuffixField, testDropSuffixField, testUpperCaseField, testLowerCaseField, testTitleCaseField, testCamelCaseField, testPascalCaseField, testSnakeCaseField, testSpinalCaseField, testTrainCaseField, testAsIsCodec, testAsIsField, testComposeRLCodec, testComposeRLField, testComposeLRCodec, testComposeLRField]

87

114

88testADT1 :: Test

115testADT1 :: Test

89testADT1 = TestCase $ assertEqual "one record constructor" (Right example) (fromTuple (toTuple example))

116testADT1 = TestCase $ assertEqual "one record constructor" (Right example) (fromTuple (toTuple example))

@@ -121,7 +148,7 @@ testADT7 :: Test

121testADT7 = TestCase $ do

148testADT7 = TestCase $ do

122 let example = Test7C (Test7AC 3)

149 let example = Test7C (Test7AC 3)

123 assertEqual "atom type" (Right example) (fromTuple (toTuple example))

150 assertEqual "atom type" (Right example) (fromTuple (toTuple example))

124− let expectedAttrs = V.singleton (Attribute "" (ConstructedAtomType "Test7A" M.empty))

151+ let expectedAttrs = A.singleton (Attribute "" (ConstructedAtomType "Test7A" M.empty))

125 assertEqual "adt atomtype" expectedAttrs (toAttributes (Proxy :: Proxy Test7T))

152 assertEqual "adt atomtype" expectedAttrs (toAttributes (Proxy :: Proxy Test7T))

126

153

127testADT8 :: Test

154testADT8 :: Test

@@ -195,8 +222,159 @@ testDeleteExpr = TestCase $ do

195testReorderedTuple :: Test

222testReorderedTuple :: Test

196testReorderedTuple = TestCase $ do

223testReorderedTuple = TestCase $ do

197 let tupleRev :: RelationTuple -> RelationTuple

224 let tupleRev :: RelationTuple -> RelationTuple

198− tupleRev (RelationTuple v1 v2) = RelationTuple (V.reverse v1) (V.reverse v2)

225+ tupleRev (RelationTuple v1 v2) = RelationTuple (revAttrs v1) (V.reverse v2)

226+ revAttrs attrs = A.attributesFromList (reverse (A.toList attrs))

199 expected = Test2C {attrB = 3,

227 expected = Test2C {attrB = 3,

200 attrC = 4}

228 attrC = 4}

201 actual = fromTuple . tupleRev . toTuple $ expected

229 actual = fromTuple . tupleRev . toTuple $ expected

202 assertEqual "reordered tuple" (Right expected) actual

230 assertEqual "reordered tuple" (Right expected) actual

231+

232+testCodec :: forall tag. ModifyOptions tag => String -> [AttributeName] -> Test

233+testCodec msg expected = TestCase $

234+ assertEqual msg (S.fromList expected) actual

235+ where

236+ actual = attributeNameSet $ toAttributes (Proxy :: Proxy (Codec tag Test10T))

237+

238+testAddPrefixField :: Test

239+testAddPrefixField = testCodec

240+ @(Field (AddPrefix "prefix_"))

241+ "codec field add prefix attributes"

242+ ["prefix_longAttrNameA10",

243+ "prefix_long_attr_name_b10",

244+ "prefix_longMixed_attr_NameC10"]

245+

246+testDropPrefixField :: Test

247+testDropPrefixField = testCodec

248+ @(Field (DropPrefix "long"))

249+ "codec field drop prefix"

250+ ["AttrNameA10",

251+ "_attr_name_b10",

252+ "Mixed_attr_NameC10"]

253+

254+testAddSuffixField :: Test

255+testAddSuffixField = testCodec

256+ @(Field (AddSuffix "_suffix"))

257+ "codec field add suffix"

258+ ["longAttrNameA10_suffix",

259+ "long_attr_name_b10_suffix",

260+ "longMixed_attr_NameC10_suffix"]

261+

262+testDropSuffixField :: Test

263+testDropSuffixField = testCodec

264+ @(Field (DropSuffix "10"))

265+ "codec field drop suffix"

266+ ["longAttrNameA",

267+ "long_attr_name_b",

268+ "longMixed_attr_NameC"]

269+

270+testUpperCaseField :: Test

271+testUpperCaseField = testCodec

272+ @(Field UpperCase)

273+ "codec field uppercase"

274+ ["LONGATTRNAMEA10",

275+ "LONG_ATTR_NAME_B10",

276+ "LONGMIXED_ATTR_NAMEC10"]

277+

278+testLowerCaseField :: Test

279+testLowerCaseField = testCodec

280+ @(Field LowerCase)

281+ "codec field lowercase"

282+ ["longattrnamea10",

283+ "long_attr_name_b10",

284+ "longmixed_attr_namec10"]

285+

286+testTitleCaseField :: Test

287+testTitleCaseField = testCodec

288+ @(Field TitleCase)

289+ "codec field title case"

290+ ["Long Attr Name A10",

291+ "Long Attr Name B10",

292+ "Long Mixed Attr Name C10"]

293+

294+testCamelCaseField :: Test

295+testCamelCaseField = testCodec

296+ @(Field CamelCase)

297+ "codec field camel case"

298+ ["longAttrNameA10",

299+ "longAttrNameB10",

300+ "longMixedAttrNameC10"]

301+

302+testPascalCaseField :: Test

303+testPascalCaseField = testCodec

304+ @(Field PascalCase)

305+ "codec field pascal case"

306+ ["LongAttrNameA10",

307+ "LongAttrNameB10",

308+ "LongMixedAttrNameC10"]

309+

310+testSnakeCaseField :: Test

311+testSnakeCaseField = testCodec

312+ @(Field SnakeCase)

313+ "codec field snake case"

314+ ["long_attr_name_a10",

315+ "long_attr_name_b10",

316+ "long_mixed_attr_name_c10"]

317+

318+testSpinalCaseField :: Test

319+testSpinalCaseField = testCodec

320+ @(Field SpinalCase)

321+ "codec field spinal case"

322+ ["long-attr-name-a10",

323+ "long-attr-name-b10",

324+ "long-mixed-attr-name-c10"]

325+

326+testTrainCaseField :: Test

327+testTrainCaseField = testCodec

328+ @(Field TrainCase)

329+ "codec field train case"

330+ ["Long-Attr-Name-A10",

331+ "Long-Attr-Name-B10",

332+ "Long-Mixed-Attr-Name-C10"]

333+

334+testAsIsCodec :: Test

335+testAsIsCodec = testCodec

336+ @AsIs

337+ "codec as is"

338+ ["longAttrNameA10",

339+ "long_attr_name_b10",

340+ "longMixed_attr_NameC10"]

341+

342+testAsIsField :: Test

343+testAsIsField = testCodec

344+ @(Field AsIs)

345+ "codec field as is"

346+ ["longAttrNameA10",

347+ "long_attr_name_b10",

348+ "longMixed_attr_NameC10"]

349+

350+testComposeRLCodec :: Test

351+testComposeRLCodec = testCodec

352+ @(Field UpperCase <<< Field (DropPrefix "long"))

353+ "codec (<<<)"

354+ ["ATTRNAMEA10",

355+ "_ATTR_NAME_B10",

356+ "MIXED_ATTR_NAMEC10"]

357+

358+testComposeRLField :: Test

359+testComposeRLField = testCodec

360+ @(Field (UpperCase <<< DropPrefix "long"))

361+ "codec field (<<<)"

362+ ["ATTRNAMEA10",

363+ "_ATTR_NAME_B10",

364+ "MIXED_ATTR_NAMEC10"]

365+

366+testComposeLRCodec :: Test

367+testComposeLRCodec = testCodec

368+ @(Field (DropPrefix "long") >>> Field UpperCase)

369+ "codec (>>>)"

370+ ["ATTRNAMEA10",

371+ "_ATTR_NAME_B10",

372+ "MIXED_ATTR_NAMEC10"]

373+

374+testComposeLRField :: Test

375+testComposeLRField = testCodec

376+ @(Field (DropPrefix "long" >>> UpperCase))

377+ "codec field (>>>)"

378+ ["ATTRNAMEA10",

379+ "_ATTR_NAME_B10",

380+ "MIXED_ATTR_NAMEC10"]

test/Server/Main.hs+24−23

@@ -5,7 +5,6 @@ test client/server interaction

5import Test.HUnit

6import ProjectM36.Client

7import qualified ProjectM36.Client as C

8−import ProjectM36.Server.EntryPoints

9import ProjectM36.Server

8import ProjectM36.Server

10import ProjectM36.Server.Config

9import ProjectM36.Server.Config

11import ProjectM36.Relation

10import ProjectM36.Relation

@@ -14,16 +13,8 @@ import ProjectM36.IsomorphicSchema

14import ProjectM36.Base

13import ProjectM36.Base

15

14

16import System.Exit

15import System.Exit

17−

16+import Network.Socket (SockAddr(..))

18import Control.Concurrent

17import Control.Concurrent

19−import Network.Transport (EndPointAddress)

20−

21−#if MIN_VERSION_network_transport_tcp(0,6,0)

22−import Network.Transport.TCP.Internal (encodeEndPointAddress, decodeEndPointAddress)

23−#else

24−import Network.Transport.TCP (encodeEndPointAddress, decodeEndPointAddress)

25−#endif

26−

27import Data.Either (isRight)

18import Data.Either (isRight)

28import Control.Exception

19import Control.Exception

29import System.IO.Temp

20import System.IO.Temp

@@ -32,6 +23,8 @@ import System.FilePath

32import System.Directory

23import System.Directory

33#endif

24#endif

34

25

26+type Timeout = Int

27+

35testList :: SessionId -> Connection -> MVar () -> Test

28testList :: SessionId -> Connection -> MVar () -> Test

36testList sessionId conn notificationTestMVar = TestList $ serverTests ++ sessionTests

29testList sessionId conn notificationTestMVar = TestList $ serverTests ++ sessionTests

37 where

30 where

@@ -49,7 +42,7 @@ testList sessionId conn notificationTestMVar = TestList $ serverTests ++ session

49 testRelationVariableSummary,

42 testRelationVariableSummary,

50 testNotification notificationTestMVar

43 testNotification notificationTestMVar

51 ]

44 ]

52− serverTests = [testRequestTimeout, testFileDescriptorCount]

45+ serverTests = [testRequestTimeout, testFileDescriptorCount, testClientConnectFail]

53

46

54main :: IO ()

47main :: IO ()

55main = do

48main = do

@@ -69,11 +62,9 @@ main = do

69testDatabaseName :: DatabaseName

62testDatabaseName :: DatabaseName

70testDatabaseName = "test"

63testDatabaseName = "test"

71

64

72−testConnection :: EndPointAddress -> MVar () -> IO (Either ConnectionError (SessionId, Connection))

65+testConnection :: Port -> MVar () -> IO (Either ConnectionError (SessionId, Connection))

73−testConnection serverAddress mvar = do

66+testConnection serverPort mvar = do

74− let Just (host, service, _) = decodeEndPointAddress serverAddress

75− serverAddress' = encodeEndPointAddress host service 1

76− let connInfo = RemoteProcessConnectionInfo testDatabaseName (NodeId serverAddress') (testNotificationCallback mvar)

67+ let connInfo = RemoteConnectionInfo testDatabaseName "127.0.0.1" (show serverPort) (testNotificationCallback mvar)

77 --putStrLn ("testConnection: " ++ show serverAddress)

68 --putStrLn ("testConnection: " ++ show serverAddress)

78 eConn <- connectProjectM36 connInfo

69 eConn <- connectProjectM36 connInfo

79 case eConn of

70 case eConn of

@@ -85,7 +76,7 @@ testConnection serverAddress mvar = do

85 Right sessionId -> pure $ Right (sessionId, conn)

76 Right sessionId -> pure $ Right (sessionId, conn)

86

77

87-- | A version of 'launchServer' which returns the port on which the server is listening on a secondary thread

78-- | A version of 'launchServer' which returns the port on which the server is listening on a secondary thread

88−launchTestServer :: Timeout -> IO (EndPointAddress, ThreadId)

79+launchTestServer :: Timeout -> IO (Port, ThreadId)

89launchTestServer ti = do

80launchTestServer ti = do

90 addressMVar <- newEmptyMVar

81 addressMVar <- newEmptyMVar

91 tid <- forkIO $

82 tid <- forkIO $

@@ -94,13 +85,14 @@ launchTestServer ti = do

94 persistenceStrategy = CrashSafePersistence (tempdir </> "db"),

85 persistenceStrategy = CrashSafePersistence (tempdir </> "db"),

95 perRequestTimeout = ti,

86 perRequestTimeout = ti,

96 testMode = True,

87 testMode = True,

97− bindPort = 0

88+ bindPort = 0,

89+ checkFS = False --not stricly needed for these tests

98 }

90 }

99

91

100 launchServer config (Just addressMVar) >> pure ()

92 launchServer config (Just addressMVar) >> pure ()

101− endPointAddress <- takeMVar addressMVar

93+ (SockAddrInet port _) <- takeMVar addressMVar

102 --liftIO $ putStrLn ("launched server on " ++ show endPointAddress)

94 --liftIO $ putStrLn ("launched server on " ++ show endPointAddress)

103− pure (endPointAddress, tid)

95+ pure (fromIntegral port, tid)

104

96

105testRelationalExpr :: SessionId -> Connection -> Test

97testRelationalExpr :: SessionId -> Connection -> Test

106testRelationalExpr sessionId conn = TestCase $ do

98testRelationalExpr sessionId conn = TestCase $ do

@@ -146,10 +138,11 @@ testPlanForDatabaseContextExpr sessionId conn = TestCase $ do

146 let attrExprs = [AttributeAndTypeNameExpr "x" (PrimitiveTypeConstructor "Int" IntAtomType) ()]

138 let attrExprs = [AttributeAndTypeNameExpr "x" (PrimitiveTypeConstructor "Int" IntAtomType) ()]

147 testrv = "testrv"

139 testrv = "testrv"

148 dbExpr = Define testrv attrExprs

140 dbExpr = Define testrv attrExprs

141+ expected = Define testrv [AttributeAndTypeNameExpr "x" (PrimitiveTypeConstructor "Int" IntAtomType) UncommittedContextMarker]

149 planResult <- planForDatabaseContextExpr sessionId conn dbExpr

142 planResult <- planForDatabaseContextExpr sessionId conn dbExpr

150 case planResult of

143 case planResult of

151 Left err -> assertFailure (show err)

144 Left err -> assertFailure (show err)

152− Right plan -> assertEqual "planForDatabaseContextExpr failure" dbExpr plan

145+ Right plan -> assertEqual "planForDatabaseContextExpr failure" expected plan

153

146

154testTransactionGraphAsRelation :: SessionId -> Connection -> Test

147testTransactionGraphAsRelation :: SessionId -> Connection -> Test

155testTransactionGraphAsRelation sessionId conn = TestCase $ do

148testTransactionGraphAsRelation sessionId conn = TestCase $ do

@@ -215,7 +208,7 @@ testRequestTimeout = TestCase $ do

215 Left err -> putStrLn ("failed to connect: " ++ show err) >> exitFailure

208 Left err -> putStrLn ("failed to connect: " ++ show err) >> exitFailure

216 Right (session, testConn) -> do

209 Right (session, testConn) -> do

217 res <- catchJust (\exc -> if exc == RequestTimeoutException then Just exc else Nothing) (callTestTimeout_ session testConn) (const (pure False))

210 res <- catchJust (\exc -> if exc == RequestTimeoutException then Just exc else Nothing) (callTestTimeout_ session testConn) (const (pure False))

218− assertBool "exception was not thrown" (not res)

211+ assertBool "timeout exception was not thrown" (not res)

219 killThread serverTid

212 killThread serverTid

220

213

221testFileDescriptorCount :: Test

214testFileDescriptorCount :: Test

@@ -244,4 +237,12 @@ fdCount = do

244#else

237#else

245--pass on non-linux platforms

238--pass on non-linux platforms

246testFileDescriptorCount = TestCase (pure ())

239testFileDescriptorCount = TestCase (pure ())

247−#endif

240+#endif

241+

242+testClientConnectFail :: Test

243+testClientConnectFail = TestCase $ do

244+ let connInfo = RemoteConnectionInfo "nonexistentdb" "127.0.0.1" "7777" emptyNotificationCallback

245+ eConn <- connectProjectM36 connInfo

246+ case eConn of

247+ Left (IOExceptionError _) -> pure ()

248+ _ -> assertFailure "connection failure failed"

test/Server/WebSocket.hs+8−12

@@ -18,12 +18,6 @@ import Data.Aeson

18import qualified Data.Map as M

19import qualified Data.ByteString.Lazy as BS

20import ProjectM36.Relation

21−#if MIN_VERSION_network_transport_tcp(0,6,0)

22−import Network.Transport.TCP.Internal (decodeEndPointAddress)

23−#else

24−import Network.Transport.TCP (decodeEndPointAddress)

25−#endif

26−

27

21

28--start the websocket server

22--start the websocket server

29-- run some tutoriald against it

23-- run some tutoriald against it

@@ -32,16 +26,17 @@ launchTestServer :: IO (PortNumber, DatabaseName)

32launchTestServer = do

26launchTestServer = do

33 addressMVar <- newEmptyMVar

27 addressMVar <- newEmptyMVar

34 let config = defaultServerConfig { databaseName = testDatabaseName,

28 let config = defaultServerConfig { databaseName = testDatabaseName,

35− bindPort = 0 }

29+ bindPort = 0,

30+ checkFS = False}

36 testDatabaseName = "test"

31 testDatabaseName = "test"

37 -- start normal server

32 -- start normal server

38 _ <- forkIO (launchServer config (Just addressMVar) >> pure ())

33 _ <- forkIO (launchServer config (Just addressMVar) >> pure ())

39− serverAddress <- takeMVar addressMVar

34+ (SockAddrInet dbPort _) <- takeMVar addressMVar

40 let wsServerHost = "127.0.0.1"

35 let wsServerHost = "127.0.0.1"

41 wsServerPort = 8889

36 wsServerPort = 8889

42− Just (dbHost, dbPort, _) = decodeEndPointAddress serverAddress

37+ dbHost = "127.0.0.1"

43 -- start websocket server proxy -- runServer doesn't support returning an arbitrary socket

38 -- start websocket server proxy -- runServer doesn't support returning an arbitrary socket

44− _ <- forkIO (WS.runServer wsServerHost wsServerPort (websocketProxyServer (read dbPort) dbHost))

39+ _ <- forkIO (WS.runServer wsServerHost wsServerPort (websocketProxyServer (fromIntegral dbPort) dbHost))

45 --wait for socket to be listening

40 --wait for socket to be listening

46 waitForListenSocket 5 (fromIntegral wsServerPort)

41 waitForListenSocket 5 (fromIntegral wsServerPort)

47 pure (fromIntegral wsServerPort, testDatabaseName)

42 pure (fromIntegral wsServerPort, testDatabaseName)

@@ -56,13 +51,14 @@ waitForListenSocket secondsToTry port =

56 if secondsToTry <= 0 then

51 if secondsToTry <= 0 then

57 throw WaitForSocketListenException

52 throw WaitForSocketListenException

58 else do

53 else do

59− hostaddr <- inet_addr "127.0.0.1"

54+ --hostaddr <- inet_addr "127.0.0.1"

55+ hostaddr:_ <- getAddrInfo Nothing (Just "127.0.0.1") (Just (show port))

60 sock <- socket AF_INET Stream defaultProtocol

56 sock <- socket AF_INET Stream defaultProtocol

61 let handler :: IOException -> IO ()

57 let handler :: IOException -> IO ()

62 handler _ = do

58 handler _ = do

63 threadDelay 1000000

59 threadDelay 1000000

64 waitForListenSocket (secondsToTry - 1) port

60 waitForListenSocket (secondsToTry - 1) port

65− catch (connect sock (SockAddrInet port hostaddr)) handler

61+ catch (connect sock (addrAddress hostaddr)) handler

66

62

67main :: IO ()

63main :: IO ()

68main = do

64main = do

test/TransactionGraph/Merge.hs+70−39

@@ -4,15 +4,28 @@ import ProjectM36.Base

4import ProjectM36.Attribute

5import ProjectM36.Relation

6import ProjectM36.Transaction

7+import ProjectM36.TransactionInfo as TI

7import ProjectM36.TransactionGraph

8import ProjectM36.TransactionGraph

8import ProjectM36.Error

9import ProjectM36.Error

9import ProjectM36.Key

10import ProjectM36.Key

10import qualified ProjectM36.DisconnectedTransaction as Discon

11import qualified ProjectM36.DisconnectedTransaction as Discon

11import qualified ProjectM36.DatabaseContext as DBC

12import qualified ProjectM36.DatabaseContext as DBC

12import ProjectM36.RelationalExpression

13import ProjectM36.RelationalExpression

14+import ProjectM36.StaticOptimizer

13

15

14import qualified Data.ByteString.Lazy as BS

16import qualified Data.ByteString.Lazy as BS

15import System.Exit

17import System.Exit

18+

19+

20+

21+

22+

23+

24+

25+

26+

27+

28+

16import Data.Word

29import Data.Word

17import qualified Data.UUID as U

30import qualified Data.UUID as U

18import qualified Data.Set as S

31import qualified Data.Set as S

@@ -21,8 +34,6 @@ import Data.Maybe

21import Data.Time.Clock

34import Data.Time.Clock

22import Data.Time.Calendar

35import Data.Time.Calendar

23

36

24−import Control.Monad.State

25−

26{-# ANN module ("HLint: ignore Reduce duplication" :: String) #-}

37{-# ANN module ("HLint: ignore Reduce duplication" :: String) #-}

27

38

28testTime :: UTCTime

39testTime :: UTCTime

@@ -62,8 +73,8 @@ basicTransactionGraph = do

62 uuidB = fakeUUID 11

73 uuidB = fakeUUID 11

63 uuidRoot = fakeUUID 1

74 uuidRoot = fakeUUID 1

64 rootContext = concreteDatabaseContext rootTrans

75 rootContext = concreteDatabaseContext rootTrans

65− (_, bsGraph') <- addTransaction "branchA" (createTrans uuidA (TransactionInfo uuidRoot S.empty testTime) rootContext) bsGraph

76+ (_, bsGraph') <- addTransaction "branchA" (createTrans uuidA (TI.singleParent uuidRoot testTime) rootContext) bsGraph

66− (_, bsGraph'') <- addTransaction "branchB" (createTrans uuidB (TransactionInfo uuidRoot S.empty testTime) rootContext) bsGraph'

77+ (_, bsGraph'') <- addTransaction "branchB" (createTrans uuidB (TI.singleParent uuidRoot testTime) rootContext) bsGraph'

67 pure bsGraph''

78 pure bsGraph''

68

79

69addTransaction :: HeadName -> Transaction -> TransactionGraph -> IO (Transaction, TransactionGraph)

80addTransaction :: HeadName -> Transaction -> TransactionGraph -> IO (Transaction, TransactionGraph)

@@ -107,7 +118,7 @@ testSubGraphToFirstAncestorSnipBranch = TestCase $ do

107 baseGraph <- basicTransactionGraph

118 baseGraph <- basicTransactionGraph

108 transA <- assertMaybe (transactionForHead "branchA" baseGraph) "failed to get branchA"

119 transA <- assertMaybe (transactionForHead "branchA" baseGraph) "failed to get branchA"

109 transB <- assertMaybe (transactionForHead "branchB" baseGraph) "failed to get branchB"

120 transB <- assertMaybe (transactionForHead "branchB" baseGraph) "failed to get branchB"

110− (_, graph) <- addTransaction "branchC" (createTrans (fakeUUID 12) (TransactionInfo (fakeUUID 1) S.empty testTime) (concreteDatabaseContext transA)) baseGraph

121+ (_, graph) <- addTransaction "branchC" (createTrans (fakeUUID 12) (TI.singleParent (fakeUUID 1) testTime) (concreteDatabaseContext transA)) baseGraph

111 subgraph <- assertEither $ subGraphOfFirstCommonAncestor graph (transactionHeadsForGraph baseGraph) transA transB S.empty

122 subgraph <- assertEither $ subGraphOfFirstCommonAncestor graph (transactionHeadsForGraph baseGraph) transA transB S.empty

112 assertGraph subgraph

123 assertGraph subgraph

113 let graphEq graphArg = S.map transactionId (transactionsForGraph graphArg)

124 let graphEq graphArg = S.map transactionId (transactionsForGraph graphArg)

@@ -121,16 +132,18 @@ testSubGraphToFirstAncestorMoreTransactions = TestCase $ do

121

132

122-- add another relvar to branchB

133-- add another relvar to branchB

123 branchBTrans <- assertMaybe (transactionForHead "branchB" graph) "failed to get branchB head"

134 branchBTrans <- assertMaybe (transactionForHead "branchB" graph) "failed to get branchB head"

135+ let env = mkDatabaseContextEvalEnv (transactionId branchBTrans) graph

136+ branchBContext = concreteDatabaseContext branchBTrans

124− (updatedBranchBContext,_,_) <- case runState (evalDatabaseContextExpr (Assign "branchBOnlyRelvar" (ExistingRelation relationTrue))) (freshDatabaseState (concreteDatabaseContext branchBTrans)) of

137+ updatedBranchBContext <- case runDatabaseContextEvalMonad branchBContext env (optimizeAndEvalDatabaseContextExpr True (Assign "branchBOnlyRelvar" (ExistingRelation relationTrue))) of

125− (Left err, _) -> assertFailure (show err) >> undefined

138+ Left err -> assertFailure (show err) >> undefined

126− (Right (), context) -> pure context

139+ Right st -> pure $ dbc_context st

127− (_, graph') <- addTransaction "branchB" (createTrans (fakeUUID 3) (TransactionInfo (transactionId branchBTrans) S.empty testTime) updatedBranchBContext) graph

140+ (_, graph') <- addTransaction "branchB" (createTrans (fakeUUID 3) (TI.singleParent (transactionId branchBTrans) testTime) updatedBranchBContext) graph

128 branchBTrans' <- assertMaybe (transactionForHead "branchB" graph') "failed to get branchB head"

141 branchBTrans' <- assertMaybe (transactionForHead "branchB" graph') "failed to get branchB head"

129 assertEqual "branchB id 3" (fakeUUID 3) (transactionId branchBTrans')

142 assertEqual "branchB id 3" (fakeUUID 3) (transactionId branchBTrans')

130

143

131 -- add another transaction to branchA

144 -- add another transaction to branchA

132 branchATrans <- assertMaybe (transactionForHead "branchA" graph) "failed to get branchA head"

145 branchATrans <- assertMaybe (transactionForHead "branchA" graph) "failed to get branchA head"

133− (_, graph'') <- addTransaction "branchA" (createTrans (fakeUUID 4) (TransactionInfo (transactionId branchATrans) S.empty testTime) (concreteDatabaseContext branchATrans)) graph'

146+ (_, graph'') <- addTransaction "branchA" (createTrans (fakeUUID 4) (TI.singleParent (transactionId branchATrans) testTime) (concreteDatabaseContext branchATrans)) graph'

134 branchATrans' <- assertMaybe (transactionForHead "branchA" graph'') "failed to get branchA head"

147 branchATrans' <- assertMaybe (transactionForHead "branchA" graph'') "failed to get branchA head"

135 assertEqual "branchA id 4" (fakeUUID 4) (transactionId branchATrans')

148 assertEqual "branchA id 4" (fakeUUID 4) (transactionId branchATrans')

136

149

@@ -148,12 +161,15 @@ testSelectedBranchMerge = TestCase $ do

148

161

149 -- add another relvar to branchB

162 -- add another relvar to branchB

150 branchBTrans <- assertMaybe (transactionForHead "branchB" graph) "failed to get branchB head"

163 branchBTrans <- assertMaybe (transactionForHead "branchB" graph) "failed to get branchB head"

151− (updatedBranchBContext,_,_) <- case runState (evalDatabaseContextExpr (Assign "branchBOnlyRelvar" (ExistingRelation relationTrue))) (freshDatabaseState (concreteDatabaseContext branchBTrans)) of

164+ let env = mkDatabaseContextEvalEnv (transactionId branchBTrans) graph

165+ branchBContext = concreteDatabaseContext branchBTrans

166+ updatedBranchBContext <- case runDatabaseContextEvalMonad branchBContext env (optimizeAndEvalDatabaseContextExpr True (Assign "branchBOnlyRelvar" (ExistingRelation relationTrue))) of

152− (Left err, _) -> assertFailure (show err) >> undefined

167+ Left err -> assertFailure (show err) >> undefined

153− (Right (), context) -> pure context

168+ Right st -> pure (dbc_context st)

154− (_, graph') <- addTransaction "branchB" (createTrans (fakeUUID 3) (TransactionInfo (transactionId branchBTrans) S.empty testTime) updatedBranchBContext) graph

169+ (_, graph') <- addTransaction "branchB" (createTrans (fakeUUID 3) (TI.singleParent (transactionId branchBTrans) testTime) updatedBranchBContext) graph

155 --create the merge transaction in the graph

170 --create the merge transaction in the graph

156− let eGraph' = mergeTransactions testTime (fakeUUID 4) (fakeUUID 10) (SelectedBranchMergeStrategy "branchA") ("branchA", "branchB") graph'

171+ let eGraph' = runGraphRefRelationalExprM gfEnv $ mergeTransactions testTime (fakeUUID 4) (fakeUUID 10) (SelectedBranchMergeStrategy "branchA") ("branchA", "branchB")

172+ gfEnv = freshGraphRefRelationalExprEnv Nothing graph'

157

173

158 (_, graph'') <- assertEither eGraph'

174 (_, graph'') <- assertEither eGraph'

159

175

@@ -175,18 +191,22 @@ testUnionPreferMergeStrategy = TestCase $ do

175 branchBTrans <- assertMaybe (transactionForHead "branchB" graph) "branchBTrans"

191 branchBTrans <- assertMaybe (transactionForHead "branchB" graph) "branchBTrans"

176 branchBRelVar <- assertEither $ mkRelationFromList (attributesFromList [Attribute "conflict" IntAtomType]) []

192 branchBRelVar <- assertEither $ mkRelationFromList (attributesFromList [Attribute "conflict" IntAtomType]) []

177 let branchAContext = (concreteDatabaseContext branchATrans) {relationVariables = M.insert conflictRelVarName branchARelVar (relationVariables (concreteDatabaseContext branchATrans))}

193 let branchAContext = (concreteDatabaseContext branchATrans) {relationVariables = M.insert conflictRelVarName branchARelVar (relationVariables (concreteDatabaseContext branchATrans))}

178− branchARelVar = relationTrue

194+ branchARelVar = ExistingRelation relationTrue

179− branchBContext = (concreteDatabaseContext branchBTrans) {relationVariables = M.insert conflictRelVarName branchBRelVar (relationVariables (concreteDatabaseContext branchBTrans))}

195+ branchBContext = (concreteDatabaseContext branchBTrans) {relationVariables = M.insert conflictRelVarName (ExistingRelation branchBRelVar) (relationVariables (concreteDatabaseContext branchBTrans))}

180− conflictRelVarName = "conflictRelVar"

196+ conflictRelVarName = "conflictRelVar"

181

197

182− (_, graph') <- addTransaction "branchA" (createTrans (fakeUUID 3) (TransactionInfo (transactionId branchATrans) S.empty testTime) branchAContext) graph

198+ (_, graph') <- addTransaction "branchA" (createTrans (fakeUUID 3) (TI.singleParent (transactionId branchATrans) testTime) branchAContext) graph

183− (_, graph'') <- addTransaction "branchB" (createTrans (fakeUUID 4) (TransactionInfo (transactionId branchBTrans) S.empty testTime) branchBContext) graph'

199+ (_, graph'') <- addTransaction "branchB" (createTrans (fakeUUID 4) (TI.singleParent (transactionId branchBTrans) testTime) branchBContext) graph'

184 -- validate that the conflict is hidden because we preferred a branch

200 -- validate that the conflict is hidden because we preferred a branch

185− let merged = mergeTransactions testTime (fakeUUID 5) (fakeUUID 3) (UnionPreferMergeStrategy "branchB") ("branchA", "branchB") graph''

201+ let merged = runGraphRefRelationalExprM env $ mergeTransactions testTime (fakeUUID 5) (fakeUUID 3) (UnionPreferMergeStrategy "branchB") ("branchA", "branchB")

202+ env = freshGraphRefRelationalExprEnv Nothing graph''

186 case merged of

203 case merged of

187 Left err -> assertFailure ("expected merge success: " ++ show err)

204 Left err -> assertFailure ("expected merge success: " ++ show err)

188− Right (discon, _) ->

205+ Right (discon, _) -> do

206+ let Just rvExpr = M.lookup conflictRelVarName (relationVariables (Discon.concreteDatabaseContext discon))

207+ reEnv = freshGraphRefRelationalExprEnv (Just (Discon.concreteDatabaseContext discon)) graph

208+ let eRvRel = runGraphRefRelationalExprM reEnv (evalGraphRefRelationalExpr rvExpr)

189− assertEqual "branchB relvar preferred in conflict" (Just branchBRelVar) (M.lookup conflictRelVarName (relationVariables (Discon.concreteDatabaseContext discon)))

209+ assertEqual "branchB relvar preferred in conflict" (Right branchBRelVar) eRvRel

190

210

191-- try various individual component conflicts and check for merge failure

211-- try various individual component conflicts and check for merge failure

192testUnionMergeStrategy :: Test

212testUnionMergeStrategy :: Test

@@ -201,31 +221,41 @@ testUnionMergeStrategy = TestCase $ do

201

221

202 let updatedBranchBContext = (concreteDatabaseContext branchBTrans) {relationVariables = M.insert branchBOnlyRelVarName branchBOnlyRelVar (relationVariables (concreteDatabaseContext branchBTrans)) }

222 let updatedBranchBContext = (concreteDatabaseContext branchBTrans) {relationVariables = M.insert branchBOnlyRelVarName branchBOnlyRelVar (relationVariables (concreteDatabaseContext branchBTrans)) }

203 updatedBranchAContext = (concreteDatabaseContext branchATrans) {inclusionDependencies = M.insert branchAOnlyIncDepName branchAOnlyIncDep (inclusionDependencies (concreteDatabaseContext branchATrans)) }

223 updatedBranchAContext = (concreteDatabaseContext branchATrans) {inclusionDependencies = M.insert branchAOnlyIncDepName branchAOnlyIncDep (inclusionDependencies (concreteDatabaseContext branchATrans)) }

204− branchBOnlyRelVar = relationTrue

224+ branchBOnlyRelVar = ExistingRelation relationTrue

205 branchAOnlyIncDepName = "branchAOnlyIncDep"

225 branchAOnlyIncDepName = "branchAOnlyIncDep"

206 branchBOnlyRelVarName = "branchBOnlyRelVar"

226 branchBOnlyRelVarName = "branchBOnlyRelVar"

207 branchAOnlyIncDep = InclusionDependency (ExistingRelation relationTrue) (ExistingRelation relationTrue)

227 branchAOnlyIncDep = InclusionDependency (ExistingRelation relationTrue) (ExistingRelation relationTrue)

208− (_, graph') <- addTransaction "branchB" (createTrans (fakeUUID 3) (TransactionInfo (transactionId branchBTrans) S.empty testTime) updatedBranchBContext) graph

228+ (_, graph') <- addTransaction "branchB" (createTrans (fakeUUID 3) (TI.singleParent (transactionId branchBTrans) testTime) updatedBranchBContext) graph

229+ let env = freshGraphRefRelationalExprEnv Nothing graph'

209− (discon, _) <- assertEither $ mergeTransactions testTime (fakeUUID 5) (fakeUUID 10) UnionMergeStrategy ("branchA", "branchB") graph'

230+ (discon, _) <- assertEither $ runGraphRefRelationalExprM env $ mergeTransactions testTime (fakeUUID 5) (fakeUUID 10) UnionMergeStrategy ("branchA", "branchB")

231+ let Just rvExpr = M.lookup branchBOnlyRelVarName (relationVariables (Discon.concreteDatabaseContext discon))

232+ Right rvRel = runGraphRefRelationalExprM reEnv (evalGraphRefRelationalExpr rvExpr)

233+ reEnv = freshGraphRefRelationalExprEnv (Just (Discon.concreteDatabaseContext discon)) graph

234+

210− assertEqual "branchBOnlyRelVar should appear in the merge" (M.lookup branchBOnlyRelVarName (relationVariables (Discon.concreteDatabaseContext discon))) (Just relationTrue)

235+ assertEqual "branchBOnlyRelVar should appear in the merge" relationTrue rvRel

211− (_, graph'') <- addTransaction "branchA" (createTrans (fakeUUID 4) (TransactionInfo (transactionId branchATrans) S.empty testTime) updatedBranchAContext) graph'

236+ (_, graph'') <- addTransaction "branchA" (createTrans (fakeUUID 4) (TI.singleParent (transactionId branchATrans) testTime) updatedBranchAContext) graph'

212− let eMergeGraph = mergeTransactions testTime (fakeUUID 5) (fakeUUID 3) UnionMergeStrategy ("branchA", "branchB") graph''

237+ let eMergeGraph = runGraphRefRelationalExprM gfEnv $ mergeTransactions testTime (fakeUUID 5) (fakeUUID 3) UnionMergeStrategy ("branchA", "branchB")

238+ gfEnv = freshGraphRefRelationalExprEnv Nothing graph''

213 case eMergeGraph of

239 case eMergeGraph of

214 Left err -> assertFailure ("expected merge success: " ++ show err)

240 Left err -> assertFailure ("expected merge success: " ++ show err)

215 Right (_, mergeGraph) -> do

241 Right (_, mergeGraph) -> do

216 -- check that the new merge transaction has the correct parents

242 -- check that the new merge transaction has the correct parents

217 mergeTrans <- assertEither $ transactionForId (fakeUUID 5) mergeGraph

243 mergeTrans <- assertEither $ transactionForId (fakeUUID 5) mergeGraph

218 let mergeContext = concreteDatabaseContext mergeTrans

244 let mergeContext = concreteDatabaseContext mergeTrans

219− assertEqual "merge transaction parents" (transactionParentIds mergeTrans) (S.fromList [fakeUUID 3, fakeUUID 4])

245+ assertEqual "merge transaction parents" (parentIds mergeTrans) (S.fromList [fakeUUID 3, fakeUUID 4])

220 -- check that the new merge tranasction has elements from both A and B branches

246 -- check that the new merge tranasction has elements from both A and B branches

221− assertEqual "merge transaction relvars" (Just relationTrue) (M.lookup branchBOnlyRelVarName (relationVariables mergeContext))

247+ let Just rvExpr' = M.lookup branchBOnlyRelVarName (relationVariables mergeContext)

248+ Right rvRel' = runGraphRefRelationalExprM reEnv' (evalGraphRefRelationalExpr rvExpr')

249+ reEnv' = freshGraphRefRelationalExprEnv (Just mergeContext) graph

250+ assertEqual "merge transaction relvars" relationTrue rvRel'

222 assertEqual "merge transaction incdeps" (Just branchAOnlyIncDep) (M.lookup branchAOnlyIncDepName (inclusionDependencies mergeContext))

251 assertEqual "merge transaction incdeps" (Just branchAOnlyIncDep) (M.lookup branchAOnlyIncDepName (inclusionDependencies mergeContext))

223 -- test an expected conflict- add branchBOnlyRelVar with same name but different attributes

252 -- test an expected conflict- add branchBOnlyRelVar with same name but different attributes

224 conflictRelVar <- assertEither $ mkRelationFromList (attributesFromList [Attribute "conflict" IntAtomType]) []

253 conflictRelVar <- assertEither $ mkRelationFromList (attributesFromList [Attribute "conflict" IntAtomType]) []

225− let conflictContextA = updatedBranchAContext {relationVariables = M.insert branchBOnlyRelVarName conflictRelVar (relationVariables updatedBranchAContext) }

254+ let conflictContextA = updatedBranchAContext {relationVariables = M.insert branchBOnlyRelVarName (ExistingRelation conflictRelVar) (relationVariables updatedBranchAContext) }

226 conflictBranchATrans <- assertMaybe (transactionForHead "branchA" graph'') "retrieving head transaction for expected conflict"

255 conflictBranchATrans <- assertMaybe (transactionForHead "branchA" graph'') "retrieving head transaction for expected conflict"

227− (_, graph''') <- addTransaction "branchA" (createTrans (fakeUUID 6) (TransactionInfo (transactionId conflictBranchATrans) S.empty testTime) conflictContextA) graph''

256+ (_, graph''') <- addTransaction "branchA" (createTrans (fakeUUID 6) (TI.singleParent (transactionId conflictBranchATrans) testTime) conflictContextA) graph''

228− let failingMerge = mergeTransactions testTime (fakeUUID 5) (fakeUUID 3) UnionMergeStrategy ("branchA", "branchB") graph'''

257+ let failingMerge = runGraphRefRelationalExprM gfEnv' $ mergeTransactions testTime (fakeUUID 5) (fakeUUID 3) UnionMergeStrategy ("branchA", "branchB")

258+ gfEnv' = freshGraphRefRelationalExprEnv Nothing graph'''

229 case failingMerge of

259 case failingMerge of

230 Right _ -> assertFailure "expected merge failure"

260 Right _ -> assertFailure "expected merge failure"

231 Left err -> assertEqual "merge failure" err (MergeTransactionError StrategyViolatesRelationVariableMergeError)

261 Left err -> assertEqual "merge failure" err (MergeTransactionError StrategyViolatesRelationVariableMergeError)

@@ -244,20 +274,21 @@ testUnionMergeIncDepViolation = TestCase $ do

244 rvName = "x"

274 rvName = "x"

245 Right branchArv = eRel 2

275 Right branchArv = eRel 2

246 Right branchBrv = eRel 3

276 Right branchBrv = eRel 3

247− branchAContext = (concreteDatabaseContext branchBTrans) {relationVariables = M.singleton rvName branchArv}

277+ branchAContext = (concreteDatabaseContext branchBTrans) {relationVariables = M.singleton rvName (ExistingRelation branchArv)}

248− branchBContext = (concreteDatabaseContext branchBTrans) {relationVariables = M.singleton rvName branchBrv,

278+ branchBContext = (concreteDatabaseContext branchBTrans) {relationVariables = M.singleton rvName (ExistingRelation branchBrv),

249 inclusionDependencies = M.singleton incDepName incDep}

279 inclusionDependencies = M.singleton incDepName incDep}

250 incDepName = "x_key"

280 incDepName = "x_key"

251 incDep = inclusionDependencyForKey (AttributeNames (S.singleton "x")) (RelationVariable "x" ())

281 incDep = inclusionDependencyForKey (AttributeNames (S.singleton "x")) (RelationVariable "x" ())

252

282

253

283

254 --add the rv in new commits to both branches

284 --add the rv in new commits to both branches

255− (_, graph') <- addTransaction "branchB" (createTrans (fakeUUID 3) (TransactionInfo (transactionId branchBTrans) S.empty testTime) branchBContext) graph

285+ (_, graph') <- addTransaction "branchB" (createTrans (fakeUUID 3) (TI.singleParent (transactionId branchBTrans) testTime) branchBContext) graph

256

286

257− (_, graph'') <- addTransaction "branchA" (createTrans (fakeUUID 4) (TransactionInfo (transactionId branchATrans) S.empty testTime) branchAContext) graph'

287+ (_, graph'') <- addTransaction "branchA" (createTrans (fakeUUID 4) (TI.singleParent (transactionId branchATrans) testTime) branchAContext) graph'

258

288

259 --check that the union merge fails due to a violated constraint

289 --check that the union merge fails due to a violated constraint

260− let eMerge = mergeTransactions testTime (fakeUUID 5) (fakeUUID 3) UnionMergeStrategy ("branchA", "branchB") graph''

290+ let eMerge = runGraphRefRelationalExprM env $ mergeTransactions testTime (fakeUUID 5) (fakeUUID 3) UnionMergeStrategy ("branchA", "branchB")

291+ env = freshGraphRefRelationalExprEnv Nothing graph''

261 case eMerge of

292 case eMerge of

262 Left (InclusionDependencyCheckError incDepName') -> assertEqual "incdep violation name" incDepName incDepName'

293 Left (InclusionDependencyCheckError incDepName') -> assertEqual "incdep violation name" incDepName incDepName'

263 Left err -> assertFailure ("other error: " ++ show err)

294 Left err -> assertFailure ("other error: " ++ show err)

test/TransactionGraph/Persist.hs+79−15

@@ -1,14 +1,14 @@

1+{-# LANGUAGE CPP #-}

1import Test.HUnit

2import Test.HUnit

2import ProjectM36.Base

3import ProjectM36.Base

3import ProjectM36.Persist (DiskSync(NoDiskSync))

4import ProjectM36.Persist (DiskSync(NoDiskSync))

4import ProjectM36.TransactionGraph.Persist

5import ProjectM36.TransactionGraph.Persist

5−import ProjectM36.TransactionGraph

6+import ProjectM36.TransactionGraph as TG

6import ProjectM36.Transaction

7import ProjectM36.Transaction

7import ProjectM36.DateExamples

8import ProjectM36.DateExamples

8−import ProjectM36.Client

9−import ProjectM36.Relation

10import System.IO.Temp

9import System.IO.Temp

11import System.Exit

10import System.Exit

11+import System.Directory

12import Data.Either

13import Data.UUID.V4 (nextRandom)

14import System.FilePath

@@ -17,6 +17,9 @@ import qualified Data.Map as M

17import qualified Data.Set as S

18import Data.Time.Clock

19import Data.Time.Calendar

20+import ProjectM36.Client as C

21+import ProjectM36.Relation

22+import ProjectM36.Transaction.Persist

20

23

21main :: IO ()

24main :: IO ()

22main = do

25main = do

@@ -26,11 +29,12 @@ main = do

26testList :: Test

29testList :: Test

27testList = TestList [testBootstrapDB,

30testList = TestList [testBootstrapDB,

28 testDBSimplePersistence,

31 testDBSimplePersistence,

29− testFunctionPersistence]

32+ testFunctionPersistence,

33+ testMerkleHashValidation]

30

34

31

35

32−stamp :: UTCTime

36+stamp' :: UTCTime

33−stamp = UTCTime (fromGregorian 1980 01 01) (secondsToDiffTime 1000)

37+stamp' = UTCTime (fromGregorian 1980 01 01) (secondsToDiffTime 1000)

34

38

35{- bootstrap a database, ensure that it can be read -}

39{- bootstrap a database, ensure that it can be read -}

36testBootstrapDB :: Test

40testBootstrapDB :: Test

@@ -38,7 +42,7 @@ testBootstrapDB = TestCase $ withSystemTempDirectory "m36testdb" $ \tempdir -> d

38 let dbdir = tempdir </> "dbdir"

42 let dbdir = tempdir </> "dbdir"

39 freshId <- nextRandom

43 freshId <- nextRandom

40

44

41− _ <- bootstrapDatabaseDir NoDiskSync dbdir (bootstrapTransactionGraph stamp freshId dateExamples)

45+ _ <- bootstrapDatabaseDir NoDiskSync dbdir (bootstrapTransactionGraph stamp' freshId dateExamples)

42 loadedGraph <- transactionGraphLoad dbdir emptyTransactionGraph Nothing

46 loadedGraph <- transactionGraphLoad dbdir emptyTransactionGraph Nothing

43 assertBool "transactionGraphLoad" $ isRight loadedGraph

47 assertBool "transactionGraphLoad" $ isRight loadedGraph

44

48

@@ -48,17 +52,17 @@ testDBSimplePersistence = TestCase $ withSystemTempDirectory "m36testdb" $ \temp

48 let dbdir = tempdir </> "dbdir"

52 let dbdir = tempdir </> "dbdir"

49 freshId <- nextRandom

53 freshId <- nextRandom

50

54

51− let graph = bootstrapTransactionGraph stamp freshId dateExamples

55+ let graph = bootstrapTransactionGraph stamp' freshId dateExamples

52 _ <- bootstrapDatabaseDir NoDiskSync dbdir graph

56 _ <- bootstrapDatabaseDir NoDiskSync dbdir graph

53 case transactionForHead "master" graph of

57 case transactionForHead "master" graph of

54 Nothing -> assertFailure "Failed to retrieve head transaction for master branch."

58 Nothing -> assertFailure "Failed to retrieve head transaction for master branch."

55 Just headTrans ->

59 Just headTrans ->

56− case interpretDatabaseContextExpr (concreteDatabaseContext headTrans) "x:=s" of

60+ case interpretDatabaseContextExpr (concreteDatabaseContext headTrans) (transactionId headTrans) graph "x:=s" of

57 Left err -> assertFailure (show err)

61 Left err -> assertFailure (show err)

58 Right context' -> do

62 Right context' -> do

59 freshId' <- nextRandom

63 freshId' <- nextRandom

60− let newdiscon = DisconnectedTransaction (transactionId headTrans) (Schemas context' M.empty) True

64+ let newdiscon = DisconnectedTransaction (transactionId headTrans) (Schemas context' M.empty) False

61− addTrans = addDisconnectedTransaction stamp freshId' "master" newdiscon graph

65+ addTrans = addDisconnectedTransaction stamp' freshId' "master" newdiscon graph

62 --add a transaction to the graph

66 --add a transaction to the graph

63 case addTrans of

67 case addTrans of

64 Left err -> assertFailure (show err)

68 Left err -> assertFailure (show err)

@@ -71,11 +75,69 @@ testDBSimplePersistence = TestCase $ withSystemTempDirectory "m36testdb" $ \temp

71 case graphErr of

75 case graphErr of

72 Left err -> assertFailure (show err)

76 Left err -> assertFailure (show err)

73 Right graph'' -> assertBool "graph equality" (mapEq graph'' == mapEq graph')

77 Right graph'' -> assertBool "graph equality" (mapEq graph'' == mapEq graph')

74−

78+

79+testMerkleHashValidation :: Test

80+testMerkleHashValidation = TestCase $

81+ -- add a commit and validate the hashes successfully

82+ withSystemTempDirectory "m36testdb" $ \tempdir -> do

83+ let dbdir = tempdir </> "dbdir"

84+ connInfo = InProcessConnectionInfo (MinimalPersistence dbdir) emptyNotificationCallback []

85+ conn <- assertIOEither $ connectProjectM36 connInfo

86+ sess <- assertIOEither $ createSessionAtHead conn "master"

87+ Right _ <- executeDatabaseContextExpr sess conn (Assign "x" (ExistingRelation relationTrue))

88+ Right _ <- commit sess conn

89+ val <- C.validateMerkleHashes sess conn

90+ assertEqual "merkle success" (Right ()) val

91+

92+ --read graph from disk

93+ conn' <- assertIOEither $ connectProjectM36 connInfo

94+ sess' <- assertIOEither $ createSessionAtHead conn' "master"

95+

96+ val' <- C.validateMerkleHashes sess' conn'

97+ assertEqual "merkle read again success" (Right ()) val'

98+

99+ --alter the on-disk representation and check that the hash validation fails

100+ eGraph <- transactionGraphLoad dbdir emptyTransactionGraph Nothing

101+ case eGraph of

102+ Left err -> assertFailure $ "failed to load graph" ++ show err

103+ Right graph -> do

104+ let trans = transactionHeadsForGraph graph M.! "master"

105+ updatedTrans = Transaction (transactionId trans) (transactionInfo trans) updatedSchemas

106+ transactionDir' = dbdir </> show (transactionId trans)

107+ updatedSchemas =

108+ case schemas trans of

109+ Schemas ctx sschemas ->

110+ let updatedContext = ctx {

111+ relationVariables = M.insert "malicious" (ExistingRelation relationFalse) (relationVariables ctx)

112+ } in

113+ Schemas updatedContext sschemas

114+ maliciousGraph = TransactionGraph malHeads malTransSet

115+ malHeads = M.insert "master" updatedTrans (transactionHeadsForGraph graph)

116+ malTransSet = S.insert updatedTrans (transactionsForGraph graph)

117+ malMerkleHash = calculateMerkleHash updatedTrans maliciousGraph

118+ regMerkleHash = merkleHash (transactionInfo trans)

119+ --validate and fail

120+ let val'' = TG.validateMerkleHashes maliciousGraph

121+ assertEqual "loaded graph merkle hashes" (Left [MerkleValidationError (transactionId trans) regMerkleHash malMerkleHash]) val''

122+ --delete existing transaction directory

123+ removeDirectoryRecursive transactionDir'

124+ writeTransaction NoDiskSync dbdir updatedTrans

125+

126+ --read graph from disk

127+ eConnFail <- connectProjectM36 connInfo

128+ case eConnFail of

129+ Left err ->

130+ assertEqual "open connection merkle validation" (DatabaseValidationError [MerkleValidationError (transactionId trans) regMerkleHash malMerkleHash]) err

131+ Right _ -> assertFailure "open connection validation"

132+

133+

75

134

76--only Haskell-scripted dbc and atom functions can be serialized

135--only Haskell-scripted dbc and atom functions can be serialized

77testFunctionPersistence :: Test

136testFunctionPersistence :: Test

137+#if !defined(PM36_HASKELL_SCRIPTING)

78−testFunctionPersistence = TestCase $

138+testFunctionPersistence = TestCase $ pure ()

139+#else

140+testFunctionPersistence = TestCase $

79 withSystemTempDirectory "m36testdb" $ \tempdir -> do

141 withSystemTempDirectory "m36testdb" $ \tempdir -> do

80 let dbdir = tempdir </> "dbdir"

142 let dbdir = tempdir </> "dbdir"

81 connInfo = InProcessConnectionInfo (MinimalPersistence dbdir) emptyNotificationCallback []

143 connInfo = InProcessConnectionInfo (MinimalPersistence dbdir) emptyNotificationCallback []

@@ -93,10 +155,12 @@ testFunctionPersistence = TestCase $

93 conn2 <- assertIOEither $ connectProjectM36 connInfo

155 conn2 <- assertIOEither $ connectProjectM36 connInfo

94 sess2 <- assertIOEither $ createSessionAtHead conn2 "master"

156 sess2 <- assertIOEither $ createSessionAtHead conn2 "master"

95

157

96− res <- executeRelationalExpr sess2 conn2 (MakeRelationFromExprs Nothing [TupleExpr (M.singleton "a" (FunctionAtomExpr "testdisk" [NakedAtomExpr (IntAtom 3)] ()))])

158+ res <- executeRelationalExpr sess2 conn2 (MakeRelationFromExprs Nothing (TupleExprs () [TupleExpr (M.singleton "a" (FunctionAtomExpr "testdisk" [NakedAtomExpr (IntAtom 3)] ()))]))

97 let expectedRel = mkRelationFromList (attributesFromList [Attribute "a" IntAtomType]) [[IntAtom 3]]

159 let expectedRel = mkRelationFromList (attributesFromList [Attribute "a" IntAtomType]) [[IntAtom 3]]

98 assertEqual "testdisk dbc function run" expectedRel res

160 assertEqual "testdisk dbc function run" expectedRel res

99−

161+

162+#endif

163+

100assertIOEither :: (Show a) => IO (Either a b) -> IO b

164assertIOEither :: (Show a) => IO (Either a b) -> IO b

101assertIOEither x = do

165assertIOEither x = do

102 ret <- x

166 ret <- x

test/TutorialD/Interpreter/AtomFunctionScript.hs+25−17

@@ -1,25 +1,32 @@

1−import TutorialD.Interpreter.TestBase

1+{-# LANGUAGE CPP #-}

2import System.Exit

3import Test.HUnit

4+#ifdef PM36_HASKELL_SCRIPTING

5+import TutorialD.Interpreter.TestBase

4import ProjectM36.Client

6import ProjectM36.Client

5import ProjectM36.Relation

7import ProjectM36.Relation

6import ProjectM36.DataTypes.Maybe

8import ProjectM36.DataTypes.Maybe

7import qualified Data.Vector as V

9import qualified Data.Vector as V

8import qualified Data.Map as M

10import qualified Data.Map as M

11+#endif

9

12

10{-# ANN module ("HLint: ignore Reduce duplication" :: String) #-}

13{-# ANN module ("HLint: ignore Reduce duplication" :: String) #-}

11main :: IO ()

14main :: IO ()

12main = do

15main = do

13− tcounts <- runTestTT (TestList [testBasicAtomFunction,

16+ tcounts <- runTestTT (TestList [

17+#ifdef PM36_HASKELL_SCRIPTING

18+ testBasicAtomFunction,

14− testExceptionAtomFunction,

19+ testExceptionAtomFunction,

15− testErrorAtomFunction,

20+ testErrorAtomFunction,

16− testNoArgumentAtomFunction,

21+ testNoArgumentAtomFunction,

17− testArgumentTypeMismatch,

22+ testArgumentTypeMismatch,

18− testPolymorphicReturnType,

23+ testPolymorphicReturnType,

19− testScriptedTypeVariable

24+ testScriptedTypeVariable

25+#endif

20− ])

26+ ])

21 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

27 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

22

28

29+#ifdef PM36_HASKELL_SCRIPTING

23--add an atom function and run it

30--add an atom function and run it

24testBasicAtomFunction :: Test

31testBasicAtomFunction :: Test

25testBasicAtomFunction = TestCase $ do

32testBasicAtomFunction = TestCase $ do

@@ -29,7 +36,7 @@ testBasicAtomFunction = TestCase $ do

29 funcAtomExpr = FunctionAtomExpr "mkTest" [NakedAtomExpr (IntegerAtom 3)] ()

36 funcAtomExpr = FunctionAtomExpr "mkTest" [NakedAtomExpr (IntegerAtom 3)] ()

30 tupleExprs = [TupleExpr (M.singleton "x" funcAtomExpr)]

37 tupleExprs = [TupleExpr (M.singleton "x" funcAtomExpr)]

31 expectedResult = mkRelationFromList (V.fromList attrs) [[IntegerAtom 3]]

38 expectedResult = mkRelationFromList (V.fromList attrs) [[IntegerAtom 3]]

32− result <- executeRelationalExpr sess conn (MakeRelationFromExprs (Just (map NakedAttributeExpr attrs)) tupleExprs)

39+ result <- executeRelationalExpr sess conn (MakeRelationFromExprs (Just (map NakedAttributeExpr attrs)) (TupleExprs () tupleExprs))

33

40

34 assertEqual "simple atom function equality" expectedResult result

41 assertEqual "simple atom function equality" expectedResult result

35

42

@@ -40,7 +47,7 @@ testExceptionAtomFunction = TestCase $ do

40 executeTutorialD sess conn "addatomfunction \"mkTest\" Integer -> Either AtomFunctionError Integer \"\"\"(\\(IntegerAtom x:xs) -> (error (show 1))) :: [Atom] -> Either AtomFunctionError Atom\"\"\""

47 executeTutorialD sess conn "addatomfunction \"mkTest\" Integer -> Either AtomFunctionError Integer \"\"\"(\\(IntegerAtom x:xs) -> (error (show 1))) :: [Atom] -> Either AtomFunctionError Atom\"\"\""

41 let attrs = [Attribute "x" IntegerAtomType]

48 let attrs = [Attribute "x" IntegerAtomType]

42 funcAtomExpr = FunctionAtomExpr "mkTest" [NakedAtomExpr (IntegerAtom 3)] ()

49 funcAtomExpr = FunctionAtomExpr "mkTest" [NakedAtomExpr (IntegerAtom 3)] ()

43− tupleExprs = [TupleExpr (M.singleton "x" funcAtomExpr)]

50+ tupleExprs = TupleExprs () [TupleExpr (M.singleton "x" funcAtomExpr)]

44 result <- executeRelationalExpr sess conn (MakeRelationFromExprs (Just (map NakedAttributeExpr attrs)) tupleExprs)

51 result <- executeRelationalExpr sess conn (MakeRelationFromExprs (Just (map NakedAttributeExpr attrs)) tupleExprs)

45 assertBool "catch error exception from script" (case result of

52 assertBool "catch error exception from script" (case result of

46 Left (UnhandledExceptionError _) -> True

53 Left (UnhandledExceptionError _) -> True

@@ -57,7 +64,7 @@ testNoArgumentAtomFunction = TestCase $ do

57 executeTutorialD sess conn "addatomfunction \"mkTest\" Either AtomFunctionError Integer \"\"\"(\\x -> pure (IntegerAtom 5)) :: [Atom] -> Either AtomFunctionError Atom\"\"\""

64 executeTutorialD sess conn "addatomfunction \"mkTest\" Either AtomFunctionError Integer \"\"\"(\\x -> pure (IntegerAtom 5)) :: [Atom] -> Either AtomFunctionError Atom\"\"\""

58 let attrs = [Attribute "x" IntegerAtomType]

65 let attrs = [Attribute "x" IntegerAtomType]

59 funcAtomExpr = FunctionAtomExpr "mkTest" [] ()

66 funcAtomExpr = FunctionAtomExpr "mkTest" [] ()

60− tupleExprs = [TupleExpr (M.singleton "x" funcAtomExpr)]

67+ tupleExprs = TupleExprs () [TupleExpr (M.singleton "x" funcAtomExpr)]

61 expectedResult = mkRelationFromList (V.fromList attrs) [[IntegerAtom 5]]

68 expectedResult = mkRelationFromList (V.fromList attrs) [[IntegerAtom 5]]

62 result <- executeRelationalExpr sess conn (MakeRelationFromExprs (Just (map NakedAttributeExpr attrs)) tupleExprs)

69 result <- executeRelationalExpr sess conn (MakeRelationFromExprs (Just (map NakedAttributeExpr attrs)) tupleExprs)

63 assertEqual "no argument scripted function" expectedResult result

70 assertEqual "no argument scripted function" expectedResult result

@@ -66,7 +73,7 @@ testArgumentTypeMismatch :: Test

66testArgumentTypeMismatch = TestCase $ do

73testArgumentTypeMismatch = TestCase $ do

67 (sess, conn) <- dateExamplesConnection emptyNotificationCallback

74 (sess, conn) <- dateExamplesConnection emptyNotificationCallback

68 executeTutorialD sess conn "addatomfunction \"mkTest\" Integer -> Either AtomFunctionError Integer \"\"\"(\\(IntegerAtom x:_) -> pure $ TextAtom \"wrong type\") :: [Atom] -> Either AtomFunctionError Atom\"\"\""

75 executeTutorialD sess conn "addatomfunction \"mkTest\" Integer -> Either AtomFunctionError Integer \"\"\"(\\(IntegerAtom x:_) -> pure $ TextAtom \"wrong type\") :: [Atom] -> Either AtomFunctionError Atom\"\"\""

69− let tupleExprs = [TupleExpr (M.singleton "x" funcAtomExpr)]

76+ let tupleExprs = TupleExprs () [TupleExpr (M.singleton "x" funcAtomExpr)]

70 funcAtomExpr = FunctionAtomExpr "mkTest" [NakedAtomExpr (IntegerAtom 3)] ()

77 funcAtomExpr = FunctionAtomExpr "mkTest" [NakedAtomExpr (IntegerAtom 3)] ()

71 attrs = [Attribute "x" IntegerAtomType]

78 attrs = [Attribute "x" IntegerAtomType]

72 expectedResult = Left (AtomTypeMismatchError IntegerAtomType TextAtomType)

79 expectedResult = Left (AtomTypeMismatchError IntegerAtomType TextAtomType)

@@ -80,7 +87,7 @@ testPolymorphicReturnType = TestCase $ do

80 let funcAtomExpr = FunctionAtomExpr "fromMaybe" [NakedAtomExpr (IntegerAtom 5),

87 let funcAtomExpr = FunctionAtomExpr "fromMaybe" [NakedAtomExpr (IntegerAtom 5),

81 NakedAtomExpr maybeAtom] ()

88 NakedAtomExpr maybeAtom] ()

82 maybeAtom = ConstructedAtom "Just" (maybeAtomType IntegerAtomType) [IntegerAtom 3]

89 maybeAtom = ConstructedAtom "Just" (maybeAtomType IntegerAtomType) [IntegerAtom 3]

83− relExpr = MakeRelationFromExprs Nothing [TupleExpr (M.singleton "x" funcAtomExpr)]

90+ relExpr = MakeRelationFromExprs Nothing (TupleExprs () [TupleExpr (M.singleton "x" funcAtomExpr)])

84 mRelType <- typeForRelationalExpr sess conn relExpr

91 mRelType <- typeForRelationalExpr sess conn relExpr

85 case mRelType of

92 case mRelType of

86 Left err -> assertFailure (show err)

93 Left err -> assertFailure (show err)

@@ -94,7 +101,7 @@ testPolymorphicReturnType = TestCase $ do

94 let failFuncAtomExpr = FunctionAtomExpr "fromMaybe" [NakedAtomExpr (IntegerAtom 5),

101 let failFuncAtomExpr = FunctionAtomExpr "fromMaybe" [NakedAtomExpr (IntegerAtom 5),

95 NakedAtomExpr mismatchAtom] ()

102 NakedAtomExpr mismatchAtom] ()

96 mismatchAtom = ConstructedAtom "Just" (maybeAtomType TextAtomType) [TextAtom "fail"]

103 mismatchAtom = ConstructedAtom "Just" (maybeAtomType TextAtomType) [TextAtom "fail"]

97− failRelExpr = MakeRelationFromExprs Nothing [TupleExpr (M.singleton "x" failFuncAtomExpr)]

104+ failRelExpr = MakeRelationFromExprs Nothing (TupleExprs () [TupleExpr (M.singleton "x" failFuncAtomExpr)])

98 mFailRes <- executeRelationalExpr sess conn failRelExpr

105 mFailRes <- executeRelationalExpr sess conn failRelExpr

99 let expectedErr = Left (AtomFunctionTypeVariableMismatch "a" IntegerAtomType TextAtomType)

106 let expectedErr = Left (AtomFunctionTypeVariableMismatch "a" IntegerAtomType TextAtomType)

100 assertEqual "expected type variable mismatch" expectedErr mFailRes

107 assertEqual "expected type variable mismatch" expectedErr mFailRes

@@ -106,9 +113,10 @@ testScriptedTypeVariable = TestCase $ do

106 executeTutorialD sess conn "addatomfunction \"idTest\" a -> Either AtomFunctionError a \"(\\\\(x:_) -> pure x) :: [Atom] -> Either AtomFunctionError Atom\""

113 executeTutorialD sess conn "addatomfunction \"idTest\" a -> Either AtomFunctionError a \"(\\\\(x:_) -> pure x) :: [Atom] -> Either AtomFunctionError Atom\""

107 let attrs = [Attribute "x" IntegerAtomType]

114 let attrs = [Attribute "x" IntegerAtomType]

108 funcAtomExpr = FunctionAtomExpr "idTest" [NakedAtomExpr (IntegerAtom 3)] ()

115 funcAtomExpr = FunctionAtomExpr "idTest" [NakedAtomExpr (IntegerAtom 3)] ()

109− tupleExprs = [TupleExpr (M.singleton "x" funcAtomExpr)]

116+ tupleExprs = TupleExprs () [TupleExpr (M.singleton "x" funcAtomExpr)]

110 expectedResult = mkRelationFromList (V.fromList attrs) [[IntegerAtom 3]]

117 expectedResult = mkRelationFromList (V.fromList attrs) [[IntegerAtom 3]]

111 result <- executeRelationalExpr sess conn (MakeRelationFromExprs (Just (map NakedAttributeExpr attrs)) tupleExprs)

118 result <- executeRelationalExpr sess conn (MakeRelationFromExprs (Just (map NakedAttributeExpr attrs)) tupleExprs)

112

119

113 assertEqual "id function equality" expectedResult result

120 assertEqual "id function equality" expectedResult result

114−

121+

122+#endif

test/TutorialD/Interpreter/DatabaseContextFunctionScript.hs+13−6

@@ -1,19 +1,26 @@

1−import TutorialD.Interpreter.TestBase

1+{-# LANGUAGE CPP #-}

2import System.Exit

3import Test.HUnit

4+#ifdef PM36_HASKELL_SCRIPTING

5+import TutorialD.Interpreter.TestBase

4import ProjectM36.Client

6import ProjectM36.Client

5import ProjectM36.Relation

7import ProjectM36.Relation

6import qualified Data.Text as T

8import qualified Data.Text as T

9+#endif

7

10

8main :: IO ()

11main :: IO ()

9main = do

12main = do

10− tcounts <- runTestTT (TestList [testBasicDBCFunction,

13+ tcounts <- runTestTT (TestList [

14+#ifdef PM36_HASKELL_SCRIPTING

15+ testBasicDBCFunction,

11− testErrorDBCFunction,

16+ testErrorDBCFunction,

12− testExceptionDBCFunction,

17+ testExceptionDBCFunction,

13− testDBCFunctionWithAtomArguments

18+ testDBCFunctionWithAtomArguments

19+#endif

14 ])

20 ])

15 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

21 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

16

22

23+#ifdef PM36_HASKELL_SCRIPTING

17testBasicDBCFunction :: Test

24testBasicDBCFunction :: Test

18testBasicDBCFunction = TestCase $ do

25testBasicDBCFunction = TestCase $ do

19 (sess, conn) <- dateExamplesConnection emptyNotificationCallback

26 (sess, conn) <- dateExamplesConnection emptyNotificationCallback

@@ -55,4 +62,4 @@ testDBCFunctionWithAtomArguments = TestCase $ do

55 assertEqual "person relation" expectedPerson result

62 assertEqual "person relation" expectedPerson result

56 expectTutorialDErr sess conn (T.isPrefixOf "AtomTypeMismatchError") "execute multiArgFunc(\"fail\", \"fail\")"

63 expectTutorialDErr sess conn (T.isPrefixOf "AtomTypeMismatchError") "execute multiArgFunc(\"fail\", \"fail\")"

57

64

58−

65+#endif

test/TutorialD/Interpreter/Import/ImportTest.hsnew file+47

@@ -0,0 +1,47 @@

1+import Test.HUnit

2+import ProjectM36.Base

3+import TutorialD.Interpreter.Import.TutorialD

4+import System.Exit

5+import qualified Data.Text as T

6+import System.IO.Temp

7+import System.FilePath

8+import qualified Data.Map as M

9+import System.IO

10+import System.Directory

11+import qualified Data.ByteString as BS

12+import qualified Data.Text.Encoding as TE

13+import Text.URI hiding (makeAbsolute)

14+

15+main :: IO ()

16+main = do

17+ tcounts <- runTestTT $ TestList [testTutdFileImport

18+ ,testTutdHTTPSImport

19+ ]

20+ if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

21+

22+testTutdFileImport :: Test

23+testTutdFileImport = TestCase $

24+ withSystemTempFile "m.tutd" $ \tempPath handle -> do

25+ BS.hPut handle (TE.encodeUtf8 "x:=relation{tuple{a 5,b \"spam\"}}; y:=relation{tuple{b \"漢字\"}}")

26+ hClose handle

27+ let expectedExpr = MultipleExpr [

28+ Assign "x" (MakeRelationFromExprs Nothing

29+ $ TupleExprs () [TupleExpr (M.fromList [("a", NakedAtomExpr $ IntegerAtom 5),

30+ ("b", NakedAtomExpr $ TextAtom "spam")])]),

31+ Assign "y" (MakeRelationFromExprs Nothing

32+ $ TupleExprs () [TupleExpr (M.fromList [("b", NakedAtomExpr (TextAtom "漢字"))])])]

33+ --on Windows, the file URI should not include the drive letter "/c/Users..." -> "/Users"

34+ let uri = "file://" <> map (\c -> if c == '\\' then '/' else c) ( joinDrive "/" (dropDrive tempPath))

35+ fileURI <- mkURI (T.pack uri)

36+ imported <- importTutorialDFromFile fileURI Nothing

37+ assertEqual "import tutd" (Right expectedExpr) imported

38+

39+testTutdHTTPSImport :: Test

40+testTutdHTTPSImport = TestCase $ do

41+ uri <- mkURI "https://raw.githubusercontent.com/agentm/project-m36/master/test/TutorialD/Interpreter/Import/httpimporttest.tutd"

42+ let hash = "effe32b247586dc3ac0079fc241b9618d41d189afcaeb7907edbe5a8b45992a4"

43+ expected = Right (MultipleExpr [Assign "x" (RelationVariable "true" ()),Assign "y" (RelationVariable "false" ())])

44+ actual <- importTutorialDViaHTTP uri (Just hash)

45+ assertEqual "github https" expected actual

46+

47+

test/TutorialD/Interpreter/Import/TutorialD.hsdeleted−29

@@ -1,29 +0,0 @@

1−import Test.HUnit

2−import ProjectM36.Base

3−import TutorialD.Interpreter.Import.TutorialD

4−import System.Exit

5−import System.IO.Temp

6−import qualified Data.Map as M

7−import System.IO

8−import qualified Data.ByteString as BS

9−import qualified Data.Text.Encoding as TE

10−

11−main :: IO ()

12−main = do

13− tcounts <- runTestTT $ TestList [testTutdImport]

14− if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

15−

16−testTutdImport :: Test

17−testTutdImport = TestCase $

18− withSystemTempFile "m.tutd" $ \tempPath handle -> do

19− BS.hPut handle (TE.encodeUtf8 "x:=relation{tuple{a 5,b \"spam\"}}; y:=relation{tuple{b \"漢字\"}}")

20− hClose handle

21− let expectedExpr = MultipleExpr [

22− Assign "x" (MakeRelationFromExprs Nothing

23− [TupleExpr (M.fromList [("a", NakedAtomExpr $ IntegerAtom 5),

24− ("b", NakedAtomExpr $ TextAtom "spam")])]),

25− Assign "y" (MakeRelationFromExprs Nothing

26− [TupleExpr (M.fromList [("b", NakedAtomExpr (TextAtom "漢字"))])])]

27− imported <- importTutorialD tempPath

28− assertEqual "import tutd" (Right expectedExpr) imported

29−

test/TutorialD/Interpreter/Import/httpimporttest.tutdnew file+2

@@ -0,0 +1,2 @@

1+x:=true;

2+y:=false;

test/TutorialD/Interpreter/TestBase.hs+10−13

@@ -2,16 +2,14 @@ module TutorialD.Interpreter.TestBase where

2import ProjectM36.Client

3import TutorialD.Interpreter

4import TutorialD.Interpreter.Base

5−import qualified ProjectM36.Base as Base

6import ProjectM36.DateExamples

5import ProjectM36.DateExamples

6+import ProjectM36.DatabaseContext

7import Test.HUnit

8−import qualified Data.Map as M

9import Data.Text

8import Data.Text

10

9

11dateExamplesConnection :: NotificationCallback -> IO (SessionId, Connection)

10dateExamplesConnection :: NotificationCallback -> IO (SessionId, Connection)

12dateExamplesConnection callback = do

11dateExamplesConnection callback = do

13 dbconn <- connectProjectM36 (InProcessConnectionInfo NoPersistence callback [])

12 dbconn <- connectProjectM36 (InProcessConnectionInfo NoPersistence callback [])

14− let incDeps = Base.inclusionDependencies dateExamples

15 case dbconn of

13 case dbconn of

16 Left err -> error (show err)

14 Left err -> error (show err)

17 Right conn -> do

15 Right conn -> do

@@ -19,8 +17,7 @@ dateExamplesConnection callback = do

19 case eSessionId of

17 case eSessionId of

20 Left err -> error (show err)

18 Left err -> error (show err)

21 Right sessionId -> do

19 Right sessionId -> do

22− mapM_ (\(rvName,rvRel) -> executeDatabaseContextExpr sessionId conn (Assign rvName (Base.ExistingRelation rvRel))) (M.toList (Base.relationVariables dateExamples))

20+ executeDatabaseContextExpr sessionId conn (databaseContextAsDatabaseContextExpr dateExamples) >>= eitherFail

23− mapM_ (\(idName,incDep) -> executeDatabaseContextExpr sessionId conn (AddInclusionDependency idName incDep)) (M.toList incDeps)

24 --skipping atom functions for now- there are no atom function manipulation operators yet

21 --skipping atom functions for now- there are no atom function manipulation operators yet

25 commit sessionId conn >>= eitherFail

22 commit sessionId conn >>= eitherFail

26 pure (sessionId, conn)

23 pure (sessionId, conn)

@@ -31,13 +28,13 @@ executeTutorialD sessionId conn tutd = case parseTutorialD tutd of

31 Right parsed -> do

28 Right parsed -> do

32 result <- evalTutorialD sessionId conn UnsafeEvaluation parsed

29 result <- evalTutorialD sessionId conn UnsafeEvaluation parsed

33 case result of

30 case result of

34− QuitResult -> putStrLn "yyy" >> assertFailure "quit?"

31+ QuitResult -> assertFailure "quit?"

35− DisplayResult _ -> putStrLn "xxx" >> assertFailure "display?"

32+ DisplayResult _ -> assertFailure "display?"

36− DisplayIOResult _ -> putStrLn "z" >> assertFailure "displayIO?"

33+ DisplayIOResult _ -> assertFailure "displayIO?"

37− DisplayRelationResult _ -> putStrLn "Y" >> assertFailure "displayrelation?"

34+ DisplayRelationResult _ -> assertFailure "displayrelation?"

38− DisplayDataFrameResult _ -> putStrLn "DF" >> assertFailure "displaydataframe?"

35+ DisplayDataFrameResult _ -> assertFailure "displaydataframe?"

39− DisplayParseErrorResult _ _ -> putStrLn "X" >> assertFailure "displayparseerrorresult?"

36+ DisplayParseErrorResult _ _ -> assertFailure "displayparseerrorresult?"

40− DisplayErrorResult err -> putStrLn "asd" >> assertFailure (show tutd ++ ": " ++ show err)

37+ DisplayErrorResult err -> assertFailure (show tutd ++ ": " ++ show err)

41 QuietSuccessResult -> pure ()

38 QuietSuccessResult -> pure ()

42

39

43expectTutorialDErr :: SessionId -> Connection -> (Text -> Bool) -> Text -> IO ()

40expectTutorialDErr :: SessionId -> Connection -> (Text -> Bool) -> Text -> IO ()

@@ -52,7 +49,7 @@ expectTutorialDErr sessionId conn matchFunc tutd = case parseTutorialD tutd of

52 DisplayRelationResult _ -> assertFailure "displayrelation?"

49 DisplayRelationResult _ -> assertFailure "displayrelation?"

53 DisplayDataFrameResult _ -> assertFailure "displaydataframe?"

50 DisplayDataFrameResult _ -> assertFailure "displaydataframe?"

54 DisplayParseErrorResult _ _ -> assertFailure "displayparseerrorresult?"

51 DisplayParseErrorResult _ _ -> assertFailure "displayparseerrorresult?"

55− DisplayErrorResult err -> assertBool ("match error on: " ++ unpack err) (matchFunc err)

52+ DisplayErrorResult err -> assertBool (unpack tutd ++ " match error on: " ++ unpack err) (matchFunc err)

56 QuietSuccessResult -> pure ()

53 QuietSuccessResult -> pure ()

57

54

58eitherFail :: Either RelationalError a -> IO ()

55eitherFail :: Either RelationalError a -> IO ()

test/TutorialD/Interpreter.hs → test/TutorialD/InterpreterTest.hsrenamed+115−27

@@ -9,6 +9,7 @@ import ProjectM36.TupleSet

9import ProjectM36.Error

10import ProjectM36.DatabaseContext

11import ProjectM36.AtomFunctions.Primitive

12+import ProjectM36.RelationalExpression

12import ProjectM36.DataTypes.Either

13import ProjectM36.DataTypes.Either

13import ProjectM36.DataTypes.Interval

14import ProjectM36.DataTypes.Interval

14import ProjectM36.DataTypes.NonEmptyList

15import ProjectM36.DataTypes.NonEmptyList

@@ -39,8 +40,9 @@ main = do

39 tcounts <- runTestTT (TestList tests)

40 tcounts <- runTestTT (TestList tests)

40 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

41 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

41 where

42 where

42− tests = map (\(tutd, expected) -> TestCase $ assertTutdEqual basicDatabaseContext expected tutd) simpleRelTests ++

43+ tests = [

43− map (\(tutd, expected) -> TestCase $ assertTutdEqual dateExamples expected tutd) dateExampleRelTests ++ [

44+ simpleRelTests,

45+ dateExampleRelTests,

44 transactionGraphBasicTest,

46 transactionGraphBasicTest,

45 transactionGraphAddCommitTest,

47 transactionGraphAddCommitTest,

46 transactionRollbackTest,

48 transactionRollbackTest,

@@ -73,9 +75,22 @@ main = do

73 testNonEmptyListType,

75 testNonEmptyListType,

74 testUnresolvedAtomTypes,

76 testUnresolvedAtomTypes,

75 testWithClause,

77 testWithClause,

76− testAtomFunctionArgumentMismatch

78+ testAtomFunctionArgumentMismatch,

79+ testInvalidDataConstructor,

80+ testBasicList,

81+ testRelationDeclarationMismatch,

82+ testInvalidTuples,

83+ testSelfReferencingUncommittedContext,

84+ testUnionAndIntersectionAttributeExprs

77 ]

85 ]

86+

87+simpleRelTests :: Test

88+simpleRelTests = TestCase $ do

89+ (graph, transId) <- freshTransactionGraph dateExamples

90+ mapM_ (\(tutd, expected) ->

91+ assertTutdEqual basicDatabaseContext transId graph expected tutd) testTups

92+ where

78− simpleRelTests = [("x:=true", Right relationTrue),

93+ testTups = [("x:=true", Right relationTrue),

79 ("x:=false", Right relationFalse),

94 ("x:=false", Right relationFalse),

80 ("x:=true union false", Right relationTrue),

95 ("x:=true union false", Right relationTrue),

81 ("x:=true minus false", Right relationTrue),

96 ("x:=true minus false", Right relationTrue),

@@ -108,31 +123,39 @@ main = do

108 ("x:=relation{tuple{a 5}} : {b:=6}", mkRelationFromTuples simpleDAttributes [RelationTuple simpleDAttributes (V.fromList [IntegerAtom 5, IntegerAtom 6])]),

123 ("x:=relation{tuple{a 5}} : {b:=6}", mkRelationFromTuples simpleDAttributes [RelationTuple simpleDAttributes (V.fromList [IntegerAtom 5, IntegerAtom 6])]),

109 ("x:=relation{tuple{a 5}} : {b:=add(@a,5)}", mkRelationFromTuples simpleDAttributes [RelationTuple simpleDAttributes (V.fromList [IntegerAtom 5, IntegerAtom 10])]),

124 ("x:=relation{tuple{a 5}} : {b:=add(@a,5)}", mkRelationFromTuples simpleDAttributes [RelationTuple simpleDAttributes (V.fromList [IntegerAtom 5, IntegerAtom 10])]),

110 ("x:=relation{tuple{a 5}} : {b:=add(@a,\"spam\")}", Left (AtomFunctionTypeError "add" 2 IntegerAtomType TextAtomType)),

125 ("x:=relation{tuple{a 5}} : {b:=add(@a,\"spam\")}", Left (AtomFunctionTypeError "add" 2 IntegerAtomType TextAtomType)),

111− ("x:=relation{tuple{a 5}} : {b:=add(add(@a,2),5)}", mkRelationFromTuples simpleDAttributes [RelationTuple simpleDAttributes (V.fromList [IntegerAtom 5, IntegerAtom 12])])

126+ ("x:=relation{tuple{a 5}} : {b:=add(add(@a,2),5)}", mkRelationFromTuples simpleDAttributes [RelationTuple simpleDAttributes (V.fromList [IntegerAtom 5, IntegerAtom 12])]),

127+ ("x:=false:{a:=1,b:=2}", mkRelationFromTuples simpleDAttributes [])

112 ]

128 ]

113 simpleAAttributes = A.attributesFromList [Attribute "a" IntegerAtomType]

129 simpleAAttributes = A.attributesFromList [Attribute "a" IntegerAtomType]

114 simpleBAttributes = A.attributesFromList [Attribute "d" IntegerAtomType]

130 simpleBAttributes = A.attributesFromList [Attribute "d" IntegerAtomType]

115 simpleCAttributes = A.attributesFromList [Attribute "a" TextAtomType, Attribute "b" IntegerAtomType]

131 simpleCAttributes = A.attributesFromList [Attribute "a" TextAtomType, Attribute "b" IntegerAtomType]

116 simpleDAttributes = A.attributesFromList [Attribute "a" IntegerAtomType, Attribute "b" IntegerAtomType]

132 simpleDAttributes = A.attributesFromList [Attribute "a" IntegerAtomType, Attribute "b" IntegerAtomType]

117− maybeTextAtomType = ConstructedAtomType "Maybe" (M.singleton "a" TextAtomType)

133+ simpleProjectionAttributes = A.attributesFromList [Attribute "c" IntegerAtomType]

134+ nestedRelationAttributes = A.attributesFromList [Attribute "a" IntegerAtomType, Attribute "b" (RelationAtomType $ A.attributesFromList [Attribute "a" IntegerAtomType])]

135+

136+dateExampleRelTests :: Test

137+dateExampleRelTests = TestCase $ do

138+ (graph, transId) <- freshTransactionGraph dateExamples

139+ mapM_ (\(tutd, expected) ->

140+ assertTutdEqual dateExamples transId graph expected tutd) testTups

141+ where

142+ simpleEitherIntTextAttributes = A.attributesFromList [Attribute "a" (eitherAtomType IntegerAtomType TextAtomType)]

118 maybeIntegerAtomType = ConstructedAtomType "Maybe" (M.singleton "a" IntegerAtomType)

143 maybeIntegerAtomType = ConstructedAtomType "Maybe" (M.singleton "a" IntegerAtomType)

144+ maybeTextAtomType = ConstructedAtomType "Maybe" (M.singleton "a" TextAtomType)

119 simpleMaybeTextAttributes = A.attributesFromList [Attribute "a" maybeTextAtomType]

145 simpleMaybeTextAttributes = A.attributesFromList [Attribute "a" maybeTextAtomType]

120 simpleMaybeIntAttributes = A.attributesFromList [Attribute "a" maybeIntegerAtomType]

146 simpleMaybeIntAttributes = A.attributesFromList [Attribute "a" maybeIntegerAtomType]

121− simpleEitherIntTextAttributes = A.attributesFromList [Attribute "a" (eitherAtomType IntegerAtomType TextAtomType)]

122− simpleProjectionAttributes = A.attributesFromList [Attribute "c" IntegerAtomType]

123− nestedRelationAttributes = A.attributesFromList [Attribute "a" IntegerAtomType, Attribute "b" (RelationAtomType $ A.attributesFromList [Attribute "a" IntegerAtomType])]

124− extendTestAttributes = A.attributesFromList [Attribute "a" IntegerAtomType, Attribute "b" $ RelationAtomType (R.attributes suppliersRel)]

125 byteStringAttributes = A.attributesFromList [Attribute "y" ByteStringAtomType]

147 byteStringAttributes = A.attributesFromList [Attribute "y" ByteStringAtomType]

126− groupCountAttrs = A.attributesFromList [Attribute "z" IntegerAtomType]

127 minMaxAttrs = A.attributesFromList [Attribute "s#" TextAtomType, Attribute "z" IntegerAtomType]

148 minMaxAttrs = A.attributesFromList [Attribute "s#" TextAtomType, Attribute "z" IntegerAtomType]

149+ groupCountAttrs = A.attributesFromList [Attribute "z" IntegerAtomType]

128 updateParisPlus10 = relMap (\tuple -> do

150 updateParisPlus10 = relMap (\tuple -> do

129 statusAtom <- atomForAttributeName "status" tuple

151 statusAtom <- atomForAttributeName "status" tuple

130 cityAtom <- atomForAttributeName "city" tuple

152 cityAtom <- atomForAttributeName "city" tuple

131 if cityAtom == TextAtom "Paris" then

153 if cityAtom == TextAtom "Paris" then

132 Right $ updateTupleWithAtoms (M.singleton "status" (IntegerAtom (castInteger statusAtom + 10))) tuple

154 Right $ updateTupleWithAtoms (M.singleton "status" (IntegerAtom (castInteger statusAtom + 10))) tuple

133 else Right tuple) suppliersRel

155 else Right tuple) suppliersRel

156+ extendTestAttributes = A.attributesFromList [Attribute "a" IntegerAtomType, Attribute "b" $ RelationAtomType (R.attributes suppliersRel)]

134− dateExampleRelTests = [("x:=s where true", Right suppliersRel),

157+ testTups = [("x:=s where true", Right suppliersRel),

135− ("x:=s where city = \"London\"", restrict (\tuple -> pure $ atomForAttributeName "city" tuple == (Right $ TextAtom "London")) suppliersRel),

158+ ("x:=s where city = \"London\"", restrict (\tuple -> pure $ atomForAttributeName "city" tuple == Right (TextAtom "London")) suppliersRel),

136 ("x:=s where false", Right $ Relation (R.attributes suppliersRel) emptyTupleSet),

159 ("x:=s where false", Right $ Relation (R.attributes suppliersRel) emptyTupleSet),

137 ("x:=p where color=\"Blue\" and city=\"Paris\"", mkRelationFromList (R.attributes productsRel) [[TextAtom "P5", TextAtom "Cam", TextAtom "Blue", IntegerAtom 12, TextAtom "Paris"]]),

160 ("x:=p where color=\"Blue\" and city=\"Paris\"", mkRelationFromList (R.attributes productsRel) [[TextAtom "P5", TextAtom "Cam", TextAtom "Blue", IntegerAtom 12, TextAtom "Paris"]]),

138 ("a:=s; update a (status:=50); x:=a{status}", mkRelation (A.attributesFromList [Attribute "status" IntegerAtomType]) (RelationTupleSet [mkRelationTuple (A.attributesFromList [Attribute "status" IntegerAtomType]) (V.fromList [IntegerAtom 50])])),

161 ("a:=s; update a (status:=50); x:=a{status}", mkRelation (A.attributesFromList [Attribute "status" IntegerAtomType]) (RelationTupleSet [mkRelationTuple (A.attributesFromList [Attribute "status" IntegerAtomType]) (V.fromList [IntegerAtom 50])])),

@@ -140,7 +163,7 @@ main = do

140 --atom function tests

163 --atom function tests

141 ("x:=((s : {status2 := add(10,@status)}) where status2=add(10,@status)){city,s#,sname,status}", Right suppliersRel),

164 ("x:=((s : {status2 := add(10,@status)}) where status2=add(10,@status)){city,s#,sname,status}", Right suppliersRel),

142 ("x:=relation{tuple{a 5}} : {b:=s}", mkRelation extendTestAttributes (RelationTupleSet [mkRelationTuple extendTestAttributes (V.fromList [IntegerAtom 5, RelationAtom suppliersRel])])),

165 ("x:=relation{tuple{a 5}} : {b:=s}", mkRelation extendTestAttributes (RelationTupleSet [mkRelationTuple extendTestAttributes (V.fromList [IntegerAtom 5, RelationAtom suppliersRel])])),

143− ("x:=s; update x where sname=\"Blake\" (city:=\"Boston\")", relMap (\tuple -> if atomForAttributeName "sname" tuple == (Right $ TextAtom "Blake") then Right $ updateTupleWithAtoms (M.singleton "city" (TextAtom "Boston")) tuple else Right tuple) suppliersRel),

166+ ("x:=s; update x where sname=\"Blake\" (city:=\"Boston\")", relMap (\tuple -> if atomForAttributeName "sname" tuple == Right (TextAtom "Blake") then Right $ updateTupleWithAtoms (M.singleton "city" (TextAtom "Boston")) tuple else Right tuple) suppliersRel),

144 ("x:=s; update x where city=\"Paris\" (status:=add(@status,10))", updateParisPlus10),

167 ("x:=s; update x where city=\"Paris\" (status:=add(@status,10))", updateParisPlus10),

145 --relatom function tests

168 --relatom function tests

146 ("x:=((s group ({city} as y)):{z:=count(@y)}){z}", mkRelation groupCountAttrs (RelationTupleSet [mkRelationTuple groupCountAttrs (V.singleton $ IntegerAtom 1)])),

169 ("x:=((s group ({city} as y)):{z:=count(@y)}){z}", mkRelation groupCountAttrs (RelationTupleSet [mkRelationTuple groupCountAttrs (V.singleton $ IntegerAtom 1)])),

@@ -174,14 +197,17 @@ main = do

174 ("x:=relation{tuple{a fromGregorian(2017,05,30)}}", mkRelationFromList (A.attributesFromList [Attribute "a" DayAtomType]) [[DayAtom (fromGregorian 2017 05 30)]])

197 ("x:=relation{tuple{a fromGregorian(2017,05,30)}}", mkRelationFromList (A.attributesFromList [Attribute "a" DayAtomType]) [[DayAtom (fromGregorian 2017 05 30)]])

175 ]

198 ]

176

199

177−assertTutdEqual :: DatabaseContext -> Either RelationalError Relation -> Text -> Assertion

200+assertTutdEqual :: DatabaseContext -> TransactionId -> TransactionGraph -> Either RelationalError Relation -> Text -> Assertion

178−assertTutdEqual databaseContext expected tutd = assertEqual (unpack tutd) expected interpreted

201+assertTutdEqual databaseContext transId graph expected tutd = assertEqual (unpack tutd) expected interpreted

179 where

202 where

180− interpreted = case interpretDatabaseContextExpr databaseContext tutd of

203+ interpreted = case interpretDatabaseContextExpr databaseContext transId graph tutd of

181 Left err -> Left err

204 Left err -> Left err

182 Right context -> case M.lookup "x" (relationVariables context) of

205 Right context -> case M.lookup "x" (relationVariables context) of

183 Nothing -> Left $ RelVarNotDefinedError "x"

206 Nothing -> Left $ RelVarNotDefinedError "x"

184− Just rel -> Right rel

207+ Just relExpr -> do

208+ let env = freshGraphRefRelationalExprEnv (Just context) graph

209+ runGraphRefRelationalExprM env (evalGraphRefRelationalExpr relExpr)

210+

185

211

186transactionGraphBasicTest :: Test

212transactionGraphBasicTest :: Test

187transactionGraphBasicTest = TestCase $ do

213transactionGraphBasicTest = TestCase $ do

@@ -209,7 +235,7 @@ transactionGraphAddCommitTest = TestCase $ do

209 commit sessionId dbconn >>= eitherFail

235 commit sessionId dbconn >>= eitherFail

210 discon <- disconnectedTransaction_ sessionId dbconn

236 discon <- disconnectedTransaction_ sessionId dbconn

211 let context = Discon.concreteDatabaseContext discon

237 let context = Discon.concreteDatabaseContext discon

212− assertEqual "ensure x was added" (M.lookup "x" (relationVariables context)) (Just suppliersRel)

238+ assertEqual "ensure x was added" (M.lookup "x" (relationVariables context)) (Just (ExistingRelation suppliersRel))

213

239

214transactionRollbackTest :: Test

240transactionRollbackTest :: Test

215transactionRollbackTest = TestCase $ do

241transactionRollbackTest = TestCase $ do

@@ -251,12 +277,16 @@ transactionBranchTest = TestCase $ do

251

277

252-- test that overlapping attribute names with different types fail with an error

278-- test that overlapping attribute names with different types fail with an error

253failJoinTest :: Test

279failJoinTest :: Test

280+failJoinTest = TestCase $ do

281+ (graph, transId) <- freshTransactionGraph dateExamples

254−failJoinTest = TestCase $ assertTutdEqual basicDatabaseContext err "x:=relation{tuple{test 4}} join relation{tuple{test \"test\"}}"

282+ assertTutdEqual basicDatabaseContext transId graph err "x:=relation{tuple{test 4}} join relation{tuple{test \"test\"}}"

255 where

283 where

256 err = Left (TupleAttributeTypeMismatchError (A.attributesFromList [Attribute "test" IntegerAtomType]))

284 err = Left (TupleAttributeTypeMismatchError (A.attributesFromList [Attribute "test" IntegerAtomType]))

257

285

258simpleJoinTest :: Test

286simpleJoinTest :: Test

287+simpleJoinTest = TestCase $ do

288+ (graph, transId) <- freshTransactionGraph dateExamples

259−simpleJoinTest = TestCase $ assertTutdEqual dateExamples joinedRel "x:=s join sp"

289+ assertTutdEqual dateExamples transId graph joinedRel "x:=s join sp"

260 where

290 where

261 attrs = A.attributesFromList [Attribute "city" TextAtomType,

291 attrs = A.attributesFromList [Attribute "city" TextAtomType,

262 Attribute "qty" IntegerAtomType,

292 Attribute "qty" IntegerAtomType,

@@ -332,7 +362,7 @@ testComments :: Test

332testComments = TestCase $ do

362testComments = TestCase $ do

333 (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback

363 (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback

334 mapM_ (executeTutorialD sessionId dbconn) [

364 mapM_ (executeTutorialD sessionId dbconn) [

335− ":branch testbranch --test comment\n",

365+ ":branch testbranch --test comment",

336 ":jumphead {- test comment -} master"]

366 ":jumphead {- test comment -} master"]

337

367

338-- create a graph and query from two disparate contexts

368-- create a graph and query from two disparate contexts

@@ -383,7 +413,9 @@ testTransGraphRelationalExpr = TestCase $ do

383 _ -> assertFailure "failed to delete branch"

413 _ -> assertFailure "failed to delete branch"

384

414

385testMultiAttributeRename :: Test

415testMultiAttributeRename :: Test

416+testMultiAttributeRename = TestCase $ do

417+ (graph, transId) <- freshTransactionGraph dateExamples

386−testMultiAttributeRename = TestCase $ assertTutdEqual dateExamples renamedRel "x:=s rename {city as town, status as price} where false"

418+ assertTutdEqual dateExamples transId graph renamedRel "x:=s rename {city as town, status as price} where false"

387 where

419 where

388 sattrs = attributesFromList [Attribute "town" TextAtomType,

420 sattrs = attributesFromList [Attribute "town" TextAtomType,

389 Attribute "sname" TextAtomType,

421 Attribute "sname" TextAtomType,

@@ -468,16 +500,22 @@ testEmptyCommits = TestCase $ do

468 assertEqual "empty insert empty commit" (Right False) dirty'

500 assertEqual "empty insert empty commit" (Right False) dirty'

469 Right () <- commit sessionId dbconn

501 Right () <- commit sessionId dbconn

470

502

471− --update no tuples

503+ --update no tuples- since we defer the restriction, we can only assume the context is dirty, perhaps the constraint checker could offer an optimization here

472 Right () <- executeDatabaseContextExpr sessionId dbconn (Update "s" (M.singleton "sname" (NakedAtomExpr (TextAtom "Bob"))) (AttributeEqualityPredicate "sname" (NakedAtomExpr (TextAtom "Mike"))))

504 Right () <- executeDatabaseContextExpr sessionId dbconn (Update "s" (M.singleton "sname" (NakedAtomExpr (TextAtom "Bob"))) (AttributeEqualityPredicate "sname" (NakedAtomExpr (TextAtom "Mike"))))

473 dirty'' <- disconnectedTransactionIsDirty sessionId dbconn

505 dirty'' <- disconnectedTransactionIsDirty sessionId dbconn

474− assertEqual "empty update empty commit" (Right False) dirty''

506+ assertEqual "empty update empty commit" (Right True) dirty''

507+ Right () <- commit sessionId dbconn

508+

509+ --assign the same rel expr

510+ Right () <- executeDatabaseContextExpr sessionId dbconn (Assign "true" (ExistingRelation relationTrue))

511+ sameREdirty <- disconnectedTransactionIsDirty sessionId dbconn

512+ assertEqual "same relexpr assigned" (Right False) sameREdirty

475 Right () <- commit sessionId dbconn

513 Right () <- commit sessionId dbconn

476

514

477 --delete no tuples

515 --delete no tuples

478 Right () <- executeDatabaseContextExpr sessionId dbconn (Delete "s" (AttributeEqualityPredicate "sname" (NakedAtomExpr (TextAtom "Mike"))))

516 Right () <- executeDatabaseContextExpr sessionId dbconn (Delete "s" (AttributeEqualityPredicate "sname" (NakedAtomExpr (TextAtom "Mike"))))

479 dirty''' <- disconnectedTransactionIsDirty sessionId dbconn

517 dirty''' <- disconnectedTransactionIsDirty sessionId dbconn

480− assertEqual "empty delete empty commit" (Right False) dirty'''

518+ assertEqual "empty delete empty commit" (Right True) dirty'''

481

519

482testIntervalAtom :: Test

520testIntervalAtom :: Test

483testIntervalAtom = TestCase $ do

521testIntervalAtom = TestCase $ do

@@ -507,7 +545,7 @@ testListConstructedAtom = TestCase $ do

507testTypeChecker :: Test

545testTypeChecker :: Test

508testTypeChecker = TestCase $ do

546testTypeChecker = TestCase $ do

509 (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback

547 (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback

510− let err1 = "AtomFunctionTypeError \"max\" 1 (RelationAtomType [Attribute \"_\" IntegerAtomType]) IntegerAtomType"

548+ let err1 = "AtomFunctionTypeError \"max\" 1"

511 expectTutorialDErr sessionId dbconn (T.isPrefixOf err1) "x:=relation{tuple{a 0}}:{b:=max(@a)}"

549 expectTutorialDErr sessionId dbconn (T.isPrefixOf err1) "x:=relation{tuple{a 0}}:{b:=max(@a)}"

512

550

513--exercise expression parser

551--exercise expression parser

@@ -627,6 +665,10 @@ testWithClause = TestCase $ do

627 executeTutorialD sessionId dbconn "x:=with (x as s) x"

665 executeTutorialD sessionId dbconn "x:=with (x as s) x"

628 eX <- executeRelationalExpr sessionId dbconn (RelationVariable "x" ())

666 eX <- executeRelationalExpr sessionId dbconn (RelationVariable "x" ())

629 assertEqual "with x as s" (Right suppliersRel) eX

667 assertEqual "with x as s" (Right suppliersRel) eX

668+

669+ executeTutorialD sessionId dbconn "y:=with(a as true) (with (b as a) b)"

670+ eY <- executeRelationalExpr sessionId dbconn (RelationVariable "y" ())

671+ assertEqual "nested with" (Right relationTrue) eY

630

672

631 let err1 = "RelVarAlreadyDefinedError"

673 let err1 = "RelVarAlreadyDefinedError"

632 expectTutorialDErr sessionId dbconn (T.isPrefixOf err1) "x:=with (s as s) s"

674 expectTutorialDErr sessionId dbconn (T.isPrefixOf err1) "x:=with (s as s) s"

@@ -642,3 +684,49 @@ testAtomFunctionArgumentMismatch = TestCase $ do

642 --wrong argument count

684 --wrong argument count

643 let err2 = "FunctionArgumentCountMismatchError"

685 let err2 = "FunctionArgumentCountMismatchError"

644 expectTutorialDErr sessionId dbconn (T.isPrefixOf err2) "x:=relation{tuple{a 5}} where ^gt(@a,1,3)"

686 expectTutorialDErr sessionId dbconn (T.isPrefixOf err2) "x:=relation{tuple{a 5}} where ^gt(@a,1,3)"

687+

688+testInvalidDataConstructor :: Test

689+testInvalidDataConstructor = TestCase $ do

690+ --test that a referenced TypeConstructor in a DataConstructor definition matches the expected count of arguments

691+ (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback

692+ let err1 = "ConstructedAtomArgumentCountMismatchError"

693+ expectTutorialDErr sessionId dbconn (T.isPrefixOf err1) "data TestT = TestT Maybe Int"

694+

695+testBasicList :: Test

696+testBasicList = TestCase $ do

697+ (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback

698+ executeTutorialD sessionId dbconn "x := relation{tuple{ a (Cons 1 (Cons 2 Empty)) }}"

699+

700+testRelationDeclarationMismatch :: Test

701+testRelationDeclarationMismatch = TestCase $ do

702+ (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback

703+ expectTutorialDErr sessionId dbconn (T.isPrefixOf "AtomTypeMismatchError") "data A a = A a | B | C; a := relation{a A Integer}{tuple{a A \"1\"}}"

704+

705+--generate errors when the tuples in a new relation don't match

706+testInvalidTuples :: Test

707+testInvalidTuples = TestCase $ do

708+ (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback

709+ expectTutorialDErr sessionId dbconn (T.isPrefixOf "AttributeNamesMismatchError") ":showexpr relation{tuple{a 1},tuple{b 2}}"

710+ expectTutorialDErr sessionId dbconn (T.isPrefixOf "AttributeNamesMismatchError") ":showexpr relation{tuple{a 1},tuple{a 2, b 3}}"

711+-- expectTutorialDErr sessionId dbconn (T.isPrefixOf "ParseErrorBundle") ":showexpr relation{tuple{a 2, a 3}}" --parse failure can't be validated with this function

712+

713+testSelfReferencingUncommittedContext :: Test

714+testSelfReferencingUncommittedContext = TestCase $ do

715+ (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback

716+ executeTutorialD sessionId dbconn "s:=s union s"

717+ eS <- executeRelationalExpr sessionId dbconn (RelationVariable "s" ())

718+ _ <- rollback sessionId dbconn

719+ eSorig <- executeRelationalExpr sessionId dbconn (RelationVariable "s" ())

720+ assertEqual "s=s'" eSorig eS

721+

722+testUnionAndIntersectionAttributeExprs :: Test

723+testUnionAndIntersectionAttributeExprs = TestCase $ do

724+ (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback

725+ executeTutorialD sessionId dbconn "x:=s{intersection of {all but sname} {sname}}"

726+ xRel <- executeRelationalExpr sessionId dbconn (RelationVariable "x" ())

727+ assertEqual "intersection attrs" (Right relationTrue) xRel

728+

729+ executeTutorialD sessionId dbconn "y:=s{union of {all but sname} {sname}}"

730+ yRel <- executeRelationalExpr sessionId dbconn (RelationVariable "y" ())

731+ assertEqual "union attrs" (Right suppliersRel) yRel

732+

test/TutorialD/PrinterTest.hsnew file+47

@@ -0,0 +1,47 @@

1+{-# LANGUAGE OverloadedStrings #-}

2+import Test.HUnit

3+import ProjectM36.Base

4+import System.Exit

5+import Data.Text.Prettyprint.Doc

6+import Data.Map (fromList)

7+import TutorialD.Printer ()

8+import TutorialD.Interpreter.RelationalExpr

9+import Text.Megaparsec

10+import Data.Text (pack)

11+

12+testList :: Test

13+testList = TestList [

14+ testPretty "true" (RelationVariable "true" ()),

15+ testPretty "relation{tuple{a 3, b \"x\"}, tuple{a 4, b \"y\"}}" (MakeRelationFromExprs Nothing (TupleExprs () [TupleExpr (fromList [("a",NakedAtomExpr (IntegerAtom 3)),("b",NakedAtomExpr (TextAtom "x"))]),TupleExpr (fromList [("a",NakedAtomExpr (IntegerAtom 4)),("b",NakedAtomExpr (TextAtom "y"))])])),

16+ testPretty "true:{a:=1, b:=1}" (Extend (AttributeExtendTupleExpr "b" (NakedAtomExpr (IntegerAtom 1))) (Extend (AttributeExtendTupleExpr "a" (NakedAtomExpr (IntegerAtom 1))) (RelationVariable "true" ()))),

17+ testPretty "relation{tuple{a fromGregorian(2014, 2, 4)}}" (MakeRelationFromExprs Nothing (TupleExprs () [TupleExpr (fromList [("a",FunctionAtomExpr "fromGregorian" [NakedAtomExpr (IntegerAtom 2014),NakedAtomExpr (IntegerAtom 2),NakedAtomExpr (IntegerAtom 4)] ())])])),

18+ testPretty "relation{tuple{a bytestring(\"dGVzdGRhdGE=\")}}" (MakeRelationFromExprs Nothing (TupleExprs () [TupleExpr (fromList [("a",FunctionAtomExpr "bytestring" [NakedAtomExpr (TextAtom "dGVzdGRhdGE=")] ())])])),

19+ testPretty "relation{tuple{a t}}" (MakeRelationFromExprs Nothing (TupleExprs () [TupleExpr (fromList [("a",NakedAtomExpr (BoolAtom True))])])),

20+ testPretty "relation{tuple{a Cons 4 (Cons 5 Empty)}}" (MakeRelationFromExprs Nothing (TupleExprs () [TupleExpr (fromList [("a",ConstructedAtomExpr "Cons" [NakedAtomExpr (IntegerAtom 4),ConstructedAtomExpr "Cons" [NakedAtomExpr (IntegerAtom 5),ConstructedAtomExpr "Empty" [] ()] ()] ())])])),

21+ testPretty "relation{a Int, b Text, c Bool}{}" (MakeRelationFromExprs (Just [AttributeAndTypeNameExpr "a" (ADTypeConstructor "Int" []) (),AttributeAndTypeNameExpr "b" (ADTypeConstructor "Text" []) (),AttributeAndTypeNameExpr "c" (ADTypeConstructor "Bool" []) ()]) (TupleExprs () [])),

22+ testPretty "relation{a relation{b Int}}{}" (MakeRelationFromExprs (Just [AttributeAndTypeNameExpr "a" (RelationAtomTypeConstructor [AttributeAndTypeNameExpr "b" (ADTypeConstructor "Int" []) ()]) ()]) (TupleExprs () []))

23+ ]

24+

25+main :: IO ()

26+main = do

27+ tcounts <- runTestTT testList

28+ if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

29+

30+testPretty :: String -> RelationalExpr -> Test

31+testPretty tutdStr relExprADT =

32+ TestCase $ do

33+ let relExprStr = show (pretty relExprADT)

34+ print relExprStr

35+ roundTrip <- parseRelExpr relExprStr

36+ {-tutdIn <- parseRelExpr tutdStr

37+ print ("tutd parsed", tutdIn)-}

38+ assertEqual ("pretty ADT " <> tutdStr) tutdStr relExprStr

39+ assertEqual ("round-trip " <> tutdStr) relExprADT roundTrip

40+

41+--round trip tutoriald

42+parseRelExpr :: String -> IO RelationalExpr

43+parseRelExpr tutdStr =

44+ case parse relExprP "test" (pack tutdStr) of

45+ Left err ->

46+ assertFailure (show err)

47+ Right parsed -> pure parsed

test/scripts.hs+5−2

@@ -4,6 +4,8 @@ import TutorialD.Interpreter.Import.TutorialD

4import System.Directory

5import Data.List (isSuffixOf)

6import System.Exit

7+import qualified Data.Text as T

8+import Text.URI

7

9

8testList :: IO Test

10testList :: IO Test

9testList = do

11testList = do

@@ -20,7 +22,8 @@ main = do

20

22

21testScript :: FilePath -> Test

23testScript :: FilePath -> Test

22testScript tutdFile = TestCase $ do

24testScript tutdFile = TestCase $ do

23− eImport <- importTutorialD tutdFile

25+ fileURI <- mkURI (T.pack ("file://" <> tutdFile))

26+ eImport <- importTutorialDFromFile fileURI Nothing

24 case eImport of

27 case eImport of

25 Left err -> assertFailure ("tutd import failure in " ++ tutdFile ++ ": " ++ show err)

28 Left err -> assertFailure ("tutd import failure in " ++ tutdFile ++ ": " ++ show err)

26− Right _ -> pure ()

29+ Right _ -> pure ()