master..f843252 · project-m36

.github/workflows/ci.yaml+21−61

since splitsnapshots

unifiedsplit

@@ -6,64 +6,24 @@ jobs:

6 dockerimage:

7 runs-on: ubuntu-latest

8 steps:

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

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

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

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

11− with:

11+ with:

12− nix_path: nixpkgs=channel:nixos-unstable

12+ skip_adding_nixpkgs_channel: true

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

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

14− with:

14+ with:

15− name: project-m36

15+ name: project-m36

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

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

17− - run: cachix use iohk

17+ - run: cachix use iohk

18− - name: docker load

18+ - name: docker load

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

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

20− - name: docker login

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

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

23− - name: docker tag with version

22+ - name: docker tag with version

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

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

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

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

26− - name: docker tag latest

25+ - name: docker tag latest

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

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

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

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

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

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

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

29+ 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+1−3

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

18jupyter/itutd.egg-info

19jupyter/build

20juyter/dist

21−.ipynb_checkpoints

21+.ipynb_checkpoints

22−project-m36.nix

23−stack.yaml

.travis.ymlnew file+60

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

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.4.4 STACK_YAML=stack.ghc8.4.yaml

20+ compiler: ": #stack 8.4.4"

21+

22+ - env: CACHE_NAME=8.6.5 STACK_YAML=stack.ghc8.6.yaml

23+ compiler: ": #stack 8.6.5"

24+

25+ - env: CACHE_NAME=osx-8.6.5 STACK_YAML=stack.ghc8.6.yaml

26+ os: osx

27+ osx_image: xcode11

28+ compiler: ": #stack 8.6.5"

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.shnew file+25

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

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.shnew file+22

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

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.shnew file+16

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

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.shnew file+21

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

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.shnew file+27

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

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://get.haskellstack.org/stable/osx-x86_64.tar.gz | tar xz --strip-components=1 --include '*/stack' -C ~/.local/bin;

14+}

15+

16+fetch_stack_linux() {

17+ curl -sL https://get.haskellstack.org/stable/linux-x86_64.tar.gz | 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−17

@@ -1,20 +1,3 @@

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)

1# 2020-10-05 (v0.8.1)

19

2

20* support GHC 8.10

3* support GHC 8.10

README.markdown+3−2

@@ -4,6 +4,7 @@

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)

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[![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[![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

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

44

45

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

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

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

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

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

48+* IRC Channel: chat.freenode.net #project-m36

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

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

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

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

50

51

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

94

95

95## Development

96## Development

96

97

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

98+Project:M36 is developed in Haskell and compiled with GHC 8.2.2 or later.

98

99

99## Related Projects

100## Related Projects

100

101

cabal.project+5−2

@@ -1,7 +1,10 @@

1packages: project-m36.cabal

2

3+--RPC library

3−package *

4+source-repository-package

4− split-sections: True

5+ type: git

6+ location: https://github.com/agentm/curryer.git

7+ tag: 1e60c0580ca33d6ae1e97aaddc32189fdfe3ef6c

5

8

6--high-performance streaming library

9--high-performance streaming library

7source-repository-package

10source-repository-package

docker.nix+11−16

@@ -1,18 +1,13 @@

1−{ compiler ? "ghc8104"

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

1+{ pkgs ? import ./pkgs.nix }:

3−, pkgs ? import sources.nixpkgs { }

4−}:

5let

2let

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

3+ release = import ./release.nix { inherit pkgs; };

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

4+ static-project-m36 = pkgs.haskell.lib.justStaticExecutables release.project;

8in

5in

9−pkgs.dockerTools.buildImage {

6+ pkgs.dockerTools.buildImage {

10− name = "project-m36";

7+ name = "project-m36";

11− tag = "latest";

8+ tag = "latest";

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

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

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

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

14− config = {

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

11+ config = { Env = ["LC_ALL=en_US.UTF-8"];

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

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

17− };

18−}

13+ }

docs/15_minute_tutorial.markdown+67−64

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

4

5## Prerequisites

6

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

7+* any Linux

8+* GHC 8.2 or later version (Haskell compiler)

9+* cabal (package downloader) installed

8

10

9## Download and Install

11## Download and Install

10

12

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−

17```bash

13```bash

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

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

15+cabal sandbox init

16+cabal install --dependencies-only

19−cabal new-run tutd

17+cabal run tutd

20```

18```

21

19

22## Some Basic TutorialD

20## Some Basic TutorialD

@@ -28,10 +26,18 @@ Note that TutorialD is strongly-typed- no type coercions take place automaticall

28### Load the Canonical Chris Date Example

26### Load the Canonical Chris Date Example

29

27

30```

28```

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

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

30+```

31+

32+or

33+

34+```

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

32```

36```

33

37

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.

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.

39+

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

35

41

36### Execute Relational Expressions

42### Execute Relational Expressions

37

43

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

158#### Create a Relation Variable

164#### Create a Relation Variable

159

165

160```

166```

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

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

162TutorialD (master/main): :showexpr x

168TutorialD (master/main): :showexpr x

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

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

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

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

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

173#### Insert Additional Tuples

179#### Insert Additional Tuples

174

180

175```

181```

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

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

177TutorialD (master/main): :showexpr x

183TutorialD (master/main): :showexpr x

178−┌────────────┬──────────┐

184+┌────────┬──────────┐

179−│age::Integer│name::Text│

185+│age::Int│name::Text│

180−├────────────┼──────────┤

186+├────────┼──────────┤

187+│40 │"Steve" │

181−│31 │"Mike" │

188+│31 │"Mike" │

182−│40 │"Steve" │

183−└────────────┴──────────┘

189+└────────┴──────────┘

184−

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

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

186TutorialD (master/main): :showexpr x

191TutorialD (master/main): :showexpr x

187−┌────────────┬──────────┐

192+┌────────┬──────────┐

188−│age::Integer│name::Text│

193+│age::Int│name::Text│

189−├────────────┼──────────┤

194+├────────┼──────────┤

190−│31 │"Mike" │

191−│40 │"Steve" │

195+│40 │"Steve" │

192−│24 │"Bob" │

196+│24 │"Bob" │

197+│31 │"Mike" │

193−└────────────┴──────────┘

198+└────────┴──────────┘

194−

195```

199```

196

200

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

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

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

200

204

201```

205```

202TutorialD (master/main): :showexpr s

206TutorialD (master/main): :showexpr s

203−┌──────────┬────────┬───────────┬───────────────┐

207+┌──────────┬────────┬───────────┬───────────┐

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

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

205−├──────────┼────────┼───────────┼───────────────┤

209+├──────────┼────────┼───────────┼───────────┤

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

211+│"Paris" │"S3" │"Blake" │30 │

206−│"London" │"S1" │"Smith" │20 │

212+│"London" │"S1" │"Smith" │20 │

213+│"London" │"S4" │"Clark" │20 │

207−│"Athens" │"S5" │"Adams" │30 │

214+│"Athens" │"S5" │"Adams" │30 │

208−│"Paris" │"S3" │"Blake" │30 │

209−│"London" │"S4" │"Clark" │20 │

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

211−└──────────┴────────┴───────────┴───────────────┘

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

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

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

213TutorialD (master/main): :showexpr s

217TutorialD (master/main): :showexpr s

214−┌──────────┬────────┬───────────┬───────────────┐

218+┌──────────┬────────┬───────────┬───────────┐

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

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

216−├──────────┼────────┼───────────┼───────────────┤

220+├──────────┼────────┼───────────┼───────────┤

217−│"Athens" │"S5" │"Adams" │30 │

221+│"London" │"S4" │"Clark" │35 │

218−│"London" │"S1" │"Smith" │35 │

222+│"London" │"S1" │"Smith" │35 │

219−│"London" │"S4" │"Clark" │35 │

220−│"Paris" │"S3" │"Blake" │30 │

221−│"Paris" │"S2" │"Jones" │10 │

223+│"Paris" │"S2" │"Jones" │10 │

224+│"Paris" │"S3" │"Blake" │30 │

225+│"Athens" │"S5" │"Adams" │30 │

222−└──────────┴────────┴───────────┴───────────────┘

226+└──────────┴────────┴───────────┴───────────┘

223−

224```

227```

225#### Deleting Tuples from a Relation Variable

228#### Deleting Tuples from a Relation Variable

226

229

227```

230```

228TutorialD (master/main): :showexpr s

231TutorialD (master/main): :showexpr s

229−┌──────────┬────────┬───────────┬───────────────┐

232+┌──────────┬────────┬───────────┬───────────┐

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

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

231−├──────────┼────────┼───────────┼───────────────┤

234+├──────────┼────────┼───────────┼───────────┤

232−│"Paris" │"S2" │"Jones" │10 │

235+│"Paris" │"S2" │"Jones" │10 │

233−│"Paris" │"S3" │"Blake" │30 │

236+│"Paris" │"S3" │"Blake" │30 │

234−│"London" │"S1" │"Smith" │20 │

237+│"London" │"S1" │"Smith" │20 │

238+│"London" │"S4" │"Clark" │20 │

235−│"Athens" │"S5" │"Adams" │30 │

239+│"Athens" │"S5" │"Adams" │30 │

236−│"London" │"S4" │"Clark" │20 │

237−└──────────┴────────┴───────────┴───────────────┘

240+└──────────┴────────┴───────────┴───────────┘

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

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

239TutorialD (master/main): :showexpr s

242TutorialD (master/main): :showexpr s

240−┌──────────┬────────┬───────────┬───────────────┐

243+┌──────────┬────────┬───────────┬───────────┐

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

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

242−├──────────┼────────┼───────────┼───────────────┤

245+├──────────┼────────┼───────────┼───────────┤

243−│"Paris" │"S2" │"Jones" │10 │

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

244−│"London" │"S4" │"Clark" │20 │

245−│"Paris" │"S3" │"Blake" │30 │

247+│"Paris" │"S3" │"Blake" │30 │

246−│"London" │"S1" │"Smith" │20 │

248+│"London" │"S1" │"Smith" │20 │

249+│"London" │"S4" │"Clark" │20 │

247−└──────────┴────────┴───────────┴───────────────┘

250+└──────────┴────────┴───────────┴───────────┘

248```

251```

249

252

250### Execute Transaction Graph Expressions

253### Execute Transaction Graph Expressions

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

267

270

268```

271```

269TutorialD (master/main): :branch experimental

272TutorialD (master/main): :branch experimental

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

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

271TutorialD (experimental): :commit

274TutorialD (experimental): :commit

272```

275```

273

276

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 cjdate

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

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 cjdate

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

41TutorialD (master/main): :showexpr s

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

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

docs/introduction_to_projectm36.markdown+2−2

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

51

52To build with stack:

53

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

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

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

56* Linux, macOS, or Microsoft Windows

57

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

63

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

65

66−Alternative building with GHC 8.6.5 or greater:

66+Alternative building with GHC 8.4.4 or greater:

67

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

69

docs/introduction_to_the_relational_algebra.markdown+1−1

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

202

203(Course Relation)

204

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

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

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

207|English 1|Steve|Room 104|

208|French 2|Bob|Room 103|

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 cjdate

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

61TutorialD (master/main): :showexpr p

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

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

docs/tutd_cheatsheet.markdown+1−3

@@ -47,9 +47,7 @@ Database context expressions take the current database context as input and alte

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`|

50+|`:importexample date`|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`|

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

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

52|`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|

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

docs/tutd_tutorial.markdown+2−56

@@ -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 cjdate

22+:importexample date

23```

24

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

@@ -30,24 +30,6 @@ 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−

51### Types

33### Types

52

34

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

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

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

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

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

216```

198```

217

199

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

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

219

201

220```

202```

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

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

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

231

213

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

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

233

215

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−

270#### Restriction

216#### Restriction

271

217

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

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

examples/Plantfarm.hsdeleted−446

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

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/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 Integer --dollars

6+data Price = Price Double

7data RoomType = Kitchen | Bathroom | LivingRoom

8−data PriceBand = Low | Med | High | Premium

8+data PriceBand = Low | Medium | 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(@price,Price 2000)) 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(offerPrice,2000.0)) 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 cjdate"

41+ ":importexample date"

42 ]

43 },

44 {

nix/sources.jsondeleted−50

@@ -1,50 +0,0 @@

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.nixdeleted−171

@@ -1,171 +0,0 @@

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); }

pkgs.nixnew file+7

@@ -0,0 +1,7 @@

1+let

2+nixpkgs = builtins.fetchGit {

3+ url = "https://github.com/NixOS/nixpkgs";

4+ rev = "f58482658eabf7d695f45904ecbc5f49c19fef98";

5+};

6+in

7+import nixpkgs { config.allowBroken = true; }

project-m36.cabal+118−105

@@ -1,8 +1,7 @@

1Cabal-Version: 2.2

2Name: project-m36

3−Version: 0.9.3

3+Version: 0.9.0

4−License: MIT

4+License: Unlicense

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

6Build-Type: Simple

5Build-Type: Simple

7Homepage: https://github.com/agentm/project-m36

6Homepage: https://github.com/agentm/project-m36

8Bug-Reports: https://github.com/agentm/project-m36/issues

7Bug-Reports: https://github.com/agentm/project-m36/issues

@@ -35,7 +34,7 @@ Flag haskell-scripting

35 Default: True

34 Default: True

36

35

37Library

36Library

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

37+ 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, network-transport, 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.3, winery, curryer, network

39 if flag(haskell-scripting)

38 if flag(haskell-scripting)

40 Build-Depends: ghc >= 8.2 && < 8.11

39 Build-Depends: ghc >= 8.2 && < 8.11

41 CPP-Options: -DPM36_HASKELL_SCRIPTING

40 CPP-Options: -DPM36_HASKELL_SCRIPTING

@@ -63,7 +62,6 @@ Library

63 ProjectM36.AtomFunction,

62 ProjectM36.AtomFunction,

64 ProjectM36.AtomFunctionError,

63 ProjectM36.AtomFunctionError,

65 ProjectM36.ScriptSession,

64 ProjectM36.ScriptSession,

66− ProjectM36.Shortcuts,

67 ProjectM36.DatabaseContextFunction,

65 ProjectM36.DatabaseContextFunction,

68 ProjectM36.DatabaseContextFunctionError,

66 ProjectM36.DatabaseContextFunctionError,

69 ProjectM36.DatabaseContextFunctionUtils,

67 ProjectM36.DatabaseContextFunctionUtils,

@@ -118,6 +116,7 @@ Library

118 ProjectM36.Serialise.DataFrame,

116 ProjectM36.Serialise.DataFrame,

119 ProjectM36.Serialise.DatabaseContextFunctionError,

117 ProjectM36.Serialise.DatabaseContextFunctionError,

120 ProjectM36.Serialise.IsomorphicSchema,

118 ProjectM36.Serialise.IsomorphicSchema,

119+ ProjectM36.Server.Types,

121 ProjectM36.Session,

120 ProjectM36.Session,

122 ProjectM36.Sessions,

121 ProjectM36.Sessions,

123 ProjectM36.Transaction.Persist,

122 ProjectM36.Transaction.Persist,

@@ -136,14 +135,14 @@ Library

136 Other-Modules: ProjectM36.Win32Handle

135 Other-Modules: ProjectM36.Win32Handle

137 else

136 else

138 --219- too many exported symbols under Windows and GHC 8.4

137 --219- too many exported symbols under Windows and GHC 8.4

139− GHC-Options: -rdynamic -fexternal-interpreter

138+ GHC-Options: -rdynamic

140 C-sources: cbits/DirectoryFsync.c, cbits/darwin_statfs.c

139 C-sources: cbits/DirectoryFsync.c, cbits/darwin_statfs.c

141 Build-Depends: unix

140 Build-Depends: unix

142 CC-Options: -fPIC

141 CC-Options: -fPIC

143 Hs-Source-Dirs: ./src/lib

142 Hs-Source-Dirs: ./src/lib

144 Default-Language: Haskell2010

143 Default-Language: Haskell2010

145 Default-Extensions: OverloadedStrings, CPP

144 Default-Extensions: OverloadedStrings, CPP

146− if !flag(stack)

145+ if !flag(stack)

147 Build-Depends: deferred-folds

146 Build-Depends: deferred-folds

148

147

149Executable tutd

148Executable tutd

@@ -175,7 +174,7 @@ Executable tutd

175 directory,

174 directory,

176 filepath,

175 filepath,

177 temporary,

176 temporary,

178− megaparsec >= 5.2.0 && < 10,

177+ megaparsec >= 5.2.0 && < 9,

179 haskeline,

178 haskeline,

180 random, MonadRandom,

179 random, MonadRandom,

181 base64-bytestring,

180 base64-bytestring,

@@ -184,14 +183,7 @@ Executable tutd

184 stm-containers >= 1.0.0,

183 stm-containers >= 1.0.0,

185 list-t,

184 list-t,

186 parser-combinators,

185 parser-combinators,

187− curryer-rpc,

186+ curryer

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

195 Other-Modules: TutorialD.Interpreter,

187 Other-Modules: TutorialD.Interpreter,

196 TutorialD.Interpreter.Base,

188 TutorialD.Interpreter.Base,

197 TutorialD.Interpreter.DatabaseContextExpr,

189 TutorialD.Interpreter.DatabaseContextExpr,

@@ -210,7 +202,6 @@ Executable tutd

210 TutorialD.Interpreter.SchemaOperator,

202 TutorialD.Interpreter.SchemaOperator,

211 TutorialD.Interpreter.TransGraphRelationalOperator,

203 TutorialD.Interpreter.TransGraphRelationalOperator,

212 TutorialD.Interpreter.SchemaOperator

204 TutorialD.Interpreter.SchemaOperator

213− TutorialD.Printer

214 main-is: TutorialD/tutd.hs

205 main-is: TutorialD/tutd.hs

215 CC-Options: -fPIC

206 CC-Options: -fPIC

216 GHC-Options: -Wall -threaded

207 GHC-Options: -Wall -threaded

@@ -223,8 +214,8 @@ Executable project-m36-server

223 Build-Depends: ghc >= 8.2 && < 8.11

214 Build-Depends: ghc >= 8.2 && < 8.11

224 Build-Depends: base,

215 Build-Depends: base,

225 ghc-paths,

216 ghc-paths,

226− transformers,

227 project-m36,

217 project-m36,

218+ transformers,

228 temporary,

219 temporary,

229 data-interval,

220 data-interval,

230 deepseq,

221 deepseq,

@@ -237,6 +228,7 @@ Executable project-m36-server

237 optparse-applicative,

228 optparse-applicative,

238 hashable-time,

229 hashable-time,

239 time,

230 time,

231+ vector-binary-instances,

240 text,

232 text,

241 deepseq-generics,

233 deepseq-generics,

242 mtl,

234 mtl,

@@ -258,7 +250,7 @@ Executable project-m36-server

258Executable bigrel

250Executable bigrel

259 Default-Language: Haskell2010

251 Default-Language: Haskell2010

260 Default-Extensions: OverloadedStrings

252 Default-Extensions: OverloadedStrings

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

253+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, 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

262 Other-Modules: TutorialD.Interpreter.Base,

254 Other-Modules: TutorialD.Interpreter.Base,

263 TutorialD.Interpreter.DatabaseContextExpr,

255 TutorialD.Interpreter.DatabaseContextExpr,

264 TutorialD.Interpreter.RelationalExpr,

256 TutorialD.Interpreter.RelationalExpr,

@@ -270,11 +262,11 @@ Executable bigrel

270 GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall

262 GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall

271

263

272Common commontest

264Common commontest

273− Default-Language: Haskell2010

265+ 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

266+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, 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

275 Default-Extensions: OverloadedStrings

267 Default-Extensions: OverloadedStrings

276 GHC-Options: -Wall -threaded

268 GHC-Options: -Wall -threaded

277− Hs-Source-Dirs: test, src/bin

269+ Hs-Source-Dirs: ./src/bin, ., test/

278

270

279Benchmark basic-benchmark

271Benchmark basic-benchmark

280 Default-Language: Haskell2010

272 Default-Language: Haskell2010

@@ -287,131 +279,121 @@ Benchmark basic-benchmark

287 if flag(profiler)

279 if flag(profiler)

288 GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall

280 GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall

289

281

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−

302Test-Suite test-tutoriald

282Test-Suite test-tutoriald

303 import: commontest

283 import: commontest

304 type: exitcode-stdio-1.0

284 type: exitcode-stdio-1.0

305− main-is: TutorialD/InterpreterTest.hs

285+ main-is: test/TutorialD/Interpreter.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

286+ 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

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

308

287

309Test-Suite test-tutoriald-atomfunctionscript

288Test-Suite test-tutoriald-atomfunctionscript

310 import: commontest

289 import: commontest

311 type: exitcode-stdio-1.0

290 type: exitcode-stdio-1.0

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

291+ 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

313− main-is: TutorialD/Interpreter/AtomFunctionScript.hs

292+ main-is: test/TutorialD/Interpreter/AtomFunctionScript.hs

314

293

315Test-Suite test-tutoriald-databasecontextfunctionscript

294Test-Suite test-tutoriald-databasecontextfunctionscript

316 import: commontest

295 import: commontest

317 type: exitcode-stdio-1.0

296 type: exitcode-stdio-1.0

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

297+ 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

319− main-is: TutorialD/Interpreter/DatabaseContextFunctionScript.hs

298+ main-is: test/TutorialD/Interpreter/DatabaseContextFunctionScript.hs

320

299

321Test-Suite test-relation

300Test-Suite test-relation

322 import: commontest

301 import: commontest

323 type: exitcode-stdio-1.0

302 type: exitcode-stdio-1.0

324− main-is: Relation/Basic.hs

303+ main-is: test/Relation/Basic.hs

325

304

326Test-Suite test-static-optimizer

305Test-Suite test-static-optimizer

327 import: commontest

306 import: commontest

328 type: exitcode-stdio-1.0

307 type: exitcode-stdio-1.0

329− main-is: Relation/StaticOptimizer.hs

308+ main-is: test/Relation/StaticOptimizer.hs

330

309

331Test-Suite test-transactiongraph-persist

310Test-Suite test-transactiongraph-persist

332 import: commontest

311 import: commontest

333 type: exitcode-stdio-1.0

312 type: exitcode-stdio-1.0

334− main-is: TransactionGraph/Persist.hs

313+ main-is: test/TransactionGraph/Persist.hs

335− Other-Modules: TutorialD.Interpreter.Base, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.Types, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Printer

314+ Other-Modules: TutorialD.Interpreter.Base, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.Types, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.Import.BasicExamples

336

315

337Test-Suite test-relation-import-csv

316Test-Suite test-relation-import-csv

338 import: commontest

317 import: commontest

339 type: exitcode-stdio-1.0

318 type: exitcode-stdio-1.0

340− main-is: Relation/Import/CSV.hs

319+ main-is: test/Relation/Import/CSV.hs

341

320

342Test-Suite test-tutoriald-import-tutoriald

321Test-Suite test-tutoriald-import-tutoriald

343− import: commontest

322+ Default-Language: Haskell2010

323+ Default-Extensions: OverloadedStrings

344 type: exitcode-stdio-1.0

324 type: exitcode-stdio-1.0

345− main-is: TutorialD/Interpreter/Import/ImportTest.hs

325+ main-is: test/TutorialD/Interpreter/Import/TutorialD.hs

326+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, 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, project-m36, random, MonadRandom, semigroups, parser-combinators

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

327+ 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

328+ GHC-Options: -Wall -threaded

329+ Hs-Source-Dirs: ., ./src/bin

347

330

348Test-Suite test-relation-export-csv

331Test-Suite test-relation-export-csv

349− import: commontest

332+ Default-Language: Haskell2010

333+ Default-Extensions: OverloadedStrings

350 type: exitcode-stdio-1.0

334 type: exitcode-stdio-1.0

351− main-is: Relation/Export/CSV.hs

335+ main-is: test/Relation/Export/CSV.hs

336+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, 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, project-m36

337+ GHC-Options: -Wall -threaded

352

338

353Test-Suite test-transactiongraph-merge

339Test-Suite test-transactiongraph-merge

354− import: commontest

340+ Default-Language: Haskell2010

355− type: exitcode-stdio-1.0

341+ Default-Extensions: OverloadedStrings

356− main-is: TransactionGraph/Merge.hs

357−

358−

359−Test-Suite test-prettyprinter

360− import: commontest

361 type: exitcode-stdio-1.0

342 type: exitcode-stdio-1.0

362− main-is: TutorialD/PrinterTest.hs

343+ main-is: test/TransactionGraph/Merge.hs

363− Other-Modules: TutorialD.Printer, TutorialD.Interpreter.Base, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.Types

344+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,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

345+ GHC-Options: -Wall -threaded

364

346

365benchmark bench

347benchmark bench

366− import: commontest

348+ Default-Language: Haskell2010

349+ Default-Extensions: OverloadedStrings

367 type: exitcode-stdio-1.0

350 type: exitcode-stdio-1.0

368 main-is: benchmark/Relation.hs

351 main-is: benchmark/Relation.hs

352+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, criterion, stm-containers, project-m36

353+ GHC-Options: -Wall -rtsopts -threaded

354+ Hs-Source-Dirs: ./src/bin

369

355

370Test-Suite test-server

356Test-Suite test-server

371− import: commontest

357+ Default-Language: Haskell2010

358+ Default-Extensions: OverloadedStrings

372 type: exitcode-stdio-1.0

359 type: exitcode-stdio-1.0

373− main-is: Server/Main.hs

360+ main-is: test/Server/Main.hs

374−

361+ 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,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, project-m36, network-transport, semigroups

362+ HS-Source-Dirs: ., ./src/bin

363+ GHC-Options: -Wall -threaded

375

364

376Executable Example-SimpleClient

365Executable Example-SimpleClient

377 Default-Language: Haskell2010

366 Default-Language: Haskell2010

378 Default-Extensions: OverloadedStrings

367 Default-Extensions: OverloadedStrings

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

368+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, 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

380 Main-Is: examples/SimpleClient.hs

369 Main-Is: examples/SimpleClient.hs

381 GHC-Options: -Wall -threaded

370 GHC-Options: -Wall -threaded

382

371

383Executable Example-OutOfTheTarpit

372Executable Example-OutOfTheTarpit

384 Default-Language: Haskell2010

373 Default-Language: Haskell2010

385 Default-Extensions: OverloadedStrings

374 Default-Extensions: OverloadedStrings

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

375+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, 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

387 Main-Is: examples/out_of_the_tarpit.hs

376 Main-Is: examples/out_of_the_tarpit.hs

388 GHC-Options: -Wall -threaded

377 GHC-Options: -Wall -threaded

389

378

390Executable Example-Blog

379Executable Example-Blog

391 Default-Language: Haskell2010

380 Default-Language: Haskell2010

392 Default-Extensions: OverloadedStrings

381 Default-Extensions: OverloadedStrings

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

382+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, 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

394 Main-Is: examples/blog.hs

383 Main-Is: examples/blog.hs

395 GHC-Options: -Wall -threaded

384 GHC-Options: -Wall -threaded

396

385

397Executable Example-Hair

386Executable Example-Hair

398 Default-Language: Haskell2010

387 Default-Language: Haskell2010

399 Default-Extensions: OverloadedStrings

388 Default-Extensions: OverloadedStrings

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+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, 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

401 Main-Is: examples/hair.hs

390 Main-Is: examples/hair.hs

402 GHC-Options: -Wall -threaded

391 GHC-Options: -Wall -threaded

403

392

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−

411Executable Example-CustomTupleable

393Executable Example-CustomTupleable

412 Default-Language: Haskell2010

394 Default-Language: Haskell2010

413 Default-Extensions: OverloadedStrings

395 Default-Extensions: OverloadedStrings

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+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, 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

415 Main-Is: examples/CustomTupleable.hs

397 Main-Is: examples/CustomTupleable.hs

416 GHC-Options: -Wall -threaded

398 GHC-Options: -Wall -threaded

417

399

@@ -426,63 +408,95 @@ Executable Example-DerivingCustomTupleable

426 GHC-Options: -Wall -threaded

408 GHC-Options: -Wall -threaded

427

409

428Test-Suite test-scripts

410Test-Suite test-scripts

429− import: commontest

411+ Default-Language: Haskell2010

412+ Default-Extensions: OverloadedStrings

430 type: exitcode-stdio-1.0

413 type: exitcode-stdio-1.0

431− main-is: scripts.hs

414+ main-is: test/scripts.hs

415+ 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,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, project-m36, random, MonadRandom, semigroups, parser-combinators

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

416+ 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

417+ GHC-Options: -Wall -threaded

418+ Hs-Source-Dirs: ., ./src/bin

433

419

434Executable project-m36-websocket-server

420Executable project-m36-websocket-server

435 Default-Language: Haskell2010

421 Default-Language: Haskell2010

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

422+ 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, parser-combinators, network

437 Main-Is: ProjectM36/Server/WebSocket/websocket-server.hs

423 Main-Is: ProjectM36/Server/WebSocket/websocket-server.hs

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

424+ 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

439 GHC-Options: -Wall -threaded

425 GHC-Options: -Wall -threaded

440 Hs-Source-Dirs: ./src/bin

426 Hs-Source-Dirs: ./src/bin

441 Default-Extensions: OverloadedStrings

427 Default-Extensions: OverloadedStrings

442

428

443Test-Suite test-websocket-server

429Test-Suite test-websocket-server

444− import: commontest

430+ Default-Language: Haskell2010

445 type: exitcode-stdio-1.0

431 type: exitcode-stdio-1.0

446− main-is: Server/WebSocket.hs

432+ main-is: test/Server/WebSocket.hs

433+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, 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, network-transport-tcp, semigroups, parser-combinators

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

434+ 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

435+ Default-Extensions: OverloadedStrings

436+ GHC-Options: -Wall -threaded

437+ Hs-Source-Dirs: ./src/bin, .

448

438

449Test-Suite test-isomorphic-schemas

439Test-Suite test-isomorphic-schemas

450− import: commontest

440+ Default-Language: Haskell2010

451 type: exitcode-stdio-1.0

441 type: exitcode-stdio-1.0

452− main-is: IsomorphicSchema.hs

442+ main-is: test/IsomorphicSchema.hs

443+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, 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

444+ Default-Extensions: OverloadedStrings

445+ GHC-Options: -Wall -threaded

446+ Hs-Source-Dirs: ./src/bin, .

453

447

454Test-Suite test-atomable

448Test-Suite test-atomable

455− import: commontest

449+ Default-Language: Haskell2010

456 type: exitcode-stdio-1.0

450 type: exitcode-stdio-1.0

457− main-is: Relation/Atomable.hs

451+ main-is: test/Relation/Atomable.hs

452+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, 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

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

453+ 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

454+ Default-Extensions: OverloadedStrings

455+ GHC-Options: -Wall -threaded

456+ Hs-Source-Dirs: ./src/bin, ., test/

459

457

460Test-Suite test-multiprocess-access

458Test-Suite test-multiprocess-access

461− import: commontest

459+ Default-Language: Haskell2010

462 type: exitcode-stdio-1.0

460 type: exitcode-stdio-1.0

463− main-is: MultiProcessDatabaseAccess.hs

461+ main-is: test/MultiProcessDatabaseAccess.hs

462+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, 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

463+ Default-Extensions: OverloadedStrings

464+ GHC-Options: -Wall -threaded

465+ Hs-Source-Dirs: ./src/bin, ., test/

464

466

465Test-Suite test-transactiongraph-automerge

467Test-Suite test-transactiongraph-automerge

466− import: commontest

468+ Default-Language: Haskell2010

467 type: exitcode-stdio-1.0

469 type: exitcode-stdio-1.0

468− main-is: TransactionGraph/Automerge.hs

470+ main-is: test/TransactionGraph/Automerge.hs

471+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, 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

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

472+ 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

473+ Default-Extensions: OverloadedStrings

474+ GHC-Options: -Wall -threaded

475+ Hs-Source-Dirs: ./src/bin, ., test/

470

476

471Test-Suite test-tupleable

477Test-Suite test-tupleable

472− import: commontest

478+ Default-Language: Haskell2010

473 type: exitcode-stdio-1.0

479 type: exitcode-stdio-1.0

474− main-is: Relation/Tupleable.hs

480+ main-is: test/Relation/Tupleable.hs

481+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, 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

482+ Default-Extensions: OverloadedStrings

483+ GHC-Options: -Wall -threaded

484+ Hs-Source-Dirs: ./src/bin, ., test/

475

485

476Test-Suite test-client-simple

486Test-Suite test-client-simple

477− import: commontest

487+ Default-Language: Haskell2010

478− Main-Is: Client/Simple.hs

488+ Main-Is: test/Client/Simple.hs

479 type: exitcode-stdio-1.0

489 type: exitcode-stdio-1.0

490+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, 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

491+ Default-Extensions: OverloadedStrings

492+ GHC-Options: -Wall -threaded

493+ Hs-Source-Dirs: ./src/bin, ., test/

480

494

481-- test for file handle leaks

495-- test for file handle leaks

482Executable handles

496Executable handles

483 Default-Language: Haskell2010

497 Default-Language: Haskell2010

484 Default-Extensions: OverloadedStrings

498 Default-Extensions: OverloadedStrings

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

499+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, 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

486 main-is: benchmark/Handles.hs

500 main-is: benchmark/Handles.hs

487 Other-Modules: TutorialD.Interpreter,

501 Other-Modules: TutorialD.Interpreter,

488 TutorialD.Interpreter.Base,

502 TutorialD.Interpreter.Base,

@@ -501,14 +515,13 @@ Executable handles

501 TutorialD.Interpreter.TransGraphRelationalOperator,

515 TutorialD.Interpreter.TransGraphRelationalOperator,

502 TutorialD.Interpreter.TransactionGraphOperator,

516 TutorialD.Interpreter.TransactionGraphOperator,

503 TutorialD.Interpreter.Types

517 TutorialD.Interpreter.Types

504− TutorialD.Printer

