fd31963...master · project-m36

git.iko.soy/project-m36

94 files changed+2601−1418

since splitsnapshots

unifiedsplit

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

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

66 dockerimage:

77 runs-on: ubuntu-latest

88 steps:

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

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

11− with:

12− skip_adding_nixpkgs_channel: true

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

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− run: echo ${{secrets.DOCKERHUB_PASSWORD}} | docker login --username ${{secrets.DOCKERHUB_USER}} --password-stdin

22− - name: docker tag with version

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

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

25− - name: docker tag latest

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

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

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

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

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

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

11+ with:

12+ nix_path: nixpkgs=channel:nixos-unstable

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

14+ with:

15+ name: project-m36

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

17+ - run: cachix use iohk

18+ - name: docker load

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

20+ - name: docker login

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

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

23+ - name: docker tag with version

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

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

26+ - name: docker tag latest

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

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

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

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

31+

32+ stack-build:

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

34+ strategy:

35+ matrix:

36+ os: [ubuntu-latest]

37+ ghc:

38+ - ghc8.10

39+ - ghc8.8

40+ - ghc8.6

41+ include:

42+ - os: macos-latest

43+ ghc: ghc8.10

44+ env:

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

46+ steps:

47+ - uses: actions/checkout@v2

48+ - name: Cache

49+ uses: actions/cache@v1

50+ with:

51+ path: ~/.stack

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

53+ restore-keys: |

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

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

56+ - name: Fix macOS cache bug

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

58+ - name: Build

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

60+ - name: Test

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

62+ - name: HLint

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

64+ - name: Haddock

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

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

67+ with:

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

69+ path: out/

.gitignore+3−1

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

1818jupyter/itutd.egg-info

1919jupyter/build

2020juyter/dist

21−.ipynb_checkpoints

21+.ipynb_checkpoints

22+project-m36.nix

23+stack.yaml

.travis.ymldeleted−60

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

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

2−language: c

3−sudo: false

4−

5−git:

6− submodules: false # whether to recursively clone submodules

7−

8−cache:

9− directories:

10− - $HOME/.ghc

11− - $HOME/.cabal

12− - $HOME/.stack

13− - .stack-work

14− timeout: 1000

15−

16−matrix:

17− fast_finish: true

18− include:

19− - env: CACHE_NAME=8.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.shdeleted−25

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

1−#!/bin/sh

2−set -o errexit -o verbose

3−

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

5−then

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

7−elif test ! "$GITHUB_TOKEN"

8−then

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

10− exit 1

11−else

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

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

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

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

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

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

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

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

20− chmod +x "./$REPO"

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

22− echo "SHA256:"

23− shasum -a 256 "$BUNDLE_NAME"

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

25−fi

.travis/install-dependencies.shdeleted−22

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

1−# Run tests

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

3− timeout_cmd="gtimeout"

4−else

5− timeout_cmd="timeout"

6−fi

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

8−ret=$?

9−case "$ret" in

10− 0)

11− # continue

12− ;;

13− 124)

14− echo "Timed out while installing dependencies."

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

16− exit 1

17− ;;

18− *)

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

20− exit "$ret"

21− ;;

22−esac

.travis/install-ghc.shdeleted−16

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

1−#!/bin/sh

2−set -eux

3−#assume stack is installed

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

5−

6−fetch_ghc_osx() {

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

8− $STACK setup $GHC_VERSION

9−}

10−

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

12− fetch_ghc_osx

13−else

14− #installed by apt

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

16−fi

.travis/install-ghr.shdeleted−21

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

1−#!/bin/sh

2−set -o errexit -o verbose

3−

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

5−then

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

7−else

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

9− then

10− ARCH="linux"

11− else

12− ARCH="darwin"

13− fi

14− echo "Installing ghr"

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

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

17− mkdir -p "$HOME/bin"

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

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

20− rm ghr.zip

21−fi

.travis/install-stack.shdeleted−27

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

1−#!/bin/sh

2−

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

4−

5−set -eux

6−

7−travis_retry() {

8− cmd=$*

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

10−}

11−

12−fetch_stack_osx() {

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

14−}

15−

16−fetch_stack_linux() {

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

18−}

19−

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

21−# builds.

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

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

24− travis_retry fetch_stack_osx

25−else

26− travis_retry fetch_stack_linux

27−fi

Changelog.markdown+17

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

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

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

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

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

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+

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

219

320* support GHC 8.10

README.markdown+2−3

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

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)

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

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

109

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

4544

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

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

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

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

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

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

5150

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

9594

9695## Development

9796

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

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

9998

10099## Related Projects

101100

cabal.project+2−5

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

11packages: project-m36.cabal

3−--RPC library

4−source-repository-package

5− type: git

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

7− tag: 1e60c0580ca33d6ae1e97aaddc32189fdfe3ef6c

3+package *

4+ split-sections: True

96--high-performance streaming library

107source-repository-package

docker.nix+16−11

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

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

1+{ compiler ? "ghc8104"

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

3+, pkgs ? import sources.nixpkgs { }

4+}:

25let

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

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

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

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

58in

6− pkgs.dockerTools.buildImage {

7− name = "project-m36";

8− tag = "latest";

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

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

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

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

13− }

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+64−67

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

55## Prerequisites

7−* any Linux

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

9−* cabal (package downloader) installed

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

108

119## Download and Install

1210

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+

1317```bash

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

15−cabal sandbox init

16−cabal install --dependencies-only

17−cabal run tutd

19+cabal new-run tutd

1820```

1921

2022## Some Basic TutorialD

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

2628### Load the Canonical Chris Date Example

2729

2830```

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

30−```

31−

32−or

33−

34−```

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

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

3632```

3733

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.

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.

4135

4236### Execute Relational Expressions

4337

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

164158#### Create a Relation Variable

165159

166160```

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

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

168162TutorialD (master/main): :showexpr x

169163┌────────┬──────────┐

170164│age::Int│name::Text│

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

179173#### Insert Additional Tuples

180174

181175```

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

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

183177TutorialD (master/main): :showexpr x

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

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

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

187−│40 │"Steve" │

188−│31 │"Mike" │

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

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

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

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

181+│31 │"Mike" │

182+│40 │"Steve" │

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

184+

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

191186TutorialD (master/main): :showexpr x

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

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

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

195−│40 │"Steve" │

196−│24 │"Bob" │

197−│31 │"Mike" │

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

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

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

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

190+│31 │"Mike" │

191+│40 │"Steve" │

192+│24 │"Bob" │

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

194+

199195```

200196

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

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

204200

205201```

206202TutorialD (master/main): :showexpr s

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−└──────────┴────────┴───────────┴───────────┘

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+└──────────┴────────┴───────────┴───────────────┘

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

217213TutorialD (master/main): :showexpr s

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−└──────────┴────────┴───────────┴───────────┘

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+

227224```

228225#### Deleting Tuples from a Relation Variable

229226

230227```

231228TutorialD (master/main): :showexpr s

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−└──────────┴────────┴───────────┴───────────┘

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+└──────────┴────────┴───────────┴───────────────┘

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

242239TutorialD (master/main): :showexpr s

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−└──────────┴────────┴───────────┴───────────┘

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+└──────────┴────────┴───────────┴───────────────┘

251248```

252249

253250### Execute Transaction Graph Expressions

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

270267

271268```

272269TutorialD (master/main): :branch experimental

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

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

274271TutorialD (experimental): :commit

275272```

276273

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 date

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

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 date

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

4141TutorialD (master/main): :showexpr s

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

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

docs/introduction_to_projectm36.markdown+2−2

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

5151

5252To build with stack:

5353

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

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

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

5656* Linux, macOS, or Microsoft Windows

5757

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

6363

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

6565

66−Alternative building with GHC 8.4.4 or greater:

66+Alternative building with GHC 8.6.5 or greater:

6767

6868* ```cabal new-build```

6969

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, Instructor Name Type)|(Course Room Number, Room Number Type)|

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

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 date

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

6161TutorialD (master/main): :showexpr p

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

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

docs/tutd_cheatsheet.markdown+3−1

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

4747

4848|Database Context Expression |Description |

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

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

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|

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

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

5355|`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+56−2

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

22+:importexample cjdate

2323```

2424

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

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

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+

3351### Types

3452

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

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

197215└────────┴───────────┴───────────────┘

198216```

199217

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

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

201219

