master..2d088d0 · project-m36

git.iko.soy/project-m36

118 files changed+2097−3480

unifiedsplit

.appveyor.yml+1

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

1717 global:

1818 STACK_ROOT: "c:\\sr"

1919 matrix:

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

2021 - YAML: "stack.ghc8.6.yaml"

2122

2223platform:

.github/workflows/ci.yamldeleted−69

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

1−name: "CI"

2−on:

3− pull_request:

4− push:

5−jobs:

6− dockerimage:

7− runs-on: ubuntu-latest

8− steps:

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

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

11− with:

12− nix_path: nixpkgs=channel:nixos-unstable

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

14− with:

15− name: project-m36

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

17− - run: cachix use iohk

18− - name: docker load

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

20− - name: docker login

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

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

23− - name: docker tag with version

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

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

26− - name: docker tag latest

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

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

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

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

31−

32− stack-build:

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

34− strategy:

35− matrix:

36− os: [ubuntu-latest]

37− ghc:

38− - ghc8.10

39− - ghc8.8

40− - ghc8.6

41− include:

42− - os: macos-latest

43− ghc: ghc8.10

44− env:

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

46− steps:

47− - uses: actions/checkout@v2

48− - name: Cache

49− uses: actions/cache@v1

50− with:

51− path: ~/.stack

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

53− restore-keys: |

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

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

56− - name: Fix macOS cache bug

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

58− - name: Build

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

60− - name: Test

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

62− - name: HLint

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

64− - name: Haddock

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

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

67− with:

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

69− path: out/

.gitignore+1−3

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

1818jupyter/itutd.egg-info

1919jupyter/build

2020juyter/dist

21−.ipynb_checkpoints

22−project-m36.nix

23−stack.yaml

21+.ipynb_checkpoints

.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

5+git:

6+ submodules: false # whether to recursively clone submodules

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

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

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

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

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

5+set -eux

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

@@ -1,24 +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)

19−

20−* support GHC 8.10

21−

221# 2020-05-25 (v0.8)

232

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

README.markdown+3−9

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

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

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

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

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

1010

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

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

1414

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

1616

17−## Quick Install

18−

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

20−

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

22−

2317## Description

2418

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

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

4438

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

4640* [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)

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

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

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

5044

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

9488

9589## Development

9690

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

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

9892

9993## Related Projects

10094

cabal.project+6−7

@@ -1,10 +1,9 @@

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

12packages: project-m36.cabal

3+allow-newer: distributed-process-extras:time,distributed-process-extras:binary,distributed-process-client-server:binary,distributed-process-client-server:time,distributed-process-async:time,distributed-process-async:binary,distributed-process-extras:stm,distributed-process-extras:containers,network-transport-tcp:containers,distributed-process-client-server:stm,distributed-process-client-server:containers,distributed-process-async:stm,distributed-process-async:containers,distributed-process:hashable,distributed-process-extras:hashable,distributed-process-client-server:hashable,distributed-process-async:hashable

3−package *

4− split-sections: True

5−

6−--high-performance streaming library

5+--necessary for GHC 8.6 support :/

76source-repository-package

8− type: git

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

10− tag: ac3af8749194f1788704dda8667d0b3807075cc2

7+ type: git

8+ location: https://github.com/agentm/distributed-process.git

9+ tag: f352e097fbe494ad648b4e09249f865893ae90a3

default.nixdeleted−1

@@ -1 +0,0 @@

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

docker.nixdeleted−18

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

1−{ compiler ? "ghc8104"

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

3−, pkgs ? import sources.nixpkgs { }

4−}:

5−let

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

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

8−in

9−pkgs.dockerTools.buildImage {

10− name = "project-m36";

11− tag = "latest";

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

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

14− config = {

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

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

17− };

18−}

docs/15_minute_tutorial.markdown+67−64

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

55## Prerequisites

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

810

911## Download and Install

1012

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−

1713```bash

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

19−cabal new-run tutd

15+cabal sandbox init

16+cabal install --dependencies-only

17+cabal run tutd

2018```

2119

2220## Some Basic TutorialD

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

2826### Load the Canonical Chris Date Example

2927

3028```

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"

3236```

3337

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.

3541

3642### Execute Relational Expressions

3743

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

158164#### Create a Relation Variable

159165

160166```

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

162168TutorialD (master/main): :showexpr x

163169┌────────┬──────────┐

164170│age::Int│name::Text│

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

173179#### Insert Additional Tuples

174180

175181```

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

177183TutorialD (master/main): :showexpr x

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

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

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

181−│31 │"Mike" │

182−│40 │"Steve" │

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

184−

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

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

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

187+│40 │"Steve" │

188+│31 │"Mike" │

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

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

186191TutorialD (master/main): :showexpr x

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

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

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

190−│31 │"Mike" │

191−│40 │"Steve" │

192−│24 │"Bob" │

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

194−

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

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

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

195+│40 │"Steve" │

196+│24 │"Bob" │

197+│31 │"Mike" │

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

195199```

196200

197201Note 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{...}".

200204

201205```

202206TutorialD (master/main): :showexpr s

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

213217TutorialD (master/main): :showexpr s

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

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

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

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

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

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

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

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

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

223−

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

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

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

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

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

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

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

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

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

224227```

225228#### Deleting Tuples from a Relation Variable

226229

227230```

228231TutorialD (master/main): :showexpr s

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

239242TutorialD (master/main): :showexpr s

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

248251```

249252

250253### Execute Transaction Graph Expressions

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

267270

268271```

269272TutorialD (master/main): :branch experimental

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

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

271274TutorialD (experimental): :commit

272275```

273276

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

99### Example Export

1010

1111```

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

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

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

1414```

1515```

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

3737S6,Samson,100,New York

3838```

3939```

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

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

4141TutorialD (master/main): :showexpr s

4242┌──────────┬────────┬───────────┬───────────────┐

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

docs/introduction_to_projectm36.markdown+8−27

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

1515

1616## Binary Releases

1717

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

18+### Windows

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

1920

20−### Install Docker:

21+### MacOS X

2122

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

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

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

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

2524

26−### Run TutorialD from Docker Image

25+### Linux

2726

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

29−

30−```bash

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

32−```

33−

34−### Run Project:M36 Server

35−

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

37−

38−```bash

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

40−```

41−

42−### Connect to Project:M36 Server

43−

44−```bash

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

46−```

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

4728

4829## Source Installation

4930

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

5132

5233To build with stack:

5334

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

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

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

5637* Linux, macOS, or Microsoft Windows

5738

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

6344

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

6546

66−Alternative building with GHC 8.6.5 or greater:

47+Alternative building with GHC 8.4.4 or greater:

6748

6849* ```cabal new-build```

6950

docs/introduction_to_the_relational_algebra.markdown+1−1

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

202202

203203(Course Relation)

204204

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

206206|-------------------------------|----------------------------------|--------------------------------------|

207207|English 1|Steve|Room 104|

208208|French 2|Bob|Room 103|

docs/reaching_out_of_the_tarpit.markdown+1−1

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

5757To 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:

5858

5959```

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

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

6161TutorialD (master/main): :showexpr p

6262┌───────────────────┬────────────┬───────────────────┬────────────┬────────────┐

6363│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

4747

4848|Database Context Expression |Description |

4949|------------------------------------------------------|---------------------------------------|

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

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

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

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

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

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

5553|`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):

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

2020

2121```

22−:importexample cjdate

22+:importexample date

2323```

2424

2525Each 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

3030|p|parts|

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

3232

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−

5133### Types

5234

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

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

215197└────────┴───────────┴───────────────┘

216198```

217199

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

219201

220202```

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

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

231213

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

233215

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−

270216#### Restriction

271217

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

examples/DerivingCustomTupleable.hs+2−4

@@ -3,16 +3,16 @@

33import ProjectM36.Tupleable.Deriving

44import ProjectM36.Atomable (Atomable)

55import Control.DeepSeq (NFData)

6+import Data.Binary (Binary)

67import Data.Text (Text)

78import GHC.Generics (Generic)

8−import Codec.Winery

1010newtype BlogId = BlogId { getBlogId :: Int }

1111 deriving stock (Eq, Ord, Show, Generic)

1212 deriving newtype (Num)

13− deriving Serialise via WineryRecord BlogId

1413

1514instance NFData BlogId

15+instance Binary BlogId

1616instance Atomable BlogId

1717

1818data Blog = Blog

@@ -23,7 +23,6 @@ data Blog = Blog

2323 deriving stock (Show, Generic)

2424 deriving (Tupleable)

2525 via Codec (Field (DropPrefix "blog" >>> CamelCase)) Blog

26− deriving Serialise via WineryRecord Blog

2726

2827data Comment = Comment