505 GHC-Options: -Wall -threaded -rtsopts

518 GHC-Options: -Wall -threaded -rtsopts

506 HS-Source-Dirs: ./src/bin

519 HS-Source-Dirs: ./src/bin

507 if flag(profiler)

520 if flag(profiler)

508 GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall

521 GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall

509−

522+

510Test-Suite test-dataframe

523Test-Suite test-dataframe

511− import: commontest

524+ import: commontest

525+ Main-Is: test/DataFrame.hs

512− type: exitcode-stdio-1.0

526+ type: exitcode-stdio-1.0

513− Main-Is: DataFrame.hs

527+

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

release.nix+58−17

@@ -1,30 +1,71 @@

1−{ compiler ? "ghc8104"

1+{ compiler ? "ghc865"

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

2+, pkgs ? import ./pkgs.nix

3−, pkgs ? import sources.nixpkgs { }

4}:

3}:

4+

5let

6+ inherit (pkgs.lib.trivial) flip pipe;

7+ inherit (pkgs.haskell.lib) appendPatch appendConfigureFlags;

6 doJailbreak = pkgs.haskell.lib.doJailbreak;

8 doJailbreak = pkgs.haskell.lib.doJailbreak;

7− needsCocoa = drv:

9+ dontHaddock = pkgs.haskell.lib.dontHaddock;

8− if pkgs.stdenv.isDarwin

10+ dontCheck = pkgs.haskell.lib.dontCheck;

9− then drv.overrideDerivation (old:

11+ distProcessPkg = pkg : dontHaddock (doJailbreak (dontCheck pkg));

10− { buildInputs = [ pkgs.darwin.apple_sdk.frameworks.Cocoa ] ++ old.buildInputs; }

12+ callHackageDirectWithOptions = {pkg,ver, sha256, options}:

11− )

13+ let pkgver = "${pkg}-${ver}";

12− else drv;

14+ in

13−

15+ haskellPackages.callCabal2nixWithOptions pkg (pkgs.fetchzip {

16+ url = "mirror://hackage/${pkgver}/${pkgver}.tar.gz";

17+ inherit sha256;

18+ }) options;

19+

14 haskellPackages = pkgs.haskell.packages.${compiler}.override {

20 haskellPackages = pkgs.haskell.packages.${compiler}.override {

15 overrides = self: super: {

21 overrides = self: super: {

16− curryer-rpc = self.callCabal2nix "curryer-rpc" sources.curryer { };

22+ rank1dynamic =

17− streamly = doJailbreak (needsCocoa (self.callCabal2nix "streamly" sources.streamly { }));

23+ distProcessPkg (self.callHackageDirect {

24+ pkg = "rank1dynamic";

25+ ver = "0.4.0";

26+ sha256 = "1x6p9z53s7xwp93jp4n1lq6m5xspcn6w62p461v8vqnp9600328b";

27+}{});

28+ stm-hamt =

29+ self.callHackageDirect {

30+ pkg = "stm-hamt";

31+ ver = "1.2.0.3";

32+ sha256 = "1i8j7q8nhx3l7gydrjlsyhkvllr6bppgrjf0hp38zpm7p6xcv2bb";

33+ }{};

34+

35+ stm-containers =

36+ self.callHackageDirect {

37+ pkg = "stm-containers";

38+ ver = "1.1.0.4";

39+ sha256 = "0h9z6lawdm44minx9spvdb7sp645l36ri5cnxvhrcxwzr64s7qb5";

40+ }{};

41+

42+ data-interval =

43+ self.callHackageDirect {

44+ pkg = "data-interval";

45+ ver = "2.0.1";

46+ sha256 = "085j4yjr8wimxampxqdrg47p577whwg2mjxgfdl44yfck52fb6an";

47+ }{};

48+

49+ curryer =

50+ self.callHackageDirect {

51+ pkg = "curryer";

52+ ver = "0.1";

53+ sha256 = "085j4yjr8wimxampxqdrg47p577whwg2mjxgfdl44yfck52fb6ac";

54+ }{};

55+

18− project-m36 = ((self.callCabal2nixWithOptions "project-m36" ./. "-f-haskell-scripting" { }));

56+ project-m36 = dontCheck (self.callCabal2nixWithOptions "project-m36" ./. "-f-haskell-scripting" { });

57+

19 };

58 };

20 };

59 };

60+

61+ project = haskellPackages.project-m36;

21in

62in

22{

63{

23− project = haskellPackages.project-m36;

64+ project = project;

24

65

25 shell = haskellPackages.shellFor {

66 shell = haskellPackages.shellFor {

26− packages = p: [

67+ packages = p: with p; [

27− p.project-m36

68+ project

28 ];

69 ];

29 buildInputs = [

70 buildInputs = [

30 haskellPackages.ghcid

71 haskellPackages.ghcid

@@ -33,4 +74,4 @@ in

33 ];

74 ];

34 withHoogle = true;

75 withHoogle = true;

35 };

76 };

36−}

77+}

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.tutddeleted−2

@@ -1,2 +0,0 @@

1−x:=relation{

2−tuple{ x 2}} -- nice

src/bin/ProjectM36/Server/RemoteCallTypes/Json.hs+2−20

@@ -11,7 +11,6 @@ import ProjectM36.Error

11import ProjectM36.IsomorphicSchema

12import ProjectM36.Server.RemoteCallTypes

13import ProjectM36.MerkleHash

14−import ProjectM36.Attribute as A

15

14

16import Data.Aeson

15import Data.Aeson

17import Data.ByteString.Base64 as B64

16import Data.ByteString.Base64 as B64

@@ -45,11 +44,8 @@ instance FromJSON ExecuteRelationalExpr

45instance ToJSON Relation

44instance ToJSON Relation

46instance FromJSON Relation

45instance FromJSON Relation

47

46

48−instance ToJSON Attribute where

47+instance ToJSON Attribute

49− toJSON (Attribute attrName aType) = object [ "name" .= attrName

50− , "type" .= toJSON aType ]

51−instance FromJSON Attribute where

48+instance FromJSON Attribute

52− parseJSON = withObject "Attribute" $ \v -> Attribute <$> v .: "name" <*> v .: "type"

53

49

54instance ToJSON ExtendTupleExpr

50instance ToJSON ExtendTupleExpr

55instance FromJSON ExtendTupleExpr

51instance FromJSON ExtendTupleExpr

@@ -103,8 +99,6 @@ instance ToJSON Atom where

103 "val" .= i ]

99 "val" .= i ]

104 toJSON atom@(RelationAtom i) = object [ "type" .= atomTypeForAtom atom,

100 toJSON atom@(RelationAtom i) = object [ "type" .= atomTypeForAtom atom,

105 "val" .= i ]

101 "val" .= i ]

106− toJSON atom@(RelationalExprAtom i) = object [ "type" .= atomTypeForAtom atom,

107− "val" .= i ]