202220```

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

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

213231

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

215233

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+

216270#### Restriction

217271

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

examples/Plantfarm.hsnew file+446

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

1+{-# LANGUAGE DeriveGeneric #-}

3+{-# LANGUAGE OverloadedStrings #-}

5+{-# LANGUAGE DeriveAnyClass #-}

7+{-# LANGUAGE DerivingVia #-}

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

11+import Control.DeepSeq (NFData)

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

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

14+import Data.Either (lefts, rights)

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

16+import Data.Text as T (Text)

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

18+import GHC.Generics (Generic)

19+import qualified ProjectM36.Base as Base

20+import ProjectM36.Client

21+ ( AtomExprBase(NakedAtomExpr)

22+ , Atomable(toAddTypeExpr, toAtom)

23+ , AttributeName

24+ , Connection

25+ , ConnectionInfo(InProcessConnectionInfo)

26+ , DatabaseContextExpr

27+ , DatabaseContextExprBase(Delete)

28+ , PersistenceStrategy(NoPersistence)

29+ , RelationalError

30+ , RelationalExprBase(RelationVariable, Restrict)

31+ , RestrictionPredicateExprBase(AttributeEqualityPredicate)

32+ , SessionId

33+ , close

34+ , commit

35+ , connectProjectM36

36+ , createSessionAtHead

37+ , databaseContextExprForUniqueKey

38+ , defaultHeadName

39+ , emptyNotificationCallback

40+ , executeDatabaseContextExpr

41+ , executeRelationalExpr

42+ , withTransaction

43+ )

44+import qualified ProjectM36.Relation as Relation

45+import ProjectM36.Tupleable

46+ ( Tupleable(fromTuple)

47+ , toDefineExpr

48+ , toDeleteExpr

49+ , toInsertExpr

50+ , toUpdateExpr

51+ )

52+import qualified System.Random as R

53+

54+

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

56+import qualified Web.Scotty as S

57+

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

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

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

61+-- plants grow in nature. \\

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

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

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

65+--

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

67+

68+

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

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

71+ deriving Serialise via WineryVariant Stage

72+

73+

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

75+ -- if the ascii values are not wanted

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

77+

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

79+

80+instance FromJSON Stage

81+

82+instance S.Parsable Stage where

83+ parseParam t

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

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

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

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

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

89+ | otherwise = Left t

90+

91+

92+-- Just for ToJSON for ilustration of stage

93+type ASCIIStage = String

94+

95+seedStr :: ASCIIStage

96+seedStr = "<>\n\

97+ \'''\n"

98+sproutStr :: ASCIIStage

99+sproutStr = " ..\n\

100+ \<|>\n\

101+ \''''\n"

102+seedlingStr :: ASCIIStage

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

104+ \ v|/\n\

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

106+adultStr :: ASCIIStage

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

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

109+ \ \\|/\n\

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

111+deadStr :: ASCIIStage

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

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

114+

115+-- Just used for ToJSON illustration of stages

116+stagetoAscii :: Stage -> ASCIIStage

117+stagetoAscii Seed = seedStr

118+stagetoAscii Sprout = sproutStr

119+stagetoAscii Seedling = seedlingStr

120+stagetoAscii Adult = adultStr

121+stagetoAscii Dead = deadStr

122+

123+-- used for update stage

124+next :: Stage -> Stage

125+next Seed = Sprout

126+next Sprout = Seedling

127+next Seedling = Adult

128+next s = s

129+

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

131+instance Tupleable Plant

132+instance ToJSON Plant

133+instance FromJSON Plant

134+

135+

136+main :: IO ()

137+main = do

138+ putStrLn "Connecting to plant farm"

139+ c <- dbConnection

140+ _ <- createSchema c

141+ putStrLn "Planting some plants"

142+ _ <- insertSampleData c

143+ let port = 8001

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

145+ S.scotty port $ do

146+

147+ -- retrieve a plant by name

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

149+ n <- S.param "name"

150+ e <- liftIO $ getPlant c n

151+ p <- handleWebError e

152+ S.json p

153+

154+

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

156+ S.post "/plant" $ do

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

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

159+ p <- handleWebError e

160+ S.json p

161+

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

163+ S.put "/plant" $ do

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

165+ e <- liftIO $ updatePlantFst c pl

166+ p <- handleWebError e

167+ S.json p

168+

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

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

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

172+ n <- S.param "name"

173+ e <- liftIO $ waterPlant c n

174+ p <- handleWebError e

175+ S.json p

176+

177+ -- retriving all the plants as json data

178+ S.get "/plants" $ do

179+ e <- liftIO $ getAllPlants c

180+ ps <- handleWebErrors e

181+ S.json ps

182+

183+ -- saving many plants at the same time

184+ S.post "/plants" $ do

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

186+ e <- liftIO $ savePlant c pl

187+ p <- handleWebError e

188+ S.json p

189+

190+ -- deleting all plants at a specific stage

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

192+ s <- S.param "stage"

193+ e <- liftIO $ deletePlantsByStage c s

194+ p <- handleWebError e

195+ S.json p

196+

197+ -- deleting all plants at a specific stage

198+ S.delete "/plants" $ do

199+ s <- S.param "name"

200+ e <- liftIO $ deletePlantByName c s

201+ p <- handleWebError e

202+ S.json p

203+

204+ -- deleting all dead plants

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

206+ e <- liftIO $ clearDeadPlants c

207+ ps <- handleWebErrors e

208+ S.json ps

209+

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

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

212+handleWebError (Right v) = pure v

213+

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

215+handleWebErrors e = do

216+ case lefts e of

217+ [] -> pure (rights e)

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

219+

220+

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

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

223+waterPlant db n = do

224+ p <- getPlant db n

225+ case p of

226+ Left e -> pure $ Left e

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

228+

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

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

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

232+ tmp <- updatePlantFst db p

233+ case tmp of

234+ Left e -> pure $ Left e

235+ Right _ -> pure $ Right p

236+updateStage db p = do

237+ res <- calculateStage p

238+ tmp <- updatePlantFst db res

239+ case tmp of

240+ Left e -> pure $ Left e

241+ Right _ -> pure $ Right res

242+ where calculateStage p' = do

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

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

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

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

247+

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

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

250+clearDeadPlants db = do

251+ _ <- deletePlantsByStage db Dead

252+ getAllPlants db

253+

254+

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

256+-- | *Database functions* :

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

258+

259+

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

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

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

263+

264+instance ToJSON Err

265+

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

267+-- and the Connection

268+data DBConnection = DB SessionId Connection

269+

270+

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

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

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

274+-- Alternatively we could return a list.

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

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

277+ get db

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

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

280+ (RelationVariable "plants" ())

281+ )

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

283+ )

284+

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

286+defaultHead d [] = d

287+defaultHead _ (x:_) = x

288+

289+-- | Getting all the plants

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

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

292+

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

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

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

296+

297+

298+-- | Saving a plant

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

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

301+

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

303+-- not being cached yet \

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

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

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

307+updatePlantFst db pln = do

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

309+ savePlant db [pln]

310+

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

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

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

314+-- be cached.\

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

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

317+updatePlant db sps = update

318+ db -- db connection

319+ sps -- plant value

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

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

322+

323+

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

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

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

327+

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

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

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

331+

332+

333+-- | Inserting the schema into the DB

334+createSchema :: DBConnection -> IO ()

335+createSchema (DB sessionId conn) = do

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

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

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

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

340+ -- Foreign Key restrictions are available too

341+ ]

342+ pure ()

343+

344+

345+-- | inserting some sample data

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

347+insertSampleData (DB sid conn) = do

348+ insert (DB sid conn) [

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

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

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

352+ ] "plants"

353+

354+dbConnection :: IO DBConnection

355+dbConnection = do

356+ -- connect to the database

357+ let connInfo = InProcessConnectionInfo NoPersistence emptyNotificationCallback []

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

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

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

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

362+ conn <- handleIOErrorAndQuit $ connectProjectM36 connInfo

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

364+ sessionId <- handleIOErrorAndQuit $ createSessionAtHead conn defaultHeadName

365+ pure (DB sessionId conn)

366+

367+

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

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

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

371+

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

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

374+--

375+-- - SessionId

376+-- - Connection

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

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

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

380+--

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

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

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

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

385+

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

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

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

389+

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

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

392+-- Therefor ultimately return Either _ ()

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

394+executeWithTransaction (DB sid conn) expr = do

395+ iEx <- handleError expr

396+ case iEx of

397+ Left e -> pure $ Left e

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

399+

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

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

402+get (DB sessionId conn) q = do

403+ eRel <- executeRelationalExpr sessionId conn q

404+ e <- handleError eRel

405+ case e of

406+ Left err -> pure [Left err]

407+ Right pRel -> do

408+ ws <- Relation.toList pRel

409+ mapM (handleError . fromTuple) ws

410+

411+-- | for closing the DB connection.

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

413+closeConn :: DBConnection -> IO ()

414+closeConn (DB _ conn) = close conn

415+

416+

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

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

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

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

421+handleIOErrorAndQuit m = do

422+ v <- m

423+ handleErrorAndQuit v

424+

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

426+handleError eErr = case eErr of

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

428+ Right v -> pure $ Right v

429+

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

431+handleIOError m = do

432+ v <- m

433+ handleError v

434+

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

436+handleErrorAndQuit eErr = case eErr of

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

438+ Right v -> pure v

439+

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

441+handleIOErrorsAndQuit m = do

442+ eErrs <- m

443+ case lefts eErrs of

444+ [] -> pure (rights eErrs)

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

446+

examples/out_of_the_tarpit.tutd+4−4

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

33data Address = Address Text

44data Agent = Agent Text

55data Name = Name Text

6−data Price = Price Double

6+data Price = Price Integer --dollars

77data RoomType = Kitchen | Bathroom | LivingRoom

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

8+data PriceBand = Low | Med | 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(offerPrice,2000.0)) minus ((property join decision){address,agent,dateRegistered,photo,price})) group ({} as x) : {z:=gt(count(@x),50)}) {z}){} equals false

60+constraint noMoreThan50PremiumProperties ((((property where ^gt(@price,Price 2000)) minus ((property join decision){address,agent,dateRegistered,photo,price})) group ({} as x) : {z:=gt(count(@x),50)}) {z}){} equals false

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 date"

41+ ":importexample cjdate"

4242 ]

4343 },

4444 {

nix/sources.jsonnew file+50

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

1+{

2+ "curryer": {

3+ "branch": "master",

4+ "description": "Fast Haskell RPC",

5+ "homepage": null,

6+ "owner": "agentm",

7+ "repo": "curryer",

8+ "rev": "74ecaac619ad1165a4517d5c0f4e530493bda130",

9+ "sha256": "1izdvzj00k0y76ixm7dfgvq2fzphb8h4nzqgwkl3p0bg0806rsn1",

10+ "type": "tarball",

11+ "url": "https://github.com/agentm/curryer/archive/74ecaac619ad1165a4517d5c0f4e530493bda130.tar.gz",

12+ "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"

13+ },

14+ "niv": {

15+ "branch": "master",

16+ "description": "Easy dependency management for Nix projects",

17+ "homepage": "https://github.com/nmattia/niv",

18+ "owner": "nmattia",

19+ "repo": "niv",

20+ "rev": "1819632b5823e0527da28ad82fecd6be5136c1e9",

21+ "sha256": "08jz17756qchq0zrqmapcm33nr4ms9f630mycc06i6zkfwl5yh5i",

22+ "type": "tarball",

23+ "url": "https://github.com/nmattia/niv/archive/1819632b5823e0527da28ad82fecd6be5136c1e9.tar.gz",

24+ "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"

25+ },

26+ "nixpkgs": {

27+ "branch": "master",

28+ "description": "Nix Packages collection",

29+ "homepage": "",

30+ "owner": "NixOS",

31+ "repo": "nixpkgs",

32+ "rev": "429c23aad0fce9ef38b0e60d55d7459c19d53ddc",

33+ "sha256": "1nj8sh1fnxp07jdlvjkijwfd1pnsi2zj0ivy7a0dhx02g63byhg3",

34+ "type": "tarball",

35+ "url": "https://github.com/NixOS/nixpkgs/archive/429c23aad0fce9ef38b0e60d55d7459c19d53ddc.tar.gz",

36+ "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"

37+ },

38+ "streamly": {

39+ "branch": "ac3af8749194f1788704dda8667d0b3807075cc2",

40+ "description": "Beautiful Streaming, Concurrent and Reactive Composition (Haskell)",

41+ "homepage": "https://hackage.haskell.org/package/streamly",

42+ "owner": "composewell",

43+ "repo": "streamly",

44+ "rev": "ac3af8749194f1788704dda8667d0b3807075cc2",

45+ "sha256": "04d8fk654vawdfs0dfidmq2awwgwi8x44iv8r7vqz70zkcsd5fij",

46+ "type": "tarball",

47+ "url": "https://github.com/composewell/streamly/archive/ac3af8749194f1788704dda8667d0b3807075cc2.tar.gz",

48+ "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"

49+ }

50+}

nix/sources.nixnew file+171

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

1+# This file has been generated by Niv.

3+let

5+ #

6+ # The fetchers. fetch_<type> fetches specs of type <type>.

7+ #

9+ fetch_file = pkgs: name: spec:

10+ let

11+ name' = sanitizeName name + "-src";

12+ in

13+ if spec.builtin or true then

14+ builtins_fetchurl { inherit (spec) url sha256; name = name'; }

15+ else

16+ pkgs.fetchurl { inherit (spec) url sha256; name = name'; };

17+

18+ fetch_tarball = pkgs: name: spec:

19+ let

20+ name' = sanitizeName name + "-src";

21+ in

22+ if spec.builtin or true then

23+ builtins_fetchTarball { name = name'; inherit (spec) url sha256; }

24+ else

25+ pkgs.fetchzip { name = name'; inherit (spec) url sha256; };

26+

27+ fetch_git = name: spec:

28+ let

29+ ref =

30+ if spec ? ref then spec.ref else

31+ if spec ? branch then "refs/heads/${spec.branch}" else

32+ if spec ? tag then "refs/tags/${spec.tag}" else

33+ abort "In git source '${name}': Please specify `ref`, `tag` or `branch`!";

34+ in

35+ builtins.fetchGit { url = spec.repo; inherit (spec) rev; inherit ref; };

36+

37+ fetch_local = spec: spec.path;

38+

39+ fetch_builtin-tarball = name: throw

40+ ''[${name}] The niv type "builtin-tarball" is deprecated. You should instead use `builtin = true`.

41+ $ niv modify ${name} -a type=tarball -a builtin=true'';

42+

43+ fetch_builtin-url = name: throw

44+ ''[${name}] The niv type "builtin-url" will soon be deprecated. You should instead use `builtin = true`.

45+ $ niv modify ${name} -a type=file -a builtin=true'';

46+

47+ #

48+ # Various helpers

49+ #

50+

51+ # https://github.com/NixOS/nixpkgs/pull/83241/files#diff-c6f540a4f3bfa4b0e8b6bafd4cd54e8bR695

52+ sanitizeName = name:

53+ (

54+ concatMapStrings (s: if builtins.isList s then "-" else s)

55+ (

56+ builtins.split "[^[:alnum:]+._?=-]+"

57+ ((x: builtins.elemAt (builtins.match "\\.*(.*)" x) 0) name)

58+ )

59+ );

60+

61+ # The set of packages used when specs are fetched using non-builtins.

62+ mkPkgs = sources: system:

63+ let

64+ sourcesNixpkgs =

65+ import (builtins_fetchTarball { inherit (sources.nixpkgs) url sha256; }) { inherit system; };

66+ hasNixpkgsPath = builtins.any (x: x.prefix == "nixpkgs") builtins.nixPath;

67+ hasThisAsNixpkgsPath = <nixpkgs> == ./.;

68+ in

69+ if builtins.hasAttr "nixpkgs" sources

70+ then sourcesNixpkgs

71+ else if hasNixpkgsPath && ! hasThisAsNixpkgsPath then

72+ import <nixpkgs> {}

73+ else

74+ abort

75+ ''

76+ Please specify either <nixpkgs> (through -I or NIX_PATH=nixpkgs=...) or

77+ add a package called "nixpkgs" to your sources.json.

78+ '';

79+

80+ # The actual fetching function.

81+ fetch = pkgs: name: spec:

82+

83+ if ! builtins.hasAttr "type" spec then

84+ abort "ERROR: niv spec ${name} does not have a 'type' attribute"

85+ else if spec.type == "file" then fetch_file pkgs name spec

86+ else if spec.type == "tarball" then fetch_tarball pkgs name spec

87+ else if spec.type == "git" then fetch_git name spec

88+ else if spec.type == "local" then fetch_local spec

89+ else if spec.type == "builtin-tarball" then fetch_builtin-tarball name

90+ else if spec.type == "builtin-url" then fetch_builtin-url name

91+ else

92+ abort "ERROR: niv spec ${name} has unknown type ${builtins.toJSON spec.type}";

93+

94+ # If the environment variable NIV_OVERRIDE_${name} is set, then use

95+ # the path directly as opposed to the fetched source.

96+ replace = name: drv:

97+ let

98+ saneName = stringAsChars (c: if isNull (builtins.match "[a-zA-Z0-9]" c) then "_" else c) name;

99+ ersatz = builtins.getEnv "NIV_OVERRIDE_${saneName}";

100+ in

101+ if ersatz == "" then drv else ersatz;

102+

103+ # Ports of functions for older nix versions

104+

105+ # a Nix version of mapAttrs if the built-in doesn't exist

106+ mapAttrs = builtins.mapAttrs or (

107+ f: set: with builtins;

108+ listToAttrs (map (attr: { name = attr; value = f attr set.${attr}; }) (attrNames set))

109+ );

110+

111+ # https://github.com/NixOS/nixpkgs/blob/0258808f5744ca980b9a1f24fe0b1e6f0fecee9c/lib/lists.nix#L295

112+ range = first: last: if first > last then [] else builtins.genList (n: first + n) (last - first + 1);

113+

114+ # https://github.com/NixOS/nixpkgs/blob/0258808f5744ca980b9a1f24fe0b1e6f0fecee9c/lib/strings.nix#L257

115+ stringToCharacters = s: map (p: builtins.substring p 1 s) (range 0 (builtins.stringLength s - 1));

116+

117+ # https://github.com/NixOS/nixpkgs/blob/0258808f5744ca980b9a1f24fe0b1e6f0fecee9c/lib/strings.nix#L269

118+ stringAsChars = f: s: concatStrings (map f (stringToCharacters s));

119+ concatMapStrings = f: list: concatStrings (map f list);

120+ concatStrings = builtins.concatStringsSep "";

121+

122+ # https://github.com/NixOS/nixpkgs/blob/8a9f58a375c401b96da862d969f66429def1d118/lib/attrsets.nix#L331

123+ optionalAttrs = cond: as: if cond then as else {};

124+

125+ # fetchTarball version that is compatible between all the versions of Nix

126+ builtins_fetchTarball = { url, name ? null, sha256 }@attrs:

127+ let

128+ inherit (builtins) lessThan nixVersion fetchTarball;

129+ in

130+ if lessThan nixVersion "1.12" then

131+ fetchTarball ({ inherit url; } // (optionalAttrs (!isNull name) { inherit name; }))

132+ else

133+ fetchTarball attrs;

134+

135+ # fetchurl version that is compatible between all the versions of Nix

136+ builtins_fetchurl = { url, name ? null, sha256 }@attrs:

137+ let

138+ inherit (builtins) lessThan nixVersion fetchurl;

139+ in

140+ if lessThan nixVersion "1.12" then

141+ fetchurl ({ inherit url; } // (optionalAttrs (!isNull name) { inherit name; }))

142+ else

143+ fetchurl attrs;

144+

145+ # Create the final "sources" from the config

146+ mkSources = config:

147+ mapAttrs (

148+ name: spec:

149+ if builtins.hasAttr "outPath" spec

150+ then abort

151+ "The values in sources.json should not have an 'outPath' attribute"

152+ else

153+ spec // { outPath = replace name (fetch config.pkgs name spec); }

154+ ) config.sources;

155+

156+ # The "config" used by the fetchers

157+ mkConfig =

158+ { sourcesFile ? if builtins.pathExists ./sources.json then ./sources.json else null

159+ , sources ? if isNull sourcesFile then {} else builtins.fromJSON (builtins.readFile sourcesFile)

160+ , system ? builtins.currentSystem

161+ , pkgs ? mkPkgs sources system

162+ }: rec {

163+ # The sources, i.e. the attribute set of spec name to spec

164+ inherit sources;

165+

166+ # The "pkgs" (evaluated nixpkgs) to use for e.g. non-builtin fetchers

167+ inherit pkgs;

168+ };

169+

170+in

171+mkSources (mkConfig {}) // { __functor = _: settings: mkSources (mkConfig settings); }

pkgs.nixdeleted−7

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

1−let

2−nixpkgs = builtins.fetchGit {

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

4− rev = "f58482658eabf7d695f45904ecbc5f49c19fef98";

5−};

6−in

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

project-m36.cabal+89−55

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

11Cabal-Version: 2.2

22Name: project-m36

3−Version: 0.9.0

4−License: Unlicense

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

56Build-Type: Simple

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

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

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

3435 Default: True

3536

3637Library

37− Build-Depends: base>=4.8 && < 4.15, ghc-paths, mtl, containers, unordered-containers, hashable, haskeline, directory, MonadRandom, random-shuffle, uuid >= 1.3.12, cassava >= 0.4.5.1 && < 0.6, text, bytestring, deepseq, deepseq-generics, vector, parallel, monad-parallel, exceptions, transformers, gnuplot, filepath, zlib, directory, temporary, stm, time, hashable-time, old-locale, rset, attoparsec, either, base64-bytestring, data-interval, extended-reals, network-transport, aeson >= 1.1, path-pieces, conduit, resourcet, http-api-data, semigroups, QuickCheck, quickcheck-instances, list-t, stm-containers >= 0.2.15, foldl, optparse-applicative, Glob, cryptohash-sha256, text-manipulate >= 0.2.0.1 && < 0.3, winery, curryer, network

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

3839 if flag(haskell-scripting)

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

4041 CPP-Options: -DPM36_HASKELL_SCRIPTING

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

6263 ProjectM36.AtomFunction,

6364 ProjectM36.AtomFunctionError,

6465 ProjectM36.ScriptSession,

66+ ProjectM36.Shortcuts,

6567 ProjectM36.DatabaseContextFunction,

6668 ProjectM36.DatabaseContextFunctionError,

6769 ProjectM36.DatabaseContextFunctionUtils,

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

116118 ProjectM36.Serialise.DataFrame,

117119 ProjectM36.Serialise.DatabaseContextFunctionError,

118120 ProjectM36.Serialise.IsomorphicSchema,

119− ProjectM36.Server.Types,

120121 ProjectM36.Session,

121122 ProjectM36.Sessions,

122123 ProjectM36.Transaction.Persist,

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

135136 Other-Modules: ProjectM36.Win32Handle

136137 else

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

138− GHC-Options: -rdynamic

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

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

140141 Build-Depends: unix

141142 CC-Options: -fPIC

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

143144 Default-Language: Haskell2010

144145 Default-Extensions: OverloadedStrings, CPP

145− if !flag(stack)

146+ if !flag(stack)

146147 Build-Depends: deferred-folds

147148

148149Executable tutd

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

174175 directory,

175176 filepath,

176177 temporary,

177− megaparsec >= 5.2.0 && < 9,

178+ megaparsec >= 5.2.0 && < 10,

178179 haskeline,

179180 random, MonadRandom,

180181 base64-bytestring,

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

183184 stm-containers >= 1.0.0,

184185 list-t,

185186 parser-combinators,

186− curryer

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

187195 Other-Modules: TutorialD.Interpreter,

188196 TutorialD.Interpreter.Base,

189197 TutorialD.Interpreter.DatabaseContextExpr,

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

202210 TutorialD.Interpreter.SchemaOperator,

203211 TutorialD.Interpreter.TransGraphRelationalOperator,

204212 TutorialD.Interpreter.SchemaOperator

213+ TutorialD.Printer

205214 main-is: TutorialD/tutd.hs

206215 CC-Options: -fPIC

207216 GHC-Options: -Wall -threaded

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

228237 optparse-applicative,

229238 hashable-time,

230239 time,

231− vector-binary-instances,

232240 text,

233241 deepseq-generics,

234242 mtl,

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

250258Executable bigrel

251259 Default-Language: Haskell2010

252260 Default-Extensions: OverloadedStrings

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

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

254262 Other-Modules: TutorialD.Interpreter.Base,

255263 TutorialD.Interpreter.DatabaseContextExpr,

256264 TutorialD.Interpreter.RelationalExpr,

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

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

263271

264272Common commontest

265− Default-Language: Haskell2010

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

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

267275 Default-Extensions: OverloadedStrings

268276 GHC-Options: -Wall -threaded

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

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

270278

271279Benchmark basic-benchmark

272280 Default-Language: Haskell2010

@@ -279,63 +287,81 @@ Benchmark basic-benchmark

279287 if flag(profiler)

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

281289

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+

282302Test-Suite test-tutoriald

283303 import: commontest

284304 type: exitcode-stdio-1.0

285− main-is: test/TutorialD/Interpreter.hs

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

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

287308

288309Test-Suite test-tutoriald-atomfunctionscript

289310 import: commontest

290311 type: exitcode-stdio-1.0

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

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

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

293314

294315Test-Suite test-tutoriald-databasecontextfunctionscript

295316 import: commontest

296317 type: exitcode-stdio-1.0

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

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

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

299320

300321Test-Suite test-relation

301322 import: commontest

302323 type: exitcode-stdio-1.0

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

324+ main-is: Relation/Basic.hs

304325

305326Test-Suite test-static-optimizer

306327 import: commontest

307328 type: exitcode-stdio-1.0

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

329+ main-is: Relation/StaticOptimizer.hs

309330

310331Test-Suite test-transactiongraph-persist

311332 import: commontest

312333 type: exitcode-stdio-1.0

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

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

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

315336

316337Test-Suite test-relation-import-csv

317338 import: commontest

318339 type: exitcode-stdio-1.0

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

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

320341

321342Test-Suite test-tutoriald-import-tutoriald

322343 import: commontest

323344 type: exitcode-stdio-1.0

324− main-is: test/TutorialD/Interpreter/Import/TutorialD.hs

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

326−

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

327347

328348Test-Suite test-relation-export-csv

329349 import: commontest

330350 type: exitcode-stdio-1.0

331− main-is: test/Relation/Export/CSV.hs

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

332352

333353Test-Suite test-transactiongraph-merge

334354 import: commontest

335355 type: exitcode-stdio-1.0

336− main-is: test/TransactionGraph/Merge.hs

356+ main-is: TransactionGraph/Merge.hs

337357

338358

359+Test-Suite test-prettyprinter

360+ import: commontest

361+ type: exitcode-stdio-1.0

362+ main-is: TutorialD/PrinterTest.hs

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

364+

339365benchmark bench

340366 import: commontest

341367 type: exitcode-stdio-1.0

@@ -344,41 +370,48 @@ benchmark bench

344370Test-Suite test-server

345371 import: commontest

346372 type: exitcode-stdio-1.0

347− main-is: test/Server/Main.hs

373+ main-is: Server/Main.hs

348374

349375

350376Executable Example-SimpleClient

351377 Default-Language: Haskell2010

352378 Default-Extensions: OverloadedStrings

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

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

354380 Main-Is: examples/SimpleClient.hs

355381 GHC-Options: -Wall -threaded

356382

357383Executable Example-OutOfTheTarpit

358384 Default-Language: Haskell2010

359385 Default-Extensions: OverloadedStrings

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

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

361387 Main-Is: examples/out_of_the_tarpit.hs

362388 GHC-Options: -Wall -threaded

363389

364390Executable Example-Blog

365391 Default-Language: Haskell2010

366392 Default-Extensions: OverloadedStrings

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

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

368394 Main-Is: examples/blog.hs

369395 GHC-Options: -Wall -threaded

370396

371397Executable Example-Hair

372398 Default-Language: Haskell2010

373399 Default-Extensions: OverloadedStrings

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

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

375401 Main-Is: examples/hair.hs

376402 GHC-Options: -Wall -threaded

377403

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+

378411Executable Example-CustomTupleable

379412 Default-Language: Haskell2010

380413 Default-Extensions: OverloadedStrings

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

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

382415 Main-Is: examples/CustomTupleable.hs

383416 GHC-Options: -Wall -threaded

384417

@@ -395,14 +428,14 @@ Executable Example-DerivingCustomTupleable

395428Test-Suite test-scripts

396429 import: commontest

397430 type: exitcode-stdio-1.0

398− main-is: test/scripts.hs

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

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

400433

401434Executable project-m36-websocket-server

402435 Default-Language: Haskell2010

403− Build-Depends: base, aeson, path-pieces, either, conduit, http-api-data, template-haskell, websockets, aeson, optparse-applicative, project-m36, containers, bytestring, text, vector, uuid, megaparsec, haskeline, mtl, directory, base64-bytestring, random, MonadRandom, time, network-transport-tcp, semigroups, attoparsec, parser-combinators, network

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

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

405− Other-Modules: ProjectM36.Client.Json, ProjectM36.Server.RemoteCallTypes.Json, ProjectM36.Server.WebSocket, TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.SchemaOperator

438+ Other-Modules: ProjectM36.Client.Json, ProjectM36.Server.RemoteCallTypes.Json, ProjectM36.Server.WebSocket, TutorialD.Interpreter, TutorialD.Interpreter.Base, TutorialD.Interpreter.DatabaseContextExpr, TutorialD.Interpreter.DatabaseContextIOOperator, TutorialD.Interpreter.Export.Base, TutorialD.Interpreter.Export.CSV, TutorialD.Interpreter.Import.Base, TutorialD.Interpreter.Import.BasicExamples, TutorialD.Interpreter.Import.CSV, TutorialD.Interpreter.Import.TutorialD, TutorialD.Interpreter.InformationOperator, TutorialD.Interpreter.RODatabaseContextOperator, TutorialD.Interpreter.RelationalExpr, TutorialD.Interpreter.TransactionGraphOperator, TutorialD.Interpreter.Types, TutorialD.Interpreter.TransGraphRelationalOperator, TutorialD.Interpreter.SchemaOperator, TutorialD.Printer

406439 GHC-Options: -Wall -threaded

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

408441 Default-Extensions: OverloadedStrings

@@ -410,46 +443,46 @@ Executable project-m36-websocket-server

410443Test-Suite test-websocket-server

411444 import: commontest

412445 type: exitcode-stdio-1.0

413− main-is: test/Server/WebSocket.hs

414− 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+ 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

415448

416449Test-Suite test-isomorphic-schemas

417450 import: commontest

418451 type: exitcode-stdio-1.0

419− main-is: test/IsomorphicSchema.hs

452+ main-is: IsomorphicSchema.hs

420453

421454Test-Suite test-atomable

422455 import: commontest

423456 type: exitcode-stdio-1.0

424− main-is: test/Relation/Atomable.hs

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

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

426459

427460Test-Suite test-multiprocess-access

428461 import: commontest

429462 type: exitcode-stdio-1.0

430− main-is: test/MultiProcessDatabaseAccess.hs

463+ main-is: MultiProcessDatabaseAccess.hs

431464

432465Test-Suite test-transactiongraph-automerge

433466 import: commontest

434467 type: exitcode-stdio-1.0

435− main-is: test/TransactionGraph/Automerge.hs

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

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

437470

438471Test-Suite test-tupleable

439472 import: commontest

440473 type: exitcode-stdio-1.0

441− main-is: test/Relation/Tupleable.hs

474+ main-is: Relation/Tupleable.hs

442475

443476Test-Suite test-client-simple

444477 import: commontest

445− Main-Is: test/Client/Simple.hs

478+ Main-Is: Client/Simple.hs

446479 type: exitcode-stdio-1.0

447480

448481-- test for file handle leaks

449482Executable handles

450483 Default-Language: Haskell2010

451484 Default-Extensions: OverloadedStrings

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

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

453486 main-is: benchmark/Handles.hs

454487 Other-Modules: TutorialD.Interpreter,

455488 TutorialD.Interpreter.Base,

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

468501 TutorialD.Interpreter.TransGraphRelationalOperator,

469502 TutorialD.Interpreter.TransactionGraphOperator,

470503 TutorialD.Interpreter.Types

504+ TutorialD.Printer

471505 GHC-Options: -Wall -threaded -rtsopts

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

473507 if flag(profiler)

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

475−

476−Test-Suite test-dataframe

477− import: commontest

478− Main-Is: test/DataFrame.hs

479− type: exitcode-stdio-1.0

480509

510+Test-Suite test-dataframe

511+ import: commontest

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

release.nix+17−58

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

1−{ compiler ? "ghc865"

2−, pkgs ? import ./pkgs.nix

1+{ compiler ? "ghc8104"

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

3+, pkgs ? import sources.nixpkgs { }

34}:

4−

55let

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

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

86 doJailbreak = pkgs.haskell.lib.doJailbreak;

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

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

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

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

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

14− in

15− haskellPackages.callCabal2nixWithOptions pkg (pkgs.fetchzip {

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

17− inherit sha256;

18− }) options;

19−

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+

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

2115 overrides = self: super: {

22− rank1dynamic =

23− distProcessPkg (self.callHackageDirect {

24− pkg = "rank1dynamic";

25− ver = "0.4.0";

26− sha256 = "1x6p9z53s7xwp93jp4n1lq6m5xspcn6w62p461v8vqnp9600328b";

27−}{});

28− stm-hamt =

29− self.callHackageDirect {

30− pkg = "stm-hamt";

31− ver = "1.2.0.3";

32− sha256 = "1i8j7q8nhx3l7gydrjlsyhkvllr6bppgrjf0hp38zpm7p6xcv2bb";

33− }{};

34−

35− stm-containers =

36− self.callHackageDirect {

37− pkg = "stm-containers";

38− ver = "1.1.0.4";

39− sha256 = "0h9z6lawdm44minx9spvdb7sp645l36ri5cnxvhrcxwzr64s7qb5";

40− }{};

41−

42− data-interval =

43− self.callHackageDirect {

44− pkg = "data-interval";

45− ver = "2.0.1";

46− sha256 = "085j4yjr8wimxampxqdrg47p577whwg2mjxgfdl44yfck52fb6an";

47− }{};

48−

49− curryer =

50− self.callHackageDirect {

51− pkg = "curryer";

52− ver = "0.1";

53− sha256 = "085j4yjr8wimxampxqdrg47p577whwg2mjxgfdl44yfck52fb6ac";

54− }{};

55−

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

57−

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

5819 };

5920 };

60−

61− project = haskellPackages.project-m36;

6221in

6322{

64− project = project;

23+ project = haskellPackages.project-m36;

6524

6625 shell = haskellPackages.shellFor {

67− packages = p: with p; [

68− project

26+ packages = p: [

27+ p.project-m36

6928 ];

7029 buildInputs = [

7130 haskellPackages.ghcid

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

7433 ];

7534 withHoogle = true;

7635 };

77−}

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.tutdnew file+2

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

1+x:=relation{

2+tuple{ x 2}} -- nice

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

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

1111import ProjectM36.IsomorphicSchema

1212import ProjectM36.Server.RemoteCallTypes

1313import ProjectM36.MerkleHash

14+import ProjectM36.Attribute as A

1415

1516import Data.Aeson

1617import Data.ByteString.Base64 as B64

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

4445instance ToJSON Relation

4546instance FromJSON Relation

4647

47−instance ToJSON Attribute

48−instance FromJSON Attribute

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"

4953

5054instance ToJSON ExtendTupleExpr

5155instance FromJSON ExtendTupleExpr

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

99103 "val" .= i ]

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

101105 "val" .= i ]

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

107+ "val" .= i ]

102108 toJSON (ConstructedAtom dConsName atomtype atomlist) = object [

103109 "dataconstructorname" .= dConsName,

104110 "type" .= toJSON atomtype,

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

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

127133 Right bs -> pure (ByteStringAtom bs)

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

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

129136

130137instance ToJSON Notification

131138instance FromJSON Notification

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

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

143150 Right bs -> pure (MerkleHash bs)

144151

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+

145158instance ToJSON RelationalError

146159instance FromJSON RelationalError

147160

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

151164instance ToJSON MergeError

152165instance FromJSON MergeError

153166

167+instance ToJSON ImportError'

168+instance FromJSON ImportError'

169+

154170instance ToJSON DatabaseContextFunctionError

155171instance FromJSON DatabaseContextFunctionError

156172

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

165181

166182instance ToJSON WithNameExpr

167183instance FromJSON WithNameExpr

184+

185+

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

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

2222import Control.Applicative

2323import Text.Megaparsec.Error

2424import Data.Functor

25+import Data.Either (fromRight)

2526

2627#if MIN_VERSION_megaparsec(7,0,0)

2728import Data.List.NonEmpty as NE

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

117118promptInfo sessionId conn = do

118119 eHeadName <- headName sessionId conn

119120 eSchemaName <- currentSchemaName sessionId conn

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

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

121122

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

123124sendPromptInfo (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 date</li>

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

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

11{-# LANGUAGE CPP #-}

2−import ProjectM36.Server.WebSocket

3−import ProjectM36.Server.Config

4−import ProjectM36.Server.ParseArgs

5−import ProjectM36.Server

63import Control.Concurrent

7−import qualified Network.WebSockets as WS

84import Control.Exception

5+import Control.Monad (when)

6+import Data.Maybe (isJust)

7+import Data.String (fromString)

8+import Network.HTTP.Types (status400)

99import Network.Socket

10+import Network.Wai (Application, responseLBS)

11+import Network.Wai.Handler.Warp

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

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

14+import Network.WebSockets (defaultConnectionOptions)

15+import ProjectM36.Server

16+import ProjectM36.Server.Config

17+import ProjectM36.Server.ParseArgs

18+import ProjectM36.Server.WebSocket

1019

1120main :: IO ()

1221main = do

1322 -- launch normal project-m36-server

1423 addressMVar <- newEmptyMVar

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

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

25+

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

17− let wsHost = bindHost serverConfig

27+ let serverConfig = wsServerConfig wsConfig

28+ wsHost = bindHost serverConfig

1829 wsPort = bindPort serverConfig

1930 serverHost = "127.0.0.1"

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

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

2239 --wait for server to be listening

2340 addr <- takeMVar addressMVar

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

2542 case addr of

2643 SockAddrInet port' _ -> fromIntegral port'

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

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

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

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"

3055

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

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

3434import Data.List (isPrefixOf)

3535import Control.Exception

3636import System.Exit

37+import Data.Either (fromRight)

3738

3839{-

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

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

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

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

7980 where

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

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

8182

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

8384parseTutorialD = parse interpreterParserP ""

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

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

216217 barf :: RelationalError -> IO TutorialDOperatorResult

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

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

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

219221 eHandler io = do

220222 eErr <- io

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

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

1212 where

1313import ProjectM36.Base

1414import ProjectM36.AtomType

15+import ProjectM36.Attribute as A

1516import ProjectM36.Relation

1617import ProjectM36.DataFrame

1718

1819#if MIN_VERSION_megaparsec(6,0,0)

19−import Text.Megaparsec.Char

20+import Text.Megaparsec.Char

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

2122import Text.Megaparsec

2223import Data.Void

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

3031import System.Random

3132import qualified Data.Text as T

3233import 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,6 +44,7 @@ import Data.List.NonEmpty as NE

4444import Data.Time.Clock

4545import Data.Time.Format

4646import Control.Monad (void)

47+import Data.Char

4748

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

4950anySingle :: Parsec Void Text (Token Text)

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

8182type ParseStr = String

8283#endif

8384

85+-- consumes only horizontal spaces

8486spaceConsumer :: Parser ()

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

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

8688

8789opChar :: Parser Char

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

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

135137semi :: Parser Text

136138semi = symbol ";"

137139

140+nline :: Parser Text

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

142+

138143integer :: Parser Integer

139144#if MIN_VERSION_megaparsec(6,0,0)

140−integer = Lex.signed spaceConsumer Lex.decimal

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

141146#else

142−integer = Lex.signed spaceConsumer Lex.integer

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

143148#endif

144149

145150natural :: Parser Integer

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

150155#endif

151156

152157float :: Parser Double

153−float = Lex.float

158+float = Lex.float <* spaceConsumer

154159

155160capitalizedIdentifier :: Parser Text

156161capitalizedIdentifier =

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

163168showRelationAttributes :: Attributes -> Text

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

165170 where

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

167− attrsL = V.toList attrs

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

172+ attrsL = A.toList attrs

168173

169174type PromptLength = Int

170175

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

200205quotedString :: Parser Text

201206quotedString = try tripleQuotedString <|> normalQuotedString

202207

208+quoted :: Parser a -> Parser a

209+quoted = between quote quote

210+

203211uuidP :: Parser U.UUID

204212uuidP = do

205213 uuidStart <- count 8 hexDigitChar

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

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

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

224232 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+3−2

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

5353multilineSep = newline >> pure "\n"

5454

5555multipleDatabaseContextExprP :: Parser DatabaseContextExpr

56−multipleDatabaseContextExprP =

57− MultipleExpr <$> sepBy1 databaseContextExprP semi

56+multipleDatabaseContextExprP = do

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

58+ pure (MultipleExpr exprs)

5859

5960insertP :: Parser DatabaseContextExpr

6061insertP = do

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

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

22module TutorialD.Interpreter.Import.Base where

33import ProjectM36.Base

44import ProjectM36.Error

5+import Text.URI (URI)

6+import Data.Text (Text)

57#if __GLASGOW_HASKELL__ < 804

68import Data.Monoid

79#endif

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

1214instance Show RelVarDataImportOperator where

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

1416

17+type HashVerification = Maybe Text

18+

1519-- | import data into a database context

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

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

1721

1822instance Show DatabaseContextDataImportOperator where

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

23+ show (DatabaseContextDataImportOperator uri hash _) =

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

2025

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

2227

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

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

2530

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

27−evalDatabaseContextDataImportOperator (DatabaseContextDataImportOperator path importFunc) = importFunc path

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

src/bin/TutorialD/Interpreter/Import/BasicExamples.hs+2−2

@@ -20,8 +20,8 @@ importBasicExampleOperatorP :: Parser ImportBasicExampleOperator

2020importBasicExampleOperatorP = do

2121 reservedOp ":importexample"

2222 example <- identifier

23− if example == "date" then

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

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

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

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

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

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

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

2121

2222importCSVP :: Parser RelVarDataImportOperator

2323importCSVP = do

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

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

99import Control.Exception

1010import qualified Data.ByteString as BS

1111import qualified Data.Text.Encoding as TE

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

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

1319

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−

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+

2875tutdImportP :: Parser DatabaseContextDataImportOperator

2976tutdImportP = do

3077 reserved ":importtutd"

31− path <- quotedString

78+ uri <- quoted URI.parser

3279 spaceConsumer

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

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

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

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

11{-# LANGUAGE GADTs #-}

22module TutorialD.Interpreter.RODatabaseContextOperator where

33import ProjectM36.Base

4+import ProjectM36.Relation

45import qualified ProjectM36.DataFrame as DF

56import ProjectM36.Error

7+import ProjectM36.Tuple

68import ProjectM36.InclusionDependency

79import qualified ProjectM36.Client as C

810import TutorialD.Interpreter.Base

911import TutorialD.Interpreter.RelationalExpr

1012import TutorialD.Interpreter.DatabaseContextExpr

13+import TutorialD.Printer

1114import Control.Monad.State

1215import qualified Data.Text as T

1316import ProjectM36.Relation.Show.Gnuplot

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

1922 ShowRelation :: RelationalExpr -> RODatabaseContextOperator

2023 PlotRelation :: RelationalExpr -> RODatabaseContextOperator

2124 ShowRelationType :: RelationalExpr -> RODatabaseContextOperator

22− ShowConstraint :: StringType -> RODatabaseContextOperator

25+ ShowConstraints :: StringType -> RODatabaseContextOperator

2326 ShowPlan :: DatabaseContextExpr -> RODatabaseContextOperator

2427 ShowTypes :: RODatabaseContextOperator

2528 ShowRelationVariables :: RODatabaseContextOperator

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

3134

3235typeP :: Parser RODatabaseContextOperator

3336typeP = do

34− reservedOp ":type"

37+ colonOp ":type"

3538 ShowRelationType <$> relExprP

3639

3740showRelP :: Parser RODatabaseContextOperator

3841showRelP = do

39− reservedOp ":showexpr"

42+ colonOp ":showexpr"

4043 ShowRelation <$> relExprP

4144

4245showPlanP :: Parser RODatabaseContextOperator

4346showPlanP = do

44− reservedOp ":showplan"

47+ colonOp ":showplan"

4548 ShowPlan <$> databaseContextExprP

4649

4750showTypesP :: Parser RODatabaseContextOperator

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

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

4952

5053showRelationVariables :: Parser RODatabaseContextOperator

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

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

5255

5356showAtomFunctionsP :: Parser RODatabaseContextOperator

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

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

5558

5659showDatabaseContextFunctionsP :: Parser RODatabaseContextOperator

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

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

5861

5962quitP :: Parser RODatabaseContextOperator

6063quitP = do

61− reservedOp ":quit"

64+ colonOp ":quit"

6265 return Quit

6366

6467showConstraintsP :: Parser RODatabaseContextOperator

6568showConstraintsP = do

66− reservedOp ":constraints"

67− ShowConstraint <$> option "" identifier

69+ colonOp ":constraints"

70+ ShowConstraints <$> option "" identifier

6871

6972plotRelExprP :: Parser RODatabaseContextOperator

7073plotRelExprP = do

71− reserved ":plotexpr"

74+ colonOp ":plotexpr"

7275 PlotRelation <$> relExprP

7376

7477roDatabaseContextOperatorP :: Parser RODatabaseContextOperator

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

106109 err <- plotRelation rel

107110 when (isJust err) $ print err

108111

109−evalRODatabaseContextOp sessionId conn (ShowConstraint name) = do

112+evalRODatabaseContextOp sessionId conn (ShowConstraints name) = do

110113 eIncDeps <- C.inclusionDependencies sessionId conn

111114 let val = case eIncDeps of

112115 Left err -> Left err

113116 Right incDeps -> case name of

114− "" -> inclusionDependenciesAsRelation incDeps

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

115118 depName -> case M.lookup depName incDeps of

116119 Nothing -> Left (InclusionDependencyNameNotInUseError depName)

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

120+ Just dep ->

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

118122 pure $ case val of

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

120124 Right rel -> DisplayRelationResult rel

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

164168

165169showDataFrameP :: Parser RODatabaseContextOperator

166170showDataFrameP = do

167− reservedOp ":showdataframe"

171+ colonOp ":showdataframe"

168172 relExpr <- relExprP

169173 reservedOp "orderby"

170174 attrOrdersExpr <- attrOrdersExprP

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

191195

192196orderP :: Parser DF.Order

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

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

2020attributeListP =

2121 (reservedOp "all but" >>

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

23+

2324 (reservedOp "all from" >>

2425 RelationalExprAttributeNames <$> relExprP) <|>

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

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+

2635

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

2837makeRelationP = do

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

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

103112extendP = do

104113 reservedOp ":"

105− Extend <$> braces extendTupleExpressionP

114+ extends <- braces (sepBy extendTupleExpressionP comma)

115+ case extends of

116+ [] -> pure (Restrict TruePredicate)

117+ extends' ->

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

106119

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

108121semijoinP = do

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

129142 [InfixL antijoinP],

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

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

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

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

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

133147 [Postfix extendP]

134148 ]

135149

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

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

201215 constructedAtomExprP consume <|>

202216 attributeAtomExprP <|>

203− nakedAtomExprP <|>

217+ try nakedAtomExprP <|>

204218 relationalAtomExprP

219+

205220

206221attributeAtomExprP :: Parser (AtomExprBase a)

207222attributeAtomExprP = do

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

220235-- used only for primitive type parsing ?

221236atomP :: Parser Atom

222237atomP = stringAtomP <|>

223− doubleAtomP <|>

238+ try doubleAtomP <|>

224239 integerAtomP <|>

225240 boolAtomP

226241

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

235250stringAtomP = TextAtom <$> quotedString

236251

237252doubleAtomP :: Parser Atom

238−doubleAtomP = DoubleAtom <$> try float

253+doubleAtomP = DoubleAtom <$> float

239254

240255integerAtomP :: Parser Atom

241256integerAtomP = IntegerAtom <$> integer

242257

243258boolAtomP :: Parser Atom

244259boolAtomP = do

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

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

260+ v <- identifier

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

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

263+ else

264+ fail "invalid boolAtom"

265+

247266

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

249268relationAtomExprP = RelationAtomExpr <$> makeRelationP

src/bin/TutorialD/Printer.hsnew file+165

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

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

2+{-# LANGUAGE FlexibleInstances #-}

3+{-# LANGUAGE OverloadedStrings #-}

4+{-# LANGUAGE ScopedTypeVariables #-}

5+{-# LANGUAGE TypeApplications #-}

6+module TutorialD.Printer where

7+import ProjectM36.Base

8+import ProjectM36.Attribute as A hiding (null)

9+import Data.Text.Prettyprint.Doc

10+import qualified Data.Set as S hiding (fromList)

11+import qualified Data.Vector as V

12+import qualified Data.Map.Strict as M

13+import Data.Time.Calendar

14+import Data.Time.Clock.POSIX

15+import qualified Data.ByteString.Base64 as B64

16+import qualified Data.Text.Encoding as TE

17+

18+instance Pretty Atom where

19+ pretty (IntegerAtom x) = pretty x

20+ pretty (IntAtom x) = "int" <> parensList [pretty x]

21+ pretty (DoubleAtom x) = pretty x

22+ pretty (TextAtom x) = dquotes (pretty x)

23+ pretty (DayAtom x) = "fromGregorian" <> parensList [pretty a, pretty b, pretty c]

24+ where

25+ (a,b,c) = toGregorian x

26+ pretty (DateTimeAtom time) = "dateTimeFromEpochSeconds" <> parensList [pretty @Integer (round (utcTimeToPOSIXSeconds time))]

27+ pretty (ByteStringAtom bs) = "bytestring" <> parensList [dquotes (pretty (TE.decodeUtf8 (B64.encode bs)))]

28+ pretty (BoolAtom x) = if x then "t" else "f"

29+ pretty (RelationAtom x) = pretty x

30+ pretty (RelationalExprAtom re) = pretty re

31+ pretty (ConstructedAtom n _ as) = pretty n <+> prettyList as

32+

33+instance Pretty AtomExpr where

34+ pretty (AttributeAtomExpr attrName) = pretty attrName

35+ pretty (NakedAtomExpr atom) = pretty atom

36+ pretty (FunctionAtomExpr atomFuncName' atomExprs _) = pretty atomFuncName' <> prettyAtomExprsAsArguments atomExprs

37+ pretty (RelationAtomExpr relExpr) = pretty relExpr

38+ pretty (ConstructedAtomExpr dName [] _) = pretty dName

39+ pretty (ConstructedAtomExpr dName atomExprs _) = pretty dName <+> hsep (map prettyAtomExpr atomExprs)

40+

41+prettyAtomExpr :: AtomExpr -> Doc ann

42+prettyAtomExpr atomExpr =

43+ case atomExpr of

44+ AttributeAtomExpr attrName -> "@" <> pretty attrName

45+ ConstructedAtomExpr dConsName [] () -> pretty dConsName

46+ ConstructedAtomExpr dConsName atomExprs () -> parens (pretty dConsName <+> hsep (map prettyAtomExpr atomExprs))

47+ _ -> pretty atomExpr

48+

49+prettyAtomExprsAsArguments :: [AtomExpr] -> Doc ann

50+prettyAtomExprsAsArguments = align . parensList . map addAt

51+ where addAt (atomExpr :: AtomExpr) =

52+ case atomExpr of

53+ AttributeAtomExpr attrName -> "@" <> pretty attrName

54+ _ -> pretty atomExpr

55+

56+instance Pretty TupleExpr where

57+ pretty (TupleExpr map') = "tuple" <> bracesList (Prelude.map (\(attrName,atom)-> pretty attrName <+> pretty atom) (M.toList map'))

58+

59+instance Pretty RelationTuple where

60+ pretty (RelationTuple attrs atoms) = "tuple" <> bracesList (zipWith (\x y-> pretty x <+> pretty y) (V.toList (attributeNames attrs)) (V.toList atoms))

61+

62+instance Pretty Relation where

63+ pretty (Relation attrs tupSet) | attrs == mempty && null (asList tupSet) = "false"

64+ pretty (Relation attrs tupSet) | attrs == mempty && asList tupSet == [RelationTuple mempty mempty] = "true"

65+ pretty (Relation attrs tupSet) = "relation" <> prettyBracesList (A.toList attrs) <> prettyBracesList (asList tupSet)

66+

67+instance Pretty Attribute where

68+ pretty (Attribute n aTy) = pretty n <+> pretty (show aTy) -- workaround

69+

70+instance Pretty RelationalExpr where

71+ pretty (RelationVariable n _) = pretty n

72+ pretty (ExistingRelation r) = pretty r

73+ pretty (NotEquals a b) = pretty' a <+> "!=" <+> pretty' b

74+ pretty (Equals a b) = pretty' a <+> "==" <+> pretty' b

75+ pretty (Project ns r) = pretty' (ignoreProjects r) <> pretty ns

76+ pretty (Extend ext r) = collectExtends r <> pretty ext <> "}"

77+ pretty (MakeRelationFromExprs Nothing (TupleExprs () tupExprs)) = "relation" <> prettyBracesList tupExprs

78+ pretty (MakeRelationFromExprs (Just attrExprs) (TupleExprs () tupExprs)) = "relation" <> prettyBracesList attrExprs <> prettyBracesList tupExprs

79+ pretty (MakeStaticRelation attrs tupSet) = "relation" <> prettyBracesList (A.toList attrs) <> prettyBracesList (asList tupSet)

80+ pretty (Union a b) = parens $ pretty' a <+> "union" <+> pretty' b

81+ pretty (Join a b) = parens $ pretty' a <+> "join" <+> pretty' b

82+ pretty (Rename n1 n2 relExpr) = parens $ pretty relExpr <+> "rename" <+> braces (pretty n1 <+> "as" <+> pretty n2)

83+ pretty (Difference a b) = parens $ pretty' a <+> "minus" <+> pretty' b

84+ pretty (Group attrNames attrName relExpr) = parens $ pretty relExpr <+> "group" <+> parens (pretty attrNames <+> "as" <+> pretty attrName)

85+ pretty (Ungroup attrName relExpr) = parens $ pretty' relExpr <+> "ungroup" <+> pretty attrName

86+ pretty (Restrict resPreExpr relExpr) = parens $ pretty' relExpr <+> "where" <+> pretty resPreExpr

87+ pretty (With pairs a) = "with" <+> parensList (map (\(name,expr)-> pretty name <+> "as" <+> pretty expr) pairs) <+> pretty' a

88+

89+-- relvar:{a:=?}:{b:=?}:... in ADTs => relvar:{a:=?, b:=?, ...} in Doc ann

90+collectExtends :: RelationalExpr -> Doc ann

91+collectExtends (Extend ext r) = collectExtends r <> pretty ext <> ", "

92+collectExtends r = pretty r <> ":{"

93+

94+--relvar{a,b,c,...}{a,b,...}..{a} => relvar{a}

95+ignoreProjects :: RelationalExpr -> RelationalExpr

96+ignoreProjects (Project _ r) = ignoreProjects r

97+ignoreProjects r = r

98+

99+prettyRelationalExpr :: RelationalExpr -> Doc n

100+prettyRelationalExpr (RelationVariable n _) = pretty n

101+prettyRelationalExpr r = parens (pretty r)

102+

103+pretty' :: RelationalExpr -> Doc n

104+pretty' = prettyRelationalExpr

105+

106+instance Pretty AttributeNames where

107+ pretty (AttributeNames attrNames) = prettyBracesList (S.toList attrNames)

108+ pretty (InvertedAttributeNames attrNames) = braces $ "all but" <+> concatWith (surround ", ") (map pretty (S.toList attrNames))

109+ pretty (RelationalExprAttributeNames relExpr) = braces $ "all from" <+> pretty relExpr

110+ pretty (UnionAttributeNames aAttrNames bAttrNames) = braces ("union of" <+> pretty aAttrNames <+> pretty bAttrNames)

111+ pretty (IntersectAttributeNames aAttrNames bAttrNames) = braces ("intersection of" <+> pretty aAttrNames <+> pretty bAttrNames)

112+

113+instance Pretty AttributeExpr where

114+ pretty (NakedAttributeExpr attr) = pretty attr

115+ pretty (AttributeAndTypeNameExpr name typeCons _) = pretty name <+> pretty typeCons

116+

117+instance Pretty TypeConstructor where

118+ pretty (ADTypeConstructor tcName []) = pretty tcName

119+ pretty (ADTypeConstructor tcName tConsArgs) = pretty tcName <+> hsep (map pretty tConsArgs)

120+ pretty (PrimitiveTypeConstructor tcName atomType') = pretty tcName <+> pretty atomType'

121+ pretty (RelationAtomTypeConstructor attrExprs) = "relation" <> prettyBracesList attrExprs

122+ pretty (TypeVariable x) = pretty x

123+

124+instance Pretty AtomType where

125+ pretty IntAtomType = "Int"

126+ pretty IntegerAtomType = "Integer"

127+ pretty DoubleAtomType = "Double"

128+ pretty TextAtomType = "Text"

129+ pretty DayAtomType = "Day"

130+ pretty DateTimeAtomType = "DateTime"

131+ pretty ByteStringAtomType = "ByteString"

132+ pretty BoolAtomType = "Bool"

133+ pretty (RelationAtomType attrs) = "relation " <+> prettyBracesList (A.toList attrs)

134+ pretty (ConstructedAtomType tcName tvMap) = pretty tcName <+> hsep (map pretty (M.toList tvMap)) --order matters

135+ pretty RelationalExprAtomType = "RelationalExpr"

136+ pretty (TypeVariableType x) = pretty x

137+

138+instance Pretty ExtendTupleExpr where

139+ pretty (AttributeExtendTupleExpr attrName atomExpr) = pretty attrName <> ":=" <> pretty atomExpr

140+

141+

142+instance Pretty RestrictionPredicateExpr where

143+ pretty TruePredicate = "true"

144+ pretty (AndPredicate a b) = pretty a <+> "and" <+> pretty b

145+ pretty (OrPredicate a b) = pretty a <+> "or" <+> pretty b

146+ pretty (NotPredicate a) = "not" <+> pretty a

147+ pretty (RelationalExprPredicate relExpr) = pretty relExpr

148+ pretty (AtomExprPredicate atomExpr) = pretty atomExpr

149+ pretty (AttributeEqualityPredicate attrName atomExpr) = pretty attrName <> "=" <> pretty atomExpr

150+

151+instance Pretty WithNameExpr where

152+ pretty (WithNameExpr name _) = pretty name

153+

154+bracesList :: [Doc ann] -> Doc ann

155+bracesList = group . encloseSep (flatAlt "{ " "{") (flatAlt " }" "}") ", "

156+

157+prettyBracesList :: Pretty a => [a] -> Doc ann

158+prettyBracesList = align . bracesList . map pretty

159+

160+parensList :: [Doc ann] -> Doc ann

161+parensList = group . encloseSep (flatAlt "( " "(") (flatAlt " )" ")") ", "

162+

163+prettyParensList :: Pretty a => [a] -> Doc ann

164+prettyParensList = align . parensList . map pretty

165+

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

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

99import ProjectM36.Attribute (atomType)

1010import ProjectM36.DataConstructorDef as DCD

1111import ProjectM36.DataTypes.Interval

12+import ProjectM36.Relation

1213import qualified Data.Vector as V

1314import Data.Text (Text)

1415import Test.QuickCheck

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

4849

4950arbitrary' BoolAtomType =

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

52+

53+arbitrary' RelationalExprAtomType =

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

55+

5156arbitrary' constructedAtomType@(ConstructedAtomType tcName tvMap)

5257 --special-casing for Interval type

5358 | isIntervalAtomType constructedAtomType = createArbitraryInterval (intervalSubType constructedAtomType)

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

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

8085arbitraryRelationTuple attris = do

8186 tcMap <- ask

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

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

8388 case sequence listOfMaybeAType of

8489 Left err -> pure $ Left err

8590 Right listOfAttr -> do

src/lib/ProjectM36/Atom.hs+1

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

2324

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

2526atomToText (ConstructedAtom dConsName typ atoms)

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

@@ -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 (map A.atomType (V.toList attrs)) evaldAtomTypes)

214+ mapM_ (uncurry resolveAtomType) (zip (A.atomTypesList 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) $ map A.atomType (V.toList resolvedAttrs))

298+ newAtoms <- mapM (\(atom, resolvedType) -> resolveTypeInAtom resolvedType atom tConss) (zip (V.toList tupAtoms) $ A.atomTypesList 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) (V.toList attrs)

317+ validateAtomType (A.atomType attr) tConss) (attributesVec 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.atomType) (V.toList attrs)

328+ errs = lefts $ map (`validateAtomType` tConss) (A.atomTypesList 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 attrs1 attrs2)

361+ atomTypeVerify (A.atomType attr1) (A.atomType attr2)) $ V.toList (V.zip (attributesVec attrs1) (attributesVec 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 attrs)) `T.append` "}"

378+prettyAtomType (RelationAtomType attrs) = "relation {" `T.append` T.intercalate "," (map prettyAttribute (V.toList (attributesVec 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,12 +442,13 @@ isResolvedType typ =

442442 DateTimeAtomType -> True

443443 ByteStringAtomType -> True

444444 BoolAtomType -> True

445+ RelationalExprAtomType -> True

445446 RelationAtomType attrs -> isResolvedAttributes attrs

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

447448 TypeVariableType _ -> False

448449

449450isResolvedAttributes :: Attributes -> Bool

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

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

451452

452453isResolvedAttribute :: Attribute -> Bool

453454isResolvedAttribute = isResolvedType . A.atomType

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

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

235235typeToTypeConstructor x@DateTimeAtomType = PrimitiveTypeConstructor "DateTime" x

236236typeToTypeConstructor x@ByteStringAtomType = PrimitiveTypeConstructor "ByteString" x

237237typeToTypeConstructor x@BoolAtomType = PrimitiveTypeConstructor "Bool" x

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

238239typeToTypeConstructor (RelationAtomType attrs)

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

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

240241 where

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

242243typeToTypeConstructor (ConstructedAtomType tcName tvMap)

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

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

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

12module ProjectM36.Attribute where

23import ProjectM36.Base

34import ProjectM36.Error

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

1011import Data.Either

1112

1213arity :: Attributes -> Int

13−arity = V.length

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

15+

16+instance Semigroup Attributes where

17+ attrsA <> attrsB =

18+ case joinAttributes attrsA attrsB of

19+ Left err -> error (show err)

20+ Right attrs' -> attrs'

21+

22+instance Monoid Attributes where

23+ mempty = Attributes {

24+ attributesVec = mempty

25+ --,attributeSet = mempty

26+ }

1427

1528emptyAttributes :: Attributes

16−emptyAttributes = V.empty

29+emptyAttributes = mempty

1730

1831null :: Attributes -> Bool

19−null = V.null

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

33+

34+singleton :: Attribute -> Attributes

35+singleton attr = Attributes {

36+ attributesVec = V.singleton attr

37+ --,attributesSet = HS.singleton attr

38+ }

39+

40+toList :: Attributes -> [Attribute]

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

2042

2143attributesFromList :: [Attribute] -> Attributes

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

44+attributesFromList attrsL = Attributes {

45+ attributesVec = vec

46+ --,attributesSet = hset

47+ }

48+ where

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

50+ --fast path- no duplicates

51+ V.fromList attrsL

52+ else

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

54+ V.fromList uniquedL

55+ hset = HS.fromList attrsL

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

57+ if HS.member attr s then

58+ acc

59+ else

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

61+ ([],mempty) attrsL

2362

2463attributeName :: Attribute -> AttributeName

2564attributeName (Attribute name _) = name

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

2867atomType (Attribute _ atype) = atype

2968

3069atomTypes :: Attributes -> V.Vector AtomType

31−atomTypes = V.map atomType

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

3271

3372atomTypesList :: Attributes -> [AtomType]

3473atomTypesList = V.toList . atomTypes

3574

36−--hm- no error-checking here

3775addAttribute :: Attribute -> Attributes -> Attributes

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

76+addAttribute attr attrs = attrs <> singleton attr

3977

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

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

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

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

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

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

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

4785 attrNames2 = V.map attributeName attrs2

4886 uniqueOverlappingAttributes = vectorUniqueify overlappingAttributes

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

50106

51107addAttributes :: Attributes -> Attributes -> Attributes

52−addAttributes = (V.++)

108+addAttributes = (<>)

109+

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

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

53112

54113deleteAttributeName :: AttributeName -> Attributes -> Attributes

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

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

115+

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

117+deleteAttributeNames attrNames attrs = Attributes {

118+ attributesVec = vec

119+ }

120+ where

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

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

56123

57124renameAttribute :: AttributeName -> Attribute -> Attribute

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

59126

60127renameAttributes :: AttributeName -> AttributeName -> Attributes -> Attributes

61−renameAttributes oldAttrName newAttrName = V.map renamer

128+renameAttributes oldAttrName newAttrName attrs = Attributes {

129+ attributesVec = vec

130+ }

62131 where

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

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

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

64134 renameAttribute newAttrName attr

65135 else

66136 attr

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

71141 return atype

72142

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

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

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

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

76146 Just attr -> Right attr

77147

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

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

90160

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

92−attributesForNames attrNameSet = V.filter filt

162+attributesForNames attrNameSet attrs = Attributes {

163+ attributesVec = vec

164+ }

93165 where

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

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

95168

96169attributeNameSet :: Attributes -> S.Set AttributeName

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

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

98171

99172attributeNames :: Attributes -> V.Vector AttributeName

100−attributeNames = V.map attributeName

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

101174

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

103176attributesContained :: Attributes -> Attributes -> Bool

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

118191

119192-- useful for display

120193orderedAttributes :: Attributes -> [Attribute]

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

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

122195

123196orderedAttributeNames :: Attributes -> [AttributeName]

124197orderedAttributeNames attrs = map attributeName (orderedAttributes attrs)

125198

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

127201attributesDifference :: Attributes -> Attributes -> Attributes

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

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

129203 where

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

131219

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

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

134222

135223--check that each attribute only appears once

136224verifyAttributes :: Attributes -> Either RelationalError Attributes

137−verifyAttributes attrs = if collapsedAttrs /= attrs then

138− Left (TupleAttributeTypeMismatchError (attributesDifference collapsedAttrs attrs))

139− else

140− Right attrs

225+verifyAttributes attrs =

226+ if vecSet == attributesSet attrs then

227+ pure attrs

228+ else

229+ Left (TupleAttributeTypeMismatchError diffAttrs)

141230 where

142− collapsedAttrs = vectorUniqueify attrs

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

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

233+ diffAttrs = Attributes {

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

235+ --,attributesSet = diffSet

236+ }

237+

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

239+--drop first n attributes from vector representation

240+drop :: Int -> Attributes -> Attributes

241+drop c attrs = Attributes { attributesVec = vec

242+ }

243+ where

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

245+

246+

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

248+attributesAndOrderEqual :: Attributes -> Attributes -> Bool

249+attributesAndOrderEqual a b = attributesVec a == attributesVec b

143250

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

144252attributesEqual :: Attributes -> Attributes -> Bool

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

253+attributesEqual attrsA attrsB =

254+ attributesVec attrsA == attributesVec attrsB ||

255+ attributesSet attrsA == attributesSet attrsB

146256

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

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

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

259+

149260

150261-- | Left-biased union of attributes.

151262union :: Attributes -> Attributes -> Attributes

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

263+union attrsA attrsB = Attributes {

264+ attributesVec = vec

265+ --,attributesSet = hset

266+ }

153267 where

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

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

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

155270

156271intersection :: Attributes -> Attributes -> Attributes

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

272+intersection attrsA attrsB = Attributes {

273+ attributesVec = vec

274+ --,attributesSet = hset

275+ }

158276 where

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

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

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

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

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

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

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

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

44module ProjectM36.Base where

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

66import ProjectM36.AtomFunctionError

77import ProjectM36.MerkleHash

9+import Data.Functor.Foldable.TH

910import qualified Data.Map as M

1011import qualified Data.HashSet as HS

1112import Data.Hashable (Hashable, hashWithSalt)

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

2425import Data.Typeable

2526import Data.ByteString (ByteString)

2627import qualified Data.List.NonEmpty as NE

28+import Data.Vector.Instances ()

2729

2830type StringType = Text

31+

32+type DatabaseName = String

2933

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

3135data Atom = IntegerAtom Integer |

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

3741 ByteStringAtom ByteString |

3842 BoolAtom Bool |

3943 RelationAtom Relation |

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

4045 ConstructedAtom DataConstructorName AtomType [Atom]

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

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

4247

4348instance Hashable Atom where

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

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

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

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

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

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

5561

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

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

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

6571 BoolAtomType |

6672 RelationAtomType Attributes |

6773 ConstructedAtomType TypeConstructorName TypeVarMap |

74+ RelationalExprAtomType |

6875 TypeVariableType TypeVarName

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

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

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

7178

7279instance Ord AtomType where

7380 compare = undefined

74−

81+

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

7583type TypeVarMap = M.Map TypeVarName AtomType

7684

7785instance Hashable TypeVarMap where

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

8694type AttributeName = StringType

8795

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

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

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

9098

9199instance Hashable Attribute where

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

93101

102+type AttributesHash = Int

103+

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

95−type Attributes = V.Vector Attribute

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

96122

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

98−attributesEqual :: Attributes -> Attributes -> Bool

99−attributesEqual attrs1 attrs2 = attrsAsSet attrs1 == attrsAsSet attrs2

100− where

101− attrsAsSet = HS.fromList . V.toList

102−

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

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

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

105125

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

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

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

128+

129+instance Read Relation where

130+ readsPrec = error "relation read not supported"

108131

109132instance Eq RelationTupleSet where

110133 set1 == set2 = hset set1 == hset set2

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

117140instance Hashable RelationTuple where

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

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

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

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

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

122145 else

123146 salt `hashWithSalt`

124147 sortedAttrs `hashWithSalt`

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

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

130153

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

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

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

133156

134157instance Eq RelationTuple where

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

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

159+ attrs1 == attrs2 && atomsEqual

136160 where

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

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

138162 Nothing -> Nothing

139163 Just index -> tupVec V.!? index

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

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

141165

142166instance NFData RelationTuple where rnf = genericRnf

143167

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

145169

146170instance Eq Relation where

147− Relation attrs1 tupSet1 == Relation attrs2 tupSet2 = attributesEqual attrs1 attrs2 && tupSet1 == tupSet2

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

148172

149173instance NFData Relation where rnf = genericRnf

150174

@@ -199,10 +223,12 @@ data RelationalExprBase a =

199223 --Summarize :: AtomExpr -> AttributeName -> RelationalExpr -> RelationalExpr -> RelationalExpr -- a special case of Extend

200224 --Evaluate relationalExpr with scoped views

201225 With [(WithNameExprBase a, RelationalExprBase a)] (RelationalExprBase a)

202− deriving (Show, Eq, Generic, NFData, Foldable, Functor, Traversable)

203−

226+ deriving (Show, Read, Eq, Generic, NFData, Foldable, Functor, Traversable)

227+

228+instance Hashable RelationalExpr

229+

204230data WithNameExprBase a = WithNameExpr RelVarName a

205− deriving (Show, Eq, Generic, NFData, Foldable, Functor, Traversable)

231+ deriving (Show, Read, Eq, Generic, NFData, Foldable, Functor, Traversable, Hashable)

206232

207233type WithNameExpr = WithNameExprBase ()

208234

@@ -224,15 +250,15 @@ type TypeVarName = StringType

224250-- | Metadata definition for type constructors such as @data Either a b@.

225251data TypeConstructorDef = ADTypeConstructorDef TypeConstructorName [TypeVarName] |

226252 PrimitiveTypeConstructorDef TypeConstructorName AtomType

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

253+ deriving (Show, Generic, Eq, NFData, Hashable, Read)

228254

229255-- | Found in data constructors and type declarations: Left (Either Int Text) | Right Int

230256type TypeConstructor = TypeConstructorBase ()

231257data TypeConstructorBase a = ADTypeConstructor TypeConstructorName [TypeConstructor] |

232− PrimitiveTypeConstructor TypeConstructorName AtomType |

233− RelationAtomTypeConstructor [AttributeExprBase a] |

234− TypeVariable TypeVarName

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

258+ PrimitiveTypeConstructor TypeConstructorName AtomType |

259+ RelationAtomTypeConstructor [AttributeExprBase a] |

260+ TypeVariable TypeVarName

261+ deriving (Show, Generic, Eq, NFData, Hashable, Read)

236262

237263type TypeConstructorMapping = [(TypeConstructorDef, DataConstructorDefs)]

238264

@@ -242,13 +268,13 @@ type DataConstructorName = StringType

242268type AtomTypeName = StringType

243269

244270-- | Used to define a data constructor in a type constructor context such as @Left a | Right b@

245−data DataConstructorDef = DataConstructorDef DataConstructorName [DataConstructorDefArg] deriving (Eq, Show, Generic, NFData)

271+data DataConstructorDef = DataConstructorDef DataConstructorName [DataConstructorDefArg] deriving (Eq, Show, Generic, NFData, Hashable, Read)

246272

247273type DataConstructorDefs = [DataConstructorDef]

248274

249275data DataConstructorDefArg = DataConstructorDefTypeConstructorArg TypeConstructor |

250276 DataConstructorDefTypeVarNameArg TypeVarName

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

277+ deriving (Show, Generic, Eq, NFData, Hashable, Read)

252278

253279type InclusionDependencies = M.Map IncDepName InclusionDependency

254280type RelationVariables = M.Map RelVarName GraphRefRelationalExpr

@@ -293,7 +319,7 @@ data DatabaseContext = DatabaseContext {

293319type IncDepName = StringType

294320

295321-- | Inclusion dependencies represent every possible database constraint. Constraints enforce specific, arbitrarily-complex rules to which the database context's relation variables must adhere unconditionally.

296−data InclusionDependency = InclusionDependency RelationalExpr RelationalExpr deriving (Show, Eq, Generic, NFData)

322+data InclusionDependency = InclusionDependency RelationalExpr RelationalExpr deriving (Show, Eq, Generic, NFData, Hashable, Read)

297323

298324type AttributeNameAtomExprMap = M.Map AttributeName AtomExpr

299325

@@ -302,6 +328,8 @@ type DatabaseContextExprName = StringType

302328

303329type DatabaseContextExpr = DatabaseContextExprBase ()

304330

331+instance Hashable DatabaseContextExpr

332+

305333type GraphRefDatabaseContextExpr = DatabaseContextExprBase GraphRefTransactionMarker

306334

307335-- | Database context expressions modify the database context.

@@ -331,7 +359,10 @@ data DatabaseContextExprBase a =

331359 ExecuteDatabaseContextFunction DatabaseContextFunctionName [AtomExprBase a] |

332360

333361 MultipleExpr [DatabaseContextExprBase a]

334− deriving (Show, Eq, Generic)

362+ deriving (Show, Read, Eq, Generic, NFData)

363+

364+instance Hashable (M.Map AttributeName AtomExpr) where

365+ hashWithSalt salt m = salt `hashWithSalt` M.toList m

335366

336367type ObjModuleName = StringType

337368type ObjFunctionName = StringType

@@ -351,6 +382,8 @@ type DatabaseContextIOExpr = DatabaseContextIOExprBase ()

351382

352383type RestrictionPredicateExpr = RestrictionPredicateExprBase ()

353384

385+instance Hashable RestrictionPredicateExpr

386+

354387type GraphRefRestrictionPredicateExpr = RestrictionPredicateExprBase GraphRefTransactionMarker

355388

356389-- | Restriction predicates are boolean algebra components which, when composed, indicate whether or not a tuple should be retained during a restriction (filtering) operation.

@@ -362,7 +395,7 @@ data RestrictionPredicateExprBase a =

362395 RelationalExprPredicate (RelationalExprBase a) | --type must be same as true and false relations (no attributes)

363396 AtomExprPredicate (AtomExprBase a) | --atom must evaluate to boolean

364397 AttributeEqualityPredicate AttributeName (AtomExprBase a) -- relationalexpr must result in relation with single tuple

365− deriving (Show, Eq, Generic, NFData, Foldable, Functor, Traversable)

398+ deriving (Show, Read, Eq, Generic, NFData, Foldable, Functor, Traversable)

366399

367400-- child + parent links

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

@@ -423,6 +456,8 @@ instance Ord Transaction where

423456

424457type AtomExpr = AtomExprBase ()

425458

459+instance Hashable AtomExpr

460+

426461type GraphRefAtomExpr = AtomExprBase GraphRefTransactionMarker

427462

428463-- | An atom expression represents an action to take when extending a relation or when statically defining a relation or a new tuple.

@@ -431,13 +466,16 @@ data AtomExprBase a = AttributeAtomExpr AttributeName |

431466 FunctionAtomExpr AtomFunctionName [AtomExprBase a] a |

432467 RelationAtomExpr (RelationalExprBase a) |

433468 ConstructedAtomExpr DataConstructorName [AtomExprBase a] a

434− deriving (Eq,Show,Generic, NFData, Foldable, Functor, Traversable)

469+ deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable)

435470

436471-- | Used in tuple creation when creating a relation.

437472data ExtendTupleExprBase a = AttributeExtendTupleExpr AttributeName (AtomExprBase a)

438− deriving (Show, Eq, Generic, NFData, Foldable, Functor, Traversable)

473+ deriving (Show, Read, Eq, Generic, NFData, Foldable, Functor, Traversable)

439474

440475type ExtendTupleExpr = ExtendTupleExprBase ()

476+

477+instance Hashable ExtendTupleExpr

478+

441479type GraphRefExtendTupleExpr = ExtendTupleExprBase GraphRefTransactionMarker

442480

443481--enumerates the list of functions available to be run as part of tuple expressions

@@ -485,7 +523,12 @@ data AttributeNamesBase a = AttributeNames (S.Set AttributeName) |

485523 UnionAttributeNames (AttributeNamesBase a) (AttributeNamesBase a) |

486524 IntersectAttributeNames (AttributeNamesBase a) (AttributeNamesBase a) |

487525 RelationalExprAttributeNames (RelationalExprBase a) -- use attribute names from the relational expression's type

488− deriving (Eq, Show, Generic, NFData, Foldable, Functor, Traversable)

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

489532

490533type AttributeNames = AttributeNamesBase ()

491534

@@ -503,18 +546,22 @@ type GraphRefAttributeExpr = AttributeExprBase GraphRefTransactionMarker

503546-- | Create attributes dynamically.

504547data AttributeExprBase a = AttributeAndTypeNameExpr AttributeName TypeConstructor a |

505548 NakedAttributeExpr Attribute

506− deriving (Eq, Show, Generic, NFData, Foldable, Functor, Traversable)

549+ deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable, Hashable)

507550

508551-- | Dynamically create a tuple from attribute names and 'AtomExpr's.

509552newtype TupleExprBase a = TupleExpr (M.Map AttributeName (AtomExprBase a))

510− deriving (Eq, Show, Generic, NFData, Foldable, Functor, Traversable)

511−

553+ deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable)

554+

555+instance Hashable TupleExpr

556+

512557type TupleExpr = TupleExprBase ()

513558

514559type GraphRefTupleExpr = TupleExprBase GraphRefTransactionMarker

515560

516561data TupleExprsBase a = TupleExprs a [TupleExprBase a]

517− deriving (Eq, Show, Generic, NFData, Foldable, Functor, Traversable)

562+ deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable)

563+

564+instance Hashable TupleExprs

518565

519566type GraphRefTupleExprs = TupleExprsBase GraphRefTransactionMarker

520567

@@ -564,7 +611,8 @@ attrTypeVars (Attribute _ aType) = case aType of

564611 DateTimeAtomType -> S.empty

565612 ByteStringAtomType -> S.empty

566613 BoolAtomType -> S.empty

567− (RelationAtomType attrs) -> S.unions (map attrTypeVars (V.toList attrs))

614+ RelationalExprAtomType -> S.empty

615+ (RelationAtomType attrs) -> S.unions (map attrTypeVars (V.toList (attributesVec attrs)))

568616 (ConstructedAtomType _ tvMap) -> M.keysSet tvMap

569617 (TypeVariableType nam) -> S.singleton nam

570618

@@ -587,13 +635,12 @@ atomTypeVars DayAtomType = S.empty

587635atomTypeVars DateTimeAtomType = S.empty

588636atomTypeVars ByteStringAtomType = S.empty

589637atomTypeVars BoolAtomType = S.empty

590−atomTypeVars (RelationAtomType attrs) = S.unions (map attrTypeVars (V.toList attrs))

638+atomTypeVars RelationalExprAtomType = S.empty

639+atomTypeVars (RelationAtomType attrs) = S.unions (map attrTypeVars (V.toList (attributesVec attrs)))

591640atomTypeVars (ConstructedAtomType _ tvMap) = M.keysSet tvMap

592641atomTypeVars (TypeVariableType nam) = S.singleton nam

593642

594643unimplemented :: HasCallStack => a

595−unimplemented = undefined

596−

597−--for serializing GraphRefRelationalExpr as part of transaction serialization

644+unimplemented = error "unimplemented"

598645

599−

646+makeBaseFunctor ''RelationalExprBase

src/lib/ProjectM36/Client.hs+79−129

@@ -127,7 +127,6 @@ import ProjectM36.TransGraphRelationalExpression as TGRE (TransGraphRelationalEx

127127import ProjectM36.Persist (DiskSync(..))

128128import ProjectM36.FileLock

129129import ProjectM36.NormalizeExpr

130−import ProjectM36.Server.Types

131130import ProjectM36.Notifications

132131import ProjectM36.Server.RemoteCallTypes

133132import qualified ProjectM36.DisconnectedTransaction as Discon

@@ -135,11 +134,13 @@ import ProjectM36.Relation (typesAsRelation)

135134import ProjectM36.ScriptSession (initScriptSession, ScriptSession)

136135import qualified ProjectM36.Relation as R

137136import Control.Exception.Base

138−import GHC.Conc.Sync

137+import Control.Concurrent.STM

138+import Control.Concurrent.Async

139139

140140import Data.Either (isRight)

141141import Data.UUID.V4 (nextRandom)

142142import Data.Word

143+import Data.Hashable

143144import Control.Exception (IOException, handle, AsyncException, throwIO, fromException, Exception)

144145import Control.Concurrent.MVar

145146import Codec.Winery hiding (Schema, schema)

@@ -161,6 +162,7 @@ import Data.Time.Clock

161162import qualified Network.RPC.Curryer.Client as RPC

162163import qualified Network.RPC.Curryer.Server as RPC

163164import Network.Socket (Socket, AddrInfo(..), getAddrInfo, defaultHints, AddrInfoFlag(..), SocketType(..), ServiceName, hostAddressToTuple, SockAddr(..))

165+import GHC.Conc (unsafeIOToSTM)

164166

165167type Hostname = String

166168

@@ -246,9 +248,10 @@ createScriptSession :: [String] -> IO (Maybe ScriptSession)

246248createScriptSession ghcPkgPaths = do

247249 eScriptSession <- initScriptSession ghcPkgPaths

248250 case eScriptSession of

249− Left err -> hPutStrLn stderr ("Failed to load scripting engine- scripting disabled: " ++ show err) >> pure Nothing --not a fatal error, but the scripting feature must be disabled

251+ Left err -> hPutStrLn stderr ("Warning: Haskell scripting disabled: " ++ show err) >> pure Nothing --not a fatal error, but the scripting feature must be disabled

250252 Right s -> pure (Just s)

251253

254+

252255-- | To create a 'Connection' to a remote or local database, create a 'ConnectionInfo' and call 'connectProjectM36'.

253256connectProjectM36 :: ConnectionInfo -> IO (Either ConnectionError Connection)

254257--create a new in-memory database/transaction graph

@@ -264,14 +267,16 @@ connectProjectM36 (InProcessConnectionInfo strat notificationCallback ghcPkgPath

264267 clientNodes <- StmSet.newIO

265268 sessions <- StmMap.newIO

266269 mScriptSession <- createScriptSession ghcPkgPaths

267−

270+ notifAsync <- startNotificationListener clientNodes notificationCallback

268271 let conn = InProcessConnection InProcessConnectionConf {

269272 ipPersistenceStrategy = strat,

270273 ipClientNodes = clientNodes,

271274 ipSessions = sessions,

272275 ipTransactionGraph = graphTvar,

273276 ipScriptSession = mScriptSession,

274− ipLocks = Nothing}

277+ ipLocks = Nothing,

278+ ipCallbackAsync = notifAsync

279+ }

275280 pure (Right conn)

276281 MinimalPersistence dbdir -> connectPersistentProjectM36 strat NoDiskSync dbdir freshGraph notificationCallback ghcPkgPaths

277282 CrashSafePersistence dbdir -> connectPersistentProjectM36 strat FsyncDiskSync dbdir freshGraph notificationCallback ghcPkgPaths

@@ -292,22 +297,32 @@ connectProjectM36 (RemoteConnectionInfo dbName hostName servicePort notification

292297 \(NotificationMessage notifications') ->

293298 forM_ (M.toList notifications') (uncurry notificationCallback)

294299 ]

295−-- TODO missing async callback

296− conn <- RPC.connect notificationHandlers (hostAddressToTuple addr) port

297− eRet <- RPC.call conn (Login dbName)

298−-- TODO handle connection errors

299− case eRet of

300− Left err -> error (show err)

301− Right False -> error "wtf"

302− Right True ->

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

303310 --TODO handle connection errors!

304− pure (Right (RemoteConnection (RemoteConnectionConf conn)))

311+ pure (Right (RemoteConnection (RemoteConnectionConf conn)))

305312

306−addClientNode :: DatabaseName ->Connection -> RPC.Locking Socket -> IO ()

307−addClientNode _ (RemoteConnection _) _ = error "addClientNode called on remote connection"

308−addClientNode dbName (InProcessConnection conf) lockSock = atomically (StmSet.insert clientInfo (ipClientNodes conf))

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

309324 where

310− clientInfo = ClientInfo dbName lockSock

325+ clientInfo = RemoteClientInfo lockSock

311326

312327connectPersistentProjectM36 :: PersistenceStrategy ->

313328 DiskSync ->

@@ -333,17 +348,27 @@ connectPersistentProjectM36 strat sync dbdir freshGraph notificationCallback ghc

333348 sessions <- StmMap.newIO

334349 clientNodes <- StmSet.newIO

335350 lockMVar <- newMVar digest

351+ notifAsync <- startNotificationListener clientNodes notificationCallback

336352 let conn = InProcessConnection InProcessConnectionConf {

337353 ipPersistenceStrategy = strat,

338354 ipClientNodes = clientNodes,

339355 ipSessions = sessions,

340356 ipTransactionGraph = tvarGraph,

341357 ipScriptSession = mScriptSession,

342− ipLocks = Just (lockFileH, lockMVar)

358+ ipLocks = Just (lockFileH, lockMVar),

359+ ipCallbackAsync = notifAsync

343360 }

344−

345361 pure (Right conn)

346−

362+

363+--startup local async process to handle notification callbacks

364+startNotificationListener :: ClientNodes -> NotificationCallback -> IO (Async ())

365+startNotificationListener cNodes notificationCallback = do

366+ inProcessClientInfo@(InProcessClientInfo notifMVar) <- InProcessClientInfo <$> newEmptyMVar

367+ atomically $ StmSet.insert inProcessClientInfo cNodes

368+ async $ forever $ do

369+ notifs <- takeMVar notifMVar

370+ forM_ (M.toList notifs) $ uncurry notificationCallback

371+

347372-- | Create a new session at the transaction id and return the session's Id.

348373createSessionAtCommit :: Connection -> TransactionId -> IO (Either RelationalError SessionId)

349374createSessionAtCommit conn@(InProcessConnection _) commitId = do

@@ -389,6 +414,7 @@ closeSession sessionId conn@(RemoteConnection _) = remoteCall conn (CloseSession

389414-- | 'close' cleans up the database access connection and closes any relevant sockets.

390415close :: Connection -> IO ()

391416close (InProcessConnection conf) = do

417+ cancel (ipCallbackAsync conf)

392418 atomically $ do

393419 let sessions = ipSessions conf

394420#if MIN_VERSION_stm_containers(1,0,0)

@@ -420,24 +446,14 @@ excEither = handle handler

420446 handler exc | Just (_ :: AsyncException) <- fromException exc = throwIO exc

421447 | otherwise = pure (Left (UnhandledExceptionError (show exc)))

422448

423−{-

424−safeLogin :: Login -> ProcessId -> Process Bool

425−safeLogin login procId = do

426− ret <- call procId login

427− case ret of

428− Left (_ :: ServerError) -> pure False

429− Right val -> pure val

430−-}

431449

432450remoteCall :: (Serialise a, Serialise b) => Connection -> a -> IO b

433451remoteCall (InProcessConnection _ ) _ = error "remoteCall called on local connection"

434452remoteCall (RemoteConnection (RemoteConnectionConf rpcConn)) arg = do

435453 eRet <- RPC.call rpcConn arg

436454 case eRet of

437− Left err -> error ("connection died " <> show err) --TODO: throw some more specific exceptions

455+ Left err -> convertRPCErrors err

438456 Right val -> pure val

439−

440−

441457

442458sessionForSessionId :: SessionId -> Sessions -> STM (Either RelationalError Session)

443459sessionForSessionId sessionId sessions =

@@ -599,20 +615,6 @@ executeDatabaseContextIOExpr sessionId (InProcessConnection conf) expr = excEith

599615 pure (Right ())

600616executeDatabaseContextIOExpr sessionId conn@(RemoteConnection _) dbExpr = remoteCall conn (ExecuteDatabaseContextIOExpr sessionId dbExpr)

601617

602−{-

603−executeGraphExprSTM_ :: TransactionId -> SessionId -> Session -> Sessions -> TransactionGraphOperator -> TransactionGraph -> TVar TransactionGraph -> STM (Either RelationalError (TransactionGraph, DisconnectedTransaction)

604−executeGraphExprSTM_ freshId sessionId session sessions graphExpr graph graphTVar= do

605− case evalGraphOp freshId (Sess.disconnectedTransaction session) graph graphExpr of

606− Left err -> do

607− when updateGraphOnError (writeTVar graphTVar graph)

608− pure $ Left err

609− Right (discon', graph') -> do

610− writeTVar graphTVar graph'

611− let newSession = Session discon' (Sess.schemaName session)

612− STMMap.insert newSession sessionId sessions

613− pure $ Right graph'

614−-}

615−

616618-- process notifications for commits

617619executeCommitExprSTM_

618620 :: TransactionGraph

@@ -653,77 +655,7 @@ executeGraphExpr sessionId (InProcessConnection conf) graphExpr = excEither $ do

653655 --if freshId appears in the graph, then we need to pass it on

654656 let transIds = [freshId | isRight (RE.transactionForId freshId graph')]

655657 pure (Right (discon', graph', transIds))

656−{-

657−executeGraphExpr sessionId (InProcessConnection conf) graphExpr = excEither $ do

658− let strat = ipPersistenceStrategy conf

659− clientNodes = ipClientNodes conf

660− sessions = ipSessions conf

661− graphTvar = ipTransactionGraph conf

662− mLockFileH = ipLocks conf

663− lockHandler body = case graphExpr of

664− Commit -> case mLockFileH of

665− Nothing -> body False

666− Just (lockFileH, lockMVar) -> let acquireLocks = do

667− lastWrittenDigest <- takeMVar lockMVar

668− lockFile lockFileH WriteLock

669− latestDigest <- readGraphTransactionIdDigest strat

670− pure (latestDigest /= lastWrittenDigest)

671−

672− releaseLocks _ = do

673− --still holding the lock- get the latest digest

674− gDigest <- readGraphTransactionIdDigest strat

675− unlockFile lockFileH

676− putMVar lockMVar gDigest

677− in bracket acquireLocks releaseLocks body

678− _ -> body False

679− freshId <- nextRandom

680− lockHandler $ \dbWrittenByOtherProcess -> do

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

682− --read transaction data and compare to existing graph

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

684− manip <- atomically $ do

685− eSession <- sessionForSessionId sessionId sessions

686− --handle graph update by other process

687− oldGraph <- readTVar graphTvar

688− case eSession of

689− Left err -> pure (Left err)

690− Right session -> do

691− let mScriptSession = ipScriptSession conf

692− dbdir = case strat of

693− MinimalPersistence x -> x

694− CrashSafePersistence x -> x

695− _ -> error "accessing dbdir on non-persisted connection"

696− eRefreshedGraph <- if dbWrittenByOtherProcess then

697− unsafeIOToSTM (transactionGraphLoad dbdir oldGraph mScriptSession)

698− else

699− pure (Right oldGraph)

700− case eRefreshedGraph of

701− Left err -> pure (Left (DatabaseLoadError err))

702− Right refreshedGraph -> do

703− --snip it

704− eGraph <- executeGraphExprSTM_ dbWrittenByOtherProcess freshId sessionId session sessions graphExpr refreshedGraph graphTvar

705− --snip it

706− case eGraph of

707− Left err -> pure (Left err)

708− Right newGraph -> do

709− --handle commit

710− if isCommit graphExpr then do

711− case transactionForId (Sess.parentId session) oldGraph of

712− Left err -> pure $ Left err

713− Right previousTrans -> do

714− (evaldNots, nodes) <- executeCommitExprSTM_ (Trans.concreteDatabaseContext previousTrans) (Sess.concreteDatabaseContext session) clientNodes

715− nodesToNotify <- toList (StmSet.stream nodes)

716− pure $ Right (evaldNots, nodesToNotify, newGraph)

717− else

718− pure $ Right (M.empty, [], newGraph)

719− case manip of

720− Left err -> return $ Just err

721− Right (notsToFire, nodesToNotify, newGraph) -> do

722− --update filesystem database, if necessary

723− processTransactionGraphPersistence strat newGraph

724− sendNotifications nodesToNotify (ipLocalNode conf) notsToFire

725− pure Nothing

726−-}

658+

727659executeGraphExpr sessionId conn@(RemoteConnection _) graphExpr = remoteCall conn (ExecuteGraphExpr sessionId graphExpr)

728660

729661-- | A trans-graph expression is a relational query executed against the entirety of a transaction graph.

@@ -732,9 +664,6 @@ executeTransGraphRelationalExpr _ (InProcessConnection conf) tgraphExpr = excEit

732664 let graphTvar = ipTransactionGraph conf

733665 graph <- readTVar graphTvar

734666 pure $ force $ optimizeAndEvalTransGraphRelationalExpr graph tgraphExpr

735−{- case runReader (RE.evalRelationalExpr relExpr) (RE.mkRelationalExprState DBC.empty) of

736− Left err -> pure (Left err)

737− Right rel -> pure (force (Right rel))-}

738667executeTransGraphRelationalExpr sessionId conn@(RemoteConnection _) tgraphExpr = remoteCall conn (ExecuteTransGraphRelationalExpr sessionId tgraphExpr)

739668

740669-- | Schema expressions manipulate the isomorphic schemas for the current 'DatabaseContext'.

@@ -767,8 +696,10 @@ commit sessionId conn@(RemoteConnection _) = remoteCall conn (ExecuteGraphExpr s

767696

768697sendNotifications :: [ClientInfo] -> EvaluatedNotifications -> IO ()

769698sendNotifications clients notifs =

770− unless (M.null notifs) $

771− forM_ (map clientSocket clients) $ \sock -> RPC.sendMessage sock (NotificationMessage 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

772703

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

774705rollback :: SessionId -> Connection -> IO (Either RelationalError ())

@@ -1070,13 +1001,6 @@ commitLock_ sessionId conf stmBlock = do

10701001 processTransactionGraphPersistence strat transactionIdsToPersist newGraph

10711002 sendNotifications nodesToNotify notsToFire

10721003 pure (Right ())

1073−{-

1074−writeDisconAndGraph_ :: TVar TransactionGraph -> SessionId -> Session -> Sessions -> DisconnectedTransaction -> TransactionGraph -> STM ()

1075−writeDisconAndGraph_ graphTvar sessionId session sessions discon graph = do

1076− writeTVar graphTvar graph

1077− let newSession = Session discon (Sess.schemaName session)

1078− StmMap.insert newSession sessionId sessions

1079−-}

10801004

10811005-- | Runs an IO monad, commits the result when the monad returns no errors, otherwise, rolls back the changes and the error.

10821006withTransaction :: SessionId -> Connection -> IO (Either RelationalError a) -> IO (Either RelationalError ()) -> IO (Either RelationalError a)

@@ -1143,3 +1067,29 @@ validateMerkleHashes sessionId (InProcessConnection conf) = do

11431067 Left merkleErrs -> pure $ Left $ someErrors (map (\(MerkleValidationError tid expected actual) -> MerkleHashValidationError tid expected actual) merkleErrs)

11441068 Right () -> pure (Right ())

11451069validateMerkleHashes sessionId conn@RemoteConnection{} = remoteCall conn (ExecuteValidateMerkleHashes sessionId)

1070+

1071+type ClientNodes = StmSet.Set ClientInfo

1072+

1073+-- internal structure specific to in-process connections

1074+data InProcessConnectionConf = InProcessConnectionConf {

1075+ ipPersistenceStrategy :: PersistenceStrategy,

1076+ ipClientNodes :: ClientNodes,

1077+ ipSessions :: Sessions,

1078+ ipTransactionGraph :: TVar TransactionGraph,

1079+ ipScriptSession :: Maybe ScriptSession,

1080+ ipLocks :: Maybe (LockFile, MVar LockFileHash), -- nothing when NoPersistence

1081+ ipCallbackAsync :: Async ()

1082+ }

1083+

1084+-- clients may connect associate one socket/mvar with the server to register for change callbacks

1085+data ClientInfo = RemoteClientInfo (RPC.Locking Socket) |

1086+ InProcessClientInfo (MVar EvaluatedNotifications)

1087+

1088+instance Eq ClientInfo where

1089+ (RemoteClientInfo a) == (RemoteClientInfo b) = RPC.lockless a == RPC.lockless b

1090+ (InProcessClientInfo a) == (InProcessClientInfo b) = a == b

1091+ _ == _ = False

1092+

1093+instance Hashable ClientInfo where

1094+ hashWithSalt salt (RemoteClientInfo sock) = hashWithSalt salt (show (RPC.lockless sock))

1095+ hashWithSalt salt (InProcessClientInfo _) = hashWithSalt salt (1::Int)

src/lib/ProjectM36/DataFrame.hs+6−6

@@ -2,7 +2,7 @@

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

5+import ProjectM36.Attribute as A hiding (drop)

66import ProjectM36.Error

77import qualified ProjectM36.Relation as R

88import ProjectM36.Relation.Show.Term

@@ -81,7 +81,7 @@ compareTupleByOneAttributeName attr tuple1 tuple2 =

8181 Right atom2 -> compareAtoms atom1 atom2

8282

8383atomForAttributeName :: AttributeName -> DataFrameTuple -> Either RelationalError Atom

84−atomForAttributeName attrName (DataFrameTuple tupAttrs tupVec) = case V.findIndex (\attr -> attributeName attr == attrName) tupAttrs of

84+atomForAttributeName attrName (DataFrameTuple tupAttrs tupVec) = case V.findIndex (\attr -> attributeName attr == attrName) (attributesVec tupAttrs) of

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

8686 Just index -> case tupVec V.!? index of

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

@@ -134,12 +134,12 @@ data DataFrameExpr = DataFrameExpr {

134134dataFrameAsHTML :: DataFrame -> T.Text

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

136136dataFrameAsHTML df

137− | length (tuples df) == 1 && L.null (attributes df) = style <>

137+ | length (tuples df) == 1 && A.null (attributes df) = style <>

138138 tablestart <>

139139 "<tr><th></th></tr>" <>

140140 "<tr><td></td></tr>" <>

141141 tablefooter <> "</table>"

142− | L.null (tuples df) && L.null (attributes df) = style <>

142+ | L.null (tuples df) && A.null (attributes df) = style <>

143143 tablestart <>

144144 "<tr><th></th></tr>" <>

145145 tablefooter <>

@@ -162,7 +162,7 @@ tuplesAsHTML = foldr folder ""

162162 folder tuple acc = acc <> tupleAsHTML tuple

163163

164164tupleAssocs :: DataFrameTuple -> [(AttributeName, Atom)]

165−tupleAssocs (DataFrameTuple attrVec tupVec) = V.toList $ V.map (first attributeName) (V.zip attrVec tupVec)

165+tupleAssocs (DataFrameTuple attrs tupVec) = V.toList $ V.map (first attributeName) (V.zip (attributesVec attrs) tupVec)

166166

167167

168168tupleAsHTML :: DataFrameTuple -> T.Text

@@ -174,7 +174,7 @@ tupleAsHTML tuple = "<tr>" <> T.concat (L.map tupleFrag (tupleAssocs tuple)) <>

174174 atomAsHTML atom = atomToText atom

175175

176176attributesAsHTML :: Attributes -> [AttributeOrder] -> T.Text

177−attributesAsHTML attrs orders' = "<tr>" <> T.concat (map oneAttrHTML (V.toList attrs)) <> "</tr>"

177+attributesAsHTML attrs orders' = "<tr>" <> T.concat (map oneAttrHTML (A.toList attrs)) <> "</tr>"

178178 where

179179 oneAttrHTML attr = "<th>" <> prettyAttribute attr <> ordering (attributeName attr) <> "</th>"

180180 ordering attrName = " " <> case L.find (\(AttributeOrder nam _) -> nam == attrName) orders' of

src/lib/ProjectM36/DataTypes/Interval.hs+2

@@ -37,6 +37,7 @@ supportsInterval typ = case typ of

3737 BoolAtomType -> False

3838 RelationAtomType _ -> False

3939 ConstructedAtomType _ _ -> False --once we support an interval-style typeclass, we might enable this

40+ RelationalExprAtomType -> False

4041 TypeVariableType _ -> False

4142

4243supportsOrdering :: AtomType -> Bool

@@ -50,6 +51,7 @@ supportsOrdering typ = case typ of

5051 ByteStringAtomType -> False

5152 BoolAtomType -> False

5253 RelationAtomType _ -> False

54+ RelationalExprAtomType -> False

5355 ConstructedAtomType _ _ -> False --once we support an interval-style typeclass, we might enable this

5456 TypeVariableType _ -> False

5557

src/lib/ProjectM36/DataTypes/Primitive.hs+1

@@ -42,3 +42,4 @@ 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,6 +24,7 @@ isSortableAtomType typ = case typ of

2424 DateTimeAtomType -> True

2525 ByteStringAtomType -> False

2626 BoolAtomType -> True

27+ RelationalExprAtomType -> False

2728 RelationAtomType _ -> False

2829 ConstructedAtomType _ _ -> False

2930 TypeVariableType _ -> False

src/lib/ProjectM36/Error.hs+10−2

@@ -81,7 +81,7 @@ data RelationalError = NoSuchAttributeNamesError (S.Set AttributeName)

8181 | RelationValuedAttributesNotSupportedError [AttributeName]

8282 | NotificationNameInUseError NotificationName

8383 | NotificationNameNotInUseError NotificationName

84− | ImportError T.Text -- really? This should be broken out into some other error type- this has nothing to do with relational algebra

84+ | ImportError ImportError'

8585 | ExportError T.Text

8686 | UnhandledExceptionError String

8787 | MergeTransactionError MergeError

@@ -144,4 +144,12 @@ data SchemaError = RelVarReferencesMissing (S.Set RelVarName) |

144144 RelVarInReferencedMoreThanOnce RelVarName |

145145 RelVarOutReferencedMoreThanOnce RelVarName

146146 deriving (Show, Eq, Generic, Typeable, NFData)

147−

147+

148+

149+data ImportError' = InvalidSHA256Error T.Text

150+ | SHA256MismatchError T.Text T.Text

151+ | InvalidFileURIError T.Text

152+ | ImportFileDecodeError T.Text

153+ | ImportFileError T.Text

154+ | ImportDownloadError T.Text

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

src/lib/ProjectM36/InclusionDependency.hs+5−6

@@ -4,17 +4,16 @@ import ProjectM36.Attribute

44import ProjectM36.Error

55import ProjectM36.Relation

66import qualified Data.Map as M

7−import qualified Data.Text as T

98inclusionDependenciesAsRelation :: InclusionDependencies -> Either RelationalError Relation

109inclusionDependenciesAsRelation incDeps =

1110 mkRelationFromList attrs (map incDepAsAtoms (M.toList incDeps))

1211 where

1312 attrs = attributesFromList [Attribute "name" TextAtomType,

14− Attribute "sub" TextAtomType,

15− Attribute "super" TextAtomType

13+ Attribute "sub" RelationalExprAtomType,

14+ Attribute "super" RelationalExprAtomType

1615 ]

1716 incDepAsAtoms (name, InclusionDependency exprA exprB) = [TextAtom name,

18− TextAtom (T.pack (show exprA)),

19− TextAtom (T.pack (show exprB))]

20−

17+ RelationalExprAtom exprA,

18+ RelationalExprAtom exprB]

19+

src/lib/ProjectM36/Relation.hs+17−22

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

99import qualified ProjectM36.Attribute as A

1010import ProjectM36.TupleSet

1111import ProjectM36.Error

12−import ProjectM36.MiscUtils

1312--import qualified Control.Parallel.Strategies as P

1413import qualified ProjectM36.TypeConstructorDef as TCD

1514import qualified ProjectM36.DataConstructorDef as DCD

@@ -17,7 +16,6 @@ import qualified Data.Text as T

1716import Data.Either (isRight)

1817import System.Random.Shuffle

1918import Control.Monad.Random

20−import Data.List (sort)

2119

2220attributes :: Relation -> Attributes

2321attributes (Relation attrs _ ) = attrs

@@ -35,7 +33,7 @@ atomTypeForName :: AttributeName -> Relation -> Either RelationalError AtomType

3533atomTypeForName attrName (Relation attrs _) = A.atomTypeForAttributeName attrName attrs

3634

3735mkRelationFromList :: Attributes -> [[Atom]] -> Either RelationalError Relation

38−mkRelationFromList attrs atomMatrix =

36+mkRelationFromList attrs atomMatrix = do

3937 Relation attrs <$> mkTupleSetFromList attrs atomMatrix

4038

4139emptyRelationWithAttrs :: Attributes -> Relation

@@ -43,11 +41,6 @@ emptyRelationWithAttrs attrs = Relation attrs emptyTupleSet

4341

4442mkRelation :: Attributes -> RelationTupleSet -> Either RelationalError Relation

4543mkRelation 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

5144 --check that all tuples have the same keys

5245 --check that all tuples have keys (1-N) where N is the attribute count

5346 case verifyTupleSet attrs tupleSet of

@@ -93,13 +86,12 @@ union (Relation attrs1 tupSet1) (Relation attrs2 tupSet2) =

9386 else

9487 Right $ Relation attrs1 newtuples

9588 where

96− newtuples = RelationTupleSet $ HS.toList . HS.fromList $ asList tupSet1 ++ map (reorderTuple attrs1) (asList tupSet2)

97−

89+ newtuples = tupleSetUnion attrs1 tupSet1 tupSet2

90+

9891project :: S.Set AttributeName -> Relation -> Either RelationalError Relation

9992project attrNames rel@(Relation _ tupSet) = do

10093 newAttrs <- A.projectionAttributesForNames attrNames (attributes rel)

101− let newAttrNameSet = A.attributeNameSet newAttrs

102− newTupleList = map (tupleProject newAttrNameSet) (asList tupSet)

94+ newTupleList <- mapM (tupleProject newAttrs) (asList tupSet)

10395 pure (Relation newAttrs (RelationTupleSet (HS.toList (HS.fromList newTupleList))))

10496

10597rename :: AttributeName -> AttributeName -> Relation -> Either RelationalError Relation

@@ -154,7 +146,7 @@ group groupAttrNames newAttrName rel = do

154146 groupProjectionAttributes <- A.projectionAttributesForNames groupAttrNames (attributes rel)

155147 let groupAttr = Attribute newAttrName (RelationAtomType groupProjectionAttributes)

156148 matchingRelTuple tupIn = case imageRelationFor tupIn rel of

157− Right rel2 -> RelationTuple (V.singleton groupAttr) (V.singleton (RelationAtom rel2))

149+ Right rel2 -> RelationTuple (A.singleton groupAttr) (V.singleton (RelationAtom rel2))

158150 Left _ -> undefined

159151 mogrifier tupIn = pure (tupleExtend tupIn (matchingRelTuple tupIn))

160152 newAttrs = A.addAttribute groupAttr nonGroupProjectionAttributes

@@ -168,7 +160,8 @@ restrictEq :: RelationTuple -> Relation -> Either RelationalError Relation

168160restrictEq tuple = restrict rfilter

169161 where

170162 rfilter :: RelationTuple -> Either RelationalError Bool

171− rfilter tupleIn = pure (tupleIntersection tuple tupleIn == tuple)

163+ rfilter tupleIn = do

164+ pure (tupleIntersection tuple tupleIn == tuple)

172165

173166-- unwrap relation-valued attribute

174167-- return error if relval attrs and nongroup attrs overlap

@@ -190,13 +183,13 @@ ungroup relvalAttrName rel = case attributesForRelval relvalAttrName rel of

190183tupleUngroup :: AttributeName -> Attributes -> RelationTuple -> Either RelationalError Relation

191184tupleUngroup relvalAttrName newAttrs tuple = do

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

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

200193

201194attributesForRelval :: AttributeName -> Relation -> Either RelationalError Attributes

202195attributesForRelval relvalAttrName (Relation attrs _) = do

@@ -251,7 +244,8 @@ relMap mapper (Relation attrs tupleSet) =

251244

252245relMogrify :: (RelationTuple -> Either RelationalError RelationTuple) -> Attributes -> Relation -> Either RelationalError Relation

253246relMogrify mapper newAttributes (Relation _ tupSet) = do

254− newTuples <- mapM mapper (asList tupSet)

247+ newTuples <- mapM (fmap (reorderTuple newAttributes) . mapper) (asList tupSet)

248+

255249 mkRelationFromTuples newAttributes newTuples

256250

257251relFold :: (RelationTuple -> a -> a) -> a -> Relation -> a

@@ -297,7 +291,8 @@ typesAsRelation types = mkRelationFromTuples attrs tuples

297291 dConsType = RelationAtomType subAttrs

298292 tuples = map mkTypeConsDescription types

299293

300− mkTypeConsDescription (tCons, dConsList) = RelationTuple attrs (V.fromList [TextAtom (TCD.name tCons), mkDataConsRelation dConsList])

294+ mkTypeConsDescription (tCons, dConsList) =

295+ RelationTuple attrs (V.fromList [TextAtom (TCD.name tCons), mkDataConsRelation dConsList])

301296

302297 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

303298 Left err -> error ("mkRelationFromTuples pooped " ++ show err)

src/lib/ProjectM36/Relation/Parse/CSV.hs+7−3

@@ -38,8 +38,7 @@ csvAsRelation attrs tConsMap inString = case APBL.parse (csvWithHeader csvDecode

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− attrNames = V.map A.attributeName attrs

42− attrNameSet = S.fromList (V.toList attrNames)

41+ attrNameSet = A.attributeNameSet attrs

4342 headerSet = S.fromList (V.toList strHeader)

4443 parseAtom attrName aType textIn = case APT.parseOnly (parseCSVAtomP attrName tConsMap aType <* APT.endOfInput) textIn of

4544 Left err -> Left (ParseError (T.pack err))

@@ -47,7 +46,7 @@ csvAsRelation attrs tConsMap inString = case APBL.parse (csvWithHeader csvDecode

4746 makeTupleList :: HM.HashMap AttributeName String -> [Either CsvImportError Atom]

4847 makeTupleList tupMap = V.toList $ V.map (\attr ->

4948 either (Left . AttributeMappingError) Right $

50− parseAtom (A.attributeName attr) (A.atomType attr) (T.pack $ tupMap HM.! A.attributeName attr)) attrs

49+ parseAtom (A.attributeName attr) (A.atomType attr) (T.pack $ tupMap HM.! A.attributeName attr)) (attributesVec attrs)

5150 if attrNameSet == headerSet then do

5251 tupleList <- mapM sequence $ V.toList (V.map makeTupleList strMapRecords)

5352 case mkRelationFromList attrs tupleList of

@@ -83,6 +82,11 @@ parseCSVAtomP _ _ BoolAtomType = do

8382 case readMaybe bString of

8483 Nothing -> fail ("invalid BoolAtom string: " ++ bString)

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

8690parseCSVAtomP attrName tConsMap typ@(ConstructedAtomType _ tvmap)

8791 | isIntervalAtomType typ = do

8892 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

4+import ProjectM36.Attribute as A

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− | V.null attrs =

20+ | A.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) attrs

26− bsAttrNames = V.map (TE.encodeUtf8 . attributeName) attrs

25+ relValAttrs = V.toList $ V.filter (isRelationAtomType . atomType) (attributesVec attrs)

26+ bsAttrNames = V.map (TE.encodeUtf8 . attributeName) (attributesVec 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) (tupleAttributes tuple)

39+ headerOrder (RecordRelationTuple tuple) = V.map (TE.encodeUtf8 . attributeName) (attributesVec (tupleAttributes tuple))

4040

4141newtype RecordAtom = RecordAtom {unAtom :: Atom}

4242

src/lib/ProjectM36/Relation/Show/HTML.hs+2−2

@@ -3,6 +3,7 @@ import ProjectM36.Base

33import ProjectM36.Relation

44import ProjectM36.Tuple

55import ProjectM36.Atom

6+import ProjectM36.Attribute as A

67import ProjectM36.AtomType

78import qualified Data.List as L

89import Data.Text (Text, pack)

@@ -11,10 +12,9 @@ import qualified Data.Text.IO as TIO

1112#if __GLASGOW_HASKELL__ < 804

1213import Data.Monoid

1314#endif

14−import qualified Data.Vector as V

1515

1616attributesAsHTML :: Attributes -> Text

17−attributesAsHTML attrs = "<tr>" <> T.concat (map oneAttrHTML (V.toList attrs)) <> "</tr>"

17+attributesAsHTML attrs = "<tr>" <> T.concat (map oneAttrHTML (A.toList attrs)) <> "</tr>"

1818 where

1919 oneAttrHTML attr = "<th>" <> prettyAttribute attr <> "</th>"

2020

src/lib/ProjectM36/RelationalExpression.hs+148−302

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

11{-# LANGUAGE ScopedTypeVariables #-}

22{-# LANGUAGE FlexibleInstances #-}

33{-# LANGUAGE FlexibleContexts #-}

4+{-# LANGUAGE OverloadedStrings #-}

45module ProjectM36.RelationalExpression where

56import ProjectM36.Relation

67import ProjectM36.Tuple

@@ -40,6 +41,8 @@ import Control.Monad.Reader as R hiding (join)

4041import ProjectM36.NormalizeExpr

4142import ProjectM36.WithNameExpr

4243import Test.QuickCheck

44+import qualified Data.Functor.Foldable as Fold

45+import Control.Applicative

4346#ifdef PM36_HASKELL_SCRIPTING

4447import GHC hiding (getContext)

4548import Control.Exception

@@ -107,11 +110,11 @@ askEnv :: GraphRefRelationalExprM GraphRefRelationalExprEnv

107110askEnv = R.ask

108111

109112mergeTuplesIntoGraphRefRelationalExprEnv :: RelationTuple -> GraphRefRelationalExprEnv -> GraphRefRelationalExprEnv

110−mergeTuplesIntoGraphRefRelationalExprEnv tupIn e =

111− e{ gre_extra = new_elems }

113+mergeTuplesIntoGraphRefRelationalExprEnv tupIn env =

114+ env { gre_extra = new_elems }

112115 where

113116 new_elems = Just (Left newTuple)

114− mergedTupMap = M.union (tupleToMap tupIn) (tupleToMap (envTuple e))

117+ mergedTupMap = M.union (tupleToMap tupIn) (tupleToMap (envTuple env))

115118 newTuple = mkRelationTupleFromMap mergedTupMap

116119

117120mergeAttributesIntoGraphRefRelationalExprEnv :: Attributes -> GraphRefRelationalExprEnv -> GraphRefRelationalExprEnv

@@ -209,166 +212,13 @@ envContext = re_context

209212setEnvContext :: RelationalExprEnv -> DatabaseContext -> RelationalExprEnv

210213setEnvContext e ctx = e { re_context = ctx }

211214

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

366215--helper function to process relation variable creation/assignment

367216setRelVar :: RelVarName -> GraphRefRelationalExpr -> DatabaseContextEvalMonad ()

368217setRelVar relVarName relExpr = do

369218 currentContext <- getStateContext

370− --prevent recursive relvar definition

371− let newRelVars = M.insert relVarName relExpr $ relationVariables currentContext

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

372222 potentialContext = currentContext { relationVariables = newRelVars }

373223 --optimization: if the relexpr is unchanged, skip the update

374224 if M.lookup relVarName (relationVariables currentContext) == Just relExpr then

@@ -381,6 +231,9 @@ setRelVar relVarName relExpr = do

381231 Left err -> dbErr err

382232 Right _ -> putStateContext potentialContext

383233

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+

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

385238deleteRelVar :: RelVarName -> DatabaseContextEvalMonad ()

386239deleteRelVar relVarName = do

@@ -446,20 +299,36 @@ evalGraphRefDatabaseContextExpr (Assign relVarName expr) = do

446299

447300evalGraphRefDatabaseContextExpr (Insert relVarName relExpr) = do

448301 gfExpr <- relVarByName relVarName

449− evalGraphRefDatabaseContextExpr (Assign relVarName

450− (Union

451− gfExpr

452− relExpr))

302+ let optExpr = applyUnionCollapse (Union

303+ relExpr

304+ gfExpr)

305+ evalGraphRefDatabaseContextExpr (Assign relVarName optExpr)

453306

454307evalGraphRefDatabaseContextExpr (Delete relVarName predicate) = do

455308 gfExpr <- relVarByName relVarName

456− setRelVar relVarName (Restrict (NotPredicate predicate) gfExpr)

309+ let optExpr = applyRestrictionCollapse (Restrict (NotPredicate predicate) gfExpr)

310+ setRelVar relVarName optExpr

457311

458312--union of restricted+updated portion and the unrestricted+unupdated portion

459313evalGraphRefDatabaseContextExpr (Update relVarName atomExprMap pred') = do

460314 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

461323 let unrestrictedPortion = Restrict (NotPredicate pred') rvExpr

462− tmpAttr attr = "_tmp_" <> attr --this could certainly be improved to verify that there is no attribute name conflict

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

463332 updateAttr nam atomExpr = Extend (AttributeExtendTupleExpr (tmpAttr nam) atomExpr)

464333 projectAndRename attr expr = Rename (tmpAttr attr) attr (Project (InvertedAttributeNames (S.singleton attr)) expr)

465334 restrictedPortion = Restrict pred' rvExpr

@@ -773,21 +642,9 @@ evalGraphRefDatabaseContextIOExpr (CreateArbitraryRelation relVarName attrExprs

773642 Left err -> pure (Left err)

774643 Right dbstate' -> putDBCIOContext (dbc_context dbstate')

775644

776−{-

777−updateTupleWithAtomExprs :: M.Map AttributeName AtomExpr -> DatabaseContext -> TransactionGraph -> RelationTuple -> Either RelationalError RelationTuple

778−updateTupleWithAtomExprs exprMap context graph tupIn = do

779− --resolve all atom exprs

780− let

781− atomsAssoc <- mapM (\(attrName, atomExpr) -> do

782− let atom = unimplemented

783− --atom <- runReader (evalAtomExpr tupIn atomExpr) (mkRelationalExprState context graph)

784− pure (attrName, atom)

785− ) (M.toList exprMap)

786− pure (updateTupleWithAtoms (M.fromList atomsAssoc) tupIn)

787−-}

788645--run verification on all constraints

789646checkConstraints :: DatabaseContext -> TransactionId -> TransactionGraph -> Either RelationalError ()

790−checkConstraints context transId graph@(TransactionGraph graphHeads transSet) =

647+checkConstraints context transId graph@(TransactionGraph graphHeads transSet) = do

791648 mapM_ (uncurry checkIncDep) (M.toList deps)

792649 where

793650 potentialGraph = TransactionGraph graphHeads (S.insert tempTrans transSet)

@@ -836,15 +693,6 @@ typeForRelationalExpr expr = do

836693 runGf = runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr gfExpr)

837694 lift $ except runGf

838695

839−--returns a database context with all tuples removed

840−--this is useful for type checking and optimization

841−{-

842−contextWithEmptyTupleSets :: DatabaseContext -> DatabaseContext

843−contextWithEmptyTupleSets contextIn = contextIn { relationVariables = relVars }

844− where

845− relVars = M.map (\rel -> ExistingRelation (Relation (attributes rel) emptyTupleSet)) (relationVariables contextIn)

846−-}

847−

848696liftE :: (Monad m) => m (Either a b) -> ExceptT a m b

849697liftE v = do

850698 y <- lift v

@@ -1000,58 +848,6 @@ evalGraphRefAtomExpr tupIn cons@(ConstructedAtomExpr dConsName dConsArgs _) = do

1000848 mapM (evalGraphRefAtomExpr tupIn) dConsArgs

1001849 pure (ConstructedAtom dConsName aType argAtoms)

1002850

1003−{-

1004−evalAtomExpr :: RelationTuple -> AtomExpr -> RelationalExprM Atom

1005−evalAtomExpr tupIn expr =

1006− -}

1007−{-

1008−

1009−evalAtomExpr tupIn (AttributeAtomExpr attrName) = case atomForAttributeName attrName tupIn of

1010− Right atom -> pure (Right atom)

1011− err@(Left (NoSuchAttributeNamesError _)) -> do

1012− rstate <- ask

1013− let stateTup = stateTuple rstate

1014− pure (atomForAttributeName attrName stateTup)

1015− Left err -> pure (Left err)

1016−evalAtomExpr _ (NakedAtomExpr atom) = pure (Right atom)

1017−evalAtomExpr tupIn (FunctionAtomExpr funcName arguments ()) = do

1018− argTypes <- mapM (typeFromAtomExpr (tupleAttributes tupIn)) arguments

1019− context <- fmap stateElemsContext ask

1020− runExceptT $ do

1021− let functions = atomFunctions context

1022− func <- either throwE pure (atomFunctionForName funcName functions)

1023− let expectedArgCount = length (atomFuncType func) - 1

1024− actualArgCount = length argTypes

1025− safeInit [] = [] -- different behavior from normal init

1026− safeInit xs = init xs

1027− if expectedArgCount /= actualArgCount then

1028− throwE (FunctionArgumentCountMismatchError expectedArgCount actualArgCount)

1029− else do

1030− let zippedArgs = zip (safeInit (atomFuncType func)) argTypes

1031− mapM_ (\(expType, eActType) -> do

1032− actType <- either throwE pure eActType

1033− either throwE pure (atomTypeVerify expType actType)) zippedArgs

1034− evaldArgs <- mapM (liftE . evalAtomExpr tupIn) arguments

1035− case evalAtomFunction func evaldArgs of

1036− Left err -> throwE (AtomFunctionUserError err)

1037− Right result -> do

1038− --validate that the result matches the expected type

1039− _ <- either throwE pure (atomTypeVerify (last (atomFuncType func)) (atomTypeForAtom result))

1040− pure result

1041−evalAtomExpr tupIn (RelationAtomExpr relExpr) = do

1042− --merge existing state tuple context into new state tuple context to support an arbitrary number of levels, but new attributes trounce old attributes

1043− rstate <- ask

1044− runExceptT $ do

1045− let newState = mergeTuplesIntoRelationalExprState tupIn rstate

1046− relAtom <- either throwE pure (runReader (evalRelationalExpr relExpr) newState)

1047− pure (RelationAtom relAtom)

1048−evalAtomExpr tupIn cons@(ConstructedAtomExpr dConsName dConsArgs ()) = runExceptT $ do

1049− rstate <- lift ask

1050− let newState = mergeTuplesIntoRelationalExprState tupIn rstate

1051− aType <- either throwE pure (runReader (typeFromAtomExpr (tupleAttributes tupIn) cons) newState)

1052− argAtoms <- mapM (\arg -> either throwE pure (runReader (evalAtomExpr tupIn arg) newState)) dConsArgs

1053− pure (ConstructedAtom dConsName aType argAtoms)

1054−-}

1055851typeForGraphRefAtomExpr :: Attributes -> GraphRefAtomExpr -> GraphRefRelationalExprM AtomType

1056852typeForGraphRefAtomExpr attrs (AttributeAtomExpr attrName) = do

1057853 renv <- askEnv

@@ -1118,7 +914,7 @@ verifyGraphRefAtomExprTypes relIn (FunctionAtomExpr funcName funcArgExprs tid) e

1118914 let handler :: RelationalError -> GraphRefRelationalExprM AtomType

1119915 handler (AtomTypeMismatchError expSubType actSubType) = throwError (AtomFunctionTypeError funcName argCount expSubType actSubType)

1120916 handler err = throwError err

1121− verifyGraphRefAtomExprTypes relIn atomExpr expectedType2 `catchError` handler

917+ verifyGraphRefAtomExprTypes relIn atomExpr expectedType2 `catchError` handler

1122918 funcArgTypes <- mapM funcArgVerifier $ zip3 funcArgExprs expectedArgTypes [1..]

1123919 if length funcArgTypes /= length expectedArgTypes - 1 then

1124920 throwError (AtomTypeCountError funcArgTypes expectedArgTypes)

@@ -1164,7 +960,7 @@ evalGraphRefTupleExprs mAttrs (TupleExprs fixedMarker tupleExprL) = do

1164960 lift $ except $ resolveAttributes accAttr tupAttr

1165961 mostResolvedTypes <-

1166962 foldM (\acc tup -> do

1167− let zipped = zip (V.toList $ tupleAttributes tup) acc

963+ let zipped = zip (V.toList . attributesVec $ tupleAttributes tup) acc

1168964 accNames = S.fromList $ map A.attributeName acc

1169965 tupNames = A.attributeNameSet (tupleAttributes tup)

1170966 attrNamesDiff = S.union (S.difference accNames tupNames) (S.difference tupNames accNames)

@@ -1175,7 +971,7 @@ evalGraphRefTupleExprs mAttrs (TupleExprs fixedMarker tupleExprL) = do

1175971 pure nextTupleAttrs

1176972 else

1177973 throwError (TupleAttributeTypeMismatchError diff)

1178− ) (V.toList $ tupleAttributes headTuple) tailTuples

974+ ) (V.toList . attributesVec $ tupleAttributes headTuple) tailTuples

1179975 pure (A.attributesFromList mostResolvedTypes)

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

1181977 tConsMap <- case singularTransactions tupleExprL of

@@ -1221,56 +1017,6 @@ evalGraphRefTupleExpr mAttrs (TupleExpr tupMap) = do

12211017-- _ <- lift $ except (validateTuple tup' tConss)

12221018 pure tup'

12231019

1224−{-

1225−evalAttributeNames :: AttributeNames -> RelationalExpr -> RelationalExprM (Either RelationalError (S.Set AttributeName))

1226−evalAttributeNames attrNames expr = do

1227− eExprType <- typeForRelationalExpr expr

1228− case eExprType of

1229− Left err -> throwError err

1230− Right exprTyp -> do

1231− let typeNameSet = S.fromList (V.toList (A.attributeNames (attributes exprTyp)))

1232− case attrNames of

1233− AttributeNames names ->

1234− case A.projectionAttributesForNames names (attributes exprTyp) of

1235− Left err -> pure (Left err)

1236− Right attrs -> pure (Right (S.fromList (V.toList (A.attributeNames attrs))))

1237−

1238− InvertedAttributeNames names -> do

1239− let nonExistentAttributeNames = A.attributeNamesNotContained names typeNameSet

1240− if not (S.null nonExistentAttributeNames) then

1241− pure (Left (AttributeNamesMismatchError nonExistentAttributeNames))

1242− else

1243− pure (Right (A.nonMatchingAttributeNameSet names typeNameSet))

1244−

1245− UnionAttributeNames namesA namesB -> do

1246− eNameSetA <- evalAttributeNames namesA expr

1247− case eNameSetA of

1248− Left err -> pure (Left err)

1249− Right nameSetA -> do

1250− eNameSetB <- evalAttributeNames namesB expr

1251− case eNameSetB of

1252− Left err -> pure (Left err)

1253− Right nameSetB ->

1254− pure (Right (S.union nameSetA nameSetB))

1255−

1256− IntersectAttributeNames namesA namesB -> do

1257− eNameSetA <- evalAttributeNames namesA expr

1258− case eNameSetA of

1259− Left err -> pure (Left err)

1260− Right nameSetA -> do

1261− eNameSetB <- evalAttributeNames namesB expr

1262− case eNameSetB of

1263− Left err -> pure (Left err)

1264− Right nameSetB ->

1265− pure (Right (S.intersection nameSetA nameSetB))

1266−

1267− RelationalExprAttributeNames attrExpr -> do

1268− eAttrExprType <- typeForRelationalExpr attrExpr

1269− case eAttrExprType of

1270− Left err -> pure (Left err)

1271− Right attrExprType -> pure (Right (A.attributeNameSet (attributes attrExprType)))

1272−-}

1273−

12741020--temporary implementation until we have a proper planner+executor

12751021evalGraphRefRelationalExpr :: GraphRefRelationalExpr -> GraphRefRelationalExprM Relation

12761022evalGraphRefRelationalExpr (MakeRelationFromExprs mAttrExprs tupleExprs) = do

@@ -1499,7 +1245,7 @@ relationVariablesAsRelation ctx graph = do

14991245 let gfEnv = freshGraphRefRelationalExprEnv (Just ctx) graph

15001246 gfType <- runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr gfExpr)

15011247 pure (rvName, gfType)

1502− relVarToAtomList (rvName, rel) = [TextAtom rvName, attributesToRel (attributes rel)]

1248+ relVarToAtomList (rvName, rel) = [TextAtom rvName, attributesToRel (attributesVec (attributes rel))]

15031249 attrAtoms a = [TextAtom (A.attributeName a), TextAtom (prettyAtomType (A.atomType a))]

15041250 attributesToRel attrl = case mkRelationFromList subrelAttrs (map attrAtoms (V.toList attrl)) of

15051251 Left err -> error ("relationVariablesAsRelation pooped " ++ show err)

@@ -1519,15 +1265,6 @@ evalRelationalExpr expr = do

15191265 Left err -> throwError err

15201266 Right rel -> pure rel

15211267

1522−{-

1523−relVarByName :: RelVarName -> GraphRefRelationalExprM GraphRefRelationalExpr

1524−relVarByName = do

1525− relvars <- relationVariables <$> getStateContext

1526− case M.lookup relVarName relvars of

1527− Nothing -> dbErr (RelVarNotDefinedError relVarName)

1528− Just gfexpr -> pure gfExpr

1529−-}

1530−

15311268class (MonadError RelationalError m, Monad m) => DatabaseContextM m where

15321269 getContext :: m DatabaseContext

15331270

@@ -1544,3 +1281,112 @@ relVarByName rvName = do

15441281 Nothing -> throwError (RelVarNotDefinedError rvName)

15451282 Just gfexpr -> pure gfexpr

15461283

1284+-- | resolve UncommittedTransactionMarker whenever possible- this is important in the DatabaseContext in order to mitigate self-referencing loops for updates

1285+class ResolveGraphRefTransactionMarker a where

1286+ resolve :: a -> DatabaseContextEvalMonad a

1287+

1288+-- s := s union t

1289+instance ResolveGraphRefTransactionMarker GraphRefRelationalExpr where

1290+ resolve (MakeRelationFromExprs mAttrs tupleExprs) =

1291+ MakeRelationFromExprs mAttrs <$> resolve tupleExprs

1292+ resolve orig@MakeStaticRelation{} = pure orig

1293+ resolve orig@ExistingRelation{} = pure orig

1294+ resolve orig@(RelationVariable rvName UncommittedContextMarker) = do

1295+ rvMap <- relationVariables <$> getStateContext

1296+ case M.lookup rvName rvMap of

1297+ Nothing -> pure orig

1298+ Just resolvedRv -> resolve resolvedRv

1299+ resolve orig@RelationVariable{} = pure orig

1300+ resolve (Project attrNames relExpr) = Project <$> resolve attrNames <*> resolve relExpr

1301+ resolve (Union exprA exprB) = Union <$> resolve exprA <*> resolve exprB

1302+ resolve (Join exprA exprB) = Join <$> resolve exprA <*> resolve exprB

1303+ resolve (Rename attrA attrB expr) = Rename attrA attrB <$> resolve expr

1304+ resolve (Difference exprA exprB) = Difference <$> resolve exprA <*> resolve exprB

1305+ resolve (Group namesA nameB expr) = Group <$> resolve namesA <*> pure nameB <*> resolve expr

1306+ resolve (Ungroup nameA expr) = Ungroup nameA <$> resolve expr

1307+ resolve (Restrict restrictExpr relExpr) = Restrict <$> resolve restrictExpr <*> resolve relExpr

1308+ resolve (Equals exprA exprB) = Equals <$> resolve exprA <*> resolve exprB

1309+ resolve (NotEquals exprA exprB) = NotEquals <$> resolve exprA <*> resolve exprB

1310+ resolve (Extend extendExpr relExpr) = Extend <$> resolve extendExpr <*> resolve relExpr

1311+ resolve (With withExprs relExpr) = With <$> mapM (\(nam, expr) -> (,) <$> resolve nam <*> resolve expr) withExprs <*> resolve relExpr

1312+

1313+instance ResolveGraphRefTransactionMarker GraphRefTupleExprs where

1314+ resolve (TupleExprs marker tupleExprs) =

1315+ TupleExprs marker <$> mapM resolve tupleExprs

1316+

1317+instance ResolveGraphRefTransactionMarker GraphRefTupleExpr where

1318+ resolve (TupleExpr tupMap) = do

1319+ tupMap' <- mapM (\(attrName, expr) -> (,) attrName <$> resolve expr ) (M.toList tupMap)

1320+ pure (TupleExpr (M.fromList tupMap'))

1321+

1322+instance ResolveGraphRefTransactionMarker GraphRefAttributeNames where

1323+ resolve orig@AttributeNames{} = pure orig

1324+ resolve orig@InvertedAttributeNames{} = pure orig

1325+ resolve (UnionAttributeNames namesA namesB) = UnionAttributeNames <$> resolve namesA <*> resolve namesB

1326+ resolve (IntersectAttributeNames namesA namesB) = IntersectAttributeNames <$> resolve namesA <*> resolve namesB

1327+ resolve (RelationalExprAttributeNames expr) = RelationalExprAttributeNames <$> resolve expr

1328+

1329+instance ResolveGraphRefTransactionMarker GraphRefRestrictionPredicateExpr where

1330+ resolve TruePredicate = pure TruePredicate

1331+ resolve (AndPredicate exprA exprB) = AndPredicate <$> resolve exprA <*> resolve exprB

1332+ resolve (OrPredicate exprA exprB) = OrPredicate <$> resolve exprA <*> resolve exprB

1333+ resolve (NotPredicate expr) = NotPredicate <$> resolve expr

1334+ resolve (RelationalExprPredicate expr) = RelationalExprPredicate <$> resolve expr

1335+ resolve (AtomExprPredicate expr) = AtomExprPredicate <$> resolve expr

1336+ resolve (AttributeEqualityPredicate nam expr)= AttributeEqualityPredicate nam <$> resolve expr

1337+

1338+instance ResolveGraphRefTransactionMarker GraphRefExtendTupleExpr where

1339+ resolve (AttributeExtendTupleExpr nam atomExpr) = AttributeExtendTupleExpr nam <$> resolve atomExpr

1340+

1341+instance ResolveGraphRefTransactionMarker GraphRefWithNameExpr where

1342+ resolve orig@WithNameExpr{} = pure orig -- match uncommitted marker?

1343+

1344+instance ResolveGraphRefTransactionMarker GraphRefAtomExpr where

1345+ resolve orig@AttributeAtomExpr{} = pure orig

1346+ resolve orig@NakedAtomExpr{} = pure orig

1347+ resolve (FunctionAtomExpr nam atomExprs marker) =

1348+ FunctionAtomExpr nam <$> mapM resolve atomExprs <*> pure marker

1349+ resolve (RelationAtomExpr expr) = RelationAtomExpr <$> resolve expr

1350+ resolve (ConstructedAtomExpr dConsName atomExprs marker) =

1351+ ConstructedAtomExpr dConsName <$> mapM resolve atomExprs <*> pure marker

1352+

1353+--convert series of simple Union queries into MakeStaticRelation

1354+-- this is especially useful for long, nested applications of Union with simple tuples

1355+-- Union (MakeRelation x y) (MakeRelation x y') -> MakeRelation x (y + y')

1356+

1357+--MakeRelationFromExprs Nothing (TupleExprs UncommittedContextMarker [TupleExpr (fromList [("name", NakedAtomExpr (TextAtom "steve"))])])

1358+

1359+applyUnionCollapse :: GraphRefRelationalExpr -> GraphRefRelationalExpr

1360+applyUnionCollapse = Fold.cata opt

1361+ where

1362+ opt :: RelationalExprBaseF GraphRefTransactionMarker GraphRefRelationalExpr -> GraphRefRelationalExpr

1363+ opt (UnionF exprA exprB) | exprA == exprB = exprA

1364+ opt (UnionF

1365+ exprA@(MakeRelationFromExprs mAttrs1 tupExprs1)

1366+ exprB@(MakeRelationFromExprs mAttrs2 tupExprs2)) | tupExprs1 == tupExprs2 = MakeRelationFromExprs (mAttrs1 <|> mAttrs2) tupExprs1

1367+ | tupExprsNull tupExprs1 = exprB

1368+ | tupExprsNull tupExprs2 = exprA

1369+ opt x = Fold.embed x

1370+ tupExprsNull (TupleExprs _ []) = True

1371+ tupExprsNull _ = False

1372+

1373+

1374+--UPDATE optimization- find matching where clause in "lower" levels of renaming

1375+--update x where y=1 set (x:=5,z:=10); update x where y=1 set(x:=6,z:=11)

1376+-- =>

1377+-- update x where y=1 set (x:=6,z:=11)

1378+-- future opt: match individual attributes update x where y=1 set (x:=5); update x where y=1 set (z:=11) => update x where y=1 set (x:=5,z:=11)

1379+

1380+--strategy: try to collapse the top-level update (union (restrict pred MakeRelationFromExpr) expr) if it contains the same predicate and resultant relation

1381+

1382+--DELETE optimization

1383+-- if a restriction matches a previous restriction, combine them

1384+-- O(1) since it only scans at the top level, critical in benchmarks generating redundant deletions

1385+applyRestrictionCollapse :: GraphRefRelationalExpr -> GraphRefRelationalExpr

1386+applyRestrictionCollapse orig@(Restrict npred@(NotPredicate _) expr) =

1387+ case expr of

1388+ orig'@(Restrict npred'@(NotPredicate _) _) | npred == npred' -> orig'

1389+ _ -> orig

1390+applyRestrictionCollapse expr = expr

1391+

1392+

src/lib/ProjectM36/ScriptSession.hs−2

@@ -128,8 +128,6 @@ initScriptSession ghcPkgPaths = do

128128 "uuid",

129129 "vector",

130130 "text",

131− "binary",

132− "vector-binary-instances",

133131 "time",

134132 "project-m36",

135133 "bytestring"]

src/lib/ProjectM36/Serialise/Base.hs+10−1

@@ -10,6 +10,7 @@ import ProjectM36.MerkleHash

1010import Data.UUID

1111import Data.Proxy

1212import Data.Word

13+import ProjectM36.Attribute as A

1314import qualified Data.List.NonEmpty as NE

1415import qualified Data.Vector as V

1516import Data.Time.Calendar (Day,toGregorian,fromGregorian)

@@ -72,5 +73,13 @@ instance Serialise Day where

7273 extractor = fromGregorianTup <$> extractor

7374 decodeCurrent = fromGregorianTup <$> decodeCurrent

7475

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

7581

76−

82+ decodeCurrent = do

83+ n <- decodeVarInt

84+ l <- replicateM n decodeCurrent

85+ pure (A.attributesFromList l)

src/lib/ProjectM36/Serialise/Error.hs+1

@@ -12,3 +12,4 @@ deriving via WineryVariant MergeError instance Serialise MergeError

1212deriving via WineryVariant ScriptCompilationError instance Serialise ScriptCompilationError

1313deriving via WineryVariant PersistenceError instance Serialise PersistenceError

1414deriving via WineryVariant SchemaError instance Serialise SchemaError

15+deriving via WineryVariant ImportError' instance Serialise ImportError'

src/lib/ProjectM36/Server.hs+1−1

@@ -24,7 +24,7 @@ requestHandlers testFlag ti =

2424 RequestHandler (\sState (Login dbName) -> do

2525 addClientLogin dbName sState

2626 conn <- getConn sState

27− handleLogin dbName conn (connectionSocket sState)),

27+ handleLogin conn (connectionSocket sState)),

2828 RequestHandler (\sState Logout -> do

2929 conn <- getConn sState

3030 handleLogout ti conn),

src/lib/ProjectM36/Server/Config.hs+6

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

1521defaultServerConfig :: ServerConfig

1622defaultServerConfig = ServerConfig { persistenceStrategy = NoPersistence,

1723 checkFS = True,

src/lib/ProjectM36/Server/EntryPoints.hs+11−7

@@ -5,8 +5,8 @@ import ProjectM36.IsomorphicSchema

55import ProjectM36.Client as C

66import Data.Map

77import Control.Concurrent (threadDelay)

8−import Network.RPC.Curryer.Server

9−import System.Timeout

8+import Network.RPC.Curryer.Server

9+import System.Timeout hiding (Timeout)

1010import Network.Socket

1111import Control.Exception

1212

@@ -45,9 +45,9 @@ handleExecuteHeadName :: Maybe Timeout -> SessionId -> Connection -> IO (Either

4545handleExecuteHeadName ti sessionId conn =

4646 timeoutRelErr ti (headName sessionId conn)

4747

48−handleLogin :: DatabaseName -> Connection -> Locking Socket -> IO Bool

49−handleLogin dbName conn lockSock = do

50− addClientNode dbName conn lockSock

48+handleLogin :: Connection -> Locking Socket -> IO Bool

49+handleLogin conn lockSock = do

50+ addClientNode conn lockSock

5151 pure True

5252

5353handleExecuteGraphExpr :: Maybe Timeout -> SessionId -> Connection -> TransactionGraphOperator -> IO (Either RelationalError ())

@@ -122,8 +122,12 @@ handleLogout _ _ =

122122

123123handleTestTimeout :: Maybe Timeout -> SessionId -> Connection -> IO Bool

124124handleTestTimeout ti _ _ = do

125− _ <- timeoutOrDie ti (threadDelay 100000 >> pure True)

126− pure True

125+ ret <- timeoutRelErr ti (threadDelay 100000 >> pure (Right ()))

126+ case ret of

127+ Right () -> pure True

128+ Left _ -> pure False

129+

130+

127131

128132handleRetrieveSessionIsDirty :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Bool)

129133handleRetrieveSessionIsDirty ti sessionId conn =

src/lib/ProjectM36/Server/ParseArgs.hs+31−14

@@ -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,43 +34,60 @@ 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−

52+

5353parsePort :: 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")

7491

7592helpOption :: Parser (a -> a)

7693helpOption = abortOption helpText $ mconcat

@@ -80,6 +97,6 @@ helpOption = abortOption helpText $ mconcat

8097 where

8198#if MIN_VERSION_optparse_applicative(0,16,0)

8299 helpText = ShowHelpText Nothing

83−#else

100+#else

84101 helpText = ShowHelpText

85102#endif

src/lib/ProjectM36/Server/RemoteCallTypes.hs−1

@@ -8,7 +8,6 @@ import ProjectM36.TransGraphRelationalExpression

88import ProjectM36.Session

99import ProjectM36.Serialise.DataFrame ()

1010import ProjectM36.Serialise.IsomorphicSchema ()

11−import ProjectM36.Server.Types

1211import GHC.Generics

1312import Codec.Winery

1413

src/lib/ProjectM36/Server/Types.hsdeleted−38

@@ -1,38 +0,0 @@

1−--types shared across server and client modules

2−module ProjectM36.Server.Types where

3−import StmContainers.Set as StmSet

4−import ProjectM36.Base

5−import Data.Hashable

6−import ProjectM36.Sessions

7−import Control.Concurrent.STM

8−import ProjectM36.ScriptSession

9−import ProjectM36.FileLock

10−import Control.Concurrent.MVar

11−import ProjectM36.TransactionGraph.Persist

12−import Network.RPC.Curryer.Server as RPC

13−import Network.Socket

14−

15−-- | The 'Connection' represents either local or remote access to a database. All operations flow through the connection.

16−type ClientNodes = StmSet.Set ClientInfo

17−

18−type DatabaseName = String

19−

20−-- internal structure specific to in-process connections

21−data InProcessConnectionConf = InProcessConnectionConf {

22− ipPersistenceStrategy :: PersistenceStrategy,

23− ipClientNodes :: ClientNodes,

24− ipSessions :: Sessions,

25− ipTransactionGraph :: TVar TransactionGraph,

26− ipScriptSession :: Maybe ScriptSession,

27− ipLocks :: Maybe (LockFile, MVar LockFileHash) -- nothing when NoPersistence

28− }

29−

30−-- clients may connect associate one socket with one database

31−data ClientInfo = ClientInfo { clientDatabaseName :: DatabaseName,

32− clientSocket :: RPC.Locking Socket }

33−

34−instance Eq ClientInfo where

35− a == b = RPC.lockless (clientSocket a) == RPC.lockless (clientSocket b)

36−

37−instance Hashable ClientInfo where

38− hashWithSalt salt ci = hashWithSalt salt (show (RPC.lockless (clientSocket ci)))

src/lib/ProjectM36/Shortcuts.hsnew file+247

@@ -0,0 +1,247 @@

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

2+{-# LANGUAGE ScopedTypeVariables #-}

3+{-# LANGUAGE TypeApplications #-}

4+{-# LANGUAGE FlexibleInstances #-}

5+{-# LANGUAGE MultiParamTypeClasses #-}

6+{-# LANGUAGE TypeFamilies #-}

7+{-# LANGUAGE ExtendedDefaultRules #-}

8+{-# LANGUAGE ExistentialQuantification #-}

9+{-# LANGUAGE FlexibleContexts #-}

10+{-# LANGUAGE GADTs #-}

11+{-# LANGUAGE UndecidableInstances #-}

12+module ProjectM36.Shortcuts where

13+-- users need OverloadedLabels, OverloadedLists, and default(Int,Text) to use these shortcuts.

14+import Data.Text hiding (foldl, map)

15+import ProjectM36.Base

16+import ProjectM36.Relation

17+import ProjectM36.Atomable

18+import Prelude hiding ((!!))

19+import Data.Proxy

20+import GHC.OverloadedLabels

21+import GHC.TypeLits hiding (Text)

22+import qualified Data.Text as T

23+import qualified Data.Map as M

24+import qualified Data.Set as S

25+import GHC.Exts (IsList(..))

26+import Data.Convertible

27+

28+default (Text)

29+

30+instance IsList (AttributeNamesBase ()) where

31+ type Item (AttributeNamesBase ()) = AttributeName

32+ fromList = AttributeNames . S.fromList

33+ toList (AttributeNames ns) = S.toList ns

34+ toList _ = error "needs AttributeNames"

35+

36+instance IsList (TupleExprsBase ()) where

37+ type Item TupleExprs = TupleExpr

38+ fromList ts = TupleExprs () ts

39+ toList (TupleExprs _ ts) = ts

40+

41+instance IsList TupleExpr where

42+ type Item TupleExpr = (AttributeName, AtomExpr)

43+ fromList attributeValues = TupleExpr (M.fromList attributeValues)

44+ toList (TupleExpr attributeValues) = M.toList attributeValues

45+

46+

47+-- #xxx :: Text

48+instance KnownSymbol x => IsLabel x Text where

49+ fromLabel = T.pack $ symbolVal @x Proxy

50+

51+-- #relvarName :: RelationalExpr

52+instance KnownSymbol x => IsLabel x RelationalExpr where

53+ fromLabel = RelationVariable (T.pack $ symbolVal @x Proxy) ()

54+

55+-- *Main> #a Int :: AttributeExpr

56+-- NakedAttributeExpr (Attribute "a" IntAtomType)

57+-- *Main> #a (Attr @[Int]) :: AttributeExpr

58+-- NakedAttributeExpr (Attribute "a" (ConstructedAtomType "List" (fromList [("a",IntAtomType)])))

59+-- can't offer a Relation atomtype -- don't know how to express a Relation type in haskell type. Maybe something a HList of (Text, a) ?

60+--

61+-- ps. I don't understand the usage of "AttributeAndTypeNameExpr AttributeName TypeConstructor a"

62+instance (KnownSymbol x, Atomable a)=> IsLabel x (HaskAtomType a -> AttributeExpr) where

63+ fromLabel = (NakedAttributeExpr . Attribute name) . toAtomType''

64+ where name = T.pack $ symbolVal @x Proxy

65+

66+-- (#a 1) :: ExtendTupleExpr

67+-- no need for :=

68+instance (Convertible a AtomExpr, KnownSymbol x) => IsLabel x (a -> ExtendTupleExpr) where

69+ fromLabel x = AttributeExtendTupleExpr name (convert x)

70+ where name = T.pack $ symbolVal @x Proxy

71+

72+-- #name AtomExpr

73+-- ex. tuple [ #name 3 ]

74+-- default(Text) is needed in client code to avoid `no Atomable Char`

75+instance (Convertible a AtomExpr, KnownSymbol x) => IsLabel x (a -> (AttributeName, AtomExpr)) where

76+ fromLabel = \x -> (name, convert x)

77+ where name = T.pack $ symbolVal @x Proxy

78+

79+-- *Main> #a [1] :: AtomExpr

80+-- FunctionAtomExpr "a" [NakedAtomExpr (IntegerAtom 1)] ()

81+--

82+-- This usage is not working in RestrictionPredicateExpr and AttributeExtendTupleExpr. Use f "a" [1] instead.

83+instance (KnownSymbol x, Convertible a AtomExpr) => IsLabel x ([a] -> AtomExpr) where

84+ fromLabel = \as' -> FunctionAtomExpr name (map convert as') ()

85+ where name = T.pack $ symbolVal @x Proxy

86+

87+instance (KnownSymbol x) => IsLabel x AtomExpr where

88+ fromLabel = AttributeAtomExpr name

89+ where name = T.pack $ symbolVal @x Proxy

90+

91+

92+data HaskAtomType a where

93+ Int :: HaskAtomType Int

94+ Integer :: HaskAtomType Integer

95+ Double :: HaskAtomType Double

96+ Text :: HaskAtomType Text

97+-- Day :: HaskAtomType Day

98+-- DateTime :: HaskAtomType DateTime

99+-- ByteString :: HaskAtomType ByteString

100+ Bool :: HaskAtomType Bool

101+ Attr :: Atomable a => HaskAtomType a -- a Proxy-like value for type application.

102+

103+toAtomType'' :: Atomable a => HaskAtomType a -> AtomType

104+toAtomType'' (_ :: HaskAtomType a) = toAtomType (Proxy @a)

105+

106+-- usage: relation [tuple [#a 1, #b "b"], tuple [#a 2, #b "b"]]

107+relation :: [TupleExpr] -> RelationalExpr

108+relation ts = MakeRelationFromExprs Nothing (TupleExprs () ts)

109+

110+relation' :: [AttributeExprBase ()] -> [TupleExpr] -> RelationalExpr

111+relation' as' ts = MakeRelationFromExprs (Just as') (TupleExprs () ts)

112+

113+-- usage: tuple [#name "Mike",#age 6]

114+tuple :: [(AttributeName, AtomExpr)] -> TupleExprBase ()

115+tuple as' = TupleExpr (M.fromList as')

116+

117+-- #a rename [#b `as` #c]

118+rename :: RelationalExpr -> [(AttributeName,AttributeName)] -> RelationalExpr

119+rename relExpr renameList = case renameList of

120+ [] -> Restrict TruePredicate relExpr

121+ renames ->

122+ foldl (\acc (old,new) -> Rename old new acc) relExpr renames

123+

124+--project !!

125+-- #a !! [#b,#c]

126+infix 9 !!

127+(!!) :: RelationalExpr -> AttributeNames -> RelationalExpr

128+relExpr !! xs = Project xs relExpr

129+

130+--join ><

131+-- #a >< #b

132+(><) :: RelationalExpr -> RelationalExpr -> RelationalExpr

133+a >< b = Join a b

134+

135+allBut :: AttributeNames -> AttributeNames

136+allBut (AttributeNames ns) = InvertedAttributeNames ns

137+allBut _ = error "give allBut something other than attribute names."

138+

139+allFrom :: RelationalExpr -> AttributeNames

140+allFrom = RelationalExprAttributeNames

141+

142+as :: AttributeNames -> AttributeName -> (AttributeNames, AttributeName)

143+as = (,)

144+

145+-- #a `group` ([#b,#c] `as` #d)

146+group :: RelationalExpr -> (AttributeNames, AttributeName) -> RelationalExpr

147+group relExpr (aNames, aName) = Group aNames aName relExpr

148+

149+-- #a `ungroup` #b

150+ungroup :: RelationalExpr -> AttributeName -> RelationalExpr

151+ungroup relExpr aName = Ungroup aName relExpr

152+

153+-- *Main> #a #:= true #: ( #b (f "count" [1,2]))

154+-- Assign "a" (Extend (AttributeExtendTupleExpr "b" (FunctionAtomExpr "count" [NakedAtomExpr (IntegerAtom 1),NakedAtomExpr (IntegerAtom 2)] ())) (ExistingRelation (Relation attributesFromList [] (RelationTupleSet {asList = [RelationTuple attributesFromList [] []]}))))

155+(#:) :: RelationalExpr -> ExtendTupleExpr -> RelationalExpr

156+a #: b = Extend b a

157+infix 8 #:

158+

159+instance Convertible AtomExpr AtomExpr where

160+ safeConvert n = Right n

161+

162+instance Convertible RelVarName AtomExpr where

163+ safeConvert n = Right $ RelationAtomExpr (RelationVariable n ())

164+

165+instance Convertible RelationalExpr AtomExpr where

166+ safeConvert relExpr = Right $ RelationAtomExpr relExpr

167+

168+instance Convertible RelVarName RelationalExpr where

169+ safeConvert n = Right $ RelationVariable n ()

170+

171+-- @ in tutd

172+-- (@@) "aaa"

173+(@@) :: AttributeName -> AtomExpr

174+(@@) = AttributeAtomExpr

175+

176+-- works in RestrictedPredicateExpr and AttributeExtendTupleExpr

177+-- usage: f "gte" [1]

178+f :: Convertible a AtomExpr => AtomFunctionName -> [a] -> AtomExpr

179+f n as' = FunctionAtomExpr n (map convert as') ()

180+

181+-- DatabaseContextExpr

182+-- define

183+(#::) :: RelVarName -> [AttributeExpr] -> DatabaseContextExpr

184+s #:: xs = Define s xs

185+infix 5 #::

186+

187+-- assign

188+(#:=) :: RelVarName -> RelationalExpr -> DatabaseContextExpr

189+s #:= r = Assign s r

190+infix 5 #:=

191+

192+class Boolean a b where

193+ (&&&) :: a -> b -> RestrictionPredicateExpr

194+ infixl 6 &&&

195+ (|||) :: a -> b -> RestrictionPredicateExpr

196+ infixl 5 |||

197+

198+-- where: @~ mimics the restriction symbol in algebra

199+-- usage: true #: (#a 1) @~ #a ?= 1 &&& not' false ||| (f "gte" [1])

200+(@~) :: Convertible a RestrictionPredicateExpr => RelationalExpr -> a -> RelationalExpr

201+(@~) relExpr resPreExpr = Restrict (convert resPreExpr) relExpr

202+infix 4 @~

203+

204+true :: RelationalExpr

205+true = ExistingRelation relationTrue

206+

207+false :: RelationalExpr

208+false = ExistingRelation relationFalse

209+

210+trueP :: RestrictionPredicateExprBase a

211+trueP = TruePredicate

212+

213+falseP :: RestrictionPredicateExprBase a

214+falseP = NotPredicate TruePredicate

215+

216+(?=) :: Convertible a AtomExpr => AttributeName -> a -> RestrictionPredicateExpr

217+(?=) name a = AttributeEqualityPredicate name (convert a)

218+infix 9 ?=

219+

220+not' :: Convertible a RestrictionPredicateExpr => a -> RestrictionPredicateExpr

221+not' = NotPredicate . convert

222+

223+instance (Convertible a RestrictionPredicateExpr, Convertible b RestrictionPredicateExpr) => Boolean a b where

224+ a &&& b = AndPredicate (convert a) (convert b)

225+ a ||| b = OrPredicate (convert a) (convert b)

226+

227+instance {-# Incoherent #-} Atomable a => Convertible a RestrictionPredicateExpr where

228+ safeConvert n = Right $ AtomExprPredicate $ toAtomExpr . toAtom $ n

229+

230+instance {-# Incoherent #-} Convertible RelationalExpr RestrictionPredicateExpr where

231+ safeConvert a = Right $ RelationalExprPredicate a

232+

233+instance {-# Incoherent #-} Convertible AtomExpr RestrictionPredicateExpr where

234+ safeConvert a = Right $ AtomExprPredicate a

235+

236+instance {-# Incoherent #-} Convertible RestrictionPredicateExpr RestrictionPredicateExpr where

237+ safeConvert a = Right a

238+

239+instance {-# Incoherent #-} Atomable a => Convertible a AtomExpr where

240+ safeConvert n = Right $ toAtomExpr . toAtom $ n

241+

242+toAtomExpr :: Atom -> AtomExpr

243+toAtomExpr (ConstructedAtom n _ xs) = ConstructedAtomExpr n (toAtomExpr <$> xs) ()

244+toAtomExpr a = NakedAtomExpr a

245+

246+

247+

src/lib/ProjectM36/StaticOptimizer.hs+4−3

@@ -22,8 +22,6 @@ 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−

2725data GraphRefSOptRelationalExprEnv =

2826 GraphRefSOptRelationalExprEnv

2927 {

@@ -179,7 +177,7 @@ fullOptimizeGraphRefRelationalExpr expr = do

179177optimizeGraphRefRelationalExpr :: GraphRefRelationalExpr -> GraphRefSOptRelationalExprM GraphRefRelationalExpr

180178optimizeGraphRefRelationalExpr e@(MakeStaticRelation _ _) = pure e

181179

182−optimizeGraphRefRelationalExpr e@(MakeRelationFromExprs _ _) = pure e

180+optimizeGraphRefRelationalExpr e@MakeRelationFromExprs{} = pure e

183181

184182optimizeGraphRefRelationalExpr e@(ExistingRelation _) = pure e

185183

@@ -209,6 +207,8 @@ optimizeGraphRefRelationalExpr (Union exprA exprB) = do

209207 case (optExprA, optExprB) of

210208 (Restrict predA (RelationVariable nameA sA),

211209 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,3 +575,4 @@ applyStaticRestrictionPushdown expr = case expr of

575575-- no optimizations available

576576optimizeDatabaseContextIOExpr :: GraphRefDatabaseContextIOExpr -> GraphRefSOptDatabaseContextExprM GraphRefDatabaseContextIOExpr

577577optimizeDatabaseContextIOExpr = pure

578+

src/lib/ProjectM36/TransactionGraph.hs+1−1

@@ -384,7 +384,7 @@ subGraphOfFirstCommonAncestor origGraph resultHeads currentTrans' goalTrans trav

384384 else do

385385 currentTransChildren <- childTransactions currentTrans' origGraph

386386 let searchChildren = S.difference (S.insert currentTrans' traverseSet) currentTransChildren

387− searchChild start = pathToTransaction origGraph start goalTrans (S.insert currentTrans' traverseSet)

387+ searchChild start' = pathToTransaction origGraph start' goalTrans (S.insert currentTrans' traverseSet)

388388 childSearches = map searchChild (S.toList searchChildren)

389389 errors = lefts childSearches

390390 pathsFound = rights childSearches

src/lib/ProjectM36/Tuple.hs+47−33

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

11module ProjectM36.Tuple where

22import ProjectM36.Base

33import ProjectM36.Error

4−import ProjectM36.Attribute

4+import ProjectM36.Attribute as A

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 V.empty V.empty

18+emptyTuple = RelationTuple mempty mempty

1919

2020tupleSize :: RelationTuple -> Int

21−tupleSize (RelationTuple tupAttrs _) = V.length tupAttrs

21+tupleSize (RelationTuple tupAttrs _) = arity tupAttrs

2222

2323tupleAttributeNameSet :: RelationTuple -> S.Set AttributeName

24−tupleAttributeNameSet (RelationTuple tupAttrs _) = S.fromList $ V.toList $ V.map attributeName tupAttrs

24+tupleAttributeNameSet (RelationTuple tupAttrs _) = attributeNameSet tupAttrs

2525

2626tupleAttributes :: RelationTuple -> Attributes

2727tupleAttributes (RelationTuple tupAttrs _) = tupAttrs

2828

2929tupleAssocs :: RelationTuple -> [(AttributeName, Atom)]

30−tupleAssocs (RelationTuple attrVec tupVec) = V.toList $ V.map (first attributeName) (V.zip attrVec tupVec)

30+tupleAssocs (RelationTuple attrs tupVec) = V.toList $ V.map (first attributeName) (V.zip (attributesVec attrs) tupVec)

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

45+atomForAttributeName attrName (RelationTuple tupAttrs tupVec) = case V.findIndex (\attr -> attributeName attr == attrName) (attributesVec 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 (V.map attributeName attrs))

62+ mapper attrName = fromMaybe (error "logic failure in vectorIndicesForAttributeNames") (V.elemIndex attrName (attributeNames 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 attrs (V.map (attrMap M.!) attrNames)

89+mkRelationTupleFromMap attrMap = RelationTuple (attributesFromList attrs) (V.map (attrMap M.!) (V.fromList attrNames))

9090 where

91− attrNames = V.fromList (M.keys attrMap)

92− attrs = V.map (\attrName -> Attribute attrName (atomTypeForAtom (attrMap M.! attrName))) attrNames

91+ attrNames = M.keys attrMap

92+ attrs = 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` tupAttrs1) tupAttrs2