2928 { commentAuthorName :: Text

@@ -33,7 +32,6 @@ data Comment = Comment

3332 deriving stock (Show, Generic)

3433 deriving (Tupleable)

3534 via Codec (Field (DropPrefix "comment" >>> CamelCase)) Comment

36− deriving Serialise via WineryRecord Comment

3735

3836main :: IO ()

3937main = do

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/SimpleClient.hs+1−1

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

66main :: IO ()

77main = do

88 -- 1. create a ConnectionInfo

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

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

1010 -- 2. conncted to the remote database

1111 eConn <- connectProjectM36 connInfo

1212 case eConn of

examples/blog.hs+3−4

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

11-- a simple example of a blog schema

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

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

44import ProjectM36.Client

55import ProjectM36.Base

@@ -10,6 +10,7 @@ import ProjectM36.Tuple (atomForAttributeName)

1010

1111import Data.Either

1212import GHC.Generics

13+import Data.Binary

1314import qualified Data.Text as T

1415import qualified Data.Text.Lazy as TL

1516import Data.Time.Clock

@@ -21,7 +22,6 @@ import Data.Monoid

2122#endif

2223import Data.List

2324import Control.Monad (when, forM_)

24−import Codec.Winery

2525

2626import Web.Scotty as S

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

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

5252instance Tupleable Comment

5353

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

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

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

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

5756

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

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

examples/hair.hs+3−4

@@ -1,17 +1,16 @@

1−{-# LANGUAGE DeriveGeneric, DeriveAnyClass, OverloadedStrings, DerivingVia #-}

1+{-# LANGUAGE DeriveGeneric, DeriveAnyClass, OverloadedStrings #-}

22import ProjectM36.Client

33import ProjectM36.Relation.Show.Term

44import GHC.Generics

55import Data.Text

6+import Data.Binary

67import Control.DeepSeq

78import qualified Data.Map as M

89import qualified Data.Text.IO as TIO

910import Data.Proxy

10−import Codec.Winery

1111

1212data Hair = Bald | Brown | Blond | OtherColor Text

13− deriving (Generic, Show, Eq, NFData, Atomable)

14− deriving Serialise via WineryVariant Hair

13+ deriving (Generic, Show, Eq, Binary, NFData, Atomable)

1514

1615main :: IO ()

1716main = do

examples/out_of_the_tarpit.hs+7−11

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

11-- the Out-of-the-Tarpit example in Haskell and Project:M36

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

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

33import ProjectM36.Client

44import ProjectM36.DataTypes.Primitive

55import ProjectM36.Tupleable

@@ -7,11 +7,11 @@ import ProjectM36.Relation

77import ProjectM36.Error

88import Data.Either

99import GHC.Generics

10+import Data.Binary

1011import Control.DeepSeq

1112import qualified Data.Text as T

1213import Data.Time.Calendar

1314import Data.Proxy

14−import Codec.Winery

1515

1616--create various database value (atom) types

1717type Price = Double

@@ -21,20 +21,16 @@ type Name = T.Text

2121type Address = T.Text

2222

2323data RoomType = Kitchen | Bathroom | LivingRoom

24− deriving (Generic, Atomable, Eq, Show, NFData)

25− deriving Serialise via WineryVariant RoomType

24+ deriving (Generic, Atomable, Eq, Show, Binary, NFData)

2625

2726data PriceBand = Low | Medium | High | Premium

28− deriving (Generic, Atomable, Eq, Show, NFData)

29− deriving Serialise via WineryVariant PriceBand

27+ deriving (Generic, Atomable, Eq, Show, Binary, NFData)

3028

3129data AreaCode = City | Suburban | Rural

32− deriving (Generic, Atomable, Eq, Show, NFData)

33− deriving Serialise via WineryVariant AreaCode

30+ deriving (Generic, Atomable, Eq, Show, Binary, NFData)

3431

3532data SpeedBand = VeryFastBand | FastBand | MediumBand | SlowBand

36− deriving (Generic, Atomable, Eq, Show, NFData)

37− deriving Serialise via WineryVariant SpeedBand

33+ deriving (Generic, Atomable, Eq, Show, Binary, NFData)

3834

3935main :: IO ()

4036main = do

@@ -261,4 +257,4 @@ handleIOErrors m = do

261257 [] -> pure (rights eErrs)

262258 errs -> handleError (Left (someErrors errs))

263259

264−

260+

examples/out_of_the_tarpit.tutd+4−4

@@ -3,9 +3,9 @@

33data Address = Address Text

44data Agent = Agent Text

55data Name = Name Text

6−data Price = Price Integer --dollars

6+data Price = Price Double

77data RoomType = Kitchen | Bathroom | LivingRoom

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

8+data PriceBand = Low | Medium | High | Premium

99data AreaCode = City | Suburban | Rural

1010data SpeedBand = VeryFast | Fast | Medium | Slow

1111

@@ -57,9 +57,9 @@ constraint noOffersAfterSale (offer join decision where ^dayEarlierThan(@offerDa

5757--1. identify offerPrices > 2000 (arbitrarily-chosen high price band which is not specified in the paper)

5858--2. remove the properties which have been sold

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

6161

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

6363

6464-- sample data

6565

jupyter/TutorialD Notebook Walkthrough.ipynb+1−1

@@ -38,7 +38,7 @@

3838 }

3939 ],

4040 "source": [

41− ":importexample cjdate"

41+ ":importexample date"

4242 ]

4343 },

4444 {

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

project-m36.cabal+159−131

@@ -1,8 +1,6 @@

1−Cabal-Version: 2.2

21Name: project-m36

3−Version: 0.9.3

4−License: MIT

5−--note that this license specification is erroneous and only labeled MIT to appease hackage which does not recognize public domain packages in cabal >2.2- Project:M36 is dedicated to the public domain

2+Version: 0.8

3+License: PublicDomain

64Build-Type: Simple

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

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

@@ -10,6 +8,7 @@ Author: AgentM

108Stability: experimental

119Category: Relational Algebra

1210Maintainer: agentm@themactionfaction.com

11+Cabal-Version: >= 1.10

1312Synopsis: Relational Algebra Engine

1413Description: A relational algebra engine which can be used to persist and query Haskell data types.

1514Extra-Source-Files: Changelog.markdown README.markdown

@@ -35,15 +34,17 @@ Flag haskell-scripting

3534 Default: True

3635

3736Library

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.14, ghc-paths, mtl, containers, unordered-containers, hashable, haskeline, directory, MonadRandom, random-shuffle, uuid >= 1.3.12, cassava >= 0.4.5.1 && < 0.6, text, bytestring, deepseq, deepseq-generics, vector, parallel, monad-parallel, exceptions, transformers, gnuplot, binary, filepath, zlib, directory, vector-binary-instances, temporary, stm, time, hashable-time, old-locale, rset, attoparsec, either, base64-bytestring, data-interval, extended-reals, network-transport, aeson >= 1.1, path-pieces, conduit, resourcet, http-api-data, semigroups, QuickCheck, quickcheck-instances, distributed-process-client-server >= 0.2.3, distributed-process >= 0.7.4, distributed-process-extras >= 0.3.2, distributed-process-async >= 0.2.4.1, network-transport-tcp >= 0.6.0, network-transport, list-t, stm-containers >= 0.2.15, foldl, optparse-applicative, Glob, cryptohash-sha256, text-manipulate >= 0.2.0.1 && < 0.3

3938 if flag(haskell-scripting)

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

39+ Build-Depends: ghc >= 8.2 && < 8.9

4140 CPP-Options: -DPM36_HASKELL_SCRIPTING

4241 if impl(ghc>= 8) && flag(haskell-scripting)

4342 build-depends:

4443 ghc-boot, ghci

4544 if impl(ghc>= 8.6)

4645 Build-Depends: deferred-folds

46+ if impl(ghc>= 8.6.1)

47+ Exposed-Modules: ProjectM36.Tupleable.Deriving

4748 Exposed-Modules: ProjectM36.Error,

4849 ProjectM36.Transaction,

4950 ProjectM36.TransactionGraph,

@@ -52,8 +53,6 @@ Library

5253 ProjectM36.TransactionGraph.Merge,

5354 ProjectM36.TransGraphRelationalExpression,

5455 ProjectM36.Base,

55− ProjectM36.Serialise.Base,

56− ProjectM36.Serialise.Error,

5756 ProjectM36.DataFrame,

5857 ProjectM36.Attribute,

5958 ProjectM36.AttributeNames,

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

6362 ProjectM36.AtomFunction,

6463 ProjectM36.AtomFunctionError,

6564 ProjectM36.ScriptSession,

66− ProjectM36.Shortcuts,

6765 ProjectM36.DatabaseContextFunction,

6866 ProjectM36.DatabaseContextFunctionError,

6967 ProjectM36.DatabaseContextFunctionUtils,

@@ -93,7 +91,6 @@ Library

9391 ProjectM36.AtomFunctions.Primitive,

9492 ProjectM36.Atomable,

9593 ProjectM36.Tupleable,

96− ProjectM36.Tupleable.Deriving,

9794 ProjectM36.DataConstructorDef,

9895 ProjectM36.DataTypes.Basic,

9996 ProjectM36.DataTypes.Sorting,

@@ -114,10 +111,6 @@ Library

114111 ProjectM36.Server.EntryPoints,

115112 ProjectM36.Server.ParseArgs,

116113 ProjectM36.Server.RemoteCallTypes,

117− ProjectM36.Serialise.AtomFunctionError,

118− ProjectM36.Serialise.DataFrame,

119− ProjectM36.Serialise.DatabaseContextFunctionError,

120− ProjectM36.Serialise.IsomorphicSchema,

121114 ProjectM36.Session,

122115 ProjectM36.Sessions,

123116 ProjectM36.Transaction.Persist,

@@ -136,19 +129,19 @@ Library

136129 Other-Modules: ProjectM36.Win32Handle

137130 else

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

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

132+ GHC-Options: -rdynamic

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

141134 Build-Depends: unix

142135 CC-Options: -fPIC

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

144137 Default-Language: Haskell2010

145138 Default-Extensions: OverloadedStrings, CPP

146− if !flag(stack)

139+ if !flag(stack)

147140 Build-Depends: deferred-folds

148141

149142Executable tutd

150143 if flag(haskell-scripting)

151− Build-Depends: ghc >= 8.2 && < 8.11

144+ Build-Depends: ghc >= 8.2 && < 8.9

152145 Build-Depends: base >=4.8 && <5.0,

153146 ghc-paths,

154147 project-m36,

@@ -163,11 +156,13 @@ Executable tutd

163156 MonadRandom, MonadRandom,

164157 vector,

165158 text,

159+ vector-binary-instances,

166160 time,

167161 hashable-time,

168162 bytestring,

169163 stm,

170164 deepseq,

165+ binary,

171166 data-interval,

172167 parallel,

173168 cassava,

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

175170 directory,

176171 filepath,

177172 temporary,

178− megaparsec >= 5.2.0 && < 10,

173+ megaparsec >= 5.2.0 && < 9,

179174 haskeline,

180175 random, MonadRandom,

181176 base64-bytestring,

@@ -183,15 +178,7 @@ Executable tutd

183178 attoparsec,

184179 stm-containers >= 1.0.0,

185180 list-t,

186− parser-combinators,

187− curryer-rpc,

188− prettyprinter,

189− cryptohash-sha256,

190− --due to decode signature change

191− base16-bytestring >= 1.0.0.0,

192− http-conduit,

193− modern-uri,

194− http-types

181+ parser-combinators

195182 Other-Modules: TutorialD.Interpreter,

196183 TutorialD.Interpreter.Base,

197184 TutorialD.Interpreter.DatabaseContextExpr,

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

210197 TutorialD.Interpreter.SchemaOperator,

211198 TutorialD.Interpreter.TransGraphRelationalOperator,

212199 TutorialD.Interpreter.SchemaOperator

213− TutorialD.Printer

214200 main-is: TutorialD/tutd.hs

215201 CC-Options: -fPIC

216202 GHC-Options: -Wall -threaded

@@ -220,11 +206,12 @@ Executable tutd

220206

221207Executable project-m36-server

222208 if flag(haskell-scripting)

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

209+ Build-Depends: ghc >= 8.2 && < 8.9

224210 Build-Depends: base,

225211 ghc-paths,

226− transformers,

227212 project-m36,

213+ binary,

214+ transformers,

228215 temporary,

229216 data-interval,

230217 deepseq,

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

237224 optparse-applicative,

238225 hashable-time,

239226 time,

227+ vector-binary-instances,

240228 text,

241229 deepseq-generics,

242230 mtl,

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

258246Executable bigrel

259247 Default-Language: Haskell2010

260248 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

249+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, optparse-applicative, stm-containers, list-t, ghc, ghc-paths, transformers, project-m36, random, MonadRandom, semigroups, parser-combinators

262250 Other-Modules: TutorialD.Interpreter.Base,

263251 TutorialD.Interpreter.DatabaseContextExpr,

264252 TutorialD.Interpreter.RelationalExpr,

@@ -269,13 +257,6 @@ Executable bigrel

269257 if flag(profiler)

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

271259

272−Common commontest

273− Default-Language: Haskell2010

274− Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics,parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36, random, MonadRandom, semigroups, parser-combinators, winery, curryer-rpc, prettyprinter, base64-bytestring, modern-uri, http-types, http-conduit, base16-bytestring,cryptohash-sha256

275− Default-Extensions: OverloadedStrings

276− GHC-Options: -Wall -threaded

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

278−

279260Benchmark basic-benchmark

280261 Default-Language: Haskell2010

281262 Default-Extensions: OverloadedStrings

@@ -287,202 +268,246 @@ Benchmark basic-benchmark

287268 if flag(profiler)

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

289270

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−

302271Test-Suite test-tutoriald

303− import: commontest

272+ Default-Language: Haskell2010

273+ Default-Extensions: OverloadedStrings

304274 type: exitcode-stdio-1.0

305− main-is: TutorialD/InterpreterTest.hs

306− Other-Modules: TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.TestBase, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.SchemaOperator, TutorialD.Printer

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

275+ main-is: test/TutorialD/Interpreter.hs

276+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, stm-containers, list-t, project-m36, random, MonadRandom, semigroups, parser-combinators

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

278+ GHC-Options: -Wall -threaded

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

308280

309281Test-Suite test-tutoriald-atomfunctionscript

310− import: commontest

282+ Default-Language: Haskell2010

283+ Default-Extensions: OverloadedStrings

311284 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

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

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

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

287+ Build-Depends: base, HUnit, project-m36, uuid, containers, megaparsec, text, vector, directory, bytestring, mtl, haskeline, random, MonadRandom, semigroups, time, parser-combinators

288+ GHC-Options: -Wall -threaded

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

314290

315291Test-Suite test-tutoriald-databasecontextfunctionscript

316− import: commontest

292+ Default-Language: Haskell2010

293+ Default-Extensions: OverloadedStrings

317294 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

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

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

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

297+ Build-Depends: base, HUnit, project-m36, uuid, containers, megaparsec, text, vector, directory, bytestring, mtl, haskeline, random, MonadRandom, semigroups, time, parser-combinators

298+ GHC-Options: -Wall -threaded

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

320300

321301Test-Suite test-relation

322− import: commontest

302+ Default-Language: Haskell2010

303+ Default-Extensions: OverloadedStrings

323304 type: exitcode-stdio-1.0

324− main-is: Relation/Basic.hs

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

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

307+ GHC-Options: -Wall -threaded

325308

326309Test-Suite test-static-optimizer

327− import: commontest

310+ Default-Language: Haskell2010

311+ Default-Extensions: OverloadedStrings

328312 type: exitcode-stdio-1.0

329− main-is: Relation/StaticOptimizer.hs

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

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

315+ GHC-Options: -Wall -threaded

330316

331317Test-Suite test-transactiongraph-persist

332− import: commontest

318+ Default-Language: Haskell2010

319+ Default-Extensions: OverloadedStrings

333320 type: exitcode-stdio-1.0

334− main-is: TransactionGraph/Persist.hs

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

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

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

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

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

325+ GHC-Options: -Wall -threaded

336326

337327Test-Suite test-relation-import-csv

338− import: commontest

328+ Default-Language: Haskell2010

329+ Default-Extensions: OverloadedStrings

339330 type: exitcode-stdio-1.0

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

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

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

333+ GHC-Options: -Wall -threaded

341334

342335Test-Suite test-tutoriald-import-tutoriald

343− import: commontest

336+ Default-Language: Haskell2010

337+ Default-Extensions: OverloadedStrings

344338 type: exitcode-stdio-1.0

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

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

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

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

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

342+ GHC-Options: -Wall -threaded

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

347344

348345Test-Suite test-relation-export-csv

349− import: commontest

346+ Default-Language: Haskell2010

347+ Default-Extensions: OverloadedStrings

350348 type: exitcode-stdio-1.0

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

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

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

351+ GHC-Options: -Wall -threaded

352352

353353Test-Suite test-transactiongraph-merge

354− import: commontest

355− type: exitcode-stdio-1.0

356− main-is: TransactionGraph/Merge.hs

357−

358−

359−Test-Suite test-prettyprinter

360− import: commontest

354+ Default-Language: Haskell2010

355+ Default-Extensions: OverloadedStrings

361356 type: exitcode-stdio-1.0

362− main-is: TutorialD/PrinterTest.hs

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

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

358+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, template-haskell, transformers, aeson, conduit, either, path-pieces, http-api-data, stm-containers, list-t, project-m36

359+ GHC-Options: -Wall -threaded

364360

365361benchmark bench

366− import: commontest

362+ Default-Language: Haskell2010

363+ Default-Extensions: OverloadedStrings

367364 type: exitcode-stdio-1.0

368365 main-is: benchmark/Relation.hs

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

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

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

369369

370370Test-Suite test-server

371− import: commontest

371+ Default-Language: Haskell2010

372+ Default-Extensions: OverloadedStrings

372373 type: exitcode-stdio-1.0

373− main-is: Server/Main.hs

374−

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

375+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, network-transport-tcp, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, project-m36, network-transport, semigroups

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

377+ GHC-Options: -Wall -threaded

375378

376379Executable Example-SimpleClient

377380 Default-Language: Haskell2010

378381 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

382+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, ghc, ghc-paths, project-m36, random, MonadRandom

380383 Main-Is: examples/SimpleClient.hs

381384 GHC-Options: -Wall -threaded

382385

383386Executable Example-OutOfTheTarpit

384387 Default-Language: Haskell2010

385388 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

389+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, aeson, path-pieces, either, conduit, http-api-data, template-haskell, ghc, ghc-paths, project-m36

387390 Main-Is: examples/out_of_the_tarpit.hs

388391 GHC-Options: -Wall -threaded

389392

390393Executable Example-Blog

391394 Default-Language: Haskell2010

392395 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

396+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, aeson, path-pieces, either, conduit, http-api-data, template-haskell, ghc, ghc-paths, project-m36, scotty, blaze-html, http-types

394397 Main-Is: examples/blog.hs

395398 GHC-Options: -Wall -threaded

396399

400+

397401Executable Example-Hair

398402 Default-Language: Haskell2010

399403 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

404+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, aeson, path-pieces, either, conduit, http-api-data, template-haskell, ghc, ghc-paths, project-m36

401405 Main-Is: examples/hair.hs

402406 GHC-Options: -Wall -threaded

403407

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−

411408Executable Example-CustomTupleable

412409 Default-Language: Haskell2010

413410 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

411+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, aeson, path-pieces, either, conduit, http-api-data, template-haskell, ghc, ghc-paths, project-m36

415412 Main-Is: examples/CustomTupleable.hs

416413 GHC-Options: -Wall -threaded

417414

418415Executable Example-DerivingCustomTupleable

419− if impl(ghc>=8.6)

420− Buildable: True

421− else

422− Buildable: False

423416 Default-Language: Haskell2010

424− Build-Depends: base, text, deepseq, project-m36, winery

417+ Build-Depends: base, text, deepseq, binary, project-m36

425418 Main-Is: examples/DerivingCustomTupleable.hs

426419 GHC-Options: -Wall -threaded

427420

428421Test-Suite test-scripts

429− import: commontest

422+ Default-Language: Haskell2010

423+ Default-Extensions: OverloadedStrings

430424 type: exitcode-stdio-1.0

431− main-is: scripts.hs

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

425+ main-is: test/scripts.hs

426+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, network-transport-tcp, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, project-m36, random, MonadRandom, semigroups, parser-combinators

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

428+ GHC-Options: -Wall -threaded

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

433430

434431Executable project-m36-websocket-server

435432 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

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

437434 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

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

439436 GHC-Options: -Wall -threaded

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

441438 Default-Extensions: OverloadedStrings

442439

443440Test-Suite test-websocket-server

444− import: commontest

441+ Default-Language: Haskell2010

445442 type: exitcode-stdio-1.0

446− main-is: Server/WebSocket.hs

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

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

444+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36, random, MonadRandom, network-transport-tcp, semigroups, parser-combinators

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

446+ Default-Extensions: OverloadedStrings

447+ GHC-Options: -Wall -threaded

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

448449

449450Test-Suite test-isomorphic-schemas

450− import: commontest

451+ Default-Language: Haskell2010

451452 type: exitcode-stdio-1.0

452− main-is: IsomorphicSchema.hs

453+ main-is: test/IsomorphicSchema.hs

454+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36

455+ Default-Extensions: OverloadedStrings

456+ GHC-Options: -Wall -threaded

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

453458

454459Test-Suite test-atomable

455− import: commontest

460+ Default-Language: Haskell2010

456461 type: exitcode-stdio-1.0

457− main-is: Relation/Atomable.hs

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

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

463+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36, random, MonadRandom, semigroups, parser-combinators

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

465+ Default-Extensions: OverloadedStrings

466+ GHC-Options: -Wall -threaded

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

459468

460469Test-Suite test-multiprocess-access

461− import: commontest

470+ Default-Language: Haskell2010

462471 type: exitcode-stdio-1.0

463− main-is: MultiProcessDatabaseAccess.hs

472+ main-is: test/MultiProcessDatabaseAccess.hs

473+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36, random, MonadRandom

474+ Default-Extensions: OverloadedStrings

475+ GHC-Options: -Wall -threaded

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

464477

465478Test-Suite test-transactiongraph-automerge

466− import: commontest

479+ Default-Language: Haskell2010

467480 type: exitcode-stdio-1.0

468− main-is: TransactionGraph/Automerge.hs

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

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

482+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36, random, MonadRandom, semigroups, parser-combinators

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

484+ Default-Extensions: OverloadedStrings

485+ GHC-Options: -Wall -threaded

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

470487

471488Test-Suite test-tupleable

472− import: commontest

489+ Default-Language: Haskell2010

473490 type: exitcode-stdio-1.0

474− main-is: Relation/Tupleable.hs

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

492+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36, random, MonadRandom, semigroups

493+ Default-Extensions: OverloadedStrings

494+ GHC-Options: -Wall -threaded

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

475496

476497Test-Suite test-client-simple

477− import: commontest

478− Main-Is: Client/Simple.hs

498+ Default-Language: Haskell2010

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

479500 type: exitcode-stdio-1.0

501+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36, random, MonadRandom, semigroups

502+ Default-Extensions: OverloadedStrings

503+ GHC-Options: -Wall -threaded

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

480505

481506-- test for file handle leaks

482507Executable handles

483508 Default-Language: Haskell2010

484509 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

510+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, optparse-applicative, stm-containers, list-t, ghc, ghc-paths, transformers, project-m36, random, MonadRandom, semigroups, parser-combinators

486511 main-is: benchmark/Handles.hs

487512 Other-Modules: TutorialD.Interpreter,

488513 TutorialD.Interpreter.Base,

@@ -501,14 +526,17 @@ Executable handles

501526 TutorialD.Interpreter.TransGraphRelationalOperator,

502527 TutorialD.Interpreter.TransactionGraphOperator,

503528 TutorialD.Interpreter.Types

504− TutorialD.Printer

505529 GHC-Options: -Wall -threaded -rtsopts

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

507531 if flag(profiler)

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

509533

510534Test-Suite test-dataframe

511− import: commontest

535+ Default-Language: Haskell2010

536+ Main-Is: test/DataFrame.hs

512537 type: exitcode-stdio-1.0

513− Main-Is: DataFrame.hs

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

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

539+ Build-Depends: base, HUnit, Cabal, containers, hashable, unordered-containers, mtl, vector, vector-binary-instances, time, hashable-time, bytestring, uuid, stm, deepseq, deepseq-generics, binary, parallel, cassava, attoparsec, gnuplot, directory, temporary, haskeline, megaparsec, text, base64-bytestring, data-interval, filepath, transformers, stm-containers, list-t, websockets, optparse-applicative, network, aeson, project-m36, random, MonadRandom, semigroups, parser-combinators

540+ Default-Extensions: OverloadedStrings

541+ GHC-Options: -Wall -threaded

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

release.nixdeleted−36

@@ -1,36 +0,0 @@

1−{ compiler ? "ghc8104"

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

3−, pkgs ? import sources.nixpkgs { }

4−}:

5−let

6− doJailbreak = pkgs.haskell.lib.doJailbreak;

7− needsCocoa = drv:

8− if pkgs.stdenv.isDarwin

9− then drv.overrideDerivation (old:

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

11− )

12− else drv;

13−

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

15− overrides = self: super: {

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

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

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

19− };

20− };

21−in

22−{

23− project = haskellPackages.project-m36;

24−

25− shell = haskellPackages.shellFor {

26− packages = p: [

27− p.project-m36

28− ];

29− buildInputs = [

30− haskellPackages.ghcid

31− haskellPackages.hlint

32− pkgs.docker

33− ];

34− withHoogle = true;

35− };

36−}

scripts/DateExamples.tutd+2−2

@@ -20,7 +20,7 @@ sp := relation{tuple{s# "S1",p# "P1",qty 300},

2020 tuple{s# "S3",p# "P2",qty 200},

2121 tuple{s# "S4",p# "P4",qty 300},

2222 tuple{s# "S4",p# "P5",qty 400}};

23−key s_pkey {s#} s;

24−key p_key {p#} p;

23+key s_pkey {s#} s

24+key p_key {p#} p

2525foreign key s_sp_fk sp{s#} in s{s#};

2626foreign 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

shell.nixdeleted−1

@@ -1 +0,0 @@

1−(import ./release.nix { }).shell

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

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

1111import ProjectM36.IsomorphicSchema

1212import ProjectM36.Server.RemoteCallTypes

1313import ProjectM36.MerkleHash

14−import ProjectM36.Attribute as A

1514

1615import Data.Aeson

1716import Data.ByteString.Base64 as B64

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

4544instance ToJSON Relation

4645instance FromJSON Relation

4746

48−instance ToJSON Attribute where

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

50− , "type" .= toJSON aType ]

51−instance FromJSON Attribute where

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

47+instance ToJSON Attribute

48+instance FromJSON Attribute

5349

5450instance ToJSON ExtendTupleExpr

5551instance FromJSON ExtendTupleExpr

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

10399 "val" .= i ]

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

105101 "val" .= i ]

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

107− "val" .= i ]

108102 toJSON (ConstructedAtom dConsName atomtype atomlist) = object [

109103 "dataconstructorname" .= dConsName,

110104 "type" .= toJSON atomtype,

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

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

133127 Right bs -> pure (ByteStringAtom bs)

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

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

136129

137130instance ToJSON Notification

138131instance FromJSON Notification

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

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

150143 Right bs -> pure (MerkleHash bs)

151144

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−

158145instance ToJSON RelationalError

159146instance FromJSON RelationalError

160147

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

164151instance ToJSON MergeError

165152instance FromJSON MergeError

166153

167−instance ToJSON ImportError'

168−instance FromJSON ImportError'

169−

170154instance ToJSON DatabaseContextFunctionError

171155instance FromJSON DatabaseContextFunctionError

172156

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

181165

182166instance ToJSON WithNameExpr

183167instance FromJSON WithNameExpr

184−

185−

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

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

2222import Control.Applicative

2323import Text.Megaparsec.Error

2424import Data.Functor

25−import Data.Either (fromRight)

2625

2726#if MIN_VERSION_megaparsec(7,0,0)

2827import Data.List.NonEmpty as NE

@@ -86,7 +85,7 @@ notificationCallback conn notifName evaldNotif = WS.sendTextData conn (encode (o

8685

8786--this creates a new database for each connection- perhaps not what we want (?)

8887createConnection :: WS.Connection -> DatabaseName -> Port -> Hostname -> IO (Either ConnectionError Connection)

89−createConnection wsconn dbname port host = connectProjectM36 (RemoteConnectionInfo dbname host (show port) (notificationCallback wsconn))

88+createConnection wsconn dbname port host = connectProjectM36 (RemoteProcessConnectionInfo dbname (createNodeId host port) (notificationCallback wsconn))

9089

9190sendError :: (ToJSON a) => WS.Connection -> a -> IO ()

9291sendError conn err = WS.sendTextData conn (encode (object ["displayerror" .= err]))

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

118117promptInfo sessionId conn = do

119118 eHeadName <- headName sessionId conn

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

122121

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

124123sendPromptInfo (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;

126126 <li>:showrelvars</li>

127127 <li>:showexpr true</li>

128128 <li>:showexpr false</li>

129− <li>:importexample cjdate</li>

129+ <li>:importexample date</li>

130130 <li>:showexpr s join sp</li>

131131 <li>update s where city="Paris" (status:=10)</li>

132132 <li>:showexpr s</li>

src/bin/ProjectM36/Server/WebSocket/websocket-server.hs+18−48

@@ -1,63 +1,33 @@

11{-# LANGUAGE CPP #-}

2−

3−import Control.Concurrent

4−import Control.Exception

5−import Control.Monad (when)

6−import Data.Maybe (isJust)

7−import Data.String (fromString)

8−import Network.HTTP.Types (status400)

9−import Network.Socket

10−import Network.Wai (Application, responseLBS)

11−import Network.Wai.Handler.Warp

12−import Network.Wai.Handler.WarpTLS (runTLS, tlsSettings)

13−import qualified Network.Wai.Handler.WebSockets as WS

14−import Network.WebSockets (defaultConnectionOptions)

15−import ProjectM36.Server

2+import ProjectM36.Server.WebSocket

163import ProjectM36.Server.Config

174import ProjectM36.Server.ParseArgs

18−import ProjectM36.Server.WebSocket

5+import ProjectM36.Server

6+import Control.Concurrent

7+import qualified Network.WebSockets as WS

9+#if MIN_VERSION_network_transport_tcp(0,6,0)

10+import Network.Transport.TCP.Internal (decodeEndPointAddress)

11+#else

12+import Network.Transport.TCP (decodeEndPointAddress)

13+#endif

14+

15+import Control.Exception

1916

2017main :: IO ()

2118main = do

2219 -- launch normal project-m36-server

2320 addressMVar <- newEmptyMVar

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

25−

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

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

27− let serverConfig = wsServerConfig wsConfig

28− wsHost = bindHost serverConfig

23+ let wsHost = bindHost serverConfig

2924 wsPort = bindPort serverConfig

3025 serverHost = "127.0.0.1"

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

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

3928 --wait for server to be listening

40− addr <- takeMVar addressMVar

41− let port =

42− case addr of

43− SockAddrInet port' _ -> fromIntegral port'

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

45− wsApp = websocketProxyServer port serverHost

46− waiApp = WS.websocketsOr defaultConnectionOptions wsApp backupApp

47− settings = warpSettings wsHost (fromIntegral wsPort)

48−

49− case (configCertificateFile, configKeyFile) of

50− (Just certificate, Just key) -> runTLS (tlsSettings certificate key) settings waiApp

51− _ -> runSettings settings waiApp

52−

53−backupApp :: Application

54−backupApp _ respond = respond $ responseLBS status400 [] "Not a WebSocket request"

29+ address <- takeMVar addressMVar

30+ let Just (_, serverPort, _) = decodeEndPointAddress address

31+ --this built-in server is apparently not meant for production use, but it's easier to test than starting up the wai or snap interfaces

32+ WS.runServer wsHost (fromIntegral wsPort) (websocketProxyServer (read serverPort) serverHost)

5533

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+2−4

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

3434import Data.List (isPrefixOf)

3535import Control.Exception

3636import System.Exit

37−import Data.Either (fromRight)

3837

3938{-

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

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

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

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

8079 where

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

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

8281

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

8483parseTutorialD = parse interpreterParserP ""

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

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

217216 barf :: RelationalError -> IO TutorialDOperatorResult

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

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

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

221219 eHandler io = do

222220 eErr <- io

@@ -229,7 +227,7 @@ type TutorialDExec = String

229227type CheckFS = Bool

230228

231229data InterpreterConfig = LocalInterpreterConfig PersistenceStrategy HeadName (Maybe TutorialDExec) [GhcPkgPath] CheckFS |

232− RemoteInterpreterConfig C.Hostname C.Port C.DatabaseName HeadName (Maybe TutorialDExec) CheckFS

230+ RemoteInterpreterConfig C.NodeId C.DatabaseName HeadName (Maybe TutorialDExec) CheckFS

233231

234232outputNotificationCallback :: C.NotificationCallback

235233outputNotificationCallback notName evaldNot = hPutStrLn stderr $ "Notification received " ++ show notName ++ ":\n" ++ "\n" ++ prettyEvaluatedNotification evaldNot

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

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

1212 where

1313import ProjectM36.Base

1414import ProjectM36.AtomType

15−import ProjectM36.Attribute as A

1615import ProjectM36.Relation

1716import ProjectM36.DataFrame

1817

1918#if MIN_VERSION_megaparsec(6,0,0)

20−import Text.Megaparsec.Char

19+import Text.Megaparsec.Char

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

2221import Text.Megaparsec

2322import Data.Void

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

3130import System.Random

3231import qualified Data.Text as T

3332import qualified Data.List as L

33+import qualified Data.Vector as V

3434import qualified Data.Text.IO as TIO

3535import System.IO

3636import ProjectM36.Relation.Show.Term

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

4444import Data.Time.Clock

4545import Data.Time.Format

4646import Control.Monad (void)

47−import Data.Char

4847

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

5049anySingle :: Parsec Void Text (Token Text)

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

8281type ParseStr = String

8382#endif

8483

85−-- consumes only horizontal spaces

8684spaceConsumer :: Parser ()

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

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

8886

8987opChar :: Parser Char

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

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

137135semi :: Parser Text

138136semi = symbol ";"

139137

140−nline :: Parser Text

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

142−

143138integer :: Parser Integer

144139#if MIN_VERSION_megaparsec(6,0,0)

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

140+integer = Lex.signed spaceConsumer Lex.decimal

146141#else

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

142+integer = Lex.signed spaceConsumer Lex.integer

148143#endif

149144

150145natural :: Parser Integer

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

155150#endif

156151

157152float :: Parser Double

158−float = Lex.float <* spaceConsumer

153+float = Lex.float

159154

160155capitalizedIdentifier :: Parser Text

161156capitalizedIdentifier =

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

168163showRelationAttributes :: Attributes -> Text

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

170165 where

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

172− attrsL = A.toList attrs

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

167+ attrsL = V.toList attrs

173168

174169type PromptLength = Int

175170

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

205200quotedString :: Parser Text

206201quotedString = try tripleQuotedString <|> normalQuotedString

207202

208−quoted :: Parser a -> Parser a

209−quoted = between quote quote

210−

211203uuidP :: Parser U.UUID

212204uuidP = do

213205 uuidStart <- count 8 hexDigitChar

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

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

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

232224 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

5353multilineSep = newline >> pure "\n"

5454

5555multipleDatabaseContextExprP :: Parser DatabaseContextExpr

56−multipleDatabaseContextExprP = do

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

58− pure (MultipleExpr exprs)

56+multipleDatabaseContextExprP =

57+ MultipleExpr <$> sepBy1 databaseContextExprP semi

5958

6059insertP :: Parser DatabaseContextExpr

6160insertP = do

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

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

22module TutorialD.Interpreter.Import.Base where

33import ProjectM36.Base

44import ProjectM36.Error

5−import Text.URI (URI)

6−import Data.Text (Text)

75#if __GLASGOW_HASKELL__ < 804

86import Data.Monoid

97#endif

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

1412instance Show RelVarDataImportOperator where

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

1614

17−type HashVerification = Maybe Text

18−

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

2117

2218instance Show DatabaseContextDataImportOperator where

23− show (DatabaseContextDataImportOperator uri hash _) =

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

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

2520

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

2722

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

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

3025

3126evalDatabaseContextDataImportOperator :: 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

2020importBasicExampleOperatorP = do

2121 reservedOp ":importexample"

2222 example <- identifier

23− if example == "cjdate" then

23+ if example == "date" then

2424 pure ImportBasicDateExampleOperator

2525 else

2626 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

1414 --TODO: handle filesystem errors

1515 csvData <- try (BS.readFile pathIn) :: IO (Either IOError BS.ByteString)

1616 case csvData of

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

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

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

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

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

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

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

2121

2222importCSVP :: Parser RelVarDataImportOperator

2323importCSVP = do

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

@@ -9,78 +9,25 @@ import qualified Data.Text as T

99import Control.Exception

1010import qualified Data.ByteString as BS

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

1913

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

21−importTutorialDFromFile fileURI mHash = do

22− case URI.uriPath fileURI of

23− Just (False, _) -> do

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

25− case eTutdBytes of

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

27− Right tutdBytes ->

28− case validateBytes tutdBytes mHash of

29− Left err -> pure (Left err)

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

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

40− Right tutdUtf8 ->

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

42− --parseErrorPretty is new in megaparsec 5

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

44− Right expr -> pure (Right expr)

45−

46−importTutorialDViaHTTP :: URI -> HashVerification -> IO (Either RelationalError DatabaseContextExpr)

47−importTutorialDViaHTTP uri mHash = do

48− reqURI <- parseRequest (URI.renderStr uri)

49− response <- httpBS reqURI

50− let scode = getResponseStatus response

51− if scode == ok200 then

52− let byteBody = getResponseBody response in

53− case validateBytes byteBody mHash of

54− Right byteBody' -> do

55− importTutorialDBytes byteBody'

56− Left err -> pure (Left err)

57− else

58− pure (Left (ImportError (ImportDownloadError (T.pack ("download failed: " <> show scode)))))

59−

60−validateBytes :: BS.ByteString -> HashVerification -> Either RelationalError BS.ByteString

61−validateBytes tutdBytes mHash =

62− case mHash of

63− Nothing -> pure tutdBytes

64− Just expectedHashText ->

65− case B16.decode (TE.encodeUtf8 expectedHashText) of

66− Left _ -> Left (ImportError (InvalidSHA256Error expectedHashText))

67− Right expectedHash | hashBytes == expectedHash -> pure tutdBytes

68− | otherwise ->

69− let p = TE.decodeUtf8 . B16.encode in

70− Left (ImportError (SHA256MismatchError (p expectedHash) (p hashBytes)))

71− where

72− hashBytes = hash tutdBytes

73−

74−

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

15+importTutorialD pathIn = do

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

17+ case eTutdBytes of

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

19+ Right tutdBytes ->

20+ case TE.decodeUtf8' tutdBytes of

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

22+ Right tutdUtf8 ->

23+ case parse multipleDatabaseContextExprP "import" tutdUtf8 of

24+ --parseErrorPretty is new in megaparsec 5

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

26+ Right expr -> pure (Right expr)

27+

7528tutdImportP :: Parser DatabaseContextDataImportOperator

7629tutdImportP = do

7730 reserved ":importtutd"

78− uri <- quoted URI.parser

31+ path <- quotedString

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

11{-# LANGUAGE GADTs #-}

22module TutorialD.Interpreter.RODatabaseContextOperator where

33import ProjectM36.Base

4−import ProjectM36.Relation

54import qualified ProjectM36.DataFrame as DF

65import ProjectM36.Error

7−import ProjectM36.Tuple

86import ProjectM36.InclusionDependency

97import qualified ProjectM36.Client as C

108import TutorialD.Interpreter.Base

119import TutorialD.Interpreter.RelationalExpr

1210import TutorialD.Interpreter.DatabaseContextExpr

13−import TutorialD.Printer

1411import Control.Monad.State

1512import qualified Data.Text as T

1613import ProjectM36.Relation.Show.Gnuplot

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

2219 ShowRelation :: RelationalExpr -> RODatabaseContextOperator

2320 PlotRelation :: RelationalExpr -> RODatabaseContextOperator

2421 ShowRelationType :: RelationalExpr -> RODatabaseContextOperator

25− ShowConstraints :: StringType -> RODatabaseContextOperator

22+ ShowConstraint :: StringType -> RODatabaseContextOperator

2623 ShowPlan :: DatabaseContextExpr -> RODatabaseContextOperator

2724 ShowTypes :: RODatabaseContextOperator

2825 ShowRelationVariables :: RODatabaseContextOperator

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

3431

3532typeP :: Parser RODatabaseContextOperator

3633typeP = do

37− colonOp ":type"

34+ reservedOp ":type"

3835 ShowRelationType <$> relExprP

3936

4037showRelP :: Parser RODatabaseContextOperator

4138showRelP = do

42− colonOp ":showexpr"

39+ reservedOp ":showexpr"

4340 ShowRelation <$> relExprP

4441

4542showPlanP :: Parser RODatabaseContextOperator

4643showPlanP = do

47− colonOp ":showplan"

44+ reservedOp ":showplan"

4845 ShowPlan <$> databaseContextExprP

4946

5047showTypesP :: Parser RODatabaseContextOperator

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

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

5249

5350showRelationVariables :: Parser RODatabaseContextOperator

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

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

5552

5653showAtomFunctionsP :: Parser RODatabaseContextOperator

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

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

5855

5956showDatabaseContextFunctionsP :: Parser RODatabaseContextOperator

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

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

6158

6259quitP :: Parser RODatabaseContextOperator

6360quitP = do

64− colonOp ":quit"

61+ reservedOp ":quit"

6562 return Quit

6663

6764showConstraintsP :: Parser RODatabaseContextOperator

6865showConstraintsP = do

69− colonOp ":constraints"

70− ShowConstraints <$> option "" identifier

66+ reservedOp ":constraints"

67+ ShowConstraint <$> option "" identifier

7168

7269plotRelExprP :: Parser RODatabaseContextOperator

7370plotRelExprP = do

74− colonOp ":plotexpr"

71+ reserved ":plotexpr"

7572 PlotRelation <$> relExprP

7673

7774roDatabaseContextOperatorP :: Parser RODatabaseContextOperator

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

109106 err <- plotRelation rel

110107 when (isJust err) $ print err

111108

112−evalRODatabaseContextOp sessionId conn (ShowConstraints name) = do

109+evalRODatabaseContextOp sessionId conn (ShowConstraint name) = do

113110 eIncDeps <- C.inclusionDependencies sessionId conn

114111 let val = case eIncDeps of

115112 Left err -> Left err

116113 Right incDeps -> case name of

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

114+ "" -> inclusionDependenciesAsRelation incDeps

118115 depName -> case M.lookup depName incDeps of

119116 Nothing -> Left (InclusionDependencyNameNotInUseError depName)

120− Just dep ->

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

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

122118 pure $ case val of

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

124120 Right rel -> DisplayRelationResult rel

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

168164

169165showDataFrameP :: Parser RODatabaseContextOperator

170166showDataFrameP = do

171− colonOp ":showdataframe"

167+ reservedOp ":showdataframe"

172168 relExpr <- relExprP

173169 reservedOp "orderby"

174170 attrOrdersExpr <- attrOrdersExprP

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

195191

196192orderP :: Parser DF.Order

197193orderP = 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)

2020attributeListP =

2121 (reservedOp "all but" >>

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

23−

2423 (reservedOp "all from" >>

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

34−

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

3526

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

3728makeRelationP = do

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

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

112103extendP = do

113104 reservedOp ":"

114− extends <- braces (sepBy extendTupleExpressionP comma)

115− case extends of

116− [] -> pure (Restrict TruePredicate)

117− extends' ->

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

105+ Extend <$> braces extendTupleExpressionP

119106

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

121108semijoinP = do

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

142129 [InfixL antijoinP],

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

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

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

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

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

147133 [Postfix extendP]

148134 ]

149135

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

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

215201 constructedAtomExprP consume <|>

216202 attributeAtomExprP <|>

217− try nakedAtomExprP <|>

203+ nakedAtomExprP <|>

218204 relationalAtomExprP

219−

220205

221206attributeAtomExprP :: Parser (AtomExprBase a)

222207attributeAtomExprP = do

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

235220-- used only for primitive type parsing ?

236221atomP :: Parser Atom

237222atomP = stringAtomP <|>

238− try doubleAtomP <|>

223+ doubleAtomP <|>

239224 integerAtomP <|>

240225 boolAtomP

241226

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

250235stringAtomP = TextAtom <$> quotedString

251236

252237doubleAtomP :: Parser Atom

253−doubleAtomP = DoubleAtom <$> float

238+doubleAtomP = DoubleAtom <$> try float

254239

255240integerAtomP :: Parser Atom

256241integerAtomP = IntegerAtom <$> integer

257242

258243boolAtomP :: Parser Atom

259244boolAtomP = do

260− v <- identifier

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

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

263− else

264− fail "invalid boolAtom"

265−

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

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

266247

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

268249relationAtomExprP = 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/bin/TutorialD/tutd.hs+18−14

@@ -5,10 +5,8 @@ import ProjectM36.Client

55import ProjectM36.Server.ParseArgs

66import ProjectM36.Server

77import System.IO

8−import GHC.IO.Encoding

98import Options.Applicative

109import System.Exit

11−import Control.Monad

1210#if __GLASGOW_HASKELL__ < 804

1311import Data.Monoid

1412#endif

@@ -22,7 +20,7 @@ import qualified Data.Text as T

2220

2321parseArgs :: Parser InterpreterConfig

2422parseArgs = LocalInterpreterConfig <$> parsePersistenceStrategy <*> parseHeadName <*> parseTutDExec <*> many parseGhcPkgPath <*> parseCheckFS <|>

25− RemoteInterpreterConfig <$> parseHostname "127.0.0.1" <*> parsePort defaultServerPort <*> parseDatabaseName <*> parseHeadName <*> parseTutDExec <*> parseCheckFS

23+ RemoteInterpreterConfig <$> parseNodeId <*> parseDatabaseName <*> parseHeadName <*> parseTutDExec <*> parseCheckFS

2624

2725parseHeadName :: Parser HeadName

2826parseHeadName = option auto (long "head" <>

@@ -31,6 +29,19 @@ parseHeadName = option auto (long "head" <>

3129 value "master"

3230 )

3331

32+parseNodeId :: Parser NodeId

33+parseNodeId = createNodeId <$>

34+ strOption (long "host" <>

35+ short 'h' <>

36+ help "Remote host name" <>

37+ metavar "HOSTNAME" <>

38+ value "127.0.0.1") <*>

39+ option auto (long "port" <>

40+ metavar "PORT NUMBER" <>

41+ short 'p' <>

42+ help "Remote port" <>

43+ value defaultServerPort)

44+

3445--just execute some tutd and exit

3546parseTutDExec :: Parser (Maybe TutorialDExec)

3647parseTutDExec = optional $ strOption (long "exec-tutd" <>

@@ -44,19 +55,19 @@ opts = info (parseArgs <**> helpOption) idm

4455

4556connectionInfoForConfig :: InterpreterConfig -> ConnectionInfo

4657connectionInfoForConfig (LocalInterpreterConfig pStrategy _ _ ghcPkgPaths _) = InProcessConnectionInfo pStrategy outputNotificationCallback ghcPkgPaths

47−connectionInfoForConfig (RemoteInterpreterConfig remoteHost remotePort remoteDBName _ _ _) = RemoteConnectionInfo remoteDBName remoteHost (show remotePort) outputNotificationCallback

58+connectionInfoForConfig (RemoteInterpreterConfig remoteNodeId remoteDBName _ _ _) = RemoteProcessConnectionInfo remoteDBName remoteNodeId outputNotificationCallback

4859

4960headNameForConfig :: InterpreterConfig -> HeadName

5061headNameForConfig (LocalInterpreterConfig _ headn _ _ _) = headn

51−headNameForConfig (RemoteInterpreterConfig _ _ _ headn _ _) = headn

62+headNameForConfig (RemoteInterpreterConfig _ _ headn _ _) = headn

5263

5364execTutDForConfig :: InterpreterConfig -> Maybe String

5465execTutDForConfig (LocalInterpreterConfig _ _ t _ _) = t

55−execTutDForConfig (RemoteInterpreterConfig _ _ _ _ t _) = t

66+execTutDForConfig (RemoteInterpreterConfig _ _ _ t _) = t

5667

5768checkFSForConfig :: InterpreterConfig -> Bool

5869checkFSForConfig (LocalInterpreterConfig _ _ _ _ c) = c

59−checkFSForConfig (RemoteInterpreterConfig _ _ _ _ _ c) = c

70+checkFSForConfig (RemoteInterpreterConfig _ _ _ _ c) = c

6071

6172persistenceStrategyForConfig :: InterpreterConfig -> Maybe PersistenceStrategy

6273persistenceStrategyForConfig (LocalInterpreterConfig strat _ _ _ _) = Just strat

@@ -75,15 +86,8 @@ printWelcome = do

7586 putStrLn "A full tutorial is available at:"

7687 putStrLn "https://github.com/agentm/project-m36/blob/master/docs/tutd_tutorial.markdown"

7788

78−-- | If the locale is set to ASCII, upgrade it to UTF-8 because tutd outputs UTF-8-encoded attributes. This is especially important in light docker images where the locale data may be missing.

79−setLocaleIfNecessary :: IO ()

80−setLocaleIfNecessary = do

81− l <- getLocaleEncoding

82− when (textEncodingName l == "ASCII") (setLocaleEncoding utf8)

83−

8489main :: IO ()

8590main = do

86− setLocaleIfNecessary

8791 interpreterConfig <- execParser opts

8892 let connInfo = connectionInfoForConfig interpreterConfig

8993 fscheck <- checkFSType (checkFSForConfig interpreterConfig) (fromMaybe NoPersistence (persistenceStrategyForConfig interpreterConfig))

src/lib/ProjectM36/Arbitrary.hs+1−6

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

99import ProjectM36.Attribute (atomType)

1010import ProjectM36.DataConstructorDef as DCD

1111import ProjectM36.DataTypes.Interval

12−import ProjectM36.Relation

1312import qualified Data.Vector as V

1413import Data.Text (Text)

1514import Test.QuickCheck

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

4948

5049arbitrary' BoolAtomType =

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

52−

53−arbitrary' RelationalExprAtomType =

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

55−

5651arbitrary' constructedAtomType@(ConstructedAtomType tcName tvMap)

5752 --special-casing for Interval type

5853 | isIntervalAtomType constructedAtomType = createArbitraryInterval (intervalSubType constructedAtomType)

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

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

8580arbitraryRelationTuple attris = do

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

8883 case sequence listOfMaybeAType of

8984 Left err -> pure $ Left err

9085 Right listOfAttr -> do

src/lib/ProjectM36/Atom.hs−1

@@ -20,7 +20,6 @@ atomToText (DayAtom i) = (T.pack . show) i

2020atomToText (DateTimeAtom i) = (T.pack . show) i

2121atomToText (ByteStringAtom i) = (T.pack . show) i

2222atomToText (BoolAtom i) = (T.pack . show) i

23−atomToText (RelationalExprAtom re) = (T.pack . show) re

2423

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

2625atomToText (ConstructedAtom dConsName typ atoms)

src/lib/ProjectM36/AtomFunction.hs+6−7

@@ -1,7 +1,6 @@

11{-# LANGUAGE CPP #-}

22module ProjectM36.AtomFunction where

33import ProjectM36.Base

4−import ProjectM36.Serialise.Base ()

54import ProjectM36.Error

65import ProjectM36.Relation

76import ProjectM36.AtomType

@@ -11,7 +10,7 @@ import qualified ProjectM36.Attribute as A

1110import qualified Data.HashSet as HS

1211import qualified Data.Text as T

1312import qualified Data.ByteString.Lazy as BL

14−import Codec.Winery

13+import Data.Binary as B

1514

1615foldAtomFuncType :: AtomType -> AtomType -> [AtomType]

1716--the underscore in the attribute name means that any attributes are acceptable

@@ -92,10 +91,10 @@ atomFunctionsAsRelation funcs = mkRelationFromList attrs tups

9291

9392--for calculating the merkle hash

9493hashBytes :: AtomFunction -> BL.ByteString

95−hashBytes func = BL.fromChunks [serialise (atomFuncName func),

96− serialise (atomFuncType func),

97− bodyBin

98− ]

94+hashBytes func = mconcat [B.encode (atomFuncName func),

95+ B.encode (atomFuncType func),

96+ bodyBin

97+ ]

9998 where

10099 bodyBin = case atomFuncBody func of

101− AtomFunctionBody mScript _ -> serialise mScript

100+ AtomFunctionBody mScript _ -> B.encode mScript

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

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

11{-# LANGUAGE DeriveGeneric, DeriveAnyClass #-}

22module ProjectM36.AtomFunctionError where

3+import Data.Binary

34import GHC.Generics

45import Control.DeepSeq

56import Data.Text

@@ -13,5 +14,5 @@ data AtomFunctionError = AtomFunctionUserError String |

1314 AtomTypeDoesNotSupportOrderingError Text |

1415 AtomTypeDoesNotSupportIntervalError Text |

1516 AtomFunctionBytesDecodingError String

16− deriving(Generic, Eq, Show, NFData)

17+ deriving(Generic, Eq, Show, Binary, NFData)

1718

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

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

211211

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

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

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

216216

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

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

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

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

297297resolveTypesInTuple 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))

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

300300

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

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

314314 _ -> Right ()

315315validateAtomType (RelationAtomType attrs) tConss =

316316 mapM_ (\attr ->

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

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

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

319319validateAtomType _ _ = pure ()

320320

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

325325 else

326326 pure ()

327327 where

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

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

329329

330330--ensure that all type vars are fully resolved

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

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

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

359359 Left $ AtomTypeMismatchError x y

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

362362 return x

363363atomTypeVerify x y = if x == y then

364364 Right x

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

375375 (M.toAscList b)

376376

377377prettyAtomType :: 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` "}"

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

380380 where

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

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

442442 DateTimeAtomType -> True

443443 ByteStringAtomType -> True

444444 BoolAtomType -> True

445− RelationalExprAtomType -> True

446445 RelationAtomType attrs -> isResolvedAttributes attrs

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

448447 TypeVariableType _ -> False

449448

450449isResolvedAttributes :: Attributes -> Bool

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

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

452451

453452isResolvedAttribute :: Attribute -> Bool

454453isResolvedAttribute = isResolvedType . A.atomType

src/lib/ProjectM36/Atomable.hs+20−4

@@ -13,16 +13,29 @@ import qualified Data.Map as M

1313import qualified Data.Text as T

1414import qualified Data.Vector as V

1515import Control.DeepSeq (NFData)

16+import Data.Binary

1617import Control.Applicative

1718import Data.Time.Calendar

1819import Data.ByteString (ByteString)

1920import Data.Time.Clock

2021import Data.Proxy

2122import qualified Data.List.NonEmpty as NE

22−import Codec.Winery

2323

24+--also add haskell scripting atomable support

25+--rename this module to Atomable along with test

26+

27+{-

28+data Test1T = Test1C Int

29+ deriving (Generic, Show, Eq, Binary, NFData, Atomable)

30+

31+data Test2T = Test2C Int Int

32+ deriving (Generic, Show, Eq, Binary, NFData, Atomable)

33+

34+data Test3T = Test3Ca | Test3Cb

35+ deriving (Generic, Show, Eq, Binary, NFData, Atomable)

36+-}

2437-- | All database values ("atoms") adhere to the 'Atomable' typeclass. This class is derivable allowing new datatypes to be easily marshaling between Haskell values and database values.

25−class (Eq a, NFData a, Serialise a, Show a) => Atomable a where

38+class (Eq a, NFData a, Binary a, Show a) => Atomable a where

2639 toAtom :: a -> Atom

2740 default toAtom :: (Generic a, AtomableG (Rep a)) => a -> Atom

2841 toAtom v = toAtomG (from v) (toAtomTypeG (from v))

@@ -152,6 +165,10 @@ instance Atomable a => Atomable (NE.NonEmpty a) where

152165 toAtomType _ = ConstructedAtomType "NonEmptyList" (M.singleton "a" (toAtomType (Proxy :: Proxy a)))

153166 toAddTypeExpr _ = NoOperation

154167

168+#if !MIN_VERSION_binary(0,8,4)

169+instance Binary a => Binary (NE.NonEmpty a)

170+#endif

171+

155172-- Generics

156173class AtomableG g where

157174 --type AtomTG g

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

235252typeToTypeConstructor x@DateTimeAtomType = PrimitiveTypeConstructor "DateTime" x

236253typeToTypeConstructor x@ByteStringAtomType = PrimitiveTypeConstructor "ByteString" x

237254typeToTypeConstructor x@BoolAtomType = PrimitiveTypeConstructor "Bool" x

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

239255typeToTypeConstructor (RelationAtomType attrs)

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

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

241257 where

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

243259typeToTypeConstructor (ConstructedAtomType tcName tvMap)

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

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

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

21module ProjectM36.Attribute where

32import ProjectM36.Base

43import ProjectM36.Error

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

1110import Data.Either

1211

1312arity :: Attributes -> Int

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

15−

16−instance Semigroup Attributes where

17− attrsA <> attrsB =

18− case joinAttributes attrsA attrsB of

19− Left err -> error (show err)

20− Right attrs' -> attrs'

21−

22−instance Monoid Attributes where

23− mempty = Attributes {

24− attributesVec = mempty

25− --,attributeSet = mempty

26− }

13+arity = V.length

2714

2815emptyAttributes :: Attributes

29−emptyAttributes = mempty

16+emptyAttributes = V.empty

3017

3118null :: Attributes -> Bool

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

33−

34−singleton :: Attribute -> Attributes

35−singleton attr = Attributes {

36− attributesVec = V.singleton attr

37− --,attributesSet = HS.singleton attr

38− }

39−

40−toList :: Attributes -> [Attribute]

41−toList attrs = V.toList (attributesVec attrs)

19+null = V.null

4220

4321attributesFromList :: [Attribute] -> Attributes

44−attributesFromList attrsL = Attributes {

45− attributesVec = vec

46− --,attributesSet = hset

47− }

48− where

49− vec = if length attrsL == HS.size hset then

50− --fast path- no duplicates

51− V.fromList attrsL

52− else

53− --duplicate detected, uniqueify while maintaining original ordering

54− V.fromList uniquedL

55− hset = HS.fromList attrsL

56− uniquedL = fst $ foldr (\attr acc@(l,s) ->

57− if HS.member attr s then

58− acc

59− else

60− (l ++ [attr], HS.insert attr s))

61− ([],mempty) attrsL

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

6223

6324attributeName :: Attribute -> AttributeName

6425attributeName (Attribute name _) = name

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

6728atomType (Attribute _ atype) = atype

6829

6930atomTypes :: Attributes -> V.Vector AtomType

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

31+atomTypes = V.map atomType

7132

7233atomTypesList :: Attributes -> [AtomType]

7334atomTypesList = V.toList . atomTypes

7435

36+--hm- no error-checking here

7537addAttribute :: Attribute -> Attributes -> Attributes

76−addAttribute attr attrs = attrs <> singleton attr

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

7739

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

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

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

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

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

8547 attrNames2 = V.map attributeName attrs2

8648 uniqueOverlappingAttributes = vectorUniqueify overlappingAttributes

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

10650

10751addAttributes :: Attributes -> Attributes -> Attributes

108−addAttributes = (<>)

109−

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

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

52+addAttributes = (V.++)

11253

11354deleteAttributeName :: AttributeName -> Attributes -> Attributes

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

115−

116−deleteAttributeNames :: S.Set AttributeName -> Attributes -> Attributes

117−deleteAttributeNames attrNames attrs = Attributes {

118− attributesVec = vec

119− }

120− where

121− vec = V.filter attrFilter (attributesVec attrs)

122− attrFilter attr = S.notMember (attributeName attr) attrNames

55+deleteAttributeName attrName = V.filter (\attr -> attributeName attr /= attrName)

12356

12457renameAttribute :: AttributeName -> Attribute -> Attribute

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

12659

12760renameAttributes :: AttributeName -> AttributeName -> Attributes -> Attributes

128−renameAttributes oldAttrName newAttrName attrs = Attributes {

129− attributesVec = vec

130− }

61+renameAttributes oldAttrName newAttrName = V.map renamer

13162 where

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

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

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

13464 renameAttribute newAttrName attr

13565 else

13666 attr

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

14171 return atype

14272

14373attributeForName :: 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

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

14676 Just attr -> Right attr

14777

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

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

16090

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

162−attributesForNames attrNameSet attrs = Attributes {

163− attributesVec = vec

164− }

92+attributesForNames attrNameSet = V.filter filt

16593 where

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

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

16895

16996attributeNameSet :: 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

17198

17299attributeNames :: Attributes -> V.Vector AttributeName

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

100+attributeNames = V.map attributeName

174101

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

176103attributesContained :: Attributes -> Attributes -> Bool

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

191118

192119-- useful for display

193120orderedAttributes :: 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)

195122

196123orderedAttributeNames :: Attributes -> [AttributeName]

197124orderedAttributeNames attrs = map attributeName (orderedAttributes attrs)

198125

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

201127attributesDifference :: 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)

203129 where

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

219131

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

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

222134

223135--check that each attribute only appears once

224136verifyAttributes :: Attributes -> Either RelationalError Attributes

225−verifyAttributes attrs =

226− if vecSet == attributesSet attrs then

227− pure attrs

228− else

229− Left (TupleAttributeTypeMismatchError diffAttrs)

137+verifyAttributes attrs = if collapsedAttrs /= attrs then

138+ Left (TupleAttributeTypeMismatchError (attributesDifference collapsedAttrs attrs))

139+ else

140+ Right attrs

230141 where

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

232− diffSet = HS.difference vecSet (attributesSet attrs) <> HS.difference (attributesSet attrs) vecSet

233− diffAttrs = Attributes {

234− attributesVec = V.fromList (HS.toList diffSet)

235− --,attributesSet = diffSet

236− }

237−

238−--used in Generics derivation for ADTs without named attributes- not to be used elsewhere

239−--drop first n attributes from vector representation

240−drop :: Int -> Attributes -> Attributes

241−drop c attrs = Attributes { attributesVec = vec

242− }

243− where

244− vec = V.drop c (attributesVec attrs)

245−

246−

247−-- use this in preference to attributesEqual when the attribute ordering matters such as during tuple unions

248−attributesAndOrderEqual :: Attributes -> Attributes -> Bool

249−attributesAndOrderEqual a b = attributesVec a == attributesVec b

142+ collapsedAttrs = vectorUniqueify attrs

250143

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

252144attributesEqual :: Attributes -> Attributes -> Bool

253−attributesEqual attrsA attrsB =

254− attributesVec attrsA == attributesVec attrsB ||

255− attributesSet attrsA == attributesSet attrsB

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

256146

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

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

259−

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

260149

261150-- | Left-biased union of attributes.

262151union :: Attributes -> Attributes -> Attributes

263−union attrsA attrsB = Attributes {

264− attributesVec = vec

265− --,attributesSet = hset

266− }

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

267153 where

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

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

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

270155

271156intersection :: Attributes -> Attributes -> Attributes

272−intersection attrsA attrsB = Attributes {

273− attributesVec = vec

274− --,attributesSet = hset

275− }

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

276158 where

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

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

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

src/lib/ProjectM36/Base.hs+108−100

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

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

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

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

44module ProjectM36.Base where

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

66import ProjectM36.AtomFunctionError

77import ProjectM36.MerkleHash

9−import Data.Functor.Foldable.TH

109import qualified Data.Map as M

1110import qualified Data.HashSet as HS

1211import Data.Hashable (Hashable, hashWithSalt)

@@ -19,17 +18,16 @@ import GHC.Stack

1918import qualified Data.Vector as V

2019import qualified Data.List as L

2120import Data.Text (Text,unpack)

21+import Data.Binary

22+import Data.Vector.Binary()

2223import Data.Time.Clock

24+import Data.Time.Clock.POSIX

25+import Data.Time.Calendar (Day,toGregorian,fromGregorian)

2326import Data.Hashable.Time ()

24−import Data.Time.Calendar (Day)

2527import Data.Typeable

2628import Data.ByteString (ByteString)

2729import qualified Data.List.NonEmpty as NE

28−import Data.Vector.Instances ()

29−

3030type StringType = Text

31−

32−type DatabaseName = String

3331

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

3533data Atom = IntegerAtom Integer |

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

4139 ByteStringAtom ByteString |

4240 BoolAtom Bool |

4341 RelationAtom Relation |

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

4542 ConstructedAtom DataConstructorName AtomType [Atom]

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

43+ deriving (Eq, Show, Binary, Typeable, NFData, Generic)

4744

4845instance Hashable Atom where

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

@@ -57,7 +54,16 @@ instance Hashable Atom where

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

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

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

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

57+

58+instance Binary UTCTime where

59+ put utc = put $ toRational (utcTimeToPOSIXSeconds utc)

60+ get = posixSecondsToUTCTime . fromRational <$> (get :: Get Rational)

61+

62+instance Binary Day where

63+ put day = put $ toGregorian day

64+ get = do

65+ (y,m,d) <- get :: Get (Integer, Int, Int)

66+ return (fromGregorian y m d)

6167

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

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

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

7177 BoolAtomType |

7278 RelationAtomType Attributes |

7379 ConstructedAtomType TypeConstructorName TypeVarMap |

74− RelationalExprAtomType |

7580 TypeVariableType TypeVarName

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

82+ deriving (Eq, NFData, Generic, Binary, Show)

7883

7984instance Ord AtomType where

8085 compare = undefined

81−

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

86+

8387type TypeVarMap = M.Map TypeVarName AtomType

8488

8589instance Hashable TypeVarMap where

@@ -94,37 +98,25 @@ isRelationAtomType _ = False

9498type AttributeName = StringType

9599

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

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

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

98102

99103instance Hashable Attribute where

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

101105

102−type AttributesHash = Int

103−

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

105−newtype Attributes = Attributes {

106− attributesVec :: V.Vector Attribute

107− --,attributesSet :: HS.HashSet Attribute --compare with this generated in heap profile and benchmarks

108− }

109− deriving (NFData, Read, Hashable, Generic)

110−

111−attributesSet :: Attributes -> HS.HashSet Attribute

112−attributesSet = HS.fromList . V.toList . attributesVec

113−

114−instance Show Attributes where

115− show attrs = "attributesFromList [" <> L.intercalate ", " (map (\attr -> "(" <> show attr <> ")") (V.toList (attributesVec attrs))) <> "]"

116−

117−--when attribute ordering is irrelevant

118−instance Eq Attributes where

119− attrsA == attrsB =

120− attributesVec attrsA == attributesVec attrsB ||

121− attributesSet attrsA == attributesSet attrsB

107+type Attributes = V.Vector Attribute

122108

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

110+attributesEqual :: Attributes -> Attributes -> Bool

111+attributesEqual attrs1 attrs2 = attrsAsSet attrs1 == attrsAsSet attrs2

112+ where

113+ attrsAsSet = HS.fromList . V.toList

114+

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

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

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

125117

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

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

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

128120

129121instance Read Relation where

130122 readsPrec = error "relation read not supported"

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

140132instance Hashable RelationTuple where

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

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

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

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

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

145137 else

146138 salt `hashWithSalt`

147139 sortedAttrs `hashWithSalt`

@@ -152,23 +144,25 @@ instance Hashable RelationTuple where

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

153145

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

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

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

148+

149+instance Binary RelationTuple

156150

157151instance Eq RelationTuple where

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

159− attrs1 == attrs2 && atomsEqual

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

160153 where

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

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

162155 Nothing -> Nothing

163156 Just index -> tupVec V.!? index

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

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

165158

166159instance NFData RelationTuple where rnf = genericRnf

167160

161+

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

169163

170164instance Eq Relation where

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

165+ Relation attrs1 tupSet1 == Relation attrs2 tupSet2 = attributesEqual attrs1 attrs2 && tupSet1 == tupSet2

172166

173167instance NFData Relation where rnf = genericRnf

174168

@@ -179,6 +173,8 @@ instance Hashable Relation where

179173 where

180174 sortedAttrs = map snd (sortedAttributesIndices attrs)

181175

176+instance Binary Relation

177+

182178-- | Used to represent the number of tuples in a relation.

183179data RelationCardinality = Countable | Finite Int deriving (Eq, Show, Generic, Ord)

184180

@@ -223,15 +219,17 @@ data RelationalExprBase a =

223219 --Summarize :: AtomExpr -> AttributeName -> RelationalExpr -> RelationalExpr -> RelationalExpr -- a special case of Extend

224220 --Evaluate relationalExpr with scoped views

225221 With [(WithNameExprBase a, RelationalExprBase a)] (RelationalExprBase a)

226− deriving (Show, Read, Eq, Generic, NFData, Foldable, Functor, Traversable)

222+ deriving (Show, Eq, Generic, NFData, Foldable, Functor, Traversable)

223+

224+instance Binary RelationalExpr

227225

228−instance Hashable RelationalExpr

229−

230226data WithNameExprBase a = WithNameExpr RelVarName a

231− deriving (Show, Read, Eq, Generic, NFData, Foldable, Functor, Traversable, Hashable)

227+ deriving (Show, Eq, Generic, NFData, Foldable, Functor, Traversable)

232228

233229type WithNameExpr = WithNameExprBase ()

234230

231+instance Binary WithNameExpr

232+

235233type GraphRefWithNameExpr = WithNameExprBase GraphRefTransactionMarker

236234

237235type NotificationName = StringType

@@ -243,22 +241,22 @@ data Notification = Notification {

243241 reportOldExpr :: RelationalExpr, --run the expression in the pre-change context

244242 reportNewExpr :: RelationalExpr --run the expression in the post-change context

245243 }

246− deriving (Show, Eq, Generic, NFData)

244+ deriving (Show, Eq, Binary, Generic, NFData)

247245

248246type TypeVarName = StringType

249247

250248-- | Metadata definition for type constructors such as @data Either a b@.

251249data TypeConstructorDef = ADTypeConstructorDef TypeConstructorName [TypeVarName] |

252250 PrimitiveTypeConstructorDef TypeConstructorName AtomType

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

251+ deriving (Show, Generic, Binary, Eq, NFData)

254252

255253-- | Found in data constructors and type declarations: Left (Either Int Text) | Right Int

256254type TypeConstructor = TypeConstructorBase ()

257255data TypeConstructorBase a = ADTypeConstructor TypeConstructorName [TypeConstructor] |

258− PrimitiveTypeConstructor TypeConstructorName AtomType |

259− RelationAtomTypeConstructor [AttributeExprBase a] |

260− TypeVariable TypeVarName

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

256+ PrimitiveTypeConstructor TypeConstructorName AtomType |

257+ RelationAtomTypeConstructor [AttributeExprBase a] |

258+ TypeVariable TypeVarName

259+ deriving (Show, Generic, Binary, Eq, NFData)

262260

263261type TypeConstructorMapping = [(TypeConstructorDef, DataConstructorDefs)]

264262

@@ -268,20 +266,20 @@ type DataConstructorName = StringType

268266type AtomTypeName = StringType

269267

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

269+data DataConstructorDef = DataConstructorDef DataConstructorName [DataConstructorDefArg] deriving (Eq, Show, Binary, Generic, NFData)

272270

273271type DataConstructorDefs = [DataConstructorDef]

274272

275273data DataConstructorDefArg = DataConstructorDefTypeConstructorArg TypeConstructor |

276274 DataConstructorDefTypeVarNameArg TypeVarName

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

275+ deriving (Show, Generic, Binary, Eq, NFData)

278276

279277type InclusionDependencies = M.Map IncDepName InclusionDependency

280278type RelationVariables = M.Map RelVarName GraphRefRelationalExpr

281279

282280data GraphRefTransactionMarker = TransactionMarker TransactionId |

283281 UncommittedContextMarker

284− deriving (Eq, Show, Generic, NFData, Ord)

282+ deriving (Eq, Show, Binary, Generic, NFData, Ord)

285283

286284-- a fundamental relational expr to which other relational expressions compile

287285type GraphRefRelationalExpr = RelationalExprBase GraphRefTransactionMarker

@@ -292,18 +290,17 @@ type Subschemas = M.Map SchemaName Schema

292290

293291-- | Every transaction has one concrete database context and any number of isomorphic subschemas.

294292data Schemas = Schemas DatabaseContext Subschemas

295− deriving (Generic)

296293

297294-- | The DatabaseContext is a snapshot of a database's evolving state and contains everything a database client can change over time.

298295-- I spent some time thinking about whether the VirtualDatabaseContext/Schema and DatabaseContext data constructors should be the same constructor, but that would allow relation variables to be created in a "virtual" context which would appear to defeat the isomorphisms of the contexts. It should be possible to switch to an alternative schema to view the same equivalent information without information loss. However, allowing all contexts to reference another context while maintaining its own relation variables, new types, etc. could be interesting from a security perspective. For example, if a user creates a new relvar in a virtual context, then does it necessarily appear in all linked contexts? After deliberation, I think the relvar should appear in *all* linked contexts to retain the isomorphic properties, even when the isomorphism is for a subset of the context. This hints that the IsoMorphs should allow for "fall-through"; that is, when a relvar is not defined in the virtual context (for morphing), then the lookup should fall through to the underlying context.

299296newtype Schema = Schema SchemaIsomorphs

300− deriving (Generic)

297+ deriving (Generic, Binary)

301298

302299data SchemaIsomorph = IsoRestrict RelVarName RestrictionPredicateExpr (RelVarName, RelVarName) |

303300 IsoRename RelVarName RelVarName |

304301 IsoUnion (RelVarName, RelVarName) RestrictionPredicateExpr RelVarName --maps two relvars to one relvar

305302 -- IsoTypeConstructor in morphAttrExpr

306− deriving (Generic, Show)

303+ deriving (Generic, Binary, Show)

307304

308305type SchemaIsomorphs = [SchemaIsomorph]

309306

@@ -319,7 +316,9 @@ data DatabaseContext = DatabaseContext {

319316type IncDepName = StringType

320317

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

319+data InclusionDependency = InclusionDependency RelationalExpr RelationalExpr deriving (Show, Eq, Generic, NFData)

320+

321+instance Binary InclusionDependency

323322

324323type AttributeNameAtomExprMap = M.Map AttributeName AtomExpr

325324

@@ -328,10 +327,10 @@ type DatabaseContextExprName = StringType

328327

329328type DatabaseContextExpr = DatabaseContextExprBase ()

330329

331−instance Hashable DatabaseContextExpr

332−

333330type GraphRefDatabaseContextExpr = DatabaseContextExprBase GraphRefTransactionMarker

334331

332+instance Binary GraphRefDatabaseContextExpr

333+

335334-- | Database context expressions modify the database context.

336335data DatabaseContextExprBase a =

337336 NoOperation |

@@ -359,10 +358,9 @@ data DatabaseContextExprBase a =

359358 ExecuteDatabaseContextFunction DatabaseContextFunctionName [AtomExprBase a] |

360359

361360 MultipleExpr [DatabaseContextExprBase a]

362− deriving (Show, Read, Eq, Generic, NFData)

361+ deriving (Show, Eq, Generic)

363362

364−instance Hashable (M.Map AttributeName AtomExpr) where

365− hashWithSalt salt m = salt `hashWithSalt` M.toList m

363+instance Binary DatabaseContextExpr

366364

367365type ObjModuleName = StringType

368366type ObjFunctionName = StringType

@@ -374,7 +372,7 @@ data DatabaseContextIOExprBase a =

374372 AddDatabaseContextFunction DatabaseContextFunctionName [TypeConstructor] DatabaseContextFunctionBodyScript |

375373 LoadDatabaseContextFunctions ObjModuleName ObjFunctionName FilePath |

376374 CreateArbitraryRelation RelVarName [AttributeExprBase a] Range

377− deriving (Show, Eq, Generic)

375+ deriving (Show, Eq, Generic, Binary)

378376

379377type GraphRefDatabaseContextIOExpr = DatabaseContextIOExprBase GraphRefTransactionMarker

380378

@@ -382,8 +380,6 @@ type DatabaseContextIOExpr = DatabaseContextIOExprBase ()

382380

383381type RestrictionPredicateExpr = RestrictionPredicateExprBase ()

384382

385−instance Hashable RestrictionPredicateExpr

386−

387383type GraphRefRestrictionPredicateExpr = RestrictionPredicateExprBase GraphRefTransactionMarker

388384

389385-- | 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 +391,9 @@ data RestrictionPredicateExprBase a =

395391 RelationalExprPredicate (RelationalExprBase a) | --type must be same as true and false relations (no attributes)

396392 AtomExprPredicate (AtomExprBase a) | --atom must evaluate to boolean

397393 AttributeEqualityPredicate AttributeName (AtomExprBase a) -- relationalexpr must result in relation with single tuple

398− deriving (Show, Read, Eq, Generic, NFData, Foldable, Functor, Traversable)

394+ deriving (Show, Eq, Generic, NFData, Foldable, Functor, Traversable)

395+

396+instance Binary RestrictionPredicateExpr

399397

400398-- child + parent links

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

@@ -405,7 +403,6 @@ type TransactionHeads = M.Map HeadName Transaction

405403

406404-- | The transaction graph is the global database's state which references every committed transaction.

407405data TransactionGraph = TransactionGraph TransactionHeads (S.Set Transaction)

408− deriving Generic

409406

410407transactionHeadsForGraph :: TransactionGraph -> TransactionHeads

411408transactionHeadsForGraph (TransactionGraph hs _) = hs

@@ -428,11 +425,12 @@ data TransactionInfo = TransactionInfo TransactionId TransactionDiffs UTCTime |

428425 deriving (Show, Generic)

429426-}

430427

428+instance Binary TransactionInfo

429+

431430-- | Every set of modifications made to the database are atomically committed to the transaction graph as a transaction.

432431type TransactionId = UUID

433432

434433data Transaction = Transaction TransactionId TransactionInfo Schemas

435− deriving Generic

436434

437435-- | The disconnected transaction represents an in-progress workspace used by sessions before changes are committed. This is similar to git's "index". After a transaction is committed, it is "connected" in the transaction graph and can no longer be modified.

438436data DisconnectedTransaction = DisconnectedTransaction TransactionId Schemas DirtyFlag

@@ -456,8 +454,6 @@ instance Ord Transaction where

456454

457455type AtomExpr = AtomExprBase ()

458456

459−instance Hashable AtomExpr

460−

461457type GraphRefAtomExpr = AtomExprBase GraphRefTransactionMarker

462458

463459-- | An atom expression represents an action to take when extending a relation or when statically defining a relation or a new tuple.

@@ -466,18 +462,19 @@ data AtomExprBase a = AttributeAtomExpr AttributeName |

466462 FunctionAtomExpr AtomFunctionName [AtomExprBase a] a |

467463 RelationAtomExpr (RelationalExprBase a) |

468464 ConstructedAtomExpr DataConstructorName [AtomExprBase a] a

469− deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable)

465+ deriving (Eq,Show,Generic, NFData, Foldable, Functor, Traversable)

470466

467+instance Binary AtomExpr

468+

471469-- | Used in tuple creation when creating a relation.

472470data ExtendTupleExprBase a = AttributeExtendTupleExpr AttributeName (AtomExprBase a)

473− deriving (Show, Read, Eq, Generic, NFData, Foldable, Functor, Traversable)

471+ deriving (Show, Eq, Generic, NFData, Foldable, Functor, Traversable)

474472

475473type ExtendTupleExpr = ExtendTupleExprBase ()

476−

477−instance Hashable ExtendTupleExpr

478−

479474type GraphRefExtendTupleExpr = ExtendTupleExprBase GraphRefTransactionMarker

480475

476+instance Binary ExtendTupleExpr

477+

481478--enumerates the list of functions available to be run as part of tuple expressions

482479type AtomFunctions = HS.HashSet AtomFunction

483480

@@ -488,7 +485,6 @@ type AtomFunctionBodyScript = StringType

488485type AtomFunctionBodyType = [Atom] -> Either AtomFunctionError Atom

489486

490487data AtomFunctionBody = AtomFunctionBody (Maybe AtomFunctionBodyScript) AtomFunctionBodyType

491− deriving Generic

492488

493489instance NFData AtomFunctionBody where

494490 rnf (AtomFunctionBody mScript _) = rnf mScript

@@ -523,17 +519,14 @@ data AttributeNamesBase a = AttributeNames (S.Set AttributeName) |

523519 UnionAttributeNames (AttributeNamesBase a) (AttributeNamesBase a) |

524520 IntersectAttributeNames (AttributeNamesBase a) (AttributeNamesBase a) |

525521 RelationalExprAttributeNames (RelationalExprBase a) -- use attribute names from the relational expression's type

526− deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable)

527−

528−instance Hashable AttributeNames

529−

530−instance Hashable (S.Set AttributeName) where

531− hashWithSalt salt s = salt `hashWithSalt` S.toList s

522+ deriving (Eq, Show, Generic, NFData, Foldable, Functor, Traversable)

532523

533524type AttributeNames = AttributeNamesBase ()

534525

535526type GraphRefAttributeNames = AttributeNamesBase GraphRefTransactionMarker

536527

528+instance Binary AttributeNames

529+

537530-- | The persistence strategy is a global database option which represents how to persist the database in the filesystem, if at all.

538531data PersistenceStrategy = NoPersistence | -- ^ no filesystem persistence/memory-only database

539532 MinimalPersistence FilePath | -- ^ fsync off, not crash-safe

@@ -546,27 +539,27 @@ type GraphRefAttributeExpr = AttributeExprBase GraphRefTransactionMarker

546539-- | Create attributes dynamically.

547540data AttributeExprBase a = AttributeAndTypeNameExpr AttributeName TypeConstructor a |

548541 NakedAttributeExpr Attribute

549− deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable, Hashable)

542+ deriving (Eq, Show, Generic, Binary, NFData, Foldable, Functor, Traversable)

550543

551544-- | Dynamically create a tuple from attribute names and 'AtomExpr's.

552545newtype TupleExprBase a = TupleExpr (M.Map AttributeName (AtomExprBase a))

553− deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable)

554−

555−instance Hashable TupleExpr

546+ deriving (Eq, Show, Generic, NFData, Foldable, Functor, Traversable)

547+

548+instance Binary TupleExpr

556549

557550type TupleExpr = TupleExprBase ()

558551

559552type GraphRefTupleExpr = TupleExprBase GraphRefTransactionMarker

560553

561554data TupleExprsBase a = TupleExprs a [TupleExprBase a]

562− deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable)

563−

564−instance Hashable TupleExprs

555+ deriving (Eq, Show, Generic, NFData, Foldable, Functor, Traversable)

565556

566557type GraphRefTupleExprs = TupleExprsBase GraphRefTransactionMarker

567558

568559type TupleExprs = TupleExprsBase ()

569560

561+instance Binary TupleExprs

562+

570563data MergeStrategy =

571564 -- | After a union merge, the merge transaction is a result of union'ing relvars of the same name, introducing all uniquely-named relvars, union of constraints, union of atom functions, notifications, and types (unless the names and definitions collide, e.g. two types of the same name with different definitions)

572565 UnionMergeStrategy |

@@ -574,7 +567,7 @@ data MergeStrategy =

574567 UnionPreferMergeStrategy HeadName |

575568 -- | Similar to the our/theirs merge strategy in git, the merge transaction's context is identical to that of the last transaction in the selected branch.

576569 SelectedBranchMergeStrategy HeadName

577− deriving (Eq, Show, Generic, NFData)

570+ deriving (Eq, Show, Binary, Generic, NFData)

578571

579572type DatabaseContextFunctionName = StringType

580573

@@ -611,8 +604,7 @@ attrTypeVars (Attribute _ aType) = case aType of

611604 DateTimeAtomType -> S.empty

612605 ByteStringAtomType -> S.empty

613606 BoolAtomType -> S.empty

614− RelationalExprAtomType -> S.empty

615− (RelationAtomType attrs) -> S.unions (map attrTypeVars (V.toList (attributesVec attrs)))

607+ (RelationAtomType attrs) -> S.unions (map attrTypeVars (V.toList attrs))

616608 (ConstructedAtomType _ tvMap) -> M.keysSet tvMap

617609 (TypeVariableType nam) -> S.singleton nam

618610

@@ -635,12 +627,28 @@ atomTypeVars DayAtomType = S.empty

635627atomTypeVars DateTimeAtomType = S.empty

636628atomTypeVars ByteStringAtomType = S.empty

637629atomTypeVars BoolAtomType = S.empty

638−atomTypeVars RelationalExprAtomType = S.empty

639−atomTypeVars (RelationAtomType attrs) = S.unions (map attrTypeVars (V.toList (attributesVec attrs)))

630+atomTypeVars (RelationAtomType attrs) = S.unions (map attrTypeVars (V.toList attrs))

640631atomTypeVars (ConstructedAtomType _ tvMap) = M.keysSet tvMap

641632atomTypeVars (TypeVariableType nam) = S.singleton nam

642633

643634unimplemented :: HasCallStack => a

644−unimplemented = error "unimplemented"

635+unimplemented = undefined

636+

637+--for serializing GraphRefRelationalExpr as part of transaction serialization

638+instance Binary (TupleExprsBase GraphRefTransactionMarker)

639+

640+instance Binary (TupleExprBase GraphRefTransactionMarker)

641+

642+instance Binary GraphRefRelationalExpr

643+

644+instance Binary (AtomExprBase GraphRefTransactionMarker)

645+

646+instance Binary (AttributeNamesBase GraphRefTransactionMarker)

647+

648+instance Binary (RestrictionPredicateExprBase GraphRefTransactionMarker)

649+

650+instance Binary (ExtendTupleExprBase GraphRefTransactionMarker)

651+

652+instance Binary GraphRefWithNameExpr

645653

646−makeBaseFunctor ''RelationalExprBase

654+

src/lib/ProjectM36/Client.hs+293−163

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

1−{-# LANGUAGE DeriveGeneric, ScopedTypeVariables, MonoLocalBinds, DerivingVia #-}

1+{-# LANGUAGE DeriveAnyClass, DeriveGeneric, ScopedTypeVariables, MonoLocalBinds #-}

22{-|

33Module: ProjectM36.Client

@@ -9,7 +9,6 @@ module ProjectM36.Client

99 Connection(..),

1010 Port,

1111 Hostname,

12− ServiceName,

1312 DatabaseName,

1413 ConnectionError(..),

1514 connectProjectM36,

@@ -44,7 +43,6 @@ module ProjectM36.Client

4443 defaultDatabaseName,

4544 defaultRemoteConnectionInfo,

4645 defaultHeadName,

47− addClientNode,

4846 PersistenceStrategy(..),

4947 RelationalExpr,

5048 RelationalExprBase(..),

@@ -55,9 +53,11 @@ module ProjectM36.Client

5553 Attribute(..),

5654 MergeStrategy(..),

5755 attributesFromList,

56+ createNodeId,

5857 createSessionAtCommit,

5958 createSessionAtHead,

6059 closeSession,

60+ addClientNode,

6161 callTestTimeout_,

6262 RelationCardinality(..),

6363 TransactionGraphOperator(..),

@@ -67,6 +67,7 @@ module ProjectM36.Client

6767 TransGraphRelationalExpr,

6868 TransactionIdLookup(..),

6969 TransactionIdHeadBacktrack(..),

70+ NodeId(..),

7071 Atom(..),

7172 Session,

7273 SessionId,

@@ -106,7 +107,6 @@ module ProjectM36.Client

106107 ) where

107108import ProjectM36.Base hiding (inclusionDependencies) --defined in this module as well

108109import qualified ProjectM36.Base as B

109−import ProjectM36.Serialise.Error ()

110110import ProjectM36.Error

111111import ProjectM36.Atomable

112112import ProjectM36.AtomFunction as AF

@@ -134,16 +134,28 @@ import ProjectM36.Relation (typesAsRelation)

134134import ProjectM36.ScriptSession (initScriptSession, ScriptSession)

135135import qualified ProjectM36.Relation as R

136136import Control.Exception.Base

137−import Control.Concurrent.STM

138−import Control.Concurrent.Async

137+import GHC.Conc.Sync

138+

139+import Network.Transport (Transport(closeTransport))

140+#if MIN_VERSION_network_transport_tcp(0,7,0)

141+import Network.Transport.TCP (createTransport, defaultTCPParameters, defaultTCPAddr)

142+import Network.Transport.TCP.Internal (encodeEndPointAddress)

143+#elif MIN_VERSION_network_transport_tcp(0,6,0)

144+import Network.Transport.TCP (createTransport, defaultTCPParameters)

145+import Network.Transport.TCP.Internal (encodeEndPointAddress)

146+#else

147+import Network.Transport.TCP (encodeEndPointAddress, createTransport, defaultTCPParameters)

148+#endif

139149

150+import Control.Distributed.Process.Node (newLocalNode, initRemoteTable, runProcess, LocalNode, forkProcess, closeLocalNode)

151+import Control.Distributed.Process.Extras.Internal.Types (whereisRemote)

152+import Control.Distributed.Process.ManagedProcess.Client (call, safeCall)

140153import Data.Either (isRight)

141154import Data.UUID.V4 (nextRandom)

142155import Data.Word

143−import Data.Hashable

156+import Control.Distributed.Process (ProcessId, Process, receiveWait, send, match, NodeId(..), reconnect)

144157import Control.Exception (IOException, handle, AsyncException, throwIO, fromException, Exception)

145158import Control.Concurrent.MVar

146−import Codec.Winery hiding (Schema, schema)

147159import qualified Data.Map as M

148160#if MIN_VERSION_stm_containers(1,0,0)

149161import qualified StmContainers.Map as StmMap

@@ -155,19 +167,19 @@ import qualified STMContainers.Set as StmSet

155167import qualified ProjectM36.Session as Sess

156168import ProjectM36.Session

157169import ProjectM36.Sessions

170+import Data.Binary (Binary)

158171import GHC.Generics (Generic)

159172import Control.DeepSeq (force)

160173import System.IO

161174import Data.Time.Clock

162−import qualified Network.RPC.Curryer.Client as RPC

163−import qualified Network.RPC.Curryer.Server as RPC

164−import Network.Socket (Socket, AddrInfo(..), getAddrInfo, defaultHints, AddrInfoFlag(..), SocketType(..), ServiceName, hostAddressToTuple, SockAddr(..))

165−import GHC.Conc (unsafeIOToSTM)

175+import Data.Typeable

166176

167177type Hostname = String

168178

169179type Port = Word16

170180

181+type DatabaseName = String

182+

171183-- | The type for notifications callbacks in the client. When a registered notification fires due to a changed relational expression evaluation, the server propagates the notifications to the clients in the form of the callback.

172184type NotificationCallback = NotificationName -> EvaluatedNotification -> IO ()

173185

@@ -187,16 +199,15 @@ data RequestTimeoutException = RequestTimeoutException

187199

188200instance Exception RequestTimeoutException

189201

190−-- | Construct a 'ConnectionInfo' to describe how to make the 'Connection'. The database can be run within the current process or running remotely via RPC.

191−data ConnectionInfo = InProcessConnectionInfo PersistenceStrategy NotificationCallback [GhcPkgPath] |

192− RemoteConnectionInfo DatabaseName Hostname ServiceName NotificationCallback

202+-- | Construct a 'ConnectionInfo' to describe how to make the 'Connection'. The database can be run within the current process or running remotely via distributed-process.

203+data ConnectionInfo = InProcessConnectionInfo PersistenceStrategy NotificationCallback [GhcPkgPath]|

204+ RemoteProcessConnectionInfo DatabaseName NodeId NotificationCallback

193205

194206type EvaluatedNotifications = M.Map NotificationName EvaluatedNotification

195207

196208-- | Used for callbacks from the server when monitored changes have been made.

197209newtype NotificationMessage = NotificationMessage EvaluatedNotifications

198− deriving (Eq, Show, Generic)

199− deriving Serialise via WineryVariant NotificationMessage

210+ deriving (Binary, Eq, Show, Generic)

200211

201212-- | When a notification is fired, the 'reportOldExpr' is evaluated in the commit's pre-change context while the 'reportNewExpr' is evaluated in the post-change context and they are returned along with the original notification.

202213data EvaluatedNotification = EvaluatedNotification {

@@ -204,10 +215,13 @@ data EvaluatedNotification = EvaluatedNotification {

204215 reportOldRelation :: Either RelationalError Relation,

205216 reportNewRelation :: Either RelationalError Relation

206217 }

207− deriving (Eq, Show, Generic)

208− deriving Serialise via WineryRecord EvaluatedNotification

218+ deriving(Binary, Eq, Show, Generic)

209219

210220

221+-- | Create a 'NodeId' for use in connecting to a remote server using distributed-process.

222+createNodeId :: Hostname -> Port -> NodeId

223+createNodeId host port = NodeId $ encodeEndPointAddress host (show port) 1

224+

211225-- | Use this for connecting to remote servers on the default port.

212226defaultServerPort :: Port

213227defaultServerPort = 6543

@@ -222,16 +236,31 @@ defaultHeadName = "master"

222236

223237-- | Create a connection configuration which connects to the localhost on the default server port and default server database name. The configured notification callback is set to ignore all events.

224238defaultRemoteConnectionInfo :: ConnectionInfo

225−defaultRemoteConnectionInfo =

226− RemoteConnectionInfo defaultDatabaseName defaultServerHostname (show defaultServerPort) emptyNotificationCallback

239+defaultRemoteConnectionInfo = RemoteProcessConnectionInfo defaultDatabaseName (createNodeId "127.0.0.1" defaultServerPort) emptyNotificationCallback

227240

228−defaultServerHostname :: Hostname

229−defaultServerHostname = "localhost"

241+-- | The 'Connection' represents either local or remote access to a database. All operations flow through the connection.

242+type ClientNodes = StmSet.Set ProcessId

243+

244+-- internal structure specific to in-process connections

245+data InProcessConnectionConf = InProcessConnectionConf {

246+ ipPersistenceStrategy :: PersistenceStrategy,

247+ ipClientNodes :: ClientNodes,

248+ ipSessions :: Sessions,

249+ ipTransactionGraph :: TVar TransactionGraph,

250+ ipScriptSession :: Maybe ScriptSession,

251+ ipLocalNode :: LocalNode,

252+ ipTransport :: Transport, -- we hold onto this so that we can close it gracefully

253+ ipLocks :: Maybe (LockFile, MVar LockFileHash) -- nothing when NoPersistence

254+ }

230255

231−newtype RemoteConnectionConf = RemoteConnectionConf RPC.Connection

256+data RemoteProcessConnectionConf = RemoteProcessConnectionConf {

257+ rLocalNode :: LocalNode,

258+ rProcessId :: ProcessId, --remote processId

259+ rTransport :: Transport --the TCP socket transport

260+ }

232261

233262data Connection = InProcessConnection InProcessConnectionConf |

234− RemoteConnection RemoteConnectionConf

263+ RemoteProcessConnection RemoteProcessConnectionConf

235264

236265-- | There are several reasons why a connection can fail.

237266data ConnectionError = SetupDatabaseDirectoryError PersistenceError |

@@ -244,14 +273,46 @@ data ConnectionError = SetupDatabaseDirectoryError PersistenceError |

244273remoteDBLookupName :: DatabaseName -> String

245274remoteDBLookupName = (++) "db-"

246275

276+createLocalNode :: IO (LocalNode, Transport)

277+createLocalNode = do

278+#if MIN_VERSION_network_transport_tcp(0,7,0)

279+ eLocalTransport <- createTransport (defaultTCPAddr "127.0.0.1" "0") defaultTCPParameters

280+#elif MIN_VERSION_network_transport_tcp(0,6,0)

281+ eLocalTransport <- createTransport "127.0.0.1" "0" (\sn -> ("127.0.0.1", sn)) defaultTCPParameters

282+#else

283+ eLocalTransport <- createTransport "127.0.0.1" "0" defaultTCPParameters

284+#endif

285+ case eLocalTransport of

286+ Left err -> error ("failed to create transport: " ++ show err)

287+ Right localTransport -> do

288+ localNode <- newLocalNode localTransport initRemoteTable

289+ pure (localNode, localTransport)

290+

291+notificationListener :: NotificationCallback -> Process ()

292+notificationListener callback = do

293+ --pid <- getSelfPid

294+ --liftIO $ putStrLn $ "LISTENER THREAD START " ++ show pid

295+ _ <- forever $

296+ receiveWait [

297+ match (\(NotificationMessage eNots) ->

298+ --say $ "NOTIFICATION: " ++ show eNots

299+ -- when notifications are thrown, they are not adjusted for the current schema which could be problematic, but we don't have access to the current session here

300+ liftIO $ mapM_ (uncurry callback) (M.toList eNots)

301+ )

302+ ]

303+ --say "LISTENER THREAD EXIT"

304+ pure ()

305+

306+startNotificationListener :: LocalNode -> NotificationCallback -> IO ProcessId

307+startNotificationListener localNode callback = forkProcess localNode (notificationListener callback)

308+

247309createScriptSession :: [String] -> IO (Maybe ScriptSession)

248310createScriptSession ghcPkgPaths = do

249311 eScriptSession <- initScriptSession ghcPkgPaths

250312 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

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

252314 Right s -> pure (Just s)

253315

254−

255316-- | To create a 'Connection' to a remote or local database, create a 'ConnectionInfo' and call 'connectProjectM36'.

256317connectProjectM36 :: ConnectionInfo -> IO (Either ConnectionError Connection)

257318--create a new in-memory database/transaction graph

@@ -266,63 +327,42 @@ connectProjectM36 (InProcessConnectionInfo strat notificationCallback ghcPkgPath

266327 graphTvar <- newTVarIO freshGraph

267328 clientNodes <- StmSet.newIO

268329 sessions <- StmMap.newIO

330+ (localNode, transport) <- createLocalNode

331+ notificationPid <- startNotificationListener localNode notificationCallback

269332 mScriptSession <- createScriptSession ghcPkgPaths

270− notifAsync <- startNotificationListener clientNodes notificationCallback

333+

271334 let conn = InProcessConnection InProcessConnectionConf {

272335 ipPersistenceStrategy = strat,

273336 ipClientNodes = clientNodes,

274337 ipSessions = sessions,

275338 ipTransactionGraph = graphTvar,

276339 ipScriptSession = mScriptSession,

277− ipLocks = Nothing,

278− ipCallbackAsync = notifAsync

279− }

340+ ipLocalNode = localNode,

341+ ipTransport = transport,

342+ ipLocks = Nothing}

343+ addClientNode conn notificationPid

280344 pure (Right conn)

281345 MinimalPersistence dbdir -> connectPersistentProjectM36 strat NoDiskSync dbdir freshGraph notificationCallback ghcPkgPaths

282346 CrashSafePersistence dbdir -> connectPersistentProjectM36 strat FsyncDiskSync dbdir freshGraph notificationCallback ghcPkgPaths

283347

284−connectProjectM36 (RemoteConnectionInfo dbName hostName servicePort notificationCallback) = do

285− --TODO- add notification callback thread

286− let resolutionHints = defaultHints { addrFlags = [AI_NUMERICHOST, AI_NUMERICSERV],

287− addrSocketType = Stream

288− }

289− resolved <- getAddrInfo (Just resolutionHints) (Just hostName) (Just servicePort)

290− case resolved of

291− [] -> error ("DNS resolution failed for" <> hostName <> ":" <> servicePort)

292− addrInfo:_ -> do

293− --supports IPv4 only for now

294− let (SockAddrInet port addr) = addrAddress addrInfo

295− notificationHandlers =

296− [RPC.ClientAsyncRequestHandler $

297− \(NotificationMessage notifications') ->

298− forM_ (M.toList notifications') (uncurry notificationCallback)

299− ]

300− let connectExcHandler (e :: IOException) = pure $ Left (IOExceptionError e)

301− eConn <- (Right <$> RPC.connect notificationHandlers (hostAddressToTuple addr) port) `catch` connectExcHandler

302− case eConn of

303− Left err -> pure (Left err)

304− Right conn -> do

305− eRet <- RPC.call conn (Login dbName)

306− case eRet of

307− Left err -> error (show err)

308− Right False -> error "wtf"

309− Right True ->

310− --TODO handle connection errors!

311− pure (Right (RemoteConnection (RemoteConnectionConf conn)))

312−

313−--convert RPC errors into exceptions

314−convertRPCErrors :: RPC.ConnectionError -> IO a

315−convertRPCErrors err =

316− case err of

317− RPC.TimeoutError -> throw RequestTimeoutException

318− RPC.CodecError msg -> error $ "decoding message failed on server: " <> msg

319− RPC.ExceptionError msg -> error $ "server threw exception: " <> msg

320−

321−addClientNode :: Connection -> RPC.Locking Socket -> IO ()

322−addClientNode (RemoteConnection _) _ = error "addClientNode called on remote connection"

323−addClientNode (InProcessConnection conf) lockSock = atomically (StmSet.insert clientInfo (ipClientNodes conf))

324− where

325− clientInfo = RemoteClientInfo lockSock

348+connectProjectM36 (RemoteProcessConnectionInfo databaseName serverNodeId notificationCallback) = do

349+ connStatus <- newEmptyMVar

350+ (localNode, transport) <- createLocalNode

351+ let dbName = remoteDBLookupName databaseName

352+ --putStrLn $ "Connecting to " ++ show serverNodeId ++ " " ++ dbName

353+ notificationListenerPid <- startNotificationListener localNode notificationCallback

354+ runProcess localNode $ do

355+ --even a failed connection retains an open socket!

356+ mServerProcessId <- whereisRemote serverNodeId dbName

357+ case mServerProcessId of

358+ Nothing -> liftIO $ putMVar connStatus $ Left (NoSuchDatabaseByNameError databaseName)

359+ Just serverProcessId -> do

360+ loginConfirmation <- safeLogin (Login notificationListenerPid) serverProcessId

361+ if not loginConfirmation then

362+ liftIO $ putMVar connStatus (Left LoginError)

363+ else

364+ liftIO $ putMVar connStatus (Right $ RemoteProcessConnection RemoteProcessConnectionConf {rLocalNode = localNode, rProcessId = serverProcessId, rTransport = transport})

365+ takeMVar connStatus

326366

327367connectPersistentProjectM36 :: PersistenceStrategy ->

328368 DiskSync ->

@@ -347,34 +387,29 @@ connectPersistentProjectM36 strat sync dbdir freshGraph notificationCallback ghc

347387 tvarGraph <- newTVarIO graph'

348388 sessions <- StmMap.newIO

349389 clientNodes <- StmSet.newIO

390+ (localNode, transport) <- createLocalNode

350391 lockMVar <- newMVar digest

351− notifAsync <- startNotificationListener clientNodes notificationCallback

352392 let conn = InProcessConnection InProcessConnectionConf {

353393 ipPersistenceStrategy = strat,

354394 ipClientNodes = clientNodes,

355395 ipSessions = sessions,

356396 ipTransactionGraph = tvarGraph,

357397 ipScriptSession = mScriptSession,

358− ipLocks = Just (lockFileH, lockMVar),

359− ipCallbackAsync = notifAsync

398+ ipLocalNode = localNode,

399+ ipTransport = transport,

400+ ipLocks = Just (lockFileH, lockMVar)

360401 }

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

371402

403+ notificationPid <- startNotificationListener localNode notificationCallback

404+ addClientNode conn notificationPid

405+ pure (Right conn)

406+

372407-- | Create a new session at the transaction id and return the session's Id.

373408createSessionAtCommit :: Connection -> TransactionId -> IO (Either RelationalError SessionId)

374409createSessionAtCommit conn@(InProcessConnection _) commitId = do

375410 newSessionId <- nextRandom

376411 atomically $ createSessionAtCommit_ commitId newSessionId conn

377−createSessionAtCommit conn@(RemoteConnection _) uuid = remoteCall conn (CreateSessionAtCommit uuid)

412+createSessionAtCommit conn@(RemoteProcessConnection _) uuid = remoteCall conn (CreateSessionAtCommit uuid)

378413

379414createSessionAtCommit_ :: TransactionId -> SessionId -> Connection -> STM (Either RelationalError SessionId)

380415createSessionAtCommit_ commitId newSessionId (InProcessConnection conf) = do

@@ -391,7 +426,7 @@ createSessionAtCommit_ commitId newSessionId (InProcessConnection conf) = do

391426 Nothing -> do

392427 StmMap.insert (Session freshDiscon defaultSchemaName) newSessionId sessions

393428 pure $ Right newSessionId

394−createSessionAtCommit_ _ _ (RemoteConnection _) = error "createSessionAtCommit_ called on remote connection"

429+createSessionAtCommit_ _ _ (RemoteProcessConnection _) = error "createSessionAtCommit_ called on remote connection"

395430

396431-- | Call 'createSessionAtHead' with a transaction graph's head's name to create a new session pinned to that head. This function returns a 'SessionId' which can be used in other function calls to reference the point in the transaction graph.

397432createSessionAtHead :: Connection -> HeadName -> IO (Either RelationalError SessionId)

@@ -403,18 +438,22 @@ createSessionAtHead conn@(InProcessConnection conf) headn = do

403438 case transactionForHead headn graph of

404439 Nothing -> pure $ Left (NoSuchHeadNameError headn)

405440 Just trans -> createSessionAtCommit_ (transactionId trans) newSessionId conn

406−createSessionAtHead conn@(RemoteConnection _) headn = remoteCall conn (CreateSessionAtHead headn)

441+createSessionAtHead conn@(RemoteProcessConnection _) headn = remoteCall conn (CreateSessionAtHead headn)

442+

443+-- | Used internally for server connections to keep track of remote nodes for the purpose of sending notifications later.

444+addClientNode :: Connection -> ProcessId -> IO ()

445+addClientNode (RemoteProcessConnection _) _ = error "addClientNode called on remote connection"

446+addClientNode (InProcessConnection conf) newProcessId = atomically (StmSet.insert newProcessId (ipClientNodes conf))

407447

408448-- | Discards a session, eliminating any uncommitted changes present in the session.

409449closeSession :: SessionId -> Connection -> IO ()

410450closeSession sessionId (InProcessConnection conf) =

411451 atomically $ StmMap.delete sessionId (ipSessions conf)

412−closeSession sessionId conn@(RemoteConnection _) = remoteCall conn (CloseSession sessionId)

452+closeSession sessionId conn@(RemoteProcessConnection _) = remoteCall conn (CloseSession sessionId)

413453

414454-- | 'close' cleans up the database access connection and closes any relevant sockets.

415455close :: Connection -> IO ()

416456close (InProcessConnection conf) = do

417− cancel (ipCallbackAsync conf)

418457 atomically $ do

419458 let sessions = ipSessions conf

420459#if MIN_VERSION_stm_containers(1,0,0)

@@ -423,18 +462,22 @@ close (InProcessConnection conf) = do

423462 StmMap.deleteAll sessions

424463#endif

425464 pure ()

465+ closeLocalNode (ipLocalNode conf)

466+ closeTransport (ipTransport conf)

426467 let mLocks = ipLocks conf

427468 case mLocks of

428469 Nothing -> pure ()

429470 Just (lockFileH, _) -> closeLockFile lockFileH

430471

431−close (RemoteConnection (RemoteConnectionConf conn)) =

432− RPC.close conn

472+close conn@(RemoteProcessConnection conf) = do

473+ _ <- remoteCall conn Logout :: IO Bool

474+ closeLocalNode (rLocalNode conf)

475+ closeTransport (rTransport conf)

433476

434477--used only by the server EntryPoints

435478closeRemote_ :: Connection -> IO ()

436479closeRemote_ (InProcessConnection _) = error "invalid call of closeRemote_ on InProcessConnection"

437−closeRemote_ (RemoteConnection (RemoteConnectionConf conn)) = RPC.close conn

480+closeRemote_ (RemoteProcessConnection conf) = runProcess (rLocalNode conf) (reconnect (rProcessId conf))

438481

439482 --we need to actually close the localNode's connection to the remote

440483--within the database server, we must catch and handle all exception lest they take down the database process- this handling might be different for other use-cases

@@ -445,15 +488,35 @@ excEither = handle handler

445488 where

446489 handler exc | Just (_ :: AsyncException) <- fromException exc = throwIO exc

447490 | otherwise = pure (Left (UnhandledExceptionError (show exc)))

491+

492+runProcessResult :: LocalNode -> Process a -> IO a

493+runProcessResult localNode proc = do

494+ ret <- newEmptyMVar

495+ runProcess localNode $ do

496+ val <- proc

497+ liftIO $ putMVar ret val

498+ takeMVar ret

499+

500+safeLogin :: Login -> ProcessId -> Process Bool

501+safeLogin login procId = do

502+ ret <- call procId login

503+ case ret of

504+ Left (_ :: ServerError) -> pure False

505+ Right val -> pure val

448506

449−

450−remoteCall :: (Serialise a, Serialise b) => Connection -> a -> IO b

507+remoteCall :: (Binary a, Binary b, Typeable a, Typeable b) => Connection -> a -> IO b

451508remoteCall (InProcessConnection _ ) _ = error "remoteCall called on local connection"

452−remoteCall (RemoteConnection (RemoteConnectionConf rpcConn)) arg = do

453− eRet <- RPC.call rpcConn arg

454− case eRet of

455− Left err -> convertRPCErrors err

456− Right val -> pure val

509+remoteCall (RemoteProcessConnection conf) arg = runProcessResult localNode $ do

510+ ret <- safeCall serverProcessId arg

511+ case ret of

512+ Left err -> error ("server died: " ++ show err)

513+ Right ret' -> case ret' of

514+ Left RequestTimeoutError -> liftIO (throwIO RequestTimeoutException)

515+ Left (ProcessDiedError _) -> liftIO (throwIO RemoteProcessDiedException)

516+ Right val -> pure val

517+ where

518+ localNode = rLocalNode conf

519+ serverProcessId = rProcessId conf

457520

458521sessionForSessionId :: SessionId -> Sessions -> STM (Either RelationalError Session)

459522sessionForSessionId sessionId sessions =

@@ -488,7 +551,7 @@ currentSchemaName sessionId (InProcessConnection conf) = atomically $ do

488551 case eSession of

489552 Left err -> pure (Left err)

490553 Right session -> pure (Right (Sess.schemaName session))

491−currentSchemaName sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveCurrentSchemaName sessionId)

554+currentSchemaName sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveCurrentSchemaName sessionId)

492555

493556-- | Switch to the named isomorphic schema.

494557setCurrentSchemaName :: SessionId -> Connection -> SchemaName -> IO (Either RelationalError ())

@@ -500,7 +563,7 @@ setCurrentSchemaName sessionId (InProcessConnection conf) sname = atomically $ d

500563 Right session -> case Sess.setSchemaName sname session of

501564 Left err -> pure (Left err)

502565 Right newSession -> StmMap.insert newSession sessionId sessions >> pure (Right ())

503−setCurrentSchemaName sessionId conn@(RemoteConnection _) sname = remoteCall conn (ExecuteSetCurrentSchema sessionId sname)

566+setCurrentSchemaName sessionId conn@(RemoteProcessConnection _) sname = remoteCall conn (ExecuteSetCurrentSchema sessionId sname)

504567

505568-- | Execute a relational expression in the context of the session and connection. Relational expressions are queries and therefore cannot alter the database.

506569executeRelationalExpr :: SessionId -> Connection -> RelationalExpr -> IO (Either RelationalError Relation)

@@ -524,7 +587,7 @@ executeRelationalExpr sessionId (InProcessConnection conf) expr = excEither $ at

524587 Right rel -> pure (force (Right rel)) -- this is necessary so that any undefined/error exceptions are spit out here

525588 Left err -> pure (Left err)

526589

527−executeRelationalExpr sessionId conn@(RemoteConnection _) relExpr = remoteCall conn (ExecuteRelationalExpr sessionId relExpr)

590+executeRelationalExpr sessionId conn@(RemoteProcessConnection _) relExpr = remoteCall conn (ExecuteRelationalExpr sessionId relExpr)

528591

529592-- | Execute a database context expression in the context of the session and connection. Database expressions modify the current session's disconnected transaction but cannot modify the transaction graph.

530593executeDatabaseContextExpr :: SessionId -> Connection -> DatabaseContextExpr -> IO (Either RelationalError ())

@@ -558,7 +621,7 @@ executeDatabaseContextExpr sessionId (InProcessConnection conf) expr = excEither

558621 newSession = Session newDiscon (Sess.schemaName session)

559622 StmMap.insert newSession sessionId sessions

560623 pure (Right ())

561−executeDatabaseContextExpr sessionId conn@(RemoteConnection _) dbExpr = remoteCall conn (ExecuteDatabaseContextExpr sessionId dbExpr)

624+executeDatabaseContextExpr sessionId conn@(RemoteProcessConnection _) dbExpr = remoteCall conn (ExecuteDatabaseContextExpr sessionId dbExpr)

562625

563626-- | Similar to a git rebase, 'autoMergeToHead' atomically creates a temporary branch and merges it to the latest commit of the branch referred to by the 'HeadName' and commits the merge. This is useful to reduce incidents of 'TransactionIsNotAHeadError's but at the risk of merge errors (thus making it similar to rebasing). Alternatively, as an optimization, if a simple commit is possible (meaning that the head has not changed), then a fast-forward commit takes place instead.

564627autoMergeToHead :: SessionId -> Connection -> MergeStrategy -> HeadName -> IO (Either RelationalError ())

@@ -587,7 +650,7 @@ autoMergeToHead sessionId (InProcessConnection conf) strat headName' = do

587650 Left err -> pure (Left err)

588651 Right ((discon', graph'), transactionIdsAdded) ->

589652 pure (Right (discon', graph', transactionIdsAdded))

590−autoMergeToHead sessionId conn@(RemoteConnection _) strat headName' = remoteCall conn (ExecuteAutoMergeToHead sessionId strat headName')

653+autoMergeToHead sessionId conn@(RemoteProcessConnection _) strat headName' = remoteCall conn (ExecuteAutoMergeToHead sessionId strat headName')

591654

592655-- | Execute a database context IO-monad-based expression for the given session and connection. `DatabaseContextIOExpr`s modify the DatabaseContext but cannot be purely implemented.

593656--this is almost completely identical to executeDatabaseContextExpr above

@@ -613,8 +676,22 @@ executeDatabaseContextIOExpr sessionId (InProcessConnection conf) expr = excEith

613676 context' = RE.dbc_context newState

614677 atomically $ StmMap.insert newSession sessionId sessions

615678 pure (Right ())

616−executeDatabaseContextIOExpr sessionId conn@(RemoteConnection _) dbExpr = remoteCall conn (ExecuteDatabaseContextIOExpr sessionId dbExpr)

679+executeDatabaseContextIOExpr sessionId conn@(RemoteProcessConnection _) dbExpr = remoteCall conn (ExecuteDatabaseContextIOExpr sessionId dbExpr)

617680

681+{-

682+executeGraphExprSTM_ :: TransactionId -> SessionId -> Session -> Sessions -> TransactionGraphOperator -> TransactionGraph -> TVar TransactionGraph -> STM (Either RelationalError (TransactionGraph, DisconnectedTransaction)

683+executeGraphExprSTM_ freshId sessionId session sessions graphExpr graph graphTVar= do

684+ case evalGraphOp freshId (Sess.disconnectedTransaction session) graph graphExpr of

685+ Left err -> do

686+ when updateGraphOnError (writeTVar graphTVar graph)

687+ pure $ Left err

688+ Right (discon', graph') -> do

689+ writeTVar graphTVar graph'

690+ let newSession = Session discon' (Sess.schemaName session)

691+ STMMap.insert newSession sessionId sessions

692+ pure $ Right graph'

693+-}

694+

618695-- process notifications for commits

619696executeCommitExprSTM_

620697 :: TransactionGraph

@@ -655,8 +732,78 @@ executeGraphExpr sessionId (InProcessConnection conf) graphExpr = excEither $ do

655732 --if freshId appears in the graph, then we need to pass it on

656733 let transIds = [freshId | isRight (RE.transactionForId freshId graph')]

657734 pure (Right (discon', graph', transIds))

658−

659−executeGraphExpr sessionId conn@(RemoteConnection _) graphExpr = remoteCall conn (ExecuteGraphExpr sessionId graphExpr)

735+{-

736+executeGraphExpr sessionId (InProcessConnection conf) graphExpr = excEither $ do

737+ let strat = ipPersistenceStrategy conf

738+ clientNodes = ipClientNodes conf

739+ sessions = ipSessions conf

740+ graphTvar = ipTransactionGraph conf

741+ mLockFileH = ipLocks conf

742+ lockHandler body = case graphExpr of

743+ Commit -> case mLockFileH of

744+ Nothing -> body False

745+ Just (lockFileH, lockMVar) -> let acquireLocks = do

746+ lastWrittenDigest <- takeMVar lockMVar

747+ lockFile lockFileH WriteLock

748+ latestDigest <- readGraphTransactionIdDigest strat

749+ pure (latestDigest /= lastWrittenDigest)

750+

751+ releaseLocks _ = do

752+ --still holding the lock- get the latest digest

753+ gDigest <- readGraphTransactionIdDigest strat

754+ unlockFile lockFileH

755+ putMVar lockMVar gDigest

756+ in bracket acquireLocks releaseLocks body

757+ _ -> body False

758+ freshId <- nextRandom

759+ lockHandler $ \dbWrittenByOtherProcess -> do

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

761+ --read transaction data and compare to existing graph

762+ --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)

763+ manip <- atomically $ do

764+ eSession <- sessionForSessionId sessionId sessions

765+ --handle graph update by other process

766+ oldGraph <- readTVar graphTvar

767+ case eSession of

768+ Left err -> pure (Left err)

769+ Right session -> do

770+ let mScriptSession = ipScriptSession conf

771+ dbdir = case strat of

772+ MinimalPersistence x -> x

773+ CrashSafePersistence x -> x

774+ _ -> error "accessing dbdir on non-persisted connection"

775+ eRefreshedGraph <- if dbWrittenByOtherProcess then

776+ unsafeIOToSTM (transactionGraphLoad dbdir oldGraph mScriptSession)

777+ else

778+ pure (Right oldGraph)

779+ case eRefreshedGraph of

780+ Left err -> pure (Left (DatabaseLoadError err))

781+ Right refreshedGraph -> do

782+ --snip it

783+ eGraph <- executeGraphExprSTM_ dbWrittenByOtherProcess freshId sessionId session sessions graphExpr refreshedGraph graphTvar

784+ --snip it

785+ case eGraph of

786+ Left err -> pure (Left err)

787+ Right newGraph -> do

788+ --handle commit

789+ if isCommit graphExpr then do

790+ case transactionForId (Sess.parentId session) oldGraph of

791+ Left err -> pure $ Left err

792+ Right previousTrans -> do

793+ (evaldNots, nodes) <- executeCommitExprSTM_ (Trans.concreteDatabaseContext previousTrans) (Sess.concreteDatabaseContext session) clientNodes

794+ nodesToNotify <- toList (StmSet.stream nodes)

795+ pure $ Right (evaldNots, nodesToNotify, newGraph)

796+ else

797+ pure $ Right (M.empty, [], newGraph)

798+ case manip of

799+ Left err -> return $ Just err

800+ Right (notsToFire, nodesToNotify, newGraph) -> do

801+ --update filesystem database, if necessary

802+ processTransactionGraphPersistence strat newGraph

803+ sendNotifications nodesToNotify (ipLocalNode conf) notsToFire

804+ pure Nothing

805+-}

806+executeGraphExpr sessionId conn@(RemoteProcessConnection _) graphExpr = remoteCall conn (ExecuteGraphExpr sessionId graphExpr)

660807

661808-- | A trans-graph expression is a relational query executed against the entirety of a transaction graph.

662809executeTransGraphRelationalExpr :: SessionId -> Connection -> TransGraphRelationalExpr -> IO (Either RelationalError Relation)

@@ -664,7 +811,10 @@ executeTransGraphRelationalExpr _ (InProcessConnection conf) tgraphExpr = excEit

664811 let graphTvar = ipTransactionGraph conf

665812 graph <- readTVar graphTvar

666813 pure $ force $ optimizeAndEvalTransGraphRelationalExpr graph tgraphExpr

667−executeTransGraphRelationalExpr sessionId conn@(RemoteConnection _) tgraphExpr = remoteCall conn (ExecuteTransGraphRelationalExpr sessionId tgraphExpr)

814+{- case runReader (RE.evalRelationalExpr relExpr) (RE.mkRelationalExprState DBC.empty) of

815+ Left err -> pure (Left err)

816+ Right rel -> pure (force (Right rel))-}

817+executeTransGraphRelationalExpr sessionId conn@(RemoteProcessConnection _) tgraphExpr = remoteCall conn (ExecuteTransGraphRelationalExpr sessionId tgraphExpr)

668818

669819-- | Schema expressions manipulate the isomorphic schemas for the current 'DatabaseContext'.

670820executeSchemaExpr :: SessionId -> Connection -> Schema.SchemaExpr -> IO (Either RelationalError ())

@@ -687,24 +837,23 @@ executeSchemaExpr sessionId (InProcessConnection conf) schemaExpr = atomically $

687837 newSession = Session (DisconnectedTransaction (Discon.parentId discon) newSchemas False) (Sess.schemaName session)

688838 StmMap.insert newSession sessionId sessions

689839 pure (Right ())

690−executeSchemaExpr sessionId conn@(RemoteConnection _) schemaExpr = remoteCall conn (ExecuteSchemaExpr sessionId schemaExpr)

840+executeSchemaExpr sessionId conn@(RemoteProcessConnection _) schemaExpr = remoteCall conn (ExecuteSchemaExpr sessionId schemaExpr)

691841

692842-- | After modifying a 'DatabaseContext', 'commit' the transaction to the transaction graph at the head which the session is referencing. This will also trigger checks for any notifications which need to be propagated.

693843commit :: SessionId -> Connection -> IO (Either RelationalError ())

694844commit sessionId conn@(InProcessConnection _) = executeGraphExpr sessionId conn Commit

695−commit sessionId conn@(RemoteConnection _) = remoteCall conn (ExecuteGraphExpr sessionId Commit)

696−

697−sendNotifications :: [ClientInfo] -> EvaluatedNotifications -> IO ()

698−sendNotifications clients notifs =

699− unless (M.null notifs) $ forM_ clients sender

700− where

701− sender (RemoteClientInfo sock) = RPC.sendMessage sock (NotificationMessage notifs)

702− sender (InProcessClientInfo tvar) = putMVar tvar notifs

703−

845+commit sessionId conn@(RemoteProcessConnection _) = remoteCall conn (ExecuteGraphExpr sessionId Commit)

846+

847+sendNotifications :: [ProcessId] -> LocalNode -> EvaluatedNotifications -> IO ()

848+sendNotifications pids localNode nots = mapM_ sendNots pids

849+ where

850+ sendNots remoteClientPid =

851+ unless (M.null nots) $ runProcess localNode $ send remoteClientPid (NotificationMessage nots)

852+

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

705854rollback :: SessionId -> Connection -> IO (Either RelationalError ())

706855rollback sessionId conn@(InProcessConnection _) = executeGraphExpr sessionId conn Rollback

707−rollback sessionId conn@(RemoteConnection _) = remoteCall conn (ExecuteGraphExpr sessionId Rollback)

856+rollback sessionId conn@(RemoteProcessConnection _) = remoteCall conn (ExecuteGraphExpr sessionId Rollback)

708857

709858-- | Write the transaction graph to disk. This function can be used to incrementally write new transactions to disk.

710859processTransactionGraphPersistence :: PersistenceStrategy -> [TransactionId] -> TransactionGraph -> IO ()

@@ -720,7 +869,7 @@ readGraphTransactionIdDigest (CrashSafePersistence dbdir) = readGraphTransaction

720869-- | Return a relation whose type would match that of the relational expression if it were executed. This is useful for checking types and validating a relational expression's types.

721870typeForRelationalExpr :: SessionId -> Connection -> RelationalExpr -> IO (Either RelationalError Relation)

722871typeForRelationalExpr sessionId conn@(InProcessConnection _) relExpr = atomically $ typeForRelationalExprSTM sessionId conn relExpr

723−typeForRelationalExpr sessionId conn@(RemoteConnection _) relExpr = remoteCall conn (ExecuteTypeForRelationalExpr sessionId relExpr)

872+typeForRelationalExpr sessionId conn@(RemoteProcessConnection _) relExpr = remoteCall conn (ExecuteTypeForRelationalExpr sessionId relExpr)

724873

725874typeForRelationalExprSTM :: SessionId -> Connection -> RelationalExpr -> STM (Either RelationalError Relation)

726875typeForRelationalExprSTM sessionId (InProcessConnection conf) relExpr = do

@@ -757,7 +906,7 @@ inclusionDependencies sessionId (InProcessConnection conf) = do

757906 else

758907 pure (Schema.inclusionDependenciesInSchema schema (B.inclusionDependencies context))

759908

760−inclusionDependencies sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveInclusionDependencies sessionId)

909+inclusionDependencies sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveInclusionDependencies sessionId)

761910

762911typeConstructorMapping :: SessionId -> Connection -> IO (Either RelationalError TypeConstructorMapping)

763912typeConstructorMapping sessionId (InProcessConnection conf) = do

@@ -768,7 +917,7 @@ typeConstructorMapping sessionId (InProcessConnection conf) = do

768917 Left err -> pure $ Left err

769918 Right (session, _) -> --warning, no schema support for typeconstructors

770919 pure (Right (B.typeConstructorMapping (Sess.concreteDatabaseContext session)))

771−typeConstructorMapping sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveTypeConstructorMapping sessionId)

920+typeConstructorMapping sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveTypeConstructorMapping sessionId)

772921

773922-- | Return an optimized database expression which is logically equivalent to the input database expression. This function can be used to determine which expression will actually be evaluated.

774923planForDatabaseContextExpr :: SessionId -> Connection -> DatabaseContextExpr -> IO (Either RelationalError GraphRefDatabaseContextExpr)

@@ -788,7 +937,7 @@ planForDatabaseContextExpr sessionId (InProcessConnection conf) dbExpr = do

788937 else -- don't show any optimization because the current optimization infrastructure relies on access to the base context- this probably underscores the need for each schema to have its own DatabaseContext, even if it is generated on-the-fly-}

789938 pure (Left NonConcreteSchemaPlanError)

790939

791−planForDatabaseContextExpr sessionId conn@(RemoteConnection _) dbExpr = remoteCall conn (RetrievePlanForDatabaseContextExpr sessionId dbExpr)

940+planForDatabaseContextExpr sessionId conn@(RemoteProcessConnection _) dbExpr = remoteCall conn (RetrievePlanForDatabaseContextExpr sessionId dbExpr)

792941

793942-- | Return a relation which represents the current state of the global transaction graph. The attributes are

794943-- * current- boolean attribute representing whether or not the current session references this transaction

@@ -806,7 +955,7 @@ transactionGraphAsRelation sessionId (InProcessConnection conf) = do

806955 Right session ->

807956 graphAsRelation (Sess.disconnectedTransaction session) <$> readTVar tvar

808957

809−transactionGraphAsRelation sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveTransactionGraph sessionId)

958+transactionGraphAsRelation sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveTransactionGraph sessionId)

810959

811960-- | Returns the names and types of the relation variables in the current 'Session'.

812961relationVariablesAsRelation :: SessionId -> Connection -> IO (Either RelationalError Relation)

@@ -828,7 +977,7 @@ relationVariablesAsRelation sessionId (InProcessConnection conf) = do

828977 let schemaContext = context {relationVariables = relvars }

829978 pure $ RE.relationVariablesAsRelation schemaContext graph

830979

831−relationVariablesAsRelation sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveRelationVariableSummary sessionId)

980+relationVariablesAsRelation sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveRelationVariableSummary sessionId)

832981

833982-- | Returns the names and types of the atom functions in the current 'Session'.

834983atomFunctionsAsRelation :: SessionId -> Connection -> IO (Either RelationalError Relation)

@@ -841,7 +990,7 @@ atomFunctionsAsRelation sessionId (InProcessConnection conf) = do

841990 Right (session, _) ->

842991 pure (AF.atomFunctionsAsRelation (atomFunctions (concreteDatabaseContext session)))

843992

844−atomFunctionsAsRelation sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveAtomFunctionSummary sessionId)

993+atomFunctionsAsRelation sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveAtomFunctionSummary sessionId)

845994

846995databaseContextFunctionsAsRelation :: SessionId -> Connection -> IO (Either RelationalError Relation)

847996databaseContextFunctionsAsRelation sessionId (InProcessConnection conf) = do

@@ -853,7 +1002,7 @@ databaseContextFunctionsAsRelation sessionId (InProcessConnection conf) = do

8531002 Right (session, _) ->

8541003 pure (DCF.databaseContextFunctionsAsRelation (dbcFunctions (concreteDatabaseContext session)))

8551004

856−databaseContextFunctionsAsRelation sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveDatabaseContextFunctionSummary sessionId)

1005+databaseContextFunctionsAsRelation sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveDatabaseContextFunctionSummary sessionId)

8571006

8581007-- | Returns the transaction id for the connection's disconnected transaction committed parent transaction.

8591008headTransactionId :: SessionId -> Connection -> IO (Either RelationalError TransactionId)

@@ -864,7 +1013,7 @@ headTransactionId sessionId (InProcessConnection conf) = do

8641013 case eSession of

8651014 Left err -> pure (Left err)

8661015 Right session -> pure $ Right (Sess.parentId session)

867−headTransactionId sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveHeadTransactionId sessionId)

1016+headTransactionId sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveHeadTransactionId sessionId)

8681017

8691018headNameSTM_ :: SessionId -> Sessions -> TVar TransactionGraph -> STM (Either RelationalError HeadName)

8701019headNameSTM_ sessionId sessions graphTvar = do

@@ -884,7 +1033,7 @@ headName sessionId (InProcessConnection conf) = do

8841033 let sessions = ipSessions conf

8851034 graphTvar = ipTransactionGraph conf

8861035 atomically (headNameSTM_ sessionId sessions graphTvar)

887−headName sessionId conn@(RemoteConnection _) = remoteCall conn (ExecuteHeadName sessionId)

1036+headName sessionId conn@(RemoteProcessConnection _) = remoteCall conn (ExecuteHeadName sessionId)

8881037

8891038-- | Returns a listing of all available atom types.

8901039atomTypesAsRelation :: SessionId -> Connection -> IO (Either RelationalError Relation)

@@ -898,7 +1047,7 @@ atomTypesAsRelation sessionId (InProcessConnection conf) = do

8981047 case typesAsRelation (B.typeConstructorMapping (Sess.concreteDatabaseContext session)) of

8991048 Left err -> pure (Left err)

9001049 Right rel -> pure (Right rel)

901−atomTypesAsRelation sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveAtomTypesAsRelation sessionId)

1050+atomTypesAsRelation sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveAtomTypesAsRelation sessionId)

9021051

9031052disconnectedTransactionIsDirty :: SessionId -> Connection -> IO (Either RelationalError Bool)

9041053disconnectedTransactionIsDirty sessionId (InProcessConnection conf) = do

@@ -909,12 +1058,12 @@ disconnectedTransactionIsDirty sessionId (InProcessConnection conf) = do

9091058 Left err -> pure (Left err)

9101059 Right session ->

9111060 pure (Right (isDirty session))

912−disconnectedTransactionIsDirty sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveSessionIsDirty sessionId)

1061+disconnectedTransactionIsDirty sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveSessionIsDirty sessionId)

9131062

9141063--used only for testing- we expect this to throw an exception

9151064callTestTimeout_ :: SessionId -> Connection -> IO Bool

9161065callTestTimeout_ _ (InProcessConnection _) = error "bad testing call"

917−callTestTimeout_ sessionId conn@(RemoteConnection _) = remoteCall conn (TestTimeout sessionId)

1066+callTestTimeout_ sessionId conn@(RemoteProcessConnection _) = remoteCall conn (TestTimeout sessionId)

9181067

9191068--used in tests only

9201069transactionGraph_ :: Connection -> IO TransactionGraph

@@ -999,8 +1148,15 @@ commitLock_ sessionId conf stmBlock = do

9991148 Right (notsToFire, nodesToNotify, newGraph, transactionIdsToPersist) -> do

10001149 --update filesystem database, if necessary

10011150 processTransactionGraphPersistence strat transactionIdsToPersist newGraph

1002− sendNotifications nodesToNotify notsToFire

1151+ sendNotifications nodesToNotify (ipLocalNode conf) notsToFire

10031152 pure (Right ())

1153+{-

1154+writeDisconAndGraph_ :: TVar TransactionGraph -> SessionId -> Session -> Sessions -> DisconnectedTransaction -> TransactionGraph -> STM ()

1155+writeDisconAndGraph_ graphTvar sessionId session sessions discon graph = do

1156+ writeTVar graphTvar graph

1157+ let newSession = Session discon (Sess.schemaName session)

1158+ StmMap.insert newSession sessionId sessions

1159+-}

10041160

10051161-- | Runs an IO monad, commits the result when the monad returns no errors, otherwise, rolls back the changes and the error.

10061162withTransaction :: SessionId -> Connection -> IO (Either RelationalError a) -> IO (Either RelationalError ()) -> IO (Either RelationalError a)

@@ -1052,7 +1208,7 @@ executeDataFrameExpr sessionId conn@(InProcessConnection _) dfExpr = do

10521208 let dFrame' = maybe dFrame (`DF.drop'` dFrame) (DF.offset dfExpr)

10531209 dFrame'' = maybe dFrame' (`DF.take'` dFrame') (DF.limit dfExpr)

10541210 pure (Right dFrame'')

1055−executeDataFrameExpr sessionId conn@(RemoteConnection _) dfExpr = remoteCall conn (ExecuteDataFrameExpr sessionId dfExpr)

1211+executeDataFrameExpr sessionId conn@(RemoteProcessConnection _) dfExpr = remoteCall conn (ExecuteDataFrameExpr sessionId dfExpr)

10561212

10571213validateMerkleHashes :: SessionId -> Connection -> IO (Either RelationalError ())

10581214validateMerkleHashes sessionId (InProcessConnection conf) = do

@@ -1066,30 +1222,4 @@ validateMerkleHashes sessionId (InProcessConnection conf) = do

10661222 case Graph.validateMerkleHashes graph of

10671223 Left merkleErrs -> pure $ Left $ someErrors (map (\(MerkleValidationError tid expected actual) -> MerkleHashValidationError tid expected actual) merkleErrs)

10681224 Right () -> pure (Right ())

1069−validateMerkleHashes sessionId conn@RemoteConnection{} = remoteCall conn (ExecuteValidateMerkleHashes sessionId)

1070−

1071−type ClientNodes = StmSet.Set ClientInfo

1072−

1073−-- internal structure specific to in-process connections

1074−data InProcessConnectionConf = InProcessConnectionConf {

1075− ipPersistenceStrategy :: PersistenceStrategy,

1076− ipClientNodes :: ClientNodes,

1077− ipSessions :: Sessions,

1078− ipTransactionGraph :: TVar TransactionGraph,

1079− ipScriptSession :: Maybe ScriptSession,

1080− ipLocks :: Maybe (LockFile, MVar LockFileHash), -- nothing when NoPersistence

1081− ipCallbackAsync :: Async ()

1082− }

1083−

1084−-- clients may connect associate one socket/mvar with the server to register for change callbacks

1085−data ClientInfo = RemoteClientInfo (RPC.Locking Socket) |

1086− InProcessClientInfo (MVar EvaluatedNotifications)

1087−

1088−instance Eq ClientInfo where

1089− (RemoteClientInfo a) == (RemoteClientInfo b) = RPC.lockless a == RPC.lockless b

1090− (InProcessClientInfo a) == (InProcessClientInfo b) = a == b

1091− _ == _ = False

1092−

1093−instance Hashable ClientInfo where

1094− hashWithSalt salt (RemoteClientInfo sock) = hashWithSalt salt (show (RPC.lockless sock))

1095− hashWithSalt salt (InProcessClientInfo _) = hashWithSalt salt (1::Int)

1225+validateMerkleHashes sessionId conn@RemoteProcessConnection{} = remoteCall conn (ExecuteValidateMerkleHashes sessionId)

src/lib/ProjectM36/DataFrame.hs+14−21

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

1−{-# LANGUAGE DeriveGeneric, DerivingVia #-}

1+{-# LANGUAGE DeriveGeneric, DeriveAnyClass #-}

22{- A dataframe is a strongly-typed, ordered list of named tuples. A dataframe differs from a relation in that its tuples are ordered.-}

33module ProjectM36.DataFrame where

44import ProjectM36.Base

5−import ProjectM36.Attribute as A hiding (drop)

5+import ProjectM36.Attribute as A

66import ProjectM36.Error

77import qualified ProjectM36.Relation as R

88import ProjectM36.Relation.Show.Term

@@ -16,19 +16,15 @@ import qualified Data.List as L

1616import qualified Data.Set as S

1717import Data.Maybe

1818import qualified Data.Text as T

19+import Data.Binary

1920import Control.Arrow

2021#if __GLASGOW_HASKELL__ < 804

2122import Data.Monoid

2223#endif

2324

24−data AttributeOrderExpr = AttributeOrderExpr AttributeName Order

25− deriving (Show, Generic)

26−

27−data AttributeOrder = AttributeOrder AttributeName Order

28− deriving (Show, Generic)

29−

30−data Order = AscendingOrder | DescendingOrder

31− deriving (Eq, Show, Generic)

25+data AttributeOrderExpr = AttributeOrderExpr AttributeName Order deriving (Show, Generic, Binary)

26+data AttributeOrder = AttributeOrder AttributeName Order deriving (Show, Generic, Binary)

27+data Order = AscendingOrder | DescendingOrder deriving (Eq, Show, Generic, Binary)

3228

3329ascending :: T.Text

3430ascending = "⬆"

@@ -43,11 +39,9 @@ data DataFrame = DataFrame {

4339 orders :: [AttributeOrder],

4440 attributes :: Attributes,

4541 tuples :: [DataFrameTuple]

46− }

47− deriving (Show, Generic)

42+ } deriving (Show, Generic, Binary)

4843

49−data DataFrameTuple = DataFrameTuple Attributes (V.Vector Atom)

50− deriving (Eq, Show, Generic)

44+data DataFrameTuple = DataFrameTuple Attributes (V.Vector Atom) deriving (Eq, Show, Generic, Binary)

5145

5246sortDataFrameBy :: [AttributeOrder] -> DataFrame -> Either RelationalError DataFrame

5347sortDataFrameBy attrOrders frame = do

@@ -81,7 +75,7 @@ compareTupleByOneAttributeName attr tuple1 tuple2 =

8175 Right atom2 -> compareAtoms atom1 atom2

8276

8377atomForAttributeName :: AttributeName -> DataFrameTuple -> Either RelationalError Atom

84−atomForAttributeName attrName (DataFrameTuple tupAttrs tupVec) = case V.findIndex (\attr -> attributeName attr == attrName) (attributesVec tupAttrs) of

78+atomForAttributeName attrName (DataFrameTuple tupAttrs tupVec) = case V.findIndex (\attr -> attributeName attr == attrName) tupAttrs of

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

8680 Just index -> case tupVec V.!? index of

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

@@ -128,18 +122,17 @@ data DataFrameExpr = DataFrameExpr {

128122 orderExprs :: [AttributeOrderExpr],

129123 offset :: Maybe Integer,

130124 limit :: Maybe Integer

131− }

132− deriving (Show, Generic)

125+ } deriving (Show, Binary, Generic)

133126

134127dataFrameAsHTML :: DataFrame -> T.Text

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

136129dataFrameAsHTML df

137− | length (tuples df) == 1 && A.null (attributes df) = style <>

130+ | length (tuples df) == 1 && L.null (attributes df) = style <>

138131 tablestart <>

139132 "<tr><th></th></tr>" <>

140133 "<tr><td></td></tr>" <>

141134 tablefooter <> "</table>"

142− | L.null (tuples df) && A.null (attributes df) = style <>

135+ | L.null (tuples df) && L.null (attributes df) = style <>

143136 tablestart <>

144137 "<tr><th></th></tr>" <>

145138 tablefooter <>

@@ -162,7 +155,7 @@ tuplesAsHTML = foldr folder ""

162155 folder tuple acc = acc <> tupleAsHTML tuple

163156

164157tupleAssocs :: DataFrameTuple -> [(AttributeName, Atom)]

165−tupleAssocs (DataFrameTuple attrs tupVec) = V.toList $ V.map (first attributeName) (V.zip (attributesVec attrs) tupVec)

158+tupleAssocs (DataFrameTuple attrVec tupVec) = V.toList $ V.map (first attributeName) (V.zip attrVec tupVec)

166159

167160

168161tupleAsHTML :: DataFrameTuple -> T.Text

@@ -174,7 +167,7 @@ tupleAsHTML tuple = "<tr>" <> T.concat (L.map tupleFrag (tupleAssocs tuple)) <>

174167 atomAsHTML atom = atomToText atom

175168

176169attributesAsHTML :: Attributes -> [AttributeOrder] -> T.Text

177−attributesAsHTML attrs orders' = "<tr>" <> T.concat (map oneAttrHTML (A.toList attrs)) <> "</tr>"

170+attributesAsHTML attrs orders' = "<tr>" <> T.concat (map oneAttrHTML (V.toList attrs)) <> "</tr>"

178171 where

179172 oneAttrHTML attr = "<th>" <> prettyAttribute attr <> ordering (attributeName attr) <> "</th>"

180173 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

3737 BoolAtomType -> False

3838 RelationAtomType _ -> False

3939 ConstructedAtomType _ _ -> False --once we support an interval-style typeclass, we might enable this

40− RelationalExprAtomType -> False

4140 TypeVariableType _ -> False

4241

4342supportsOrdering :: AtomType -> Bool

@@ -51,7 +50,6 @@ supportsOrdering typ = case typ of

5150 ByteStringAtomType -> False

5251 BoolAtomType -> False

5352 RelationAtomType _ -> False

54− RelationalExprAtomType -> False

5553 ConstructedAtomType _ _ -> False --once we support an interval-style typeclass, we might enable this

5654 TypeVariableType _ -> False

5755

src/lib/ProjectM36/DataTypes/Primitive.hs−1

@@ -42,4 +42,3 @@ atomTypeForAtom (ByteStringAtom _) = ByteStringAtomType

4242atomTypeForAtom (BoolAtom _) = BoolAtomType

4343atomTypeForAtom (RelationAtom (Relation attrs _)) = RelationAtomType attrs

4444atomTypeForAtom (ConstructedAtom _ aType _) = aType

45−atomTypeForAtom (RelationalExprAtom _) = RelationalExprAtomType

src/lib/ProjectM36/DataTypes/Sorting.hs−1

@@ -24,7 +24,6 @@ isSortableAtomType typ = case typ of

2424 DateTimeAtomType -> True

2525 ByteStringAtomType -> False

2626 BoolAtomType -> True

27− RelationalExprAtomType -> False

2827 RelationAtomType _ -> False

2928 ConstructedAtomType _ _ -> False

3029 TypeVariableType _ -> False

src/lib/ProjectM36/DatabaseContext.hs+6−6

@@ -7,9 +7,9 @@ import ProjectM36.DataTypes.Basic

77import ProjectM36.AtomFunctions.Basic

88import ProjectM36.Relation

99import qualified Data.ByteString.Lazy as BL

10+import Data.Binary as B

1011import ProjectM36.AtomFunction as AF

1112import ProjectM36.DatabaseContextFunction as DBCF

12−import Codec.Winery

1313

1414empty :: DatabaseContext

1515empty = DatabaseContext { inclusionDependencies = M.empty,

@@ -44,11 +44,11 @@ basicDatabaseContext = DatabaseContext { inclusionDependencies = M.empty,

4444

4545--for building the Merkle hash

4646hashBytes :: DatabaseContext -> BL.ByteString

47−hashBytes ctx = BL.fromChunks [incDeps, rvs, nots, tConsMap] <> atomFs <> dbcFs

47+hashBytes ctx = mconcat [incDeps, rvs, atomFs, dbcFs, nots, tConsMap]

4848 where

49− incDeps = serialise (inclusionDependencies ctx)

50− rvs = serialise (relationVariables ctx)

49+ incDeps = B.encode (inclusionDependencies ctx)

50+ rvs = B.encode (relationVariables ctx)

5151 atomFs = HS.foldr (mappend . AF.hashBytes) mempty (atomFunctions ctx)

5252 dbcFs = HS.foldr (mappend . DBCF.hashBytes) mempty (dbcFunctions ctx)

53− nots = serialise (notifications ctx)

54− tConsMap = serialise (typeConstructorMapping ctx)

53+ nots = B.encode (notifications ctx)

54+ tConsMap = B.encode (typeConstructorMapping ctx)

src/lib/ProjectM36/DatabaseContextFunction.hs+5−6

@@ -3,7 +3,6 @@ module ProjectM36.DatabaseContextFunction where

33--implements functions which operate as: [Atom] -> DatabaseContextExpr -> Either RelationalError DatabaseContextExpr

44import ProjectM36.Base

55import ProjectM36.Error

6−import ProjectM36.Serialise.Base ()

76import ProjectM36.Attribute as A

87import ProjectM36.Relation

98import ProjectM36.AtomType

@@ -12,7 +11,7 @@ import qualified Data.Map as M

1211import ProjectM36.ScriptSession

1312import qualified Data.Text as T

1413import qualified Data.ByteString.Lazy as BL

15−import Codec.Winery

14+import Data.Binary as B

1615

1716emptyDatabaseContextFunction :: DatabaseContextFunctionName -> DatabaseContextFunction

1817emptyDatabaseContextFunction name = DatabaseContextFunction {

@@ -83,9 +82,9 @@ databaseContextFunctionsAsRelation dbcFuncs = mkRelationFromList attrs tups

8382

8483-- for merkle hash

8584hashBytes :: DatabaseContextFunction -> BL.ByteString

86−hashBytes func = BL.fromChunks [fname, ftype, fbody]

85+hashBytes func = mconcat [fname, ftype, fbody]

8786 where

88− fname = serialise (dbcFuncName func)

89− ftype = serialise (dbcFuncType func)

87+ fname = B.encode (dbcFuncName func)

88+ ftype = B.encode (dbcFuncType func)

9089 fbody = case dbcFuncBody func of

91− DatabaseContextFunctionBody mBody _ -> serialise mBody

90+ DatabaseContextFunctionBody mBody _ -> B.encode mBody

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

@@ -1,8 +1,9 @@

11{-# LANGUAGE DeriveGeneric, DeriveAnyClass #-}

22module ProjectM36.DatabaseContextFunctionError where

33import GHC.Generics

4+import Data.Binary

45import Control.DeepSeq

67{-# ANN module ("HLint: ignore Use newtype instead of data" :: String) #-}

78data DatabaseContextFunctionError = DatabaseContextFunctionUserError String

8− deriving (Generic, Eq, Show, NFData)

9+ deriving (Generic, Eq, Show, Binary, NFData)

src/lib/ProjectM36/Error.hs+14−16

@@ -9,6 +9,7 @@ import Control.DeepSeq (NFData, rnf)

99import Control.DeepSeq.Generics (genericRnf)

1010import GHC.Generics (Generic)

1111import qualified Data.Text as T

12+import Data.Binary

1213import Data.Typeable

1314import Control.Exception

1415

@@ -81,7 +82,7 @@ data RelationalError = NoSuchAttributeNamesError (S.Set AttributeName)

8182 | RelationValuedAttributesNotSupportedError [AttributeName]

8283 | NotificationNameInUseError NotificationName

8384 | NotificationNameNotInUseError NotificationName

84− | ImportError ImportError'

85+ | ImportError T.Text -- really? This should be broken out into some other error type- this has nothing to do with relational algebra

8586 | ExportError T.Text

8687 | UnhandledExceptionError String

8788 | MergeTransactionError MergeError

@@ -103,14 +104,14 @@ data RelationalError = NoSuchAttributeNamesError (S.Set AttributeName)

103104 | TupleExprsReferenceMultipleMarkersError

104105

105106 | MerkleHashValidationError TransactionId MerkleHash MerkleHash

106−

107+

107108 | MultipleErrors [RelationalError]

108− deriving (Show,Eq,Generic,Typeable, NFData)

109+ deriving (Show,Eq,Generic,Binary,Typeable, NFData)

109110

110111data PersistenceError = InvalidDirectoryError FilePath |

111112 MissingTransactionError TransactionId |

112113 WrongDatabaseFormatVersionError String String

113− deriving (Show, Eq, Generic, NFData)

114+ deriving (Show, Eq, Generic, Binary, NFData)

114115

115116--collapse list of errors into normal error- if there is just one, just return one

116117someErrors :: [RelationalError] -> RelationalError

@@ -128,7 +129,7 @@ data MergeError = SelectedHeadMismatchMergeError |

128129 StrategyViolatesComponentMergeError | --failed merge in inc deps, relvars, etc.

129130 StrategyViolatesRelationVariableMergeError |

130131 StrategyViolatesTypeConstructorMergeError

131− deriving (Show, Eq, Generic, Typeable)

132+ deriving (Show, Eq, Generic, Binary, Typeable)

132133

133134instance NFData MergeError where rnf = genericRnf

134135

@@ -136,20 +137,17 @@ data ScriptCompilationError = TypeCheckCompilationError String String | --expect

136137 SyntaxErrorCompilationError String |

137138 ScriptCompilationDisabledError |

138139 OtherScriptCompilationError String

139− deriving (Show, Eq, Generic, Typeable, NFData)

140+ deriving (Show, Eq, Generic, Binary, Typeable, NFData)

140141

141142instance Exception ScriptCompilationError

142143

143144data SchemaError = RelVarReferencesMissing (S.Set RelVarName) |

144145 RelVarInReferencedMoreThanOnce RelVarName |

145146 RelVarOutReferencedMoreThanOnce RelVarName

146− deriving (Show, Eq, Generic, Typeable, NFData)

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)

147+ deriving (Show, Eq, Generic, Binary, Typeable, NFData)

148+

149+

150+-- errors returned from the distributed-process call handlers

151+data ServerError = RequestTimeoutError |

152+ ProcessDiedError String

153+ deriving (Generic, Binary, Eq)

src/lib/ProjectM36/InclusionDependency.hs+6−5

@@ -4,16 +4,17 @@ import ProjectM36.Attribute

44import ProjectM36.Error

55import ProjectM36.Relation

66import qualified Data.Map as M

7+import qualified Data.Text as T

89inclusionDependenciesAsRelation :: InclusionDependencies -> Either RelationalError Relation

910inclusionDependenciesAsRelation incDeps =

1011 mkRelationFromList attrs (map incDepAsAtoms (M.toList incDeps))

1112 where

1213 attrs = attributesFromList [Attribute "name" TextAtomType,

13− Attribute "sub" RelationalExprAtomType,

14− Attribute "super" RelationalExprAtomType

14+ Attribute "sub" TextAtomType,

15+ Attribute "super" TextAtomType

1516 ]

1617 incDepAsAtoms (name, InclusionDependency exprA exprB) = [TextAtom name,

17− RelationalExprAtom exprA,

18− RelationalExprAtom exprB]

19−

18+ TextAtom (T.pack (show exprA)),

19+ TextAtom (T.pack (show exprB))]

20+

src/lib/ProjectM36/IsomorphicSchema.hs+4−2

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

1−{-# LANGUAGE DeriveGeneric, LambdaCase, DerivingVia #-}

1+{-# LANGUAGE DeriveGeneric, DeriveAnyClass, LambdaCase #-}

22module ProjectM36.IsomorphicSchema where

33import ProjectM36.Base

44import ProjectM36.Error

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

99import qualified ProjectM36.AttributeNames as AN

1010import Control.Monad

1111import GHC.Generics

12+import Data.Binary

1213import qualified Data.Map as M

1314import qualified Data.Set as S

1415import qualified Data.List as L

@@ -27,7 +28,8 @@ import Data.Monoid

2728

2829data SchemaExpr = AddSubschema SchemaName SchemaIsomorphs |

2930 RemoveSubschema SchemaName

30− deriving (Generic, Show)

31+ deriving (Generic, Binary, Show)

32+

3133

3234isomorphs :: Schema -> SchemaIsomorphs

3335isomorphs (Schema i) = i

src/lib/ProjectM36/MerkleHash.hs+3−2

@@ -1,9 +1,10 @@

1−{-# LANGUAGE GeneralizedNewtypeDeriving, DeriveGeneric, DerivingVia #-}

1+{-# LANGUAGE GeneralizedNewtypeDeriving, DeriveGeneric #-}

22module ProjectM36.MerkleHash where

33import Data.ByteString (ByteString)

44import GHC.Generics

5+import Data.Binary (Binary)

56import Control.DeepSeq (NFData)

78newtype MerkleHash = MerkleHash { _unMerkleHash :: ByteString }

8− deriving (Show, Eq, Generic, Monoid, Semigroup, NFData)

9+ deriving (Show, Eq, Binary, Generic, Monoid, Semigroup, NFData)

910

src/lib/ProjectM36/Persist.hs+4−3

@@ -36,6 +36,7 @@ import Foreign.C

3636#endif

3737

3838import System.IO (withFile, IOMode(WriteMode), Handle)

39+import qualified Data.ByteString.Lazy as BS

3940import qualified Data.ByteString as BS'

4041import qualified Data.Text.Encoding as TE

4142

@@ -99,10 +100,10 @@ syncDirectory :: DiskSync -> FilePath -> IO ()

99100syncDirectory FsyncDiskSync path = directoryFsync path

100101syncDirectory NoDiskSync _ = pure ()

101102

102−writeBSFileSync :: DiskSync -> FilePath -> BS'.ByteString -> IO ()

103+writeBSFileSync :: DiskSync -> FilePath -> BS.ByteString -> IO ()

103104writeBSFileSync sync path bstring =

104105 withFile path WriteMode $ \handle -> do

105− BS'.hPut handle bstring

106+ BS.hPut handle bstring

106107 syncHandle sync handle

107108

108109directoryFsync :: FilePath -> IO ()

@@ -130,4 +131,4 @@ fdCount = do

130131 fds <- getDirectoryContents FDDIR

131132 pure ((length fds) - 2)

132133--not supported on non-linux

133−#endif

134+#endif

src/lib/ProjectM36/Relation.hs+22−17

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

99import qualified ProjectM36.Attribute as A

1010import ProjectM36.TupleSet

1111import ProjectM36.Error

12+import ProjectM36.MiscUtils

1213--import qualified Control.Parallel.Strategies as P

1314import qualified ProjectM36.TypeConstructorDef as TCD

1415import qualified ProjectM36.DataConstructorDef as DCD

@@ -16,6 +17,7 @@ import qualified Data.Text as T

1617import Data.Either (isRight)

1718import System.Random.Shuffle

1819import Control.Monad.Random

20+import Data.List (sort)

1921

2022attributes :: Relation -> Attributes

2123attributes (Relation attrs _ ) = attrs

@@ -33,7 +35,7 @@ atomTypeForName :: AttributeName -> Relation -> Either RelationalError AtomType

3335atomTypeForName attrName (Relation attrs _) = A.atomTypeForAttributeName attrName attrs

3436

3537mkRelationFromList :: Attributes -> [[Atom]] -> Either RelationalError Relation

36−mkRelationFromList attrs atomMatrix = do

38+mkRelationFromList attrs atomMatrix =

3739 Relation attrs <$> mkTupleSetFromList attrs atomMatrix

3840

3941emptyRelationWithAttrs :: Attributes -> Relation

@@ -41,6 +43,11 @@ emptyRelationWithAttrs attrs = Relation attrs emptyTupleSet

4143

4244mkRelation :: Attributes -> RelationTupleSet -> Either RelationalError Relation

4345mkRelation 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

4451 --check that all tuples have the same keys

4552 --check that all tuples have keys (1-N) where N is the attribute count

4653 case verifyTupleSet attrs tupleSet of

@@ -86,12 +93,13 @@ union (Relation attrs1 tupSet1) (Relation attrs2 tupSet2) =

8693 else

8794 Right $ Relation attrs1 newtuples

8895 where

89− newtuples = tupleSetUnion attrs1 tupSet1 tupSet2

90−

96+ newtuples = RelationTupleSet $ HS.toList . HS.fromList $ asList tupSet1 ++ map (reorderTuple attrs1) (asList tupSet2)

97+

9198project :: S.Set AttributeName -> Relation -> Either RelationalError Relation

9299project attrNames rel@(Relation _ tupSet) = do

93100 newAttrs <- A.projectionAttributesForNames attrNames (attributes rel)

94− newTupleList <- mapM (tupleProject newAttrs) (asList tupSet)

101+ let newAttrNameSet = A.attributeNameSet newAttrs

102+ newTupleList = map (tupleProject newAttrNameSet) (asList tupSet)

95103 pure (Relation newAttrs (RelationTupleSet (HS.toList (HS.fromList newTupleList))))

96104

97105rename :: AttributeName -> AttributeName -> Relation -> Either RelationalError Relation

@@ -146,7 +154,7 @@ group groupAttrNames newAttrName rel = do

146154 groupProjectionAttributes <- A.projectionAttributesForNames groupAttrNames (attributes rel)

147155 let groupAttr = Attribute newAttrName (RelationAtomType groupProjectionAttributes)

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

150158 Left _ -> undefined

151159 mogrifier tupIn = pure (tupleExtend tupIn (matchingRelTuple tupIn))

152160 newAttrs = A.addAttribute groupAttr nonGroupProjectionAttributes

@@ -160,8 +168,7 @@ restrictEq :: RelationTuple -> Relation -> Either RelationalError Relation

160168restrictEq tuple = restrict rfilter

161169 where

162170 rfilter :: RelationTuple -> Either RelationalError Bool

163− rfilter tupleIn = do

164− pure (tupleIntersection tuple tupleIn == tuple)

171+ rfilter tupleIn = pure (tupleIntersection tuple tupleIn == tuple)

165172

166173-- unwrap relation-valued attribute

167174-- return error if relval attrs and nongroup attrs overlap

@@ -183,13 +190,13 @@ ungroup relvalAttrName rel = case attributesForRelval relvalAttrName rel of

183190tupleUngroup :: AttributeName -> Attributes -> RelationTuple -> Either RelationalError Relation

184191tupleUngroup relvalAttrName newAttrs tuple = do

185192 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])

192193 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])

193200

194201attributesForRelval :: AttributeName -> Relation -> Either RelationalError Attributes

195202attributesForRelval relvalAttrName (Relation attrs _) = do

@@ -244,8 +251,7 @@ relMap mapper (Relation attrs tupleSet) =

244251

245252relMogrify :: (RelationTuple -> Either RelationalError RelationTuple) -> Attributes -> Relation -> Either RelationalError Relation

246253relMogrify mapper newAttributes (Relation _ tupSet) = do

247− newTuples <- mapM (fmap (reorderTuple newAttributes) . mapper) (asList tupSet)

248−

254+ newTuples <- mapM mapper (asList tupSet)

249255 mkRelationFromTuples newAttributes newTuples

250256

251257relFold :: (RelationTuple -> a -> a) -> a -> Relation -> a

@@ -291,8 +297,7 @@ typesAsRelation types = mkRelationFromTuples attrs tuples

291297 dConsType = RelationAtomType subAttrs

292298 tuples = map mkTypeConsDescription types

293299

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

296301

297302 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

298303 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

3838 let strHeader = V.map decodeUtf8 headerRaw

3939 strMapRecords = V.map convertMap vecMapsRaw

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

4243 headerSet = S.fromList (V.toList strHeader)

4344 parseAtom attrName aType textIn = case APT.parseOnly (parseCSVAtomP attrName tConsMap aType <* APT.endOfInput) textIn of

4445 Left err -> Left (ParseError (T.pack err))

@@ -46,7 +47,7 @@ csvAsRelation attrs tConsMap inString = case APBL.parse (csvWithHeader csvDecode

4647 makeTupleList :: HM.HashMap AttributeName String -> [Either CsvImportError Atom]

4748 makeTupleList tupMap = V.toList $ V.map (\attr ->

4849 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

5051 if attrNameSet == headerSet then do

5152 tupleList <- mapM sequence $ V.toList (V.map makeTupleList strMapRecords)

5253 case mkRelationFromList attrs tupleList of

@@ -82,11 +83,6 @@ parseCSVAtomP _ _ BoolAtomType = do

8283 case readMaybe bString of

8384 Nothing -> fail ("invalid BoolAtom string: " ++ bString)

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

9086parseCSVAtomP attrName tConsMap typ@(ConstructedAtomType _ tvmap)

9187 | isIntervalAtomType typ = do

9288 begin <- (APT.char '[' >> pure False) <|> (APT.char '(' >> pure True)

src/lib/ProjectM36/Relation/Show/CSV.hs+5−5

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

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

22module ProjectM36.Relation.Show.CSV where

33import ProjectM36.Base

4−import ProjectM36.Attribute as A

4+import ProjectM36.Attribute

55import Data.Csv

66import ProjectM36.Tuple

77import qualified Data.ByteString.Lazy as BS

@@ -17,13 +17,13 @@ relationAsCSV (Relation attrs tupleSet)

1717 | relValAttrs /= [] =

1818 Left $ RelationValuedAttributesNotSupportedError (map attributeName relValAttrs)

1919 --check that there is at least one attribute

20− | A.null attrs =

20+ | V.null attrs =

2121 Left $ TupleAttributeCountMismatchError 0

2222 | otherwise =

2323 Right $ encodeByName bsAttrNames $ map RecordRelationTuple (asList tupleSet)

2424 where

25− relValAttrs = V.toList $ V.filter (isRelationAtomType . atomType) (attributesVec attrs)

26− bsAttrNames = V.map (TE.encodeUtf8 . attributeName) (attributesVec attrs)

25+ relValAttrs = V.toList $ V.filter (isRelationAtomType . atomType) attrs

26+ bsAttrNames = V.map (TE.encodeUtf8 . attributeName) attrs

2727

2828{-

2929instance ToRecord RelationTuple where

@@ -36,7 +36,7 @@ instance ToNamedRecord RecordRelationTuple where

3636 toNamedRecord rTuple = namedRecord $ map (\(k,v) -> TE.encodeUtf8 k .= RecordAtom v) (tupleAssocs $ unTuple rTuple)

3737

3838instance 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)

4040

4141newtype RecordAtom = RecordAtom {unAtom :: Atom}

4242

src/lib/ProjectM36/Relation/Show/HTML.hs+2−2

@@ -3,7 +3,6 @@ import ProjectM36.Base

33import ProjectM36.Relation

44import ProjectM36.Tuple

55import ProjectM36.Atom

6−import ProjectM36.Attribute as A

76import ProjectM36.AtomType

87import qualified Data.List as L

98import Data.Text (Text, pack)

@@ -12,9 +11,10 @@ import qualified Data.Text.IO as TIO

1211#if __GLASGOW_HASKELL__ < 804

1312import Data.Monoid

1413#endif

14+import qualified Data.Vector as V

1515

1616attributesAsHTML :: 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>"

1818 where

1919 oneAttrHTML attr = "<th>" <> prettyAttribute attr <> "</th>"

2020

src/lib/ProjectM36/RelationalExpression.hs+310−169

@@ -1,7 +1,6 @@

11{-# LANGUAGE ScopedTypeVariables #-}

22{-# LANGUAGE FlexibleInstances #-}

33{-# LANGUAGE FlexibleContexts #-}

4−{-# LANGUAGE OverloadedStrings #-}

54module ProjectM36.RelationalExpression where

65import ProjectM36.Relation

76import ProjectM36.Tuple

@@ -41,8 +40,6 @@ import Control.Monad.Reader as R hiding (join)

4140import ProjectM36.NormalizeExpr

4241import ProjectM36.WithNameExpr

4342import Test.QuickCheck

44−import qualified Data.Functor.Foldable as Fold

45−import Control.Applicative

4643#ifdef PM36_HASKELL_SCRIPTING

4744import GHC hiding (getContext)

4845import Control.Exception

@@ -110,11 +107,11 @@ askEnv :: GraphRefRelationalExprM GraphRefRelationalExprEnv

110107askEnv = R.ask

111108

112109mergeTuplesIntoGraphRefRelationalExprEnv :: RelationTuple -> GraphRefRelationalExprEnv -> GraphRefRelationalExprEnv

113−mergeTuplesIntoGraphRefRelationalExprEnv tupIn env =

114− env { gre_extra = new_elems }

110+mergeTuplesIntoGraphRefRelationalExprEnv tupIn e =

111+ e{ gre_extra = new_elems }

115112 where

116113 new_elems = Just (Left newTuple)

117− mergedTupMap = M.union (tupleToMap tupIn) (tupleToMap (envTuple env))

114+ mergedTupMap = M.union (tupleToMap tupIn) (tupleToMap (envTuple e))

118115 newTuple = mkRelationTupleFromMap mergedTupMap

119116

120117mergeAttributesIntoGraphRefRelationalExprEnv :: Attributes -> GraphRefRelationalExprEnv -> GraphRefRelationalExprEnv

@@ -212,13 +209,166 @@ envContext = re_context

212209setEnvContext :: RelationalExprEnv -> DatabaseContext -> RelationalExprEnv

213210setEnvContext e ctx = e { re_context = ctx }

214211

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

215366--helper function to process relation variable creation/assignment

216367setRelVar :: RelVarName -> GraphRefRelationalExpr -> DatabaseContextEvalMonad ()

217368setRelVar relVarName relExpr = do

218369 currentContext <- getStateContext

219− --prevent recursive relvar definition by resolving references to relvars in previous states

220− relExpr' <- resolve relExpr

221− let newRelVars = M.insert relVarName relExpr' $ relationVariables currentContext

370+ --prevent recursive relvar definition

371+ let newRelVars = M.insert relVarName relExpr $ relationVariables currentContext

222372 potentialContext = currentContext { relationVariables = newRelVars }

223373 --optimization: if the relexpr is unchanged, skip the update

224374 if M.lookup relVarName (relationVariables currentContext) == Just relExpr then

@@ -231,9 +381,6 @@ setRelVar relVarName relExpr = do

231381 Left err -> dbErr err

232382 Right _ -> putStateContext potentialContext

233383

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−

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

238385deleteRelVar :: RelVarName -> DatabaseContextEvalMonad ()

239386deleteRelVar relVarName = do

@@ -299,36 +446,20 @@ evalGraphRefDatabaseContextExpr (Assign relVarName expr) = do

299446

300447evalGraphRefDatabaseContextExpr (Insert relVarName relExpr) = do

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

306453

307454evalGraphRefDatabaseContextExpr (Delete relVarName predicate) = do

308455 gfExpr <- relVarByName relVarName

309− let optExpr = applyRestrictionCollapse (Restrict (NotPredicate predicate) gfExpr)

310− setRelVar relVarName optExpr

456+ setRelVar relVarName (Restrict (NotPredicate predicate) gfExpr)

311457

312458--union of restricted+updated portion and the unrestricted+unupdated portion

313459evalGraphRefDatabaseContextExpr (Update relVarName atomExprMap pred') = do

314460 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

323461 let unrestrictedPortion = Restrict (NotPredicate pred') rvExpr

324− tmpAttr = tmpAttrC 1

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

462+ tmpAttr attr = "_tmp_" <> attr --this could certainly be improved to verify that there is no attribute name conflict

332463 updateAttr nam atomExpr = Extend (AttributeExtendTupleExpr (tmpAttr nam) atomExpr)

333464 projectAndRename attr expr = Rename (tmpAttr attr) attr (Project (InvertedAttributeNames (S.singleton attr)) expr)

334465 restrictedPortion = Restrict pred' rvExpr

@@ -610,7 +741,6 @@ evalGraphRefDatabaseContextIOExpr (LoadDatabaseContextFunctions modName funcName

610741 Right dbcListFunc -> let newContext = currentContext { dbcFunctions = mergedFuncs }

611742 mergedFuncs = HS.union (dbcFunctions currentContext) (HS.fromList dbcListFunc)

612743 in putDBCIOContext newContext

613−#endif

614744evalGraphRefDatabaseContextIOExpr (CreateArbitraryRelation relVarName attrExprs range) = do

615745 --Define

616746 currentContext <- getDBCIOContext

@@ -641,10 +771,22 @@ evalGraphRefDatabaseContextIOExpr (CreateArbitraryRelation relVarName attrExprs

641771 case runDatabaseContextEvalMonad currentContext evalEnv (setRelVar relVarName (ExistingRelation rel)) of

642772 Left err -> pure (Left err)

643773 Right dbstate' -> putDBCIOContext (dbc_context dbstate')

644−

774+#endif

775+{-

776+updateTupleWithAtomExprs :: M.Map AttributeName AtomExpr -> DatabaseContext -> TransactionGraph -> RelationTuple -> Either RelationalError RelationTuple

777+updateTupleWithAtomExprs exprMap context graph tupIn = do

778+ --resolve all atom exprs

779+ let

780+ atomsAssoc <- mapM (\(attrName, atomExpr) -> do

781+ let atom = unimplemented

782+ --atom <- runReader (evalAtomExpr tupIn atomExpr) (mkRelationalExprState context graph)

783+ pure (attrName, atom)

784+ ) (M.toList exprMap)

785+ pure (updateTupleWithAtoms (M.fromList atomsAssoc) tupIn)

786+-}

645787--run verification on all constraints

646788checkConstraints :: DatabaseContext -> TransactionId -> TransactionGraph -> Either RelationalError ()

647−checkConstraints context transId graph@(TransactionGraph graphHeads transSet) = do

789+checkConstraints context transId graph@(TransactionGraph graphHeads transSet) =

648790 mapM_ (uncurry checkIncDep) (M.toList deps)

649791 where

650792 potentialGraph = TransactionGraph graphHeads (S.insert tempTrans transSet)

@@ -693,6 +835,15 @@ typeForRelationalExpr expr = do

693835 runGf = runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr gfExpr)

694836 lift $ except runGf

695837

838+--returns a database context with all tuples removed

839+--this is useful for type checking and optimization

840+{-

841+contextWithEmptyTupleSets :: DatabaseContext -> DatabaseContext

842+contextWithEmptyTupleSets contextIn = contextIn { relationVariables = relVars }

843+ where

844+ relVars = M.map (\rel -> ExistingRelation (Relation (attributes rel) emptyTupleSet)) (relationVariables contextIn)

845+-}

846+

696847liftE :: (Monad m) => m (Either a b) -> ExceptT a m b

697848liftE v = do

698849 y <- lift v

@@ -848,6 +999,58 @@ evalGraphRefAtomExpr tupIn cons@(ConstructedAtomExpr dConsName dConsArgs _) = do

848999 mapM (evalGraphRefAtomExpr tupIn) dConsArgs

8491000 pure (ConstructedAtom dConsName aType argAtoms)

8501001

1002+{-

1003+evalAtomExpr :: RelationTuple -> AtomExpr -> RelationalExprM Atom

1004+evalAtomExpr tupIn expr =

1005+ -}

1006+{-

1007+

1008+evalAtomExpr tupIn (AttributeAtomExpr attrName) = case atomForAttributeName attrName tupIn of

1009+ Right atom -> pure (Right atom)

1010+ err@(Left (NoSuchAttributeNamesError _)) -> do

1011+ rstate <- ask

1012+ let stateTup = stateTuple rstate

1013+ pure (atomForAttributeName attrName stateTup)

1014+ Left err -> pure (Left err)

1015+evalAtomExpr _ (NakedAtomExpr atom) = pure (Right atom)

1016+evalAtomExpr tupIn (FunctionAtomExpr funcName arguments ()) = do

1017+ argTypes <- mapM (typeFromAtomExpr (tupleAttributes tupIn)) arguments

1018+ context <- fmap stateElemsContext ask

1019+ runExceptT $ do

1020+ let functions = atomFunctions context

1021+ func <- either throwE pure (atomFunctionForName funcName functions)

1022+ let expectedArgCount = length (atomFuncType func) - 1

1023+ actualArgCount = length argTypes

1024+ safeInit [] = [] -- different behavior from normal init

1025+ safeInit xs = init xs

1026+ if expectedArgCount /= actualArgCount then

1027+ throwE (FunctionArgumentCountMismatchError expectedArgCount actualArgCount)

1028+ else do

1029+ let zippedArgs = zip (safeInit (atomFuncType func)) argTypes

1030+ mapM_ (\(expType, eActType) -> do

1031+ actType <- either throwE pure eActType

1032+ either throwE pure (atomTypeVerify expType actType)) zippedArgs

1033+ evaldArgs <- mapM (liftE . evalAtomExpr tupIn) arguments

1034+ case evalAtomFunction func evaldArgs of

1035+ Left err -> throwE (AtomFunctionUserError err)

1036+ Right result -> do

1037+ --validate that the result matches the expected type

1038+ _ <- either throwE pure (atomTypeVerify (last (atomFuncType func)) (atomTypeForAtom result))

1039+ pure result

1040+evalAtomExpr tupIn (RelationAtomExpr relExpr) = do

1041+ --merge existing state tuple context into new state tuple context to support an arbitrary number of levels, but new attributes trounce old attributes

1042+ rstate <- ask

1043+ runExceptT $ do

1044+ let newState = mergeTuplesIntoRelationalExprState tupIn rstate

1045+ relAtom <- either throwE pure (runReader (evalRelationalExpr relExpr) newState)

1046+ pure (RelationAtom relAtom)

1047+evalAtomExpr tupIn cons@(ConstructedAtomExpr dConsName dConsArgs ()) = runExceptT $ do

1048+ rstate <- lift ask

1049+ let newState = mergeTuplesIntoRelationalExprState tupIn rstate

1050+ aType <- either throwE pure (runReader (typeFromAtomExpr (tupleAttributes tupIn) cons) newState)

1051+ argAtoms <- mapM (\arg -> either throwE pure (runReader (evalAtomExpr tupIn arg) newState)) dConsArgs

1052+ pure (ConstructedAtom dConsName aType argAtoms)

1053+-}

8511054typeForGraphRefAtomExpr :: Attributes -> GraphRefAtomExpr -> GraphRefRelationalExprM AtomType

8521055typeForGraphRefAtomExpr attrs (AttributeAtomExpr attrName) = do

8531056 renv <- askEnv

@@ -914,7 +1117,7 @@ verifyGraphRefAtomExprTypes relIn (FunctionAtomExpr funcName funcArgExprs tid) e

9141117 let handler :: RelationalError -> GraphRefRelationalExprM AtomType

9151118 handler (AtomTypeMismatchError expSubType actSubType) = throwError (AtomFunctionTypeError funcName argCount expSubType actSubType)

9161119 handler err = throwError err

917− verifyGraphRefAtomExprTypes relIn atomExpr expectedType2 `catchError` handler

1120+ verifyGraphRefAtomExprTypes relIn atomExpr expectedType2 `catchError` handler

9181121 funcArgTypes <- mapM funcArgVerifier $ zip3 funcArgExprs expectedArgTypes [1..]

9191122 if length funcArgTypes /= length expectedArgTypes - 1 then

9201123 throwError (AtomTypeCountError funcArgTypes expectedArgTypes)

@@ -951,27 +1154,15 @@ evalGraphRefTupleExprs mAttrs (TupleExprs fixedMarker tupleExprL) = do

9511154 [] -> pure emptyAttributes

9521155 (headTuple:tailTuples) -> do

9531156 --gather up resolved atom types or throw an error if an attribute cannot be made concrete from the inferred types- this could still fail if the type cannot be inferred (e.g. from [Nothing, Nothing])

954− let

955− processTupleAttrs (tupAttr, accAttr) =

956− --if the attribute is a constructedatomtype, we can recurse into it to potentially resolve type variables

957− if isResolvedAttribute accAttr && tupAttr == accAttr then

958− pure accAttr

959− else

960− lift $ except $ resolveAttributes accAttr tupAttr

961− mostResolvedTypes <-

962− foldM (\acc tup -> do

963− let zipped = zip (V.toList . attributesVec $ tupleAttributes tup) acc

964− accNames = S.fromList $ map A.attributeName acc

965− tupNames = A.attributeNameSet (tupleAttributes tup)

966− attrNamesDiff = S.union (S.difference accNames tupNames) (S.difference tupNames accNames)

967− unless (null attrNamesDiff) (throwError (AttributeNamesMismatchError attrNamesDiff))

968− nextTupleAttrs <- mapM processTupleAttrs zipped

969− let diff = A.attributesDifference (A.attributesFromList nextTupleAttrs) (A.attributesFromList acc)

970− if diff == A.emptyAttributes then

971− pure nextTupleAttrs

972− else

973− throwError (TupleAttributeTypeMismatchError diff)

974− ) (V.toList . attributesVec $ tupleAttributes headTuple) tailTuples

1157+ let mostResolvedTypes =

1158+ foldr (\tup acc ->

1159+ fmap (\(tupAttr,accAttr) -> --if the attribute is a constructedatomtype, we can recurse into it to potentially resolve type variables

1160+ if isResolvedAttribute accAttr then

1161+ accAttr

1162+ else

1163+ case resolveAttributes accAttr tupAttr of

1164+ Left _ -> accAttr

1165+ Right val -> val) (zip (V.toList $ tupleAttributes tup) acc)) (V.toList $ tupleAttributes headTuple) tailTuples

9751166 pure (A.attributesFromList mostResolvedTypes)

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

9771168 tConsMap <- case singularTransactions tupleExprL of

@@ -1017,6 +1208,56 @@ evalGraphRefTupleExpr mAttrs (TupleExpr tupMap) = do

10171208-- _ <- lift $ except (validateTuple tup' tConss)

10181209 pure tup'

10191210

1211+{-

1212+evalAttributeNames :: AttributeNames -> RelationalExpr -> RelationalExprM (Either RelationalError (S.Set AttributeName))

1213+evalAttributeNames attrNames expr = do

1214+ eExprType <- typeForRelationalExpr expr

1215+ case eExprType of

1216+ Left err -> throwError err

1217+ Right exprTyp -> do

1218+ let typeNameSet = S.fromList (V.toList (A.attributeNames (attributes exprTyp)))

1219+ case attrNames of

1220+ AttributeNames names ->

1221+ case A.projectionAttributesForNames names (attributes exprTyp) of

1222+ Left err -> pure (Left err)

1223+ Right attrs -> pure (Right (S.fromList (V.toList (A.attributeNames attrs))))

1224+

1225+ InvertedAttributeNames names -> do

1226+ let nonExistentAttributeNames = A.attributeNamesNotContained names typeNameSet

1227+ if not (S.null nonExistentAttributeNames) then

1228+ pure (Left (AttributeNamesMismatchError nonExistentAttributeNames))

1229+ else

1230+ pure (Right (A.nonMatchingAttributeNameSet names typeNameSet))

1231+

1232+ UnionAttributeNames namesA namesB -> do

1233+ eNameSetA <- evalAttributeNames namesA expr

1234+ case eNameSetA of

1235+ Left err -> pure (Left err)

1236+ Right nameSetA -> do

1237+ eNameSetB <- evalAttributeNames namesB expr

1238+ case eNameSetB of

1239+ Left err -> pure (Left err)

1240+ Right nameSetB ->

1241+ pure (Right (S.union nameSetA nameSetB))

1242+

1243+ IntersectAttributeNames namesA namesB -> do

1244+ eNameSetA <- evalAttributeNames namesA expr

1245+ case eNameSetA of

1246+ Left err -> pure (Left err)

1247+ Right nameSetA -> do

1248+ eNameSetB <- evalAttributeNames namesB expr

1249+ case eNameSetB of

1250+ Left err -> pure (Left err)

1251+ Right nameSetB ->

1252+ pure (Right (S.intersection nameSetA nameSetB))

1253+

1254+ RelationalExprAttributeNames attrExpr -> do

1255+ eAttrExprType <- typeForRelationalExpr attrExpr

1256+ case eAttrExprType of

1257+ Left err -> pure (Left err)

1258+ Right attrExprType -> pure (Right (A.attributeNameSet (attributes attrExprType)))

1259+-}

1260+

10201261--temporary implementation until we have a proper planner+executor

10211262evalGraphRefRelationalExpr :: GraphRefRelationalExpr -> GraphRefRelationalExprM Relation

10221263evalGraphRefRelationalExpr (MakeRelationFromExprs mAttrExprs tupleExprs) = do

@@ -1245,7 +1486,7 @@ relationVariablesAsRelation ctx graph = do

12451486 let gfEnv = freshGraphRefRelationalExprEnv (Just ctx) graph

12461487 gfType <- runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr gfExpr)

12471488 pure (rvName, gfType)

1248− relVarToAtomList (rvName, rel) = [TextAtom rvName, attributesToRel (attributesVec (attributes rel))]

1489+ relVarToAtomList (rvName, rel) = [TextAtom rvName, attributesToRel (attributes rel)]

12491490 attrAtoms a = [TextAtom (A.attributeName a), TextAtom (prettyAtomType (A.atomType a))]

12501491 attributesToRel attrl = case mkRelationFromList subrelAttrs (map attrAtoms (V.toList attrl)) of

12511492 Left err -> error ("relationVariablesAsRelation pooped " ++ show err)

@@ -1265,6 +1506,15 @@ evalRelationalExpr expr = do

12651506 Left err -> throwError err

12661507 Right rel -> pure rel

12671508

1509+{-

1510+relVarByName :: RelVarName -> GraphRefRelationalExprM GraphRefRelationalExpr

1511+relVarByName = do

1512+ relvars <- relationVariables <$> getStateContext

1513+ case M.lookup relVarName relvars of

1514+ Nothing -> dbErr (RelVarNotDefinedError relVarName)

1515+ Just gfexpr -> pure gfExpr

1516+-}

1517+

12681518class (MonadError RelationalError m, Monad m) => DatabaseContextM m where

12691519 getContext :: m DatabaseContext

12701520

@@ -1281,112 +1531,3 @@ relVarByName rvName = do

12811531 Nothing -> throwError (RelVarNotDefinedError rvName)

12821532 Just gfexpr -> pure gfexpr

12831533

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+4−11

@@ -18,7 +18,6 @@ import System.Info (os, arch)

1818import Data.Text (Text, unpack)

1919import Data.Maybe

2020import GHC.Paths (libdir)

21−import System.Environment

2221#if __GLASGOW_HASKELL__ >= 800

2322import GHC.LanguageExtensions

2423import GHCi.ObjLink

@@ -79,8 +78,6 @@ initScriptSession ghcPkgPaths = do

7978 handleGhcException excHandler $ runGhc (Just libdir) $ do

8079 dflags <- getSessionDynFlags

8180 let ghcVersion = projectVersion dflags

82− -- get nix packages dir, if available

83− mNixLibDir <- liftIO $ lookupEnv "NIX_GHC_LIBDIR"

8481

8582 sandboxPkgPaths <- liftIO $ concat <$> mapM glob [

8683 --"./dist-newstyle/packagedb/ghc-" ++ ghcVersion, --rely on cabal 3's ghc.environment install: "cabal install --lib project-m36"

@@ -92,7 +89,7 @@ initScriptSession ghcPkgPaths = do

9289 --homeDir </> ".cabal/store/ghc-" ++ ghcVersion ++ "/package.db"

9390 ]

9491

95− let localPkgPaths = map PkgConfFile (ghcPkgPaths ++ sandboxPkgPaths ++ maybeToList mNixLibDir)

92+ let localPkgPaths = map PkgConfFile (ghcPkgPaths ++ sandboxPkgPaths)

9693

9794 let dflags' = applyGopts . applyXopts $ dflags { hscTarget = HscInterpreted ,

9895 ghcLink = LinkInMemory,

@@ -128,6 +125,8 @@ initScriptSession ghcPkgPaths = do

128125 "uuid",

129126 "vector",

130127 "text",

128+ "binary",

129+ "vector-binary-instances",

131130 "time",

132131 "project-m36",

133132 "bytestring"]

@@ -145,9 +144,7 @@ initScriptSession ghcPkgPaths = do

145144 ideclSourceSrc = Nothing,

146145#endif

147146

148−#if __GLASGOW_HASKELL__ >= 810

149− ideclExt = noExtField,

150−#elif __GLASGOW_HASKELL__ >= 806

147+#if __GLASGOW_HASKELL__ >= 806

151148 ideclExt = NoExt,

152149#endif

153150 ideclName = noLoc mn,

@@ -155,11 +152,7 @@ initScriptSession ghcPkgPaths = do

155152 ideclSource = False,

156153 ideclSafe = True,

157154 ideclImplicit = False,

158−#if __GLASGOW_HASKELL__ >= 810

159− ideclQualified = if isJust mQual then QualifiedPre else NotQualified,

160−#else

161155 ideclQualified = isJust mQual,

162−#endif

163156 ideclAs = mQual,

164157 ideclHiding = Nothing

165158 }

src/lib/ProjectM36/Serialise/AtomFunctionError.hsdeleted−7

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

1−{-# LANGUAGE DerivingVia, StandaloneDeriving #-}

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

3−module ProjectM36.Serialise.AtomFunctionError where

4−import Codec.Winery

5−import ProjectM36.AtomFunctionError

6−

7−deriving via WineryVariant AtomFunctionError instance Serialise AtomFunctionError

src/lib/ProjectM36/Serialise/Base.hsdeleted−85

@@ -1,85 +0,0 @@

1−{-# LANGUAGE StandaloneDeriving, DerivingVia, TypeApplications, TypeSynonymInstances, ScopedTypeVariables #-}

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

3−--Serialise instances for ProjectM36.Base data types- orphan instance city

4−module ProjectM36.Serialise.Base where

5−import Codec.Winery hiding (Schema)

6−import Codec.Winery.Internal

7−import Control.Monad

8−import ProjectM36.Base

9−import ProjectM36.MerkleHash

10−import Data.UUID

11−import Data.Proxy

12−import Data.Word

13−import ProjectM36.Attribute as A

14−import qualified Data.List.NonEmpty as NE

15−import qualified Data.Vector as V

16−import Data.Time.Calendar (Day,toGregorian,fromGregorian)

17−

18−deriving via WineryVariant Atom instance Serialise Atom

19−deriving via WineryVariant AtomType instance Serialise AtomType

20−deriving via WineryVariant Attribute instance Serialise Attribute

21−deriving via WineryVariant RelationTupleSet instance Serialise RelationTupleSet

22−deriving via WineryVariant RelationTuple instance Serialise RelationTuple

23−deriving via WineryVariant Relation instance Serialise Relation

24−deriving via WineryVariant RelationCardinality instance Serialise RelationCardinality

25−deriving via WineryVariant (RelationalExprBase a) instance Serialise a => Serialise (RelationalExprBase a)

26−deriving via WineryVariant (WithNameExprBase a) instance Serialise a => Serialise (WithNameExprBase a)

27−deriving via WineryVariant Notification instance Serialise Notification

28−deriving via WineryVariant TypeConstructorDef instance Serialise TypeConstructorDef

29−deriving via WineryVariant (TypeConstructorBase a) instance Serialise a => Serialise (TypeConstructorBase a)

30−deriving via WineryVariant DataConstructorDef instance Serialise DataConstructorDef

31−deriving via WineryVariant DataConstructorDefArg instance Serialise DataConstructorDefArg

32−deriving via WineryVariant GraphRefTransactionMarker instance Serialise GraphRefTransactionMarker

33−deriving via WineryVariant SchemaIsomorph instance Serialise SchemaIsomorph

34−deriving via WineryVariant InclusionDependency instance Serialise InclusionDependency

35−deriving via WineryVariant (DatabaseContextExprBase a) instance Serialise a => Serialise (DatabaseContextExprBase a)

36−deriving via WineryVariant (DatabaseContextIOExprBase a) instance Serialise a => Serialise (DatabaseContextIOExprBase a)

37−deriving via WineryVariant (RestrictionPredicateExprBase a) instance Serialise a => Serialise (RestrictionPredicateExprBase a)

38−deriving via WineryVariant TransactionInfo instance Serialise TransactionInfo

39−deriving via WineryVariant (AtomExprBase a) instance Serialise a => Serialise (AtomExprBase a)

40−deriving via WineryVariant MerkleHash instance Serialise MerkleHash

41−deriving via WineryVariant (AttributeExprBase a) instance Serialise a => Serialise (AttributeExprBase a)

42−deriving via WineryVariant (TupleExprsBase a) instance Serialise a => Serialise (TupleExprsBase a)

43−deriving via WineryVariant (TupleExprBase a) instance Serialise a => Serialise (TupleExprBase a)

44−deriving via WineryVariant (AttributeNamesBase a) instance Serialise a => Serialise (AttributeNamesBase a)

45−deriving via WineryVariant (ExtendTupleExprBase a) instance Serialise a => Serialise (ExtendTupleExprBase a)

46−deriving via WineryVariant Schema instance Serialise Schema

47−deriving via WineryVariant MergeStrategy instance Serialise MergeStrategy

48−

49−fromWordsTup :: (Word32, Word32, Word32, Word32) -> TransactionId

50−fromWordsTup (a,b,c,d) = fromWords a b c d

51−

52−instance Serialise TransactionId where

53− schemaGen _ = getSchema (Proxy @(Word32, Word32, Word32, Word32))

54− toBuilder uuid = toBuilder (toWords uuid)

55− extractor = fromWordsTup <$> extractor

56− decodeCurrent = fromWordsTup <$> decodeCurrent

57−

58−instance Serialise a => Serialise (NE.NonEmpty a) where

59− schemaGen _ = SVector <$> getSchema (Proxy @a)

60− toBuilder xs = varInt (length xs) <> foldMap toBuilder xs

61− extractor = NE.fromList . V.toList <$> extractListBy extractor --use nonempty instead to replace error with winery error

62− decodeCurrent = do

63− n <- decodeVarInt

64− l <- replicateM n decodeCurrent

65− pure (NE.fromList l)

66−

67−fromGregorianTup :: (Integer, Int, Int) -> Day

68−fromGregorianTup (a, b, c) = fromGregorian a b c

69−

70−instance Serialise Day where

71− schemaGen _ = getSchema (Proxy @(Integer, Int, Int))

72− toBuilder day = toBuilder (toGregorian day)

73− extractor = fromGregorianTup <$> extractor

74− decodeCurrent = fromGregorianTup <$> decodeCurrent

75−

76−instance Serialise Attributes where

77− schemaGen _ = SVector <$> getSchema (Proxy @Attribute)

78− toBuilder attrs = varInt (V.length (attributesVec attrs)) <> foldMap toBuilder (V.toList (attributesVec attrs))

79− extractor =

80− attributesFromList . V.toList <$> extractListBy extractor

81−

82− decodeCurrent = do

83− n <- decodeVarInt

84− l <- replicateM n decodeCurrent

85− pure (A.attributesFromList l)

src/lib/ProjectM36/Serialise/DataFrame.hsdeleted−13

@@ -1,13 +0,0 @@

1−{-# LANGUAGE DerivingVia, StandaloneDeriving #-}

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

3−module ProjectM36.Serialise.DataFrame where

4−import Codec.Winery

5−import ProjectM36.DataFrame

6−import ProjectM36.Serialise.Base ()

7−

8−deriving via WineryVariant AttributeOrderExpr instance Serialise AttributeOrderExpr

9−deriving via WineryVariant AttributeOrder instance Serialise AttributeOrder

10−deriving via WineryVariant Order instance Serialise Order

11−deriving via WineryRecord DataFrame instance Serialise DataFrame

12−deriving via WineryVariant DataFrameTuple instance Serialise DataFrameTuple

13−deriving via WineryRecord DataFrameExpr instance Serialise DataFrameExpr

src/lib/ProjectM36/Serialise/DatabaseContextFunctionError.hsdeleted−7

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

1−{-# LANGUAGE DerivingVia, StandaloneDeriving #-}

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

3−module ProjectM36.Serialise.DatabaseContextFunctionError where

4−import Codec.Winery

5−import ProjectM36.DatabaseContextFunctionError

6−

7−deriving via WineryVariant DatabaseContextFunctionError instance Serialise DatabaseContextFunctionError

src/lib/ProjectM36/Serialise/Error.hsdeleted−15

@@ -1,15 +0,0 @@

1−{-# LANGUAGE DerivingVia, StandaloneDeriving #-}

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

3−module ProjectM36.Serialise.Error where

4−import ProjectM36.Error

5−import Codec.Winery

6−import ProjectM36.Serialise.Base ()

7−import ProjectM36.Serialise.AtomFunctionError ()

8−import ProjectM36.Serialise.DatabaseContextFunctionError ()

9−

10−deriving via WineryVariant RelationalError instance Serialise RelationalError

11−deriving via WineryVariant MergeError instance Serialise MergeError

12−deriving via WineryVariant ScriptCompilationError instance Serialise ScriptCompilationError

13−deriving via WineryVariant PersistenceError instance Serialise PersistenceError

14−deriving via WineryVariant SchemaError instance Serialise SchemaError

15−deriving via WineryVariant ImportError' instance Serialise ImportError'

src/lib/ProjectM36/Serialise/IsomorphicSchema.hsdeleted−7

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

1−{-# LANGUAGE StandaloneDeriving, DerivingVia, TypeSynonymInstances, ScopedTypeVariables #-}

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

3−module ProjectM36.Serialise.IsomorphicSchema where

4−import Codec.Winery

5−import ProjectM36.IsomorphicSchema

6−

7−deriving via WineryVariant SchemaExpr instance Serialise SchemaExpr

src/lib/ProjectM36/Serialise/MergeError.hsdeleted−1

@@ -1 +0,0 @@

1−

src/lib/ProjectM36/Server.hs+91−166

@@ -7,119 +7,77 @@ import ProjectM36.Server.RemoteCallTypes

77import ProjectM36.Server.Config (ServerConfig(..))

88import ProjectM36.FSType

10−import Control.Concurrent.MVar (MVar)

10+import Control.Monad.IO.Class (liftIO)

11+#if MIN_VERSION_network_transport_tcp(0,7,0)

12+import Network.Transport.TCP (createTransport, defaultTCPParameters, defaultTCPAddr)

13+#else

14+import Network.Transport.TCP (createTransport, defaultTCPParameters)

15+#endif

16+import Network.Transport (EndPointAddress(..), newEndPoint, address)

17+import Control.Distributed.Process.Node (initRemoteTable, runProcess, newLocalNode, initRemoteTable)

18+import Control.Distributed.Process.Extras.Time (Delay(..))

19+import Control.Distributed.Process (Process, register, getSelfPid)

20+import Control.Distributed.Process.ManagedProcess (defaultProcess, UnhandledMessagePolicy(..), ProcessDefinition(..), handleCall, serve, InitHandler, InitResult(..))

21+import Control.Concurrent.MVar (putMVar, MVar)

1122import System.IO (stderr, hPutStrLn)

1223import System.FilePath (takeDirectory)

1324import System.Directory (doesDirectoryExist)

14−import Network.RPC.Curryer.Server

15−import Network.Socket

16−import qualified StmContainers.Map as StmMap

17−import Control.Concurrent.STM

18−

19−type TestMode = Bool

20−

21−requestHandlers :: TestMode -> Maybe Timeout -> RequestHandlers ServerState

22−requestHandlers testFlag ti =

23− [

24− RequestHandler (\sState (Login dbName) -> do

25− addClientLogin dbName sState

26− conn <- getConn sState

27− handleLogin conn (connectionSocket sState)),

28− RequestHandler (\sState Logout -> do

29− conn <- getConn sState

30− handleLogout ti conn),

31− RequestHandler $ \sState (ExecuteHeadName sessionId) -> do

32− --socket -> dbname --maybe create a socket->client state mapping in the server state, too

33− conn <- getConn sState

34− handleExecuteHeadName ti sessionId conn,

35− RequestHandler (\sState (ExecuteRelationalExpr sessionId expr) -> do

36− conn <- getConn sState

37− handleExecuteRelationalExpr ti sessionId conn expr),

38− RequestHandler (\sState (ExecuteDataFrameExpr sessionId expr) -> do

39− conn <- getConn sState

40− handleExecuteDataFrameExpr ti sessionId conn expr),

41− RequestHandler (\sState (ExecuteDatabaseContextExpr sessionId expr) -> do

42− conn <- getConn sState

43− handleExecuteDatabaseContextExpr ti sessionId conn expr),

44− RequestHandler (\sState (ExecuteDatabaseContextIOExpr sessionId expr) -> do

45− conn <- getConn sState

46− handleExecuteDatabaseContextIOExpr ti sessionId conn expr),

47− RequestHandler (\sState (ExecuteGraphExpr sessionId expr) -> do

48− conn <- getConn sState

49− handleExecuteGraphExpr ti sessionId conn expr),

50− RequestHandler (\sState (ExecuteTransGraphRelationalExpr sessionId expr) -> do

51− conn <- getConn sState

52− handleExecuteTransGraphRelationalExpr ti sessionId conn expr),

53− RequestHandler (\sState (ExecuteTypeForRelationalExpr sessionId expr) -> do

54− conn <- getConn sState

55− handleExecuteTypeForRelationalExpr ti sessionId conn expr),

56− RequestHandler (\sState (RetrieveInclusionDependencies sessionId) -> do

57− conn <- getConn sState

58− handleRetrieveInclusionDependencies ti sessionId conn),

59− RequestHandler (\sState (RetrievePlanForDatabaseContextExpr sessionId dbExpr) -> do

60− conn <- getConn sState

61− handleRetrievePlanForDatabaseContextExpr ti sessionId conn dbExpr),

62− RequestHandler (\sState (RetrieveHeadTransactionId sessionId) -> do

63− conn <- getConn sState

64− handleRetrieveHeadTransactionId ti sessionId conn),

65− RequestHandler (\sState (RetrieveTransactionGraph sessionId) -> do

66− conn <- getConn sState

67− handleRetrieveTransactionGraph ti sessionId conn),

68− RequestHandler (\sState (CreateSessionAtHead headn) -> do

69− conn <- getConn sState

70− handleCreateSessionAtHead ti conn headn),

71− RequestHandler (\sState (CreateSessionAtCommit commitId) -> do

72− conn <- getConn sState

73− handleCreateSessionAtCommit ti conn commitId),

74− RequestHandler (\sState (CloseSession sessionId) -> do

75− conn <- getConn sState

76− handleCloseSession sessionId conn),

77− RequestHandler (\sState (RetrieveAtomTypesAsRelation sessionId) -> do

78− conn <- getConn sState

79− handleRetrieveAtomTypesAsRelation ti sessionId conn),

80− RequestHandler (\sState (RetrieveRelationVariableSummary sessionId) -> do

81− conn <- getConn sState

82− handleRetrieveRelationVariableSummary ti sessionId conn),

83− RequestHandler (\sState (RetrieveAtomFunctionSummary sessionId) -> do

84− conn <- getConn sState

85− handleRetrieveAtomFunctionSummary ti sessionId conn),

86− RequestHandler (\sState (RetrieveDatabaseContextFunctionSummary sessionId) -> do

87− conn <- getConn sState

88− handleRetrieveDatabaseContextFunctionSummary ti sessionId conn), RequestHandler (\sState (RetrieveCurrentSchemaName sessionId) -> do

89− conn <- getConn sState

90− handleRetrieveCurrentSchemaName ti sessionId conn),

91− RequestHandler (\sState (ExecuteSchemaExpr sessionId schemaExpr) -> do

92− conn <- getConn sState

93− handleExecuteSchemaExpr ti sessionId conn schemaExpr),

94− RequestHandler (\sState (RetrieveSessionIsDirty sessionId) -> do

95− conn <- getConn sState

96− handleRetrieveSessionIsDirty ti sessionId conn),

97− RequestHandler (\sState (ExecuteAutoMergeToHead sessionId strat headName') -> do

98− conn <- getConn sState

99− handleExecuteAutoMergeToHead ti sessionId conn strat headName'),

100− RequestHandler (\sState (RetrieveTypeConstructorMapping sessionId) -> do

101− conn <- getConn sState

102− handleRetrieveTypeConstructorMapping ti sessionId conn),

103− RequestHandler (\sState (ExecuteValidateMerkleHashes sessionId) -> do

104− conn <- getConn sState

105− handleValidateMerkleHashes ti sessionId conn)

106− ] ++ if testFlag then testModeHandlers ti else []

107−

108−getConn :: ConnectionState ServerState -> IO Connection

109−getConn connState = do

110− let sock = lockless (connectionSocket connState)

111− sState = connectionServerState connState

112− mConn <- connectionForClient sock sState

113− case mConn of

114− Nothing -> error "failed to find socket in client map"

115− Just conn -> pure conn

116−

117−testModeHandlers :: Maybe Timeout -> RequestHandlers ServerState

118−testModeHandlers ti = [RequestHandler (\sState (TestTimeout sessionId) -> do

119− conn <- getConn sState

120− handleTestTimeout ti sessionId conn)]

12125

26+-- the state should be a mapping of remote connection to the disconnected transaction- the graph should be the same, so discon must be removed from the stm tuple

27+--trying to refactor this for less repetition is very challenging because the return type cannot be polymorphic or the distributed-process call gets confused and drops messages

28+serverDefinition :: Bool -> Timeout -> ProcessDefinition Connection

29+serverDefinition testBool ti = defaultProcess {

30+ apiHandlers = [

31+ handleCall (\conn (ExecuteHeadName sessionId) -> handleExecuteHeadName ti sessionId conn),

32+ handleCall (\conn (ExecuteRelationalExpr sessionId expr) -> handleExecuteRelationalExpr ti sessionId conn expr),

33+ handleCall (\conn (ExecuteDataFrameExpr sessionId expr) -> handleExecuteDataFrameExpr ti sessionId conn expr),

34+ handleCall (\conn (ExecuteDatabaseContextExpr sessionId expr) -> handleExecuteDatabaseContextExpr ti sessionId conn expr),

35+ handleCall (\conn (ExecuteDatabaseContextIOExpr sessionId expr) -> handleExecuteDatabaseContextIOExpr ti sessionId conn expr),

36+ handleCall (\conn (ExecuteGraphExpr sessionId expr) -> handleExecuteGraphExpr ti sessionId conn expr),

37+ handleCall (\conn (ExecuteTransGraphRelationalExpr sessionId expr) -> handleExecuteTransGraphRelationalExpr ti sessionId conn expr),

38+ handleCall (\conn (ExecuteTypeForRelationalExpr sessionId expr) -> handleExecuteTypeForRelationalExpr ti sessionId conn expr),

39+ handleCall (\conn (RetrieveInclusionDependencies sessionId) -> handleRetrieveInclusionDependencies ti sessionId conn),

40+ handleCall (\conn (RetrievePlanForDatabaseContextExpr sessionId dbExpr) -> handleRetrievePlanForDatabaseContextExpr ti sessionId conn dbExpr),

41+ handleCall (\conn (RetrieveHeadTransactionId sessionId) -> handleRetrieveHeadTransactionId ti sessionId conn),

42+ handleCall (\conn (RetrieveTransactionGraph sessionId) -> handleRetrieveTransactionGraph ti sessionId conn),

43+ handleCall (\conn (Login procId) -> handleLogin ti conn procId),

44+ handleCall (\conn (CreateSessionAtHead headn) -> handleCreateSessionAtHead ti conn headn),

45+ handleCall (\conn (CreateSessionAtCommit commitId) -> handleCreateSessionAtCommit ti conn commitId),

46+ handleCall (\conn (CloseSession sessionId) -> handleCloseSession ti sessionId conn),

47+ handleCall (\conn (RetrieveAtomTypesAsRelation sessionId) -> handleRetrieveAtomTypesAsRelation ti sessionId conn),

48+ handleCall (\conn (RetrieveRelationVariableSummary sessionId) -> handleRetrieveRelationVariableSummary ti sessionId conn),

49+ handleCall (\conn (RetrieveAtomFunctionSummary sessionId) -> handleRetrieveAtomFunctionSummary ti sessionId conn),

50+ handleCall (\conn (RetrieveDatabaseContextFunctionSummary sessionId) -> handleRetrieveDatabaseContextFunctionSummary ti sessionId conn),

51+ handleCall (\conn (RetrieveCurrentSchemaName sessionId) -> handleRetrieveCurrentSchemaName ti sessionId conn),

52+ handleCall (\conn (ExecuteSchemaExpr sessionId schemaExpr) -> handleExecuteSchemaExpr ti sessionId conn schemaExpr),

53+ handleCall (\conn (RetrieveSessionIsDirty sessionId) -> handleRetrieveSessionIsDirty ti sessionId conn),

54+ handleCall (\conn (ExecuteAutoMergeToHead sessionId strat headName') -> handleExecuteAutoMergeToHead ti sessionId conn strat headName'),

55+ handleCall (\conn (RetrieveTypeConstructorMapping sessionId) -> handleRetrieveTypeConstructorMapping ti sessionId conn),

56+ handleCall (\conn (ExecuteValidateMerkleHashes sessionId) -> handleValidateMerkleHashes ti sessionId conn),

57+ handleCall (\conn Logout -> handleLogout ti conn)

58+ ] ++ testModeHandlers,

59+ unhandledMessagePolicy = Terminate

60+ --unhandledMessagePolicy = Log

61+ }

62+ where

63+ testModeHandlers = [handleCall (\conn (TestTimeout sessionId) -> handleTestTimeout ti sessionId conn) | testBool]

12264

65+initServer :: InitHandler (Connection, DatabaseName, Maybe (MVar EndPointAddress), EndPointAddress) Connection

66+initServer (conn, dbname, mAddressMVar, saddress) = do

67+ registerDB dbname

68+ case mAddressMVar of

69+ Nothing -> pure ()

70+ Just addressMVar -> liftIO $ putMVar addressMVar saddress

71+ --traceShowM ("server started on " ++ show saddress)

72+ pure $ InitOk conn Infinity

73+

74+registerDB :: DatabaseName -> Process ()

75+registerDB dbname = do

76+ self <- getSelfPid

77+ let dbname' = remoteDBLookupName dbname

78+ register dbname' self

79+ --liftIO $ putStrLn $ "registered " ++ (show self) ++ " " ++ dbname'

80+

12381-- | A notification callback which logs the notification to stderr and does nothing else.

12482loggingNotificationCallback :: NotificationCallback

12583loggingNotificationCallback notName evaldNot = hPutStrLn stderr $ "Notification received \"" ++ show notName ++ "\": " ++ show evaldNot

@@ -144,47 +102,9 @@ checkFSType performCheck strat =

144102checkFSErrorMsg :: String

145103checkFSErrorMsg = "The filesystem does not support journaling so writes may not be crash-safe. Use --disable-fscheck to disable this fatal error."

146104

147−-- Sockets do not implement hashable, so we just use their string values as keys

148−type SocketString = String

149−

150−data ServerState =

151− ServerState {

152− --map available databases to local database configurations

153− stateDBMap :: StmMap.Map DatabaseName Connection,

154− --map clients to database names- after logging in, clients are afixed to specific database names

155− stateClientMap :: StmMap.Map SocketString DatabaseName

156− }

157−

158−-- add a client socket to the database mapping

159−addClientLogin :: DatabaseName -> ConnectionState ServerState -> IO ()

160−addClientLogin dbName cState = do

161− let clientMap = stateClientMap (connectionServerState cState)

162− sock = lockless (connectionSocket cState)

163− atomically $ do

164− mVal <- StmMap.lookup (show sock) clientMap

165− case mVal of

166− Nothing -> StmMap.insert dbName (show sock) clientMap

167− Just _ -> pure () --TODO: throw exception- user already logged in

168−

169−connectionForClient :: Socket -> ServerState -> IO (Maybe Connection)

170−connectionForClient sock sState =

171− atomically $ do

172− mdbname <- StmMap.lookup (show sock) (stateClientMap sState)

173− case mdbname of

174− Nothing -> pure Nothing

175− Just dbname ->

176− StmMap.lookup dbname (stateDBMap sState)

177−

178−initialServerState :: DatabaseName -> Connection -> IO ServerState

179−initialServerState dbName conn =

180− atomically $ do

181− dbmap <- StmMap.new

182− clientMap <- StmMap.new

183− StmMap.insert conn dbName dbmap

184− pure (ServerState { stateDBMap = dbmap, stateClientMap = clientMap })

185105-- | A synchronous function to start the project-m36 daemon given an appropriate 'ServerConfig'. Note that this function only returns if the server exits. Returns False if the daemon exited due to an error. If the second argument is not Nothing, the port is put after the server is ready to service the port.

186−launchServer :: ServerConfig -> Maybe (MVar SockAddr) -> IO Bool

187−launchServer daemonConfig mAddr = do

106+launchServer :: ServerConfig -> Maybe (MVar EndPointAddress) -> IO Bool

107+launchServer daemonConfig mAddressMVar = do

188108 checkFSResult <- checkFSType (checkFS daemonConfig) (persistenceStrategy daemonConfig)

189109 if not checkFSResult then do

190110 hPutStrLn stderr checkFSErrorMsg

@@ -197,21 +117,26 @@ launchServer daemonConfig mAddr = do

197117 pure False

198118 Right conn -> do

199119 let hostname = bindHost daemonConfig

200− port = fromIntegral (bindPort daemonConfig)

201−

202−

203− --curryer only supports IPv4 for now

204− let addrHints = defaultHints { addrSocketType = Stream, addrFamily = AF_INET }

205− hostAddrs <- getAddrInfo (Just addrHints) (Just hostname) Nothing

206− case hostAddrs of

207− [] -> hPutStrLn stderr ("Failed to resolve: " <> hostname) >> pure False

208− (AddrInfo _ _ _ _ (SockAddrInet _ addr32) _):_ -> do

209− let hostAddr = hostAddressToTuple addr32

210− mTimeout = fromIntegral <$> case perRequestTimeout daemonConfig of

211− 0 -> Nothing

212− v -> Just v

213−

214− sState <- initialServerState (databaseName daemonConfig) conn

215− serve (requestHandlers (testMode daemonConfig) mTimeout) sState hostAddr port mAddr

216− _ -> error "unsupported socket addressing mode (IPv4 only currently)"

217−

120+ port = bindPort daemonConfig

121+#if MIN_VERSION_network_transport_tcp(0,7,0)

122+ etransport <- createTransport (defaultTCPAddr hostname (show port)) defaultTCPParameters

123+#elif MIN_VERSION_network_transport_tcp(0,6,0)

124+ etransport <- createTransport hostname (show port) (\nam -> (hostname, nam)) defaultTCPParameters

125+#else

126+ etransport <- createTransport hostname (show port) defaultTCPParameters

127+#endif

128+ case etransport of

129+ Left err -> error ("failed to create transport: " ++ show err)

130+ Right transport -> do

131+ eEndpoint <- newEndPoint transport

132+ case eEndpoint of

133+ Left err -> hPutStrLn stderr ("Failed to create transport: " ++ show err) >> pure False

134+ Right endpoint -> do

135+ localTCPNode <- newLocalNode transport initRemoteTable

136+ --traceShowM ("newLocalNode in Server " ++ show (localNodeId localTCPNode))

137+ runProcess localTCPNode $ do

138+ let testBool = testMode daemonConfig

139+ reqTimeout = perRequestTimeout daemonConfig

140+ serve (conn, databaseName daemonConfig, mAddressMVar, address endpoint) initServer (serverDefinition testBool reqTimeout)

141+ liftIO $ putStrLn "serve returned"

142+ pure True

src/lib/ProjectM36/Server/Config.hs−6

@@ -12,12 +12,6 @@ data ServerConfig = ServerConfig { persistenceStrategy :: PersistenceStrategy,

1212 }

1313 deriving (Show)

1414

15−data WebsocketServerConfig = WebsocketServerConfig { wsServerConfig :: ServerConfig,

16− tlsCertificatePath :: Maybe String,

17− tlsKeyPath :: Maybe String

18− }

19− deriving (Show)

20−

2115defaultServerConfig :: ServerConfig

2216defaultServerConfig = ServerConfig { persistenceStrategy = NoPersistence,

2317 checkFS = True,

src/lib/ProjectM36/Server/EntryPoints.hs+157−125

@@ -3,144 +3,176 @@ module ProjectM36.Server.EntryPoints where

33import ProjectM36.Base hiding (inclusionDependencies)

44import ProjectM36.IsomorphicSchema

55import ProjectM36.Client as C

6+import ProjectM36.Error

7+import Control.Distributed.Process (Process, ProcessId)

8+import Control.Distributed.Process.ManagedProcess (ProcessReply)

9+import Control.Distributed.Process.ManagedProcess.Server (reply)

10+import Control.Distributed.Process.Async (async, task, waitCancelTimeout, AsyncResult(..))

11+import Control.Monad.IO.Class (liftIO)

612import Data.Map

713import Control.Concurrent (threadDelay)

8−import Network.RPC.Curryer.Server

9−import System.Timeout hiding (Timeout)

10−import Network.Socket

11−import Control.Exception

14+import Data.Typeable

15+import Data.Binary

1216

13−timeoutOrDie :: Maybe Timeout -> IO a -> IO (Maybe a)

14−timeoutOrDie mMicros act =

15− case mMicros of

16− Nothing -> Just <$> act

17− Just micros ->

18− timeout (fromIntegral micros) act

19−

20−timeoutRelErr :: Maybe Timeout -> IO (Either RelationalError a) -> IO (Either RelationalError a)

21−timeoutRelErr mMicros act = do

22− ret <- timeoutOrDie mMicros act

23− case ret of

24− Nothing -> throw TimeoutException

25− Just v -> pure v

26−

17+timeoutOrDie :: (Binary a, Typeable a) => Timeout -> IO a -> Process (Either ServerError a)

18+timeoutOrDie micros act =

19+ if micros == 0 then

20+ liftIO act >>= \x -> pure (Right x)

21+ else do

22+ asyncUnit <- async (task (liftIO act))

23+ asyncRes <- waitCancelTimeout micros asyncUnit

24+ case asyncRes of

25+ AsyncDone x -> pure (Right x)

26+ AsyncCancelled -> pure (Left RequestTimeoutError)

27+ AsyncFailed reason -> pure (Left (ProcessDiedError (show reason)))

28+ AsyncLinkFailed reason -> pure (Left (ProcessDiedError (show reason)))

29+ AsyncPending -> pure (Left (ProcessDiedError "process pending"))

30+

31+type Timeout = Int

2732

28−handleExecuteRelationalExpr :: Maybe Timeout -> SessionId -> Connection -> RelationalExpr -> IO (Either RelationalError Relation)

29−handleExecuteRelationalExpr ti sessionId conn expr =

30− timeoutRelErr ti (executeRelationalExpr sessionId conn expr)

33+type Reply a = Process (ProcessReply (Either ServerError a) Connection)

34+

35+handleExecuteRelationalExpr :: Timeout -> SessionId -> Connection -> RelationalExpr -> Reply (Either RelationalError Relation)

36+handleExecuteRelationalExpr ti sessionId conn expr = do

37+ ret <- timeoutOrDie ti (executeRelationalExpr sessionId conn expr)

38+ reply ret conn

3139

32−handleExecuteDataFrameExpr :: Maybe Timeout -> SessionId -> Connection -> DataFrameExpr -> IO (Either RelationalError DataFrame)

33−handleExecuteDataFrameExpr ti sessionId conn expr =

34− timeoutRelErr ti (executeDataFrameExpr sessionId conn expr)

35−

36−handleExecuteDatabaseContextExpr :: Maybe Timeout -> SessionId -> Connection -> DatabaseContextExpr -> IO (Either RelationalError ())

37−handleExecuteDatabaseContextExpr ti sessionId conn dbexpr =

38− timeoutRelErr ti (executeDatabaseContextExpr sessionId conn dbexpr)

39−

40−handleExecuteDatabaseContextIOExpr :: Maybe Timeout -> SessionId -> Connection -> DatabaseContextIOExpr -> IO (Either RelationalError ())

41−handleExecuteDatabaseContextIOExpr ti sessionId conn dbexpr =

42− timeoutRelErr ti (executeDatabaseContextIOExpr sessionId conn dbexpr)

43−

44−handleExecuteHeadName :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError HeadName)

45−handleExecuteHeadName ti sessionId conn =

46− timeoutRelErr ti (headName sessionId conn)

47−

48−handleLogin :: Connection -> Locking Socket -> IO Bool

49−handleLogin conn lockSock = do

50− addClientNode conn lockSock

51− pure True

52−

53−handleExecuteGraphExpr :: Maybe Timeout -> SessionId -> Connection -> TransactionGraphOperator -> IO (Either RelationalError ())

54−handleExecuteGraphExpr ti sessionId conn graphExpr =

55− timeoutRelErr ti (executeGraphExpr sessionId conn graphExpr)

56−

57−handleExecuteTransGraphRelationalExpr :: Maybe Timeout -> SessionId -> Connection -> TransGraphRelationalExpr -> IO (Either RelationalError Relation)

58−handleExecuteTransGraphRelationalExpr ti sessionId conn graphExpr =

59− timeoutRelErr ti (executeTransGraphRelationalExpr sessionId conn graphExpr)

40+handleExecuteDataFrameExpr :: Timeout -> SessionId -> Connection -> DataFrameExpr -> Reply (Either RelationalError DataFrame)

41+handleExecuteDataFrameExpr ti sessionId conn expr = do

42+ ret <- timeoutOrDie ti (executeDataFrameExpr sessionId conn expr)

43+ reply ret conn

44+

45+handleExecuteDatabaseContextExpr :: Timeout -> SessionId -> Connection -> DatabaseContextExpr -> Reply (Either RelationalError ())

46+handleExecuteDatabaseContextExpr ti sessionId conn dbexpr = do

47+ ret <- timeoutOrDie ti (executeDatabaseContextExpr sessionId conn dbexpr)

48+ reply ret conn

49+

50+handleExecuteDatabaseContextIOExpr :: Timeout -> SessionId -> Connection -> DatabaseContextIOExpr -> Reply (Either RelationalError ())

51+handleExecuteDatabaseContextIOExpr ti sessionId conn dbexpr = do

52+ ret <- timeoutOrDie ti (executeDatabaseContextIOExpr sessionId conn dbexpr)

53+ reply ret conn

54+

55+handleExecuteHeadName :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError HeadName)

56+handleExecuteHeadName ti sessionId conn = do

57+ ret <- timeoutOrDie ti (headName sessionId conn)

58+ reply ret conn

59+

60+handleLogin :: Timeout -> Connection -> ProcessId -> Reply Bool

61+handleLogin ti conn newClientProcessId = do

62+ ret <- timeoutOrDie ti (addClientNode conn newClientProcessId)

63+ case ret of

64+ Right () -> reply (Right True) conn

65+ Left err -> reply (Left err) conn

66+

67+handleExecuteGraphExpr :: Timeout -> SessionId -> Connection -> TransactionGraphOperator -> Reply (Either RelationalError ())

68+handleExecuteGraphExpr ti sessionId conn graphExpr = do

69+ ret <- timeoutOrDie ti (executeGraphExpr sessionId conn graphExpr)

70+ reply ret conn

71+

72+handleExecuteTransGraphRelationalExpr :: Timeout -> SessionId -> Connection -> TransGraphRelationalExpr -> Reply (Either RelationalError Relation)

73+handleExecuteTransGraphRelationalExpr ti sessionId conn graphExpr = do

74+ ret <- timeoutOrDie ti (executeTransGraphRelationalExpr sessionId conn graphExpr)

75+ reply ret conn

6076

61−handleExecuteTypeForRelationalExpr :: Maybe Timeout -> SessionId -> Connection -> RelationalExpr -> IO (Either RelationalError Relation)

62−handleExecuteTypeForRelationalExpr ti sessionId conn relExpr =

63− timeoutRelErr ti (typeForRelationalExpr sessionId conn relExpr)

64−

65−handleRetrieveInclusionDependencies :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError (Map IncDepName InclusionDependency))

66−handleRetrieveInclusionDependencies ti sessionId conn =

67− timeoutRelErr ti (inclusionDependencies sessionId conn)

68−

69−handleRetrievePlanForDatabaseContextExpr :: Maybe Timeout -> SessionId -> Connection -> DatabaseContextExpr -> IO (Either RelationalError GraphRefDatabaseContextExpr)

70−handleRetrievePlanForDatabaseContextExpr ti sessionId conn dbExpr =

71− timeoutRelErr ti (planForDatabaseContextExpr sessionId conn dbExpr)

72−

73−handleRetrieveTransactionGraph :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Relation)

74−handleRetrieveTransactionGraph ti sessionId conn =

75− timeoutRelErr ti (transactionGraphAsRelation sessionId conn)

76−

77−handleRetrieveHeadTransactionId :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError TransactionId)

78−handleRetrieveHeadTransactionId ti sessionId conn =

79− timeoutRelErr ti (headTransactionId sessionId conn)

80−

81−handleCreateSessionAtCommit :: Maybe Timeout -> Connection -> TransactionId -> IO (Either RelationalError SessionId)

82−handleCreateSessionAtCommit ti conn commitId =

83− timeoutRelErr ti (createSessionAtCommit conn commitId)

84−

85−handleCreateSessionAtHead :: Maybe Timeout -> Connection -> HeadName -> IO (Either RelationalError SessionId)

86−handleCreateSessionAtHead ti conn headn =

87− timeoutRelErr ti (createSessionAtHead conn headn)

88−

89−handleCloseSession :: SessionId -> Connection -> IO ()

90−handleCloseSession =

91− closeSession

77+handleExecuteTypeForRelationalExpr :: Timeout -> SessionId -> Connection -> RelationalExpr -> Reply (Either RelationalError Relation)

78+handleExecuteTypeForRelationalExpr ti sessionId conn relExpr = do

79+ ret <- timeoutOrDie ti (typeForRelationalExpr sessionId conn relExpr)

80+ reply ret conn

81+

82+handleRetrieveInclusionDependencies :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError (Map IncDepName InclusionDependency))

83+handleRetrieveInclusionDependencies ti sessionId conn = do

84+ ret <- timeoutOrDie ti (inclusionDependencies sessionId conn)

85+ reply ret conn

86+

87+handleRetrievePlanForDatabaseContextExpr :: Timeout -> SessionId -> Connection -> DatabaseContextExpr -> Reply (Either RelationalError GraphRefDatabaseContextExpr)

88+handleRetrievePlanForDatabaseContextExpr ti sessionId conn dbExpr = do

89+ ret <- timeoutOrDie ti (planForDatabaseContextExpr sessionId conn dbExpr)

90+ reply ret conn

91+

92+handleRetrieveTransactionGraph :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError Relation)

93+handleRetrieveTransactionGraph ti sessionId conn = do

94+ ret <- timeoutOrDie ti (transactionGraphAsRelation sessionId conn)

95+ reply ret conn

96+

97+handleRetrieveHeadTransactionId :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError TransactionId)

98+handleRetrieveHeadTransactionId ti sessionId conn = do

99+ ret <- timeoutOrDie ti (headTransactionId sessionId conn)

100+ reply ret conn

101+

102+handleCreateSessionAtCommit :: Timeout -> Connection -> TransactionId -> Reply (Either RelationalError SessionId)

103+handleCreateSessionAtCommit ti conn commitId = do

104+ ret <- timeoutOrDie ti (createSessionAtCommit conn commitId)

105+ reply ret conn

106+

107+handleCreateSessionAtHead :: Timeout -> Connection -> HeadName -> Reply (Either RelationalError SessionId)

108+handleCreateSessionAtHead ti conn headn = do

109+ ret <- timeoutOrDie ti (createSessionAtHead conn headn)

110+ reply ret conn

111+

112+handleCloseSession :: Timeout -> SessionId -> Connection -> Reply ()

113+handleCloseSession ti sessionId conn = do

114+ ret <- timeoutOrDie ti (closeSession sessionId conn)

115+ case ret of

116+ Right () -> reply (Right ()) conn

117+ Left err -> reply (Left err) conn

92118

93−handleRetrieveAtomTypesAsRelation :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Relation)

94−handleRetrieveAtomTypesAsRelation ti sessionId conn =

95− timeoutRelErr ti (atomTypesAsRelation sessionId conn)

119+handleRetrieveAtomTypesAsRelation :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError Relation)

120+handleRetrieveAtomTypesAsRelation ti sessionId conn = do

121+ ret <- timeoutOrDie ti (atomTypesAsRelation sessionId conn)

122+ reply ret conn

96123

97124-- | Returns a relation which lists the names of relvars in the current session as well as its types.

98−handleRetrieveRelationVariableSummary :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Relation)

99−handleRetrieveRelationVariableSummary ti sessionId conn =

100− timeoutRelErr ti (relationVariablesAsRelation sessionId conn)

101−

102−handleRetrieveAtomFunctionSummary :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Relation)

103−handleRetrieveAtomFunctionSummary ti sessionId conn =

104− timeoutRelErr ti (atomFunctionsAsRelation sessionId conn)

105−

106−handleRetrieveDatabaseContextFunctionSummary :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Relation)

107−handleRetrieveDatabaseContextFunctionSummary ti sessionId conn =

108− timeoutRelErr ti (databaseContextFunctionsAsRelation sessionId conn)

109−

110−handleRetrieveCurrentSchemaName :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError SchemaName)

111−handleRetrieveCurrentSchemaName ti sessionId conn =

112− timeoutRelErr ti (currentSchemaName sessionId conn)

125+handleRetrieveRelationVariableSummary :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError Relation)

126+handleRetrieveRelationVariableSummary ti sessionId conn = do

127+ ret <- timeoutOrDie ti (relationVariablesAsRelation sessionId conn)

128+ reply ret conn

129+

130+handleRetrieveAtomFunctionSummary :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError Relation)

131+handleRetrieveAtomFunctionSummary ti sessionId conn = do

132+ ret <- timeoutOrDie ti (atomFunctionsAsRelation sessionId conn)

133+ reply ret conn

134+

135+handleRetrieveDatabaseContextFunctionSummary :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError Relation)

136+handleRetrieveDatabaseContextFunctionSummary ti sessionId conn = do

137+ ret <- timeoutOrDie ti (databaseContextFunctionsAsRelation sessionId conn)

138+ reply ret conn

139+

140+handleRetrieveCurrentSchemaName :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError SchemaName)

141+handleRetrieveCurrentSchemaName ti sessionId conn = do

142+ ret <- timeoutOrDie ti (currentSchemaName sessionId conn)

143+ reply ret conn

113144

114−handleExecuteSchemaExpr :: Maybe Timeout -> SessionId -> Connection -> SchemaExpr -> IO (Either RelationalError ())

115−handleExecuteSchemaExpr ti sessionId conn schemaExpr =

116− timeoutRelErr ti (executeSchemaExpr sessionId conn schemaExpr)

145+handleExecuteSchemaExpr :: Timeout -> SessionId -> Connection -> SchemaExpr -> Reply (Either RelationalError ())

146+handleExecuteSchemaExpr ti sessionId conn schemaExpr = do

147+ ret <- timeoutOrDie ti (executeSchemaExpr sessionId conn schemaExpr)

148+ reply ret conn

117149

118−handleLogout :: Maybe Timeout -> Connection -> IO Bool

119−handleLogout _ _ =

150+handleLogout :: Timeout -> Connection -> Reply Bool

151+handleLogout _ =

120152 --liftIO $ closeRemote_ conn

121− pure True

153+ reply (pure True)

122154

123−handleTestTimeout :: Maybe Timeout -> SessionId -> Connection -> IO Bool

124−handleTestTimeout ti _ _ = do

125− ret <- timeoutRelErr ti (threadDelay 100000 >> pure (Right ()))

126− case ret of

127− Right () -> pure True

128− Left _ -> pure False

155+handleTestTimeout :: Timeout -> SessionId -> Connection -> Reply Bool

156+handleTestTimeout ti _ conn = do

157+ ret <- timeoutOrDie ti (threadDelay 100000 >> pure True)

158+ reply ret conn

129159

130−

131−

132−handleRetrieveSessionIsDirty :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Bool)

133−handleRetrieveSessionIsDirty ti sessionId conn =

134− timeoutRelErr ti (disconnectedTransactionIsDirty sessionId conn)

135−

136−handleExecuteAutoMergeToHead :: Maybe Timeout -> SessionId -> Connection -> MergeStrategy -> HeadName -> IO (Either RelationalError ())

137−handleExecuteAutoMergeToHead ti sessionId conn strat headName' =

138− timeoutRelErr ti (autoMergeToHead sessionId conn strat headName')

160+handleRetrieveSessionIsDirty :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError Bool)

161+handleRetrieveSessionIsDirty ti sessionId conn = do

162+ ret <- timeoutOrDie ti (disconnectedTransactionIsDirty sessionId conn)

163+ reply ret conn

164+

165+handleExecuteAutoMergeToHead :: Timeout -> SessionId -> Connection -> MergeStrategy -> HeadName -> Reply (Either RelationalError ())

166+handleExecuteAutoMergeToHead ti sessionId conn strat headName' = do

167+ ret <- timeoutOrDie ti (autoMergeToHead sessionId conn strat headName')

168+ reply ret conn

139169

140−handleRetrieveTypeConstructorMapping :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError TypeConstructorMapping)

141−handleRetrieveTypeConstructorMapping ti sessionId conn =

142− timeoutRelErr ti (C.typeConstructorMapping sessionId conn)

170+handleRetrieveTypeConstructorMapping :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError TypeConstructorMapping)

171+handleRetrieveTypeConstructorMapping ti sessionId conn = do

172+ ret <- timeoutOrDie ti (C.typeConstructorMapping sessionId conn)

173+ reply ret conn

143174

144−handleValidateMerkleHashes :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError ())

145−handleValidateMerkleHashes ti sessionId conn =

146− timeoutRelErr ti (C.validateMerkleHashes sessionId conn)

175+handleValidateMerkleHashes :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError ())

176+handleValidateMerkleHashes ti sessionId conn = do

177+ ret <- timeoutOrDie ti (C.validateMerkleHashes sessionId conn)

178+ reply ret conn

src/lib/ProjectM36/Server/ParseArgs.hs+15−38

@@ -17,14 +17,14 @@ parseArgsWithDefaults defaults = ServerConfig <$>

1717 many parseGhcPkgPath <*>

1818 parseTimeout (perRequestTimeout defaults) <*>

1919 parseTestMode

20−

20+

2121parsePersistenceStrategy :: Parser PersistenceStrategy

2222parsePersistenceStrategy = CrashSafePersistence <$> (dbdirOpt <* fsyncOpt) <|>

2323 MinimalPersistence <$> dbdirOpt <|>

2424 pure NoPersistence

25− where

26− dbdirOpt = strOption (short 'd' <>

27− long "database-directory" <>

25+ where

26+ dbdirOpt = strOption (short 'd' <>

27+ long "database-directory" <>

2828 metavar "DIRECTORY" <>

2929 showDefaultWith show

3030 )

@@ -34,69 +34,46 @@ parsePersistenceStrategy = CrashSafePersistence <$> (dbdirOpt <* fsyncOpt) <|>

3434

3535parseTestMode :: Parser Bool

3636parseTestMode = flag True False (long "test-mode" <> hidden)

37−

38−parseCheckFS :: Parser Bool

37+

38+parseCheckFS :: Parser Bool

3939parseCheckFS = flag True False (long "disable-fscheck" <>

4040 help "Disable filesystem check for journaling.")

41−

41+

4242parseDatabaseName :: Parser DatabaseName

4343parseDatabaseName = strOption (short 'n' <>

4444 long "database" <>

4545 metavar "DATABASE_NAME")

4646

47−parseHostname :: Hostname -> Parser Hostname

47+parseHostname :: Hostname -> Parser Hostname

4848parseHostname defHostname = strOption (short 'h' <>

4949 long "hostname" <>

5050 metavar "HOST_NAME" <>

5151 value defHostname)

52−

53−parsePort :: Port -> Parser Port

52+

53+parsePort :: Port -> Parser Port

5454parsePort defPort = option auto (short 'p' <>

5555 long "port" <>

5656 metavar "PORT_NUMBER" <>

5757 value defPort)

58−

58+

5959parseGhcPkgPath :: Parser String

6060parseGhcPkgPath = strOption (long "ghc-pkg-dir" <>

6161 metavar "GHC_PACKAGE_DIRECTORY")

62−

63−parseTimeout :: Int -> Parser Int

62+

63+parseTimeout :: Int -> Parser Int

6464parseTimeout defTimeout = option auto (long "timeout" <>

6565 metavar "MICROSECONDS" <>

6666 value defTimeout)

6767

6868parseConfig :: IO ServerConfig

6969parseConfig = parseConfigWithDefaults defaultServerConfig

70−

70+

7171parseConfigWithDefaults :: ServerConfig -> IO ServerConfig

7272parseConfigWithDefaults defaults = execParser (info (parseArgsWithDefaults defaults <**> helpOption) idm)

7373

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

9174

9275helpOption :: Parser (a -> a)

93−helpOption = abortOption helpText $ mconcat

76+helpOption = abortOption ShowHelpText $ mconcat

9477 [ long "help"

9578 , help "Show this help text"

9679 , hidden ]

97− where

98−#if MIN_VERSION_optparse_applicative(0,16,0)

99− helpText = ShowHelpText Nothing

100−#else

101− helpText = ShowHelpText

102−#endif

src/lib/ProjectM36/Server/RemoteCallTypes.hs+36−65

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

1−{-# LANGUAGE DeriveGeneric, DerivingVia, CPP #-}

1+{-# LANGUAGE DeriveAnyClass, DeriveGeneric #-}

22module ProjectM36.Server.RemoteCallTypes where

33import ProjectM36.Base

44import ProjectM36.IsomorphicSchema

@@ -6,98 +6,69 @@ import ProjectM36.TransactionGraph

66import ProjectM36.DataFrame

77import ProjectM36.TransGraphRelationalExpression

88import ProjectM36.Session

9−import ProjectM36.Serialise.DataFrame ()

10−import ProjectM36.Serialise.IsomorphicSchema ()

119import GHC.Generics

12−import Codec.Winery

13−

14−#define RPCData(typeName) deriving Generic \

15− deriving Serialise via WineryVariant typeName

10+import Data.Binary

11+import Control.Distributed.Process (ProcessId)

1612

1713{-# ANN module ("HLint: ignore Use newtype instead of data" :: String) #-}

1814-- | The initial login message. The argument should be the process id of the initiating client. This ProcessId will receive notification callbacks.

19−data Login = Login DatabaseName

20− RPCData(Login)

15+data Login = Login ProcessId

16+ deriving (Binary, Generic)

2117

2218data Logout = Logout

23− RPCData(Logout)

24−

25−data ExecuteRelationalExpr = ExecuteRelationalExpr SessionId RelationalExpr

26− RPCData(ExecuteRelationalExpr)

27−

19+ deriving (Binary, Generic)

20+data ExecuteRelationalExpr = ExecuteRelationalExpr SessionId RelationalExpr

21+ deriving (Binary, Generic)

2822data ExecuteDataFrameExpr = ExecuteDataFrameExpr SessionId DataFrameExpr

29− RPCData(ExecuteDataFrameExpr)

30−

23+ deriving (Binary, Generic)

3124data ExecuteDatabaseContextExpr = ExecuteDatabaseContextExpr SessionId DatabaseContextExpr

32− RPCData(ExecuteDatabaseContextExpr)

33−

25+ deriving (Binary, Generic)

3426data ExecuteDatabaseContextIOExpr = ExecuteDatabaseContextIOExpr SessionId DatabaseContextIOExpr

35− RPCData(ExecuteDatabaseContextIOExpr)

36−

27+ deriving (Binary, Generic)

3728data ExecuteGraphExpr = ExecuteGraphExpr SessionId TransactionGraphOperator

38− RPCData(ExecuteGraphExpr)

39−

29+ deriving (Binary, Generic)

4030data ExecuteTransGraphRelationalExpr = ExecuteTransGraphRelationalExpr SessionId TransGraphRelationalExpr

41− RPCData(ExecuteTransGraphRelationalExpr)

42−

31+ deriving (Binary, Generic)

4332data ExecuteHeadName = ExecuteHeadName SessionId

44− RPCData(ExecuteHeadName)

45−

33+ deriving (Binary, Generic)

4634data ExecuteTypeForRelationalExpr = ExecuteTypeForRelationalExpr SessionId RelationalExpr

47− RPCData(ExecuteTypeForRelationalExpr)

48−

49−data ExecuteSchemaExpr = ExecuteSchemaExpr SessionId SchemaExpr RPCData(ExecuteSchemaExpr)

50−

35+ deriving (Binary, Generic)

36+data ExecuteSchemaExpr = ExecuteSchemaExpr SessionId SchemaExpr

37+ deriving (Binary, Generic)

5138data ExecuteSetCurrentSchema = ExecuteSetCurrentSchema SessionId SchemaName

52− RPCData(ExecuteSetCurrentSchema)

53−

39+ deriving (Binary, Generic)

5440data RetrieveInclusionDependencies = RetrieveInclusionDependencies SessionId

55− RPCData(RetrieveInclusionDependencies)

56−

41+ deriving (Binary, Generic)

5742data RetrievePlanForDatabaseContextExpr = RetrievePlanForDatabaseContextExpr SessionId DatabaseContextExpr

58− RPCData(RetrievePlanForDatabaseContextExpr)

59−

43+ deriving (Binary, Generic)

6044data RetrieveTransactionGraph = RetrieveTransactionGraph SessionId

61− RPCData(RetrieveTransactionGraph)

62−

45+ deriving (Binary, Generic)

6346data RetrieveHeadTransactionId = RetrieveHeadTransactionId SessionId

64− RPCData(RetrieveHeadTransactionId)

65−

47+ deriving (Binary, Generic)

6648data CreateSessionAtCommit = CreateSessionAtCommit TransactionId

67− RPCData(CreateSessionAtCommit)

68−

49+ deriving (Binary, Generic)

6950data CreateSessionAtHead = CreateSessionAtHead HeadName

70− RPCData(CreateSessionAtHead)

71−

51+ deriving (Binary, Generic)

7252data CloseSession = CloseSession SessionId

73− RPCData(CloseSession)

74−

53+ deriving (Binary, Generic)

7554data RetrieveAtomTypesAsRelation = RetrieveAtomTypesAsRelation SessionId

76− RPCData(RetrieveAtomTypesAsRelation)

77−

55+ deriving (Binary, Generic)

7856data RetrieveRelationVariableSummary = RetrieveRelationVariableSummary SessionId

79− RPCData(RetrieveRelationVariableSummary)

80−

57+ deriving (Binary, Generic)

8158data RetrieveAtomFunctionSummary = RetrieveAtomFunctionSummary SessionId

82− RPCData(RetrieveAtomFunctionSummary)

83−

59+ deriving (Binary, Generic)

8460data RetrieveDatabaseContextFunctionSummary = RetrieveDatabaseContextFunctionSummary SessionId

85− RPCData(RetrieveDatabaseContextFunctionSummary)

86−

61+ deriving (Binary, Generic)

8762data RetrieveCurrentSchemaName = RetrieveCurrentSchemaName SessionId

88− RPCData(RetrieveCurrentSchemaName)

89−

63+ deriving (Binary, Generic)

9064data TestTimeout = TestTimeout SessionId

91− RPCData(TestTimeout)

92−

93−data RetrieveSessionIsDirty = RetrieveSessionIsDirty SessionId

94− RPCData(RetrieveSessionIsDirty)

95−

65+ deriving (Binary, Generic)

66+data RetrieveSessionIsDirty = RetrieveSessionIsDirty SessionId

67+ deriving (Binary, Generic)

9668data ExecuteAutoMergeToHead = ExecuteAutoMergeToHead SessionId MergeStrategy HeadName

97− RPCData(ExecuteAutoMergeToHead)

98−

69+ deriving (Binary, Generic)

9970data RetrieveTypeConstructorMapping = RetrieveTypeConstructorMapping SessionId

100− RPCData(RetrieveTypeConstructorMapping)

71+ deriving (Binary, Generic)

10172

10273data ExecuteValidateMerkleHashes = ExecuteValidateMerkleHashes SessionId

103− RPCData(ExecuteValidateMerkleHashes)

74+ deriving (Binary, Generic)

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

2222

2323-- the static optimizer performs optimizations which need not take any specific-relation statistics into account

2424

25+--import Debug.Trace

26+

2527data GraphRefSOptRelationalExprEnv =

2628 GraphRefSOptRelationalExprEnv

2729 {

@@ -177,7 +179,7 @@ fullOptimizeGraphRefRelationalExpr expr = do

177179optimizeGraphRefRelationalExpr :: GraphRefRelationalExpr -> GraphRefSOptRelationalExprM GraphRefRelationalExpr

178180optimizeGraphRefRelationalExpr e@(MakeStaticRelation _ _) = pure e

179181

180−optimizeGraphRefRelationalExpr e@MakeRelationFromExprs{} = pure e

182+optimizeGraphRefRelationalExpr e@(MakeRelationFromExprs _ _) = pure e

181183

182184optimizeGraphRefRelationalExpr e@(ExistingRelation _) = pure e

183185

@@ -207,8 +209,6 @@ optimizeGraphRefRelationalExpr (Union exprA exprB) = do

207209 case (optExprA, optExprB) of

208210 (Restrict predA (RelationVariable nameA sA),

209211 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'

212212 _ -> if optExprA == optExprB then

213213 pure optExprA

214214 else

@@ -575,4 +575,3 @@ applyStaticRestrictionPushdown expr = case expr of

575575-- no optimizations available

576576optimizeDatabaseContextIOExpr :: GraphRefDatabaseContextIOExpr -> GraphRefSOptDatabaseContextExprM GraphRefDatabaseContextIOExpr

577577optimizeDatabaseContextIOExpr = pure

578−

src/lib/ProjectM36/TransGraphRelationalExpression.hs+17

@@ -10,26 +10,43 @@ import Control.Monad.Trans.Reader

1010import Control.Monad.Trans.Class

1111import Control.Monad.Trans.Except

1212import Data.Functor.Identity

13+import Data.Binary

1314

1415-- | The TransGraphRelationalExpression is equivalent to a relational expression except that relation variables can reference points in the transaction graph (at previous points in time).

1516type TransGraphRelationalExpr = RelationalExprBase TransactionIdLookup

1617

18+instance Binary TransGraphRelationalExpr

19+

1720type TransGraphAttributeNames = AttributeNamesBase TransactionIdLookup

1821

22+instance Binary TransGraphAttributeNames

23+

1924type TransGraphExtendTupleExpr = ExtendTupleExprBase TransactionIdLookup

2025

26+instance Binary TransGraphExtendTupleExpr

27+

2128type TransGraphTupleExpr = TupleExprBase TransactionIdLookup

2229

30+instance Binary TransGraphTupleExpr

31+

2332type TransGraphTupleExprs = TupleExprsBase TransactionIdLookup

2433

34+instance Binary TransGraphTupleExprs

35+

2536type TransGraphRestrictionPredicateExpr = RestrictionPredicateExprBase TransactionIdLookup

2637

38+instance Binary TransGraphRestrictionPredicateExpr

39+

2740type TransGraphAtomExpr = AtomExprBase TransactionIdLookup

2841

42+instance Binary TransGraphAtomExpr

43+

2944type TransGraphAttributeExpr = AttributeExprBase TransactionIdLookup

3045

3146type TransGraphWithNameExpr = WithNameExprBase TransactionIdLookup

3247

48+instance Binary TransGraphWithNameExpr

49+

3350newtype TransGraphEvalEnv = TransGraphEvalEnv {

3451 tge_graph :: TransactionGraph

3552 }

src/lib/ProjectM36/Transaction/Persist.hs+16−16

@@ -8,13 +8,13 @@ import ProjectM36.AtomFunction

88import ProjectM36.Persist (writeBSFileSync, DiskSync, renameSync)

99import qualified Data.Map as M

1010import qualified Data.HashSet as HS

11+import qualified Data.Binary as B

1112import System.FilePath

1213import System.Directory

1314import qualified Data.Text as T

1415import Control.Monad

1516import ProjectM36.ScriptSession

1617import ProjectM36.AtomFunctions.Basic (precompiledAtomFunctions)

17−import Codec.Winery

1818

1919#ifdef PM36_HASKELL_SCRIPTING

2020import GHC

@@ -62,7 +62,7 @@ readTransaction dbdir transId mScriptSession = do

6262 return $ Left $ MissingTransactionError transId

6363 else do

6464 relvars <- readRelVars transDir

65− transInfo <- readFileDeserialise (transactionInfoPath transDir)

65+ transInfo <- B.decodeFile (transactionInfoPath transDir)

6666 incDeps <- readIncDeps transDir

6767 typeCons <- readTypeConstructorMapping transDir

6868 sschemas <- readSubschemas transDir

@@ -92,28 +92,28 @@ writeTransaction sync dbdir trans = do

9292 writeDBCFuncs sync tempTransDir (dbcFunctions context)

9393 writeTypeConstructorMapping sync tempTransDir (typeConstructorMapping context)

9494 writeSubschemas sync tempTransDir (subschemas trans)

95− writeFileSerialise (transactionInfoPath tempTransDir) (transactionInfo trans)

95+ B.encodeFile (transactionInfoPath tempTransDir) (transactionInfo trans)

9696 --move the temp directory to final location

9797 renameSync sync tempTransDir finalTransDir

9898

9999writeRelVars :: DiskSync -> FilePath -> RelationVariables -> IO ()

100100writeRelVars sync transDir relvars = do

101101 let path = relvarsPath transDir

102− writeBSFileSync sync path (serialise relvars)

102+ writeBSFileSync sync path (B.encode relvars)

103103

104104readRelVars :: FilePath -> IO RelationVariables

105105readRelVars transDir =

106− readFileDeserialise (relvarsPath transDir)

106+ B.decodeFile (relvarsPath transDir)

107107

108108writeAtomFuncs :: DiskSync -> FilePath -> AtomFunctions -> IO ()

109109writeAtomFuncs sync transDir funcs = do

110110 let atomFuncPath = atomFuncsPath transDir

111− writeBSFileSync sync atomFuncPath (serialise $ map (\f -> (atomFuncType f, atomFuncName f, atomFunctionScript f)) (HS.toList funcs))

111+ writeBSFileSync sync atomFuncPath (B.encode $ map (\f -> (atomFuncType f, atomFuncName f, atomFunctionScript f)) (HS.toList funcs))

112112

113113--all the atom functions are in one file

114114readAtomFuncs :: FilePath -> Maybe ScriptSession -> IO AtomFunctions

115115readAtomFuncs transDir mScriptSession = do

116− atomFuncsList <- readFileDeserialise (atomFuncsPath transDir)

116+ atomFuncsList <- B.decodeFile (atomFuncsPath transDir)

117117 --only Haskell script functions can be serialized

118118 --we always return the pre-compiled functions

119119 funcs <- mapM (\(funcType, funcName, mFuncScript) -> loadAtomFunc precompiledAtomFunctions mScriptSession funcName funcType mFuncScript) atomFuncsList

@@ -153,7 +153,7 @@ readAtomFunc _ _ _ _ = error "Haskell scripting is disabled"

153153#else

154154readAtomFunc transDir funcName mScriptSession precompiledFuncs = do

155155 let atomFuncPath = atomFuncsPath transDir

156− (funcType, mFuncScript) <- readFileDeserialise @([AtomType],Maybe T.Text) atomFuncPath

156+ (funcType, mFuncScript) <- B.decodeFile @([AtomType],Maybe T.Text) atomFuncPath

157157 case mFuncScript of

158158 --handle pre-compiled case- pull it from the precompiled list

159159 Nothing -> case atomFunctionForName funcName precompiledFuncs of

@@ -184,7 +184,7 @@ writeDBCFuncs sync transDir funcs = mapM_ (writeDBCFunc sync transDir) (HS.toLis

184184writeDBCFunc :: DiskSync -> FilePath -> DatabaseContextFunction -> IO ()

185185writeDBCFunc sync transDir func = do

186186 let dbcFuncPath = dbcFuncsDir transDir </> T.unpack (dbcFuncName func)

187− writeBSFileSync sync dbcFuncPath (serialise (dbcFuncType func, databaseContextFunctionScript func))

187+ writeBSFileSync sync dbcFuncPath (B.encode (dbcFuncType func, databaseContextFunctionScript func))

188188

189189readDBCFuncs :: FilePath -> Maybe ScriptSession -> IO DatabaseContextFunctions

190190readDBCFuncs transDir mScriptSession = do

@@ -201,7 +201,7 @@ readDBCFunc transDir funcName _ precompiledFuncs = do

201201readDBCFunc transDir funcName mScriptSession precompiledFuncs = do

202202#endif

203203 let dbcFuncPath = dbcFuncsDir transDir </> T.unpack funcName

204− (_funcType, mFuncScript) <- readFileDeserialise @([AtomType], Maybe T.Text) dbcFuncPath

204+ (_funcType, mFuncScript) <- B.decodeFile @([AtomType], Maybe T.Text) dbcFuncPath

205205 case mFuncScript of

206206 Nothing -> case databaseContextFunctionForName funcName precompiledFuncs of

207207 Left _ -> error ("expected precompiled dbc function: " ++ T.unpack funcName)

@@ -225,7 +225,7 @@ readDBCFunc transDir funcName mScriptSession precompiledFuncs = do

225225

226226writeIncDep :: DiskSync -> FilePath -> (IncDepName, InclusionDependency) -> IO ()

227227writeIncDep sync transDir (incDepName, incDep) =

228− writeBSFileSync sync (incDepsDir transDir </> T.unpack incDepName) $ serialise incDep

228+ writeBSFileSync sync (incDepsDir transDir </> T.unpack incDepName) $ B.encode incDep

229229

230230writeIncDeps :: DiskSync -> FilePath -> M.Map IncDepName InclusionDependency -> IO ()

231231writeIncDeps sync transDir incdeps = mapM_ (writeIncDep sync transDir) $ M.toList incdeps

@@ -233,7 +233,7 @@ writeIncDeps sync transDir incdeps = mapM_ (writeIncDep sync transDir) $ M.toLis

233233readIncDep :: FilePath -> IncDepName -> IO (IncDepName, InclusionDependency)

234234readIncDep transDir incdepName = do

235235 let incDepPath = incDepsDir transDir </> T.unpack incdepName

236− incDepData <- readFileDeserialise incDepPath

236+ incDepData <- B.decodeFile incDepPath

237237 pure (incdepName, incDepData)

238238

239239readIncDeps :: FilePath -> IO (M.Map IncDepName InclusionDependency)

@@ -245,20 +245,20 @@ readIncDeps transDir = do

245245readSubschemas :: FilePath -> IO Subschemas

246246readSubschemas transDir = do

247247 let sschemasPath = subschemasPath transDir

248− readFileDeserialise sschemasPath

248+ B.decodeFile sschemasPath

249249

250250writeSubschemas :: DiskSync -> FilePath -> Subschemas -> IO ()

251251writeSubschemas sync transDir sschemas = do

252252 let sschemasPath = subschemasPath transDir

253− writeBSFileSync sync sschemasPath (serialise sschemas)

253+ writeBSFileSync sync sschemasPath (B.encode sschemas)

254254

255255writeTypeConstructorMapping :: DiskSync -> FilePath -> TypeConstructorMapping -> IO ()

256256writeTypeConstructorMapping sync path types = let atPath = typeConsPath path in

257− writeBSFileSync sync atPath $ serialise types

257+ writeBSFileSync sync atPath $ B.encode types

258258

259259readTypeConstructorMapping :: FilePath -> IO TypeConstructorMapping

260260readTypeConstructorMapping path = do

261261 let atPath = typeConsPath path

262− readFileDeserialise atPath

262+ B.decodeFile atPath

263263

264264

src/lib/ProjectM36/TransactionGraph.hs+13−15

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

1−{-# LANGUAGE DeriveGeneric, CPP, FlexibleContexts, DerivingVia #-}

1+{-# LANGUAGE DeriveAnyClass, DeriveGeneric, CPP, FlexibleContexts #-}

22module ProjectM36.TransactionGraph where

33import ProjectM36.Base

44import ProjectM36.Error

@@ -13,7 +13,6 @@ import ProjectM36.MerkleHash

1313import qualified ProjectM36.DisconnectedTransaction as Discon

1414import qualified ProjectM36.Attribute as A

1515

16−import Codec.Winery

1716import Control.Monad.Except hiding (join)

1817import Control.Monad.Reader hiding (join)

1918import qualified Data.Vector as V

@@ -24,6 +23,7 @@ import qualified Data.List.NonEmpty as NE

2423import Data.Time.Clock

2524import qualified Data.Text as T

2625import GHC.Generics

26+import Data.Binary as B

2727import Data.Either (lefts, rights, isRight)

2828#if __GLASGOW_HASKELL__ < 804

2929import Data.Monoid

@@ -38,15 +38,13 @@ import Crypto.Hash.SHA256

3838-- | Record a lookup for a specific transaction in the graph.

3939data TransactionIdLookup = TransactionIdLookup TransactionId |

4040 TransactionIdHeadNameLookup HeadName [TransactionIdHeadBacktrack]

41− deriving (Show, Eq, Generic)

42− deriving Serialise via WineryVariant TransactionIdLookup

41+ deriving (Show, Eq, Binary, Generic)

4342

4443-- | Used for git-style head backtracking such as topic~3^2.

45−data TransactionIdHeadBacktrack = TransactionIdHeadParentBacktrack Int | -- ^ git equivalent of ~v: walk back n parents, arbitrarily choosing a parent when a choice must be made

44+data TransactionIdHeadBacktrack = TransactionIdHeadParentBacktrack Int | -- ^ git equivalent of ~: walk back n parents, arbitrarily choosing a parent when a choice must be made

4645 TransactionIdHeadBranchBacktrack Int | -- ^ git equivalent of ^: walk back one parent level to the nth arbitrarily-chosen parent

4746 TransactionStampHeadBacktrack UTCTime -- ^ git equivalent of 'git-rev-list -n 1 --before X' find the first transaction which was created before the timestamp

48− deriving (Show, Eq, Generic)

49− deriving Serialise via WineryVariant TransactionIdHeadBacktrack

47+ deriving (Show, Eq, Binary, Generic)

5048

5149

5250-- | Operators which manipulate a transaction graph and which transaction the current 'Session' is based upon.

@@ -58,8 +56,7 @@ data TransactionGraphOperator = JumpToHead HeadName |

5856 MergeTransactions MergeStrategy HeadName HeadName |

5957 Commit |

6058 Rollback

61− deriving (Eq, Show, Generic)

62− deriving Serialise via WineryVariant TransactionGraphOperator

59+ deriving (Eq, Show, Binary, Generic)

6360

6461isCommit :: TransactionGraphOperator -> Bool

6562isCommit Commit = True

@@ -384,7 +381,7 @@ subGraphOfFirstCommonAncestor origGraph resultHeads currentTrans' goalTrans trav

384381 else do

385382 currentTransChildren <- childTransactions currentTrans' origGraph

386383 let searchChildren = S.difference (S.insert currentTrans' traverseSet) currentTransChildren

387− searchChild start' = pathToTransaction origGraph start' goalTrans (S.insert currentTrans' traverseSet)

384+ searchChild start = pathToTransaction origGraph start goalTrans (S.insert currentTrans' traverseSet)

388385 childSearches = map searchChild (S.toList searchChildren)

389386 errors = lefts childSearches

390387 pathsFound = rights childSearches

@@ -596,9 +593,10 @@ addMerkleHash graph trans = Transaction (transactionId trans) newInfo (schemas t

596593

597594-- the new hash includes the parents' ids, the current id, and the hash of the context, and the merkle hashes of the parent transactions

598595calculateMerkleHash :: Transaction -> TransactionGraph -> MerkleHash

599−calculateMerkleHash trans graph = MerkleHash $ hashlazy (BL.fromChunks [transIds,

600− schemasBytes

601− ] <> dbcBytes <> parentMerkleHashes)

596+calculateMerkleHash trans graph = MerkleHash $ hashlazy (mconcat [transIds,

597+ dbcBytes,

598+ schemasBytes,

599+ parentMerkleHashes])

602600 where

603601 parentMerkleHashes = BL.fromChunks $ map (_unMerkleHash . getMerkleHash) parentTranses

604602 parentTranses =

@@ -607,9 +605,9 @@ calculateMerkleHash trans graph = MerkleHash $ hashlazy (BL.fromChunks [transIds

607605 Left e -> error ("failed to find transaction in Merkle hash construction: " ++ show e)

608606 Right t -> S.toList t

609607 getMerkleHash t = merkleHash (transactionInfo t)

610− transIds = serialise (transactionId trans : S.toList (parentIds trans))

608+ transIds = B.encode (transactionId trans : S.toList (parentIds trans))

611609 dbcBytes = DBC.hashBytes (concreteDatabaseContext trans)

612− schemasBytes = serialise (subschemas trans)

610+ schemasBytes = B.encode (subschemas trans)

613611

614612validateMerkleHash :: Transaction -> TransactionGraph -> Either MerkleValidationError ()

615613validateMerkleHash trans graph =

src/lib/ProjectM36/Tuple.hs+33−47

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

11module ProjectM36.Tuple where

22import ProjectM36.Base

33import ProjectM36.Error

4−import ProjectM36.Attribute as A

4+import ProjectM36.Attribute

55import ProjectM36.Atom

66import ProjectM36.AtomType

77import ProjectM36.DataTypes.Primitive

@@ -15,19 +15,19 @@ import Control.Arrow

1515import Data.Maybe

1616

1717emptyTuple :: RelationTuple

18−emptyTuple = RelationTuple mempty mempty

18+emptyTuple = RelationTuple V.empty V.empty

1919

2020tupleSize :: RelationTuple -> Int

21−tupleSize (RelationTuple tupAttrs _) = arity tupAttrs

21+tupleSize (RelationTuple tupAttrs _) = V.length tupAttrs

2222

2323tupleAttributeNameSet :: RelationTuple -> S.Set AttributeName

24−tupleAttributeNameSet (RelationTuple tupAttrs _) = attributeNameSet tupAttrs

24+tupleAttributeNameSet (RelationTuple tupAttrs _) = S.fromList $ V.toList $ V.map attributeName tupAttrs

2525

2626tupleAttributes :: RelationTuple -> Attributes

2727tupleAttributes (RelationTuple tupAttrs _) = tupAttrs

2828

2929tupleAssocs :: 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)

3131

3232orderedTupleAssocs :: RelationTuple -> [(AttributeName, Atom)]

3333orderedTupleAssocs tup@(RelationTuple attrVec _) = map (\attr -> (attributeName attr, atomForAttr (attributeName attr))) oAttrs

@@ -42,7 +42,7 @@ tupleAtoms :: RelationTuple -> V.Vector Atom

4242tupleAtoms (RelationTuple _ tupVec) = tupVec

4343

4444atomForAttributeName :: 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

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

4747 Just index -> case tupVec V.!? index of

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

@@ -59,7 +59,7 @@ vectorIndicesForAttributeNames attrNameVec attrs = if not $ V.null unknownAttrNa

5959 Right $ V.map mapper attrNameVec

6060 where

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

6363

6464

6565relationForAttributeName :: AttributeName -> RelationTuple -> Either RelationalError Relation

@@ -86,10 +86,10 @@ mkRelationTuples attrs = map mapper

8686 mapper = mkRelationTuple attrs

8787

8888mkRelationTupleFromMap :: 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)

9090 where

91− attrNames = M.keys attrMap

92− attrs = map (\attrName -> Attribute attrName (atomTypeForAtom (attrMap M.! attrName))) attrNames

91+ attrNames = V.fromList (M.keys attrMap)

92+ attrs = V.map (\attrName -> Attribute attrName (atomTypeForAtom (attrMap M.! attrName))) attrNames

9393

9494--return error if attribute names match but their types do not

9595singleTupleSetJoin :: Attributes -> RelationTuple -> RelationTupleSet -> Either RelationalError [RelationTuple]

@@ -120,8 +120,8 @@ singleTupleJoin joinedAttrs tup1@(RelationTuple tupAttrs1 _) tup2@(RelationTuple

120120 return $ Just $ RelationTuple joinedAttrs newVec

121121 where

122122 keysIntersection = V.map attributeName attrsIntersection

123− attrsIntersection = V.filter (`V.elem` attributesVec tupAttrs1) (attributesVec tupAttrs2)

124− newVec = V.map (findAtomForAttributeName . attributeName) (attributesVec joinedAttrs)

123+ attrsIntersection = V.filter (`V.elem` tupAttrs1) tupAttrs2

124+ newVec = V.map (findAtomForAttributeName . attributeName) joinedAttrs

125125 --search both tuples for the attribute

126126 findAtomForAttributeName attrName = head $ rights $ fmap (atomForAttributeName attrName) [tup1, tup2]

127127

@@ -138,31 +138,23 @@ vectorUnion v1 v2 = V.foldr folder v1 v2

138138tupleExtend :: RelationTuple -> RelationTuple -> RelationTuple

139139tupleExtend (RelationTuple tupAttrs1 tupVec1) (RelationTuple tupAttrs2 tupVec2) = RelationTuple newAttrs newVec

140140 where

141− newAttrs = tupAttrs1 <> tupAttrs2

142− newVec = tupVec1 <> tupVec2

141+ newAttrs = tupAttrs1 V.++ tupAttrs2

142+ newVec = tupVec1 V.++ tupVec2

143143

144144tupleAtomExtend :: AttributeName -> Atom -> RelationTuple -> RelationTuple

145145tupleAtomExtend newAttrName atom tupIn = tupleExtend tupIn newTup

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

148148

149−{-tupleProject :: S.Set AttributeName -> RelationTuple -> RelationTuple

149+--this could be cheaper- it may not be wortwhile to update all the tuples for projection, but then the attribute management must be slightly different- perhaps the attributes should be a vector of association tuples [(name, index)]

150+tupleProject :: S.Set AttributeName -> RelationTuple -> RelationTuple

150151tupleProject projectAttrs (RelationTuple attrs tupVec) = RelationTuple newAttrs newTupVec

151152 where

152− deleteIndices = V.findIndices (\attr -> S.notMember (attributeName attr) projectAttrs) (attributesVec attrs)

153+ deleteIndices = V.findIndices (\attr -> S.notMember (attributeName attr) projectAttrs) attrs

153154 indexDeleter = V.ifilter (\index _ -> V.notElem index deleteIndices)

154− newAttrs = case A.projectionAttributesForNames projectAttrs attrs of

155− Left err -> error (show (err, projectAttrs, attrs))

156− Right attrs' -> attrs'

155+ newAttrs = indexDeleter attrs

157156 newTupVec = indexDeleter tupVec

158−-}

159−-- remember that the attributes order matters

160−tupleProject :: Attributes -> RelationTuple -> Either RelationalError RelationTuple

161−tupleProject projectAttrs tup = do

162− newTupVec <- foldM (\acc attr ->

163− V.snoc acc <$> atomForAttributeName (attributeName attr) tup

164− ) V.empty (attributesVec projectAttrs)

165− pure $ reorderTuple projectAttrs (RelationTuple projectAttrs newTupVec)

157+

166158--return the attributes and atoms which are equal in both vectors

167159--semi-join

168160tupleIntersection :: RelationTuple -> RelationTuple -> RelationTuple

@@ -170,14 +162,12 @@ tupleIntersection tuple1 tuple2 = RelationTuple newAttrs newTupVec

170162 where

171163 attrs1 = tupleAttributes tuple1

172164 attrs2 = tupleAttributes tuple2

173− intersectAttrs = A.intersection attrs1 attrs2

174− matchingIndices = V.findIndices (\attr -> A.member attr intersectAttrs &&

175− atomForAttributeName (attributeName attr) tuple1 ==

176− atomForAttributeName (attributeName attr) tuple2) (attributesVec attrs1)

165+ matchingIndices = V.findIndices (\attr -> V.elem attr attrs2 &&

166+ atomForAttributeName (attributeName attr) tuple1 ==

167+ atomForAttributeName (attributeName attr) tuple2

168+ ) attrs1

177169 indexFilter = V.ifilter (\index _ -> V.elem index matchingIndices)

178− newAttrs = case A.projectionAttributesForNames (A.attributeNameSet intersectAttrs) attrs1 of

179− Left _ -> mempty

180− Right attrs' -> attrs'

170+ newAttrs = indexFilter attrs1

181171 newTupVec = indexFilter (tupleAtoms tuple1)

182172

183173-- | An optimized form of tuple update which updates vectors efficiently.

@@ -185,20 +175,19 @@ updateTupleWithAtoms :: M.Map AttributeName Atom -> RelationTuple -> RelationTup

185175updateTupleWithAtoms updateMap (RelationTuple attrs tupVec) = RelationTuple attrs newVec

186176 where

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

189179 newVec = V.update tupVec updateVec

190180 updateVec = V.map (\(index, attr) -> (index, updateMap M.! attributeName attr)) updateKeysIVec

191181

192182tupleToMap :: RelationTuple -> M.Map AttributeName Atom

193183tupleToMap (RelationTuple attrs tupVec) = M.fromList assocList

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

196186

197−-- | Validate that the tuple has the correct attributes in the correct order

198187verifyTuple :: Attributes -> RelationTuple -> Either RelationalError RelationTuple

199−verifyTuple attrs tuple = let attrsTypes = A.atomTypes attrs

188+verifyTuple attrs tuple = let attrsTypes = V.map atomType attrs

200189 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

202191 Left $ TupleAttributeCountMismatchError 0

203192 else do

204193 mapM_ (uncurry atomTypeVerify) (V.zip attrsTypes tupleTypes)

@@ -207,18 +196,15 @@ verifyTuple attrs tuple = let attrsTypes = A.atomTypes attrs

207196--two tuples can be equal but the vectors of attributes could be out-of-order

208197--reorder if necessary- this is useful during relMogrify so that all the relation's tuples have identical atom/attribute ordering

209198reorderTuple :: Attributes -> RelationTuple -> RelationTuple

210−reorderTuple attrs tupIn = if attributesAndOrderEqual (tupleAttributes tupIn) attrs then

199+reorderTuple attrs tupIn = if tupleAttributes tupIn == attrs then

211200 tupIn

212201 else

213− RelationTuple attrs (V.map mapper (attributesVec attrs))

202+ RelationTuple attrs (V.map mapper attrs)

214203 where

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

217206 Right atom -> atom

218207

219208--used in Generics derivation for ADTs without named attributes

220209trimTuple :: Int -> RelationTuple -> RelationTuple

221−trimTuple index (RelationTuple attrs vals) =

222− RelationTuple newAttrs (V.drop index vals)

223− where

224− newAttrs = A.drop index attrs

210+trimTuple index (RelationTuple attrs vals) = RelationTuple (V.drop index attrs) (V.drop index vals)

src/lib/ProjectM36/TupleSet.hs−7

@@ -31,10 +31,3 @@ mkTupleSet attrs tuples = verifyTupleSet attrs (RelationTupleSet tuples)

3131

3232mkTupleSetFromList :: Attributes -> [[Atom]] -> Either RelationalError RelationTupleSet

3333mkTupleSetFromList 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

3838import qualified Data.Vector as V

3939import GHC.Generics

4040import ProjectM36.Atomable

41−import ProjectM36.Attribute as A hiding (null, toList)

41+import ProjectM36.Attribute hiding (null)

4242import ProjectM36.Base

4343import ProjectM36.DataTypes.Primitive

4444import ProjectM36.Error

@@ -89,7 +89,7 @@ toInsertExpr vals rvName = do

8989

9090-- | 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'.

9191toDefineExpr :: 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))

9393 where

9494 attrs = toAttributes (Proxy :: Proxy a)

9595

@@ -228,12 +228,11 @@ instance (Constructor c, TupleableG a, AtomableG a) => TupleableG (M1 C c a) whe

228228 toTupleG opts (M1 v) = RelationTuple attrs atoms

229229 where

230230 attrsToCheck = toAttributesG opts v

231− counter = V.generate (arity attrsToCheck) id

232− attrs = attributesFromList (V.toList attrsV)

233− attrsV = V.zipWith (\num attr@(Attribute name typ) -> if T.null name then

231+ counter = V.generate (V.length attrsToCheck) id

232+ attrs = V.zipWith (\num attr@(Attribute name typ) -> if T.null name then

234233 Attribute ("attr" <> T.pack (show (num + 1))) typ

235234 else

236− attr) counter (attributesVec attrsToCheck)

235+ attr) counter attrsToCheck

237236 atoms = V.fromList (toAtomsG v)

238237 toAttributesG opts (M1 v) = toAttributesG opts v

239238 fromTupleG opts tup = M1 <$> fromTupleG opts tup

@@ -242,7 +241,7 @@ instance (Constructor c, TupleableG a, AtomableG a) => TupleableG (M1 C c a) whe

242241-- product types

243242instance (TupleableG a, TupleableG b) => TupleableG (a :*: b) where

244243 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

246245 fromTupleG opts tup = (:*:) <$> fromTupleG opts tup <*> fromTupleG opts processedTuple

247246 where

248247 processedTuple = if isRecordTypeG (undefined :: a x) then

@@ -254,7 +253,7 @@ instance (TupleableG a, TupleableG b) => TupleableG (a :*: b) where

254253--selector/record

255254instance (Selector c, AtomableG a) => TupleableG (M1 S c a) where

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

258257 where

259258 name = T.pack (selName m)

260259 modifiedName = if T.null name then

@@ -269,7 +268,7 @@ instance (Selector c, AtomableG a) => TupleableG (M1 S c a) where

269268 val <- atomv atom

270269 pure (M1 val)

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

273272 atomv atom = maybe (Left (AtomTypeMismatchError

274273 expectedAtomType

275274 (atomTypeForAtom atom)

src/lib/ProjectM36/WithNameExpr.hs+2−4

@@ -42,11 +42,9 @@ substituteWithNameMacros macros (NotEquals exprA exprB) =

4242substituteWithNameMacros macros (Extend extendTup expr) =

4343 Extend (substituteWitNameMacrosExtendTupleExpr macros extendTup) (substituteWithNameMacros macros expr)

4444substituteWithNameMacros macros (With moreMacros expr) =

45− --collect and update nested with exprs

45+ --collect and override existing macros and recurse

4646 let newMacros = foldr macroFolder macros moreMacros

47− macroFolder (wnexpr, mexpr) acc =

48− let subExpr = substituteWithNameMacros macros mexpr in

49− filter (\(w,_) -> w /= wnexpr) acc ++ [(wnexpr, subExpr)] in

47+ macroFolder (wnexpr, mexpr) acc = filter (\(w,_) -> w /= wnexpr) acc ++ [(wnexpr, mexpr)] in

5048 --scan for a match- if it exists, replace it (representing a with clause at a lower level

5149 substituteWithNameMacros newMacros expr

5250

stack.ghc8.0.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/

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

7+# Local packages, usually specified by relative directory name

8+packages:

9+- '.'

10+# Packages to be pulled from upstream that are not in the resolver (e.g., acme-missiles-0.3)

11+extra-deps:

12+- data-accessor-transformers-0.2.1.7

13+- data-interval-1.2.0

14+- extended-reals-0.2.1.0

15+- gnuplot-0.5.4.1

16+- text-1.2.2.1

17+- aeson-1.2.1.00

18+- distributed-process-0.6.6

19+- distributed-process-async-0.2.4

20+- distributed-process-client-server-0.2.3

21+- distributed-process-extras-0.3.2

22+- deferred-folds-0.6.12

23+- rset-1.0.0

24+

25+# Override default flag values for local packages and extra-deps

26+flags: {}

27+

28+# Extra package databases containing global packages

29+extra-package-dbs: []

30+

31+# Control whether we use the GHC we find on the path

32+# system-ghc: true

33+

34+# Require a specific version of stack, using version ranges

35+# require-stack-version: -any # Default

36+# require-stack-version: >= 1.0.0

37+

38+# Override the architecture used by stack, especially useful on Windows

39+# arch: i386

40+# arch: x86_64

41+

42+# Extra directories used by stack for building

43+# extra-include-dirs: [/path/to/dir]

44+# extra-lib-dirs: [/path/to/dir]

45+

46+# Allow a newer minor version of GHC than the snapshot specifies

47+# compiler-check: newer-minor

48+

49+allow-newer: true

50+

stack.ghc8.10.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+51

@@ -0,0 +1,51 @@

1+# This file was automatically generated by stack init

2+# For more information, see: http://docs.haskellstack.org/en/stable/yaml_configuration/

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

7+# Local packages, usually specified by relative directory name

8+packages:

9+- '.'

10+# Packages to be pulled from upstream that are not in the resolver (e.g., acme-missiles-0.3)

11+extra-deps:

12+- data-accessor-transformers-0.2.1.7

13+- data-interval-1.2.0

14+- extended-reals-0.2.1.0

15+- gnuplot-0.5.4.1

16+- text-1.2.2.1

17+- aeson-1.2.1.00

18+- distributed-process-0.7.3

19+- distributed-process-async-0.2.4.1

20+- distributed-process-client-server-0.2.3

21+- distributed-process-extras-0.3.2

22+- rset-1.0.0

23+

24+# Override default flag values for local packages and extra-deps

25+flags:

26+ project-m36:

27+ stack: true

28+

29+# Extra package databases containing global packages

30+extra-package-dbs: []

31+

32+# Control whether we use the GHC we find on the path

33+# system-ghc: true

34+

35+# Require a specific version of stack, using version ranges

36+# require-stack-version: -any # Default

37+# require-stack-version: >= 1.0.0

38+

39+# Override the architecture used by stack, especially useful on Windows

40+# arch: i386

41+# arch: x86_64

42+

43+# Extra directories used by stack for building

44+# extra-include-dirs: [/path/to/dir]

45+# extra-lib-dirs: [/path/to/dir]

46+

47+# Allow a newer minor version of GHC than the snapshot specifies

48+# compiler-check: newer-minor

49+

50+allow-newer: true

51+

stack.ghc8.4.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/

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

7+# Local packages, usually specified by relative directory name

8+packages:

9+- '.'

10+# Packages to be pulled from upstream that are not in the resolver (e.g., acme-missiles-0.3)

11+extra-deps:

12+- data-interval-1.3.0

13+- extended-reals-0.2.3.0

14+- distributed-process-0.7.4

15+- distributed-process-async-0.2.6

16+- distributed-process-client-server-0.2.5.1

17+- distributed-process-extras-0.3.5

18+- rset-1.0.0

19+- hashable-time-0.2.0.2

20+- network-transport-tcp-0.6.0

21+

22+# Override default flag values for local packages and extra-deps

23+flags:

24+ project-m36:

25+ stack: true

26+

27+# Extra package databases containing global packages

28+extra-package-dbs: []

29+

30+# Control whether we use the GHC we find on the path

31+# system-ghc: true

32+

33+# Require a specific version of stack, using version ranges

34+# require-stack-version: -any # Default

35+# require-stack-version: >= 1.0.0

36+

37+# Override the architecture used by stack, especially useful on Windows

38+# arch: i386

39+# arch: x86_64

40+

41+# Extra directories used by stack for building

42+# extra-include-dirs: [/path/to/dir]

43+# extra-lib-dirs: [/path/to/dir]

44+

45+# Allow a newer minor version of GHC than the snapshot specifies

46+# compiler-check: newer-minor

47+

48+allow-newer: true

stack.ghc8.6.yaml+16−25

@@ -2,36 +2,27 @@

22# For more information, see: http://docs.haskellstack.org/en/stable/yaml_configuration/

44# 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

77# Local packages, usually specified by relative directory name

88packages:

9− - "."

9+- '.'

1010# Packages to be pulled from upstream that are not in the resolver (e.g., acme-missiles-0.3)

1111extra-deps:

12− - git: https://github.com/agentm/curryer.git

13− commit: 74ecaac619ad1165a4517d5c0f4e530493bda130

14− - git: https://github.com/composewell/streamly.git

15− commit: ac3af8749194f1788704dda8667d0b3807075cc2

16− - fast-builder-0.1.2.1

17− - winery-1.3.2

18− - barbies-2.0.2.0

19− - barbies-th-0.1.7

20− - extended-reals-0.2.3.0

21− - data-interval-2.0.1

22− - stm-containers-1.1.0.4

23− - stm-hamt-1.2.0.4

24− - rset-1.0.0

25− - hashable-time-0.2.0.2

26− - network-transport-tcp-0.6.0

27− - megaparsec-7.0.5

28− - prettyprinter-1.7.0

29− - prettyprinter-ansi-terminal-1.1.2

30− - fusion-plugin-types-0.1.0

31− - base16-bytestring-1.0.1.0

32− - modern-uri-0.3.4.0

33− - cryptohash-sha256-0.11.102.0

34− - http-types-0.12.3

12+- git: https://github.com/haskell-distributed/distributed-process.git

13+ commit: 660d554f6acd2dba8b605c84e8fa69e45708bc14

14+- extended-reals-0.2.3.0

15+- data-interval-2.0.1

16+- stm-containers-1.1.0.4

17+- distributed-static-0.3.9

18+- stm-hamt-1.2.0.4

19+- distributed-process-async-0.2.6

20+- distributed-process-client-server-0.2.5.1

21+- distributed-process-extras-0.3.5

22+- rset-1.0.0

23+- hashable-time-0.2.0.2

24+- network-transport-tcp-0.6.0

25+- megaparsec-7.0.5

3526

3627# Override default flag values for local packages and extra-deps

3728flags:

stack.ghc8.8.yaml+17−25

@@ -2,36 +2,28 @@

22# For more information, see: http://docs.haskellstack.org/en/stable/yaml_configuration/

44# 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-16.4

5+resolver: lts-15.11

77# Local packages, usually specified by relative directory name

88packages:

9− - "."

9+- '.'

1010# Packages to be pulled from upstream that are not in the resolver (e.g., acme-missiles-0.3)

1111extra-deps:

12− - git: https://github.com/agentm/curryer.git

13− commit: 74ecaac619ad1165a4517d5c0f4e530493bda130

14− - git: https://github.com/composewell/streamly.git

15− commit: ac3af8749194f1788704dda8667d0b3807075cc2

16− - fast-builder-0.1.2.1

17− - winery-1.3.2

18− - barbies-2.0.2.0

19− - barbies-th-0.1.7

20− - extended-reals-0.2.3.0

21− - data-interval-2.0.1

22− - stm-containers-1.1.0.4

23− - stm-hamt-1.2.0.4

24− - rset-1.0.0

25− - hashable-time-0.2.0.2

26− - network-transport-tcp-0.7.0

27− - megaparsec-7.0.5

28− - network-2.8.0.1

29− - primitive-extras-0.8

30− - primitive-unlifted-0.1.3.0

31− - prettyprinter-1.7.0

32− - prettyprinter-ansi-terminal-1.1.2

33− - base16-bytestring-1.0.1.0

34− - modern-uri-0.3.4.0

12+- git: https://github.com/agentm/distributed-process.git

13+ commit: 688a5b96d4b7b36d90c3db676230b2c943604288

14+- extended-reals-0.2.3.0

15+- data-interval-2.0.1

16+- stm-containers-1.1.0.4

17+- distributed-static-0.3.9

18+- stm-hamt-1.2.0.4

19+- distributed-process-async-0.2.6

20+- distributed-process-client-server-0.2.5.1

21+- distributed-process-extras-0.3.5

22+- rset-1.0.0

23+- hashable-time-0.2.0.2

24+- network-transport-tcp-0.7.0

25+- megaparsec-7.0.5

26+- network-2.8.0.1

3527

3628# Override default flag values for local packages and extra-deps

3729flags:

test/Client/Simple.hs+2−1

@@ -9,6 +9,7 @@ import System.IO.Temp

99import System.FilePath

1010import ProjectM36.TupleSet

1111import ProjectM36.Attribute

12+import qualified Data.Vector as V

1213import qualified Data.Map as M

1314

1415main :: IO ()

@@ -58,7 +59,7 @@ testSimpleCommitFailure = TestCase $ do

5859 execute $ Assign "x" (ExistingRelation relationTrue)

5960 --cause error

6061 execute $ Assign "x" (MakeStaticRelation failAttrs emptyTupleSet)

61− let expectedErr = Left (RelError (RelationTypeMismatchError mempty failAttrs))

62+ let expectedErr = Left (RelError (RelationTypeMismatchError V.empty failAttrs))

6263 assertEqual "dbc error" expectedErr err

6364

6465-- #176 default merge couldn't handle Update

test/Relation/Atomable.hs+15−28

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

11--Test Atomable typeclass which allows users to use existing Haskell datatypes to marshal them to and from the database as ConstructedAtoms.

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

2+{-# LANGUAGE DeriveGeneric, DeriveAnyClass, OverloadedStrings, TypeApplications #-}

33import Test.HUnit

44import ProjectM36.Client

5+import Data.Binary

56import Control.DeepSeq

67import System.Exit

78import TutorialD.Interpreter.TestBase

@@ -12,65 +13,52 @@ import Data.Time.Calendar (fromGregorian)

1213import Data.Text

1314import qualified Data.Map as M

1415import Data.Proxy

15−import Codec.Winery

1616

1717{-# ANN module ("Hlint: ignore Use newtype instead of data" :: String) #-}

1818data Test1T = Test1C Integer

19− deriving (Generic, Show, Eq, NFData, Atomable)

20− deriving Serialise via WineryVariant Test1T

19+ deriving (Generic, Show, Eq, Binary, NFData, Atomable)

2120

2221data Test2T x = Test2C x

23− deriving (Show, Generic, Eq, NFData, Atomable)

24− deriving Serialise via WineryVariant (Test2T x)

22+ deriving (Show, Generic, Eq, Binary, NFData, Atomable)

2523

2624data Test3T = Test3C Integer Integer

27− deriving (Show, Generic, Eq, NFData, Atomable)

28− deriving Serialise via WineryVariant Test3T

25+ deriving (Show, Generic, Eq, Binary, NFData, Atomable)

2926

3027data Test4T = Test4Ca Integer |

3128 Test4Cb Integer

32− deriving (Show, Generic, Eq, NFData, Atomable)

33− deriving Serialise via WineryVariant Test4T

29+ deriving (Show, Generic, Eq, Binary, NFData, Atomable)

3430

3531data TestListT = TestListC [Integer]

36− deriving (Show, Generic, Eq, NFData, Atomable)

37− deriving Serialise via WineryVariant TestListT

32+ deriving (Show, Generic, Eq, Binary, NFData, Atomable)

3833

3934data TestNonEmptyT = TestNonEmptyC [Integer]

40− deriving (Show, Generic, Eq, NFData, Atomable)

41− deriving Serialise via WineryVariant TestNonEmptyT

35+ deriving (Show, Generic, Eq, Binary, NFData, Atomable)

4236

4337data Test5T = Test5C {

4438 con1 :: Integer,

4539 con2 :: Integer

46− } deriving (Show, Generic, Eq, NFData, Atomable)

47− deriving Serialise via WineryRecord Test5T

40+ } deriving (Show, Generic, Eq, Binary, NFData, Atomable)

4841

4942data Test6T = Test6C (Maybe Integer)

50− deriving (Show, Generic, Eq, NFData, Atomable)

51− deriving Serialise via WineryVariant Test6T

43+ deriving (Show, Generic, Eq, Binary, NFData, Atomable)

5244

5345data Test7T = Test7C (Either Integer Integer)

54− deriving (Show, Generic, Eq, NFData, Atomable)

55− deriving Serialise via WineryVariant Test7T

46+ deriving (Show, Generic, Eq, Binary, NFData, Atomable)

5647

5748data Test8T = Test8C Test1T

58− deriving (Show, Generic, Eq, NFData, Atomable)

59− deriving Serialise via WineryVariant Test8T

49+ deriving (Show, Generic, Eq, Binary, NFData, Atomable)

6050

6151data User = User

6252 { userFirstName :: Text

6353 , userLastName :: Text

64− } deriving (Eq, Ord, Show, Generic, NFData, Atomable)

65− deriving Serialise via WineryRecord User

54+ } deriving (Eq, Ord, Show, Generic, NFData, Binary, Atomable)

6655

6756data Test9_4T = Test9_4C {

6857 f9_41 :: Int,

6958 f9_42 :: Int,

7059 f9_43 :: Int,

7160 f9_44 :: Int }

72− deriving (Show, Generic, Eq, NFData, Atomable)

73− deriving Serialise via WineryRecord Test9_4T

61+ deriving (Show, Generic, Eq, Binary, NFData, Atomable)

7462

7563data Test9_5T = Test9_5C {

7664 f9_51 :: Int,

@@ -79,8 +67,7 @@ data Test9_5T = Test9_5C {

7967 f9_54 :: Int,

8068 f9_55 :: Int

8169 }

82− deriving (Show, Generic, Eq, NFData, Atomable)

83− deriving Serialise via WineryRecord Test9_5T

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

8471

8572main :: IO ()

8673main = do

test/Relation/Basic.hs+12−13

@@ -3,6 +3,8 @@ import ProjectM36.Base

33import ProjectM36.Relation

44import ProjectM36.Error

55import ProjectM36.DateExamples

6+import ProjectM36.TupleSet

7+import ProjectM36.Attribute hiding (null, attributeNames)

68import ProjectM36.DataTypes.Primitive

79import ProjectM36.RelationalExpression

810import ProjectM36.TransactionGraph

@@ -23,8 +25,8 @@ testList = TestList [testRelation "relationTrue" relationTrue, testRelation "rel

2325 testRelation "products" productsRel,

2426 testRelation "supplierProducts" supplierProductsRel,

2527 testMkRelationFromExprsBadAttrs,

26− testExistingRelationType,

27− testReorderTuple

28+ testDuplicateAttributes,

29+ testExistingRelationType

2830 ]

2931

3032main :: IO ()

@@ -63,7 +65,7 @@ validateAttrTypesMatchTupleAttrTypes rel@(Relation attrs tupSet) = foldr (\tuple

6365 attrChecks tuple = V.map (\attr -> case atomForAttributeName (A.attributeName attr) tuple of

6466 Left _ -> False

6567 Right atom -> Right (atomTypeForAtom atom) ==

66− A.atomTypeForAttributeName (A.attributeName attr) attrs) (attributesVec (attributes rel))

68+ A.atomTypeForAttributeName (A.attributeName attr) attrs) (attributes rel)

6769

6870simpleRel :: Relation

6971simpleRel = case mkRelation attrs tupleSet of

@@ -101,19 +103,16 @@ testMkRelationFromExprsBadAttrs = TestCase $ do

101103 Left err -> assertEqual "tuple type mismatch" (TupleAttributeTypeMismatchError (A.attributesFromList [Attribute "badAttr2" IntAtomType])) err

102104 Right _ -> assertFailure "expected tuple type mismatch"

103105

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+

104113testExistingRelationType :: Test

105114testExistingRelationType = TestCase $ do

106115 (graph, _) <- freshTransactionGraph dateExamples

107116 let typeResult = runRelationalExprM reenv (typeForRelationalExpr (ExistingRelation relationTrue))

108117 reenv = mkRelationalExprEnv dateExamples graph

109118 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+7−18

@@ -8,22 +8,22 @@

88 , DataKinds

99 , TypeOperators

1010 , AllowAmbiguousTypes

11− , DerivingVia

1211 #-}

1312import Test.HUnit

1413import ProjectM36.Tupleable.Deriving

1514import ProjectM36.Atomable

16−import ProjectM36.Attribute as A

15+import ProjectM36.Attribute

1716import ProjectM36.Error

17+import Data.Binary

1818import ProjectM36.Base

1919import Control.DeepSeq (NFData)

20+import GHC.Generics

2021import qualified Data.Vector as V

2122import qualified Data.Map as M

2223import qualified Data.Text as T

2324import qualified Data.Set as S

2425import System.Exit

2526import Data.Proxy

26−import Codec.Winery

2727

2828{-# ANN module ("Hlint: ignore Use newtype instead of data" :: String) #-}

2929

@@ -31,43 +31,35 @@ data Test1T = Test1C {

3131 attrA :: Integer

3232 }

3333 deriving (Generic, Eq, Show)

34− deriving Serialise via WineryRecord Test1T

3534

3635data Test2T = Test2C {

3736 attrB :: Integer,

3837 attrC :: Integer

3938 }

4039 deriving (Generic, Eq, Show)

41− deriving Serialise via WineryRecord Test2T

4240

4341data Test3T = Test3C Integer

4442 deriving (Generic, Eq, Show)

45− deriving Serialise via WineryVariant Test3T

4643

4744data Test4T = Test4C

4845 deriving (Generic, Eq, Show)

49− deriving Serialise via WineryVariant Test4T

5046

5147data Test5T = Test5C1 Integer |

5248 Test5C2 Integer

5349 deriving (Generic, Eq, Show)

54− deriving Serialise via WineryVariant Test5T

5550

5651data Test6T = Test6C T.Text Integer Double

5752 deriving (Generic, Eq, Show)

5853

5954data Test7A = Test7AC Integer

60− deriving (Generic, Show, Eq, NFData, Atomable)

61− deriving Serialise via WineryVariant Test7A

55+ deriving (Generic, Show, Eq, Binary, NFData, Atomable)

6256

6357

6458data Test7T = Test7C Test7A

6559 deriving (Generic, Show, Eq)

66− deriving Serialise via WineryVariant Test7T

6760

6861data Test8T = Test8C

6962 deriving (Generic, Show, Eq)

70− deriving Serialise via WineryVariant Test8T

7163

7264data Test9T = Test9C

7365 {

@@ -76,7 +68,6 @@ data Test9T = Test9C

7668 attr9C :: Double

7769 }

7870 deriving (Generic, Show, Eq)

79− deriving Serialise via WineryRecord Test9T

8071

8172data Test10T = Test10C {

8273 longAttrNameA10 :: Integer,

@@ -84,7 +75,6 @@ data Test10T = Test10C {

8475 longMixed_attr_NameC10 :: Integer

8576 }

8677 deriving (Generic, Show, Eq)

87− deriving Serialise via WineryRecord Test10T

8878

8979instance Tupleable Test1T

9080

@@ -110,7 +100,7 @@ main = do

110100 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

111101

112102testList :: 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]

103+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]

114104

115105testADT1 :: Test

116106testADT1 = TestCase $ assertEqual "one record constructor" (Right example) (fromTuple (toTuple example))

@@ -148,7 +138,7 @@ testADT7 :: Test

148138testADT7 = TestCase $ do

149139 let example = Test7C (Test7AC 3)

150140 assertEqual "atom type" (Right example) (fromTuple (toTuple example))

151− let expectedAttrs = A.singleton (Attribute "" (ConstructedAtomType "Test7A" M.empty))

141+ let expectedAttrs = V.singleton (Attribute "" (ConstructedAtomType "Test7A" M.empty))

152142 assertEqual "adt atomtype" expectedAttrs (toAttributes (Proxy :: Proxy Test7T))

153143

154144testADT8 :: Test

@@ -222,8 +212,7 @@ testDeleteExpr = TestCase $ do

222212testReorderedTuple :: Test

223213testReorderedTuple = TestCase $ do

224214 let tupleRev :: RelationTuple -> RelationTuple

225− tupleRev (RelationTuple v1 v2) = RelationTuple (revAttrs v1) (V.reverse v2)

226− revAttrs attrs = A.attributesFromList (reverse (A.toList attrs))

215+ tupleRev (RelationTuple v1 v2) = RelationTuple (V.reverse v1) (V.reverse v2)

227216 expected = Test2C {attrB = 3,

228217 attrC = 4}

229218 actual = fromTuple . tupleRev . toTuple $ expected

test/Server/Main.hs+20−19

@@ -5,6 +5,7 @@ test client/server interaction

55import Test.HUnit

66import ProjectM36.Client

77import qualified ProjectM36.Client as C

8+import ProjectM36.Server.EntryPoints

89import ProjectM36.Server

910import ProjectM36.Server.Config

1011import ProjectM36.Relation

@@ -13,8 +14,16 @@ import ProjectM36.IsomorphicSchema

1314import ProjectM36.Base

1415

1516import System.Exit

16−import Network.Socket (SockAddr(..))

17+

1718import 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+

1827import Data.Either (isRight)

1928import Control.Exception

2029import System.IO.Temp

@@ -23,8 +32,6 @@ import System.FilePath

2332import System.Directory

2433#endif

2534

26−type Timeout = Int

27−

2835testList :: SessionId -> Connection -> MVar () -> Test

2936testList sessionId conn notificationTestMVar = TestList $ serverTests ++ sessionTests

3037 where

@@ -42,7 +49,7 @@ testList sessionId conn notificationTestMVar = TestList $ serverTests ++ session

4249 testRelationVariableSummary,

4350 testNotification notificationTestMVar

4451 ]

45− serverTests = [testRequestTimeout, testFileDescriptorCount, testClientConnectFail]

52+ serverTests = [testRequestTimeout, testFileDescriptorCount]

4653

4754main :: IO ()

4855main = do

@@ -62,9 +69,11 @@ main = do

6269testDatabaseName :: DatabaseName

6370testDatabaseName = "test"

6471

65−testConnection :: Port -> MVar () -> IO (Either ConnectionError (SessionId, Connection))

66−testConnection serverPort mvar = do

67− let connInfo = RemoteConnectionInfo testDatabaseName "127.0.0.1" (show serverPort) (testNotificationCallback mvar)

72+testConnection :: EndPointAddress -> MVar () -> IO (Either ConnectionError (SessionId, Connection))

73+testConnection serverAddress mvar = do

74+ let Just (host, service, _) = decodeEndPointAddress serverAddress

75+ serverAddress' = encodeEndPointAddress host service 1

76+ let connInfo = RemoteProcessConnectionInfo testDatabaseName (NodeId serverAddress') (testNotificationCallback mvar)

6877 --putStrLn ("testConnection: " ++ show serverAddress)

6978 eConn <- connectProjectM36 connInfo

7079 case eConn of

@@ -76,7 +85,7 @@ testConnection serverPort mvar = do

7685 Right sessionId -> pure $ Right (sessionId, conn)

7786

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

8089launchTestServer ti = do

8190 addressMVar <- newEmptyMVar

8291 tid <- forkIO $

@@ -90,9 +99,9 @@ launchTestServer ti = do

9099 }

91100

92101 launchServer config (Just addressMVar) >> pure ()

93− (SockAddrInet port _) <- takeMVar addressMVar

102+ endPointAddress <- takeMVar addressMVar

94103 --liftIO $ putStrLn ("launched server on " ++ show endPointAddress)

95− pure (fromIntegral port, tid)

104+ pure (endPointAddress, tid)

96105

97106testRelationalExpr :: SessionId -> Connection -> Test

98107testRelationalExpr sessionId conn = TestCase $ do

@@ -208,7 +217,7 @@ testRequestTimeout = TestCase $ do

208217 Left err -> putStrLn ("failed to connect: " ++ show err) >> exitFailure

209218 Right (session, testConn) -> do

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

212221 killThread serverTid

213222

214223testFileDescriptorCount :: Test

@@ -238,11 +247,3 @@ fdCount = do

238247--pass on non-linux platforms

239248testFileDescriptorCount = TestCase (pure ())

240249#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

1818import qualified Data.Map as M

1919import qualified Data.ByteString.Lazy as BS

2020import 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+

2127

2228--start the websocket server

2329-- run some tutoriald against it

@@ -31,12 +37,12 @@ launchTestServer = do

3137 testDatabaseName = "test"

3238 -- start normal server

3339 _ <- forkIO (launchServer config (Just addressMVar) >> pure ())

34− (SockAddrInet dbPort _) <- takeMVar addressMVar

40+ serverAddress <- takeMVar addressMVar

3541 let wsServerHost = "127.0.0.1"

3642 wsServerPort = 8889

37− dbHost = "127.0.0.1"

43+ Just (dbHost, dbPort, _) = decodeEndPointAddress serverAddress

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

4046 --wait for socket to be listening

4147 waitForListenSocket 5 (fromIntegral wsServerPort)

4248 pure (fromIntegral wsServerPort, testDatabaseName)

test/TransactionGraph/Persist.hs+3−3

@@ -99,11 +99,11 @@ testMerkleHashValidation = TestCase $

9999 --alter the on-disk representation and check that the hash validation fails

100100 eGraph <- transactionGraphLoad dbdir emptyTransactionGraph Nothing

101101 case eGraph of

102− Left err -> assertFailure $ "failed to load graph" ++ show err

102+ Left err -> assertFailure "failed to load graph"

103103 Right graph -> do

104104 let trans = transactionHeadsForGraph graph M.! "master"

105105 updatedTrans = Transaction (transactionId trans) (transactionInfo trans) updatedSchemas

106− transactionDir' = dbdir </> show (transactionId trans)

106+ transactionDir = dbdir </> show (transactionId trans)

107107 updatedSchemas =

108108 case schemas trans of

109109 Schemas ctx sschemas ->

@@ -120,7 +120,7 @@ testMerkleHashValidation = TestCase $

120120 let val'' = TG.validateMerkleHashes maliciousGraph

121121 assertEqual "loaded graph merkle hashes" (Left [MerkleValidationError (transactionId trans) regMerkleHash malMerkleHash]) val''

122122 --delete existing transaction directory

123− removeDirectoryRecursive transactionDir'

123+ removeDirectoryRecursive transactionDir

124124 writeTransaction NoDiskSync dbdir updatedTrans

125125

126126 --read graph from disk

test/TutorialD/InterpreterTest.hs → test/TutorialD/Interpreter.hsrenamed+7−46

@@ -78,17 +78,13 @@ main = do

7878 testAtomFunctionArgumentMismatch,

7979 testInvalidDataConstructor,

8080 testBasicList,

81− testRelationDeclarationMismatch,

82− testInvalidTuples,

83− testSelfReferencingUncommittedContext,

84− testUnionAndIntersectionAttributeExprs

81+ testRelationDeclarationMismatch

8582 ]

8683

8784simpleRelTests :: Test

8885simpleRelTests = TestCase $ do

8986 (graph, transId) <- freshTransactionGraph dateExamples

90− mapM_ (\(tutd, expected) ->

91− assertTutdEqual basicDatabaseContext transId graph expected tutd) testTups

87+ mapM_ (\(tutd, expected) -> assertTutdEqual basicDatabaseContext transId graph expected tutd) testTups

9288 where

9389 testTups = [("x:=true", Right relationTrue),

9490 ("x:=false", Right relationFalse),

@@ -123,8 +119,7 @@ simpleRelTests = TestCase $ do

123119 ("x:=relation{tuple{a 5}} : {b:=6}", mkRelationFromTuples simpleDAttributes [RelationTuple simpleDAttributes (V.fromList [IntegerAtom 5, IntegerAtom 6])]),

124120 ("x:=relation{tuple{a 5}} : {b:=add(@a,5)}", mkRelationFromTuples simpleDAttributes [RelationTuple simpleDAttributes (V.fromList [IntegerAtom 5, IntegerAtom 10])]),

125121 ("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])]),

127− ("x:=false:{a:=1,b:=2}", mkRelationFromTuples simpleDAttributes [])

122+ ("x:=relation{tuple{a 5}} : {b:=add(add(@a,2),5)}", mkRelationFromTuples simpleDAttributes [RelationTuple simpleDAttributes (V.fromList [IntegerAtom 5, IntegerAtom 12])])

128123 ]

129124 simpleAAttributes = A.attributesFromList [Attribute "a" IntegerAtomType]

130125 simpleBAttributes = A.attributesFromList [Attribute "d" IntegerAtomType]

@@ -136,8 +131,7 @@ simpleRelTests = TestCase $ do

136131dateExampleRelTests :: Test

137132dateExampleRelTests = TestCase $ do

138133 (graph, transId) <- freshTransactionGraph dateExamples

139− mapM_ (\(tutd, expected) ->

140− assertTutdEqual dateExamples transId graph expected tutd) testTups

134+ mapM_ (\(tutd, expected) -> assertTutdEqual dateExamples transId graph expected tutd) testTups

141135 where

142136 simpleEitherIntTextAttributes = A.attributesFromList [Attribute "a" (eitherAtomType IntegerAtomType TextAtomType)]

143137 maybeIntegerAtomType = ConstructedAtomType "Maybe" (M.singleton "a" IntegerAtomType)

@@ -235,7 +229,7 @@ transactionGraphAddCommitTest = TestCase $ do

235229 commit sessionId dbconn >>= eitherFail

236230 discon <- disconnectedTransaction_ sessionId dbconn

237231 let context = Discon.concreteDatabaseContext discon

238− assertEqual "ensure x was added" (M.lookup "x" (relationVariables context)) (Just (ExistingRelation suppliersRel))

232+ assertEqual "ensure x was added" (M.lookup "x" (relationVariables context)) (Just (RelationVariable "s" UncommittedContextMarker))

239233

240234transactionRollbackTest :: Test

241235transactionRollbackTest = TestCase $ do

@@ -362,7 +356,7 @@ testComments :: Test

362356testComments = TestCase $ do

363357 (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback

364358 mapM_ (executeTutorialD sessionId dbconn) [

365− ":branch testbranch --test comment",

359+ ":branch testbranch --test comment\n",

366360 ":jumphead {- test comment -} master"]

367361

368362-- create a graph and query from two disparate contexts

@@ -545,7 +539,7 @@ testListConstructedAtom = TestCase $ do

545539testTypeChecker :: Test

546540testTypeChecker = TestCase $ do

547541 (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback

548− let err1 = "AtomFunctionTypeError \"max\" 1"

542+ let err1 = "AtomFunctionTypeError \"max\" 1 (RelationAtomType [Attribute \"_\" IntegerAtomType]) IntegerAtomType"

549543 expectTutorialDErr sessionId dbconn (T.isPrefixOf err1) "x:=relation{tuple{a 0}}:{b:=max(@a)}"

550544

551545--exercise expression parser

@@ -665,10 +659,6 @@ testWithClause = TestCase $ do

665659 executeTutorialD sessionId dbconn "x:=with (x as s) x"

666660 eX <- executeRelationalExpr sessionId dbconn (RelationVariable "x" ())

667661 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

672662

673663 let err1 = "RelVarAlreadyDefinedError"

674664 expectTutorialDErr sessionId dbconn (T.isPrefixOf err1) "x:=with (s as s) s"

@@ -701,32 +691,3 @@ testRelationDeclarationMismatch :: Test

701691testRelationDeclarationMismatch = TestCase $ do

702692 (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback

703693 expectTutorialDErr sessionId dbconn (T.isPrefixOf "AtomTypeMismatchError") "data A a = A a | B | C; a := relation{a A Integer}{tuple{a A \"1\"}}"

704−

705−--generate errors when the tuples in a new relation don't match

706−testInvalidTuples :: Test

707−testInvalidTuples = TestCase $ do

708− (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback

709− expectTutorialDErr sessionId dbconn (T.isPrefixOf "AttributeNamesMismatchError") ":showexpr relation{tuple{a 1},tuple{b 2}}"

710− expectTutorialDErr sessionId dbconn (T.isPrefixOf "AttributeNamesMismatchError") ":showexpr relation{tuple{a 1},tuple{a 2, b 3}}"

711−-- expectTutorialDErr sessionId dbconn (T.isPrefixOf "ParseErrorBundle") ":showexpr relation{tuple{a 2, a 3}}" --parse failure can't be validated with this function

712−

713−testSelfReferencingUncommittedContext :: Test

714−testSelfReferencingUncommittedContext = TestCase $ do

715− (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback

716− executeTutorialD sessionId dbconn "s:=s union s"

717− eS <- executeRelationalExpr sessionId dbconn (RelationVariable "s" ())

718− _ <- rollback sessionId dbconn

719− eSorig <- executeRelationalExpr sessionId dbconn (RelationVariable "s" ())

720− assertEqual "s=s'" eSorig eS

721−

722−testUnionAndIntersectionAttributeExprs :: Test

723−testUnionAndIntersectionAttributeExprs = TestCase $ do

724− (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback

725− executeTutorialD sessionId dbconn "x:=s{intersection of {all but sname} {sname}}"

726− xRel <- executeRelationalExpr sessionId dbconn (RelationVariable "x" ())

727− assertEqual "intersection attrs" (Right relationTrue) xRel

728−

729− executeTutorialD sessionId dbconn "y:=s{union of {all but sname} {sname}}"

730− yRel <- executeRelationalExpr sessionId dbconn (RelationVariable "y" ())

731− assertEqual "union attrs" (Right suppliersRel) yRel

732−

test/TutorialD/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

44import System.Directory

55import Data.List (isSuffixOf)

66import System.Exit

7−import qualified Data.Text as T

8−import Text.URI

108testList :: IO Test

119testList = do

@@ -22,8 +20,7 @@ main = do

2220

2321testScript :: FilePath -> Test

2422testScript tutdFile = TestCase $ do

25− fileURI <- mkURI (T.pack ("file://" <> tutdFile))

26− eImport <- importTutorialDFromFile fileURI Nothing

23+ eImport <- importTutorialD tutdFile

2724 case eImport of

2825 Left err -> assertFailure ("tutd import failure in " ++ tutdFile ++ ": " ++ show err)

29− Right _ -> pure ()

26+ Right _ -> pure ()