108 toJSON (ConstructedAtom dConsName atomtype atomlist) = object [

102 toJSON (ConstructedAtom dConsName atomtype atomlist) = object [

109 "dataconstructorname" .= dConsName,

103 "dataconstructorname" .= dConsName,

110 "type" .= toJSON atomtype,

104 "type" .= toJSON atomtype,

@@ -132,7 +126,6 @@ instance FromJSON Atom where

132 Left err -> fail ("Failed to parse base64-encoded ByteString: " ++ err)

126 Left err -> fail ("Failed to parse base64-encoded ByteString: " ++ err)

133 Right bs -> pure (ByteStringAtom bs)

127 Right bs -> pure (ByteStringAtom bs)

134 BoolAtomType -> BoolAtom <$> o .: "val"

128 BoolAtomType -> BoolAtom <$> o .: "val"

135− RelationalExprAtomType -> RelationalExprAtom <$> o .: "val"

136

129

137instance ToJSON Notification

130instance ToJSON Notification

138instance FromJSON Notification

131instance FromJSON Notification

@@ -149,12 +142,6 @@ instance FromJSON MerkleHash where

149 Left err -> fail ("Failed to parse merkle hash: " ++ err)

142 Left err -> fail ("Failed to parse merkle hash: " ++ err)

150 Right bs -> pure (MerkleHash bs)

143 Right bs -> pure (MerkleHash bs)

151

144

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−

158instance ToJSON RelationalError

145instance ToJSON RelationalError

159instance FromJSON RelationalError

146instance FromJSON RelationalError

160

147

@@ -164,9 +151,6 @@ instance FromJSON SchemaError

164instance ToJSON MergeError

151instance ToJSON MergeError

165instance FromJSON MergeError

152instance FromJSON MergeError

166

153

167−instance ToJSON ImportError'

168−instance FromJSON ImportError'

169−

170instance ToJSON DatabaseContextFunctionError

154instance ToJSON DatabaseContextFunctionError

171instance FromJSON DatabaseContextFunctionError

155instance FromJSON DatabaseContextFunctionError

172

156

@@ -181,5 +165,3 @@ instance FromJSON AtomFunctionError

181

165

182instance ToJSON WithNameExpr

166instance ToJSON WithNameExpr

183instance FromJSON WithNameExpr

167instance FromJSON WithNameExpr

184−

185−

src/bin/ProjectM36/Server/WebSocket.hs+1−2

@@ -22,7 +22,6 @@ import Data.Attoparsec.Text

22import Control.Applicative

23import Text.Megaparsec.Error

24import Data.Functor

25−import Data.Either (fromRight)

26

25

27#if MIN_VERSION_megaparsec(7,0,0)

26#if MIN_VERSION_megaparsec(7,0,0)

28import Data.List.NonEmpty as NE

27import Data.List.NonEmpty as NE

@@ -118,7 +117,7 @@ promptInfo :: SessionId -> Connection -> IO (HeadName, SchemaName)

118promptInfo sessionId conn = do

117promptInfo sessionId conn = do

119 eHeadName <- headName sessionId conn

118 eHeadName <- headName sessionId conn

120 eSchemaName <- currentSchemaName sessionId conn

119 eSchemaName <- currentSchemaName sessionId conn

121− pure (fromRight "<unknown>" eHeadName, fromRight "<no schema>" eSchemaName)

120+ pure (either (const "<unknown>") id eHeadName, either (const "<no schema>") id eSchemaName)

122

121

123sendPromptInfo :: (HeadName, SchemaName) -> WS.Connection -> IO ()

122sendPromptInfo :: (HeadName, SchemaName) -> WS.Connection -> IO ()

124sendPromptInfo (hName, sName) conn = WS.sendTextData conn (encode (object ["promptInfo" .= object ["headname" .= hName, "schemaname" .= sName]]))

123sendPromptInfo (hName, sName) conn = WS.sendTextData conn (encode (object ["promptInfo" .= object ["headname" .= hName, "schemaname" .= sName]]))

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 cjdate</li>

129+ <li>:importexample date</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+9−42

@@ -1,40 +1,23 @@

1{-# LANGUAGE CPP #-}

2−

2+import ProjectM36.Server.WebSocket

3+import ProjectM36.Server.Config

4+import ProjectM36.Server.ParseArgs

5+import ProjectM36.Server

3import Control.Concurrent

6import Control.Concurrent

7+import qualified Network.WebSockets as WS

4import Control.Exception

8import Control.Exception

5−import Control.Monad (when)

6−import Data.Maybe (isJust)

7−import Data.String (fromString)

8−import Network.HTTP.Types (status400)

9import 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

19

10

20main :: IO ()

11main :: IO ()

21main = do

12main = do

22 -- launch normal project-m36-server

13 -- launch normal project-m36-server

23 addressMVar <- newEmptyMVar

14 addressMVar <- newEmptyMVar

24− wsConfig <- parseWSConfigWithDefaults (defaultServerConfig {bindPort = 8000, bindHost = "127.0.0.1"})

15+ serverConfig <- parseConfigWithDefaults (defaultServerConfig { bindPort = 8000, bindHost = "127.0.0.1" })

25−

26 --usurp the serverConfig for our websocket server and make the proxied server run locally

16 --usurp the serverConfig for our websocket server and make the proxied server run locally

27− let serverConfig = wsServerConfig wsConfig

28− wsHost = bindHost serverConfig

17+ let wsHost = bindHost serverConfig

29 wsPort = bindPort serverConfig

18 wsPort = bindPort serverConfig

30 serverHost = "127.0.0.1"

19 serverHost = "127.0.0.1"

31 serverConfig' = serverConfig {bindPort = 0, bindHost = serverHost}

20 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−

38 _ <- forkFinally (launchServer serverConfig' (Just addressMVar) >> pure ()) (either throwIO pure)

21 _ <- forkFinally (launchServer serverConfig' (Just addressMVar) >> pure ()) (either throwIO pure)

39 --wait for server to be listening

22 --wait for server to be listening

40 addr <- takeMVar addressMVar

23 addr <- takeMVar addressMVar

@@ -42,22 +25,6 @@ main = do

42 case addr of

25 case addr of

43 SockAddrInet port' _ -> fromIntegral port'

26 SockAddrInet port' _ -> fromIntegral port'

44 _ -> error "unsupported socket address (IPv4 only currently)"

27 _ -> error "unsupported socket address (IPv4 only currently)"

45− wsApp = websocketProxyServer port serverHost

28+ --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

46− waiApp = WS.websocketsOr defaultConnectionOptions wsApp backupApp

47− settings = warpSettings wsHost (fromIntegral wsPort)

29+ WS.runServer wsHost (fromIntegral wsPort) (websocketProxyServer port serverHost)

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"

55

30

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+1−3

@@ -34,7 +34,6 @@ import Data.Monoid

34import Data.List (isPrefixOf)

35import Control.Exception

36import System.Exit

37−import Data.Either (fromRight)

38

37

39{-

38{-

40context ops are read-only operations which only operate on the database context (relvars and constraints)

39context ops are read-only operations which only operate on the database context (relvars and constraints)

@@ -78,7 +77,7 @@ safeInterpreterParserP = fmap RODatabaseContextOp (roDatabaseContextOperatorP <*

78promptText :: Either RelationalError HeadName -> Either RelationalError SchemaName -> StringType

77promptText :: Either RelationalError HeadName -> Either RelationalError SchemaName -> StringType

79promptText eHeadName eSchemaName = "TutorialD (" <> transInfo <> "): "

78promptText eHeadName eSchemaName = "TutorialD (" <> transInfo <> "): "

80 where

79 where

81− transInfo = fromRight "<unknown>" eHeadName <> "/" <> fromRight "<no schema>" eSchemaName

80+ transInfo = either (const "<unknown>") id eHeadName <> "/" <> either (const "<no schema>") id eSchemaName

82

81

83parseTutorialD :: T.Text -> Either ParserError ParsedOperation

82parseTutorialD :: T.Text -> Either ParserError ParsedOperation

84parseTutorialD = parse interpreterParserP ""

83parseTutorialD = parse interpreterParserP ""

@@ -216,7 +215,6 @@ evalTutorialDInteractive sessionId conn safe interactive expr = case expr of

216 unsafeError = pure $ DisplayErrorResult "File I/O operation prohibited."

215 unsafeError = pure $ DisplayErrorResult "File I/O operation prohibited."

217 barf :: RelationalError -> IO TutorialDOperatorResult

216 barf :: RelationalError -> IO TutorialDOperatorResult

218 barf (ScriptError (OtherScriptCompilationError errStr)) = pure (DisplayErrorResult (T.pack errStr))

217 barf (ScriptError (OtherScriptCompilationError errStr)) = pure (DisplayErrorResult (T.pack errStr))

219− barf (ParseError err) = pure (DisplayErrorResult err)

220 barf err = return $ DisplayErrorResult (T.pack (show err))

218 barf err = return $ DisplayErrorResult (T.pack (show err))

221 eHandler io = do

219 eHandler io = do

222 eErr <- io

220 eErr <- io

src/bin/TutorialD/Interpreter/Base.hs+8−29

@@ -12,12 +12,11 @@ module TutorialD.Interpreter.Base (

12 where

13import ProjectM36.Base

14import ProjectM36.AtomType

15−import ProjectM36.Attribute as A

16import ProjectM36.Relation

15import ProjectM36.Relation

17import ProjectM36.DataFrame

16import ProjectM36.DataFrame

18

17

19#if MIN_VERSION_megaparsec(6,0,0)

18#if MIN_VERSION_megaparsec(6,0,0)

20−import Text.Megaparsec.Char

19+import Text.Megaparsec.Char

21import qualified Text.Megaparsec.Char.Lexer as Lex

20import qualified Text.Megaparsec.Char.Lexer as Lex

22import Text.Megaparsec

21import Text.Megaparsec

23import Data.Void

22import Data.Void

@@ -31,6 +30,7 @@ import Data.Text hiding (count)

31import System.Random

30import System.Random

32import qualified Data.Text as T

31import qualified Data.Text as T

33import qualified Data.List as L

32import 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

@@ -44,7 +44,6 @@ import Data.List.NonEmpty as NE

44import Data.Time.Clock

45import Data.Time.Format

46import Control.Monad (void)

47−import Data.Char

48

47

49#if !MIN_VERSION_megaparsec(7,0,0)

48#if !MIN_VERSION_megaparsec(7,0,0)

50anySingle :: Parsec Void Text (Token Text)

49anySingle :: Parsec Void Text (Token Text)

@@ -82,9 +81,8 @@ type ParseStr = Text

82type ParseStr = String

81type ParseStr = String

83#endif

82#endif

84

83

85−-- consumes only horizontal spaces

86spaceConsumer :: Parser ()

84spaceConsumer :: Parser ()

87−spaceConsumer = Lex.space space1 (Lex.skipLineComment "--") (Lex.skipBlockComment "{-" "-}")

85+spaceConsumer = Lex.space (void spaceChar) (Lex.skipLineComment "--") (Lex.skipBlockComment "{-" "-}")

88

86

89opChar :: Parser Char

87opChar :: Parser Char

90opChar = oneOf (":!#$%&*+./<=>?\\^|-~" :: String)-- remove "@" so it can be used as attribute marker without spaces

88opChar = oneOf (":!#$%&*+./<=>?\\^|-~" :: String)-- remove "@" so it can be used as attribute marker without spaces

@@ -137,14 +135,11 @@ arrow = symbol "->"

137semi :: Parser Text

135semi :: Parser Text

138semi = symbol ";"

136semi = symbol ";"

139

137

140−nline :: Parser Text

141−nline = (T.singleton <$> newline) <|> crlf

142−

143integer :: Parser Integer

138integer :: Parser Integer

144#if MIN_VERSION_megaparsec(6,0,0)

139#if MIN_VERSION_megaparsec(6,0,0)

145−integer = Lex.signed (pure ()) Lex.decimal <* spaceConsumer

140+integer = Lex.signed spaceConsumer Lex.decimal

146#else

141#else

147−integer = Lex.signed (pure ()) Lex.integer <* spaceConsumer

142+integer = Lex.signed spaceConsumer Lex.integer

148#endif

143#endif

149

144

150natural :: Parser Integer

145natural :: Parser Integer

@@ -155,7 +150,7 @@ natural = Lex.integer <* spaceConsumer

155#endif

150#endif

156

151

157float :: Parser Double

152float :: Parser Double

158−float = Lex.float <* spaceConsumer

153+float = Lex.float

159

154

160capitalizedIdentifier :: Parser Text

155capitalizedIdentifier :: Parser Text

161capitalizedIdentifier =

156capitalizedIdentifier =

@@ -168,8 +163,8 @@ uncapitalizedIdentifier =

168showRelationAttributes :: Attributes -> Text

163showRelationAttributes :: Attributes -> Text

169showRelationAttributes attrs = "{" <> T.concat (L.intersperse ", " $ L.map showAttribute attrsL) <> "}"

164showRelationAttributes attrs = "{" <> T.concat (L.intersperse ", " $ L.map showAttribute attrsL) <> "}"

170 where

165 where

171− showAttribute (Attribute name atomType') = name <> " " <> prettyAtomType atomType'

166+ showAttribute (Attribute name atomType) = name <> " " <> prettyAtomType atomType

172− attrsL = A.toList attrs

167+ attrsL = V.toList attrs

173

168

174type PromptLength = Int

169type PromptLength = Int

175

170

@@ -205,9 +200,6 @@ normalQuotedString = quote *> (T.pack <$> manyTill Lex.charLiteral quote)

205quotedString :: Parser Text

200quotedString :: Parser Text

206quotedString = try tripleQuotedString <|> normalQuotedString

201quotedString = try tripleQuotedString <|> normalQuotedString

207

202

208−quoted :: Parser a -> Parser a

209−quoted = between quote quote

210−

211uuidP :: Parser U.UUID

203uuidP :: Parser U.UUID

212uuidP = do

204uuidP = do

213 uuidStart <- count 8 hexDigitChar

205 uuidStart <- count 8 hexDigitChar

@@ -230,16 +222,3 @@ utcTimeP = do

230 case parseTimeM True defaultTimeLocale "%Y-%m-%d %H:%M:%S" (T.unpack timeStr) of

222 case parseTimeM True defaultTimeLocale "%Y-%m-%d %H:%M:%S" (T.unpack timeStr) of

231 Nothing -> fail "invalid datetime input, use \"YYYY-MM-DD HH:MM:SS\""

223 Nothing -> fail "invalid datetime input, use \"YYYY-MM-DD HH:MM:SS\""

232 Just stamp' -> pure stamp'

224 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'))

245−

src/bin/TutorialD/Interpreter/DatabaseContextExpr.hs+2−3

@@ -53,9 +53,8 @@ multilineSep :: Parser T.Text

53multilineSep = newline >> pure "\n"

54

55multipleDatabaseContextExprP :: Parser DatabaseContextExpr

56−multipleDatabaseContextExprP = do

56+multipleDatabaseContextExprP =

57− exprs <- filter (/= NoOperation) <$> sepBy1 databaseContextExprP semi

57+ MultipleExpr <$> sepBy1 databaseContextExprP semi

58− pure (MultipleExpr exprs)

59

58

60insertP :: Parser DatabaseContextExpr

59insertP :: Parser DatabaseContextExpr

61insertP = do

60insertP = do

src/bin/TutorialD/Interpreter/Import/Base.hs+3−8

@@ -2,8 +2,6 @@

2module TutorialD.Interpreter.Import.Base where

3import ProjectM36.Base

4import ProjectM36.Error

5−import Text.URI (URI)

6−import Data.Text (Text)

7#if __GLASGOW_HASKELL__ < 804

5#if __GLASGOW_HASKELL__ < 804

8import Data.Monoid

6import Data.Monoid

9#endif

7#endif

@@ -14,14 +12,11 @@ data RelVarDataImportOperator = RelVarDataImportOperator RelVarName FilePath (Re

14instance Show RelVarDataImportOperator where

12instance Show RelVarDataImportOperator where

15 show (RelVarDataImportOperator rv path _) = "RelVarDataImportOperator " <> show rv <> " " <> path

13 show (RelVarDataImportOperator rv path _) = "RelVarDataImportOperator " <> show rv <> " " <> path

16

14

17−type HashVerification = Maybe Text

18−

19-- | import data into a database context

15-- | import data into a database context

20−data DatabaseContextDataImportOperator = DatabaseContextDataImportOperator URI HashVerification (URI -> HashVerification -> IO (Either RelationalError DatabaseContextExpr))

16+data DatabaseContextDataImportOperator = DatabaseContextDataImportOperator FilePath (FilePath -> IO (Either RelationalError DatabaseContextExpr))

21

17

22instance Show DatabaseContextDataImportOperator where

18instance Show DatabaseContextDataImportOperator where

23− show (DatabaseContextDataImportOperator uri hash _) =

19+ show (DatabaseContextDataImportOperator path _) = "DatabaseContextDataImportOperator " <> path

24− "DatabaseContextDataImportOperator " <> show uri <> " " <> show hash

25

20

26-- perhaps create a structure to import a whole transaction graph section in the future

21-- perhaps create a structure to import a whole transaction graph section in the future

27

22

@@ -29,4 +24,4 @@ evalRelVarDataImportOperator :: RelVarDataImportOperator -> TypeConstructorMappi

29evalRelVarDataImportOperator (RelVarDataImportOperator relVarName path importFunc) tConsMap attrs = importFunc relVarName tConsMap attrs path

24evalRelVarDataImportOperator (RelVarDataImportOperator relVarName path importFunc) tConsMap attrs = importFunc relVarName tConsMap attrs path

30

25

31evalDatabaseContextDataImportOperator :: DatabaseContextDataImportOperator -> IO (Either RelationalError DatabaseContextExpr)

26evalDatabaseContextDataImportOperator :: DatabaseContextDataImportOperator -> IO (Either RelationalError DatabaseContextExpr)

32−evalDatabaseContextDataImportOperator (DatabaseContextDataImportOperator uri hash importFunc) = importFunc uri hash

27+evalDatabaseContextDataImportOperator (DatabaseContextDataImportOperator path importFunc) = importFunc path

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 == "cjdate" then

23+ if example == "date" 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 -> pure $ Left (ImportError (ImportFileError (T.pack (show err))))

17+ Left err -> return $ Left (ImportError $ T.pack (show err))

18 Right csvData' -> case csvAsRelation attrs tConsMap csvData' of

19− Left err -> pure $ Left (ParseError $ T.pack (show err))

19+ Left err -> return $ Left (ParseError $ T.pack (show err))

20− Right csvRel -> pure $ Right (Insert relVarName (ExistingRelation csvRel))

20+ Right csvRel -> return $ Right (Insert relVarName (ExistingRelation csvRel))

21

22importCSVP :: Parser RelVarDataImportOperator

23importCSVP = do

src/bin/TutorialD/Interpreter/Import/TutorialD.hs+17−70

@@ -9,78 +9,25 @@ 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

18−--import a file containing TutorialD database context expressions via local files or HTTP/HTTPS

12+--import a file containing TutorialD database context expressions

19

13

20−importTutorialDFromFile :: URI -> HashVerification -> IO (Either RelationalError DatabaseContextExpr)

14+importTutorialD :: FilePath -> IO (Either RelationalError DatabaseContextExpr)

21−importTutorialDFromFile fileURI mHash = do

15+importTutorialD pathIn = do

22− case URI.uriPath fileURI of

23− Just (False, _) -> do

24− eTutdBytes <- try (BS.readFile filePath) :: IO (Either IOError BS.ByteString)

16+ eTutdBytes <- try (BS.readFile pathIn) :: IO (Either IOError BS.ByteString)

25− case eTutdBytes of

17+ case eTutdBytes of

26− Left err -> pure $ Left (ImportError (ImportFileError (T.pack (show err))))

18+ Left err -> return $ Left (ImportError $ T.pack (show err))

27− Right tutdBytes ->

19+ Right tutdBytes ->

28− case validateBytes tutdBytes mHash of

29− Left err -> pure (Left err)

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 =

38− case TE.decodeUtf8' tutdBytes of

20+ case TE.decodeUtf8' tutdBytes of

39− Left err -> pure (Left (ImportError (ImportFileDecodeError (T.pack (show err)))))

21+ Left err -> pure (Left (ImportError $ T.pack (show err)))

40− Right tutdUtf8 ->

22+ Right tutdUtf8 ->

41− case parse (multipleDatabaseContextExprP <* eof) "import" tutdUtf8 of

23+ case parse multipleDatabaseContextExprP "import" tutdUtf8 of

42− --parseErrorPretty is new in megaparsec 5

24+ --parseErrorPretty is new in megaparsec 5

43− Left err -> pure (Left (PM36E.ParseError (T.pack (errorBundlePretty err))))

25+ Left err -> pure (Left (PM36E.ParseError (T.pack (show err))))

44− Right expr -> pure (Right expr)

26+ Right expr -> pure (Right expr)

45−

27+

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−

75tutdImportP :: Parser DatabaseContextDataImportOperator

28tutdImportP :: Parser DatabaseContextDataImportOperator

76tutdImportP = do

29tutdImportP = do

77 reserved ":importtutd"

30 reserved ":importtutd"

78− uri <- quoted URI.parser

31+ path <- quotedString

79 spaceConsumer

32 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)

86− pure $ DatabaseContextDataImportOperator uri mhash handler

33+ return $ DatabaseContextDataImportOperator (T.unpack path) importTutorialD

src/bin/TutorialD/Interpreter/RODatabaseContextOperator.hs+16−33

@@ -1,16 +1,13 @@

1{-# LANGUAGE GADTs #-}

2module TutorialD.Interpreter.RODatabaseContextOperator where

3import ProjectM36.Base

4−import ProjectM36.Relation

5import qualified ProjectM36.DataFrame as DF

4import qualified ProjectM36.DataFrame as DF

6import ProjectM36.Error

5import ProjectM36.Error

7−import ProjectM36.Tuple

8import ProjectM36.InclusionDependency

6import ProjectM36.InclusionDependency

9import qualified ProjectM36.Client as C

7import qualified ProjectM36.Client as C

10import TutorialD.Interpreter.Base

8import TutorialD.Interpreter.Base

11import TutorialD.Interpreter.RelationalExpr

9import TutorialD.Interpreter.RelationalExpr

12import TutorialD.Interpreter.DatabaseContextExpr

10import TutorialD.Interpreter.DatabaseContextExpr

13−import TutorialD.Printer

14import Control.Monad.State

11import Control.Monad.State

15import qualified Data.Text as T

12import qualified Data.Text as T

16import ProjectM36.Relation.Show.Gnuplot

13import ProjectM36.Relation.Show.Gnuplot

@@ -22,7 +19,7 @@ data RODatabaseContextOperator where

22 ShowRelation :: RelationalExpr -> RODatabaseContextOperator

19 ShowRelation :: RelationalExpr -> RODatabaseContextOperator

23 PlotRelation :: RelationalExpr -> RODatabaseContextOperator

20 PlotRelation :: RelationalExpr -> RODatabaseContextOperator

24 ShowRelationType :: RelationalExpr -> RODatabaseContextOperator

21 ShowRelationType :: RelationalExpr -> RODatabaseContextOperator

25− ShowConstraints :: StringType -> RODatabaseContextOperator

22+ ShowConstraint :: StringType -> RODatabaseContextOperator

26 ShowPlan :: DatabaseContextExpr -> RODatabaseContextOperator

23 ShowPlan :: DatabaseContextExpr -> RODatabaseContextOperator

27 ShowTypes :: RODatabaseContextOperator

24 ShowTypes :: RODatabaseContextOperator

28 ShowRelationVariables :: RODatabaseContextOperator

25 ShowRelationVariables :: RODatabaseContextOperator

@@ -34,44 +31,44 @@ data RODatabaseContextOperator where

34

31

35typeP :: Parser RODatabaseContextOperator

32typeP :: Parser RODatabaseContextOperator

36typeP = do

33typeP = do

37− colonOp ":type"

34+ reservedOp ":type"

38 ShowRelationType <$> relExprP

35 ShowRelationType <$> relExprP

39

36

40showRelP :: Parser RODatabaseContextOperator

37showRelP :: Parser RODatabaseContextOperator

41showRelP = do

38showRelP = do

42− colonOp ":showexpr"

39+ reservedOp ":showexpr"

43 ShowRelation <$> relExprP

40 ShowRelation <$> relExprP

44

41

45showPlanP :: Parser RODatabaseContextOperator

42showPlanP :: Parser RODatabaseContextOperator

46showPlanP = do

43showPlanP = do

47− colonOp ":showplan"

44+ reservedOp ":showplan"

48 ShowPlan <$> databaseContextExprP

45 ShowPlan <$> databaseContextExprP

49

46

50showTypesP :: Parser RODatabaseContextOperator

47showTypesP :: Parser RODatabaseContextOperator

51−showTypesP = colonOp ":showtypes" >> pure ShowTypes

48+showTypesP = reserved ":showtypes" >> pure ShowTypes

52

49

53showRelationVariables :: Parser RODatabaseContextOperator

50showRelationVariables :: Parser RODatabaseContextOperator

54−showRelationVariables = colonOp ":showrelvars" >> pure ShowRelationVariables

51+showRelationVariables = reserved ":showrelvars" >> pure ShowRelationVariables

55

52

56showAtomFunctionsP :: Parser RODatabaseContextOperator

53showAtomFunctionsP :: Parser RODatabaseContextOperator

57−showAtomFunctionsP = colonOp ":showatomfunctions" >> pure ShowAtomFunctions

54+showAtomFunctionsP = reserved ":showatomfunctions" >> pure ShowAtomFunctions

58

55

59showDatabaseContextFunctionsP :: Parser RODatabaseContextOperator

56showDatabaseContextFunctionsP :: Parser RODatabaseContextOperator

60−showDatabaseContextFunctionsP = colonOp ":showdatabasecontextfunctions" >> pure ShowDatabaseContextFunctions

57+showDatabaseContextFunctionsP = reserved ":showdatabasecontextfunctions" >> pure ShowDatabaseContextFunctions

61

58

62quitP :: Parser RODatabaseContextOperator

59quitP :: Parser RODatabaseContextOperator

63quitP = do

60quitP = do

64− colonOp ":quit"

61+ reservedOp ":quit"

65 return Quit

62 return Quit

66

63

67showConstraintsP :: Parser RODatabaseContextOperator

64showConstraintsP :: Parser RODatabaseContextOperator

68showConstraintsP = do

65showConstraintsP = do

69− colonOp ":constraints"

66+ reservedOp ":constraints"

70− ShowConstraints <$> option "" identifier

67+ ShowConstraint <$> option "" identifier

71

68

72plotRelExprP :: Parser RODatabaseContextOperator

69plotRelExprP :: Parser RODatabaseContextOperator

73plotRelExprP = do

70plotRelExprP = do

74− colonOp ":plotexpr"

71+ reserved ":plotexpr"

75 PlotRelation <$> relExprP

72 PlotRelation <$> relExprP

76

73

77roDatabaseContextOperatorP :: Parser RODatabaseContextOperator

74roDatabaseContextOperatorP :: Parser RODatabaseContextOperator

@@ -109,16 +106,15 @@ evalRODatabaseContextOp sessionId conn (PlotRelation expr) = do

109 err <- plotRelation rel

106 err <- plotRelation rel

110 when (isJust err) $ print err

107 when (isJust err) $ print err

111

108

112−evalRODatabaseContextOp sessionId conn (ShowConstraints name) = do

109+evalRODatabaseContextOp sessionId conn (ShowConstraint name) = do

113 eIncDeps <- C.inclusionDependencies sessionId conn

110 eIncDeps <- C.inclusionDependencies sessionId conn

114 let val = case eIncDeps of

111 let val = case eIncDeps of

115 Left err -> Left err

112 Left err -> Left err

116 Right incDeps -> case name of

113 Right incDeps -> case name of

117− "" -> inclusionDependenciesAsRelation incDeps >>= renderRelExprsInIncDeps

114+ "" -> inclusionDependenciesAsRelation incDeps

118 depName -> case M.lookup depName incDeps of

115 depName -> case M.lookup depName incDeps of

119 Nothing -> Left (InclusionDependencyNameNotInUseError depName)

116 Nothing -> Left (InclusionDependencyNameNotInUseError depName)

120− Just dep ->

121− inclusionDependenciesAsRelation (M.singleton depName dep) >>= renderRelExprsInIncDeps

117+ Just dep -> inclusionDependenciesAsRelation (M.singleton depName dep)

122 pure $ case val of

118 pure $ case val of

123 Left err -> DisplayErrorResult (T.pack (show err))

119 Left err -> DisplayErrorResult (T.pack (show err))

124 Right rel -> DisplayRelationResult rel

120 Right rel -> DisplayRelationResult rel

@@ -168,7 +164,7 @@ interpretRODatabaseContextOp sessionId conn tutdstring = case parse roDatabaseCo

168

164

169showDataFrameP :: Parser RODatabaseContextOperator

165showDataFrameP :: Parser RODatabaseContextOperator

170showDataFrameP = do

166showDataFrameP = do

171− colonOp ":showdataframe"

167+ reservedOp ":showdataframe"

172 relExpr <- relExprP

168 relExpr <- relExprP

173 reservedOp "orderby"

169 reservedOp "orderby"

174 attrOrdersExpr <- attrOrdersExprP

170 attrOrdersExpr <- attrOrdersExprP

@@ -195,16 +191,3 @@ attrOrderExprP = DF.AttributeOrderExpr <$> identifier <*> orderP

195

191

196orderP :: Parser DF.Order

192orderP :: Parser DF.Order

197orderP = try (reservedOp "ascending" >> pure DF.AscendingOrder) <|> try (reservedOp "descending" >> pure DF.DescendingOrder) <|> pure DF.AscendingOrder

193orderP = 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+8−27

@@ -20,18 +20,9 @@ attributeListP :: RelationalMarkerExpr a => Parser (AttributeNamesBase a)

20attributeListP =

21 (reservedOp "all but" >>

22 InvertedAttributeNames . S.fromList <$> sepBy attributeNameP comma) <|>

23−

24 (reservedOp "all from" >>

23 (reservedOp "all from" >>

25 RelationalExprAttributeNames <$> relExprP) <|>

24 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−

33− (AttributeNames . S.fromList <$> sepBy attributeNameP comma)

25+ (AttributeNames . S.fromList <$> sepBy attributeNameP comma)

34−

35

26

36makeRelationP :: RelationalMarkerExpr a => Parser (RelationalExprBase a)

27makeRelationP :: RelationalMarkerExpr a => Parser (RelationalExprBase a)

37makeRelationP = do

28makeRelationP = do

@@ -111,11 +102,7 @@ ungroupP = do

111extendP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a)

102extendP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a)

112extendP = do

103extendP = do

113 reservedOp ":"

104 reservedOp ":"

114− extends <- braces (sepBy extendTupleExpressionP comma)

105+ Extend <$> braces extendTupleExpressionP

115− case extends of

116− [] -> pure (Restrict TruePredicate)

117− extends' ->

118− pure $ \expr -> foldl (flip Extend) expr extends'

119

106

120semijoinP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a -> RelationalExprBase a)

107semijoinP :: RelationalMarkerExpr a => Parser (RelationalExprBase a -> RelationalExprBase a -> RelationalExprBase a)

121semijoinP = do

108semijoinP = do

@@ -142,8 +129,7 @@ relOperators = [

142 [InfixL antijoinP],

129 [InfixL antijoinP],

143 [InfixL (reservedOp "union" >> return Union)],

130 [InfixL (reservedOp "union" >> return Union)],

144 [InfixL (reservedOp "minus" >> return Difference)],

131 [InfixL (reservedOp "minus" >> return Difference)],

145− [InfixN (reservedOp "=" >> return Equals),

132+ [InfixN (reservedOp "=" >> return Equals)],

146− InfixN (reservedOp "/=" >> return NotEquals)],

147 [Postfix extendP]

133 [Postfix extendP]

148 ]

134 ]

149

135

@@ -214,9 +200,8 @@ consumeAtomExprP consume = try functionAtomExprP <|>

214 try (parens (constructedAtomExprP True)) <|>

200 try (parens (constructedAtomExprP True)) <|>

215 constructedAtomExprP consume <|>

201 constructedAtomExprP consume <|>

216 attributeAtomExprP <|>

202 attributeAtomExprP <|>

217− try nakedAtomExprP <|>

203+ nakedAtomExprP <|>

218 relationalAtomExprP

204 relationalAtomExprP

219−

220

205

221attributeAtomExprP :: Parser (AtomExprBase a)

206attributeAtomExprP :: Parser (AtomExprBase a)

222attributeAtomExprP = do

207attributeAtomExprP = do

@@ -235,7 +220,7 @@ constructedAtomExprP consume = do

235-- used only for primitive type parsing ?

220-- used only for primitive type parsing ?

236atomP :: Parser Atom

221atomP :: Parser Atom

237atomP = stringAtomP <|>

222atomP = stringAtomP <|>

238− try doubleAtomP <|>

223+ doubleAtomP <|>

239 integerAtomP <|>

224 integerAtomP <|>

240 boolAtomP

225 boolAtomP

241

226

@@ -250,19 +235,15 @@ stringAtomP :: Parser Atom

250stringAtomP = TextAtom <$> quotedString

235stringAtomP = TextAtom <$> quotedString

251

236

252doubleAtomP :: Parser Atom

237doubleAtomP :: Parser Atom

253−doubleAtomP = DoubleAtom <$> float

238+doubleAtomP = DoubleAtom <$> try float

254

239

255integerAtomP :: Parser Atom

240integerAtomP :: Parser Atom

256integerAtomP = IntegerAtom <$> integer

241integerAtomP = IntegerAtom <$> integer

257

242

258boolAtomP :: Parser Atom

243boolAtomP :: Parser Atom

259boolAtomP = do

244boolAtomP = do

260− v <- identifier

245+ val <- char 't' <|> char 'f'

261− if v == "t" || v == "f" then

262− pure $ BoolAtom (v == "t")

246+ return $ BoolAtom (val == 't')

263− else

264− fail "invalid boolAtom"

265−

266

247

267relationAtomExprP :: RelationalMarkerExpr a => Parser (AtomExprBase a)

248relationAtomExprP :: RelationalMarkerExpr a => Parser (AtomExprBase a)

268relationAtomExprP = RelationAtomExpr <$> makeRelationP

249relationAtomExprP = RelationAtomExpr <$> makeRelationP

src/bin/TutorialD/Printer.hsdeleted−165

@@ -1,165 +0,0 @@

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/lib/ProjectM36/Arbitrary.hs+1−6

@@ -9,7 +9,6 @@ import ProjectM36.AtomType

9import ProjectM36.Attribute (atomType)

10import ProjectM36.DataConstructorDef as DCD

11import ProjectM36.DataTypes.Interval

12−import ProjectM36.Relation

13import qualified Data.Vector as V

12import qualified Data.Vector as V

14import Data.Text (Text)

13import Data.Text (Text)

15import Test.QuickCheck

14import Test.QuickCheck

@@ -49,10 +48,6 @@ arbitrary' ByteStringAtomType =

49

48

50arbitrary' BoolAtomType =

49arbitrary' BoolAtomType =

51 Right . BoolAtom <$> lift (arbitrary :: Gen Bool)

50 Right . BoolAtom <$> lift (arbitrary :: Gen Bool)

52−

53−arbitrary' RelationalExprAtomType =

54− pure (Right (RelationalExprAtom (ExistingRelation relationTrue))) -- don't bother with arbitrary relational expressions

55−

56arbitrary' constructedAtomType@(ConstructedAtomType tcName tvMap)

51arbitrary' constructedAtomType@(ConstructedAtomType tcName tvMap)

57 --special-casing for Interval type

52 --special-casing for Interval type

58 | isIntervalAtomType constructedAtomType = createArbitraryInterval (intervalSubType constructedAtomType)

53 | isIntervalAtomType constructedAtomType = createArbitraryInterval (intervalSubType constructedAtomType)

@@ -84,7 +79,7 @@ maybeToRight y Nothing = Left y

84arbitraryRelationTuple :: Attributes -> WithTCMap Gen (Either RelationalError RelationTuple)

79arbitraryRelationTuple :: Attributes -> WithTCMap Gen (Either RelationalError RelationTuple)

85arbitraryRelationTuple attris = do

80arbitraryRelationTuple attris = do

86 tcMap <- ask

81 tcMap <- ask

87− listOfMaybeAType <- lift $ mapM ((\aTy -> runReaderT (arbitrary' aTy) tcMap) . atomType) (V.toList (attributesVec attris))

82+ listOfMaybeAType <- lift $ mapM ((\aTy -> runReaderT (arbitrary' aTy) tcMap) . atomType) (V.toList attris)

88 case sequence listOfMaybeAType of

83 case sequence listOfMaybeAType of

89 Left err -> pure $ Left err

84 Left err -> pure $ Left err

90 Right listOfAttr -> do

85 Right listOfAttr -> do

src/lib/ProjectM36/Atom.hs−1

@@ -20,7 +20,6 @@ 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

24

23

25atomToText (RelationAtom i) = (T.pack . show) i

24atomToText (RelationAtom i) = (T.pack . show) i

26atomToText (ConstructedAtom dConsName typ atoms)

25atomToText (ConstructedAtom dConsName typ atoms)

src/lib/ProjectM36/AtomType.hs+7−8

@@ -211,7 +211,7 @@ isValidAtomTypeForTypeConstructor (ConstructedAtomType tConsName _) (ADTypeConst

211

212isValidAtomTypeForTypeConstructor (RelationAtomType attrs) (RelationAtomTypeConstructor attrExprs) tConsMap = do

213 evaldAtomTypes <- mapM (\expr -> atomTypeForAttributeExpr expr tConsMap M.empty) attrExprs

214− mapM_ (uncurry resolveAtomType) (zip (A.atomTypesList attrs) evaldAtomTypes)

214+ mapM_ (uncurry resolveAtomType) (zip (map A.atomType (V.toList attrs)) evaldAtomTypes)

215isValidAtomTypeForTypeConstructor aType tCons _ = Left (AtomTypeTypeConstructorReconciliationError aType (TC.name tCons))

216

217findTypeConstructor :: TypeConstructorName -> TypeConstructorMapping -> Maybe (TypeConstructorDef, [DataConstructorDef])

@@ -295,7 +295,7 @@ resolveTypeInAtom _ atom _ = Right atom

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.

296resolveTypesInTuple :: Attributes -> TypeConstructorMapping -> RelationTuple -> Either RelationalError RelationTuple

297resolveTypesInTuple resolvedAttrs tConss (RelationTuple _ tupAtoms) = do

298− newAtoms <- mapM (\(atom, resolvedType) -> resolveTypeInAtom resolvedType atom tConss) (zip (V.toList tupAtoms) $ A.atomTypesList resolvedAttrs)

298+ newAtoms <- mapM (\(atom, resolvedType) -> resolveTypeInAtom resolvedType atom tConss) (zip (V.toList tupAtoms) $ map A.atomType (V.toList resolvedAttrs))

299 Right (RelationTuple resolvedAttrs (V.fromList newAtoms))

300

301-- | Validate that the type is provided with complete type variables for type constructors.

@@ -314,7 +314,7 @@ validateAtomType typ@(ConstructedAtomType tConsName tVarMap) tConss =

314 _ -> Right ()

315validateAtomType (RelationAtomType attrs) tConss =

316 mapM_ (\attr ->

317− validateAtomType (A.atomType attr) tConss) (attributesVec attrs)

317+ validateAtomType (A.atomType attr) tConss) (V.toList attrs)

318validateAtomType (TypeVariableType x) _ = Left (TypeConstructorTypeVarMissing x)

319validateAtomType _ _ = pure ()

320

@@ -325,7 +325,7 @@ validateAttributes tConss attrs =

325 else

326 pure ()

327 where

328− errs = lefts $ map (`validateAtomType` tConss) (A.atomTypesList attrs)

328+ errs = lefts $ map ((`validateAtomType` tConss) . A.atomType) (V.toList attrs)

329

330--ensure that all type vars are fully resolved

331validateTypeVarMap :: TypeVarMap -> TypeConstructorMapping -> Either RelationalError ()

@@ -358,7 +358,7 @@ atomTypeVerify x@(RelationAtomType attrs1) y@(RelationAtomType attrs2) = do

358 if notElem "_" [name1, name2] && name1 /= name2 then

359 Left $ AtomTypeMismatchError x y

360 else

361− atomTypeVerify (A.atomType attr1) (A.atomType attr2)) $ V.toList (V.zip (attributesVec attrs1) (attributesVec attrs2))

361+ atomTypeVerify (A.atomType attr1) (A.atomType attr2)) $ V.toList (V.zip attrs1 attrs2)

362 return x

363atomTypeVerify x y = if x == y then

364 Right x

@@ -375,7 +375,7 @@ typeVarMapsVerify a b = M.keysSet a == M.keysSet b && (length . rights) zipped =

375 (M.toAscList b)

376

377prettyAtomType :: AtomType -> T.Text

378−prettyAtomType (RelationAtomType attrs) = "relation {" `T.append` T.intercalate "," (map prettyAttribute (V.toList (attributesVec attrs))) `T.append` "}"

378+prettyAtomType (RelationAtomType attrs) = "relation {" `T.append` T.intercalate "," (map prettyAttribute (V.toList attrs)) `T.append` "}"

379prettyAtomType (ConstructedAtomType tConsName typeVarMap) = tConsName `T.append` T.concat (map showTypeVars (M.toList typeVarMap))

380 where

381 showTypeVars (_, TypeVariableType x) = " " <> x

@@ -442,13 +442,12 @@ isResolvedType typ =

442 DateTimeAtomType -> True

443 ByteStringAtomType -> True

444 BoolAtomType -> True

445− RelationalExprAtomType -> True

446 RelationAtomType attrs -> isResolvedAttributes attrs

445 RelationAtomType attrs -> isResolvedAttributes attrs

447 ConstructedAtomType _ tvMap -> all isResolvedType (M.elems tvMap)

446 ConstructedAtomType _ tvMap -> all isResolvedType (M.elems tvMap)

448 TypeVariableType _ -> False

447 TypeVariableType _ -> False

449

448

450isResolvedAttributes :: Attributes -> Bool

449isResolvedAttributes :: Attributes -> Bool

451−isResolvedAttributes attrs = all isResolvedAttribute (V.toList (attributesVec attrs))

450+isResolvedAttributes attrs = all isResolvedAttribute (V.toList attrs)

452

451

453isResolvedAttribute :: Attribute -> Bool

452isResolvedAttribute :: Attribute -> Bool

454isResolvedAttribute = isResolvedType . A.atomType

453isResolvedAttribute = isResolvedType . A.atomType

src/lib/ProjectM36/Atomable.hs+1−2

@@ -235,9 +235,8 @@ typeToTypeConstructor x@DayAtomType = PrimitiveTypeConstructor "Day" x

235typeToTypeConstructor x@DateTimeAtomType = PrimitiveTypeConstructor "DateTime" x

236typeToTypeConstructor x@ByteStringAtomType = PrimitiveTypeConstructor "ByteString" x

237typeToTypeConstructor x@BoolAtomType = PrimitiveTypeConstructor "Bool" x

238−typeToTypeConstructor x@RelationalExprAtomType = PrimitiveTypeConstructor "RelationalExpr" x

239typeToTypeConstructor (RelationAtomType attrs)

238typeToTypeConstructor (RelationAtomType attrs)

240− = RelationAtomTypeConstructor $ map attrToAttrExpr $ V.toList (attributesVec attrs)

239+ = RelationAtomTypeConstructor $ map attrToAttrExpr $ V.toList attrs

241 where

240 where

242 attrToAttrExpr (Attribute n t) = AttributeAndTypeNameExpr n (typeToTypeConstructor t) ()

241 attrToAttrExpr (Attribute n t) = AttributeAndTypeNameExpr n (typeToTypeConstructor t) ()

243typeToTypeConstructor (ConstructedAtomType tcName tvMap)

242typeToTypeConstructor (ConstructedAtomType tcName tvMap)

src/lib/ProjectM36/Attribute.hs+29−148

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

1−{-# OPTIONS_GHC -fno-warn-orphans #-}

2module ProjectM36.Attribute where

1module ProjectM36.Attribute where

3import ProjectM36.Base

2import ProjectM36.Base

4import ProjectM36.Error

3import ProjectM36.Error

@@ -11,54 +10,16 @@ import qualified Data.Map as M

11import Data.Either

10import Data.Either

12

11

13arity :: Attributes -> Int

12arity :: Attributes -> Int

14−arity a = V.length (attributesVec a)

13+arity = V.length

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− }

27

14

28emptyAttributes :: Attributes

15emptyAttributes :: Attributes

29−emptyAttributes = mempty

16+emptyAttributes = V.empty

30

17

31null :: Attributes -> Bool

18null :: Attributes -> Bool

32−null a = V.null (attributesVec a)

19+null = V.null

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)

42

20

43attributesFromList :: [Attribute] -> Attributes

21attributesFromList :: [Attribute] -> Attributes

44−attributesFromList attrsL = Attributes {

22+attributesFromList = V.fromList -- . L.nub --too expensive

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

62

23

63attributeName :: Attribute -> AttributeName

24attributeName :: Attribute -> AttributeName

64attributeName (Attribute name _) = name

25attributeName (Attribute name _) = name

@@ -67,16 +28,17 @@ atomType :: Attribute -> AtomType

67atomType (Attribute _ atype) = atype

28atomType (Attribute _ atype) = atype

68

29

69atomTypes :: Attributes -> V.Vector AtomType

30atomTypes :: Attributes -> V.Vector AtomType

70−atomTypes attrs = V.map atomType (attributesVec attrs)

31+atomTypes = V.map atomType

71

32

72atomTypesList :: Attributes -> [AtomType]

33atomTypesList :: Attributes -> [AtomType]

73atomTypesList = V.toList . atomTypes

34atomTypesList = V.toList . atomTypes

74

35

36+--hm- no error-checking here

75addAttribute :: Attribute -> Attributes -> Attributes

37addAttribute :: Attribute -> Attributes -> Attributes

76−addAttribute attr attrs = attrs <> singleton attr

38+addAttribute attr attrs = attrs `V.snoc` attr

77

39

78--if some attribute names overlap but the types do not, then spit back an error

40--if some attribute names overlap but the types do not, then spit back an error

79−{-joinAttributes :: Attributes -> Attributes -> Either RelationalError Attributes

41+joinAttributes :: Attributes -> Attributes -> Either RelationalError Attributes

80joinAttributes attrs1 attrs2 | V.length uniqueOverlappingAttributes /= V.length overlappingAttributes = Left (TupleAttributeTypeMismatchError overlappingAttributes)

42joinAttributes attrs1 attrs2 | V.length uniqueOverlappingAttributes /= V.length overlappingAttributes = Left (TupleAttributeTypeMismatchError overlappingAttributes)

81 | V.length overlappingAttrsDifferentTypes > 0 = Left (TupleAttributeTypeMismatchError overlappingAttrsDifferentTypes)

43 | V.length overlappingAttrsDifferentTypes > 0 = Left (TupleAttributeTypeMismatchError overlappingAttrsDifferentTypes)

82 | otherwise = Right $ vectorUniqueify (attrs1 V.++ attrs2)

44 | otherwise = Right $ vectorUniqueify (attrs1 V.++ attrs2)

@@ -85,52 +47,20 @@ joinAttributes attrs1 attrs2 | V.length uniqueOverlappingAttributes /= V.length

85 attrNames2 = V.map attributeName attrs2

47 attrNames2 = V.map attributeName attrs2

86 uniqueOverlappingAttributes = vectorUniqueify overlappingAttributes

48 uniqueOverlappingAttributes = vectorUniqueify overlappingAttributes

87 overlappingAttributes = V.filter (`V.elem` attrs2) attrs1

49 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− }

106

50

107addAttributes :: Attributes -> Attributes -> Attributes

51addAttributes :: Attributes -> Attributes -> Attributes

108−addAttributes = (<>)

52+addAttributes = (V.++)

109−

110−member :: Attribute -> Attributes -> Bool

111−member attr attrs = HS.member attr (attributesSet attrs)

112

53

113deleteAttributeName :: AttributeName -> Attributes -> Attributes

54deleteAttributeName :: AttributeName -> Attributes -> Attributes

114−deleteAttributeName attrName = deleteAttributeNames (S.singleton attrName)

55+deleteAttributeName attrName = V.filter (\attr -> attributeName attr /= 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

123

56

124renameAttribute :: AttributeName -> Attribute -> Attribute

57renameAttribute :: AttributeName -> Attribute -> Attribute

125renameAttribute newAttrName (Attribute _ typeo) = Attribute newAttrName typeo

58renameAttribute newAttrName (Attribute _ typeo) = Attribute newAttrName typeo

126

59

127renameAttributes :: AttributeName -> AttributeName -> Attributes -> Attributes

60renameAttributes :: AttributeName -> AttributeName -> Attributes -> Attributes

128−renameAttributes oldAttrName newAttrName attrs = Attributes {

61+renameAttributes oldAttrName newAttrName = V.map renamer

129− attributesVec = vec

130− }

131 where

62 where

132− vec = V.map renamer (attributesVec attrs)

133− renamer attr = if attributeName attr == oldAttrName then

63+ renamer attr = if attributeName attr == oldAttrName then

134 renameAttribute newAttrName attr

64 renameAttribute newAttrName attr

135 else

65 else

136 attr

66 attr

@@ -141,7 +71,7 @@ atomTypeForAttributeName attrName attrs = do

141 return atype

71 return atype

142

72

143attributeForName :: AttributeName -> Attributes -> Either RelationalError Attribute

73attributeForName :: AttributeName -> Attributes -> Either RelationalError Attribute

144−attributeForName attrName attrs = case V.find (\attr -> attributeName attr == attrName) (attributesVec attrs) of

74+attributeForName attrName attrs = case V.find (\attr -> attributeName attr == attrName) attrs of

145 Nothing -> Left (NoSuchAttributeNamesError (S.singleton attrName))

75 Nothing -> Left (NoSuchAttributeNamesError (S.singleton attrName))

146 Just attr -> Right attr

76 Just attr -> Right attr

147

77

@@ -159,18 +89,15 @@ projectionAttributesForNames names attrsIn =

159 missingNames = attributeNamesNotContained names (S.fromList (V.toList (attributeNames attrsIn)))

89 missingNames = attributeNamesNotContained names (S.fromList (V.toList (attributeNames attrsIn)))

160

90

161attributesForNames :: S.Set AttributeName -> Attributes -> Attributes

91attributesForNames :: S.Set AttributeName -> Attributes -> Attributes

162−attributesForNames attrNameSet attrs = Attributes {

92+attributesForNames attrNameSet = V.filter filt

163− attributesVec = vec

164− }

165 where

93 where

166− vec = V.filter filt (attributesVec attrs)

167 filt attr = S.member (attributeName attr) attrNameSet

94 filt attr = S.member (attributeName attr) attrNameSet

168

95

169attributeNameSet :: Attributes -> S.Set AttributeName

96attributeNameSet :: Attributes -> S.Set AttributeName

170−attributeNameSet attrs = S.fromList $ V.toList $ V.map (\(Attribute name _) -> name) (attributesVec attrs)

97+attributeNameSet attrVec = S.fromList $ V.toList $ V.map (\(Attribute name _) -> name) attrVec

171

98

172attributeNames :: Attributes -> V.Vector AttributeName

99attributeNames :: Attributes -> V.Vector AttributeName

173−attributeNames attrs = V.map attributeName (attributesVec attrs)

100+attributeNames = V.map attributeName

174

101

175--checks if set s1 is wholly contained in the set s2

102--checks if set s1 is wholly contained in the set s2

176attributesContained :: Attributes -> Attributes -> Bool

103attributesContained :: Attributes -> Attributes -> Bool

@@ -191,88 +118,42 @@ attributeNamesNotContained subset superset = S.filter (`S.notMember` superset) s

191

118

192-- useful for display

119-- useful for display

193orderedAttributes :: Attributes -> [Attribute]

120orderedAttributes :: Attributes -> [Attribute]

194−orderedAttributes attrs = L.sortBy (\a b -> attributeName a `compare` attributeName b) (V.toList (attributesVec attrs))

121+orderedAttributes attrs = L.sortBy (\a b -> attributeName a `compare` attributeName b) (V.toList attrs)

195

122

196orderedAttributeNames :: Attributes -> [AttributeName]

123orderedAttributeNames :: Attributes -> [AttributeName]

197orderedAttributeNames attrs = map attributeName (orderedAttributes attrs)

124orderedAttributeNames attrs = map attributeName (orderedAttributes attrs)

198

125

199-- take two attribute sets and return an attribute set with the attributes which do not match

126-- 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

201attributesDifference :: Attributes -> Attributes -> Attributes

127attributesDifference :: Attributes -> Attributes -> Attributes

202−{-attributesDifference attrsA attrsB = V.fromList $ diff (V.toList attrsA) (V.toList attrsB)

128+attributesDifference attrsA attrsB = V.fromList $ diff (V.toList attrsA) (V.toList attrsB)

203 where

129 where

204 diff a b = (a L.\\ b) ++ (b L.\\ a)

130 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)

219

131

220vectorUniqueify :: (Hash.Hashable a, Eq a) => V.Vector a -> V.Vector a

132vectorUniqueify :: (Hash.Hashable a, Eq a) => V.Vector a -> V.Vector a

221vectorUniqueify vecIn = V.fromList $ HS.toList $ HS.fromList $ V.toList vecIn

133vectorUniqueify vecIn = V.fromList $ HS.toList $ HS.fromList $ V.toList vecIn

222

134

223--check that each attribute only appears once

135--check that each attribute only appears once

224verifyAttributes :: Attributes -> Either RelationalError Attributes

136verifyAttributes :: Attributes -> Either RelationalError Attributes

225−verifyAttributes attrs =

137+verifyAttributes attrs = if collapsedAttrs /= attrs then

226− if vecSet == attributesSet attrs then

227− pure attrs

228− else

229− Left (TupleAttributeTypeMismatchError diffAttrs)

138+ Left (TupleAttributeTypeMismatchError (attributesDifference collapsedAttrs attrs))

139+ else

140+ Right attrs

230 where

141 where

231− vecSet = V.foldr' HS.insert HS.empty (attributesVec attrs)

142+ collapsedAttrs = vectorUniqueify 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

250

143

251−-- use to determine if the same attributes are contained (but ordering is irrelevant)

252attributesEqual :: Attributes -> Attributes -> Bool

144attributesEqual :: Attributes -> Attributes -> Bool

253−attributesEqual attrsA attrsB =

145+attributesEqual attrs1 attrs2 = V.null (attributesDifference attrs1 attrs2)

254− attributesVec attrsA == attributesVec attrsB ||

255− attributesSet attrsA == attributesSet attrsB

256

146

257attributesAsMap :: Attributes -> M.Map AttributeName Attribute

147attributesAsMap :: Attributes -> M.Map AttributeName Attribute

258−attributesAsMap attrs = V.foldr' (\attr acc -> M.insert (attributeName attr) attr acc) mempty (attributesVec attrs)

148+attributesAsMap attrs = (M.fromList . V.toList) (V.map (\attr -> (attributeName attr, attr)) attrs)

259−

260

149

261-- | Left-biased union of attributes.

150-- | Left-biased union of attributes.

262union :: Attributes -> Attributes -> Attributes

151union :: Attributes -> Attributes -> Attributes

263−union attrsA attrsB = Attributes {

152+union attrsA attrsB = V.fromList (M.elems unioned)

264− attributesVec = vec

265− --,attributesSet = hset

266− }

267 where

153 where

268− hset = HS.union (attributesSet attrsA) (attributesSet attrsB)

154+ unioned = M.union (attributesAsMap attrsA) (attributesAsMap attrsB)

269− vec = HS.foldr (flip V.snoc) mempty hset

270

155

271intersection :: Attributes -> Attributes -> Attributes

156intersection :: Attributes -> Attributes -> Attributes

272−intersection attrsA attrsB = Attributes {

157+intersection attrsA attrsB = V.fromList (M.elems intersected)

273− attributesVec = vec

274− --,attributesSet = hset

275− }

276 where

158 where

277− hset = HS.intersection (attributesSet attrsA) (attributesSet attrsB)

159+ intersected = M.intersection (attributesAsMap attrsA) (attributesAsMap attrsB)

278− vec = HS.foldr (flip V.snoc) mempty hset

src/lib/ProjectM36/Base.hs+47−94

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

1−{-# LANGUAGE ExistentialQuantification,DeriveGeneric,DeriveAnyClass,FlexibleInstances,OverloadedStrings, DeriveTraversable, DerivingVia, TemplateHaskell, TypeFamilies #-}

1+{-# LANGUAGE ExistentialQuantification,DeriveGeneric,DeriveAnyClass,FlexibleInstances,OverloadedStrings, DeriveTraversable, DerivingVia #-}

2{-# OPTIONS_GHC -fno-warn-orphans #-}

3

4module ProjectM36.Base where

@@ -6,7 +6,6 @@ import ProjectM36.DatabaseContextFunctionError

6import ProjectM36.AtomFunctionError

7import ProjectM36.MerkleHash

8

9−import Data.Functor.Foldable.TH

10import qualified Data.Map as M

9import qualified Data.Map as M

11import qualified Data.HashSet as HS

10import qualified Data.HashSet as HS

12import Data.Hashable (Hashable, hashWithSalt)

11import Data.Hashable (Hashable, hashWithSalt)

@@ -25,11 +24,8 @@ import Data.Time.Calendar (Day)

25import Data.Typeable

24import Data.Typeable

26import Data.ByteString (ByteString)

25import Data.ByteString (ByteString)

27import qualified Data.List.NonEmpty as NE

26import qualified Data.List.NonEmpty as NE

28−import Data.Vector.Instances ()

29

27

30type StringType = Text

28type StringType = Text

31−

32−type DatabaseName = String

33

29

34-- | Database atoms are the smallest, undecomposable units of a tuple. Common examples are integers, text, or unique identity keys.

30-- | Database atoms are the smallest, undecomposable units of a tuple. Common examples are integers, text, or unique identity keys.

35data Atom = IntegerAtom Integer |

31data Atom = IntegerAtom Integer |

@@ -41,9 +37,8 @@ data Atom = IntegerAtom Integer |

41 ByteStringAtom ByteString |

37 ByteStringAtom ByteString |

42 BoolAtom Bool |

38 BoolAtom Bool |

43 RelationAtom Relation |

39 RelationAtom Relation |

44− RelationalExprAtom RelationalExpr | --used for returning inc deps

45 ConstructedAtom DataConstructorName AtomType [Atom]

40 ConstructedAtom DataConstructorName AtomType [Atom]

46− deriving (Eq, Show, Typeable, NFData, Generic, Read)

41+ deriving (Eq, Show, Typeable, NFData, Generic)

47

42

48instance Hashable Atom where

43instance Hashable Atom where

49 hashWithSalt salt (ConstructedAtom dConsName _ atoms) = salt `hashWithSalt` atoms

44 hashWithSalt salt (ConstructedAtom dConsName _ atoms) = salt `hashWithSalt` atoms

@@ -57,7 +52,6 @@ instance Hashable Atom where

57 hashWithSalt salt (ByteStringAtom bs) = salt `hashWithSalt` bs

52 hashWithSalt salt (ByteStringAtom bs) = salt `hashWithSalt` bs

58 hashWithSalt salt (BoolAtom b) = salt `hashWithSalt` b

53 hashWithSalt salt (BoolAtom b) = salt `hashWithSalt` b

59 hashWithSalt salt (RelationAtom r) = salt `hashWithSalt` r

54 hashWithSalt salt (RelationAtom r) = salt `hashWithSalt` r

60− hashWithSalt salt (RelationalExprAtom re) = salt `hashWithSalt` re

61

55

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.

56-- 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.

63-- | The AtomType uniquely identifies the type of a atom.

57-- | The AtomType uniquely identifies the type of a atom.

@@ -71,15 +65,13 @@ data AtomType = IntAtomType |

71 BoolAtomType |

65 BoolAtomType |

72 RelationAtomType Attributes |

66 RelationAtomType Attributes |

73 ConstructedAtomType TypeConstructorName TypeVarMap |

67 ConstructedAtomType TypeConstructorName TypeVarMap |

74− RelationalExprAtomType |

75 TypeVariableType TypeVarName

68 TypeVariableType TypeVarName

76 --wildcard used in Atom Functions and tuples for data constructors which don't provide all arguments to the type constructor

69 --wildcard used in Atom Functions and tuples for data constructors which don't provide all arguments to the type constructor

77− deriving (Eq, NFData, Generic, Show, Read, Hashable)

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

78

71

79instance Ord AtomType where

72instance Ord AtomType where

80 compare = undefined

73 compare = undefined

81−

74+

82−-- this should probably be an ordered dictionary in order to be able to round-trip these arguments

83type TypeVarMap = M.Map TypeVarName AtomType

75type TypeVarMap = M.Map TypeVarName AtomType

84

76

85instance Hashable TypeVarMap where

77instance Hashable TypeVarMap where

@@ -94,40 +86,25 @@ isRelationAtomType _ = False

94type AttributeName = StringType

86type AttributeName = StringType

95

87

96-- | A relation's type is composed of attribute names and types.

88-- | A relation's type is composed of attribute names and types.

97−data Attribute = Attribute AttributeName AtomType deriving (Eq, Show, Read, Generic, NFData)

89+data Attribute = Attribute AttributeName AtomType deriving (Eq, Show, Generic, NFData)

98

90

99instance Hashable Attribute where

91instance Hashable Attribute where

100 hashWithSalt salt (Attribute attrName _) = hashWithSalt salt attrName

92 hashWithSalt salt (Attribute attrName _) = hashWithSalt salt attrName

101

93

102−type AttributesHash = Int

103−

104-- | 'Attributes' represent the head of a relation.

94-- | 'Attributes' represent the head of a relation.

105−newtype Attributes = Attributes {

106− attributesVec :: V.Vector Attribute

95+type Attributes = 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

122

96

97+-- | Equality function for a set of attributes.

98+attributesEqual :: Attributes -> Attributes -> Bool

99+attributesEqual attrs1 attrs2 = attrsAsSet attrs1 == attrsAsSet attrs2

100+ where

101+ attrsAsSet = HS.fromList . V.toList

102+

123sortedAttributesIndices :: Attributes -> [(Int, Attribute)]

103sortedAttributesIndices :: Attributes -> [(Int, Attribute)]

124−sortedAttributesIndices attrs = L.sortBy (\(_, Attribute name1 _) (_,Attribute name2 _) -> compare name1 name2) $ V.toList (V.indexed (attributesVec attrs))

104+sortedAttributesIndices attrs = L.sortBy (\(_, Attribute name1 _) (_,Attribute name2 _) -> compare name1 name2) $ V.toList (V.indexed attrs)

125

105

126-- | The relation's tuple set is the body of the relation.

106-- | The relation's tuple set is the body of the relation.

127−newtype RelationTupleSet = RelationTupleSet { asList :: [RelationTuple] } deriving (Hashable, Show, Generic, Read)

107+newtype RelationTupleSet = RelationTupleSet { asList :: [RelationTuple] } deriving (Hashable, Show, Generic)

128−

129−instance Read Relation where

130− readsPrec = error "relation read not supported"

131

108

132instance Eq RelationTupleSet where

109instance Eq RelationTupleSet where

133 set1 == set2 = hset set1 == hset set2

110 set1 == set2 = hset set1 == hset set2

@@ -140,8 +117,8 @@ instance NFData RelationTupleSet where rnf = genericRnf

140instance Hashable RelationTuple where

117instance Hashable RelationTuple where

141 --sanity check the tuple for attribute and tuple counts

118 --sanity check the tuple for attribute and tuple counts

142 --this bit me when tuples were being hashed before being verified

119 --this bit me when tuples were being hashed before being verified

143− hashWithSalt salt (RelationTuple attrs tupVec) = if V.length (attributesVec attrs) /= V.length tupVec then

120+ hashWithSalt salt (RelationTuple attrs tupVec) = if V.length attrs /= V.length tupVec then

144− error ("invalid tuple: attributes and tuple count mismatch " <> show (attributesVec attrs, tupVec))

121+ error "invalid tuple: attributes and tuple count mismatch"

145 else

122 else

146 salt `hashWithSalt`

123 salt `hashWithSalt`

147 sortedAttrs `hashWithSalt`

124 sortedAttrs `hashWithSalt`

@@ -152,23 +129,22 @@ instance Hashable RelationTuple where

152 sortedTupVec = V.map (\(index, _) -> tupVec V.! index) $ V.fromList sortedAttrsIndices

129 sortedTupVec = V.map (\(index, _) -> tupVec V.! index) $ V.fromList sortedAttrsIndices

153

130

154-- | A tuple is a set of attributes mapped to their 'Atom' values.

131-- | A tuple is a set of attributes mapped to their 'Atom' values.

155−data RelationTuple = RelationTuple Attributes (V.Vector Atom) deriving (Show, Read, Generic)

132+data RelationTuple = RelationTuple Attributes (V.Vector Atom) deriving (Show, Generic)

156

133

157instance Eq RelationTuple where

134instance Eq RelationTuple where

158− tuple1@(RelationTuple attrs1 _) == tuple2@(RelationTuple attrs2 _) =

135+ (==) tuple1@(RelationTuple attrs1 _) tuple2@(RelationTuple attrs2 _) = attributesEqual attrs1 attrs2 && atomsEqual

159− attrs1 == attrs2 && atomsEqual

160 where

136 where

161− atomForAttribute attr (RelationTuple attrs tupVec) = case V.findIndex (== attr) (attributesVec attrs) of

137+ atomForAttribute attr (RelationTuple attrs tupVec) = case V.findIndex (== attr) attrs of

162 Nothing -> Nothing

138 Nothing -> Nothing

163 Just index -> tupVec V.!? index

139 Just index -> tupVec V.!? index

164− atomsEqual = V.all (== True) $ V.map (\attr -> atomForAttribute attr tuple1 == atomForAttribute attr tuple2) (attributesVec attrs1)

140+ atomsEqual = V.all (== True) $ V.map (\attr -> atomForAttribute attr tuple1 == atomForAttribute attr tuple2) attrs1

165

141

166instance NFData RelationTuple where rnf = genericRnf

142instance NFData RelationTuple where rnf = genericRnf

167

143

168data Relation = Relation Attributes RelationTupleSet deriving (Show, Generic,Typeable)

144data Relation = Relation Attributes RelationTupleSet deriving (Show, Generic,Typeable)

169

145

170instance Eq Relation where

146instance Eq Relation where

171− Relation attrs1 tupSet1 == Relation attrs2 tupSet2 = attrs1 == attrs2 && tupSet1 == tupSet2

147+ Relation attrs1 tupSet1 == Relation attrs2 tupSet2 = attributesEqual attrs1 attrs2 && tupSet1 == tupSet2

172

148

173instance NFData Relation where rnf = genericRnf

149instance NFData Relation where rnf = genericRnf

174

150

@@ -223,12 +199,10 @@ data RelationalExprBase a =

223 --Summarize :: AtomExpr -> AttributeName -> RelationalExpr -> RelationalExpr -> RelationalExpr -- a special case of Extend

199 --Summarize :: AtomExpr -> AttributeName -> RelationalExpr -> RelationalExpr -> RelationalExpr -- a special case of Extend

224 --Evaluate relationalExpr with scoped views

200 --Evaluate relationalExpr with scoped views

225 With [(WithNameExprBase a, RelationalExprBase a)] (RelationalExprBase a)

201 With [(WithNameExprBase a, RelationalExprBase a)] (RelationalExprBase a)

226− deriving (Show, Read, Eq, Generic, NFData, Foldable, Functor, Traversable)

202+ deriving (Show, Eq, Generic, NFData, Foldable, Functor, Traversable)

227−

203+

228−instance Hashable RelationalExpr

229−

230data WithNameExprBase a = WithNameExpr RelVarName a

204data WithNameExprBase a = WithNameExpr RelVarName a

231− deriving (Show, Read, Eq, Generic, NFData, Foldable, Functor, Traversable, Hashable)

205+ deriving (Show, Eq, Generic, NFData, Foldable, Functor, Traversable)

232

206

233type WithNameExpr = WithNameExprBase ()

207type WithNameExpr = WithNameExprBase ()

234

208

@@ -250,15 +224,15 @@ type TypeVarName = StringType

250-- | Metadata definition for type constructors such as @data Either a b@.

224-- | Metadata definition for type constructors such as @data Either a b@.

251data TypeConstructorDef = ADTypeConstructorDef TypeConstructorName [TypeVarName] |

225data TypeConstructorDef = ADTypeConstructorDef TypeConstructorName [TypeVarName] |

252 PrimitiveTypeConstructorDef TypeConstructorName AtomType

226 PrimitiveTypeConstructorDef TypeConstructorName AtomType

253− deriving (Show, Generic, Eq, NFData, Hashable, Read)

227+ deriving (Show, Generic, Eq, NFData)

254

228

255-- | Found in data constructors and type declarations: Left (Either Int Text) | Right Int

229-- | Found in data constructors and type declarations: Left (Either Int Text) | Right Int

256type TypeConstructor = TypeConstructorBase ()

230type TypeConstructor = TypeConstructorBase ()

257data TypeConstructorBase a = ADTypeConstructor TypeConstructorName [TypeConstructor] |

231data TypeConstructorBase a = ADTypeConstructor TypeConstructorName [TypeConstructor] |

258− PrimitiveTypeConstructor TypeConstructorName AtomType |

232+ PrimitiveTypeConstructor TypeConstructorName AtomType |

259− RelationAtomTypeConstructor [AttributeExprBase a] |

233+ RelationAtomTypeConstructor [AttributeExprBase a] |

260− TypeVariable TypeVarName

234+ TypeVariable TypeVarName

261− deriving (Show, Generic, Eq, NFData, Hashable, Read)

235+ deriving (Show, Generic, Eq, NFData)

262

236

263type TypeConstructorMapping = [(TypeConstructorDef, DataConstructorDefs)]

237type TypeConstructorMapping = [(TypeConstructorDef, DataConstructorDefs)]

264

238

@@ -268,13 +242,13 @@ type DataConstructorName = StringType

268type AtomTypeName = StringType

242type AtomTypeName = StringType

269

243

270-- | Used to define a data constructor in a type constructor context such as @Left a | Right b@

244-- | Used to define a data constructor in a type constructor context such as @Left a | Right b@

271−data DataConstructorDef = DataConstructorDef DataConstructorName [DataConstructorDefArg] deriving (Eq, Show, Generic, NFData, Hashable, Read)

245+data DataConstructorDef = DataConstructorDef DataConstructorName [DataConstructorDefArg] deriving (Eq, Show, Generic, NFData)

272

246

273type DataConstructorDefs = [DataConstructorDef]

247type DataConstructorDefs = [DataConstructorDef]

274

248

275data DataConstructorDefArg = DataConstructorDefTypeConstructorArg TypeConstructor |

249data DataConstructorDefArg = DataConstructorDefTypeConstructorArg TypeConstructor |

276 DataConstructorDefTypeVarNameArg TypeVarName

250 DataConstructorDefTypeVarNameArg TypeVarName

277− deriving (Show, Generic, Eq, NFData, Hashable, Read)

251+ deriving (Show, Generic, Eq, NFData)

278

252

279type InclusionDependencies = M.Map IncDepName InclusionDependency

253type InclusionDependencies = M.Map IncDepName InclusionDependency

280type RelationVariables = M.Map RelVarName GraphRefRelationalExpr

254type RelationVariables = M.Map RelVarName GraphRefRelationalExpr

@@ -319,7 +293,7 @@ data DatabaseContext = DatabaseContext {

319type IncDepName = StringType

293type IncDepName = StringType

320

294

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.

295-- | Inclusion dependencies represent every possible database constraint. Constraints enforce specific, arbitrarily-complex rules to which the database context's relation variables must adhere unconditionally.

322−data InclusionDependency = InclusionDependency RelationalExpr RelationalExpr deriving (Show, Eq, Generic, NFData, Hashable, Read)

296+data InclusionDependency = InclusionDependency RelationalExpr RelationalExpr deriving (Show, Eq, Generic, NFData)

323

297

324type AttributeNameAtomExprMap = M.Map AttributeName AtomExpr

298type AttributeNameAtomExprMap = M.Map AttributeName AtomExpr

325

299

@@ -328,8 +302,6 @@ type DatabaseContextExprName = StringType

328

302

329type DatabaseContextExpr = DatabaseContextExprBase ()

303type DatabaseContextExpr = DatabaseContextExprBase ()

330

304

331−instance Hashable DatabaseContextExpr

332−

333type GraphRefDatabaseContextExpr = DatabaseContextExprBase GraphRefTransactionMarker

305type GraphRefDatabaseContextExpr = DatabaseContextExprBase GraphRefTransactionMarker

334

306

335-- | Database context expressions modify the database context.

307-- | Database context expressions modify the database context.

@@ -359,10 +331,7 @@ data DatabaseContextExprBase a =

359 ExecuteDatabaseContextFunction DatabaseContextFunctionName [AtomExprBase a] |

331 ExecuteDatabaseContextFunction DatabaseContextFunctionName [AtomExprBase a] |

360

332

361 MultipleExpr [DatabaseContextExprBase a]

333 MultipleExpr [DatabaseContextExprBase a]

362− deriving (Show, Read, Eq, Generic, NFData)

334+ deriving (Show, Eq, Generic)

363−

364−instance Hashable (M.Map AttributeName AtomExpr) where

365− hashWithSalt salt m = salt `hashWithSalt` M.toList m

366

335

367type ObjModuleName = StringType

336type ObjModuleName = StringType

368type ObjFunctionName = StringType

337type ObjFunctionName = StringType

@@ -382,8 +351,6 @@ type DatabaseContextIOExpr = DatabaseContextIOExprBase ()

382

351

383type RestrictionPredicateExpr = RestrictionPredicateExprBase ()

352type RestrictionPredicateExpr = RestrictionPredicateExprBase ()

384

353

385−instance Hashable RestrictionPredicateExpr

386−

387type GraphRefRestrictionPredicateExpr = RestrictionPredicateExprBase GraphRefTransactionMarker

354type GraphRefRestrictionPredicateExpr = RestrictionPredicateExprBase GraphRefTransactionMarker

388

355

389-- | Restriction predicates are boolean algebra components which, when composed, indicate whether or not a tuple should be retained during a restriction (filtering) operation.

356-- | Restriction predicates are boolean algebra components which, when composed, indicate whether or not a tuple should be retained during a restriction (filtering) operation.

@@ -395,7 +362,7 @@ data RestrictionPredicateExprBase a =

395 RelationalExprPredicate (RelationalExprBase a) | --type must be same as true and false relations (no attributes)

362 RelationalExprPredicate (RelationalExprBase a) | --type must be same as true and false relations (no attributes)

396 AtomExprPredicate (AtomExprBase a) | --atom must evaluate to boolean

363 AtomExprPredicate (AtomExprBase a) | --atom must evaluate to boolean

397 AttributeEqualityPredicate AttributeName (AtomExprBase a) -- relationalexpr must result in relation with single tuple

364 AttributeEqualityPredicate AttributeName (AtomExprBase a) -- relationalexpr must result in relation with single tuple

398− deriving (Show, Read, Eq, Generic, NFData, Foldable, Functor, Traversable)

365+ deriving (Show, Eq, Generic, NFData, Foldable, Functor, Traversable)

399

366

400-- child + parent links

367-- child + parent links

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.

368-- | 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.

@@ -456,8 +423,6 @@ instance Ord Transaction where

456

423

457type AtomExpr = AtomExprBase ()

424type AtomExpr = AtomExprBase ()

458

425

459−instance Hashable AtomExpr

460−

461type GraphRefAtomExpr = AtomExprBase GraphRefTransactionMarker

426type GraphRefAtomExpr = AtomExprBase GraphRefTransactionMarker

462

427

463-- | An atom expression represents an action to take when extending a relation or when statically defining a relation or a new tuple.

428-- | An atom expression represents an action to take when extending a relation or when statically defining a relation or a new tuple.

@@ -466,16 +431,13 @@ data AtomExprBase a = AttributeAtomExpr AttributeName |

466 FunctionAtomExpr AtomFunctionName [AtomExprBase a] a |

431 FunctionAtomExpr AtomFunctionName [AtomExprBase a] a |

467 RelationAtomExpr (RelationalExprBase a) |

432 RelationAtomExpr (RelationalExprBase a) |

468 ConstructedAtomExpr DataConstructorName [AtomExprBase a] a

433 ConstructedAtomExpr DataConstructorName [AtomExprBase a] a

469− deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable)

434+ deriving (Eq,Show,Generic, NFData, Foldable, Functor, Traversable)

470

435

471-- | Used in tuple creation when creating a relation.

436-- | Used in tuple creation when creating a relation.

472data ExtendTupleExprBase a = AttributeExtendTupleExpr AttributeName (AtomExprBase a)

437data ExtendTupleExprBase a = AttributeExtendTupleExpr AttributeName (AtomExprBase a)

473− deriving (Show, Read, Eq, Generic, NFData, Foldable, Functor, Traversable)

438+ deriving (Show, Eq, Generic, NFData, Foldable, Functor, Traversable)

474

439

475type ExtendTupleExpr = ExtendTupleExprBase ()

440type ExtendTupleExpr = ExtendTupleExprBase ()

476−

477−instance Hashable ExtendTupleExpr

478−

479type GraphRefExtendTupleExpr = ExtendTupleExprBase GraphRefTransactionMarker

441type GraphRefExtendTupleExpr = ExtendTupleExprBase GraphRefTransactionMarker

480

442

481--enumerates the list of functions available to be run as part of tuple expressions

443--enumerates the list of functions available to be run as part of tuple expressions

@@ -523,12 +485,7 @@ data AttributeNamesBase a = AttributeNames (S.Set AttributeName) |

523 UnionAttributeNames (AttributeNamesBase a) (AttributeNamesBase a) |

485 UnionAttributeNames (AttributeNamesBase a) (AttributeNamesBase a) |

524 IntersectAttributeNames (AttributeNamesBase a) (AttributeNamesBase a) |

486 IntersectAttributeNames (AttributeNamesBase a) (AttributeNamesBase a) |

525 RelationalExprAttributeNames (RelationalExprBase a) -- use attribute names from the relational expression's type

487 RelationalExprAttributeNames (RelationalExprBase a) -- use attribute names from the relational expression's type

526− deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable)

488+ deriving (Eq, Show, 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

532

489

533type AttributeNames = AttributeNamesBase ()

490type AttributeNames = AttributeNamesBase ()

534

491

@@ -546,22 +503,18 @@ type GraphRefAttributeExpr = AttributeExprBase GraphRefTransactionMarker

546-- | Create attributes dynamically.

503-- | Create attributes dynamically.

547data AttributeExprBase a = AttributeAndTypeNameExpr AttributeName TypeConstructor a |

504data AttributeExprBase a = AttributeAndTypeNameExpr AttributeName TypeConstructor a |

548 NakedAttributeExpr Attribute

505 NakedAttributeExpr Attribute

549− deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable, Hashable)

506+ deriving (Eq, Show, Generic, NFData, Foldable, Functor, Traversable)

550

507

551-- | Dynamically create a tuple from attribute names and 'AtomExpr's.

508-- | Dynamically create a tuple from attribute names and 'AtomExpr's.

552newtype TupleExprBase a = TupleExpr (M.Map AttributeName (AtomExprBase a))

509newtype TupleExprBase a = TupleExpr (M.Map AttributeName (AtomExprBase a))

553− deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable)

510+ deriving (Eq, Show, Generic, NFData, Foldable, Functor, Traversable)

554−

511+

555−instance Hashable TupleExpr

556−

557type TupleExpr = TupleExprBase ()

512type TupleExpr = TupleExprBase ()

558

513

559type GraphRefTupleExpr = TupleExprBase GraphRefTransactionMarker

514type GraphRefTupleExpr = TupleExprBase GraphRefTransactionMarker

560

515

561data TupleExprsBase a = TupleExprs a [TupleExprBase a]

516data TupleExprsBase a = TupleExprs a [TupleExprBase a]

562− deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable)

517+ deriving (Eq, Show, Generic, NFData, Foldable, Functor, Traversable)

563−

564−instance Hashable TupleExprs

565

518

566type GraphRefTupleExprs = TupleExprsBase GraphRefTransactionMarker

519type GraphRefTupleExprs = TupleExprsBase GraphRefTransactionMarker

567

520

@@ -611,8 +564,7 @@ attrTypeVars (Attribute _ aType) = case aType of

611 DateTimeAtomType -> S.empty

564 DateTimeAtomType -> S.empty

612 ByteStringAtomType -> S.empty

565 ByteStringAtomType -> S.empty

613 BoolAtomType -> S.empty

566 BoolAtomType -> S.empty

614− RelationalExprAtomType -> S.empty

615− (RelationAtomType attrs) -> S.unions (map attrTypeVars (V.toList (attributesVec attrs)))

567+ (RelationAtomType attrs) -> S.unions (map attrTypeVars (V.toList attrs))

616 (ConstructedAtomType _ tvMap) -> M.keysSet tvMap

568 (ConstructedAtomType _ tvMap) -> M.keysSet tvMap

617 (TypeVariableType nam) -> S.singleton nam

569 (TypeVariableType nam) -> S.singleton nam

618

570

@@ -635,12 +587,13 @@ atomTypeVars DayAtomType = S.empty

635atomTypeVars DateTimeAtomType = S.empty

587atomTypeVars DateTimeAtomType = S.empty

636atomTypeVars ByteStringAtomType = S.empty

588atomTypeVars ByteStringAtomType = S.empty

637atomTypeVars BoolAtomType = S.empty

589atomTypeVars BoolAtomType = S.empty

638−atomTypeVars RelationalExprAtomType = S.empty

639−atomTypeVars (RelationAtomType attrs) = S.unions (map attrTypeVars (V.toList (attributesVec attrs)))

590+atomTypeVars (RelationAtomType attrs) = S.unions (map attrTypeVars (V.toList attrs))

640atomTypeVars (ConstructedAtomType _ tvMap) = M.keysSet tvMap

591atomTypeVars (ConstructedAtomType _ tvMap) = M.keysSet tvMap

641atomTypeVars (TypeVariableType nam) = S.singleton nam

592atomTypeVars (TypeVariableType nam) = S.singleton nam

642

593

643unimplemented :: HasCallStack => a

594unimplemented :: HasCallStack => a

644−unimplemented = error "unimplemented"

595+unimplemented = undefined

596+

597+--for serializing GraphRefRelationalExpr as part of transaction serialization

645

598

646−makeBaseFunctor ''RelationalExprBase

599+

src/lib/ProjectM36/Client.hs+135−84

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

1−{-# LANGUAGE DeriveGeneric, ScopedTypeVariables, MonoLocalBinds, DerivingVia #-}

1+{-# LANGUAGE DeriveAnyClass, DeriveGeneric, ScopedTypeVariables, MonoLocalBinds, DerivingVia, GeneralizedNewtypeDeriving, PackageImports #-}

2{-|

3Module: ProjectM36.Client

4

@@ -127,6 +127,7 @@ import ProjectM36.TransGraphRelationalExpression as TGRE (TransGraphRelationalEx

127import ProjectM36.Persist (DiskSync(..))

128import ProjectM36.FileLock

129import ProjectM36.NormalizeExpr

130+import ProjectM36.Server.Types

130import ProjectM36.Notifications

131import ProjectM36.Notifications

131import ProjectM36.Server.RemoteCallTypes

132import ProjectM36.Server.RemoteCallTypes

132import qualified ProjectM36.DisconnectedTransaction as Discon

133import qualified ProjectM36.DisconnectedTransaction as Discon

@@ -134,13 +135,11 @@ import ProjectM36.Relation (typesAsRelation)

134import ProjectM36.ScriptSession (initScriptSession, ScriptSession)

135import ProjectM36.ScriptSession (initScriptSession, ScriptSession)

135import qualified ProjectM36.Relation as R

136import qualified ProjectM36.Relation as R

136import Control.Exception.Base

137import Control.Exception.Base

137−import Control.Concurrent.STM

138+import GHC.Conc.Sync

138−import Control.Concurrent.Async

139

140import Data.Either (isRight)

141import Data.UUID.V4 (nextRandom)

142import Data.Word

143−import Data.Hashable

144import Control.Exception (IOException, handle, AsyncException, throwIO, fromException, Exception)

143import Control.Exception (IOException, handle, AsyncException, throwIO, fromException, Exception)

145import Control.Concurrent.MVar

144import Control.Concurrent.MVar

146import Codec.Winery hiding (Schema, schema)

145import Codec.Winery hiding (Schema, schema)

@@ -162,7 +161,6 @@ import Data.Time.Clock

162import qualified Network.RPC.Curryer.Client as RPC

161import qualified Network.RPC.Curryer.Client as RPC

163import qualified Network.RPC.Curryer.Server as RPC

162import qualified Network.RPC.Curryer.Server as RPC

164import Network.Socket (Socket, AddrInfo(..), getAddrInfo, defaultHints, AddrInfoFlag(..), SocketType(..), ServiceName, hostAddressToTuple, SockAddr(..))

163import Network.Socket (Socket, AddrInfo(..), getAddrInfo, defaultHints, AddrInfoFlag(..), SocketType(..), ServiceName, hostAddressToTuple, SockAddr(..))

165−import GHC.Conc (unsafeIOToSTM)

166

164

167type Hostname = String

165type Hostname = String

168

166

@@ -194,7 +192,7 @@ data ConnectionInfo = InProcessConnectionInfo PersistenceStrategy NotificationCa

194type EvaluatedNotifications = M.Map NotificationName EvaluatedNotification

192type EvaluatedNotifications = M.Map NotificationName EvaluatedNotification

195

193

196-- | Used for callbacks from the server when monitored changes have been made.

194-- | Used for callbacks from the server when monitored changes have been made.

197−newtype NotificationMessage = NotificationMessage EvaluatedNotifications

195+data NotificationMessage = NotificationMessage EvaluatedNotifications

198 deriving (Eq, Show, Generic)

196 deriving (Eq, Show, Generic)

199 deriving Serialise via WineryVariant NotificationMessage

197 deriving Serialise via WineryVariant NotificationMessage

200

198

@@ -228,7 +226,7 @@ defaultRemoteConnectionInfo =

228defaultServerHostname :: Hostname

226defaultServerHostname :: Hostname

229defaultServerHostname = "localhost"

227defaultServerHostname = "localhost"

230

228

231−newtype RemoteConnectionConf = RemoteConnectionConf RPC.Connection

229+data RemoteConnectionConf = RemoteConnectionConf RPC.Connection

232

230

233data Connection = InProcessConnection InProcessConnectionConf |

231data Connection = InProcessConnection InProcessConnectionConf |

234 RemoteConnection RemoteConnectionConf

232 RemoteConnection RemoteConnectionConf

@@ -248,10 +246,9 @@ createScriptSession :: [String] -> IO (Maybe ScriptSession)

248createScriptSession ghcPkgPaths = do

246createScriptSession ghcPkgPaths = do

249 eScriptSession <- initScriptSession ghcPkgPaths

247 eScriptSession <- initScriptSession ghcPkgPaths

250 case eScriptSession of

248 case eScriptSession of

251− Left err -> hPutStrLn stderr ("Warning: Haskell scripting disabled: " ++ show err) >> pure Nothing --not a fatal error, but the scripting feature must be disabled

249+ 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

252 Right s -> pure (Just s)

250 Right s -> pure (Just s)

253

251

254−

255-- | To create a 'Connection' to a remote or local database, create a 'ConnectionInfo' and call 'connectProjectM36'.

252-- | To create a 'Connection' to a remote or local database, create a 'ConnectionInfo' and call 'connectProjectM36'.

256connectProjectM36 :: ConnectionInfo -> IO (Either ConnectionError Connection)

253connectProjectM36 :: ConnectionInfo -> IO (Either ConnectionError Connection)

257--create a new in-memory database/transaction graph

254--create a new in-memory database/transaction graph

@@ -267,16 +264,14 @@ connectProjectM36 (InProcessConnectionInfo strat notificationCallback ghcPkgPath

267 clientNodes <- StmSet.newIO

264 clientNodes <- StmSet.newIO

268 sessions <- StmMap.newIO

265 sessions <- StmMap.newIO

269 mScriptSession <- createScriptSession ghcPkgPaths

266 mScriptSession <- createScriptSession ghcPkgPaths

270− notifAsync <- startNotificationListener clientNodes notificationCallback

267+

271 let conn = InProcessConnection InProcessConnectionConf {

268 let conn = InProcessConnection InProcessConnectionConf {

272 ipPersistenceStrategy = strat,

269 ipPersistenceStrategy = strat,

273 ipClientNodes = clientNodes,

270 ipClientNodes = clientNodes,

274 ipSessions = sessions,

271 ipSessions = sessions,

275 ipTransactionGraph = graphTvar,

272 ipTransactionGraph = graphTvar,

276 ipScriptSession = mScriptSession,

273 ipScriptSession = mScriptSession,

277− ipLocks = Nothing,

274+ ipLocks = Nothing}

278− ipCallbackAsync = notifAsync

279− }

280 pure (Right conn)

275 pure (Right conn)

281 MinimalPersistence dbdir -> connectPersistentProjectM36 strat NoDiskSync dbdir freshGraph notificationCallback ghcPkgPaths

276 MinimalPersistence dbdir -> connectPersistentProjectM36 strat NoDiskSync dbdir freshGraph notificationCallback ghcPkgPaths

282 CrashSafePersistence dbdir -> connectPersistentProjectM36 strat FsyncDiskSync dbdir freshGraph notificationCallback ghcPkgPaths

277 CrashSafePersistence dbdir -> connectPersistentProjectM36 strat FsyncDiskSync dbdir freshGraph notificationCallback ghcPkgPaths

@@ -295,34 +290,25 @@ connectProjectM36 (RemoteConnectionInfo dbName hostName servicePort notification

295 notificationHandlers =

290 notificationHandlers =

296 [RPC.ClientAsyncRequestHandler $

291 [RPC.ClientAsyncRequestHandler $

297 \(NotificationMessage notifications') ->

292 \(NotificationMessage notifications') ->

298− forM_ (M.toList notifications') (uncurry notificationCallback)

293+ forM_ (M.toList notifications') (\(notName, notInfo) ->

294+ notificationCallback notName notInfo)

299 ]

295 ]

300− let connectExcHandler (e :: IOException) = pure $ Left (IOExceptionError e)

296+-- TODO missing async callback

301− eConn <- (Right <$> RPC.connect notificationHandlers (hostAddressToTuple addr) port) `catch` connectExcHandler

297+ conn <- RPC.connect notificationHandlers (hostAddressToTuple addr) port

302− case eConn of

303− Left err -> pure (Left err)

304− Right conn -> do

305− eRet <- RPC.call conn (Login dbName)

298+ eRet <- RPC.call conn (Login dbName)

299+-- TODO handle connection errors

306− case eRet of

300+ case eRet of

307− Left err -> error (show err)

301+ Left err -> error (show err)

308− Right False -> error "wtf"

302+ Right False -> error "wtf"

309− Right True ->

303+ Right True ->

310 --TODO handle connection errors!

304 --TODO handle connection errors!

311− pure (Right (RemoteConnection (RemoteConnectionConf conn)))

305+ pure (Right (RemoteConnection (RemoteConnectionConf conn)))

312

306

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 ()

307+addClientNode :: DatabaseName ->Connection -> RPC.Locking Socket -> IO ()

322−addClientNode (RemoteConnection _) _ = error "addClientNode called on remote connection"

308+addClientNode _ (RemoteConnection _) _ = error "addClientNode called on remote connection"

323−addClientNode (InProcessConnection conf) lockSock = atomically (StmSet.insert clientInfo (ipClientNodes conf))

309+addClientNode dbName (InProcessConnection conf) lockSock = atomically (StmSet.insert clientInfo (ipClientNodes conf))

324 where

310 where

325− clientInfo = RemoteClientInfo lockSock

311+ clientInfo = ClientInfo dbName lockSock

326

312

327connectPersistentProjectM36 :: PersistenceStrategy ->

313connectPersistentProjectM36 :: PersistenceStrategy ->

328 DiskSync ->

314 DiskSync ->

@@ -348,27 +334,17 @@ connectPersistentProjectM36 strat sync dbdir freshGraph notificationCallback ghc

348 sessions <- StmMap.newIO

334 sessions <- StmMap.newIO

349 clientNodes <- StmSet.newIO

335 clientNodes <- StmSet.newIO

350 lockMVar <- newMVar digest

336 lockMVar <- newMVar digest

351− notifAsync <- startNotificationListener clientNodes notificationCallback

352 let conn = InProcessConnection InProcessConnectionConf {

337 let conn = InProcessConnection InProcessConnectionConf {

353 ipPersistenceStrategy = strat,

338 ipPersistenceStrategy = strat,

354 ipClientNodes = clientNodes,

339 ipClientNodes = clientNodes,

355 ipSessions = sessions,

340 ipSessions = sessions,

356 ipTransactionGraph = tvarGraph,

341 ipTransactionGraph = tvarGraph,

357 ipScriptSession = mScriptSession,

342 ipScriptSession = mScriptSession,

358− ipLocks = Just (lockFileH, lockMVar),

343+ ipLocks = Just (lockFileH, lockMVar)

359− ipCallbackAsync = notifAsync

360 }

344 }

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

371

345

346+ pure (Right conn)

347+

372-- | Create a new session at the transaction id and return the session's Id.

348-- | Create a new session at the transaction id and return the session's Id.

373createSessionAtCommit :: Connection -> TransactionId -> IO (Either RelationalError SessionId)

349createSessionAtCommit :: Connection -> TransactionId -> IO (Either RelationalError SessionId)

374createSessionAtCommit conn@(InProcessConnection _) commitId = do

350createSessionAtCommit conn@(InProcessConnection _) commitId = do

@@ -414,7 +390,6 @@ closeSession sessionId conn@(RemoteConnection _) = remoteCall conn (CloseSession

414-- | 'close' cleans up the database access connection and closes any relevant sockets.

390-- | 'close' cleans up the database access connection and closes any relevant sockets.

415close :: Connection -> IO ()

391close :: Connection -> IO ()

416close (InProcessConnection conf) = do

392close (InProcessConnection conf) = do

417− cancel (ipCallbackAsync conf)

418 atomically $ do

393 atomically $ do

419 let sessions = ipSessions conf

394 let sessions = ipSessions conf

420#if MIN_VERSION_stm_containers(1,0,0)

395#if MIN_VERSION_stm_containers(1,0,0)

@@ -428,7 +403,7 @@ close (InProcessConnection conf) = do

428 Nothing -> pure ()

403 Nothing -> pure ()

429 Just (lockFileH, _) -> closeLockFile lockFileH

404 Just (lockFileH, _) -> closeLockFile lockFileH

430

405

431−close (RemoteConnection (RemoteConnectionConf conn)) =

406+close (RemoteConnection (RemoteConnectionConf conn)) = do

432 RPC.close conn

407 RPC.close conn

433

408

434--used only by the server EntryPoints

409--used only by the server EntryPoints

@@ -446,14 +421,24 @@ excEither = handle handler

446 handler exc | Just (_ :: AsyncException) <- fromException exc = throwIO exc

421 handler exc | Just (_ :: AsyncException) <- fromException exc = throwIO exc

447 | otherwise = pure (Left (UnhandledExceptionError (show exc)))

422 | otherwise = pure (Left (UnhandledExceptionError (show exc)))

448

423

424+{-

425+safeLogin :: Login -> ProcessId -> Process Bool

426+safeLogin login procId = do

427+ ret <- call procId login

428+ case ret of

429+ Left (_ :: ServerError) -> pure False

430+ Right val -> pure val

431+-}

449

432

450remoteCall :: (Serialise a, Serialise b) => Connection -> a -> IO b

433remoteCall :: (Serialise a, Serialise b) => Connection -> a -> IO b

451remoteCall (InProcessConnection _ ) _ = error "remoteCall called on local connection"

434remoteCall (InProcessConnection _ ) _ = error "remoteCall called on local connection"

452remoteCall (RemoteConnection (RemoteConnectionConf rpcConn)) arg = do

435remoteCall (RemoteConnection (RemoteConnectionConf rpcConn)) arg = do

453 eRet <- RPC.call rpcConn arg

436 eRet <- RPC.call rpcConn arg

454 case eRet of

437 case eRet of

455− Left err -> convertRPCErrors err

438+ Left err -> error ("connection died " <> show err) --TODO: throw some more specific exceptions

456 Right val -> pure val

439 Right val -> pure val

440+

441+

457

442

458sessionForSessionId :: SessionId -> Sessions -> STM (Either RelationalError Session)

443sessionForSessionId :: SessionId -> Sessions -> STM (Either RelationalError Session)

459sessionForSessionId sessionId sessions =

444sessionForSessionId sessionId sessions =

@@ -615,6 +600,20 @@ executeDatabaseContextIOExpr sessionId (InProcessConnection conf) expr = excEith

615 pure (Right ())

600 pure (Right ())

616executeDatabaseContextIOExpr sessionId conn@(RemoteConnection _) dbExpr = remoteCall conn (ExecuteDatabaseContextIOExpr sessionId dbExpr)

601executeDatabaseContextIOExpr sessionId conn@(RemoteConnection _) dbExpr = remoteCall conn (ExecuteDatabaseContextIOExpr sessionId dbExpr)

617

602

603+{-

604+executeGraphExprSTM_ :: TransactionId -> SessionId -> Session -> Sessions -> TransactionGraphOperator -> TransactionGraph -> TVar TransactionGraph -> STM (Either RelationalError (TransactionGraph, DisconnectedTransaction)

605+executeGraphExprSTM_ freshId sessionId session sessions graphExpr graph graphTVar= do

606+ case evalGraphOp freshId (Sess.disconnectedTransaction session) graph graphExpr of

607+ Left err -> do

608+ when updateGraphOnError (writeTVar graphTVar graph)

609+ pure $ Left err

610+ Right (discon', graph') -> do

611+ writeTVar graphTVar graph'

612+ let newSession = Session discon' (Sess.schemaName session)

613+ STMMap.insert newSession sessionId sessions

614+ pure $ Right graph'

615+-}

616+

618-- process notifications for commits

617-- process notifications for commits

619executeCommitExprSTM_

618executeCommitExprSTM_

620 :: TransactionGraph

619 :: TransactionGraph

@@ -655,7 +654,77 @@ executeGraphExpr sessionId (InProcessConnection conf) graphExpr = excEither $ do

655 --if freshId appears in the graph, then we need to pass it on

654 --if freshId appears in the graph, then we need to pass it on

656 let transIds = [freshId | isRight (RE.transactionForId freshId graph')]

655 let transIds = [freshId | isRight (RE.transactionForId freshId graph')]

657 pure (Right (discon', graph', transIds))

656 pure (Right (discon', graph', transIds))

658−

657+{-

658+executeGraphExpr sessionId (InProcessConnection conf) graphExpr = excEither $ do

659+ let strat = ipPersistenceStrategy conf

660+ clientNodes = ipClientNodes conf

661+ sessions = ipSessions conf

662+ graphTvar = ipTransactionGraph conf

663+ mLockFileH = ipLocks conf

664+ lockHandler body = case graphExpr of

665+ Commit -> case mLockFileH of

666+ Nothing -> body False

667+ Just (lockFileH, lockMVar) -> let acquireLocks = do

668+ lastWrittenDigest <- takeMVar lockMVar

669+ lockFile lockFileH WriteLock

670+ latestDigest <- readGraphTransactionIdDigest strat

671+ pure (latestDigest /= lastWrittenDigest)

672+

673+ releaseLocks _ = do

674+ --still holding the lock- get the latest digest

675+ gDigest <- readGraphTransactionIdDigest strat

676+ unlockFile lockFileH

677+ putMVar lockMVar gDigest

678+ in bracket acquireLocks releaseLocks body

679+ _ -> body False

680+ freshId <- nextRandom

681+ lockHandler $ \dbWrittenByOtherProcess -> do

682+ --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

683+ --read transaction data and compare to existing graph

684+ --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)

685+ manip <- atomically $ do

686+ eSession <- sessionForSessionId sessionId sessions

687+ --handle graph update by other process

688+ oldGraph <- readTVar graphTvar

689+ case eSession of

690+ Left err -> pure (Left err)

691+ Right session -> do

692+ let mScriptSession = ipScriptSession conf

693+ dbdir = case strat of

694+ MinimalPersistence x -> x

695+ CrashSafePersistence x -> x

696+ _ -> error "accessing dbdir on non-persisted connection"

697+ eRefreshedGraph <- if dbWrittenByOtherProcess then

698+ unsafeIOToSTM (transactionGraphLoad dbdir oldGraph mScriptSession)

699+ else

700+ pure (Right oldGraph)

701+ case eRefreshedGraph of

702+ Left err -> pure (Left (DatabaseLoadError err))

703+ Right refreshedGraph -> do

704+ --snip it

705+ eGraph <- executeGraphExprSTM_ dbWrittenByOtherProcess freshId sessionId session sessions graphExpr refreshedGraph graphTvar

706+ --snip it

707+ case eGraph of

708+ Left err -> pure (Left err)

709+ Right newGraph -> do

710+ --handle commit

711+ if isCommit graphExpr then do

712+ case transactionForId (Sess.parentId session) oldGraph of

713+ Left err -> pure $ Left err

714+ Right previousTrans -> do

715+ (evaldNots, nodes) <- executeCommitExprSTM_ (Trans.concreteDatabaseContext previousTrans) (Sess.concreteDatabaseContext session) clientNodes

716+ nodesToNotify <- toList (StmSet.stream nodes)

717+ pure $ Right (evaldNots, nodesToNotify, newGraph)

718+ else

719+ pure $ Right (M.empty, [], newGraph)

720+ case manip of

721+ Left err -> return $ Just err

722+ Right (notsToFire, nodesToNotify, newGraph) -> do

723+ --update filesystem database, if necessary

724+ processTransactionGraphPersistence strat newGraph

725+ sendNotifications nodesToNotify (ipLocalNode conf) notsToFire

726+ pure Nothing

727+-}

659executeGraphExpr sessionId conn@(RemoteConnection _) graphExpr = remoteCall conn (ExecuteGraphExpr sessionId graphExpr)

728executeGraphExpr sessionId conn@(RemoteConnection _) graphExpr = remoteCall conn (ExecuteGraphExpr sessionId graphExpr)

660

729

661-- | A trans-graph expression is a relational query executed against the entirety of a transaction graph.

730-- | A trans-graph expression is a relational query executed against the entirety of a transaction graph.

@@ -664,6 +733,9 @@ executeTransGraphRelationalExpr _ (InProcessConnection conf) tgraphExpr = excEit

664 let graphTvar = ipTransactionGraph conf

733 let graphTvar = ipTransactionGraph conf

665 graph <- readTVar graphTvar

734 graph <- readTVar graphTvar

666 pure $ force $ optimizeAndEvalTransGraphRelationalExpr graph tgraphExpr

735 pure $ force $ optimizeAndEvalTransGraphRelationalExpr graph tgraphExpr

736+{- case runReader (RE.evalRelationalExpr relExpr) (RE.mkRelationalExprState DBC.empty) of

737+ Left err -> pure (Left err)

738+ Right rel -> pure (force (Right rel))-}

667executeTransGraphRelationalExpr sessionId conn@(RemoteConnection _) tgraphExpr = remoteCall conn (ExecuteTransGraphRelationalExpr sessionId tgraphExpr)

739executeTransGraphRelationalExpr sessionId conn@(RemoteConnection _) tgraphExpr = remoteCall conn (ExecuteTransGraphRelationalExpr sessionId tgraphExpr)

668

740

669-- | Schema expressions manipulate the isomorphic schemas for the current 'DatabaseContext'.

741-- | Schema expressions manipulate the isomorphic schemas for the current 'DatabaseContext'.

@@ -696,10 +768,8 @@ commit sessionId conn@(RemoteConnection _) = remoteCall conn (ExecuteGraphExpr s

696

768

697sendNotifications :: [ClientInfo] -> EvaluatedNotifications -> IO ()

769sendNotifications :: [ClientInfo] -> EvaluatedNotifications -> IO ()

698sendNotifications clients notifs =

770sendNotifications clients notifs =

699− unless (M.null notifs) $ forM_ clients sender

771+ unless (M.null notifs) $

700− where

701− sender (RemoteClientInfo sock) = RPC.sendMessage sock (NotificationMessage notifs)

772+ forM_ (map clientSocket clients) $ \sock -> RPC.sendMessage sock (NotificationMessage notifs)

702− sender (InProcessClientInfo tvar) = putMVar tvar notifs

703

773

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.

774-- | 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.

705rollback :: SessionId -> Connection -> IO (Either RelationalError ())

775rollback :: SessionId -> Connection -> IO (Either RelationalError ())

@@ -1001,6 +1071,13 @@ commitLock_ sessionId conf stmBlock = do

1001 processTransactionGraphPersistence strat transactionIdsToPersist newGraph

1071 processTransactionGraphPersistence strat transactionIdsToPersist newGraph

1002 sendNotifications nodesToNotify notsToFire

1072 sendNotifications nodesToNotify notsToFire

1003 pure (Right ())

1073 pure (Right ())

1074+{-

1075+writeDisconAndGraph_ :: TVar TransactionGraph -> SessionId -> Session -> Sessions -> DisconnectedTransaction -> TransactionGraph -> STM ()

1076+writeDisconAndGraph_ graphTvar sessionId session sessions discon graph = do

1077+ writeTVar graphTvar graph

1078+ let newSession = Session discon (Sess.schemaName session)

1079+ StmMap.insert newSession sessionId sessions

1080+-}

1004

1081

1005-- | Runs an IO monad, commits the result when the monad returns no errors, otherwise, rolls back the changes and the error.

1082-- | Runs an IO monad, commits the result when the monad returns no errors, otherwise, rolls back the changes and the error.

1006withTransaction :: SessionId -> Connection -> IO (Either RelationalError a) -> IO (Either RelationalError ()) -> IO (Either RelationalError a)

1083withTransaction :: SessionId -> Connection -> IO (Either RelationalError a) -> IO (Either RelationalError ()) -> IO (Either RelationalError a)

@@ -1067,29 +1144,3 @@ validateMerkleHashes sessionId (InProcessConnection conf) = do

1067 Left merkleErrs -> pure $ Left $ someErrors (map (\(MerkleValidationError tid expected actual) -> MerkleHashValidationError tid expected actual) merkleErrs)

1144 Left merkleErrs -> pure $ Left $ someErrors (map (\(MerkleValidationError tid expected actual) -> MerkleHashValidationError tid expected actual) merkleErrs)

1068 Right () -> pure (Right ())

1145 Right () -> pure (Right ())

1069validateMerkleHashes sessionId conn@RemoteConnection{} = remoteCall conn (ExecuteValidateMerkleHashes sessionId)

1146validateMerkleHashes 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+7−7

@@ -1,8 +1,8 @@

1−{-# LANGUAGE DeriveGeneric, DerivingVia #-}

1+{-# LANGUAGE DeriveGeneric, DeriveAnyClass, 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 hiding (drop)

5+import ProjectM36.Attribute as A

6import ProjectM36.Error

7import qualified ProjectM36.Relation as R

8import ProjectM36.Relation.Show.Term

@@ -81,7 +81,7 @@ compareTupleByOneAttributeName attr tuple1 tuple2 =

81 Right atom2 -> compareAtoms atom1 atom2

82

83atomForAttributeName :: AttributeName -> DataFrameTuple -> Either RelationalError Atom

84−atomForAttributeName attrName (DataFrameTuple tupAttrs tupVec) = case V.findIndex (\attr -> attributeName attr == attrName) (attributesVec tupAttrs) of

84+atomForAttributeName attrName (DataFrameTuple tupAttrs tupVec) = case V.findIndex (\attr -> attributeName attr == attrName) tupAttrs of

85 Nothing -> Left (NoSuchAttributeNamesError (S.singleton attrName))

86 Just index -> case tupVec V.!? index of

87 Nothing -> Left (NoSuchAttributeNamesError (S.singleton attrName))

@@ -134,12 +134,12 @@ data DataFrameExpr = DataFrameExpr {

134dataFrameAsHTML :: DataFrame -> T.Text

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

136dataFrameAsHTML df

137− | length (tuples df) == 1 && A.null (attributes df) = style <>

137+ | length (tuples df) == 1 && L.null (attributes df) = style <>

138 tablestart <>

139 "<tr><th></th></tr>" <>

140 "<tr><td></td></tr>" <>

141 tablefooter <> "</table>"

142− | L.null (tuples df) && A.null (attributes df) = style <>

142+ | L.null (tuples df) && L.null (attributes df) = style <>

143 tablestart <>

144 "<tr><th></th></tr>" <>

145 tablefooter <>

@@ -162,7 +162,7 @@ tuplesAsHTML = foldr folder ""

162 folder tuple acc = acc <> tupleAsHTML tuple

163

164tupleAssocs :: DataFrameTuple -> [(AttributeName, Atom)]

165−tupleAssocs (DataFrameTuple attrs tupVec) = V.toList $ V.map (first attributeName) (V.zip (attributesVec attrs) tupVec)

165+tupleAssocs (DataFrameTuple attrVec tupVec) = V.toList $ V.map (first attributeName) (V.zip attrVec tupVec)

166

167

168tupleAsHTML :: DataFrameTuple -> T.Text

@@ -174,7 +174,7 @@ tupleAsHTML tuple = "<tr>" <> T.concat (L.map tupleFrag (tupleAssocs tuple)) <>

174 atomAsHTML atom = atomToText atom

175

176attributesAsHTML :: Attributes -> [AttributeOrder] -> T.Text

177−attributesAsHTML attrs orders' = "<tr>" <> T.concat (map oneAttrHTML (A.toList attrs)) <> "</tr>"

177+attributesAsHTML attrs orders' = "<tr>" <> T.concat (map oneAttrHTML (V.toList attrs)) <> "</tr>"

178 where

179 oneAttrHTML attr = "<th>" <> prettyAttribute attr <> ordering (attributeName attr) <> "</th>"

180 ordering attrName = " " <> case L.find (\(AttributeOrder nam _) -> nam == attrName) orders' of

src/lib/ProjectM36/DataTypes/Interval.hs−2

@@ -37,7 +37,6 @@ 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

41 TypeVariableType _ -> False

40 TypeVariableType _ -> False

42

41

43supportsOrdering :: AtomType -> Bool

42supportsOrdering :: AtomType -> Bool

@@ -51,7 +50,6 @@ supportsOrdering typ = case typ of

51 ByteStringAtomType -> False

50 ByteStringAtomType -> False

52 BoolAtomType -> False

51 BoolAtomType -> False

53 RelationAtomType _ -> False

52 RelationAtomType _ -> False

54− RelationalExprAtomType -> False

55 ConstructedAtomType _ _ -> False --once we support an interval-style typeclass, we might enable this

53 ConstructedAtomType _ _ -> False --once we support an interval-style typeclass, we might enable this

56 TypeVariableType _ -> False

54 TypeVariableType _ -> False

57

55

src/lib/ProjectM36/DataTypes/Primitive.hs−1

@@ -42,4 +42,3 @@ 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,7 +24,6 @@ isSortableAtomType typ = case typ of

24 DateTimeAtomType -> True

25 ByteStringAtomType -> False

26 BoolAtomType -> True

27− RelationalExprAtomType -> False

28 RelationAtomType _ -> False

27 RelationAtomType _ -> False

29 ConstructedAtomType _ _ -> False

28 ConstructedAtomType _ _ -> False

30 TypeVariableType _ -> False

29 TypeVariableType _ -> False

src/lib/ProjectM36/Error.hs+2−10

@@ -81,7 +81,7 @@ data RelationalError = NoSuchAttributeNamesError (S.Set AttributeName)

81 | RelationValuedAttributesNotSupportedError [AttributeName]

82 | NotificationNameInUseError NotificationName

83 | NotificationNameNotInUseError NotificationName

84− | ImportError ImportError'

84+ | ImportError T.Text -- really? This should be broken out into some other error type- this has nothing to do with relational algebra

85 | ExportError T.Text

86 | UnhandledExceptionError String

87 | MergeTransactionError MergeError

@@ -144,12 +144,4 @@ data SchemaError = RelVarReferencesMissing (S.Set RelVarName) |

144 RelVarInReferencedMoreThanOnce RelVarName |

145 RelVarOutReferencedMoreThanOnce RelVarName

146 deriving (Show, Eq, Generic, Typeable, NFData)

147−

147+

148−

149−data ImportError' = InvalidSHA256Error T.Text

150− | SHA256MismatchError T.Text T.Text

151− | InvalidFileURIError T.Text

152− | ImportFileDecodeError T.Text

153− | ImportFileError T.Text

154− | ImportDownloadError T.Text

155− deriving (Show, Eq, Generic, Typeable, NFData)

src/lib/ProjectM36/InclusionDependency.hs+6−5

@@ -4,16 +4,17 @@ import ProjectM36.Attribute

4import ProjectM36.Error

5import ProjectM36.Relation

6import qualified Data.Map as M

7+import qualified Data.Text as T

7

8

8inclusionDependenciesAsRelation :: InclusionDependencies -> Either RelationalError Relation

9inclusionDependenciesAsRelation :: InclusionDependencies -> Either RelationalError Relation

9inclusionDependenciesAsRelation incDeps =

10inclusionDependenciesAsRelation incDeps =

10 mkRelationFromList attrs (map incDepAsAtoms (M.toList incDeps))

11 mkRelationFromList attrs (map incDepAsAtoms (M.toList incDeps))

11 where

12 where

12 attrs = attributesFromList [Attribute "name" TextAtomType,

13 attrs = attributesFromList [Attribute "name" TextAtomType,

13− Attribute "sub" RelationalExprAtomType,

14+ Attribute "sub" TextAtomType,

14− Attribute "super" RelationalExprAtomType

15+ Attribute "super" TextAtomType

15 ]

16 ]

16 incDepAsAtoms (name, InclusionDependency exprA exprB) = [TextAtom name,

17 incDepAsAtoms (name, InclusionDependency exprA exprB) = [TextAtom name,

17− RelationalExprAtom exprA,

18+ TextAtom (T.pack (show exprA)),

18− RelationalExprAtom exprB]

19+ TextAtom (T.pack (show exprB))]

19−

20+

src/lib/ProjectM36/IsomorphicSchema.hs+1−1

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

1−{-# LANGUAGE DeriveGeneric, LambdaCase, DerivingVia #-}

1+{-# LANGUAGE DeriveGeneric, DeriveAnyClass, LambdaCase, DerivingVia #-}

2module ProjectM36.IsomorphicSchema where

3import ProjectM36.Base

4import ProjectM36.Error

src/lib/ProjectM36/Relation.hs+22−17

@@ -9,6 +9,7 @@ import ProjectM36.Tuple

9import qualified ProjectM36.Attribute as A

10import ProjectM36.TupleSet

11import ProjectM36.Error

12+import ProjectM36.MiscUtils

12--import qualified Control.Parallel.Strategies as P

13--import qualified Control.Parallel.Strategies as P

13import qualified ProjectM36.TypeConstructorDef as TCD

14import qualified ProjectM36.TypeConstructorDef as TCD

14import qualified ProjectM36.DataConstructorDef as DCD

15import qualified ProjectM36.DataConstructorDef as DCD

@@ -16,6 +17,7 @@ import qualified Data.Text as T

16import Data.Either (isRight)

17import Data.Either (isRight)

17import System.Random.Shuffle

18import System.Random.Shuffle

18import Control.Monad.Random

19import Control.Monad.Random

20+import Data.List (sort)

19

21

20attributes :: Relation -> Attributes

22attributes :: Relation -> Attributes

21attributes (Relation attrs _ ) = attrs

23attributes (Relation attrs _ ) = attrs

@@ -33,7 +35,7 @@ atomTypeForName :: AttributeName -> Relation -> Either RelationalError AtomType

33atomTypeForName attrName (Relation attrs _) = A.atomTypeForAttributeName attrName attrs

35atomTypeForName attrName (Relation attrs _) = A.atomTypeForAttributeName attrName attrs

34

36

35mkRelationFromList :: Attributes -> [[Atom]] -> Either RelationalError Relation

37mkRelationFromList :: Attributes -> [[Atom]] -> Either RelationalError Relation

36−mkRelationFromList attrs atomMatrix = do

38+mkRelationFromList attrs atomMatrix =

37 Relation attrs <$> mkTupleSetFromList attrs atomMatrix

39 Relation attrs <$> mkTupleSetFromList attrs atomMatrix

38

40

39emptyRelationWithAttrs :: Attributes -> Relation

41emptyRelationWithAttrs :: Attributes -> Relation

@@ -41,6 +43,11 @@ emptyRelationWithAttrs attrs = Relation attrs emptyTupleSet

41

43

42mkRelation :: Attributes -> RelationTupleSet -> Either RelationalError Relation

44mkRelation :: Attributes -> RelationTupleSet -> Either RelationalError Relation

43mkRelation attrs tupleSet =

45mkRelation 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

44 --check that all tuples have the same keys

51 --check that all tuples have the same keys

45 --check that all tuples have keys (1-N) where N is the attribute count

52 --check that all tuples have keys (1-N) where N is the attribute count

46 case verifyTupleSet attrs tupleSet of

53 case verifyTupleSet attrs tupleSet of

@@ -86,12 +93,13 @@ union (Relation attrs1 tupSet1) (Relation attrs2 tupSet2) =

86 else

93 else

87 Right $ Relation attrs1 newtuples

94 Right $ Relation attrs1 newtuples

88 where

95 where

89− newtuples = tupleSetUnion attrs1 tupSet1 tupSet2

96+ newtuples = RelationTupleSet $ HS.toList . HS.fromList $ asList tupSet1 ++ map (reorderTuple attrs1) (asList tupSet2)

90−

97+

91project :: S.Set AttributeName -> Relation -> Either RelationalError Relation

98project :: S.Set AttributeName -> Relation -> Either RelationalError Relation

92project attrNames rel@(Relation _ tupSet) = do

99project attrNames rel@(Relation _ tupSet) = do

93 newAttrs <- A.projectionAttributesForNames attrNames (attributes rel)

100 newAttrs <- A.projectionAttributesForNames attrNames (attributes rel)

101+ let newAttrNameSet = A.attributeNameSet newAttrs

94− newTupleList <- mapM (tupleProject newAttrs) (asList tupSet)

102+ newTupleList = map (tupleProject newAttrNameSet) (asList tupSet)

95 pure (Relation newAttrs (RelationTupleSet (HS.toList (HS.fromList newTupleList))))

103 pure (Relation newAttrs (RelationTupleSet (HS.toList (HS.fromList newTupleList))))

96

104

97rename :: AttributeName -> AttributeName -> Relation -> Either RelationalError Relation

105rename :: AttributeName -> AttributeName -> Relation -> Either RelationalError Relation

@@ -146,7 +154,7 @@ group groupAttrNames newAttrName rel = do

146 groupProjectionAttributes <- A.projectionAttributesForNames groupAttrNames (attributes rel)

154 groupProjectionAttributes <- A.projectionAttributesForNames groupAttrNames (attributes rel)

147 let groupAttr = Attribute newAttrName (RelationAtomType groupProjectionAttributes)

155 let groupAttr = Attribute newAttrName (RelationAtomType groupProjectionAttributes)

148 matchingRelTuple tupIn = case imageRelationFor tupIn rel of

156 matchingRelTuple tupIn = case imageRelationFor tupIn rel of

149− Right rel2 -> RelationTuple (A.singleton groupAttr) (V.singleton (RelationAtom rel2))

157+ Right rel2 -> RelationTuple (V.singleton groupAttr) (V.singleton (RelationAtom rel2))

150 Left _ -> undefined

158 Left _ -> undefined

151 mogrifier tupIn = pure (tupleExtend tupIn (matchingRelTuple tupIn))

159 mogrifier tupIn = pure (tupleExtend tupIn (matchingRelTuple tupIn))

152 newAttrs = A.addAttribute groupAttr nonGroupProjectionAttributes

160 newAttrs = A.addAttribute groupAttr nonGroupProjectionAttributes

@@ -160,8 +168,7 @@ restrictEq :: RelationTuple -> Relation -> Either RelationalError Relation

160restrictEq tuple = restrict rfilter

168restrictEq tuple = restrict rfilter

161 where

169 where

162 rfilter :: RelationTuple -> Either RelationalError Bool

170 rfilter :: RelationTuple -> Either RelationalError Bool

163− rfilter tupleIn = do

164− pure (tupleIntersection tuple tupleIn == tuple)

171+ rfilter tupleIn = pure (tupleIntersection tuple tupleIn == tuple)

165

172

166-- unwrap relation-valued attribute

173-- unwrap relation-valued attribute

167-- return error if relval attrs and nongroup attrs overlap

174-- return error if relval attrs and nongroup attrs overlap

@@ -183,13 +190,13 @@ ungroup relvalAttrName rel = case attributesForRelval relvalAttrName rel of

183tupleUngroup :: AttributeName -> Attributes -> RelationTuple -> Either RelationalError Relation

190tupleUngroup :: AttributeName -> Attributes -> RelationTuple -> Either RelationalError Relation

184tupleUngroup relvalAttrName newAttrs tuple = do

191tupleUngroup relvalAttrName newAttrs tuple = do

185 relvalRelation <- relationForAttributeName relvalAttrName tuple

192 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])

192 relFold folder (Right $ Relation newAttrs emptyTupleSet) relvalRelation

193 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])

193

200

194attributesForRelval :: AttributeName -> Relation -> Either RelationalError Attributes

201attributesForRelval :: AttributeName -> Relation -> Either RelationalError Attributes

195attributesForRelval relvalAttrName (Relation attrs _) = do

202attributesForRelval relvalAttrName (Relation attrs _) = do

@@ -244,8 +251,7 @@ relMap mapper (Relation attrs tupleSet) =

244

251

245relMogrify :: (RelationTuple -> Either RelationalError RelationTuple) -> Attributes -> Relation -> Either RelationalError Relation

252relMogrify :: (RelationTuple -> Either RelationalError RelationTuple) -> Attributes -> Relation -> Either RelationalError Relation

246relMogrify mapper newAttributes (Relation _ tupSet) = do

253relMogrify mapper newAttributes (Relation _ tupSet) = do

247− newTuples <- mapM (fmap (reorderTuple newAttributes) . mapper) (asList tupSet)

254+ newTuples <- mapM mapper (asList tupSet)

248−

249 mkRelationFromTuples newAttributes newTuples

255 mkRelationFromTuples newAttributes newTuples

250

256

251relFold :: (RelationTuple -> a -> a) -> a -> Relation -> a

257relFold :: (RelationTuple -> a -> a) -> a -> Relation -> a

@@ -291,8 +297,7 @@ typesAsRelation types = mkRelationFromTuples attrs tuples

291 dConsType = RelationAtomType subAttrs

297 dConsType = RelationAtomType subAttrs

292 tuples = map mkTypeConsDescription types

298 tuples = map mkTypeConsDescription types

293

299

294− mkTypeConsDescription (tCons, dConsList) =

295− RelationTuple attrs (V.fromList [TextAtom (TCD.name tCons), mkDataConsRelation dConsList])

300+ mkTypeConsDescription (tCons, dConsList) = RelationTuple attrs (V.fromList [TextAtom (TCD.name tCons), mkDataConsRelation dConsList])

296

301

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

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

298 Left err -> error ("mkRelationFromTuples pooped " ++ show err)

303 Left err -> error ("mkRelationFromTuples pooped " ++ show err)

src/lib/ProjectM36/Relation/Parse/CSV.hs+3−7

@@ -38,7 +38,8 @@ 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− attrNameSet = A.attributeNameSet attrs

41+ attrNames = V.map A.attributeName attrs

42+ attrNameSet = S.fromList (V.toList attrNames)

42 headerSet = S.fromList (V.toList strHeader)

43 headerSet = S.fromList (V.toList strHeader)

43 parseAtom attrName aType textIn = case APT.parseOnly (parseCSVAtomP attrName tConsMap aType <* APT.endOfInput) textIn of

44 parseAtom attrName aType textIn = case APT.parseOnly (parseCSVAtomP attrName tConsMap aType <* APT.endOfInput) textIn of

44 Left err -> Left (ParseError (T.pack err))

45 Left err -> Left (ParseError (T.pack err))

@@ -46,7 +47,7 @@ csvAsRelation attrs tConsMap inString = case APBL.parse (csvWithHeader csvDecode

46 makeTupleList :: HM.HashMap AttributeName String -> [Either CsvImportError Atom]

47 makeTupleList :: HM.HashMap AttributeName String -> [Either CsvImportError Atom]

47 makeTupleList tupMap = V.toList $ V.map (\attr ->

48 makeTupleList tupMap = V.toList $ V.map (\attr ->

48 either (Left . AttributeMappingError) Right $

49 either (Left . AttributeMappingError) Right $

49− parseAtom (A.attributeName attr) (A.atomType attr) (T.pack $ tupMap HM.! A.attributeName attr)) (attributesVec attrs)

50+ parseAtom (A.attributeName attr) (A.atomType attr) (T.pack $ tupMap HM.! A.attributeName attr)) attrs

50 if attrNameSet == headerSet then do

51 if attrNameSet == headerSet then do

51 tupleList <- mapM sequence $ V.toList (V.map makeTupleList strMapRecords)

52 tupleList <- mapM sequence $ V.toList (V.map makeTupleList strMapRecords)

52 case mkRelationFromList attrs tupleList of

53 case mkRelationFromList attrs tupleList of

@@ -82,11 +83,6 @@ parseCSVAtomP _ _ BoolAtomType = do

82 case readMaybe bString of

83 case readMaybe bString of

83 Nothing -> fail ("invalid BoolAtom string: " ++ bString)

84 Nothing -> fail ("invalid BoolAtom string: " ++ bString)

84 Just b -> pure (Right (BoolAtom b))

85 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))

90parseCSVAtomP attrName tConsMap typ@(ConstructedAtomType _ tvmap)

86parseCSVAtomP attrName tConsMap typ@(ConstructedAtomType _ tvmap)

91 | isIntervalAtomType typ = do

87 | isIntervalAtomType typ = do

92 begin <- (APT.char '[' >> pure False) <|> (APT.char '(' >> pure True)

88 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 as A

4+import ProjectM36.Attribute

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− | A.null attrs =

20+ | V.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) (attributesVec attrs)

25+ relValAttrs = V.toList $ V.filter (isRelationAtomType . atomType) attrs

26− bsAttrNames = V.map (TE.encodeUtf8 . attributeName) (attributesVec attrs)

26+ bsAttrNames = V.map (TE.encodeUtf8 . attributeName) 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) (attributesVec (tupleAttributes tuple))

39+ headerOrder (RecordRelationTuple tuple) = V.map (TE.encodeUtf8 . attributeName) (tupleAttributes tuple)

40

41newtype RecordAtom = RecordAtom {unAtom :: Atom}

42

src/lib/ProjectM36/Relation/Show/HTML.hs+2−2

@@ -3,7 +3,6 @@ import ProjectM36.Base

3import ProjectM36.Relation

4import ProjectM36.Tuple

5import ProjectM36.Atom

6−import ProjectM36.Attribute as A

7import ProjectM36.AtomType

6import ProjectM36.AtomType

8import qualified Data.List as L

7import qualified Data.List as L

9import Data.Text (Text, pack)

8import Data.Text (Text, pack)

@@ -12,9 +11,10 @@ import qualified Data.Text.IO as TIO

12#if __GLASGOW_HASKELL__ < 804

11#if __GLASGOW_HASKELL__ < 804

13import Data.Monoid

12import Data.Monoid

14#endif

13#endif

14+import qualified Data.Vector as V

15

16attributesAsHTML :: Attributes -> Text

17−attributesAsHTML attrs = "<tr>" <> T.concat (map oneAttrHTML (A.toList attrs)) <> "</tr>"

17+attributesAsHTML attrs = "<tr>" <> T.concat (map oneAttrHTML (V.toList attrs)) <> "</tr>"

18 where

19 oneAttrHTML attr = "<th>" <> prettyAttribute attr <> "</th>"

20

src/lib/ProjectM36/RelationalExpression.hs+302−148

@@ -1,7 +1,6 @@

1{-# LANGUAGE ScopedTypeVariables #-}

2{-# LANGUAGE FlexibleInstances #-}

3{-# LANGUAGE FlexibleContexts #-}

4−{-# LANGUAGE OverloadedStrings #-}

5module ProjectM36.RelationalExpression where

4module ProjectM36.RelationalExpression where

6import ProjectM36.Relation

5import ProjectM36.Relation

7import ProjectM36.Tuple

6import ProjectM36.Tuple

@@ -41,8 +40,6 @@ import Control.Monad.Reader as R hiding (join)

41import ProjectM36.NormalizeExpr

40import ProjectM36.NormalizeExpr

42import ProjectM36.WithNameExpr

41import ProjectM36.WithNameExpr

43import Test.QuickCheck

42import Test.QuickCheck

44−import qualified Data.Functor.Foldable as Fold

45−import Control.Applicative

46#ifdef PM36_HASKELL_SCRIPTING

43#ifdef PM36_HASKELL_SCRIPTING

47import GHC hiding (getContext)

44import GHC hiding (getContext)

48import Control.Exception

45import Control.Exception

@@ -110,11 +107,11 @@ askEnv :: GraphRefRelationalExprM GraphRefRelationalExprEnv

110askEnv = R.ask

107askEnv = R.ask

111

108

112mergeTuplesIntoGraphRefRelationalExprEnv :: RelationTuple -> GraphRefRelationalExprEnv -> GraphRefRelationalExprEnv

109mergeTuplesIntoGraphRefRelationalExprEnv :: RelationTuple -> GraphRefRelationalExprEnv -> GraphRefRelationalExprEnv

113−mergeTuplesIntoGraphRefRelationalExprEnv tupIn env =

110+mergeTuplesIntoGraphRefRelationalExprEnv tupIn e =

114− env { gre_extra = new_elems }

111+ e{ gre_extra = new_elems }

115 where

112 where

116 new_elems = Just (Left newTuple)

113 new_elems = Just (Left newTuple)

117− mergedTupMap = M.union (tupleToMap tupIn) (tupleToMap (envTuple env))

114+ mergedTupMap = M.union (tupleToMap tupIn) (tupleToMap (envTuple e))

118 newTuple = mkRelationTupleFromMap mergedTupMap

115 newTuple = mkRelationTupleFromMap mergedTupMap

119

116

120mergeAttributesIntoGraphRefRelationalExprEnv :: Attributes -> GraphRefRelationalExprEnv -> GraphRefRelationalExprEnv

117mergeAttributesIntoGraphRefRelationalExprEnv :: Attributes -> GraphRefRelationalExprEnv -> GraphRefRelationalExprEnv

@@ -212,13 +209,166 @@ envContext = re_context

212setEnvContext :: RelationalExprEnv -> DatabaseContext -> RelationalExprEnv

209setEnvContext :: RelationalExprEnv -> DatabaseContext -> RelationalExprEnv

213setEnvContext e ctx = e { re_context = ctx }

210setEnvContext e ctx = e { re_context = ctx }

214

211

212+{-

213+--full evaluation down the graph

214+eval :: RelationalExpr -> RelationalExprState (Either RelationalError Relation)

215+eval expr = do

216+ env <- askEnv

217+ eGfExpr <- processRelationalExpr expr

218+ case eGfExpr of

219+ Left err -> pure (Left err)

220+ Right gfExpr -> pure $ evalGraphRefRelationalExpr gfExpr (re_graph env)

221+-}

222+{-

223+--relvar state is needed in evaluation of relational expression but only as read-only in order to extract current relvar values

224+evalRelationalExpr :: RelationalExpr -> RelationalExprState (Either RelationalError GraphRefRelationalExpr)

225+evalRelationalExpr (RelationVariable name _) = do

226+ relvarTable <- fmap (relationVariables . envContext) askEnv

227+ return $ case M.lookup name relvarTable of

228+ Just res -> Right res

229+ Nothing -> Left $ RelVarNotDefinedError name

230+

231+evalRelationalExpr (Project attrNames expr) = do

232+ eAttrNameSet <- evalAttributeNames attrNames expr

233+ case eAttrNameSet of

234+ Left err -> pure (Left err)

235+ Right attrNameSet -> do

236+ rel <- evalRelationalExpr expr

237+ case rel of

238+ Right rel2 -> pure $ Right (Project (AttributeNames attrNameSet) rel2)

239+ Left err -> pure $ Left err

240+

241+evalRelationalExpr (Union 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 (Union relA2 relB2)

249+

250+evalRelationalExpr (Join 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 (Join relA2 relB2)

258+

259+evalRelationalExpr (Difference exprA exprB) = do

260+ relA <- evalRelationalExpr exprA

261+ relB <- evalRelationalExpr exprB

262+ case relA of

263+ Left err -> return $ Left err

264+ Right relA2 -> case relB of

265+ Left err -> return $ Left err

266+ Right relB2 -> return $ Right (Difference relA2 relB2)

267+

268+evalRelationalExpr (MakeStaticRelation attributeSet tupleSet) =

269+ case mkRelation attributeSet tupleSet of

270+ Right rel -> return $ Right (ExistingRelation rel)

271+ Left err -> return $ Left err

272+

273+evalRelationalExpr (MakeRelationFromExprs mAttrExprs tupleExprs) = do

274+ currentContext <- fmap envContext askEnv

275+ let tConss = typeConstructorMapping currentContext

276+ -- 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

277+ runExceptT $ do

278+ mAttrs <- case mAttrExprs of

279+ Just _ ->

280+ Just . A.attributesFromList <$> mapM evalGraphRefAttrExpr (fromMaybe [] mAttrExprs)

281+ Nothing -> pure Nothing

282+ tuples <- mapM (liftE . evalTupleExpr mAttrs) tupleExprs

283+ let attrs = fromMaybe firstTupleAttrs mAttrs

284+ firstTupleAttrs = if null tuples then A.emptyAttributes else tupleAttributes (head tuples)

285+ expr <- either throwE pure (mkRelation attrs (RelationTupleSet tuples))

286+ pure (ExistingRelation expr)

287+

288+evalRelationalExpr (ExistingRelation rel) = pure (Right (ExistingRelation rel))

289+

290+evalRelationalExpr (Rename oldAttrName newAttrName relExpr) = do

291+ evald <- evalRelationalExpr relExpr

292+ case evald of

293+ Right expr -> return $ Right (Rename oldAttrName newAttrName expr)

294+ Left err -> return $ Left err

295+

296+evalRelationalExpr (Group oldAttrNames newAttrName relExpr) = do

297+ eOldAttrNameSet <- evalAttributeNames oldAttrNames relExpr

298+ case eOldAttrNameSet of

299+ Left err -> pure (Left err)

300+ Right oldAttrNameSet -> do

301+ evald <- evalRelationalExpr relExpr

302+ case evald of

303+ Right expr -> return $ Right (Group (AttributeNames oldAttrNameSet) newAttrName expr)

304+ Left err -> return $ Left err

305+

306+evalRelationalExpr (Ungroup attrName relExpr) = do

307+ evald <- evalRelationalExpr relExpr

308+ case evald of

309+ Right expr -> return $ Right (Ungroup attrName expr)

310+ Left err -> return $ Left err

311+

312+evalRelationalExpr (Restrict predicateExpr relExpr) = do

313+ evald <- evalRelationalExpr relExpr

314+ pred <- processRestrictionPredicateExpr predicateExpr

315+ case evald of

316+ Left err -> return $ Left err

317+ Right expr ->

318+ pure $ Right (Restrict pred expr)

319+

320+evalRelationalExpr (Equals relExprA relExprB) = do

321+ evaldA <- evalRelationalExpr relExprA

322+ evaldB <- evalRelationalExpr relExprB

323+ case evaldA of

324+ Left err -> return $ Left err

325+ Right exprA -> case evaldB of

326+ Left err -> return $ Left err

327+ Right exprB -> return $ Right (Equals exprA exprB)

328+{-

329+evalRelationalExpr (With views mainExpr) = do

330+ rstate <- ask

331+

332+ let addScopedView ctx (vname,vexpr) = if vname `M.member` relationVariables ctx then

333+ Left (RelVarAlreadyDefinedError vname)

334+ else

335+ case runState (evalDatabaseContextExpr (Assign vname vexpr)) (freshDatabaseState ctx) of

336+ (Left err,_) -> Left err

337+ (Right (), (ctx',_,_)) -> Right ctx'

338+

339+ case foldM addScopedView (stateElemsContext rstate) views of

340+ Left err -> return $ Left err

341+ Right ctx'' -> do

342+ let evalMainExpr expr = runReader (evalRelationalExpr expr) (RelationalExprEnv ctx'')

343+ case evalMainExpr mainExpr of

344+ Left err -> return $ Left err

345+ Right rel -> return $ Right rel

346+-}

347+--warning: copy-pasta from above- refactor

348+evalRelationalExpr (NotEquals relExprA relExprB) = do

349+ evaldA <- evalRelationalExpr relExprA

350+ evaldB <- evalRelationalExpr relExprB

351+ case evaldA of

352+ Left err -> return $ Left err

353+ Right exprA -> case evaldB of

354+ Left err -> return $ Left err

355+ Right exprB -> return $ Right (NotEquals exprA exprB)

356+

357+-- extending a relation adds a single attribute with the results of the per-tuple expression evaluated

358+evalRelationalExpr (Extend tupleExpression relExpr) = do

359+ eExpr <- evalRelationalExpr relExpr

360+ case eExpr of

361+ Left err -> pure (Left err)

362+ Right expr -> do

363+ tupProc <- processExtendTupleExpr tupleExpression

364+ pure (Right (Extend tupProc expr))

365+-}

215--helper function to process relation variable creation/assignment

366--helper function to process relation variable creation/assignment

216setRelVar :: RelVarName -> GraphRefRelationalExpr -> DatabaseContextEvalMonad ()

367setRelVar :: RelVarName -> GraphRefRelationalExpr -> DatabaseContextEvalMonad ()

217setRelVar relVarName relExpr = do

368setRelVar relVarName relExpr = do

218 currentContext <- getStateContext

369 currentContext <- getStateContext

219− --prevent recursive relvar definition by resolving references to relvars in previous states

370+ --prevent recursive relvar definition

220− relExpr' <- resolve relExpr

221− let newRelVars = M.insert relVarName relExpr' $ relationVariables currentContext

371+ let newRelVars = M.insert relVarName relExpr $ relationVariables currentContext

222 potentialContext = currentContext { relationVariables = newRelVars }

372 potentialContext = currentContext { relationVariables = newRelVars }

223 --optimization: if the relexpr is unchanged, skip the update

373 --optimization: if the relexpr is unchanged, skip the update

224 if M.lookup relVarName (relationVariables currentContext) == Just relExpr then

374 if M.lookup relVarName (relationVariables currentContext) == Just relExpr then

@@ -231,9 +381,6 @@ setRelVar relVarName relExpr = do

231 Left err -> dbErr err

381 Left err -> dbErr err

232 Right _ -> putStateContext potentialContext

382 Right _ -> putStateContext potentialContext

233

383

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 ()

236−

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

384-- 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

238deleteRelVar :: RelVarName -> DatabaseContextEvalMonad ()

385deleteRelVar :: RelVarName -> DatabaseContextEvalMonad ()

239deleteRelVar relVarName = do

386deleteRelVar relVarName = do

@@ -299,36 +446,20 @@ evalGraphRefDatabaseContextExpr (Assign relVarName expr) = do

299

446

300evalGraphRefDatabaseContextExpr (Insert relVarName relExpr) = do

447evalGraphRefDatabaseContextExpr (Insert relVarName relExpr) = do

301 gfExpr <- relVarByName relVarName

448 gfExpr <- relVarByName relVarName

302− let optExpr = applyUnionCollapse (Union

303− relExpr

304− gfExpr)

305− evalGraphRefDatabaseContextExpr (Assign relVarName optExpr)

449+ evalGraphRefDatabaseContextExpr (Assign relVarName

450+ (Union

451+ gfExpr

452+ relExpr))

306

453

307evalGraphRefDatabaseContextExpr (Delete relVarName predicate) = do

454evalGraphRefDatabaseContextExpr (Delete relVarName predicate) = do

308 gfExpr <- relVarByName relVarName

455 gfExpr <- relVarByName relVarName

309− let optExpr = applyRestrictionCollapse (Restrict (NotPredicate predicate) gfExpr)

456+ setRelVar relVarName (Restrict (NotPredicate predicate) gfExpr)

310− setRelVar relVarName optExpr

311

457

312--union of restricted+updated portion and the unrestricted+unupdated portion

458--union of restricted+updated portion and the unrestricted+unupdated portion

313evalGraphRefDatabaseContextExpr (Update relVarName atomExprMap pred') = do

459evalGraphRefDatabaseContextExpr (Update relVarName atomExprMap pred') = do

314 rvExpr <- relVarByName relVarName

460 rvExpr <- relVarByName relVarName

315− graph <- re_graph <$> dbcRelationalExprEnv

316− context <- getStateContext

317− let reEnv = freshGraphRefRelationalExprEnv (Just context) graph

318− --get the current attributes name in the relvar to ensure that we don't conflict when renaming

319− eExprType = runGraphRefRelationalExprM reEnv (typeForGraphRefRelationalExpr rvExpr)

320− exprType' <- case eExprType of

321− Left err -> throwError err

322− Right t -> pure t

323 let unrestrictedPortion = Restrict (NotPredicate pred') rvExpr

461 let unrestrictedPortion = Restrict (NotPredicate pred') rvExpr

324− tmpAttr = tmpAttrC 1

462+ 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

332 updateAttr nam atomExpr = Extend (AttributeExtendTupleExpr (tmpAttr nam) atomExpr)

463 updateAttr nam atomExpr = Extend (AttributeExtendTupleExpr (tmpAttr nam) atomExpr)

333 projectAndRename attr expr = Rename (tmpAttr attr) attr (Project (InvertedAttributeNames (S.singleton attr)) expr)

464 projectAndRename attr expr = Rename (tmpAttr attr) attr (Project (InvertedAttributeNames (S.singleton attr)) expr)

334 restrictedPortion = Restrict pred' rvExpr

465 restrictedPortion = Restrict pred' rvExpr

@@ -642,9 +773,21 @@ evalGraphRefDatabaseContextIOExpr (CreateArbitraryRelation relVarName attrExprs

642 Left err -> pure (Left err)

773 Left err -> pure (Left err)

643 Right dbstate' -> putDBCIOContext (dbc_context dbstate')

774 Right dbstate' -> putDBCIOContext (dbc_context dbstate')

644

775

776+{-

777+updateTupleWithAtomExprs :: M.Map AttributeName AtomExpr -> DatabaseContext -> TransactionGraph -> RelationTuple -> Either RelationalError RelationTuple

778+updateTupleWithAtomExprs exprMap context graph tupIn = do

779+ --resolve all atom exprs

780+ let

781+ atomsAssoc <- mapM (\(attrName, atomExpr) -> do

782+ let atom = unimplemented

783+ --atom <- runReader (evalAtomExpr tupIn atomExpr) (mkRelationalExprState context graph)

784+ pure (attrName, atom)

785+ ) (M.toList exprMap)

786+ pure (updateTupleWithAtoms (M.fromList atomsAssoc) tupIn)

787+-}

645--run verification on all constraints

788--run verification on all constraints

646checkConstraints :: DatabaseContext -> TransactionId -> TransactionGraph -> Either RelationalError ()

789checkConstraints :: DatabaseContext -> TransactionId -> TransactionGraph -> Either RelationalError ()

647−checkConstraints context transId graph@(TransactionGraph graphHeads transSet) = do

790+checkConstraints context transId graph@(TransactionGraph graphHeads transSet) =

648 mapM_ (uncurry checkIncDep) (M.toList deps)

791 mapM_ (uncurry checkIncDep) (M.toList deps)

649 where

792 where

650 potentialGraph = TransactionGraph graphHeads (S.insert tempTrans transSet)

793 potentialGraph = TransactionGraph graphHeads (S.insert tempTrans transSet)

@@ -693,6 +836,15 @@ typeForRelationalExpr expr = do

693 runGf = runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr gfExpr)

836 runGf = runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr gfExpr)

694 lift $ except runGf

837 lift $ except runGf

695

838

839+--returns a database context with all tuples removed

840+--this is useful for type checking and optimization

841+{-

842+contextWithEmptyTupleSets :: DatabaseContext -> DatabaseContext

843+contextWithEmptyTupleSets contextIn = contextIn { relationVariables = relVars }

844+ where

845+ relVars = M.map (\rel -> ExistingRelation (Relation (attributes rel) emptyTupleSet)) (relationVariables contextIn)

846+-}

847+

696liftE :: (Monad m) => m (Either a b) -> ExceptT a m b

848liftE :: (Monad m) => m (Either a b) -> ExceptT a m b

697liftE v = do

849liftE v = do

698 y <- lift v

850 y <- lift v

@@ -848,6 +1000,58 @@ evalGraphRefAtomExpr tupIn cons@(ConstructedAtomExpr dConsName dConsArgs _) = do

848 mapM (evalGraphRefAtomExpr tupIn) dConsArgs

1000 mapM (evalGraphRefAtomExpr tupIn) dConsArgs

849 pure (ConstructedAtom dConsName aType argAtoms)

1001 pure (ConstructedAtom dConsName aType argAtoms)

850

1002

1003+{-

1004+evalAtomExpr :: RelationTuple -> AtomExpr -> RelationalExprM Atom

1005+evalAtomExpr tupIn expr =

1006+ -}

1007+{-

1008+

1009+evalAtomExpr tupIn (AttributeAtomExpr attrName) = case atomForAttributeName attrName tupIn of

1010+ Right atom -> pure (Right atom)

1011+ err@(Left (NoSuchAttributeNamesError _)) -> do

1012+ rstate <- ask

1013+ let stateTup = stateTuple rstate

1014+ pure (atomForAttributeName attrName stateTup)

1015+ Left err -> pure (Left err)

1016+evalAtomExpr _ (NakedAtomExpr atom) = pure (Right atom)

1017+evalAtomExpr tupIn (FunctionAtomExpr funcName arguments ()) = do

1018+ argTypes <- mapM (typeFromAtomExpr (tupleAttributes tupIn)) arguments

1019+ context <- fmap stateElemsContext ask

1020+ runExceptT $ do

1021+ let functions = atomFunctions context

1022+ func <- either throwE pure (atomFunctionForName funcName functions)

1023+ let expectedArgCount = length (atomFuncType func) - 1

1024+ actualArgCount = length argTypes

1025+ safeInit [] = [] -- different behavior from normal init

1026+ safeInit xs = init xs

1027+ if expectedArgCount /= actualArgCount then

1028+ throwE (FunctionArgumentCountMismatchError expectedArgCount actualArgCount)

1029+ else do

1030+ let zippedArgs = zip (safeInit (atomFuncType func)) argTypes

1031+ mapM_ (\(expType, eActType) -> do

1032+ actType <- either throwE pure eActType

1033+ either throwE pure (atomTypeVerify expType actType)) zippedArgs

1034+ evaldArgs <- mapM (liftE . evalAtomExpr tupIn) arguments

1035+ case evalAtomFunction func evaldArgs of

1036+ Left err -> throwE (AtomFunctionUserError err)

1037+ Right result -> do

1038+ --validate that the result matches the expected type

1039+ _ <- either throwE pure (atomTypeVerify (last (atomFuncType func)) (atomTypeForAtom result))

1040+ pure result

1041+evalAtomExpr tupIn (RelationAtomExpr relExpr) = do

1042+ --merge existing state tuple context into new state tuple context to support an arbitrary number of levels, but new attributes trounce old attributes

1043+ rstate <- ask

1044+ runExceptT $ do

1045+ let newState = mergeTuplesIntoRelationalExprState tupIn rstate

1046+ relAtom <- either throwE pure (runReader (evalRelationalExpr relExpr) newState)

1047+ pure (RelationAtom relAtom)

1048+evalAtomExpr tupIn cons@(ConstructedAtomExpr dConsName dConsArgs ()) = runExceptT $ do

1049+ rstate <- lift ask

1050+ let newState = mergeTuplesIntoRelationalExprState tupIn rstate

1051+ aType <- either throwE pure (runReader (typeFromAtomExpr (tupleAttributes tupIn) cons) newState)

1052+ argAtoms <- mapM (\arg -> either throwE pure (runReader (evalAtomExpr tupIn arg) newState)) dConsArgs

1053+ pure (ConstructedAtom dConsName aType argAtoms)

1054+-}

851typeForGraphRefAtomExpr :: Attributes -> GraphRefAtomExpr -> GraphRefRelationalExprM AtomType

1055typeForGraphRefAtomExpr :: Attributes -> GraphRefAtomExpr -> GraphRefRelationalExprM AtomType

852typeForGraphRefAtomExpr attrs (AttributeAtomExpr attrName) = do

1056typeForGraphRefAtomExpr attrs (AttributeAtomExpr attrName) = do

853 renv <- askEnv

1057 renv <- askEnv

@@ -914,7 +1118,7 @@ verifyGraphRefAtomExprTypes relIn (FunctionAtomExpr funcName funcArgExprs tid) e

914 let handler :: RelationalError -> GraphRefRelationalExprM AtomType

1118 let handler :: RelationalError -> GraphRefRelationalExprM AtomType

915 handler (AtomTypeMismatchError expSubType actSubType) = throwError (AtomFunctionTypeError funcName argCount expSubType actSubType)

1119 handler (AtomTypeMismatchError expSubType actSubType) = throwError (AtomFunctionTypeError funcName argCount expSubType actSubType)

916 handler err = throwError err

1120 handler err = throwError err

917− verifyGraphRefAtomExprTypes relIn atomExpr expectedType2 `catchError` handler

1121+ verifyGraphRefAtomExprTypes relIn atomExpr expectedType2 `catchError` handler

918 funcArgTypes <- mapM funcArgVerifier $ zip3 funcArgExprs expectedArgTypes [1..]

1122 funcArgTypes <- mapM funcArgVerifier $ zip3 funcArgExprs expectedArgTypes [1..]

919 if length funcArgTypes /= length expectedArgTypes - 1 then

1123 if length funcArgTypes /= length expectedArgTypes - 1 then

920 throwError (AtomTypeCountError funcArgTypes expectedArgTypes)

1124 throwError (AtomTypeCountError funcArgTypes expectedArgTypes)

@@ -960,7 +1164,7 @@ evalGraphRefTupleExprs mAttrs (TupleExprs fixedMarker tupleExprL) = do

960 lift $ except $ resolveAttributes accAttr tupAttr

1164 lift $ except $ resolveAttributes accAttr tupAttr

961 mostResolvedTypes <-

1165 mostResolvedTypes <-

962 foldM (\acc tup -> do

1166 foldM (\acc tup -> do

963− let zipped = zip (V.toList . attributesVec $ tupleAttributes tup) acc

1167+ let zipped = zip (V.toList $ tupleAttributes tup) acc

964 accNames = S.fromList $ map A.attributeName acc

1168 accNames = S.fromList $ map A.attributeName acc

965 tupNames = A.attributeNameSet (tupleAttributes tup)

1169 tupNames = A.attributeNameSet (tupleAttributes tup)

966 attrNamesDiff = S.union (S.difference accNames tupNames) (S.difference tupNames accNames)

1170 attrNamesDiff = S.union (S.difference accNames tupNames) (S.difference tupNames accNames)

@@ -971,7 +1175,7 @@ evalGraphRefTupleExprs mAttrs (TupleExprs fixedMarker tupleExprL) = do

971 pure nextTupleAttrs

1175 pure nextTupleAttrs

972 else

1176 else

973 throwError (TupleAttributeTypeMismatchError diff)

1177 throwError (TupleAttributeTypeMismatchError diff)

974− ) (V.toList . attributesVec $ tupleAttributes headTuple) tailTuples

1178+ ) (V.toList $ tupleAttributes headTuple) tailTuples

975 pure (A.attributesFromList mostResolvedTypes)

1179 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

1180 --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

1181 tConsMap <- case singularTransactions tupleExprL of

@@ -1017,6 +1221,56 @@ evalGraphRefTupleExpr mAttrs (TupleExpr tupMap) = do

1017-- _ <- lift $ except (validateTuple tup' tConss)

1221-- _ <- lift $ except (validateTuple tup' tConss)

1018 pure tup'

1222 pure tup'

1019

1223

1224+{-

1225+evalAttributeNames :: AttributeNames -> RelationalExpr -> RelationalExprM (Either RelationalError (S.Set AttributeName))

1226+evalAttributeNames attrNames expr = do

1227+ eExprType <- typeForRelationalExpr expr

1228+ case eExprType of

1229+ Left err -> throwError err

1230+ Right exprTyp -> do

1231+ let typeNameSet = S.fromList (V.toList (A.attributeNames (attributes exprTyp)))

1232+ case attrNames of

1233+ AttributeNames names ->

1234+ case A.projectionAttributesForNames names (attributes exprTyp) of

1235+ Left err -> pure (Left err)

1236+ Right attrs -> pure (Right (S.fromList (V.toList (A.attributeNames attrs))))

1237+

1238+ InvertedAttributeNames names -> do

1239+ let nonExistentAttributeNames = A.attributeNamesNotContained names typeNameSet

1240+ if not (S.null nonExistentAttributeNames) then

1241+ pure (Left (AttributeNamesMismatchError nonExistentAttributeNames))

1242+ else

1243+ pure (Right (A.nonMatchingAttributeNameSet names typeNameSet))

1244+

1245+ UnionAttributeNames namesA namesB -> do

1246+ eNameSetA <- evalAttributeNames namesA expr

1247+ case eNameSetA of

1248+ Left err -> pure (Left err)

1249+ Right nameSetA -> do

1250+ eNameSetB <- evalAttributeNames namesB expr

1251+ case eNameSetB of

1252+ Left err -> pure (Left err)

1253+ Right nameSetB ->

1254+ pure (Right (S.union nameSetA nameSetB))

1255+

1256+ IntersectAttributeNames namesA namesB -> do

1257+ eNameSetA <- evalAttributeNames namesA expr

1258+ case eNameSetA of

1259+ Left err -> pure (Left err)

1260+ Right nameSetA -> do

1261+ eNameSetB <- evalAttributeNames namesB expr

1262+ case eNameSetB of

1263+ Left err -> pure (Left err)

1264+ Right nameSetB ->

1265+ pure (Right (S.intersection nameSetA nameSetB))

1266+

1267+ RelationalExprAttributeNames attrExpr -> do

1268+ eAttrExprType <- typeForRelationalExpr attrExpr

1269+ case eAttrExprType of

1270+ Left err -> pure (Left err)

1271+ Right attrExprType -> pure (Right (A.attributeNameSet (attributes attrExprType)))

1272+-}

1273+

1020--temporary implementation until we have a proper planner+executor

1274--temporary implementation until we have a proper planner+executor

1021evalGraphRefRelationalExpr :: GraphRefRelationalExpr -> GraphRefRelationalExprM Relation

1275evalGraphRefRelationalExpr :: GraphRefRelationalExpr -> GraphRefRelationalExprM Relation

1022evalGraphRefRelationalExpr (MakeRelationFromExprs mAttrExprs tupleExprs) = do

1276evalGraphRefRelationalExpr (MakeRelationFromExprs mAttrExprs tupleExprs) = do

@@ -1245,7 +1499,7 @@ relationVariablesAsRelation ctx graph = do

1245 let gfEnv = freshGraphRefRelationalExprEnv (Just ctx) graph

1499 let gfEnv = freshGraphRefRelationalExprEnv (Just ctx) graph

1246 gfType <- runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr gfExpr)

1500 gfType <- runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr gfExpr)

1247 pure (rvName, gfType)

1501 pure (rvName, gfType)

1248− relVarToAtomList (rvName, rel) = [TextAtom rvName, attributesToRel (attributesVec (attributes rel))]

1502+ relVarToAtomList (rvName, rel) = [TextAtom rvName, attributesToRel (attributes rel)]

1249 attrAtoms a = [TextAtom (A.attributeName a), TextAtom (prettyAtomType (A.atomType a))]

1503 attrAtoms a = [TextAtom (A.attributeName a), TextAtom (prettyAtomType (A.atomType a))]

1250 attributesToRel attrl = case mkRelationFromList subrelAttrs (map attrAtoms (V.toList attrl)) of

1504 attributesToRel attrl = case mkRelationFromList subrelAttrs (map attrAtoms (V.toList attrl)) of

1251 Left err -> error ("relationVariablesAsRelation pooped " ++ show err)

1505 Left err -> error ("relationVariablesAsRelation pooped " ++ show err)

@@ -1265,6 +1519,15 @@ evalRelationalExpr expr = do

1265 Left err -> throwError err

1519 Left err -> throwError err

1266 Right rel -> pure rel

1520 Right rel -> pure rel

1267

1521

1522+{-

1523+relVarByName :: RelVarName -> GraphRefRelationalExprM GraphRefRelationalExpr

1524+relVarByName = do

1525+ relvars <- relationVariables <$> getStateContext

1526+ case M.lookup relVarName relvars of

1527+ Nothing -> dbErr (RelVarNotDefinedError relVarName)

1528+ Just gfexpr -> pure gfExpr

1529+-}

1530+

1268class (MonadError RelationalError m, Monad m) => DatabaseContextM m where

1531class (MonadError RelationalError m, Monad m) => DatabaseContextM m where

1269 getContext :: m DatabaseContext

1532 getContext :: m DatabaseContext

1270

1533

@@ -1281,112 +1544,3 @@ relVarByName rvName = do

1281 Nothing -> throwError (RelVarNotDefinedError rvName)

1544 Nothing -> throwError (RelVarNotDefinedError rvName)

1282 Just gfexpr -> pure gfexpr

1545 Just gfexpr -> pure gfexpr

1283

1546

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+2

@@ -128,6 +128,8 @@ initScriptSession ghcPkgPaths = do

128 "uuid",

129 "vector",

130 "text",

131+ "binary",

132+ "vector-binary-instances",

131 "time",

133 "time",

132 "project-m36",

134 "project-m36",

133 "bytestring"]

135 "bytestring"]

src/lib/ProjectM36/Serialise/Base.hs+2−11

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

1−{-# LANGUAGE StandaloneDeriving, DerivingVia, TypeApplications, TypeSynonymInstances, ScopedTypeVariables #-}

1+{-# LANGUAGE StandaloneDeriving, DerivingVia, TypeApplications, TypeSynonymInstances, ScopedTypeVariables, GeneralizedNewtypeDeriving #-}

2{-# OPTIONS_GHC -fno-warn-orphans #-}

3--Serialise instances for ProjectM36.Base data types- orphan instance city

4module ProjectM36.Serialise.Base where

@@ -10,7 +10,6 @@ import ProjectM36.MerkleHash

10import Data.UUID

11import Data.Proxy

12import Data.Word

13−import ProjectM36.Attribute as A

14import qualified Data.List.NonEmpty as NE

13import qualified Data.List.NonEmpty as NE

15import qualified Data.Vector as V

14import qualified Data.Vector as V

16import Data.Time.Calendar (Day,toGregorian,fromGregorian)

15import Data.Time.Calendar (Day,toGregorian,fromGregorian)

@@ -73,13 +72,5 @@ instance Serialise Day where

73 extractor = fromGregorianTup <$> extractor

72 extractor = fromGregorianTup <$> extractor

74 decodeCurrent = fromGregorianTup <$> decodeCurrent

73 decodeCurrent = fromGregorianTup <$> decodeCurrent

75

74

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

75

82− decodeCurrent = do

76+

83− n <- decodeVarInt

84− l <- replicateM n decodeCurrent

85− pure (A.attributesFromList l)

src/lib/ProjectM36/Serialise/Error.hs−1

@@ -12,4 +12,3 @@ deriving via WineryVariant MergeError instance Serialise MergeError

12deriving via WineryVariant ScriptCompilationError instance Serialise ScriptCompilationError

13deriving via WineryVariant PersistenceError instance Serialise PersistenceError

14deriving via WineryVariant SchemaError instance Serialise SchemaError

15−deriving via WineryVariant ImportError' instance Serialise ImportError'

src/lib/ProjectM36/Serialise/IsomorphicSchema.hs+1−1

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

1−{-# LANGUAGE StandaloneDeriving, DerivingVia, TypeSynonymInstances, ScopedTypeVariables #-}

1+{-# LANGUAGE StandaloneDeriving, DerivingVia, TypeApplications, TypeSynonymInstances, ScopedTypeVariables, GeneralizedNewtypeDeriving #-}

2{-# OPTIONS_GHC -fno-warn-orphans #-}

3module ProjectM36.Serialise.IsomorphicSchema where

4import Codec.Winery

src/lib/ProjectM36/Server.hs+2−2

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

1−{-# LANGUAGE ScopedTypeVariables #-}

1+{-# LANGUAGE ScopedTypeVariables, TypeApplications #-}

2module ProjectM36.Server where

3

4import ProjectM36.Client

@@ -24,7 +24,7 @@ requestHandlers testFlag ti =

24 RequestHandler (\sState (Login dbName) -> do

25 addClientLogin dbName sState

26 conn <- getConn sState

27− handleLogin conn (connectionSocket sState)),

27+ handleLogin dbName conn (connectionSocket sState)),

28 RequestHandler (\sState Logout -> do

29 conn <- getConn sState

30 handleLogout ti conn),

src/lib/ProjectM36/Server/Config.hs−6

@@ -12,12 +12,6 @@ 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−

21defaultServerConfig :: ServerConfig

15defaultServerConfig :: ServerConfig

22defaultServerConfig = ServerConfig { persistenceStrategy = NoPersistence,

16defaultServerConfig = ServerConfig { persistenceStrategy = NoPersistence,

23 checkFS = True,

17 checkFS = True,

src/lib/ProjectM36/Server/EntryPoints.hs+24−26

@@ -5,16 +5,18 @@ import ProjectM36.IsomorphicSchema

5import ProjectM36.Client as C

6import Data.Map

7import Control.Concurrent (threadDelay)

8−import Network.RPC.Curryer.Server

8+import Network.RPC.Curryer.Server

9−import System.Timeout hiding (Timeout)

9+import System.Timeout

10import Network.Socket

11import Control.Exception

12

13timeoutOrDie :: Maybe Timeout -> IO a -> IO (Maybe a)

14timeoutOrDie mMicros act =

15 case mMicros of

16− Nothing -> Just <$> act

16+ Nothing -> do

17+ ret <- act

18+ pure (Just ret)

17− Just micros ->

19+ Just micros -> do

18 timeout (fromIntegral micros) act

20 timeout (fromIntegral micros) act

19

21

20timeoutRelErr :: Maybe Timeout -> IO (Either RelationalError a) -> IO (Either RelationalError a)

22timeoutRelErr :: Maybe Timeout -> IO (Either RelationalError a) -> IO (Either RelationalError a)

@@ -45,13 +47,13 @@ handleExecuteHeadName :: Maybe Timeout -> SessionId -> Connection -> IO (Either

45handleExecuteHeadName ti sessionId conn =

47handleExecuteHeadName ti sessionId conn =

46 timeoutRelErr ti (headName sessionId conn)

48 timeoutRelErr ti (headName sessionId conn)

47

49

48−handleLogin :: Connection -> Locking Socket -> IO Bool

50+handleLogin :: DatabaseName -> Connection -> Locking Socket -> IO Bool

49−handleLogin conn lockSock = do

51+handleLogin dbName conn lockSock = do

50− addClientNode conn lockSock

52+ addClientNode dbName conn lockSock

51 pure True

53 pure True

52

54

53handleExecuteGraphExpr :: Maybe Timeout -> SessionId -> Connection -> TransactionGraphOperator -> IO (Either RelationalError ())

55handleExecuteGraphExpr :: Maybe Timeout -> SessionId -> Connection -> TransactionGraphOperator -> IO (Either RelationalError ())

54−handleExecuteGraphExpr ti sessionId conn graphExpr =

56+handleExecuteGraphExpr ti sessionId conn graphExpr = do

55 timeoutRelErr ti (executeGraphExpr sessionId conn graphExpr)

57 timeoutRelErr ti (executeGraphExpr sessionId conn graphExpr)

56

58

57handleExecuteTransGraphRelationalExpr :: Maybe Timeout -> SessionId -> Connection -> TransGraphRelationalExpr -> IO (Either RelationalError Relation)

59handleExecuteTransGraphRelationalExpr :: Maybe Timeout -> SessionId -> Connection -> TransGraphRelationalExpr -> IO (Either RelationalError Relation)

@@ -63,11 +65,11 @@ handleExecuteTypeForRelationalExpr ti sessionId conn relExpr =

63 timeoutRelErr ti (typeForRelationalExpr sessionId conn relExpr)

65 timeoutRelErr ti (typeForRelationalExpr sessionId conn relExpr)

64

66

65handleRetrieveInclusionDependencies :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError (Map IncDepName InclusionDependency))

67handleRetrieveInclusionDependencies :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError (Map IncDepName InclusionDependency))

66−handleRetrieveInclusionDependencies ti sessionId conn =

68+handleRetrieveInclusionDependencies ti sessionId conn = do

67 timeoutRelErr ti (inclusionDependencies sessionId conn)

69 timeoutRelErr ti (inclusionDependencies sessionId conn)

68

70

69handleRetrievePlanForDatabaseContextExpr :: Maybe Timeout -> SessionId -> Connection -> DatabaseContextExpr -> IO (Either RelationalError GraphRefDatabaseContextExpr)

71handleRetrievePlanForDatabaseContextExpr :: Maybe Timeout -> SessionId -> Connection -> DatabaseContextExpr -> IO (Either RelationalError GraphRefDatabaseContextExpr)

70−handleRetrievePlanForDatabaseContextExpr ti sessionId conn dbExpr =

72+handleRetrievePlanForDatabaseContextExpr ti sessionId conn dbExpr = do

71 timeoutRelErr ti (planForDatabaseContextExpr sessionId conn dbExpr)

73 timeoutRelErr ti (planForDatabaseContextExpr sessionId conn dbExpr)

72

74

73handleRetrieveTransactionGraph :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Relation)

75handleRetrieveTransactionGraph :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Relation)

@@ -87,16 +89,16 @@ handleCreateSessionAtHead ti conn headn =

87 timeoutRelErr ti (createSessionAtHead conn headn)

89 timeoutRelErr ti (createSessionAtHead conn headn)

88

90

89handleCloseSession :: SessionId -> Connection -> IO ()

91handleCloseSession :: SessionId -> Connection -> IO ()

90−handleCloseSession =

92+handleCloseSession sessionId conn =

91− closeSession

93+ closeSession sessionId conn

92

94

93handleRetrieveAtomTypesAsRelation :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Relation)

95handleRetrieveAtomTypesAsRelation :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Relation)

94−handleRetrieveAtomTypesAsRelation ti sessionId conn =

96+handleRetrieveAtomTypesAsRelation ti sessionId conn = do

95 timeoutRelErr ti (atomTypesAsRelation sessionId conn)

97 timeoutRelErr ti (atomTypesAsRelation sessionId conn)

96

98

97-- | Returns a relation which lists the names of relvars in the current session as well as its types.

99-- | Returns a relation which lists the names of relvars in the current session as well as its types.

98handleRetrieveRelationVariableSummary :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Relation)

100handleRetrieveRelationVariableSummary :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Relation)

99−handleRetrieveRelationVariableSummary ti sessionId conn =

101+handleRetrieveRelationVariableSummary ti sessionId conn = do

100 timeoutRelErr ti (relationVariablesAsRelation sessionId conn)

102 timeoutRelErr ti (relationVariablesAsRelation sessionId conn)

101

103

102handleRetrieveAtomFunctionSummary :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Relation)

104handleRetrieveAtomFunctionSummary :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Relation)

@@ -108,11 +110,11 @@ handleRetrieveDatabaseContextFunctionSummary ti sessionId conn =

108 timeoutRelErr ti (databaseContextFunctionsAsRelation sessionId conn)

110 timeoutRelErr ti (databaseContextFunctionsAsRelation sessionId conn)

109

111

110handleRetrieveCurrentSchemaName :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError SchemaName)

112handleRetrieveCurrentSchemaName :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError SchemaName)

111−handleRetrieveCurrentSchemaName ti sessionId conn =

113+handleRetrieveCurrentSchemaName ti sessionId conn = do

112 timeoutRelErr ti (currentSchemaName sessionId conn)

114 timeoutRelErr ti (currentSchemaName sessionId conn)

113

115

114handleExecuteSchemaExpr :: Maybe Timeout -> SessionId -> Connection -> SchemaExpr -> IO (Either RelationalError ())

116handleExecuteSchemaExpr :: Maybe Timeout -> SessionId -> Connection -> SchemaExpr -> IO (Either RelationalError ())

115−handleExecuteSchemaExpr ti sessionId conn schemaExpr =

117+handleExecuteSchemaExpr ti sessionId conn schemaExpr = do

116 timeoutRelErr ti (executeSchemaExpr sessionId conn schemaExpr)

118 timeoutRelErr ti (executeSchemaExpr sessionId conn schemaExpr)

117

119

118handleLogout :: Maybe Timeout -> Connection -> IO Bool

120handleLogout :: Maybe Timeout -> Connection -> IO Bool

@@ -122,25 +124,21 @@ handleLogout _ _ =

122

124

123handleTestTimeout :: Maybe Timeout -> SessionId -> Connection -> IO Bool

125handleTestTimeout :: Maybe Timeout -> SessionId -> Connection -> IO Bool

124handleTestTimeout ti _ _ = do

126handleTestTimeout ti _ _ = do

125− ret <- timeoutRelErr ti (threadDelay 100000 >> pure (Right ()))

127+ _ <- timeoutOrDie ti (threadDelay 100000 >> pure True)

126− case ret of

127− Right () -> pure True

128+ pure True

128− Left _ -> pure False

129−

130−

131

129

132handleRetrieveSessionIsDirty :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Bool)

130handleRetrieveSessionIsDirty :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Bool)

133−handleRetrieveSessionIsDirty ti sessionId conn =

131+handleRetrieveSessionIsDirty ti sessionId conn = do

134 timeoutRelErr ti (disconnectedTransactionIsDirty sessionId conn)

132 timeoutRelErr ti (disconnectedTransactionIsDirty sessionId conn)

135

133

136handleExecuteAutoMergeToHead :: Maybe Timeout -> SessionId -> Connection -> MergeStrategy -> HeadName -> IO (Either RelationalError ())

134handleExecuteAutoMergeToHead :: Maybe Timeout -> SessionId -> Connection -> MergeStrategy -> HeadName -> IO (Either RelationalError ())

137−handleExecuteAutoMergeToHead ti sessionId conn strat headName' =

135+handleExecuteAutoMergeToHead ti sessionId conn strat headName' = do

138 timeoutRelErr ti (autoMergeToHead sessionId conn strat headName')

136 timeoutRelErr ti (autoMergeToHead sessionId conn strat headName')

139

137

140handleRetrieveTypeConstructorMapping :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError TypeConstructorMapping)

138handleRetrieveTypeConstructorMapping :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError TypeConstructorMapping)

141−handleRetrieveTypeConstructorMapping ti sessionId conn =

139+handleRetrieveTypeConstructorMapping ti sessionId conn = do

142 timeoutRelErr ti (C.typeConstructorMapping sessionId conn)

140 timeoutRelErr ti (C.typeConstructorMapping sessionId conn)

143

141

144handleValidateMerkleHashes :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError ())

142handleValidateMerkleHashes :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError ())

145−handleValidateMerkleHashes ti sessionId conn =

143+handleValidateMerkleHashes ti sessionId conn = do

146 timeoutRelErr ti (C.validateMerkleHashes sessionId conn)

144 timeoutRelErr ti (C.validateMerkleHashes sessionId conn)

src/lib/ProjectM36/Server/ParseArgs.hs+14−31

@@ -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,60 +34,43 @@ 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+

53parsePort :: 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")

91

74

92helpOption :: Parser (a -> a)

75helpOption :: Parser (a -> a)

93helpOption = abortOption helpText $ mconcat

76helpOption = abortOption helpText $ mconcat

@@ -97,6 +80,6 @@ helpOption = abortOption helpText $ mconcat

97 where

80 where

98#if MIN_VERSION_optparse_applicative(0,16,0)

81#if MIN_VERSION_optparse_applicative(0,16,0)

99 helpText = ShowHelpText Nothing

82 helpText = ShowHelpText Nothing

100−#else

83+#else

101 helpText = ShowHelpText

84 helpText = ShowHelpText

102#endif

85#endif

src/lib/ProjectM36/Server/RemoteCallTypes.hs+2−1

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

1−{-# LANGUAGE DeriveGeneric, DerivingVia, CPP #-}

1+{-# LANGUAGE DeriveAnyClass, DeriveGeneric, DerivingVia, DerivingStrategies, DeriveGeneric, CPP #-}

2module ProjectM36.Server.RemoteCallTypes where

3import ProjectM36.Base

4import ProjectM36.IsomorphicSchema

@@ -8,6 +8,7 @@ import ProjectM36.TransGraphRelationalExpression

8import ProjectM36.Session

9import ProjectM36.Serialise.DataFrame ()

10import ProjectM36.Serialise.IsomorphicSchema ()

11+import ProjectM36.Server.Types

11import GHC.Generics

12import GHC.Generics

12import Codec.Winery

13import Codec.Winery

13

14

src/lib/ProjectM36/Server/Types.hsnew file+38

@@ -0,0 +1,38 @@

1+--types shared across server and client modules

2+module ProjectM36.Server.Types where

3+import StmContainers.Set as StmSet

4+import ProjectM36.Base

5+import Data.Hashable

6+import ProjectM36.Sessions

7+import Control.Concurrent.STM

8+import ProjectM36.ScriptSession

9+import ProjectM36.FileLock

10+import Control.Concurrent.MVar

11+import ProjectM36.TransactionGraph.Persist

12+import Network.RPC.Curryer.Server as RPC

13+import Network.Socket

14+

15+-- | The 'Connection' represents either local or remote access to a database. All operations flow through the connection.

16+type ClientNodes = StmSet.Set ClientInfo

17+

18+type DatabaseName = String

19+

20+-- internal structure specific to in-process connections

21+data InProcessConnectionConf = InProcessConnectionConf {

22+ ipPersistenceStrategy :: PersistenceStrategy,

23+ ipClientNodes :: ClientNodes,

24+ ipSessions :: Sessions,

25+ ipTransactionGraph :: TVar TransactionGraph,

26+ ipScriptSession :: Maybe ScriptSession,

27+ ipLocks :: Maybe (LockFile, MVar LockFileHash) -- nothing when NoPersistence

28+ }

29+

30+-- clients may connect associate one socket with one database

31+data ClientInfo = ClientInfo { clientDatabaseName :: DatabaseName,

32+ clientSocket :: RPC.Locking Socket }

33+

34+instance Eq ClientInfo where

35+ a == b = RPC.lockless (clientSocket a) == RPC.lockless (clientSocket b)

36+

37+instance Hashable ClientInfo where

38+ hashWithSalt salt ci = hashWithSalt salt (show (RPC.lockless (clientSocket ci)))

src/lib/ProjectM36/Shortcuts.hsdeleted−247

@@ -1,247 +0,0 @@

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+3−4

@@ -22,6 +22,8 @@ import qualified Data.Set as S

22

23-- the static optimizer performs optimizations which need not take any specific-relation statistics into account

24

25+--import Debug.Trace

26+

25data GraphRefSOptRelationalExprEnv =

27data GraphRefSOptRelationalExprEnv =

26 GraphRefSOptRelationalExprEnv

28 GraphRefSOptRelationalExprEnv

27 {

29 {

@@ -177,7 +179,7 @@ fullOptimizeGraphRefRelationalExpr expr = do

177optimizeGraphRefRelationalExpr :: GraphRefRelationalExpr -> GraphRefSOptRelationalExprM GraphRefRelationalExpr

179optimizeGraphRefRelationalExpr :: GraphRefRelationalExpr -> GraphRefSOptRelationalExprM GraphRefRelationalExpr

178optimizeGraphRefRelationalExpr e@(MakeStaticRelation _ _) = pure e

180optimizeGraphRefRelationalExpr e@(MakeStaticRelation _ _) = pure e

179

181

180−optimizeGraphRefRelationalExpr e@MakeRelationFromExprs{} = pure e

182+optimizeGraphRefRelationalExpr e@(MakeRelationFromExprs _ _) = pure e

181

183

182optimizeGraphRefRelationalExpr e@(ExistingRelation _) = pure e

184optimizeGraphRefRelationalExpr e@(ExistingRelation _) = pure e

183

185

@@ -207,8 +209,6 @@ optimizeGraphRefRelationalExpr (Union exprA exprB) = do

207 case (optExprA, optExprB) of

209 case (optExprA, optExprB) of

208 (Restrict predA (RelationVariable nameA sA),

210 (Restrict predA (RelationVariable nameA sA),

209 Restrict predB (RelationVariable nameB sB)) | nameA == nameB && sA == sB -> pure (Restrict (AndPredicate predA predB) (RelationVariable nameA sA))

211 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'

212 _ -> if optExprA == optExprB then

213 pure optExprA

214 else

@@ -575,4 +575,3 @@ applyStaticRestrictionPushdown expr = case expr of

575-- no optimizations available

576optimizeDatabaseContextIOExpr :: GraphRefDatabaseContextIOExpr -> GraphRefSOptDatabaseContextExprM GraphRefDatabaseContextIOExpr

577optimizeDatabaseContextIOExpr = pure

578−

src/lib/ProjectM36/TransactionGraph.hs+2−2

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

1−{-# LANGUAGE DeriveGeneric, CPP, FlexibleContexts, DerivingVia #-}

1+{-# LANGUAGE DeriveAnyClass, DeriveGeneric, CPP, FlexibleContexts, DerivingVia #-}

2module ProjectM36.TransactionGraph where

3import ProjectM36.Base

4import ProjectM36.Error

@@ -384,7 +384,7 @@ subGraphOfFirstCommonAncestor origGraph resultHeads currentTrans' goalTrans trav

384 else do

385 currentTransChildren <- childTransactions currentTrans' origGraph

386 let searchChildren = S.difference (S.insert currentTrans' traverseSet) currentTransChildren

387− searchChild start' = pathToTransaction origGraph start' goalTrans (S.insert currentTrans' traverseSet)

387+ searchChild start = pathToTransaction origGraph start goalTrans (S.insert currentTrans' traverseSet)

388 childSearches = map searchChild (S.toList searchChildren)

389 errors = lefts childSearches

390 pathsFound = rights childSearches

src/lib/ProjectM36/Tuple.hs+33−47

@@ -1,7 +1,7 @@

1module ProjectM36.Tuple where

2import ProjectM36.Base

3import ProjectM36.Error

4−import ProjectM36.Attribute as A

4+import ProjectM36.Attribute

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 mempty mempty

18+emptyTuple = RelationTuple V.empty V.empty

19

20tupleSize :: RelationTuple -> Int

21−tupleSize (RelationTuple tupAttrs _) = arity tupAttrs

21+tupleSize (RelationTuple tupAttrs _) = V.length tupAttrs

22

23tupleAttributeNameSet :: RelationTuple -> S.Set AttributeName

24−tupleAttributeNameSet (RelationTuple tupAttrs _) = attributeNameSet tupAttrs

24+tupleAttributeNameSet (RelationTuple tupAttrs _) = S.fromList $ V.toList $ V.map attributeName tupAttrs

25

26tupleAttributes :: RelationTuple -> Attributes

27tupleAttributes (RelationTuple tupAttrs _) = tupAttrs

28

29tupleAssocs :: RelationTuple -> [(AttributeName, Atom)]

30−tupleAssocs (RelationTuple attrs tupVec) = V.toList $ V.map (first attributeName) (V.zip (attributesVec attrs) tupVec)

30+tupleAssocs (RelationTuple attrVec tupVec) = V.toList $ V.map (first attributeName) (V.zip attrVec 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) (attributesVec tupAttrs) of

45+atomForAttributeName attrName (RelationTuple tupAttrs tupVec) = case V.findIndex (\attr -> attributeName attr == attrName) 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 (attributeNames attrs))

62+ mapper attrName = fromMaybe (error "logic failure in vectorIndicesForAttributeNames") (V.elemIndex attrName (V.map attributeName 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 (attributesFromList attrs) (V.map (attrMap M.!) (V.fromList attrNames))

89+mkRelationTupleFromMap attrMap = RelationTuple attrs (V.map (attrMap M.!) attrNames)

90 where

91− attrNames = M.keys attrMap

91+ attrNames = V.fromList (M.keys attrMap)

92− attrs = map (\attrName -> Attribute attrName (atomTypeForAtom (attrMap M.! attrName))) attrNames

92+ attrs = V.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` attributesVec tupAttrs1) (attributesVec tupAttrs2)

123+ attrsIntersection = V.filter (`V.elem` tupAttrs1) tupAttrs2

124− newVec = V.map (findAtomForAttributeName . attributeName) (attributesVec joinedAttrs)

124+ newVec = V.map (findAtomForAttributeName . attributeName) joinedAttrs

125 --search both tuples for the attribute

126 findAtomForAttributeName attrName = head $ rights $ fmap (atomForAttributeName attrName) [tup1, tup2]

127

@@ -138,31 +138,23 @@ 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 <> tupAttrs2

141+ newAttrs = tupAttrs1 V.++ tupAttrs2

142− newVec = tupVec1 <> tupVec2

142+ newVec = tupVec1 V.++ tupVec2

143

144tupleAtomExtend :: AttributeName -> Atom -> RelationTuple -> RelationTuple

145tupleAtomExtend newAttrName atom tupIn = tupleExtend tupIn newTup

146 where

147− newTup = RelationTuple (A.singleton $ Attribute newAttrName (atomTypeForAtom atom)) (V.singleton atom)

147+ newTup = RelationTuple (V.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)]

149−{-tupleProject :: S.Set AttributeName -> RelationTuple -> RelationTuple

150+tupleProject :: S.Set AttributeName -> RelationTuple -> RelationTuple

150tupleProject projectAttrs (RelationTuple attrs tupVec) = RelationTuple newAttrs newTupVec

151tupleProject projectAttrs (RelationTuple attrs tupVec) = RelationTuple newAttrs newTupVec

151 where

152 where

152− deleteIndices = V.findIndices (\attr -> S.notMember (attributeName attr) projectAttrs) (attributesVec attrs)

153+ deleteIndices = V.findIndices (\attr -> S.notMember (attributeName attr) projectAttrs) attrs

153 indexDeleter = V.ifilter (\index _ -> V.notElem index deleteIndices)

154 indexDeleter = V.ifilter (\index _ -> V.notElem index deleteIndices)

154− newAttrs = case A.projectionAttributesForNames projectAttrs attrs of

155+ newAttrs = indexDeleter attrs

155− Left err -> error (show (err, projectAttrs, attrs))

156− Right attrs' -> attrs'

157 newTupVec = indexDeleter tupVec

156 newTupVec = indexDeleter tupVec

158−-}

157+

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)

166--return the attributes and atoms which are equal in both vectors

158--return the attributes and atoms which are equal in both vectors

167--semi-join

159--semi-join

168tupleIntersection :: RelationTuple -> RelationTuple -> RelationTuple

160tupleIntersection :: RelationTuple -> RelationTuple -> RelationTuple

@@ -170,14 +162,12 @@ tupleIntersection tuple1 tuple2 = RelationTuple newAttrs newTupVec

170 where

162 where

171 attrs1 = tupleAttributes tuple1

163 attrs1 = tupleAttributes tuple1

172 attrs2 = tupleAttributes tuple2

164 attrs2 = tupleAttributes tuple2

173− intersectAttrs = A.intersection attrs1 attrs2

174− matchingIndices = V.findIndices (\attr -> A.member attr intersectAttrs &&

165+ matchingIndices = V.findIndices (\attr -> V.elem attr attrs2 &&

175− atomForAttributeName (attributeName attr) tuple1 ==

166+ atomForAttributeName (attributeName attr) tuple1 ==

176− atomForAttributeName (attributeName attr) tuple2) (attributesVec attrs1)

167+ atomForAttributeName (attributeName attr) tuple2

168+ ) attrs1

177 indexFilter = V.ifilter (\index _ -> V.elem index matchingIndices)

169 indexFilter = V.ifilter (\index _ -> V.elem index matchingIndices)

178− newAttrs = case A.projectionAttributesForNames (A.attributeNameSet intersectAttrs) attrs1 of

170+ newAttrs = indexFilter attrs1

179− Left _ -> mempty

180− Right attrs' -> attrs'

181 newTupVec = indexFilter (tupleAtoms tuple1)

171 newTupVec = indexFilter (tupleAtoms tuple1)

182

172

183-- | An optimized form of tuple update which updates vectors efficiently.

173-- | An optimized form of tuple update which updates vectors efficiently.

@@ -185,20 +175,19 @@ updateTupleWithAtoms :: M.Map AttributeName Atom -> RelationTuple -> RelationTup

185updateTupleWithAtoms updateMap (RelationTuple attrs tupVec) = RelationTuple attrs newVec

175updateTupleWithAtoms updateMap (RelationTuple attrs tupVec) = RelationTuple attrs newVec

186 where

176 where

187 updateKeysSet = M.keysSet updateMap

177 updateKeysSet = M.keysSet updateMap

188− updateKeysIVec = V.filter (\(_,attr) -> S.member (attributeName attr) updateKeysSet) (V.indexed (attributesVec attrs))

178+ updateKeysIVec = V.filter (\(_,attr) -> S.member (attributeName attr) updateKeysSet) (V.indexed attrs)

189 newVec = V.update tupVec updateVec

179 newVec = V.update tupVec updateVec

190 updateVec = V.map (\(index, attr) -> (index, updateMap M.! attributeName attr)) updateKeysIVec

180 updateVec = V.map (\(index, attr) -> (index, updateMap M.! attributeName attr)) updateKeysIVec

191

181

192tupleToMap :: RelationTuple -> M.Map AttributeName Atom

182tupleToMap :: RelationTuple -> M.Map AttributeName Atom

193tupleToMap (RelationTuple attrs tupVec) = M.fromList assocList

183tupleToMap (RelationTuple attrs tupVec) = M.fromList assocList

194 where

184 where

195− assocList = V.toList $ V.map (\(index, attr) -> (attributeName attr, tupVec V.! index)) (V.indexed (attributesVec attrs))

185+ assocList = V.toList $ V.map (\(index, attr) -> (attributeName attr, tupVec V.! index)) (V.indexed attrs)

196

186

197−-- | Validate that the tuple has the correct attributes in the correct order

198verifyTuple :: Attributes -> RelationTuple -> Either RelationalError RelationTuple

187verifyTuple :: Attributes -> RelationTuple -> Either RelationalError RelationTuple

199−verifyTuple attrs tuple = let attrsTypes = A.atomTypes attrs

188+verifyTuple attrs tuple = let attrsTypes = V.map atomType attrs

200 tupleTypes = V.map atomTypeForAtom (tupleAtoms tuple) in

189 tupleTypes = V.map atomTypeForAtom (tupleAtoms tuple) in

201− if A.arity attrs /= V.length tupleTypes then

190+ if V.length attrs /= V.length tupleTypes then

202 Left $ TupleAttributeCountMismatchError 0

191 Left $ TupleAttributeCountMismatchError 0

203 else do

192 else do

204 mapM_ (uncurry atomTypeVerify) (V.zip attrsTypes tupleTypes)

193 mapM_ (uncurry atomTypeVerify) (V.zip attrsTypes tupleTypes)

@@ -207,18 +196,15 @@ verifyTuple attrs tuple = let attrsTypes = A.atomTypes attrs

207--two tuples can be equal but the vectors of attributes could be out-of-order

196--two tuples can be equal but the vectors of attributes could be out-of-order

208--reorder if necessary- this is useful during relMogrify so that all the relation's tuples have identical atom/attribute ordering

197--reorder if necessary- this is useful during relMogrify so that all the relation's tuples have identical atom/attribute ordering

209reorderTuple :: Attributes -> RelationTuple -> RelationTuple

198reorderTuple :: Attributes -> RelationTuple -> RelationTuple

210−reorderTuple attrs tupIn = if attributesAndOrderEqual (tupleAttributes tupIn) attrs then

199+reorderTuple attrs tupIn = if tupleAttributes tupIn == attrs then

211 tupIn

200 tupIn

212 else

201 else

213− RelationTuple attrs (V.map mapper (attributesVec attrs))

202+ RelationTuple attrs (V.map mapper attrs)

214 where

203 where

215 mapper attr = case atomForAttributeName (attributeName attr) tupIn of

204 mapper attr = case atomForAttributeName (attributeName attr) tupIn of

216− Left err -> error ("logic bug in reorderTuple: " ++ show err <> show tupIn)

205+ Left err -> error ("logic bug in reorderTuple: " ++ show err)

217 Right atom -> atom

206 Right atom -> atom

218

207

219--used in Generics derivation for ADTs without named attributes

208--used in Generics derivation for ADTs without named attributes

220trimTuple :: Int -> RelationTuple -> RelationTuple

209trimTuple :: Int -> RelationTuple -> RelationTuple

221−trimTuple index (RelationTuple attrs vals) =

210+trimTuple index (RelationTuple attrs vals) = RelationTuple (V.drop index attrs) (V.drop index vals)

222− RelationTuple newAttrs (V.drop index vals)

223− where

224− newAttrs = A.drop index attrs

src/lib/ProjectM36/TupleSet.hs−7

@@ -31,10 +31,3 @@ 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+8−9

@@ -38,7 +38,7 @@ import qualified Data.Text as T

38import qualified Data.Vector as V

39import GHC.Generics

40import ProjectM36.Atomable

41−import ProjectM36.Attribute as A hiding (null, toList)

41+import ProjectM36.Attribute hiding (null)

42import ProjectM36.Base

43import ProjectM36.DataTypes.Primitive

44import ProjectM36.Error

@@ -89,7 +89,7 @@ toInsertExpr vals rvName = do

89

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'.

91toDefineExpr :: forall a proxy. Tupleable a => proxy a -> RelVarName -> DatabaseContextExpr

92−toDefineExpr _ rvName = Define rvName (map NakedAttributeExpr (V.toList (attributesVec attrs)))

92+toDefineExpr _ rvName = Define rvName (map NakedAttributeExpr (V.toList attrs))

93 where

94 attrs = toAttributes (Proxy :: Proxy a)

95

@@ -228,12 +228,11 @@ instance (Constructor c, TupleableG a, AtomableG a) => TupleableG (M1 C c a) whe

228 toTupleG opts (M1 v) = RelationTuple attrs atoms

229 where

230 attrsToCheck = toAttributesG opts v

231− counter = V.generate (arity attrsToCheck) id

231+ counter = V.generate (V.length attrsToCheck) id

232− attrs = attributesFromList (V.toList attrsV)

233− attrsV = V.zipWith (\num attr@(Attribute name typ) -> if T.null name then

232+ attrs = V.zipWith (\num attr@(Attribute name typ) -> if T.null name then

234 Attribute ("attr" <> T.pack (show (num + 1))) typ

233 Attribute ("attr" <> T.pack (show (num + 1))) typ

235 else

234 else

236− attr) counter (attributesVec attrsToCheck)

235+ attr) counter attrsToCheck

237 atoms = V.fromList (toAtomsG v)

236 atoms = V.fromList (toAtomsG v)

238 toAttributesG opts (M1 v) = toAttributesG opts v

237 toAttributesG opts (M1 v) = toAttributesG opts v

239 fromTupleG opts tup = M1 <$> fromTupleG opts tup

238 fromTupleG opts tup = M1 <$> fromTupleG opts tup

@@ -242,7 +241,7 @@ instance (Constructor c, TupleableG a, AtomableG a) => TupleableG (M1 C c a) whe

242-- product types

241-- product types

243instance (TupleableG a, TupleableG b) => TupleableG (a :*: b) where

242instance (TupleableG a, TupleableG b) => TupleableG (a :*: b) where

244 toTupleG = error "toTupleG"

243 toTupleG = error "toTupleG"

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

244+ toAttributesG opts ~(x :*: y) = toAttributesG opts x V.++ toAttributesG opts y --a bit of extra laziness prevents whnf so that we can use toAttributes (undefined :: Test2T Int Int) without throwing an exception

246 fromTupleG opts tup = (:*:) <$> fromTupleG opts tup <*> fromTupleG opts processedTuple

245 fromTupleG opts tup = (:*:) <$> fromTupleG opts tup <*> fromTupleG opts processedTuple

247 where

246 where

248 processedTuple = if isRecordTypeG (undefined :: a x) then

247 processedTuple = if isRecordTypeG (undefined :: a x) then

@@ -254,7 +253,7 @@ instance (TupleableG a, TupleableG b) => TupleableG (a :*: b) where

254--selector/record

253--selector/record

255instance (Selector c, AtomableG a) => TupleableG (M1 S c a) where

254instance (Selector c, AtomableG a) => TupleableG (M1 S c a) where

256 toTupleG = error "toTupleG"

255 toTupleG = error "toTupleG"

257− toAttributesG opts m@(M1 v) = A.singleton (Attribute modifiedName aType)

256+ toAttributesG opts m@(M1 v) = V.singleton (Attribute modifiedName aType)

258 where

257 where

259 name = T.pack (selName m)

258 name = T.pack (selName m)

260 modifiedName = if T.null name then

259 modifiedName = if T.null name then

@@ -269,7 +268,7 @@ instance (Selector c, AtomableG a) => TupleableG (M1 S c a) where

269 val <- atomv atom

268 val <- atomv atom

270 pure (M1 val)

269 pure (M1 val)

271 where

270 where

272− expectedAtomType = atomType (V.head (attributesVec (toAttributesG opts (undefined :: M1 S c a x))))

271+ expectedAtomType = atomType (V.head (toAttributesG opts (undefined :: M1 S c a x)))

273 atomv atom = maybe (Left (AtomTypeMismatchError

272 atomv atom = maybe (Left (AtomTypeMismatchError

274 expectedAtomType

273 expectedAtomType

275 (atomTypeForAtom atom)

274 (atomTypeForAtom atom)

src/lib/ProjectM36/WithNameExpr.hs+2−4

@@ -42,11 +42,9 @@ 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 update nested with exprs

45+ --collect and override existing macros and recurse

46 let newMacros = foldr macroFolder macros moreMacros

47− macroFolder (wnexpr, mexpr) acc =

47+ macroFolder (wnexpr, mexpr) acc = filter (\(w,_) -> w /= wnexpr) acc ++ [(wnexpr, mexpr)] in

48− let subExpr = substituteWithNameMacros macros mexpr in

49− filter (\(w,_) -> w /= wnexpr) acc ++ [(wnexpr, subExpr)] in

50 --scan for a match- if it exists, replace it (representing a with clause at a lower level

48 --scan for a match- if it exists, replace it (representing a with clause at a lower level

51 substituteWithNameMacros newMacros expr

49 substituteWithNameMacros newMacros expr

52

50

stack.ghc8.0.yamlnew file+48

@@ -0,0 +1,48 @@

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+- git: https://github.com/agentm/curryer.git

13+ commit: 1e60c0580ca33d6ae1e97aaddc32189fdfe3ef6c

14+- data-accessor-transformers-0.2.1.7

15+- data-interval-1.2.0

16+- extended-reals-0.2.1.0

17+- gnuplot-0.5.4.1

18+- text-1.2.2.1

19+- aeson-1.2.1.00

20+- deferred-folds-0.6.12

21+- rset-1.0.0

22+

23+# Override default flag values for local packages and extra-deps

24+flags: {}

25+

26+# Extra package databases containing global packages

27+extra-package-dbs: []

28+

29+# Control whether we use the GHC we find on the path

30+# system-ghc: true

31+

32+# Require a specific version of stack, using version ranges

33+# require-stack-version: -any # Default

34+# require-stack-version: >= 1.0.0

35+

36+# Override the architecture used by stack, especially useful on Windows

37+# arch: i386

38+# arch: x86_64

39+

40+# Extra directories used by stack for building

41+# extra-include-dirs: [/path/to/dir]

42+# extra-lib-dirs: [/path/to/dir]

43+

44+# Allow a newer minor version of GHC than the snapshot specifies

45+# compiler-check: newer-minor

46+

47+allow-newer: true

48+

stack.ghc8.10.yamldeleted−19

@@ -1,19 +0,0 @@

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.2.yamlnew file+50

@@ -0,0 +1,50 @@

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-11.20

6+

7+# Local packages, usually specified by relative directory name

8+packages:

9+- '.'

10+

11+# Packages to be pulled from upstream that are not in the resolver (e.g., acme-missiles-0.3)

12+extra-deps:

13+- git: https://github.com/agentm/curryer.git

14+ commit: 1e60c0580ca33d6ae1e97aaddc32189fdfe3ef6c

15+- data-accessor-transformers-0.2.1.7

16+- data-interval-1.2.0

17+- extended-reals-0.2.1.0

18+- gnuplot-0.5.4.1

19+- text-1.2.2.1

20+- aeson-1.2.1.00

21+- rset-1.0.0

22+

23+# Override default flag values for local packages and extra-deps

24+flags:

25+ project-m36:

26+ stack: true

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.4.yamlnew file+46

@@ -0,0 +1,46 @@

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-12.26

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+- git: https://github.com/agentm/curryer.git

13+ commit: 1e60c0580ca33d6ae1e97aaddc32189fdfe3ef6c

14+- data-interval-1.3.0

15+- extended-reals-0.2.3.0

16+- rset-1.0.0

17+- hashable-time-0.2.0.2

18+- network-transport-tcp-0.6.0

19+

20+# Override default flag values for local packages and extra-deps

21+flags:

22+ project-m36:

23+ stack: true

24+

25+# Extra package databases containing global packages

26+extra-package-dbs: []

27+

28+# Control whether we use the GHC we find on the path

29+# system-ghc: true

30+

31+# Require a specific version of stack, using version ranges

32+# require-stack-version: -any # Default

33+# require-stack-version: >= 1.0.0

34+

35+# Override the architecture used by stack, especially useful on Windows

36+# arch: i386

37+# arch: x86_64

38+

39+# Extra directories used by stack for building

40+# extra-include-dirs: [/path/to/dir]

41+# extra-lib-dirs: [/path/to/dir]

42+

43+# Allow a newer minor version of GHC than the snapshot specifies

44+# compiler-check: newer-minor

45+

46+allow-newer: true

stack.ghc8.6.yaml+12−25

@@ -2,36 +2,23 @@

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-14.27

5+resolver: lts-14.3

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− - git: https://github.com/agentm/curryer.git

12+- git: https://github.com/agentm/curryer.git

13− commit: 74ecaac619ad1165a4517d5c0f4e530493bda130

13+ commit: 1e60c0580ca33d6ae1e97aaddc32189fdfe3ef6c

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

20− - extended-reals-0.2.3.0

14+- extended-reals-0.2.3.0

21− - data-interval-2.0.1

15+- data-interval-2.0.1

22− - stm-containers-1.1.0.4

16+- stm-containers-1.1.0.4

23− - stm-hamt-1.2.0.4

17+- stm-hamt-1.2.0.4

24− - rset-1.0.0

18+- rset-1.0.0

25− - hashable-time-0.2.0.2

19+- hashable-time-0.2.0.2

26− - network-transport-tcp-0.6.0

20+- network-transport-tcp-0.6.0

27− - megaparsec-7.0.5

21+- 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

35

22

36# Override default flag values for local packages and extra-deps

23# Override default flag values for local packages and extra-deps

37flags:

24flags:

stack.ghc8.8.yaml+14−24

@@ -6,32 +6,22 @@ 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− - git: https://github.com/agentm/curryer.git

12+- git: https://github.com/agentm/curryer.git

13− commit: 74ecaac619ad1165a4517d5c0f4e530493bda130

13+ commit: 1e60c0580ca33d6ae1e97aaddc32189fdfe3ef6c

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

20− - extended-reals-0.2.3.0

14+- extended-reals-0.2.3.0

21− - data-interval-2.0.1

15+- data-interval-2.0.1

22− - stm-containers-1.1.0.4

16+- stm-containers-1.1.0.4

23− - stm-hamt-1.2.0.4

17+- stm-hamt-1.2.0.4

24− - rset-1.0.0

18+- rset-1.0.0

25− - hashable-time-0.2.0.2

19+- hashable-time-0.2.0.2

26− - network-transport-tcp-0.7.0

20+- network-transport-tcp-0.7.0

27− - megaparsec-7.0.5

21+- megaparsec-7.0.5

28− - network-2.8.0.1

22+- network-2.8.0.1

29− - primitive-extras-0.8

23+- primitive-extras-0.8

30− - primitive-unlifted-0.1.3.0

24+- 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

35

25

36# Override default flag values for local packages and extra-deps

26# Override default flag values for local packages and extra-deps

37flags:

27flags:

test/Client/Simple.hs+2−1

@@ -9,6 +9,7 @@ import System.IO.Temp

9import System.FilePath

10import ProjectM36.TupleSet

11import ProjectM36.Attribute

12+import qualified Data.Vector as V

12import qualified Data.Map as M

13import qualified Data.Map as M

13

14

14main :: IO ()

15main :: IO ()

@@ -58,7 +59,7 @@ testSimpleCommitFailure = TestCase $ do

58 execute $ Assign "x" (ExistingRelation relationTrue)

59 execute $ Assign "x" (ExistingRelation relationTrue)

59 --cause error

60 --cause error

60 execute $ Assign "x" (MakeStaticRelation failAttrs emptyTupleSet)

61 execute $ Assign "x" (MakeStaticRelation failAttrs emptyTupleSet)

61− let expectedErr = Left (RelError (RelationTypeMismatchError mempty failAttrs))

62+ let expectedErr = Left (RelError (RelationTypeMismatchError V.empty failAttrs))

62 assertEqual "dbc error" expectedErr err

63 assertEqual "dbc error" expectedErr err

63

64

64-- #176 default merge couldn't handle Update

65-- #176 default merge couldn't handle Update

test/Relation/Basic.hs+12−13

@@ -3,6 +3,8 @@ import ProjectM36.Base

3import ProjectM36.Relation

4import ProjectM36.Error

5import ProjectM36.DateExamples

6+import ProjectM36.TupleSet

7+import ProjectM36.Attribute hiding (null, attributeNames)

6import ProjectM36.DataTypes.Primitive

8import ProjectM36.DataTypes.Primitive

7import ProjectM36.RelationalExpression

9import ProjectM36.RelationalExpression

8import ProjectM36.TransactionGraph

10import ProjectM36.TransactionGraph

@@ -23,8 +25,8 @@ testList = TestList [testRelation "relationTrue" relationTrue, testRelation "rel

23 testRelation "products" productsRel,

25 testRelation "products" productsRel,

24 testRelation "supplierProducts" supplierProductsRel,

26 testRelation "supplierProducts" supplierProductsRel,

25 testMkRelationFromExprsBadAttrs,

27 testMkRelationFromExprsBadAttrs,

26− testExistingRelationType,

28+ testDuplicateAttributes,

27− testReorderTuple

29+ testExistingRelationType

28 ]

30 ]

29

31

30main :: IO ()

32main :: IO ()

@@ -63,7 +65,7 @@ validateAttrTypesMatchTupleAttrTypes rel@(Relation attrs tupSet) = foldr (\tuple

63 attrChecks tuple = V.map (\attr -> case atomForAttributeName (A.attributeName attr) tuple of

65 attrChecks tuple = V.map (\attr -> case atomForAttributeName (A.attributeName attr) tuple of

64 Left _ -> False

66 Left _ -> False

65 Right atom -> Right (atomTypeForAtom atom) ==

67 Right atom -> Right (atomTypeForAtom atom) ==

66− A.atomTypeForAttributeName (A.attributeName attr) attrs) (attributesVec (attributes rel))

68+ A.atomTypeForAttributeName (A.attributeName attr) attrs) (attributes rel)

67

69

68simpleRel :: Relation

70simpleRel :: Relation

69simpleRel = case mkRelation attrs tupleSet of

71simpleRel = case mkRelation attrs tupleSet of

@@ -101,19 +103,16 @@ testMkRelationFromExprsBadAttrs = TestCase $ do

101 Left err -> assertEqual "tuple type mismatch" (TupleAttributeTypeMismatchError (A.attributesFromList [Attribute "badAttr2" IntAtomType])) err

103 Left err -> assertEqual "tuple type mismatch" (TupleAttributeTypeMismatchError (A.attributesFromList [Attribute "badAttr2" IntAtomType])) err

102 Right _ -> assertFailure "expected tuple type mismatch"

104 Right _ -> assertFailure "expected tuple type mismatch"

103

105

106+--creating an empty relation with duplicate attribute names should fail

107+testDuplicateAttributes :: Test

108+testDuplicateAttributes = TestCase $ do

109+ let eRel = mkRelation attrs emptyTupleSet

110+ attrs = attributesFromList [Attribute "a" IntAtomType, Attribute "a" TextAtomType]

111+ assertEqual "duplicate attribute names" (Left (DuplicateAttributeNamesError (S.singleton "a"))) eRel

112+

104testExistingRelationType :: Test

113testExistingRelationType :: Test

105testExistingRelationType = TestCase $ do

114testExistingRelationType = TestCase $ do

106 (graph, _) <- freshTransactionGraph dateExamples

115 (graph, _) <- freshTransactionGraph dateExamples

107 let typeResult = runRelationalExprM reenv (typeForRelationalExpr (ExistingRelation relationTrue))

116 let typeResult = runRelationalExprM reenv (typeForRelationalExpr (ExistingRelation relationTrue))

108 reenv = mkRelationalExprEnv dateExamples graph

117 reenv = mkRelationalExprEnv dateExamples graph

109 assertEqual "ExistingRelation with tuples type" (Right relationFalse) typeResult

118 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/Tupleable.hs+6−18

@@ -8,13 +8,13 @@

8 , DataKinds

9 , TypeOperators

10 , AllowAmbiguousTypes

11− , DerivingVia

12 #-}

11 #-}

13import Test.HUnit

12import Test.HUnit

14import ProjectM36.Tupleable.Deriving

13import ProjectM36.Tupleable.Deriving

15import ProjectM36.Atomable

14import ProjectM36.Atomable

16−import ProjectM36.Attribute as A

15+import ProjectM36.Attribute

17import ProjectM36.Error

16import ProjectM36.Error

17+import Data.Binary

18import ProjectM36.Base

19import Control.DeepSeq (NFData)

20import qualified Data.Vector as V

@@ -23,7 +23,6 @@ import qualified Data.Text as T

23import qualified Data.Set as S

24import System.Exit

25import Data.Proxy

26−import Codec.Winery

27

26

28{-# ANN module ("Hlint: ignore Use newtype instead of data" :: String) #-}

27{-# ANN module ("Hlint: ignore Use newtype instead of data" :: String) #-}

29

28

@@ -31,43 +30,35 @@ data Test1T = Test1C {

31 attrA :: Integer

30 attrA :: Integer

32 }

31 }

33 deriving (Generic, Eq, Show)

32 deriving (Generic, Eq, Show)

34− deriving Serialise via WineryRecord Test1T

35

33

36data Test2T = Test2C {

34data Test2T = Test2C {

37 attrB :: Integer,

35 attrB :: Integer,

38 attrC :: Integer

36 attrC :: Integer

39 }

37 }

40 deriving (Generic, Eq, Show)

38 deriving (Generic, Eq, Show)

41− deriving Serialise via WineryRecord Test2T

42

39

43data Test3T = Test3C Integer

40data Test3T = Test3C Integer

44 deriving (Generic, Eq, Show)

41 deriving (Generic, Eq, Show)

45− deriving Serialise via WineryVariant Test3T

46

42

47data Test4T = Test4C

43data Test4T = Test4C

48 deriving (Generic, Eq, Show)

44 deriving (Generic, Eq, Show)

49− deriving Serialise via WineryVariant Test4T

50

45

51data Test5T = Test5C1 Integer |

46data Test5T = Test5C1 Integer |

52 Test5C2 Integer

47 Test5C2 Integer

53 deriving (Generic, Eq, Show)

48 deriving (Generic, Eq, Show)

54− deriving Serialise via WineryVariant Test5T

55

49

56data Test6T = Test6C T.Text Integer Double

50data Test6T = Test6C T.Text Integer Double

57 deriving (Generic, Eq, Show)

51 deriving (Generic, Eq, Show)

58

52

59data Test7A = Test7AC Integer

53data Test7A = Test7AC Integer

60− deriving (Generic, Show, Eq, NFData, Atomable)

54+ deriving (Generic, Show, Eq, Binary, NFData, Atomable)

61− deriving Serialise via WineryVariant Test7A

62

55

63

56

64data Test7T = Test7C Test7A

57data Test7T = Test7C Test7A

65 deriving (Generic, Show, Eq)

58 deriving (Generic, Show, Eq)

66− deriving Serialise via WineryVariant Test7T

67

59

68data Test8T = Test8C

60data Test8T = Test8C

69 deriving (Generic, Show, Eq)

61 deriving (Generic, Show, Eq)

70− deriving Serialise via WineryVariant Test8T

71

62

72data Test9T = Test9C

63data Test9T = Test9C

73 {

64 {

@@ -76,7 +67,6 @@ data Test9T = Test9C

76 attr9C :: Double

67 attr9C :: Double

77 }

68 }

78 deriving (Generic, Show, Eq)

69 deriving (Generic, Show, Eq)

79− deriving Serialise via WineryRecord Test9T

80

70

81data Test10T = Test10C {

71data Test10T = Test10C {

82 longAttrNameA10 :: Integer,

72 longAttrNameA10 :: Integer,

@@ -84,7 +74,6 @@ data Test10T = Test10C {

84 longMixed_attr_NameC10 :: Integer

74 longMixed_attr_NameC10 :: Integer

85 }

75 }

86 deriving (Generic, Show, Eq)

76 deriving (Generic, Show, Eq)

87− deriving Serialise via WineryRecord Test10T

88

77

89instance Tupleable Test1T

78instance Tupleable Test1T

90

79

@@ -110,7 +99,7 @@ main = do

110 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

99 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

111

100

112testList :: Test

101testList :: Test

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]

102+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]

114

103

115testADT1 :: Test

104testADT1 :: Test

116testADT1 = TestCase $ assertEqual "one record constructor" (Right example) (fromTuple (toTuple example))

105testADT1 = TestCase $ assertEqual "one record constructor" (Right example) (fromTuple (toTuple example))

@@ -148,7 +137,7 @@ testADT7 :: Test

148testADT7 = TestCase $ do

137testADT7 = TestCase $ do

149 let example = Test7C (Test7AC 3)

138 let example = Test7C (Test7AC 3)

150 assertEqual "atom type" (Right example) (fromTuple (toTuple example))

139 assertEqual "atom type" (Right example) (fromTuple (toTuple example))

151− let expectedAttrs = A.singleton (Attribute "" (ConstructedAtomType "Test7A" M.empty))

140+ let expectedAttrs = V.singleton (Attribute "" (ConstructedAtomType "Test7A" M.empty))

152 assertEqual "adt atomtype" expectedAttrs (toAttributes (Proxy :: Proxy Test7T))

141 assertEqual "adt atomtype" expectedAttrs (toAttributes (Proxy :: Proxy Test7T))

153

142

154testADT8 :: Test

143testADT8 :: Test

@@ -222,8 +211,7 @@ testDeleteExpr = TestCase $ do

222testReorderedTuple :: Test

211testReorderedTuple :: Test

223testReorderedTuple = TestCase $ do

212testReorderedTuple = TestCase $ do

224 let tupleRev :: RelationTuple -> RelationTuple

213 let tupleRev :: RelationTuple -> RelationTuple

225− tupleRev (RelationTuple v1 v2) = RelationTuple (revAttrs v1) (V.reverse v2)

214+ tupleRev (RelationTuple v1 v2) = RelationTuple (V.reverse v1) (V.reverse v2)

226− revAttrs attrs = A.attributesFromList (reverse (A.toList attrs))

227 expected = Test2C {attrB = 3,

215 expected = Test2C {attrB = 3,

228 attrC = 4}

216 attrC = 4}

229 actual = fromTuple . tupleRev . toTuple $ expected

217 actual = fromTuple . tupleRev . toTuple $ expected

test/Server/Main.hs+20−19

@@ -5,6 +5,7 @@ test client/server interaction

5import Test.HUnit

6import ProjectM36.Client

7import qualified ProjectM36.Client as C

8+import ProjectM36.Server.EntryPoints

8import ProjectM36.Server

9import ProjectM36.Server

9import ProjectM36.Server.Config

10import ProjectM36.Server.Config

10import ProjectM36.Relation

11import ProjectM36.Relation

@@ -13,8 +14,16 @@ import ProjectM36.IsomorphicSchema

13import ProjectM36.Base

14import ProjectM36.Base

14

15

15import System.Exit

16import System.Exit

16−import Network.Socket (SockAddr(..))

17+

17import Control.Concurrent

18import 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+

18import Data.Either (isRight)

27import Data.Either (isRight)

19import Control.Exception

28import Control.Exception

20import System.IO.Temp

29import System.IO.Temp

@@ -23,8 +32,6 @@ import System.FilePath

23import System.Directory

32import System.Directory

24#endif

33#endif

25

34

26−type Timeout = Int

27−

28testList :: SessionId -> Connection -> MVar () -> Test

35testList :: SessionId -> Connection -> MVar () -> Test

29testList sessionId conn notificationTestMVar = TestList $ serverTests ++ sessionTests

36testList sessionId conn notificationTestMVar = TestList $ serverTests ++ sessionTests

30 where

37 where

@@ -42,7 +49,7 @@ testList sessionId conn notificationTestMVar = TestList $ serverTests ++ session

42 testRelationVariableSummary,

49 testRelationVariableSummary,

43 testNotification notificationTestMVar

50 testNotification notificationTestMVar

44 ]

51 ]

45− serverTests = [testRequestTimeout, testFileDescriptorCount, testClientConnectFail]

52+ serverTests = [testRequestTimeout, testFileDescriptorCount]

46

53

47main :: IO ()

54main :: IO ()

48main = do

55main = do

@@ -62,9 +69,11 @@ main = do

62testDatabaseName :: DatabaseName

69testDatabaseName :: DatabaseName

63testDatabaseName = "test"

70testDatabaseName = "test"

64

71

65−testConnection :: Port -> MVar () -> IO (Either ConnectionError (SessionId, Connection))

72+testConnection :: EndPointAddress -> MVar () -> IO (Either ConnectionError (SessionId, Connection))

66−testConnection serverPort mvar = do

73+testConnection serverAddress mvar = do

74+ let Just (host, service, _) = decodeEndPointAddress serverAddress

75+ serverAddress' = encodeEndPointAddress host service 1

67− let connInfo = RemoteConnectionInfo testDatabaseName "127.0.0.1" (show serverPort) (testNotificationCallback mvar)

76+ let connInfo = RemoteProcessConnectionInfo testDatabaseName (NodeId serverAddress') (testNotificationCallback mvar)

68 --putStrLn ("testConnection: " ++ show serverAddress)

77 --putStrLn ("testConnection: " ++ show serverAddress)

69 eConn <- connectProjectM36 connInfo

78 eConn <- connectProjectM36 connInfo

70 case eConn of

79 case eConn of

@@ -76,7 +85,7 @@ testConnection serverPort mvar = do

76 Right sessionId -> pure $ Right (sessionId, conn)

85 Right sessionId -> pure $ Right (sessionId, conn)

77

86

78-- | A version of 'launchServer' which returns the port on which the server is listening on a secondary thread

87-- | A version of 'launchServer' which returns the port on which the server is listening on a secondary thread

79−launchTestServer :: Timeout -> IO (Port, ThreadId)

88+launchTestServer :: Timeout -> IO (EndPointAddress, ThreadId)

80launchTestServer ti = do

89launchTestServer ti = do

81 addressMVar <- newEmptyMVar

90 addressMVar <- newEmptyMVar

82 tid <- forkIO $

91 tid <- forkIO $

@@ -90,9 +99,9 @@ launchTestServer ti = do

90 }

99 }

91

100

92 launchServer config (Just addressMVar) >> pure ()

101 launchServer config (Just addressMVar) >> pure ()

93− (SockAddrInet port _) <- takeMVar addressMVar

102+ endPointAddress <- takeMVar addressMVar

94 --liftIO $ putStrLn ("launched server on " ++ show endPointAddress)

103 --liftIO $ putStrLn ("launched server on " ++ show endPointAddress)

95− pure (fromIntegral port, tid)

104+ pure (endPointAddress, tid)

96

105

97testRelationalExpr :: SessionId -> Connection -> Test

106testRelationalExpr :: SessionId -> Connection -> Test

98testRelationalExpr sessionId conn = TestCase $ do

107testRelationalExpr sessionId conn = TestCase $ do

@@ -208,7 +217,7 @@ testRequestTimeout = TestCase $ do

208 Left err -> putStrLn ("failed to connect: " ++ show err) >> exitFailure

217 Left err -> putStrLn ("failed to connect: " ++ show err) >> exitFailure

209 Right (session, testConn) -> do

218 Right (session, testConn) -> do

210 res <- catchJust (\exc -> if exc == RequestTimeoutException then Just exc else Nothing) (callTestTimeout_ session testConn) (const (pure False))

219 res <- catchJust (\exc -> if exc == RequestTimeoutException then Just exc else Nothing) (callTestTimeout_ session testConn) (const (pure False))

211− assertBool "timeout exception was not thrown" (not res)

220+ assertBool "exception was not thrown" (not res)

212 killThread serverTid

221 killThread serverTid

213

222

214testFileDescriptorCount :: Test

223testFileDescriptorCount :: Test

@@ -238,11 +247,3 @@ fdCount = do

238--pass on non-linux platforms

247--pass on non-linux platforms

239testFileDescriptorCount = TestCase (pure ())

248testFileDescriptorCount = TestCase (pure ())

240#endif

249#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+9−3

@@ -18,6 +18,12 @@ 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+

21

27

22--start the websocket server

28--start the websocket server

23-- run some tutoriald against it

29-- run some tutoriald against it

@@ -31,12 +37,12 @@ launchTestServer = do

31 testDatabaseName = "test"

37 testDatabaseName = "test"

32 -- start normal server

38 -- start normal server

33 _ <- forkIO (launchServer config (Just addressMVar) >> pure ())

39 _ <- forkIO (launchServer config (Just addressMVar) >> pure ())

34− (SockAddrInet dbPort _) <- takeMVar addressMVar

40+ serverAddress <- takeMVar addressMVar

35 let wsServerHost = "127.0.0.1"

41 let wsServerHost = "127.0.0.1"

36 wsServerPort = 8889

42 wsServerPort = 8889

37− dbHost = "127.0.0.1"

43+ Just (dbHost, dbPort, _) = decodeEndPointAddress serverAddress

38 -- start websocket server proxy -- runServer doesn't support returning an arbitrary socket

44 -- start websocket server proxy -- runServer doesn't support returning an arbitrary socket

39− _ <- forkIO (WS.runServer wsServerHost wsServerPort (websocketProxyServer (fromIntegral dbPort) dbHost))

45+ _ <- forkIO (WS.runServer wsServerHost wsServerPort (websocketProxyServer (read dbPort) dbHost))

40 --wait for socket to be listening

46 --wait for socket to be listening

41 waitForListenSocket 5 (fromIntegral wsServerPort)

47 waitForListenSocket 5 (fromIntegral wsServerPort)

42 pure (fromIntegral wsServerPort, testDatabaseName)

48 pure (fromIntegral wsServerPort, testDatabaseName)

test/TutorialD/InterpreterTest.hs → test/TutorialD/Interpreter.hsrenamed+7−37

@@ -79,16 +79,13 @@ main = do

79 testInvalidDataConstructor,

80 testBasicList,

81 testRelationDeclarationMismatch,

82− testInvalidTuples,

82+ testInvalidTuples

83− testSelfReferencingUncommittedContext,

84− testUnionAndIntersectionAttributeExprs

85 ]

83 ]

86

84

87simpleRelTests :: Test

85simpleRelTests :: Test

88simpleRelTests = TestCase $ do

86simpleRelTests = TestCase $ do

89 (graph, transId) <- freshTransactionGraph dateExamples

87 (graph, transId) <- freshTransactionGraph dateExamples

90− mapM_ (\(tutd, expected) ->

91− assertTutdEqual basicDatabaseContext transId graph expected tutd) testTups

88+ mapM_ (\(tutd, expected) -> assertTutdEqual basicDatabaseContext transId graph expected tutd) testTups

92 where

89 where

93 testTups = [("x:=true", Right relationTrue),

90 testTups = [("x:=true", Right relationTrue),

94 ("x:=false", Right relationFalse),

91 ("x:=false", Right relationFalse),

@@ -123,8 +120,7 @@ simpleRelTests = TestCase $ do

123 ("x:=relation{tuple{a 5}} : {b:=6}", mkRelationFromTuples simpleDAttributes [RelationTuple simpleDAttributes (V.fromList [IntegerAtom 5, IntegerAtom 6])]),

120 ("x:=relation{tuple{a 5}} : {b:=6}", mkRelationFromTuples simpleDAttributes [RelationTuple simpleDAttributes (V.fromList [IntegerAtom 5, IntegerAtom 6])]),

124 ("x:=relation{tuple{a 5}} : {b:=add(@a,5)}", mkRelationFromTuples simpleDAttributes [RelationTuple simpleDAttributes (V.fromList [IntegerAtom 5, IntegerAtom 10])]),

121 ("x:=relation{tuple{a 5}} : {b:=add(@a,5)}", mkRelationFromTuples simpleDAttributes [RelationTuple simpleDAttributes (V.fromList [IntegerAtom 5, IntegerAtom 10])]),

125 ("x:=relation{tuple{a 5}} : {b:=add(@a,\"spam\")}", Left (AtomFunctionTypeError "add" 2 IntegerAtomType TextAtomType)),

122 ("x:=relation{tuple{a 5}} : {b:=add(@a,\"spam\")}", Left (AtomFunctionTypeError "add" 2 IntegerAtomType TextAtomType)),

126− ("x:=relation{tuple{a 5}} : {b:=add(add(@a,2),5)}", mkRelationFromTuples simpleDAttributes [RelationTuple simpleDAttributes (V.fromList [IntegerAtom 5, IntegerAtom 12])]),

123+ ("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 [])

128 ]

124 ]

129 simpleAAttributes = A.attributesFromList [Attribute "a" IntegerAtomType]

125 simpleAAttributes = A.attributesFromList [Attribute "a" IntegerAtomType]

130 simpleBAttributes = A.attributesFromList [Attribute "d" IntegerAtomType]

126 simpleBAttributes = A.attributesFromList [Attribute "d" IntegerAtomType]

@@ -136,8 +132,7 @@ simpleRelTests = TestCase $ do

136dateExampleRelTests :: Test

132dateExampleRelTests :: Test

137dateExampleRelTests = TestCase $ do

133dateExampleRelTests = TestCase $ do

138 (graph, transId) <- freshTransactionGraph dateExamples

134 (graph, transId) <- freshTransactionGraph dateExamples

139− mapM_ (\(tutd, expected) ->

140− assertTutdEqual dateExamples transId graph expected tutd) testTups

135+ mapM_ (\(tutd, expected) -> assertTutdEqual dateExamples transId graph expected tutd) testTups

141 where

136 where

142 simpleEitherIntTextAttributes = A.attributesFromList [Attribute "a" (eitherAtomType IntegerAtomType TextAtomType)]

137 simpleEitherIntTextAttributes = A.attributesFromList [Attribute "a" (eitherAtomType IntegerAtomType TextAtomType)]

143 maybeIntegerAtomType = ConstructedAtomType "Maybe" (M.singleton "a" IntegerAtomType)

138 maybeIntegerAtomType = ConstructedAtomType "Maybe" (M.singleton "a" IntegerAtomType)

@@ -235,7 +230,7 @@ transactionGraphAddCommitTest = TestCase $ do

235 commit sessionId dbconn >>= eitherFail

230 commit sessionId dbconn >>= eitherFail

236 discon <- disconnectedTransaction_ sessionId dbconn

231 discon <- disconnectedTransaction_ sessionId dbconn

237 let context = Discon.concreteDatabaseContext discon

232 let context = Discon.concreteDatabaseContext discon

238− assertEqual "ensure x was added" (M.lookup "x" (relationVariables context)) (Just (ExistingRelation suppliersRel))

233+ assertEqual "ensure x was added" (M.lookup "x" (relationVariables context)) (Just (RelationVariable "s" UncommittedContextMarker))

239

234

240transactionRollbackTest :: Test

235transactionRollbackTest :: Test

241transactionRollbackTest = TestCase $ do

236transactionRollbackTest = TestCase $ do

@@ -362,7 +357,7 @@ testComments :: Test

362testComments = TestCase $ do

357testComments = TestCase $ do

363 (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback

358 (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback

364 mapM_ (executeTutorialD sessionId dbconn) [

359 mapM_ (executeTutorialD sessionId dbconn) [

365− ":branch testbranch --test comment",

360+ ":branch testbranch --test comment\n",

366 ":jumphead {- test comment -} master"]

361 ":jumphead {- test comment -} master"]

367

362

368-- create a graph and query from two disparate contexts

363-- create a graph and query from two disparate contexts

@@ -545,7 +540,7 @@ testListConstructedAtom = TestCase $ do

545testTypeChecker :: Test

540testTypeChecker :: Test

546testTypeChecker = TestCase $ do

541testTypeChecker = TestCase $ do

547 (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback

542 (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback

548− let err1 = "AtomFunctionTypeError \"max\" 1"

543+ let err1 = "AtomFunctionTypeError \"max\" 1 (RelationAtomType [Attribute \"_\" IntegerAtomType]) IntegerAtomType"

549 expectTutorialDErr sessionId dbconn (T.isPrefixOf err1) "x:=relation{tuple{a 0}}:{b:=max(@a)}"

544 expectTutorialDErr sessionId dbconn (T.isPrefixOf err1) "x:=relation{tuple{a 0}}:{b:=max(@a)}"

550

545

551--exercise expression parser

546--exercise expression parser

@@ -665,10 +660,6 @@ testWithClause = TestCase $ do

665 executeTutorialD sessionId dbconn "x:=with (x as s) x"

660 executeTutorialD sessionId dbconn "x:=with (x as s) x"

666 eX <- executeRelationalExpr sessionId dbconn (RelationVariable "x" ())

661 eX <- executeRelationalExpr sessionId dbconn (RelationVariable "x" ())

667 assertEqual "with x as s" (Right suppliersRel) eX

662 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

672

663

673 let err1 = "RelVarAlreadyDefinedError"

664 let err1 = "RelVarAlreadyDefinedError"

674 expectTutorialDErr sessionId dbconn (T.isPrefixOf err1) "x:=with (s as s) s"

665 expectTutorialDErr sessionId dbconn (T.isPrefixOf err1) "x:=with (s as s) s"

@@ -709,24 +700,3 @@ testInvalidTuples = TestCase $ do

709 expectTutorialDErr sessionId dbconn (T.isPrefixOf "AttributeNamesMismatchError") ":showexpr relation{tuple{a 1},tuple{b 2}}"

700 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}}"

701 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

702-- 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/Interpreter/Import/ImportTest.hsdeleted−47

@@ -1,47 +0,0 @@

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.hsnew file+29

@@ -0,0 +1,29 @@

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+ $ TupleExprs () [TupleExpr (M.fromList [("a", NakedAtomExpr $ IntegerAtom 5),

24+ ("b", NakedAtomExpr $ TextAtom "spam")])]),

25+ Assign "y" (MakeRelationFromExprs Nothing

26+ $ TupleExprs () [TupleExpr (M.fromList [("b", NakedAtomExpr (TextAtom "漢字"))])])]

27+ imported <- importTutorialD tempPath

28+ assertEqual "import tutd" (Right expectedExpr) imported

29+

test/TutorialD/Interpreter/Import/httpimporttest.tutddeleted−2

@@ -1,2 +0,0 @@

1−x:=true;

2−y:=false;

test/TutorialD/PrinterTest.hsdeleted−47

@@ -1,47 +0,0 @@

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+2−5

@@ -4,8 +4,6 @@ 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

9

7

10testList :: IO Test

8testList :: IO Test

11testList = do

9testList = do

@@ -22,8 +20,7 @@ main = do

22

20

23testScript :: FilePath -> Test

21testScript :: FilePath -> Test

24testScript tutdFile = TestCase $ do

22testScript tutdFile = TestCase $ do

25− fileURI <- mkURI (T.pack ("file://" <> tutdFile))

23+ eImport <- importTutorialD tutdFile

26− eImport <- importTutorialDFromFile fileURI Nothing

27 case eImport of

24 case eImport of

28 Left err -> assertFailure ("tutd import failure in " ++ tutdFile ++ ": " ++ show err)

25 Left err -> assertFailure ("tutd import failure in " ++ tutdFile ++ ": " ++ show err)

29− Right _ -> pure ()

26+ Right _ -> pure ()