124− newVec = V.map (findAtomForAttributeName . attributeName) joinedAttrs

123+ attrsIntersection = V.filter (`V.elem` attributesVec tupAttrs1) (attributesVec tupAttrs2)

124+ newVec = V.map (findAtomForAttributeName . attributeName) (attributesVec joinedAttrs)

125125 --search both tuples for the attribute

126126 findAtomForAttributeName attrName = head $ rights $ fmap (atomForAttributeName attrName) [tup1, tup2]

127127

@@ -138,23 +138,31 @@ 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 V.++ tupAttrs2

142− newVec = tupVec1 V.++ tupVec2

141+ newAttrs = tupAttrs1 <> tupAttrs2

142+ newVec = tupVec1 <> tupVec2

143143

144144tupleAtomExtend :: AttributeName -> Atom -> RelationTuple -> RelationTuple

145145tupleAtomExtend newAttrName atom tupIn = tupleExtend tupIn newTup

146146 where

147− newTup = RelationTuple (V.singleton $ Attribute newAttrName (atomTypeForAtom atom)) (V.singleton atom)

147+ newTup = RelationTuple (A.singleton $ Attribute newAttrName (atomTypeForAtom atom)) (V.singleton atom)

148148

149−--this could be cheaper- it may not be wortwhile to update all the tuples for projection, but then the attribute management must be slightly different- perhaps the attributes should be a vector of association tuples [(name, index)]

150−tupleProject :: S.Set AttributeName -> RelationTuple -> RelationTuple

149+{-tupleProject :: S.Set AttributeName -> RelationTuple -> RelationTuple

151150tupleProject projectAttrs (RelationTuple attrs tupVec) = RelationTuple newAttrs newTupVec

152151 where

153− deleteIndices = V.findIndices (\attr -> S.notMember (attributeName attr) projectAttrs) attrs

152+ deleteIndices = V.findIndices (\attr -> S.notMember (attributeName attr) projectAttrs) (attributesVec attrs)

154153 indexDeleter = V.ifilter (\index _ -> V.notElem index deleteIndices)

155− newAttrs = indexDeleter attrs

154+ newAttrs = case A.projectionAttributesForNames projectAttrs attrs of

155+ Left err -> error (show (err, projectAttrs, attrs))

156+ Right attrs' -> attrs'

156157 newTupVec = indexDeleter tupVec

157−

158+-}

159+-- remember that the attributes order matters

160+tupleProject :: Attributes -> RelationTuple -> Either RelationalError RelationTuple

161+tupleProject projectAttrs tup = do

162+ newTupVec <- foldM (\acc attr ->

163+ V.snoc acc <$> atomForAttributeName (attributeName attr) tup

164+ ) V.empty (attributesVec projectAttrs)

165+ pure $ reorderTuple projectAttrs (RelationTuple projectAttrs newTupVec)

158166--return the attributes and atoms which are equal in both vectors

159167--semi-join

160168tupleIntersection :: RelationTuple -> RelationTuple -> RelationTuple

@@ -162,12 +170,14 @@ tupleIntersection tuple1 tuple2 = RelationTuple newAttrs newTupVec

162170 where

163171 attrs1 = tupleAttributes tuple1

164172 attrs2 = tupleAttributes tuple2

165− matchingIndices = V.findIndices (\attr -> V.elem attr attrs2 &&

166− atomForAttributeName (attributeName attr) tuple1 ==

167− atomForAttributeName (attributeName attr) tuple2

168− ) attrs1

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)

169177 indexFilter = V.ifilter (\index _ -> V.elem index matchingIndices)

170− newAttrs = indexFilter attrs1

178+ newAttrs = case A.projectionAttributesForNames (A.attributeNameSet intersectAttrs) attrs1 of

179+ Left _ -> mempty

180+ Right attrs' -> attrs'

171181 newTupVec = indexFilter (tupleAtoms tuple1)

172182

173183-- | An optimized form of tuple update which updates vectors efficiently.

@@ -175,19 +185,20 @@ updateTupleWithAtoms :: M.Map AttributeName Atom -> RelationTuple -> RelationTup

175185updateTupleWithAtoms updateMap (RelationTuple attrs tupVec) = RelationTuple attrs newVec

176186 where

177187 updateKeysSet = M.keysSet updateMap

178− updateKeysIVec = V.filter (\(_,attr) -> S.member (attributeName attr) updateKeysSet) (V.indexed attrs)

188+ updateKeysIVec = V.filter (\(_,attr) -> S.member (attributeName attr) updateKeysSet) (V.indexed (attributesVec attrs))

179189 newVec = V.update tupVec updateVec

180190 updateVec = V.map (\(index, attr) -> (index, updateMap M.! attributeName attr)) updateKeysIVec

181191

182192tupleToMap :: RelationTuple -> M.Map AttributeName Atom

183193tupleToMap (RelationTuple attrs tupVec) = M.fromList assocList

184194 where

185− assocList = V.toList $ V.map (\(index, attr) -> (attributeName attr, tupVec V.! index)) (V.indexed attrs)

195+ assocList = V.toList $ V.map (\(index, attr) -> (attributeName attr, tupVec V.! index)) (V.indexed (attributesVec attrs))

186196

197+-- | Validate that the tuple has the correct attributes in the correct order

187198verifyTuple :: Attributes -> RelationTuple -> Either RelationalError RelationTuple

188−verifyTuple attrs tuple = let attrsTypes = V.map atomType attrs

199+verifyTuple attrs tuple = let attrsTypes = A.atomTypes attrs

189200 tupleTypes = V.map atomTypeForAtom (tupleAtoms tuple) in

190− if V.length attrs /= V.length tupleTypes then

201+ if A.arity attrs /= V.length tupleTypes then

191202 Left $ TupleAttributeCountMismatchError 0

192203 else do

193204 mapM_ (uncurry atomTypeVerify) (V.zip attrsTypes tupleTypes)

@@ -196,15 +207,18 @@ verifyTuple attrs tuple = let attrsTypes = V.map atomType attrs

196207--two tuples can be equal but the vectors of attributes could be out-of-order

197208--reorder if necessary- this is useful during relMogrify so that all the relation's tuples have identical atom/attribute ordering

198209reorderTuple :: Attributes -> RelationTuple -> RelationTuple

199−reorderTuple attrs tupIn = if tupleAttributes tupIn == attrs then

210+reorderTuple attrs tupIn = if attributesAndOrderEqual (tupleAttributes tupIn) attrs then

200211 tupIn

201212 else

202− RelationTuple attrs (V.map mapper attrs)

213+ RelationTuple attrs (V.map mapper (attributesVec attrs))

203214 where

204215 mapper attr = case atomForAttributeName (attributeName attr) tupIn of

205− Left err -> error ("logic bug in reorderTuple: " ++ show err)

216+ Left err -> error ("logic bug in reorderTuple: " ++ show err <> show tupIn)

206217 Right atom -> atom

207218

208219--used in Generics derivation for ADTs without named attributes

209220trimTuple :: Int -> RelationTuple -> RelationTuple

210−trimTuple index (RelationTuple attrs vals) = RelationTuple (V.drop index attrs) (V.drop index vals)

221+trimTuple index (RelationTuple attrs vals) =

222+ RelationTuple newAttrs (V.drop index vals)

223+ where

224+ newAttrs = A.drop index attrs

src/lib/ProjectM36/TupleSet.hs+7

@@ -31,3 +31,10 @@ mkTupleSet attrs tuples = verifyTupleSet attrs (RelationTupleSet tuples)

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+9−8

@@ -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 hiding (null)

41+import ProjectM36.Attribute as A hiding (null, toList)

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

92+toDefineExpr _ rvName = Define rvName (map NakedAttributeExpr (V.toList (attributesVec attrs)))

9393 where

9494 attrs = toAttributes (Proxy :: Proxy a)

9595

@@ -228,11 +228,12 @@ 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 (V.length attrsToCheck) id

232− attrs = V.zipWith (\num attr@(Attribute name typ) -> if T.null name then

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

233234 Attribute ("attr" <> T.pack (show (num + 1))) typ

234235 else

235− attr) counter attrsToCheck

236+ attr) counter (attributesVec attrsToCheck)

236237 atoms = V.fromList (toAtomsG v)

237238 toAttributesG opts (M1 v) = toAttributesG opts v

238239 fromTupleG opts tup = M1 <$> fromTupleG opts tup

@@ -241,7 +242,7 @@ instance (Constructor c, TupleableG a, AtomableG a) => TupleableG (M1 C c a) whe

241242-- product types

242243instance (TupleableG a, TupleableG b) => TupleableG (a :*: b) where

243244 toTupleG = error "toTupleG"

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

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

245246 fromTupleG opts tup = (:*:) <$> fromTupleG opts tup <*> fromTupleG opts processedTuple

246247 where

247248 processedTuple = if isRecordTypeG (undefined :: a x) then

@@ -253,7 +254,7 @@ instance (TupleableG a, TupleableG b) => TupleableG (a :*: b) where

253254--selector/record

254255instance (Selector c, AtomableG a) => TupleableG (M1 S c a) where

255256 toTupleG = error "toTupleG"

256− toAttributesG opts m@(M1 v) = V.singleton (Attribute modifiedName aType)

257+ toAttributesG opts m@(M1 v) = A.singleton (Attribute modifiedName aType)

257258 where

258259 name = T.pack (selName m)

259260 modifiedName = if T.null name then

@@ -268,7 +269,7 @@ instance (Selector c, AtomableG a) => TupleableG (M1 S c a) where

268269 val <- atomv atom

269270 pure (M1 val)

270271 where

271− expectedAtomType = atomType (V.head (toAttributesG opts (undefined :: M1 S c a x)))

272+ expectedAtomType = atomType (V.head (attributesVec (toAttributesG opts (undefined :: M1 S c a x))))

272273 atomv atom = maybe (Left (AtomTypeMismatchError

273274 expectedAtomType

274275 (atomTypeForAtom atom)

src/lib/ProjectM36/WithNameExpr.hs+4−2

@@ -42,9 +42,11 @@ 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 override existing macros and recurse

45+ --collect and update nested with exprs

4646 let newMacros = foldr macroFolder macros moreMacros

47− macroFolder (wnexpr, mexpr) acc = filter (\(w,_) -> w /= wnexpr) acc ++ [(wnexpr, mexpr)] in

47+ macroFolder (wnexpr, mexpr) acc =

48+ let subExpr = substituteWithNameMacros macros mexpr in

49+ filter (\(w,_) -> w /= wnexpr) acc ++ [(wnexpr, subExpr)] in

4850 --scan for a match- if it exists, replace it (representing a with clause at a lower level

4951 substituteWithNameMacros newMacros expr

5052

stack.ghc8.0.yamldeleted−48

@@ -1,48 +0,0 @@

1−# This file was automatically generated by stack init

2−# For more information, see: http://docs.haskellstack.org/en/stable/yaml_configuration/

3−

4−# Specifies the GHC version and set of packages available (e.g., lts-3.5, nightly-2015-09-21, ghc-7.10.2)

5−resolver: lts-8.5

6−

7−# Local packages, usually specified by relative directory name

8−packages:

9−- '.'

10−# Packages to be pulled from upstream that are not in the resolver (e.g., acme-missiles-0.3)

11−extra-deps:

12−- git: https://github.com/agentm/curryer.git

13− commit: 1e60c0580ca33d6ae1e97aaddc32189fdfe3ef6c

14−- data-accessor-transformers-0.2.1.7

15−- data-interval-1.2.0

16−- extended-reals-0.2.1.0

17−- gnuplot-0.5.4.1

18−- text-1.2.2.1

19−- aeson-1.2.1.00

20−- deferred-folds-0.6.12

21−- rset-1.0.0

22−

23−# Override default flag values for local packages and extra-deps

24−flags: {}

25−

26−# Extra package databases containing global packages

27−extra-package-dbs: []

28−

29−# Control whether we use the GHC we find on the path

30−# system-ghc: true

31−

32−# Require a specific version of stack, using version ranges

33−# require-stack-version: -any # Default

34−# require-stack-version: >= 1.0.0

35−

36−# Override the architecture used by stack, especially useful on Windows

37−# arch: i386

38−# arch: x86_64

39−

40−# Extra directories used by stack for building

41−# extra-include-dirs: [/path/to/dir]

42−# extra-lib-dirs: [/path/to/dir]

43−

44−# Allow a newer minor version of GHC than the snapshot specifies

45−# compiler-check: newer-minor

46−

47−allow-newer: true

48−

stack.ghc8.10.yamlnew file+19

@@ -0,0 +1,19 @@

1+resolver: lts-17.13

2+packages:

3+ - "."

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.yamldeleted−50

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

1−# This file was automatically generated by stack init

2−# For more information, see: http://docs.haskellstack.org/en/stable/yaml_configuration/

3−

4−# Specifies the GHC version and set of packages available (e.g., lts-3.5, nightly-2015-09-21, ghc-7.10.2)

5−resolver: lts-11.20

6−

7−# Local packages, usually specified by relative directory name

8−packages:

9−- '.'

10−

11−# Packages to be pulled from upstream that are not in the resolver (e.g., acme-missiles-0.3)

12−extra-deps:

13−- git: https://github.com/agentm/curryer.git

14− commit: 1e60c0580ca33d6ae1e97aaddc32189fdfe3ef6c

15−- data-accessor-transformers-0.2.1.7

16−- data-interval-1.2.0

17−- extended-reals-0.2.1.0

18−- gnuplot-0.5.4.1

19−- text-1.2.2.1

20−- aeson-1.2.1.00

21−- rset-1.0.0

22−

23−# Override default flag values for local packages and extra-deps

24−flags:

25− project-m36:

26− stack: true

27−

28−# Extra package databases containing global packages

29−extra-package-dbs: []

30−

31−# Control whether we use the GHC we find on the path

32−# system-ghc: true

33−

34−# Require a specific version of stack, using version ranges

35−# require-stack-version: -any # Default

36−# require-stack-version: >= 1.0.0

37−

38−# Override the architecture used by stack, especially useful on Windows

39−# arch: i386

40−# arch: x86_64

41−

42−# Extra directories used by stack for building

43−# extra-include-dirs: [/path/to/dir]

44−# extra-lib-dirs: [/path/to/dir]

45−

46−# Allow a newer minor version of GHC than the snapshot specifies

47−# compiler-check: newer-minor

48−

49−allow-newer: true

50−

stack.ghc8.4.yamldeleted−46

@@ -1,46 +0,0 @@

1−# This file was automatically generated by stack init

2−# For more information, see: http://docs.haskellstack.org/en/stable/yaml_configuration/

3−

4−# Specifies the GHC version and set of packages available (e.g., lts-3.5, nightly-2015-09-21, ghc-7.10.2)

5−resolver: lts-12.26

6−

7−# Local packages, usually specified by relative directory name

8−packages:

9−- '.'

10−# Packages to be pulled from upstream that are not in the resolver (e.g., acme-missiles-0.3)

11−extra-deps:

12−- git: https://github.com/agentm/curryer.git

13− commit: 1e60c0580ca33d6ae1e97aaddc32189fdfe3ef6c

14−- data-interval-1.3.0

15−- extended-reals-0.2.3.0

16−- rset-1.0.0

17−- hashable-time-0.2.0.2

18−- network-transport-tcp-0.6.0

19−

20−# Override default flag values for local packages and extra-deps

21−flags:

22− project-m36:

23− stack: true

24−

25−# Extra package databases containing global packages

26−extra-package-dbs: []

27−

28−# Control whether we use the GHC we find on the path

29−# system-ghc: true

30−

31−# Require a specific version of stack, using version ranges

32−# require-stack-version: -any # Default

33−# require-stack-version: >= 1.0.0

34−

35−# Override the architecture used by stack, especially useful on Windows

36−# arch: i386

37−# arch: x86_64

38−

39−# Extra directories used by stack for building

40−# extra-include-dirs: [/path/to/dir]

41−# extra-lib-dirs: [/path/to/dir]

42−

43−# Allow a newer minor version of GHC than the snapshot specifies

44−# compiler-check: newer-minor

45−

46−allow-newer: true

stack.ghc8.6.yaml+25−12

@@ -2,23 +2,36 @@

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

5+resolver: lts-14.27

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: 1e60c0580ca33d6ae1e97aaddc32189fdfe3ef6c

14−- extended-reals-0.2.3.0

15−- data-interval-2.0.1

16−- stm-containers-1.1.0.4

17−- stm-hamt-1.2.0.4

18−- rset-1.0.0

19−- hashable-time-0.2.0.2

20−- network-transport-tcp-0.6.0

21−- megaparsec-7.0.5

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

2235

2336# Override default flag values for local packages and extra-deps

2437flags:

stack.ghc8.8.yaml+24−14

@@ -6,22 +6,32 @@ resolver: lts-16.4

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: 1e60c0580ca33d6ae1e97aaddc32189fdfe3ef6c

14−- extended-reals-0.2.3.0

15−- data-interval-2.0.1

16−- stm-containers-1.1.0.4

17−- stm-hamt-1.2.0.4

18−- rset-1.0.0

19−- hashable-time-0.2.0.2

20−- network-transport-tcp-0.7.0

21−- megaparsec-7.0.5

22−- network-2.8.0.1

23−- primitive-extras-0.8

24−- primitive-unlifted-0.1.3.0

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

2535

2636# Override default flag values for local packages and extra-deps

2737flags:

test/Client/Simple.hs+1−2

@@ -9,7 +9,6 @@ import System.IO.Temp

99import System.FilePath

1010import ProjectM36.TupleSet

1111import ProjectM36.Attribute

12−import qualified Data.Vector as V

1312import qualified Data.Map as M

1413

1514main :: IO ()

@@ -59,7 +58,7 @@ testSimpleCommitFailure = TestCase $ do

5958 execute $ Assign "x" (ExistingRelation relationTrue)

6059 --cause error

6160 execute $ Assign "x" (MakeStaticRelation failAttrs emptyTupleSet)

62− let expectedErr = Left (RelError (RelationTypeMismatchError V.empty failAttrs))

61+ let expectedErr = Left (RelError (RelationTypeMismatchError mempty failAttrs))

6362 assertEqual "dbc error" expectedErr err

6463

6564-- #176 default merge couldn't handle Update

test/Relation/Basic.hs+13−12

@@ -3,8 +3,6 @@ import ProjectM36.Base

33import ProjectM36.Relation

44import ProjectM36.Error

55import ProjectM36.DateExamples

6−import ProjectM36.TupleSet

7−import ProjectM36.Attribute hiding (null, attributeNames)

86import ProjectM36.DataTypes.Primitive

97import ProjectM36.RelationalExpression

108import ProjectM36.TransactionGraph

@@ -25,8 +23,8 @@ testList = TestList [testRelation "relationTrue" relationTrue, testRelation "rel

2523 testRelation "products" productsRel,

2624 testRelation "supplierProducts" supplierProductsRel,

2725 testMkRelationFromExprsBadAttrs,

28− testDuplicateAttributes,

29− testExistingRelationType

26+ testExistingRelationType,

27+ testReorderTuple

3028 ]

3129

3230main :: IO ()

@@ -65,7 +63,7 @@ validateAttrTypesMatchTupleAttrTypes rel@(Relation attrs tupSet) = foldr (\tuple

6563 attrChecks tuple = V.map (\attr -> case atomForAttributeName (A.attributeName attr) tuple of

6664 Left _ -> False

6765 Right atom -> Right (atomTypeForAtom atom) ==

68− A.atomTypeForAttributeName (A.attributeName attr) attrs) (attributes rel)

66+ A.atomTypeForAttributeName (A.attributeName attr) attrs) (attributesVec (attributes rel))

6967

7068simpleRel :: Relation

7169simpleRel = case mkRelation attrs tupleSet of

@@ -103,16 +101,19 @@ testMkRelationFromExprsBadAttrs = TestCase $ do

103101 Left err -> assertEqual "tuple type mismatch" (TupleAttributeTypeMismatchError (A.attributesFromList [Attribute "badAttr2" IntAtomType])) err

104102 Right _ -> assertFailure "expected tuple type mismatch"

105103

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−

113104testExistingRelationType :: Test

114105testExistingRelationType = TestCase $ do

115106 (graph, _) <- freshTransactionGraph dateExamples

116107 let typeResult = runRelationalExprM reenv (typeForRelationalExpr (ExistingRelation relationTrue))

117108 reenv = mkRelationalExprEnv dateExamples graph

118109 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+18−6

@@ -8,13 +8,13 @@

88 , DataKinds

99 , TypeOperators

1010 , AllowAmbiguousTypes

11+ , DerivingVia

1112 #-}

1213import Test.HUnit

1314import ProjectM36.Tupleable.Deriving

1415import ProjectM36.Atomable

15−import ProjectM36.Attribute

16+import ProjectM36.Attribute as A

1617import ProjectM36.Error

17−import Data.Binary

1818import ProjectM36.Base

1919import Control.DeepSeq (NFData)

2020import qualified Data.Vector as V

@@ -23,6 +23,7 @@ import qualified Data.Text as T

2323import qualified Data.Set as S

2424import System.Exit

2525import Data.Proxy

26+import Codec.Winery

2627

2728{-# ANN module ("Hlint: ignore Use newtype instead of data" :: String) #-}

2829

@@ -30,35 +31,43 @@ data Test1T = Test1C {

3031 attrA :: Integer

3132 }

3233 deriving (Generic, Eq, Show)

34+ deriving Serialise via WineryRecord Test1T

3335

3436data Test2T = Test2C {

3537 attrB :: Integer,

3638 attrC :: Integer

3739 }

3840 deriving (Generic, Eq, Show)

41+ deriving Serialise via WineryRecord Test2T

3942

4043data Test3T = Test3C Integer

4144 deriving (Generic, Eq, Show)

45+ deriving Serialise via WineryVariant Test3T

4246

4347data Test4T = Test4C

4448 deriving (Generic, Eq, Show)

49+ deriving Serialise via WineryVariant Test4T

4550

4651data Test5T = Test5C1 Integer |

4752 Test5C2 Integer

4853 deriving (Generic, Eq, Show)

54+ deriving Serialise via WineryVariant Test5T

4955

5056data Test6T = Test6C T.Text Integer Double

5157 deriving (Generic, Eq, Show)

5258

5359data Test7A = Test7AC Integer

54− deriving (Generic, Show, Eq, Binary, NFData, Atomable)

60+ deriving (Generic, Show, Eq, NFData, Atomable)

61+ deriving Serialise via WineryVariant Test7A

5562

5663

5764data Test7T = Test7C Test7A

5865 deriving (Generic, Show, Eq)

66+ deriving Serialise via WineryVariant Test7T

5967

6068data Test8T = Test8C

6169 deriving (Generic, Show, Eq)

70+ deriving Serialise via WineryVariant Test8T

6271

6372data Test9T = Test9C

6473 {

@@ -67,6 +76,7 @@ data Test9T = Test9C

6776 attr9C :: Double

6877 }

6978 deriving (Generic, Show, Eq)

79+ deriving Serialise via WineryRecord Test9T

7080

7181data Test10T = Test10C {

7282 longAttrNameA10 :: Integer,

@@ -74,6 +84,7 @@ data Test10T = Test10C {

7484 longMixed_attr_NameC10 :: Integer

7585 }

7686 deriving (Generic, Show, Eq)

87+ deriving Serialise via WineryRecord Test10T

7788

7889instance Tupleable Test1T

7990

@@ -99,7 +110,7 @@ main = do

99110 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

100111

101112testList :: Test

102−testList = TestList [testADT1, testADT2, testADT3, testADT4, testADT6, testADT7, testADT8, testInsertExpr, testDefineExpr, testUpdateExpr, testUpdateExprEmptyAttrs, testDeleteExpr, testUpdateExprWrongAttr, testReorderedTuple, testAddPrefixField, testDropPrefixField, testAddSuffixField, testDropSuffixField, testUpperCaseField, testLowerCaseField, testTitleCaseField, testCamelCaseField, testPascalCaseField, testSnakeCaseField, testSpinalCaseField, testTrainCaseField, testAsIsCodec, testAsIsField, testComposeRLCodec, testComposeRLField, testComposeLRCodec, testComposeLRField]

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]

103114

104115testADT1 :: Test

105116testADT1 = TestCase $ assertEqual "one record constructor" (Right example) (fromTuple (toTuple example))

@@ -137,7 +148,7 @@ testADT7 :: Test

137148testADT7 = TestCase $ do

138149 let example = Test7C (Test7AC 3)

139150 assertEqual "atom type" (Right example) (fromTuple (toTuple example))

140− let expectedAttrs = V.singleton (Attribute "" (ConstructedAtomType "Test7A" M.empty))

151+ let expectedAttrs = A.singleton (Attribute "" (ConstructedAtomType "Test7A" M.empty))

141152 assertEqual "adt atomtype" expectedAttrs (toAttributes (Proxy :: Proxy Test7T))

142153

143154testADT8 :: Test

@@ -211,7 +222,8 @@ testDeleteExpr = TestCase $ do

211222testReorderedTuple :: Test

212223testReorderedTuple = TestCase $ do

213224 let tupleRev :: RelationTuple -> RelationTuple

214− tupleRev (RelationTuple v1 v2) = RelationTuple (V.reverse v1) (V.reverse v2)

225+ tupleRev (RelationTuple v1 v2) = RelationTuple (revAttrs v1) (V.reverse v2)

226+ revAttrs attrs = A.attributesFromList (reverse (A.toList attrs))

215227 expected = Test2C {attrB = 3,

216228 attrC = 4}

217229 actual = fromTuple . tupleRev . toTuple $ expected

test/Server/Main.hs+19−20

@@ -5,7 +5,6 @@ test client/server interaction

55import Test.HUnit

66import ProjectM36.Client

77import qualified ProjectM36.Client as C

8−import ProjectM36.Server.EntryPoints

98import ProjectM36.Server

109import ProjectM36.Server.Config

1110import ProjectM36.Relation

@@ -14,16 +13,8 @@ import ProjectM36.IsomorphicSchema

1413import ProjectM36.Base

1514

1615import System.Exit

17−

16+import Network.Socket (SockAddr(..))

1817import 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−

2718import Data.Either (isRight)

2819import Control.Exception

2920import System.IO.Temp

@@ -32,6 +23,8 @@ import System.FilePath

3223import System.Directory

3324#endif

3425

26+type Timeout = Int

27+

3528testList :: SessionId -> Connection -> MVar () -> Test

3629testList sessionId conn notificationTestMVar = TestList $ serverTests ++ sessionTests

3730 where

@@ -49,7 +42,7 @@ testList sessionId conn notificationTestMVar = TestList $ serverTests ++ session

4942 testRelationVariableSummary,

5043 testNotification notificationTestMVar

5144 ]

52− serverTests = [testRequestTimeout, testFileDescriptorCount]

45+ serverTests = [testRequestTimeout, testFileDescriptorCount, testClientConnectFail]

5346

5447main :: IO ()

5548main = do

@@ -69,11 +62,9 @@ main = do

6962testDatabaseName :: DatabaseName

7063testDatabaseName = "test"

7164

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)

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)

7768 --putStrLn ("testConnection: " ++ show serverAddress)

7869 eConn <- connectProjectM36 connInfo

7970 case eConn of

@@ -85,7 +76,7 @@ testConnection serverAddress mvar = do

8576 Right sessionId -> pure $ Right (sessionId, conn)

8677

8778-- | A version of 'launchServer' which returns the port on which the server is listening on a secondary thread

88−launchTestServer :: Timeout -> IO (EndPointAddress, ThreadId)

79+launchTestServer :: Timeout -> IO (Port, ThreadId)

8980launchTestServer ti = do

9081 addressMVar <- newEmptyMVar

9182 tid <- forkIO $

@@ -99,9 +90,9 @@ launchTestServer ti = do

9990 }

10091

10192 launchServer config (Just addressMVar) >> pure ()

102− endPointAddress <- takeMVar addressMVar

93+ (SockAddrInet port _) <- takeMVar addressMVar

10394 --liftIO $ putStrLn ("launched server on " ++ show endPointAddress)

104− pure (endPointAddress, tid)

95+ pure (fromIntegral port, tid)

10596

10697testRelationalExpr :: SessionId -> Connection -> Test

10798testRelationalExpr sessionId conn = TestCase $ do

@@ -217,7 +208,7 @@ testRequestTimeout = TestCase $ do

217208 Left err -> putStrLn ("failed to connect: " ++ show err) >> exitFailure

218209 Right (session, testConn) -> do

219210 res <- catchJust (\exc -> if exc == RequestTimeoutException then Just exc else Nothing) (callTestTimeout_ session testConn) (const (pure False))

220− assertBool "exception was not thrown" (not res)

211+ assertBool "timeout exception was not thrown" (not res)

221212 killThread serverTid

222213

223214testFileDescriptorCount :: Test

@@ -247,3 +238,11 @@ fdCount = do

247238--pass on non-linux platforms

248239testFileDescriptorCount = TestCase (pure ())

249240#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+3−9

@@ -18,12 +18,6 @@ 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−

2721

2822--start the websocket server

2923-- run some tutoriald against it

@@ -37,12 +31,12 @@ launchTestServer = do

3731 testDatabaseName = "test"

3832 -- start normal server

3933 _ <- forkIO (launchServer config (Just addressMVar) >> pure ())

40− serverAddress <- takeMVar addressMVar

34+ (SockAddrInet dbPort _) <- takeMVar addressMVar

4135 let wsServerHost = "127.0.0.1"

4236 wsServerPort = 8889

43− Just (dbHost, dbPort, _) = decodeEndPointAddress serverAddress

37+ dbHost = "127.0.0.1"

4438 -- start websocket server proxy -- runServer doesn't support returning an arbitrary socket

45− _ <- forkIO (WS.runServer wsServerHost wsServerPort (websocketProxyServer (read dbPort) dbHost))

39+ _ <- forkIO (WS.runServer wsServerHost wsServerPort (websocketProxyServer (fromIntegral dbPort) dbHost))

4640 --wait for socket to be listening

4741 waitForListenSocket 5 (fromIntegral wsServerPort)

4842 pure (fromIntegral wsServerPort, testDatabaseName)

test/TutorialD/Interpreter/Import/ImportTest.hsnew file+47

@@ -0,0 +1,47 @@

1+import Test.HUnit

2+import ProjectM36.Base

3+import TutorialD.Interpreter.Import.TutorialD

4+import System.Exit

5+import qualified Data.Text as T

6+import System.IO.Temp

7+import System.FilePath

8+import qualified Data.Map as M

9+import System.IO

10+import System.Directory

11+import qualified Data.ByteString as BS

12+import qualified Data.Text.Encoding as TE

13+import Text.URI hiding (makeAbsolute)

14+

15+main :: IO ()

16+main = do

17+ tcounts <- runTestTT $ TestList [testTutdFileImport

18+ ,testTutdHTTPSImport

19+ ]

20+ if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

21+

22+testTutdFileImport :: Test

23+testTutdFileImport = TestCase $

24+ withSystemTempFile "m.tutd" $ \tempPath handle -> do

25+ BS.hPut handle (TE.encodeUtf8 "x:=relation{tuple{a 5,b \"spam\"}}; y:=relation{tuple{b \"漢字\"}}")

26+ hClose handle

27+ let expectedExpr = MultipleExpr [

28+ Assign "x" (MakeRelationFromExprs Nothing

29+ $ TupleExprs () [TupleExpr (M.fromList [("a", NakedAtomExpr $ IntegerAtom 5),

30+ ("b", NakedAtomExpr $ TextAtom "spam")])]),

31+ Assign "y" (MakeRelationFromExprs Nothing

32+ $ TupleExprs () [TupleExpr (M.fromList [("b", NakedAtomExpr (TextAtom "漢字"))])])]

33+ --on Windows, the file URI should not include the drive letter "/c/Users..." -> "/Users"

34+ let uri = "file://" <> map (\c -> if c == '\\' then '/' else c) ( joinDrive "/" (dropDrive tempPath))

35+ fileURI <- mkURI (T.pack uri)

36+ imported <- importTutorialDFromFile fileURI Nothing

37+ assertEqual "import tutd" (Right expectedExpr) imported

38+

39+testTutdHTTPSImport :: Test

40+testTutdHTTPSImport = TestCase $ do

41+ uri <- mkURI "https://raw.githubusercontent.com/agentm/project-m36/master/test/TutorialD/Interpreter/Import/httpimporttest.tutd"

42+ let hash = "effe32b247586dc3ac0079fc241b9618d41d189afcaeb7907edbe5a8b45992a4"

43+ expected = Right (MultipleExpr [Assign "x" (RelationVariable "true" ()),Assign "y" (RelationVariable "false" ())])

44+ actual <- importTutorialDViaHTTP uri (Just hash)

45+ assertEqual "github https" expected actual

46+

47+

test/TutorialD/Interpreter/Import/TutorialD.hsdeleted−29

@@ -1,29 +0,0 @@

1−import Test.HUnit

2−import ProjectM36.Base

3−import TutorialD.Interpreter.Import.TutorialD

4−import System.Exit

5−import System.IO.Temp

6−import qualified Data.Map as M

7−import System.IO

8−import qualified Data.ByteString as BS

9−import qualified Data.Text.Encoding as TE

10−

11−main :: IO ()

12−main = do

13− tcounts <- runTestTT $ TestList [testTutdImport]

14− if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

15−

16−testTutdImport :: Test

17−testTutdImport = TestCase $

18− withSystemTempFile "m.tutd" $ \tempPath handle -> do

19− BS.hPut handle (TE.encodeUtf8 "x:=relation{tuple{a 5,b \"spam\"}}; y:=relation{tuple{b \"漢字\"}}")

20− hClose handle

21− let expectedExpr = MultipleExpr [

22− Assign "x" (MakeRelationFromExprs Nothing

23− $ 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.tutdnew file+2

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

1+x:=true;

2+y:=false;

test/TutorialD/Interpreter.hs → test/TutorialD/InterpreterTest.hsrenamed+37−7

@@ -79,13 +79,16 @@ main = do

7979 testInvalidDataConstructor,

8080 testBasicList,

8181 testRelationDeclarationMismatch,

82− testInvalidTuples

82+ testInvalidTuples,

83+ testSelfReferencingUncommittedContext,

84+ testUnionAndIntersectionAttributeExprs

8385 ]

8486

8587simpleRelTests :: Test

8688simpleRelTests = TestCase $ do

8789 (graph, transId) <- freshTransactionGraph dateExamples

88− mapM_ (\(tutd, expected) -> assertTutdEqual basicDatabaseContext transId graph expected tutd) testTups

90+ mapM_ (\(tutd, expected) ->

91+ assertTutdEqual basicDatabaseContext transId graph expected tutd) testTups

8992 where

9093 testTups = [("x:=true", Right relationTrue),

9194 ("x:=false", Right relationFalse),

@@ -120,7 +123,8 @@ simpleRelTests = TestCase $ do

120123 ("x:=relation{tuple{a 5}} : {b:=6}", mkRelationFromTuples simpleDAttributes [RelationTuple simpleDAttributes (V.fromList [IntegerAtom 5, IntegerAtom 6])]),

121124 ("x:=relation{tuple{a 5}} : {b:=add(@a,5)}", mkRelationFromTuples simpleDAttributes [RelationTuple simpleDAttributes (V.fromList [IntegerAtom 5, IntegerAtom 10])]),

122125 ("x:=relation{tuple{a 5}} : {b:=add(@a,\"spam\")}", Left (AtomFunctionTypeError "add" 2 IntegerAtomType TextAtomType)),

123− ("x:=relation{tuple{a 5}} : {b:=add(add(@a,2),5)}", mkRelationFromTuples simpleDAttributes [RelationTuple simpleDAttributes (V.fromList [IntegerAtom 5, IntegerAtom 12])])

126+ ("x:=relation{tuple{a 5}} : {b:=add(add(@a,2),5)}", mkRelationFromTuples simpleDAttributes [RelationTuple simpleDAttributes (V.fromList [IntegerAtom 5, IntegerAtom 12])]),

127+ ("x:=false:{a:=1,b:=2}", mkRelationFromTuples simpleDAttributes [])

124128 ]

125129 simpleAAttributes = A.attributesFromList [Attribute "a" IntegerAtomType]

126130 simpleBAttributes = A.attributesFromList [Attribute "d" IntegerAtomType]

@@ -132,7 +136,8 @@ simpleRelTests = TestCase $ do

132136dateExampleRelTests :: Test

133137dateExampleRelTests = TestCase $ do

134138 (graph, transId) <- freshTransactionGraph dateExamples

135− mapM_ (\(tutd, expected) -> assertTutdEqual dateExamples transId graph expected tutd) testTups

139+ mapM_ (\(tutd, expected) ->

140+ assertTutdEqual dateExamples transId graph expected tutd) testTups

136141 where

137142 simpleEitherIntTextAttributes = A.attributesFromList [Attribute "a" (eitherAtomType IntegerAtomType TextAtomType)]

138143 maybeIntegerAtomType = ConstructedAtomType "Maybe" (M.singleton "a" IntegerAtomType)

@@ -230,7 +235,7 @@ transactionGraphAddCommitTest = TestCase $ do

230235 commit sessionId dbconn >>= eitherFail

231236 discon <- disconnectedTransaction_ sessionId dbconn

232237 let context = Discon.concreteDatabaseContext discon

233− assertEqual "ensure x was added" (M.lookup "x" (relationVariables context)) (Just (RelationVariable "s" UncommittedContextMarker))

238+ assertEqual "ensure x was added" (M.lookup "x" (relationVariables context)) (Just (ExistingRelation suppliersRel))

234239

235240transactionRollbackTest :: Test

236241transactionRollbackTest = TestCase $ do

@@ -357,7 +362,7 @@ testComments :: Test

357362testComments = TestCase $ do

358363 (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback

359364 mapM_ (executeTutorialD sessionId dbconn) [

360− ":branch testbranch --test comment\n",

365+ ":branch testbranch --test comment",

361366 ":jumphead {- test comment -} master"]

362367

363368-- create a graph and query from two disparate contexts

@@ -540,7 +545,7 @@ testListConstructedAtom = TestCase $ do

540545testTypeChecker :: Test

541546testTypeChecker = TestCase $ do

542547 (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback

543− let err1 = "AtomFunctionTypeError \"max\" 1 (RelationAtomType [Attribute \"_\" IntegerAtomType]) IntegerAtomType"

548+ let err1 = "AtomFunctionTypeError \"max\" 1"

544549 expectTutorialDErr sessionId dbconn (T.isPrefixOf err1) "x:=relation{tuple{a 0}}:{b:=max(@a)}"

545550

546551--exercise expression parser

@@ -660,6 +665,10 @@ testWithClause = TestCase $ do

660665 executeTutorialD sessionId dbconn "x:=with (x as s) x"

661666 eX <- executeRelationalExpr sessionId dbconn (RelationVariable "x" ())

662667 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

663672

664673 let err1 = "RelVarAlreadyDefinedError"

665674 expectTutorialDErr sessionId dbconn (T.isPrefixOf err1) "x:=with (s as s) s"

@@ -700,3 +709,24 @@ testInvalidTuples = TestCase $ do

700709 expectTutorialDErr sessionId dbconn (T.isPrefixOf "AttributeNamesMismatchError") ":showexpr relation{tuple{a 1},tuple{b 2}}"

701710 expectTutorialDErr sessionId dbconn (T.isPrefixOf "AttributeNamesMismatchError") ":showexpr relation{tuple{a 1},tuple{a 2, b 3}}"

702711-- expectTutorialDErr sessionId dbconn (T.isPrefixOf "ParseErrorBundle") ":showexpr relation{tuple{a 2, a 3}}" --parse failure can't be validated with this function

712+

713+testSelfReferencingUncommittedContext :: Test

714+testSelfReferencingUncommittedContext = TestCase $ do

715+ (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback

716+ executeTutorialD sessionId dbconn "s:=s union s"

717+ eS <- executeRelationalExpr sessionId dbconn (RelationVariable "s" ())

718+ _ <- rollback sessionId dbconn

719+ eSorig <- executeRelationalExpr sessionId dbconn (RelationVariable "s" ())

720+ assertEqual "s=s'" eSorig eS

721+

722+testUnionAndIntersectionAttributeExprs :: Test

723+testUnionAndIntersectionAttributeExprs = TestCase $ do

724+ (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback

725+ executeTutorialD sessionId dbconn "x:=s{intersection of {all but sname} {sname}}"

726+ xRel <- executeRelationalExpr sessionId dbconn (RelationVariable "x" ())

727+ assertEqual "intersection attrs" (Right relationTrue) xRel

728+

729+ executeTutorialD sessionId dbconn "y:=s{union of {all but sname} {sname}}"

730+ yRel <- executeRelationalExpr sessionId dbconn (RelationVariable "y" ())

731+ assertEqual "union attrs" (Right suppliersRel) yRel

732+

test/TutorialD/PrinterTest.hsnew file+47

@@ -0,0 +1,47 @@

1+{-# LANGUAGE OverloadedStrings #-}

2+import Test.HUnit

3+import ProjectM36.Base

4+import System.Exit

5+import Data.Text.Prettyprint.Doc

6+import Data.Map (fromList)

7+import TutorialD.Printer ()

8+import TutorialD.Interpreter.RelationalExpr

9+import Text.Megaparsec

10+import Data.Text (pack)

11+

12+testList :: Test

13+testList = TestList [

14+ testPretty "true" (RelationVariable "true" ()),

15+ testPretty "relation{tuple{a 3, b \"x\"}, tuple{a 4, b \"y\"}}" (MakeRelationFromExprs Nothing (TupleExprs () [TupleExpr (fromList [("a",NakedAtomExpr (IntegerAtom 3)),("b",NakedAtomExpr (TextAtom "x"))]),TupleExpr (fromList [("a",NakedAtomExpr (IntegerAtom 4)),("b",NakedAtomExpr (TextAtom "y"))])])),

16+ testPretty "true:{a:=1, b:=1}" (Extend (AttributeExtendTupleExpr "b" (NakedAtomExpr (IntegerAtom 1))) (Extend (AttributeExtendTupleExpr "a" (NakedAtomExpr (IntegerAtom 1))) (RelationVariable "true" ()))),

17+ testPretty "relation{tuple{a fromGregorian(2014, 2, 4)}}" (MakeRelationFromExprs Nothing (TupleExprs () [TupleExpr (fromList [("a",FunctionAtomExpr "fromGregorian" [NakedAtomExpr (IntegerAtom 2014),NakedAtomExpr (IntegerAtom 2),NakedAtomExpr (IntegerAtom 4)] ())])])),

18+ testPretty "relation{tuple{a bytestring(\"dGVzdGRhdGE=\")}}" (MakeRelationFromExprs Nothing (TupleExprs () [TupleExpr (fromList [("a",FunctionAtomExpr "bytestring" [NakedAtomExpr (TextAtom "dGVzdGRhdGE=")] ())])])),

19+ testPretty "relation{tuple{a t}}" (MakeRelationFromExprs Nothing (TupleExprs () [TupleExpr (fromList [("a",NakedAtomExpr (BoolAtom True))])])),

20+ testPretty "relation{tuple{a Cons 4 (Cons 5 Empty)}}" (MakeRelationFromExprs Nothing (TupleExprs () [TupleExpr (fromList [("a",ConstructedAtomExpr "Cons" [NakedAtomExpr (IntegerAtom 4),ConstructedAtomExpr "Cons" [NakedAtomExpr (IntegerAtom 5),ConstructedAtomExpr "Empty" [] ()] ()] ())])])),

21+ testPretty "relation{a Int, b Text, c Bool}{}" (MakeRelationFromExprs (Just [AttributeAndTypeNameExpr "a" (ADTypeConstructor "Int" []) (),AttributeAndTypeNameExpr "b" (ADTypeConstructor "Text" []) (),AttributeAndTypeNameExpr "c" (ADTypeConstructor "Bool" []) ()]) (TupleExprs () [])),

22+ testPretty "relation{a relation{b Int}}{}" (MakeRelationFromExprs (Just [AttributeAndTypeNameExpr "a" (RelationAtomTypeConstructor [AttributeAndTypeNameExpr "b" (ADTypeConstructor "Int" []) ()]) ()]) (TupleExprs () []))

23+ ]

24+

25+main :: IO ()

26+main = do

27+ tcounts <- runTestTT testList

28+ if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

29+

30+testPretty :: String -> RelationalExpr -> Test

31+testPretty tutdStr relExprADT =

32+ TestCase $ do

33+ let relExprStr = show (pretty relExprADT)

34+ print relExprStr

35+ roundTrip <- parseRelExpr relExprStr

36+ {-tutdIn <- parseRelExpr tutdStr

37+ print ("tutd parsed", tutdIn)-}

38+ assertEqual ("pretty ADT " <> tutdStr) tutdStr relExprStr

39+ assertEqual ("round-trip " <> tutdStr) relExprADT roundTrip

40+

41+--round trip tutoriald

42+parseRelExpr :: String -> IO RelationalExpr

43+parseRelExpr tutdStr =

44+ case parse relExprP "test" (pack tutdStr) of

45+ Left err ->

46+ assertFailure (show err)

47+ Right parsed -> pure parsed

test/scripts.hs+5−2

@@ -4,6 +4,8 @@ import TutorialD.Interpreter.Import.TutorialD

44import System.Directory

55import Data.List (isSuffixOf)

66import System.Exit

7+import qualified Data.Text as T

8+import Text.URI

810testList :: IO Test

911testList = do

@@ -20,7 +22,8 @@ main = do

2022

2123testScript :: FilePath -> Test

2224testScript tutdFile = TestCase $ do

23− eImport <- importTutorialD tutdFile

25+ fileURI <- mkURI (T.pack ("file://" <> tutdFile))

26+ eImport <- importTutorialDFromFile fileURI Nothing

2427 case eImport of

2528 Left err -> assertFailure ("tutd import failure in " ++ tutdFile ++ ": " ++ show err)

26− Right _ -> pure ()

29+ Right _ -> pure ()