f5e3e65...master · project-m36

git.iko.soy/project-m36

on master help sign in

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

since splitsnapshots

unifiedsplit

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

6 dockerimage:

7 runs-on: ubuntu-latest

8 steps:

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

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

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

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

11− with:

11+ with:

12− skip_adding_nixpkgs_channel: true

12+ nix_path: nixpkgs=channel:nixos-unstable

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

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

14− with:

14+ with:

15− name: project-m36

15+ name: project-m36

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

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

17− - run: cachix use iohk

17+ - run: cachix use iohk

18− - name: docker load

18+ - name: docker load

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

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

20− - name: docker login

20+ - name: docker login

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

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

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

22− - name: docker tag with version

23+ - name: docker tag with version

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

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

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

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

25− - name: docker tag latest

26+ - name: docker tag latest

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

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

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

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

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

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

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

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

31+

32+ stack-build:

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

34+ strategy:

35+ matrix:

36+ os: [ubuntu-latest]

37+ ghc:

38+ - ghc8.10

39+ - ghc8.8

40+ - ghc8.6

41+ include:

42+ - os: macos-latest

43+ ghc: ghc8.10

44+ env:

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

46+ steps:

47+ - uses: actions/checkout@v2

48+ - name: Cache

49+ uses: actions/cache@v1

50+ with:

51+ path: ~/.stack

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

53+ restore-keys: |

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

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

56+ - name: Fix macOS cache bug

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

58+ - name: Build

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

60+ - name: Test

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

62+ - name: HLint

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

64+ - name: Haddock

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

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

67+ with:

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

69+ path: out/

.gitignore+1

@@ -20,3 +20,4 @@ jupyter/build

20juyter/dist

21.ipynb_checkpoints

22project-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+

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

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

3* support GHC 8.10

20* support GHC 8.10

README.markdown+2−3

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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)

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

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

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

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

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

96## Development

95## Development

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.

100## Related Projects

99## Related Projects

101

100

cabal.project+7−6

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

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

2packages: project-m36.cabal

1packages: project-m36.cabal

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

5−--necessary for GHC 8.6 support :/

3+package *

4+ split-sections: True

6+--high-performance streaming library

6source-repository-package

7source-repository-package

7− type: git

8+ type: git

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

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

9− tag: f352e097fbe494ad648b4e09249f865893ae90a3

10+ tag: ac3af8749194f1788704dda8667d0b3807075cc2

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

2let

5let

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

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

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

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

5in

8in

6− pkgs.dockerTools.buildImage {

9+pkgs.dockerTools.buildImage {

7− name = "project-m36";

10+ name = "project-m36";

8− tag = "latest";

11+ tag = "latest";

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

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

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

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

14+ config = {

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

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

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

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

17+ };

13− }

18+}

docs/15_minute_tutorial.markdown+4−8

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

5## Prerequisites

7−* any Linux

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

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

9−* cabal (package downloader) installed

11## Download and Install

9## Download and Install

@@ -14,13 +12,11 @@ Run a pre-built docker image:

15```docker run -it projectm36/project-m36 tutd```

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

17−or build it yourself:

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

19```bash

17```bash

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

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

21−cabal sandbox init

22−cabal install --dependencies-only

23−cabal run tutd

19+cabal new-run tutd

24```

20```

26## Some Basic TutorialD

22## Some Basic TutorialD

@@ -32,7 +28,7 @@ Note that TutorialD is strongly-typed- no type coercions take place automaticall

32### Load the Canonical Chris Date Example

28### Load the Canonical Chris Date Example

34```

30```

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

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

36```

32```

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

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.

docs/import_export_csv.markdown+2−2

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

9### Example Export

11```

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

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

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

14```

15```

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

37S6,Samson,100,New York

38```

39```

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

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

41TutorialD (master/main): :showexpr s

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

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

docs/introduction_to_projectm36.markdown+2−2

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

52To build with stack:

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

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

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

56* Linux, macOS, or Microsoft Windows

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

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

66−Alternative building with GHC 8.4.4 or greater:

66+Alternative building with GHC 8.6.5 or greater:

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

docs/introduction_to_the_relational_algebra.markdown+1−1

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

202

203(Course Relation)

204

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

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

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

207|English 1|Steve|Room 104|

208|French 2|Bob|Room 103|

docs/reaching_out_of_the_tarpit.markdown+1−1

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

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

59```

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

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

61TutorialD (master/main): :showexpr p

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

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

docs/tutd_cheatsheet.markdown+3−1

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

48|Database Context Expression |Description |

49|------------------------------------------------------|---------------------------------------|

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|

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

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

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

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

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

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

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

21```

22−:importexample date

22+:importexample cjdate

23```

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

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

30|p|parts|

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

33+### Importing TutorialD from Other Sources

34+

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

36+

37+To import TutorialD from a file:

38+

39+```

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

41+```

42+

43+or from a web server:

44+

45+```

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

47+```

48+

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

50+

33### Types

51### Types

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

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

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

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

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

198```

216```

199

217

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

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

201

219

202```

220```

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

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

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

213

231

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

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

215

233

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

235+

236+```

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

252+```

253+

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

255+

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

257+

258+```

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

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

261+│city::Text│

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

263+│"London" │

264+│"Paris" │

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

266+```

267+

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

269+

216#### Restriction

270#### Restriction

217

271

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

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

examples/DerivingCustomTupleable.hs+4−2

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

3import ProjectM36.Tupleable.Deriving

4import ProjectM36.Atomable (Atomable)

5import Control.DeepSeq (NFData)

6−import Data.Binary (Binary)

7import Data.Text (Text)

6import Data.Text (Text)

8import GHC.Generics (Generic)

7import GHC.Generics (Generic)

8+import Codec.Winery

10newtype BlogId = BlogId { getBlogId :: Int }

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

12 deriving newtype (Num)

13+ deriving Serialise via WineryRecord BlogId

14instance NFData BlogId

15instance NFData BlogId

15−instance Binary BlogId

16instance Atomable BlogId

18data Blog = Blog

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

23 deriving stock (Show, Generic)

24 deriving (Tupleable)

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

26+ deriving Serialise via WineryRecord Blog

27data Comment = Comment

28data Comment = Comment

28 { commentAuthorName :: Text

29 { commentAuthorName :: Text

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

32 deriving stock (Show, Generic)

33 deriving stock (Show, Generic)

33 deriving (Tupleable)

34 deriving (Tupleable)

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

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

36+ deriving Serialise via WineryRecord Comment

36main :: IO ()

38main :: IO ()

37main = do

39main = do

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

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

6main :: IO ()

7main = do

8 -- 1. create a ConnectionInfo

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

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

10 -- 2. conncted to the remote database

11 eConn <- connectProjectM36 connInfo

12 case eConn of

examples/blog.hs+4−3

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

1-- a simple example of a blog schema

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

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

4import ProjectM36.Client

5import ProjectM36.Base

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

11import Data.Either

12import GHC.Generics

13−import Data.Binary

14import qualified Data.Text as T

13import qualified Data.Text as T

15import qualified Data.Text.Lazy as TL

14import qualified Data.Text.Lazy as TL

16import Data.Time.Clock

15import Data.Time.Clock

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

22#endif

21#endif

23import Data.List

22import Data.List

24import Control.Monad (when, forM_)

23import Control.Monad (when, forM_)

24+import Codec.Winery

26import Web.Scotty as S

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

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

52instance Tupleable Comment

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

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

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

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

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

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

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

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

examples/hair.hs+4−3

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

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

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

2import ProjectM36.Client

3import ProjectM36.Relation.Show.Term

4import GHC.Generics

5import Data.Text

6−import Data.Binary

7import Control.DeepSeq

6import Control.DeepSeq

8import qualified Data.Map as M

7import qualified Data.Map as M

9import qualified Data.Text.IO as TIO

8import qualified Data.Text.IO as TIO

10import Data.Proxy

9import Data.Proxy

10+import Codec.Winery

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

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

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

14+ deriving Serialise via WineryVariant Hair

15main :: IO ()

16main :: IO ()

16main = do

17main = do

examples/out_of_the_tarpit.hs+11−7

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

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

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

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

3import ProjectM36.Client

4import ProjectM36.DataTypes.Primitive

5import ProjectM36.Tupleable

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

7import ProjectM36.Error

8import Data.Either

9import GHC.Generics

10−import Data.Binary

11import Control.DeepSeq

10import Control.DeepSeq

12import qualified Data.Text as T

11import qualified Data.Text as T

13import Data.Time.Calendar

12import Data.Time.Calendar

14import Data.Proxy

13import Data.Proxy

14+import Codec.Winery

16--create various database value (atom) types

17type Price = Double

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

21type Address = T.Text

23data RoomType = Kitchen | Bathroom | LivingRoom

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

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

25+ deriving Serialise via WineryVariant RoomType

26data PriceBand = Low | Medium | High | Premium

27data PriceBand = Low | Medium | High | Premium

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

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

29+ deriving Serialise via WineryVariant PriceBand

29data AreaCode = City | Suburban | Rural

31data AreaCode = City | Suburban | Rural

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

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

33+ deriving Serialise via WineryVariant AreaCode

32data SpeedBand = VeryFastBand | FastBand | MediumBand | SlowBand

35data SpeedBand = VeryFastBand | FastBand | MediumBand | SlowBand

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

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

37+ deriving Serialise via WineryVariant SpeedBand

35main :: IO ()

39main :: IO ()

36main = do

40main = do

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

257 [] -> pure (rights eErrs)

261 [] -> pure (rights eErrs)

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

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

259

263

260−

264+

examples/out_of_the_tarpit.tutd+4−4

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

3data Address = Address Text

4data Agent = Agent Text

5data Name = Name Text

6−data Price = Price Double

6+data Price = Price Integer --dollars

7data RoomType = Kitchen | Bathroom | LivingRoom

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

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

9data AreaCode = City | Suburban | Rural

10data SpeedBand = VeryFast | Fast | Medium | Slow

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

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

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

59--3. group and count sub-relation and restrict by greater than 50

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

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

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

64-- sample data

jupyter/TutorialD Notebook Walkthrough.ipynb+1−1

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

38 }

39 ],

40 "source": [

41− ":importexample date"

41+ ":importexample cjdate"

42 ]

43 },

44 {

nix/sources.jsonnew file+50

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

1+{

2+ "curryer": {

3+ "branch": "master",

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

5+ "homepage": null,

6+ "owner": "agentm",

7+ "repo": "curryer",

8+ "rev": "74ecaac619ad1165a4517d5c0f4e530493bda130",

9+ "sha256": "1izdvzj00k0y76ixm7dfgvq2fzphb8h4nzqgwkl3p0bg0806rsn1",

10+ "type": "tarball",

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

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

13+ },

14+ "niv": {

15+ "branch": "master",

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

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

18+ "owner": "nmattia",

19+ "repo": "niv",

20+ "rev": "1819632b5823e0527da28ad82fecd6be5136c1e9",

21+ "sha256": "08jz17756qchq0zrqmapcm33nr4ms9f630mycc06i6zkfwl5yh5i",

22+ "type": "tarball",

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

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

25+ },

26+ "nixpkgs": {

27+ "branch": "master",

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

29+ "homepage": "",

30+ "owner": "NixOS",

31+ "repo": "nixpkgs",

32+ "rev": "429c23aad0fce9ef38b0e60d55d7459c19d53ddc",

33+ "sha256": "1nj8sh1fnxp07jdlvjkijwfd1pnsi2zj0ivy7a0dhx02g63byhg3",

34+ "type": "tarball",

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

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

37+ },

38+ "streamly": {

39+ "branch": "ac3af8749194f1788704dda8667d0b3807075cc2",

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

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

42+ "owner": "composewell",

43+ "repo": "streamly",

44+ "rev": "ac3af8749194f1788704dda8667d0b3807075cc2",

45+ "sha256": "04d8fk654vawdfs0dfidmq2awwgwi8x44iv8r7vqz70zkcsd5fij",

46+ "type": "tarball",

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

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

49+ }

50+}

nix/sources.nixnew file+171

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

1+# This file has been generated by Niv.

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+110−155

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

1+Cabal-Version: 2.2

1Name: project-m36

2Name: project-m36

2−Version: 0.8.1

3+Version: 0.9.3

3−License: PublicDomain

4+License: MIT

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

4Build-Type: Simple

6Build-Type: Simple

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

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

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

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

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

8Stability: experimental

10Stability: experimental

9Category: Relational Algebra

11Category: Relational Algebra

10Maintainer: agentm@themactionfaction.com

12Maintainer: agentm@themactionfaction.com

11−Cabal-Version: >= 1.10

12Synopsis: Relational Algebra Engine

13Synopsis: Relational Algebra Engine

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

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

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

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

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

34 Default: True

35 Default: True

36Library

37Library

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, binary, filepath, zlib, directory, vector-binary-instances, temporary, stm, time, hashable-time, old-locale, rset, attoparsec, either, base64-bytestring, data-interval, extended-reals, network-transport, aeson >= 1.1, path-pieces, conduit, resourcet, http-api-data, semigroups, QuickCheck, quickcheck-instances, distributed-process-client-server >= 0.2.3, distributed-process >= 0.7.4, distributed-process-extras >= 0.3.2, distributed-process-async >= 0.2.4.1, network-transport-tcp >= 0.6.0, network-transport, list-t, stm-containers >= 0.2.15, foldl, optparse-applicative, Glob, cryptohash-sha256, text-manipulate >= 0.2.0.1 && < 0.3, vector-instances

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

38 if flag(haskell-scripting)

39 if flag(haskell-scripting)

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

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

40 CPP-Options: -DPM36_HASKELL_SCRIPTING

41 CPP-Options: -DPM36_HASKELL_SCRIPTING

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

51 ProjectM36.TransactionGraph.Merge,

52 ProjectM36.TransactionGraph.Merge,

52 ProjectM36.TransGraphRelationalExpression,

53 ProjectM36.TransGraphRelationalExpression,

53 ProjectM36.Base,

54 ProjectM36.Base,

55+ ProjectM36.Serialise.Base,

56+ ProjectM36.Serialise.Error,

54 ProjectM36.DataFrame,

57 ProjectM36.DataFrame,

55 ProjectM36.Attribute,

58 ProjectM36.Attribute,

56 ProjectM36.AttributeNames,

59 ProjectM36.AttributeNames,

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

60 ProjectM36.AtomFunction,

63 ProjectM36.AtomFunction,

61 ProjectM36.AtomFunctionError,

64 ProjectM36.AtomFunctionError,

62 ProjectM36.ScriptSession,

65 ProjectM36.ScriptSession,

66+ ProjectM36.Shortcuts,

63 ProjectM36.DatabaseContextFunction,

67 ProjectM36.DatabaseContextFunction,

64 ProjectM36.DatabaseContextFunctionError,

68 ProjectM36.DatabaseContextFunctionError,

65 ProjectM36.DatabaseContextFunctionUtils,

69 ProjectM36.DatabaseContextFunctionUtils,

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

110 ProjectM36.Server.EntryPoints,

114 ProjectM36.Server.EntryPoints,

111 ProjectM36.Server.ParseArgs,

115 ProjectM36.Server.ParseArgs,

112 ProjectM36.Server.RemoteCallTypes,

116 ProjectM36.Server.RemoteCallTypes,

117+ ProjectM36.Serialise.AtomFunctionError,

118+ ProjectM36.Serialise.DataFrame,

119+ ProjectM36.Serialise.DatabaseContextFunctionError,

120+ ProjectM36.Serialise.IsomorphicSchema,

113 ProjectM36.Session,

121 ProjectM36.Session,

114 ProjectM36.Sessions,

122 ProjectM36.Sessions,

115 ProjectM36.Transaction.Persist,

123 ProjectM36.Transaction.Persist,

@@ -128,14 +136,14 @@ Library

128 Other-Modules: ProjectM36.Win32Handle

136 Other-Modules: ProjectM36.Win32Handle

129 else

137 else

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

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

131− GHC-Options: -rdynamic

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

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

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

133 Build-Depends: unix

141 Build-Depends: unix

134 CC-Options: -fPIC

142 CC-Options: -fPIC

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

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

136 Default-Language: Haskell2010

144 Default-Language: Haskell2010

137 Default-Extensions: OverloadedStrings, CPP

145 Default-Extensions: OverloadedStrings, CPP

138− if !flag(stack)

146+ if !flag(stack)

139 Build-Depends: deferred-folds

147 Build-Depends: deferred-folds

140

148

141Executable tutd

149Executable tutd

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

155 MonadRandom, MonadRandom,

163 MonadRandom, MonadRandom,

156 vector,

164 vector,

157 text,

165 text,

158− vector-binary-instances,

159 time,

166 time,

160 hashable-time,

167 hashable-time,

161 bytestring,

168 bytestring,

162 stm,

169 stm,

163 deepseq,

170 deepseq,

164− binary,

165 data-interval,

171 data-interval,

166 parallel,

172 parallel,

167 cassava,

173 cassava,

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

169 directory,

175 directory,

170 filepath,

176 filepath,

171 temporary,

177 temporary,

172− megaparsec >= 5.2.0 && < 9,

178+ megaparsec >= 5.2.0 && < 10,

173 haskeline,

179 haskeline,

174 random, MonadRandom,

180 random, MonadRandom,

175 base64-bytestring,

181 base64-bytestring,

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

178 stm-containers >= 1.0.0,

184 stm-containers >= 1.0.0,

179 list-t,

185 list-t,

180 parser-combinators,

186 parser-combinators,

187+ curryer-rpc,

181− prettyprinter

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

182 Other-Modules: TutorialD.Interpreter,

195 Other-Modules: TutorialD.Interpreter,

183 TutorialD.Interpreter.Base,

196 TutorialD.Interpreter.Base,

184 TutorialD.Interpreter.DatabaseContextExpr,

197 TutorialD.Interpreter.DatabaseContextExpr,

@@ -210,9 +223,8 @@ Executable project-m36-server

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

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

211 Build-Depends: base,

224 Build-Depends: base,

212 ghc-paths,

225 ghc-paths,

213− project-m36,

214− binary,

215 transformers,

226 transformers,

227+ project-m36,

216 temporary,

228 temporary,

217 data-interval,

229 data-interval,

218 deepseq,

230 deepseq,

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

225 optparse-applicative,

237 optparse-applicative,

226 hashable-time,

238 hashable-time,

227 time,

239 time,

228− vector-binary-instances,

229 text,

240 text,

230 deepseq-generics,

241 deepseq-generics,

231 mtl,

242 mtl,

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

247Executable bigrel

258Executable bigrel

248 Default-Language: Haskell2010

259 Default-Language: Haskell2010

249 Default-Extensions: OverloadedStrings

260 Default-Extensions: OverloadedStrings

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

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

251 Other-Modules: TutorialD.Interpreter.Base,

262 Other-Modules: TutorialD.Interpreter.Base,

252 TutorialD.Interpreter.DatabaseContextExpr,

263 TutorialD.Interpreter.DatabaseContextExpr,

253 TutorialD.Interpreter.RelationalExpr,

264 TutorialD.Interpreter.RelationalExpr,

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

258 if flag(profiler)

269 if flag(profiler)

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

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

260

271

272+Common commontest

273+ Default-Language: Haskell2010

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

275+ Default-Extensions: OverloadedStrings

276+ GHC-Options: -Wall -threaded

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

278+

261Benchmark basic-benchmark

279Benchmark basic-benchmark

262 Default-Language: Haskell2010

280 Default-Language: Haskell2010

263 Default-Extensions: OverloadedStrings

281 Default-Extensions: OverloadedStrings

@@ -269,157 +287,131 @@ Benchmark basic-benchmark

269 if flag(profiler)

287 if flag(profiler)

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

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

271

289

290+--benchmark inserts, updates, deletes for a basic use-case to shake out any space leaks

291+Benchmark update-exprs

292+ Default-Language: Haskell2010

293+ Default-Extensions: OverloadedStrings

294+ Build-Depends: base, criterion, project-m36, text, winery

295+ Main-Is: benchmark/Server.hs

296+ Type: exitcode-stdio-1.0

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

298+ HS-Source-Dirs: ./src/bin

299+ if flag(profiler)

300+ GHC-Prof-Options: -fprof-auto -rtsopts -threaded -Wall -fexternal-interpreter

301+

272Test-Suite test-tutoriald

302Test-Suite test-tutoriald

273− Default-Language: Haskell2010

303+ import: commontest

274− Default-Extensions: OverloadedStrings

275 type: exitcode-stdio-1.0

304 type: exitcode-stdio-1.0

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

305+ main-is: TutorialD/InterpreterTest.hs

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

278 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

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

279− GHC-Options: -Wall -threaded

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

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

281

308

282Test-Suite test-tutoriald-atomfunctionscript

309Test-Suite test-tutoriald-atomfunctionscript

283− Default-Language: Haskell2010

310+ import: commontest

284− Default-Extensions: OverloadedStrings

285 type: exitcode-stdio-1.0

311 type: exitcode-stdio-1.0

286 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

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

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

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

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

289− GHC-Options: -Wall -threaded

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

291

314

292Test-Suite test-tutoriald-databasecontextfunctionscript

315Test-Suite test-tutoriald-databasecontextfunctionscript

293− Default-Language: Haskell2010

316+ import: commontest

294− Default-Extensions: OverloadedStrings

295 type: exitcode-stdio-1.0

317 type: exitcode-stdio-1.0

296 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

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

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

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

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

299− GHC-Options: -Wall -threaded

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

301

320

302Test-Suite test-relation

321Test-Suite test-relation

303− Default-Language: Haskell2010

322+ import: commontest

304− Default-Extensions: OverloadedStrings

305 type: exitcode-stdio-1.0

323 type: exitcode-stdio-1.0

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

324+ main-is: Relation/Basic.hs

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

308− GHC-Options: -Wall -threaded

309

325

310Test-Suite test-static-optimizer

326Test-Suite test-static-optimizer

311− Default-Language: Haskell2010

327+ import: commontest

312− Default-Extensions: OverloadedStrings

313 type: exitcode-stdio-1.0

328 type: exitcode-stdio-1.0

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

329+ main-is: Relation/StaticOptimizer.hs

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

316− GHC-Options: -Wall -threaded

317

330

318Test-Suite test-transactiongraph-persist

331Test-Suite test-transactiongraph-persist

319− Default-Language: Haskell2010

332+ import: commontest

320− Default-Extensions: OverloadedStrings

321 type: exitcode-stdio-1.0

333 type: exitcode-stdio-1.0

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

334+ main-is: TransactionGraph/Persist.hs

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

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

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

325− Hs-Source-Dirs: ., ./src/bin

326− GHC-Options: -Wall -threaded

327

336

328Test-Suite test-relation-import-csv

337Test-Suite test-relation-import-csv

329− Default-Language: Haskell2010

338+ import: commontest

330− Default-Extensions: OverloadedStrings

331 type: exitcode-stdio-1.0

339 type: exitcode-stdio-1.0

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

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

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

334− GHC-Options: -Wall -threaded

335

341

336Test-Suite test-tutoriald-import-tutoriald

342Test-Suite test-tutoriald-import-tutoriald

337− Default-Language: Haskell2010

343+ import: commontest

338− Default-Extensions: OverloadedStrings

339 type: exitcode-stdio-1.0

344 type: exitcode-stdio-1.0

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

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

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

342 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

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

343− GHC-Options: -Wall -threaded

344− Hs-Source-Dirs: ., ./src/bin

345

347

346Test-Suite test-relation-export-csv

348Test-Suite test-relation-export-csv

347− Default-Language: Haskell2010

349+ import: commontest

348− Default-Extensions: OverloadedStrings

349 type: exitcode-stdio-1.0

350 type: exitcode-stdio-1.0

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

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

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

352− GHC-Options: -Wall -threaded

353

352

354Test-Suite test-transactiongraph-merge

353Test-Suite test-transactiongraph-merge

355− Default-Language: Haskell2010

354+ import: commontest

356− Default-Extensions: OverloadedStrings

357 type: exitcode-stdio-1.0

355 type: exitcode-stdio-1.0

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

356+ main-is: TransactionGraph/Merge.hs

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

357+

360− GHC-Options: -Wall -threaded

361

358

362Test-Suite test-prettyprinter

359Test-Suite test-prettyprinter

363− Default-Language: Haskell2010

360+ import: commontest

364− Default-Extensions: OverloadedStrings

365 type: exitcode-stdio-1.0

361 type: exitcode-stdio-1.0

366− main-is: test/TutorialD/Printer.hs

362+ main-is: TutorialD/PrinterTest.hs

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

368− GHC-Options: -Wall -threaded

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

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

370− Hs-Source-Dirs: ., ./src/bin

371

364

372benchmark bench

365benchmark bench

373− Default-Language: Haskell2010

366+ import: commontest

374− Default-Extensions: OverloadedStrings

375 type: exitcode-stdio-1.0

367 type: exitcode-stdio-1.0

376 main-is: benchmark/Relation.hs

368 main-is: benchmark/Relation.hs

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

378− GHC-Options: -Wall -rtsopts -threaded

379− Hs-Source-Dirs: ./src/bin

380

369

381Test-Suite test-server

370Test-Suite test-server

382− Default-Language: Haskell2010

371+ import: commontest

383− Default-Extensions: OverloadedStrings

384 type: exitcode-stdio-1.0

372 type: exitcode-stdio-1.0

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

373+ main-is: Server/Main.hs

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

374+

387− HS-Source-Dirs: ., ./src/bin

388− GHC-Options: -Wall -threaded

389

375

390Executable Example-SimpleClient

376Executable Example-SimpleClient

391 Default-Language: Haskell2010

377 Default-Language: Haskell2010

392 Default-Extensions: OverloadedStrings

378 Default-Extensions: OverloadedStrings

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

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

394 Main-Is: examples/SimpleClient.hs

380 Main-Is: examples/SimpleClient.hs

395 GHC-Options: -Wall -threaded

381 GHC-Options: -Wall -threaded

396

382

397Executable Example-OutOfTheTarpit

383Executable Example-OutOfTheTarpit

398 Default-Language: Haskell2010

384 Default-Language: Haskell2010

399 Default-Extensions: OverloadedStrings

385 Default-Extensions: OverloadedStrings

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

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

401 Main-Is: examples/out_of_the_tarpit.hs

387 Main-Is: examples/out_of_the_tarpit.hs

402 GHC-Options: -Wall -threaded

388 GHC-Options: -Wall -threaded

403

389

404Executable Example-Blog

390Executable Example-Blog

405 Default-Language: Haskell2010

391 Default-Language: Haskell2010

406 Default-Extensions: OverloadedStrings

392 Default-Extensions: OverloadedStrings

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

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

408 Main-Is: examples/blog.hs

394 Main-Is: examples/blog.hs

409 GHC-Options: -Wall -threaded

395 GHC-Options: -Wall -threaded

410

396

411−

412Executable Example-Hair

397Executable Example-Hair

413 Default-Language: Haskell2010

398 Default-Language: Haskell2010

414 Default-Extensions: OverloadedStrings

399 Default-Extensions: OverloadedStrings

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

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

416 Main-Is: examples/hair.hs

401 Main-Is: examples/hair.hs

417 GHC-Options: -Wall -threaded

402 GHC-Options: -Wall -threaded

418

403

404+Executable Example-Plantfarm

405+ Default-Language: Haskell2010

406+ Default-Extensions: OverloadedStrings

407+ Build-Depends: aeson, barbies, base, binary, containers, deepseq, hashable, project-m36, random, scotty, text, winery

408+ Main-Is: examples/Plantfarm.hs

409+ GHC-Options: -Wall -threaded

410+

419Executable Example-CustomTupleable

411Executable Example-CustomTupleable

420 Default-Language: Haskell2010

412 Default-Language: Haskell2010

421 Default-Extensions: OverloadedStrings

413 Default-Extensions: OverloadedStrings

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

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

423 Main-Is: examples/CustomTupleable.hs

415 Main-Is: examples/CustomTupleable.hs

424 GHC-Options: -Wall -threaded

416 GHC-Options: -Wall -threaded

425

417

@@ -429,102 +421,68 @@ Executable Example-DerivingCustomTupleable

429 else

421 else

430 Buildable: False

422 Buildable: False

431 Default-Language: Haskell2010

423 Default-Language: Haskell2010

432− Build-Depends: base, text, deepseq, binary, project-m36

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

433 Main-Is: examples/DerivingCustomTupleable.hs

425 Main-Is: examples/DerivingCustomTupleable.hs

434 GHC-Options: -Wall -threaded

426 GHC-Options: -Wall -threaded

435

427

436Test-Suite test-scripts

428Test-Suite test-scripts

437− Default-Language: Haskell2010

429+ import: commontest

438− Default-Extensions: OverloadedStrings

439 type: exitcode-stdio-1.0

430 type: exitcode-stdio-1.0

440− main-is: test/scripts.hs

431+ main-is: scripts.hs

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

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

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

443− GHC-Options: -Wall -threaded

444− Hs-Source-Dirs: ., ./src/bin

445

433

446Executable project-m36-websocket-server

434Executable project-m36-websocket-server

447 Default-Language: Haskell2010

435 Default-Language: Haskell2010

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

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

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

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

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

451 GHC-Options: -Wall -threaded

439 GHC-Options: -Wall -threaded

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

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

453 Default-Extensions: OverloadedStrings

441 Default-Extensions: OverloadedStrings

454

442

455Test-Suite test-websocket-server

443Test-Suite test-websocket-server

456− Default-Language: Haskell2010

444+ import: commontest

457 type: exitcode-stdio-1.0

445 type: exitcode-stdio-1.0

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

446+ main-is: Server/WebSocket.hs

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

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

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

461− Default-Extensions: OverloadedStrings

462− GHC-Options: -Wall -threaded

463− Hs-Source-Dirs: ./src/bin, .

464

448

465Test-Suite test-isomorphic-schemas

449Test-Suite test-isomorphic-schemas

466− Default-Language: Haskell2010

450+ import: commontest

467 type: exitcode-stdio-1.0

451 type: exitcode-stdio-1.0

468− main-is: test/IsomorphicSchema.hs

452+ main-is: IsomorphicSchema.hs

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

470− Default-Extensions: OverloadedStrings

471− GHC-Options: -Wall -threaded

472− Hs-Source-Dirs: ./src/bin, .

473− Other-Modules: TutorialD.Printer

474

453

475Test-Suite test-atomable

454Test-Suite test-atomable

476− Default-Language: Haskell2010

455+ import: commontest

477 type: exitcode-stdio-1.0

456 type: exitcode-stdio-1.0

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

457+ main-is: Relation/Atomable.hs

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

480 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

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

481− Default-Extensions: OverloadedStrings

482− GHC-Options: -Wall -threaded

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

484

459

485Test-Suite test-multiprocess-access

460Test-Suite test-multiprocess-access

486− Default-Language: Haskell2010

461+ import: commontest

487 type: exitcode-stdio-1.0

462 type: exitcode-stdio-1.0

488− main-is: test/MultiProcessDatabaseAccess.hs

463+ main-is: MultiProcessDatabaseAccess.hs

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

490− Default-Extensions: OverloadedStrings

491− GHC-Options: -Wall -threaded

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

493

464

494Test-Suite test-transactiongraph-automerge

465Test-Suite test-transactiongraph-automerge

495− Default-Language: Haskell2010

466+ import: commontest

496 type: exitcode-stdio-1.0

467 type: exitcode-stdio-1.0

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

468+ main-is: TransactionGraph/Automerge.hs

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

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

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

500− Default-Extensions: OverloadedStrings

501− GHC-Options: -Wall -threaded

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

503

470

504Test-Suite test-tupleable

471Test-Suite test-tupleable

505− Default-Language: Haskell2010

472+ import: commontest

506 type: exitcode-stdio-1.0

473 type: exitcode-stdio-1.0

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

474+ main-is: Relation/Tupleable.hs

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

509− Default-Extensions: OverloadedStrings

510− GHC-Options: -Wall -threaded

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

512

475

513Test-Suite test-client-simple

476Test-Suite test-client-simple

514− Default-Language: Haskell2010

477+ import: commontest

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

478+ Main-Is: Client/Simple.hs

516 type: exitcode-stdio-1.0

479 type: exitcode-stdio-1.0

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

518− Default-Extensions: OverloadedStrings

519− GHC-Options: -Wall -threaded

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

521− Other-Modules: TutorialD.Printer

522

480

523-- test for file handle leaks

481-- test for file handle leaks

524Executable handles

482Executable handles

525 Default-Language: Haskell2010

483 Default-Language: Haskell2010

526 Default-Extensions: OverloadedStrings

484 Default-Extensions: OverloadedStrings

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

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

528 main-is: benchmark/Handles.hs

486 main-is: benchmark/Handles.hs

529 Other-Modules: TutorialD.Interpreter,

487 Other-Modules: TutorialD.Interpreter,

530 TutorialD.Interpreter.Base,

488 TutorialD.Interpreter.Base,

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

543 TutorialD.Interpreter.TransGraphRelationalOperator,

501 TutorialD.Interpreter.TransGraphRelationalOperator,

544 TutorialD.Interpreter.TransactionGraphOperator,

502 TutorialD.Interpreter.TransactionGraphOperator,

545 TutorialD.Interpreter.Types

503 TutorialD.Interpreter.Types

504+ TutorialD.Printer

546 GHC-Options: -Wall -threaded -rtsopts

505 GHC-Options: -Wall -threaded -rtsopts

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

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

548 if flag(profiler)

507 if flag(profiler)

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

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

550

509

551Test-Suite test-dataframe

510Test-Suite test-dataframe

552− Default-Language: Haskell2010

511+ import: commontest

553− Main-Is: test/DataFrame.hs

554 type: exitcode-stdio-1.0

512 type: exitcode-stdio-1.0

513+ Main-Is: DataFrame.hs

555 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

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

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

557− Default-Extensions: OverloadedStrings

558− GHC-Options: -Wall -threaded

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

release.nix+17−94

@@ -1,107 +1,30 @@

1−{ compiler ? "ghc865"

1+{ compiler ? "ghc8104"

2−, pkgs ? import ./pkgs.nix

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

3+, pkgs ? import sources.nixpkgs { }

3}:

4}:

4−

5let

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

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

8 doJailbreak = pkgs.haskell.lib.doJailbreak;

6 doJailbreak = pkgs.haskell.lib.doJailbreak;

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

7+ needsCocoa = drv:

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

8+ if pkgs.stdenv.isDarwin

11− #distributed-process packages are no longer maintained- until we replace it entirely, add some hacks to build on newer GHC and packages

9+ then drv.overrideDerivation (old:

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

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

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

11+ )

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

12+ else drv;

15− in

13+

16− haskellPackages.callCabal2nixWithOptions pkg (pkgs.fetchzip {

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

18− inherit sha256;

19− }) options;

20−

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

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

22 overrides = self: super: {

15 overrides = self: super: {

23− distributed-process-extras =

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

24− distProcessPkg (self.callHackageDirect {

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

25− pkg = "distributed-process-extras";

26− ver = "0.3.5";

27− sha256 = "13clq3alymcvknp7q8gz0i1hzx8im855lzmyrfffl8gglnlbi2w9";

28− }{});

29−

30− distributed-process-client-server =

31− distProcessPkg (self.callHackageDirect {

32− pkg = "distributed-process-client-server";

33− ver = "0.2.5.1";

34− sha256 = "0gkd8awapq7vy14vpnzawnwb67jvvcjaqg7imm0bp1wb6rw6x5x4";

35− }{});

36−

37− distributed-process-async =

38− distProcessPkg (callHackageDirectWithOptions {

39− pkg = "distributed-process-async";

40− ver = "0.2.6";

41− sha256 = "15wyfq115r6xjaz1h00sjh1v0fv498kkxr3xx6w84d8wdp2gxbn1";

42− options = "--no-check";

43− }{});

44−

45− distributed-process =

46− dontHaddock (self.callCabal2nix "distributed-process" (pkgs.fetchFromGitHub {

47− owner = "agentm";

48− repo = "distributed-process";

49− rev = "f352e097fbe494ad648b4e09249f865893ae90a3";

50− sha256 = "0xa2v77c9idmi89bky2wq1fykrn8grpk4rk7gcd5bkicxvdbcrym";}){});

51−

52− distributed-static =

53− self.callHackageDirect {

54− pkg = "distributed-static";

55− ver = "0.3.9";

56− sha256 = "0hibpzqwklnq335m7fwgk1bghz0lgxnd7ym10pbvxlcf7ly3nr6v";

57−}{};

58− rank1dynamic =

59− distProcessPkg (self.callHackageDirect {

60− pkg = "rank1dynamic";

61− ver = "0.4.0";

62− sha256 = "1x6p9z53s7xwp93jp4n1lq6m5xspcn6w62p461v8vqnp9600328b";

63−}{});

64− stm-hamt =

65− self.callHackageDirect {

66− pkg = "stm-hamt";

67− ver = "1.2.0.3";

68− sha256 = "1i8j7q8nhx3l7gydrjlsyhkvllr6bppgrjf0hp38zpm7p6xcv2bb";

69− }{};

70−

71− stm-containers =

72− self.callHackageDirect {

73− pkg = "stm-containers";

74− ver = "1.1.0.4";

75− sha256 = "0h9z6lawdm44minx9spvdb7sp645l36ri5cnxvhrcxwzr64s7qb5";

76− }{};

77−

78− network-transport-tcp =

79− dontCheck (self.callHackageDirect {

80− pkg = "network-transport-tcp";

81− ver = "0.7.0";

82− sha256 = "0kfzrcynf34xsxx4rccg4qfy7jvinwqd8baian8ifqad9lfcapsb";

83− }{});

84−

85− data-interval =

86− self.callHackageDirect {

87− pkg = "data-interval";

88− ver = "2.0.1";

89− sha256 = "085j4yjr8wimxampxqdrg47p577whwg2mjxgfdl44yfck52fb6an";

90− }{};

91−

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

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

93−

94 };

19 };

95 };

20 };

96−

97− project = haskellPackages.project-m36;

98in

21in

99{

22{

100− project = project;

23+ project = haskellPackages.project-m36;

101

102 shell = haskellPackages.shellFor {

25 shell = haskellPackages.shellFor {

103− packages = p: with p; [

26+ packages = p: [

104− project

27+ p.project-m36

105 ];

28 ];

106 buildInputs = [

29 buildInputs = [

107 haskellPackages.ghcid

30 haskellPackages.ghcid

@@ -110,4 +33,4 @@ in

110 ];

33 ];

111 withHoogle = true;

34 withHoogle = true;

112 };

35 };

113−}

36+}

scripts/DateExamples.tutd+2−2

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

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

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

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

23−key s_pkey {s#} s

23+key s_pkey {s#} s;

24−key p_key {p#} p

24+key p_key {p#} p;

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

26foreign key p_sp_fk sp{p#} in p{p#};

scripts/multiline.tutdnew file+2

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

1+x:=relation{

2+tuple{ x 2}} -- nice

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

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

11import ProjectM36.IsomorphicSchema

12import ProjectM36.Server.RemoteCallTypes

13import ProjectM36.MerkleHash

14+import ProjectM36.Attribute as A

15import Data.Aeson

16import Data.Aeson

16import Data.ByteString.Base64 as B64

17import Data.ByteString.Base64 as B64

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

44instance ToJSON Relation

45instance ToJSON Relation

45instance FromJSON Relation

46instance FromJSON Relation

47−instance ToJSON Attribute

48+instance ToJSON Attribute where

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

50+ , "type" .= toJSON aType ]

48−instance FromJSON Attribute

51+instance FromJSON Attribute where

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

50instance ToJSON ExtendTupleExpr

54instance ToJSON ExtendTupleExpr

51instance FromJSON ExtendTupleExpr

55instance FromJSON ExtendTupleExpr

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

99 "val" .= i ]

103 "val" .= i ]

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

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

101 "val" .= i ]

105 "val" .= i ]

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

107+ "val" .= i ]

102 toJSON (ConstructedAtom dConsName atomtype atomlist) = object [

108 toJSON (ConstructedAtom dConsName atomtype atomlist) = object [

103 "dataconstructorname" .= dConsName,

109 "dataconstructorname" .= dConsName,

104 "type" .= toJSON atomtype,

110 "type" .= toJSON atomtype,

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

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

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

127 Right bs -> pure (ByteStringAtom bs)

133 Right bs -> pure (ByteStringAtom bs)

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

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

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

129

136

130instance ToJSON Notification

137instance ToJSON Notification

131instance FromJSON Notification

138instance FromJSON Notification

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

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

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

143 Right bs -> pure (MerkleHash bs)

150 Right bs -> pure (MerkleHash bs)

144

151

152+instance ToJSON Attributes where

153+ toJSON attrs = object ["attributes" .= map toJSON (A.toList attrs)]

154+instance FromJSON Attributes where

155+ parseJSON = withObject "Attributes" $ \o ->

156+ A.attributesFromList <$> o .: "attributes"

157+

145instance ToJSON RelationalError

158instance ToJSON RelationalError

146instance FromJSON RelationalError

159instance FromJSON RelationalError

147

160

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

151instance ToJSON MergeError

164instance ToJSON MergeError

152instance FromJSON MergeError

165instance FromJSON MergeError

153

166

167+instance ToJSON ImportError'

168+instance FromJSON ImportError'

169+

154instance ToJSON DatabaseContextFunctionError

170instance ToJSON DatabaseContextFunctionError

155instance FromJSON DatabaseContextFunctionError

171instance FromJSON DatabaseContextFunctionError

156

172

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

165

181

166instance ToJSON WithNameExpr

182instance ToJSON WithNameExpr

167instance FromJSON WithNameExpr

183instance FromJSON WithNameExpr

184+

185+

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

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

22import Control.Applicative

23import Text.Megaparsec.Error

24import Data.Functor

25+import Data.Either (fromRight)

26#if MIN_VERSION_megaparsec(7,0,0)

27#if MIN_VERSION_megaparsec(7,0,0)

27import Data.List.NonEmpty as NE

28import Data.List.NonEmpty as NE

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

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

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

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

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

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

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

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

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

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

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

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

117promptInfo sessionId conn = do

118promptInfo sessionId conn = do

118 eHeadName <- headName sessionId conn

119 eHeadName <- headName sessionId conn

119 eSchemaName <- currentSchemaName sessionId conn

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

121

122

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

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

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

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

src/bin/ProjectM36/Server/WebSocket/websocket-client.html+1−1

@@ -126,7 +126,7 @@ margin-bottom: 5pt;

126 <li>:showrelvars</li>

127 <li>:showexpr true</li>

128 <li>:showexpr false</li>

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

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

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

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

132 <li>:showexpr s</li>

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

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

1{-# LANGUAGE CPP #-}

2−import ProjectM36.Server.WebSocket

3−import ProjectM36.Server.Config

4−import ProjectM36.Server.ParseArgs

5−import ProjectM36.Server

6−import Control.Concurrent

7−import qualified Network.WebSockets as WS

8−

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

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

11−#else

12−import Network.Transport.TCP (decodeEndPointAddress)

13−#endif

3+import Control.Concurrent

15import Control.Exception

4import Control.Exception

5+import Control.Monad (when)

6+import Data.Maybe (isJust)

7+import Data.String (fromString)

8+import Network.HTTP.Types (status400)

9+import Network.Socket

10+import Network.Wai (Application, responseLBS)

11+import Network.Wai.Handler.Warp

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

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

14+import Network.WebSockets (defaultConnectionOptions)

15+import ProjectM36.Server

16+import ProjectM36.Server.Config

17+import ProjectM36.Server.ParseArgs

18+import ProjectM36.Server.WebSocket

17main :: IO ()

20main :: IO ()

18main = do

21main = do

19 -- launch normal project-m36-server

22 -- launch normal project-m36-server

20 addressMVar <- newEmptyMVar

23 addressMVar <- newEmptyMVar

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

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

25+

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

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

27+ let serverConfig = wsServerConfig wsConfig

23− let wsHost = bindHost serverConfig

28+ wsHost = bindHost serverConfig

24 wsPort = bindPort serverConfig

29 wsPort = bindPort serverConfig

25 serverHost = "127.0.0.1"

30 serverHost = "127.0.0.1"

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

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

32+ configCertificateFile = tlsCertificatePath wsConfig

33+ configKeyFile = tlsKeyPath wsConfig

34+

35+ when (isJust configCertificateFile /= isJust configKeyFile) $

36+ throwIO $ ErrorCall "TLS_CERTIFICATE_PATH and TLS_KEY_PATH must be set in tandem"

37+

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

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

28 --wait for server to be listening

39 --wait for server to be listening

29− address <- takeMVar addressMVar

40+ addr <- takeMVar addressMVar

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

41+ let port =

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

42+ case addr of

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

43+ SockAddrInet port' _ -> fromIntegral port'

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

45+ wsApp = websocketProxyServer port serverHost

46+ waiApp = WS.websocketsOr defaultConnectionOptions wsApp backupApp

47+ settings = warpSettings wsHost (fromIntegral wsPort)

48+

49+ case (configCertificateFile, configKeyFile) of

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

51+ _ -> runSettings settings waiApp

52+

53+backupApp :: Application

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

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

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

34import Data.List (isPrefixOf)

35import Control.Exception

36import System.Exit

37+import Data.Either (fromRight)

38{-

39{-

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

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

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

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

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

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

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

79 where

80 where

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

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

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

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

83parseTutorialD = parse interpreterParserP ""

84parseTutorialD = parse interpreterParserP ""

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

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

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

216 barf :: RelationalError -> IO TutorialDOperatorResult

217 barf :: RelationalError -> IO TutorialDOperatorResult

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

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

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

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

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

219 eHandler io = do

221 eHandler io = do

220 eErr <- io

222 eErr <- io

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

227type CheckFS = Bool

229type CheckFS = Bool

228

230

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

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

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

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

231

233

232outputNotificationCallback :: C.NotificationCallback

234outputNotificationCallback :: C.NotificationCallback

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

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

src/bin/TutorialD/Interpreter/Base.hs+21−6

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

12 where

13import ProjectM36.Base

14import ProjectM36.AtomType

15+import ProjectM36.Attribute as A

15import ProjectM36.Relation

16import ProjectM36.Relation

16import ProjectM36.DataFrame

17import ProjectM36.DataFrame

18#if MIN_VERSION_megaparsec(6,0,0)

19#if MIN_VERSION_megaparsec(6,0,0)

19−import Text.Megaparsec.Char

20+import Text.Megaparsec.Char

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

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

21import Text.Megaparsec

22import Text.Megaparsec

22import Data.Void

23import Data.Void

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

30import System.Random

31import System.Random

31import qualified Data.Text as T

32import qualified Data.Text as T

32import qualified Data.List as L

33import qualified Data.List as L

33−import qualified Data.Vector as V

34import qualified Data.Text.IO as TIO

35import System.IO

36import ProjectM36.Relation.Show.Term

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

44import Data.Time.Clock

45import Data.Time.Format

46import Control.Monad (void)

47+import Data.Char

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

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

49anySingle :: Parsec Void Text (Token Text)

50anySingle :: Parsec Void Text (Token Text)

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

81type ParseStr = String

82type ParseStr = String

82#endif

83#endif

85+-- consumes only horizontal spaces

84spaceConsumer :: Parser ()

86spaceConsumer :: Parser ()

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

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

87opChar :: Parser Char

89opChar :: Parser Char

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

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

@@ -135,6 +137,9 @@ arrow = symbol "->"

135semi :: Parser Text

137semi :: Parser Text

136semi = symbol ";"

138semi = symbol ";"

137

139

140+nline :: Parser Text

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

142+

138integer :: Parser Integer

143integer :: Parser Integer

139#if MIN_VERSION_megaparsec(6,0,0)

144#if MIN_VERSION_megaparsec(6,0,0)

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

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

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

150#endif

155#endif

151

156

152float :: Parser Double

157float :: Parser Double

153−float = Lex.float

158+float = Lex.float <* spaceConsumer

154

159

155capitalizedIdentifier :: Parser Text

160capitalizedIdentifier :: Parser Text

156capitalizedIdentifier =

161capitalizedIdentifier =

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

163showRelationAttributes :: Attributes -> Text

168showRelationAttributes :: Attributes -> Text

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

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

165 where

170 where

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

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

167− attrsL = V.toList attrs

172+ attrsL = A.toList attrs

168

173

169type PromptLength = Int

174type PromptLength = Int

170

175

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

200quotedString :: Parser Text

205quotedString :: Parser Text

201quotedString = try tripleQuotedString <|> normalQuotedString

206quotedString = try tripleQuotedString <|> normalQuotedString

202

207

208+quoted :: Parser a -> Parser a

209+quoted = between quote quote

210+

203uuidP :: Parser U.UUID

211uuidP :: Parser U.UUID

204uuidP = do

212uuidP = do

205 uuidStart <- count 8 hexDigitChar

213 uuidStart <- count 8 hexDigitChar

@@ -228,3 +236,10 @@ colonOp :: Text -> Parser ()

228colonOp opStr = do

236colonOp opStr = do

229 _ <- string opStr <* (void spaceChar <|> eof) <* spaceConsumer

237 _ <- string opStr <* (void spaceChar <|> eof) <* spaceConsumer

230 pure ()

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

53multilineSep = newline >> pure "\n"

55multipleDatabaseContextExprP :: Parser DatabaseContextExpr

56−multipleDatabaseContextExprP =

56+multipleDatabaseContextExprP = do

57− MultipleExpr <$> sepBy1 databaseContextExprP semi

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

58+ pure (MultipleExpr exprs)

59insertP :: Parser DatabaseContextExpr

60insertP :: Parser DatabaseContextExpr

60insertP = do

61insertP = do

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

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

2module TutorialD.Interpreter.Import.Base where

3import ProjectM36.Base

4import ProjectM36.Error

5+import Text.URI (URI)

6+import Data.Text (Text)

5#if __GLASGOW_HASKELL__ < 804

7#if __GLASGOW_HASKELL__ < 804

6import Data.Monoid

8import Data.Monoid

7#endif

9#endif

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

12instance Show RelVarDataImportOperator where

14instance Show RelVarDataImportOperator where

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

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

17+type HashVerification = Maybe Text

18+

15-- | import data into a database context

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

18instance Show DatabaseContextDataImportOperator where

22instance Show DatabaseContextDataImportOperator where

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

23+ show (DatabaseContextDataImportOperator uri hash _) =

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

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

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

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

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

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

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

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

20importBasicExampleOperatorP = do

21 reservedOp ":importexample"

22 example <- identifier

23− if example == "date" then

23+ if example == "cjdate" then

24 pure ImportBasicDateExampleOperator

25 else

26 fail "Unknown example name"

27−

27+

src/bin/TutorialD/Interpreter/Import/CSV.hs+3−3

@@ -14,10 +14,10 @@ importCSVRelation relVarName tConsMap attrs pathIn = do

14 --TODO: handle filesystem errors

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

16 case csvData of

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

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

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

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

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

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

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

22importCSVP :: Parser RelVarDataImportOperator

23importCSVP = do

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

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

9import Control.Exception

10import qualified Data.ByteString as BS

11import qualified Data.Text.Encoding as TE

12+import qualified Text.URI as URI

13+import Text.URI (URI)

14+import Crypto.Hash.SHA256

15+import Data.ByteString.Base16 as B16

16+import Network.HTTP.Simple

17+import Network.HTTP.Types

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

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

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

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

15−importTutorialD pathIn = do

21+importTutorialDFromFile fileURI mHash = do

22+ case URI.uriPath fileURI of

23+ Just (False, _) -> do

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

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

17− case eTutdBytes of

25+ case eTutdBytes of

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

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

27+ Right tutdBytes ->

28+ case validateBytes tutdBytes mHash of

29+ Left err -> pure (Left err)

19− Right tutdBytes ->

30+ Right tutdBytes' -> importTutorialDBytes tutdBytes'

31+ _ -> pure (Left (ImportError (InvalidFileURIError (URI.render fileURI))))

32+ where

33+ filePath = drop (length ("file://" :: String)) (URI.renderStr fileURI)

34+

35+

36+importTutorialDBytes :: BS.ByteString -> IO (Either RelationalError DatabaseContextExpr)

37+importTutorialDBytes tutdBytes =

20− case TE.decodeUtf8' tutdBytes of

38+ case TE.decodeUtf8' tutdBytes of

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

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

22− Right tutdUtf8 ->

40+ Right tutdUtf8 ->

23− case parse multipleDatabaseContextExprP "import" tutdUtf8 of

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

24− --parseErrorPretty is new in megaparsec 5

42+ --parseErrorPretty is new in megaparsec 5

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

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

26− Right expr -> pure (Right expr)

44+ Right expr -> pure (Right expr)

27−

45+

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

47+importTutorialDViaHTTP uri mHash = do

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

49+ response <- httpBS reqURI

50+ let scode = getResponseStatus response

51+ if scode == ok200 then

52+ let byteBody = getResponseBody response in

53+ case validateBytes byteBody mHash of

54+ Right byteBody' -> do

55+ importTutorialDBytes byteBody'

56+ Left err -> pure (Left err)

57+ else

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

59+

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

61+validateBytes tutdBytes mHash =

62+ case mHash of

63+ Nothing -> pure tutdBytes

64+ Just expectedHashText ->

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

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

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

68+ | otherwise ->

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

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

71+ where

72+ hashBytes = hash tutdBytes

73+

74+

28tutdImportP :: Parser DatabaseContextDataImportOperator

75tutdImportP :: Parser DatabaseContextDataImportOperator

29tutdImportP = do

76tutdImportP = do

30 reserved ":importtutd"

77 reserved ":importtutd"

31− path <- quotedString

78+ uri <- quoted URI.parser

32 spaceConsumer

79 spaceConsumer

80+ mhash <- optional (quoted hex)

81+ handler <- case URI.unRText <$> URI.uriScheme uri of

82+ Nothing -> fail "URI scheme missing"

83+ Just "file" -> pure importTutorialDFromFile

84+ Just scheme | scheme `elem` ["http", "https"] -> pure importTutorialDViaHTTP

85+ | otherwise -> fail ( "unsupported URI scheme: " <> show scheme)

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

86+ pure $ DatabaseContextDataImportOperator uri mhash handler

src/bin/TutorialD/Interpreter/RelationalExpr.hs+13−3

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

20attributeListP =

21 (reservedOp "all but" >>

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

23+

23 (reservedOp "all from" >>

24 (reservedOp "all from" >>

24 RelationalExprAttributeNames <$> relExprP) <|>

25 RelationalExprAttributeNames <$> relExprP) <|>

26+

27+ (reservedOp "union of" >>

28+ UnionAttributeNames <$> braces attributeListP <*> braces attributeListP) <|>

29+

30+ (reservedOp "intersection of" >>

31+ IntersectAttributeNames <$> braces attributeListP <*> braces attributeListP) <|>

32+

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

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

34+

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

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

28makeRelationP = do

37makeRelationP = do

@@ -207,6 +216,7 @@ consumeAtomExprP consume = try functionAtomExprP <|>

207 attributeAtomExprP <|>

216 attributeAtomExprP <|>

208 try nakedAtomExprP <|>

217 try nakedAtomExprP <|>

209 relationalAtomExprP

218 relationalAtomExprP

219+

210

220

211attributeAtomExprP :: Parser (AtomExprBase a)

221attributeAtomExprP :: Parser (AtomExprBase a)

212attributeAtomExprP = do

222attributeAtomExprP = do

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

225-- used only for primitive type parsing ?

235-- used only for primitive type parsing ?

226atomP :: Parser Atom

236atomP :: Parser Atom

227atomP = stringAtomP <|>

237atomP = stringAtomP <|>

228− doubleAtomP <|>

238+ try doubleAtomP <|>

229 integerAtomP <|>

239 integerAtomP <|>

230 boolAtomP

240 boolAtomP

231

241

@@ -240,7 +250,7 @@ stringAtomP :: Parser Atom

240stringAtomP = TextAtom <$> quotedString

250stringAtomP = TextAtom <$> quotedString

241

251

242doubleAtomP :: Parser Atom

252doubleAtomP :: Parser Atom

243−doubleAtomP = DoubleAtom <$> try float

253+doubleAtomP = DoubleAtom <$> float

244

254

245integerAtomP :: Parser Atom

255integerAtomP :: Parser Atom

246integerAtomP = IntegerAtom <$> integer

256integerAtomP = IntegerAtom <$> integer

src/bin/TutorialD/Printer.hs+8−10

@@ -5,7 +5,7 @@

5{-# LANGUAGE TypeApplications #-}

6module TutorialD.Printer where

7import ProjectM36.Base

8−import ProjectM36.Attribute hiding (null)

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

9import Data.Text.Prettyprint.Doc

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

11import qualified Data.Vector as V

@@ -60,9 +60,9 @@ 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))

62instance Pretty Relation where

63− pretty (Relation attrs tupSet) | attrs == V.empty && null (asList tupSet) = "false"

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

64− pretty (Relation attrs tupSet) | attrs == V.empty && asList tupSet == [RelationTuple V.empty V.empty] = "true"

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

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

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

67instance Pretty Attribute where

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

@@ -76,7 +76,7 @@ instance Pretty RelationalExpr where

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 (V.toList attrs) <> prettyBracesList (asList tupSet)

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)

@@ -107,10 +107,8 @@ 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 a = error $ show a ++ " is not implemented yet."

111−-- YuMing L.: I guess these two are used in evaluating relational expressions. So we won't be using them in pretty printer.

112−-- pretty (UnionAttributeNames aAttrNames bAttrNames) = prettyBracesList (S.toList (aAttrNames `union` bAttrNames))

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

113−-- pretty (IntersectAttributeNames aAttrNames bAttrNames) = prettyBracesList (S.toList (aAttrNames `intersection` bAttrNames))

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

114

112

115instance Pretty AttributeExpr where

113instance Pretty AttributeExpr where

116 pretty (NakedAttributeExpr attr) = pretty attr

114 pretty (NakedAttributeExpr attr) = pretty attr

@@ -132,7 +130,7 @@ instance Pretty AtomType where

132 pretty DateTimeAtomType = "DateTime"

130 pretty DateTimeAtomType = "DateTime"

133 pretty ByteStringAtomType = "ByteString"

131 pretty ByteStringAtomType = "ByteString"

134 pretty BoolAtomType = "Bool"

132 pretty BoolAtomType = "Bool"

135− pretty (RelationAtomType attrs) = "relation " <+> prettyBracesList (V.toList attrs)

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

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

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

137 pretty RelationalExprAtomType = "RelationalExpr"

135 pretty RelationalExprAtomType = "RelationalExpr"

138 pretty (TypeVariableType x) = pretty x

136 pretty (TypeVariableType x) = pretty x

src/bin/TutorialD/tutd.hs+5−18

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

23parseArgs :: Parser InterpreterConfig

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

25− RemoteInterpreterConfig <$> parseNodeId <*> parseDatabaseName <*> parseHeadName <*> parseTutDExec <*> parseCheckFS

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

27parseHeadName :: Parser HeadName

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

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

31 value "master"

32 )

34−parseNodeId :: Parser NodeId

35−parseNodeId = createNodeId <$>

36− strOption (long "host" <>

37− short 'h' <>

38− help "Remote host name" <>

39− metavar "HOSTNAME" <>

40− value "127.0.0.1") <*>

41− option auto (long "port" <>

42− metavar "PORT NUMBER" <>

43− short 'p' <>

44− help "Remote port" <>

45− value defaultServerPort)

46−

47--just execute some tutd and exit

34--just execute some tutd and exit

48parseTutDExec :: Parser (Maybe TutorialDExec)

35parseTutDExec :: Parser (Maybe TutorialDExec)

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

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

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

58connectionInfoForConfig :: InterpreterConfig -> ConnectionInfo

45connectionInfoForConfig :: InterpreterConfig -> ConnectionInfo

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

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

60−connectionInfoForConfig (RemoteInterpreterConfig remoteNodeId remoteDBName _ _ _) = RemoteProcessConnectionInfo remoteDBName remoteNodeId outputNotificationCallback

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

62headNameForConfig :: InterpreterConfig -> HeadName

49headNameForConfig :: InterpreterConfig -> HeadName

63headNameForConfig (LocalInterpreterConfig _ headn _ _ _) = headn

50headNameForConfig (LocalInterpreterConfig _ headn _ _ _) = headn

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

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

66execTutDForConfig :: InterpreterConfig -> Maybe String

53execTutDForConfig :: InterpreterConfig -> Maybe String

67execTutDForConfig (LocalInterpreterConfig _ _ t _ _) = t

54execTutDForConfig (LocalInterpreterConfig _ _ t _ _) = t

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

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

70checkFSForConfig :: InterpreterConfig -> Bool

57checkFSForConfig :: InterpreterConfig -> Bool

71checkFSForConfig (LocalInterpreterConfig _ _ _ _ c) = c

58checkFSForConfig (LocalInterpreterConfig _ _ _ _ c) = c

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

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

74persistenceStrategyForConfig :: InterpreterConfig -> Maybe PersistenceStrategy

61persistenceStrategyForConfig :: InterpreterConfig -> Maybe PersistenceStrategy

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

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

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

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

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

85arbitraryRelationTuple attris = do

86 tcMap <- ask

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

88 case sequence listOfMaybeAType of

89 Left err -> pure $ Left err

90 Right listOfAttr -> do

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

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

1{-# LANGUAGE CPP #-}

2module ProjectM36.AtomFunction where

3import ProjectM36.Base

4+import ProjectM36.Serialise.Base ()

4import ProjectM36.Error

5import ProjectM36.Error

5import ProjectM36.Relation

6import ProjectM36.Relation

6import ProjectM36.AtomType

7import ProjectM36.AtomType

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

10import qualified Data.HashSet as HS

11import qualified Data.HashSet as HS

11import qualified Data.Text as T

12import qualified Data.Text as T

12import qualified Data.ByteString.Lazy as BL

13import qualified Data.ByteString.Lazy as BL

13−import Data.Binary as B

14+import Codec.Winery

15foldAtomFuncType :: AtomType -> AtomType -> [AtomType]

16foldAtomFuncType :: AtomType -> AtomType -> [AtomType]

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

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

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

92--for calculating the merkle hash

93--for calculating the merkle hash

93hashBytes :: AtomFunction -> BL.ByteString

94hashBytes :: AtomFunction -> BL.ByteString

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

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

95− B.encode (atomFuncType func),

96+ serialise (atomFuncType func),

96− bodyBin

97+ bodyBin

97− ]

98+ ]

98 where

99 where

99 bodyBin = case atomFuncBody func of

100 bodyBin = case atomFuncBody func of

100− AtomFunctionBody mScript _ -> B.encode mScript

101+ AtomFunctionBody mScript _ -> serialise mScript

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

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

1{-# LANGUAGE DeriveGeneric, DeriveAnyClass #-}

2module ProjectM36.AtomFunctionError where

3−import Data.Binary

4import GHC.Generics

3import GHC.Generics

5import Control.DeepSeq

4import Control.DeepSeq

6import Data.Text

5import Data.Text

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

14 AtomTypeDoesNotSupportOrderingError Text |

13 AtomTypeDoesNotSupportOrderingError Text |

15 AtomTypeDoesNotSupportIntervalError Text |

14 AtomTypeDoesNotSupportIntervalError Text |

16 AtomFunctionBytesDecodingError String

15 AtomFunctionBytesDecodingError String

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

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

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

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

211

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

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

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

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

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

216

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

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

295-- Example: "Nothing" does not specify the the argument in "Maybe a", so allow delayed resolution in the tuple before it is added to the relation. Note that this resolution could cause a type error. Hardly a Hindley-Milner system.

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

297resolveTypesInTuple resolvedAttrs tConss (RelationTuple _ tupAtoms) = do

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

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

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

300

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

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

314 _ -> Right ()

315validateAtomType (RelationAtomType attrs) tConss =

316 mapM_ (\attr ->

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

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

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

319validateAtomType _ _ = pure ()

320

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

325 else

326 pure ()

327 where

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

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

329

330--ensure that all type vars are fully resolved

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

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

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

359 Left $ AtomTypeMismatchError x y

360 else

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

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

362 return x

363atomTypeVerify x y = if x == y then

364 Right x

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

375 (M.toAscList b)

376

377prettyAtomType :: AtomType -> T.Text

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

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

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

380 where

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

@@ -448,7 +448,7 @@ isResolvedType typ =

448 TypeVariableType _ -> False

449

450isResolvedAttributes :: Attributes -> Bool

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

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

452

453isResolvedAttribute :: Attribute -> Bool

454isResolvedAttribute = isResolvedType . A.atomType

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

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

13import qualified Data.Text as T

14import qualified Data.Vector as V

15import Control.DeepSeq (NFData)

16−import Data.Binary

17import Control.Applicative

16import Control.Applicative

18import Data.Time.Calendar

17import Data.Time.Calendar

19import Data.ByteString (ByteString)

18import Data.ByteString (ByteString)

20import Data.Time.Clock

19import Data.Time.Clock

21import Data.Proxy

20import Data.Proxy

22import qualified Data.List.NonEmpty as NE

21import qualified Data.List.NonEmpty as NE

22+import Codec.Winery

24−--also add haskell scripting atomable support

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

26−

27−{-

28−data Test1T = Test1C Int

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

30−

31−data Test2T = Test2C Int Int

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

33−

34−data Test3T = Test3Ca | Test3Cb

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

36−-}

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

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

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

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

39 toAtom :: a -> Atom

26 toAtom :: a -> Atom

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

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

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

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

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

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

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

166 toAddTypeExpr _ = NoOperation

153 toAddTypeExpr _ = NoOperation

167

154

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

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

170−#endif

171−

172-- Generics

155-- Generics

173class AtomableG g where

156class AtomableG g where

174 --type AtomTG g

157 --type AtomTG g

@@ -254,7 +237,7 @@ typeToTypeConstructor x@ByteStringAtomType = PrimitiveTypeConstructor "ByteStrin

254typeToTypeConstructor x@BoolAtomType = PrimitiveTypeConstructor "Bool" x

237typeToTypeConstructor x@BoolAtomType = PrimitiveTypeConstructor "Bool" x

255typeToTypeConstructor x@RelationalExprAtomType = PrimitiveTypeConstructor "RelationalExpr" x

238typeToTypeConstructor x@RelationalExprAtomType = PrimitiveTypeConstructor "RelationalExpr" x

256typeToTypeConstructor (RelationAtomType attrs)

239typeToTypeConstructor (RelationAtomType attrs)

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

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

258 where

241 where

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

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

260typeToTypeConstructor (ConstructedAtomType tcName tvMap)

243typeToTypeConstructor (ConstructedAtomType tcName tvMap)

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

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

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

1module ProjectM36.Attribute where

2module ProjectM36.Attribute where

2import ProjectM36.Base

3import ProjectM36.Base

3import ProjectM36.Error

4import ProjectM36.Error

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

10import Data.Either

11import Data.Either

12arity :: Attributes -> Int

13arity :: Attributes -> Int

13−arity = V.length

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

15+

16+instance Semigroup Attributes where

17+ attrsA <> attrsB =

18+ case joinAttributes attrsA attrsB of

19+ Left err -> error (show err)

20+ Right attrs' -> attrs'

21+

22+instance Monoid Attributes where

23+ mempty = Attributes {

24+ attributesVec = mempty

25+ --,attributeSet = mempty

26+ }

15emptyAttributes :: Attributes

28emptyAttributes :: Attributes

16−emptyAttributes = V.empty

29+emptyAttributes = mempty

18null :: Attributes -> Bool

31null :: Attributes -> Bool

19−null = V.null

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

33+

34+singleton :: Attribute -> Attributes

35+singleton attr = Attributes {

36+ attributesVec = V.singleton attr

37+ --,attributesSet = HS.singleton attr

38+ }

39+

40+toList :: Attributes -> [Attribute]

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

21attributesFromList :: [Attribute] -> Attributes

43attributesFromList :: [Attribute] -> Attributes

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

44+attributesFromList attrsL = Attributes {

45+ attributesVec = vec

46+ --,attributesSet = hset

47+ }

48+ where

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

50+ --fast path- no duplicates

51+ V.fromList attrsL

52+ else

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

54+ V.fromList uniquedL

55+ hset = HS.fromList attrsL

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

57+ if HS.member attr s then

58+ acc

59+ else

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

61+ ([],mempty) attrsL

24attributeName :: Attribute -> AttributeName

63attributeName :: Attribute -> AttributeName

25attributeName (Attribute name _) = name

64attributeName (Attribute name _) = name

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

28atomType (Attribute _ atype) = atype

67atomType (Attribute _ atype) = atype

30atomTypes :: Attributes -> V.Vector AtomType

69atomTypes :: Attributes -> V.Vector AtomType

31−atomTypes = V.map atomType

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

33atomTypesList :: Attributes -> [AtomType]

72atomTypesList :: Attributes -> [AtomType]

34atomTypesList = V.toList . atomTypes

73atomTypesList = V.toList . atomTypes

36−--hm- no error-checking here

37addAttribute :: Attribute -> Attributes -> Attributes

75addAttribute :: Attribute -> Attributes -> Attributes

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

76+addAttribute attr attrs = attrs <> singleton attr

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

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

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

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

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

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

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

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

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

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

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

47 attrNames2 = V.map attributeName attrs2

85 attrNames2 = V.map attributeName attrs2

48 uniqueOverlappingAttributes = vectorUniqueify overlappingAttributes

86 uniqueOverlappingAttributes = vectorUniqueify overlappingAttributes

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

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

88+-}

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

90+joinAttributes attrs1 attrs2

91+ | S.size overlappingNames == 0 = -- fast path, no overlapping names

92+ pure (concated id)

93+ | attributesForNames overlappingNames attrs1 == attributesForNames overlappingNames attrs2 = -- that atomtypes match

94+ pure (concated vectorUniqueify)

95+ | otherwise =

96+ --special handling to validate that overlapping names have the same atom types

97+ Left (TupleAttributeTypeMismatchError (attributesForNames overlappingNames attrs1))

98+ where

99+ nameSet1 = attributeNameSet attrs1

100+ nameSet2 = attributeNameSet attrs2

101+ overlappingNames = S.intersection nameSet1 nameSet2

102+ concated f = Attributes {

103+ attributesVec = f (attributesVec attrs1 <> attributesVec attrs2)

104+ --,attributesSet = attributesSet attrs1 <> attributesSet attrs2

105+ }

106

51addAttributes :: Attributes -> Attributes -> Attributes

107addAttributes :: Attributes -> Attributes -> Attributes

52−addAttributes = (V.++)

108+addAttributes = (<>)

109+

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

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

112

54deleteAttributeName :: AttributeName -> Attributes -> Attributes

113deleteAttributeName :: AttributeName -> Attributes -> Attributes

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

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

115+

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

117+deleteAttributeNames attrNames attrs = Attributes {

118+ attributesVec = vec

119+ }

120+ where

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

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

123

57renameAttribute :: AttributeName -> Attribute -> Attribute

124renameAttribute :: AttributeName -> Attribute -> Attribute

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

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

126

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

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

61−renameAttributes oldAttrName newAttrName = V.map renamer

128+renameAttributes oldAttrName newAttrName attrs = Attributes {

129+ attributesVec = vec

130+ }

62 where

131 where

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

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

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

64 renameAttribute newAttrName attr

134 renameAttribute newAttrName attr

65 else

135 else

66 attr

136 attr

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

71 return atype

141 return atype

142

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

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

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

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

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

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

76 Just attr -> Right attr

146 Just attr -> Right attr

147

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

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

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

160

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

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

92−attributesForNames attrNameSet = V.filter filt

162+attributesForNames attrNameSet attrs = Attributes {

163+ attributesVec = vec

164+ }

93 where

165 where

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

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

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

168

96attributeNameSet :: Attributes -> S.Set AttributeName

169attributeNameSet :: Attributes -> S.Set AttributeName

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

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

171

99attributeNames :: Attributes -> V.Vector AttributeName

172attributeNames :: Attributes -> V.Vector AttributeName

100−attributeNames = V.map attributeName

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

101

174

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

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

103attributesContained :: Attributes -> Attributes -> Bool

176attributesContained :: Attributes -> Attributes -> Bool

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

118

191

119-- useful for display

192-- useful for display

120orderedAttributes :: Attributes -> [Attribute]

193orderedAttributes :: Attributes -> [Attribute]

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

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

122

195

123orderedAttributeNames :: Attributes -> [AttributeName]

196orderedAttributeNames :: Attributes -> [AttributeName]

124orderedAttributeNames attrs = map attributeName (orderedAttributes attrs)

197orderedAttributeNames attrs = map attributeName (orderedAttributes attrs)

125

198

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

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

200+--this is the function which benefits the most from the HashSet representation- this turned up in the insert performance test

127attributesDifference :: Attributes -> Attributes -> Attributes

201attributesDifference :: Attributes -> Attributes -> Attributes

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

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

129 where

203 where

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

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

205+-}

206+attributesDifference attrsA attrsB =

207+ if attributesSet attrsA == attributesSet attrsB then

208+ mempty

209+ else

210+ Attributes {

211+ attributesVec = vec

212+ --,attributesSet = hset

213+ }

214+ where

215+ hset = HS.difference setA setB <> HS.difference setB setA

216+ setA = attributesSet attrsA

217+ setB = attributesSet attrsB

218+ vec = V.filter (`HS.member` hset) (attributesVec attrsA <> attributesVec attrsB)

131

219

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

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

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

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

134

222

135--check that each attribute only appears once

223--check that each attribute only appears once

136verifyAttributes :: Attributes -> Either RelationalError Attributes

224verifyAttributes :: Attributes -> Either RelationalError Attributes

137−verifyAttributes attrs = if collapsedAttrs /= attrs then

225+verifyAttributes attrs =

226+ if vecSet == attributesSet attrs then

227+ pure attrs

228+ else

138− Left (TupleAttributeTypeMismatchError (attributesDifference collapsedAttrs attrs))

229+ Left (TupleAttributeTypeMismatchError diffAttrs)

139− else

140− Right attrs

141 where

230 where

142− collapsedAttrs = vectorUniqueify attrs

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

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

233+ diffAttrs = Attributes {

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

235+ --,attributesSet = diffSet

236+ }

237+

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

239+--drop first n attributes from vector representation

240+drop :: Int -> Attributes -> Attributes

241+drop c attrs = Attributes { attributesVec = vec

242+ }

243+ where

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

245+

246+

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

248+attributesAndOrderEqual :: Attributes -> Attributes -> Bool

249+attributesAndOrderEqual a b = attributesVec a == attributesVec b

143

250

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

144attributesEqual :: Attributes -> Attributes -> Bool

252attributesEqual :: Attributes -> Attributes -> Bool

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

253+attributesEqual attrsA attrsB =

254+ attributesVec attrsA == attributesVec attrsB ||

255+ attributesSet attrsA == attributesSet attrsB

146

256

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

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

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

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

259+

149

260

150-- | Left-biased union of attributes.

261-- | Left-biased union of attributes.

151union :: Attributes -> Attributes -> Attributes

262union :: Attributes -> Attributes -> Attributes

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

263+union attrsA attrsB = Attributes {

264+ attributesVec = vec

265+ --,attributesSet = hset

266+ }

153 where

267 where

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

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

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

155

270

156intersection :: Attributes -> Attributes -> Attributes

271intersection :: Attributes -> Attributes -> Attributes

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

272+intersection attrsA attrsB = Attributes {

273+ attributesVec = vec

274+ --,attributesSet = hset

275+ }

158 where

276 where

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

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

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

src/lib/ProjectM36/Base.hs+58−101

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

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

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

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

4module ProjectM36.Base where

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

6import ProjectM36.AtomFunctionError

7import ProjectM36.MerkleHash

9+import Data.Functor.Foldable.TH

9import qualified Data.Map as M

10import qualified Data.Map as M

10import qualified Data.HashSet as HS

11import qualified Data.HashSet as HS

11import Data.Hashable (Hashable, hashWithSalt)

12import Data.Hashable (Hashable, hashWithSalt)

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

18import qualified Data.Vector as V

19import qualified Data.Vector as V

19import qualified Data.List as L

20import qualified Data.List as L

20import Data.Text (Text,unpack)

21import Data.Text (Text,unpack)

21−import Data.Binary

22−import Data.Vector.Binary()

23import Data.Time.Clock

22import Data.Time.Clock

24−import Data.Time.Clock.POSIX

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

26import Data.Hashable.Time ()

23import Data.Hashable.Time ()

24+import Data.Time.Calendar (Day)

27import Data.Typeable

25import Data.Typeable

28import Data.ByteString (ByteString)

26import Data.ByteString (ByteString)

29import qualified Data.List.NonEmpty as NE

27import qualified Data.List.NonEmpty as NE

30import Data.Vector.Instances ()

28import Data.Vector.Instances ()

31−import Data.Hashable.Generic

33type StringType = Text

30type StringType = Text

31+

32+type DatabaseName = String

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

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

36data Atom = IntegerAtom Integer |

35data Atom = IntegerAtom Integer |

@@ -44,7 +43,7 @@ data Atom = IntegerAtom Integer |

44 RelationAtom Relation |

43 RelationAtom Relation |

45 RelationalExprAtom RelationalExpr | --used for returning inc deps

44 RelationalExprAtom RelationalExpr | --used for returning inc deps

46 ConstructedAtom DataConstructorName AtomType [Atom]

45 ConstructedAtom DataConstructorName AtomType [Atom]

47− deriving (Eq, Show, Binary, Typeable, NFData, Generic, Read)

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

49instance Hashable Atom where

48instance Hashable Atom where

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

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

@@ -60,16 +59,6 @@ instance Hashable Atom where

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

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

61 hashWithSalt salt (RelationalExprAtom re) = salt `hashWithSalt` re

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

63−instance Binary UTCTime where

64− put utc = put $ toRational (utcTimeToPOSIXSeconds utc)

65− get = posixSecondsToUTCTime . fromRational <$> (get :: Get Rational)

66−

67−instance Binary Day where

68− put day = put $ toGregorian day

69− get = do

70− (y,m,d) <- get :: Get (Integer, Int, Int)

71− return (fromGregorian y m d)

72−

73-- I suspect the definition of ConstructedAtomType with its name alone is insufficient to disambiguate the cases; for example, one could create a type named X, remove a type named X, and re-add it using different constructors. However, as long as requests are served from only one DatabaseContext at-a-time, the type name is unambiguous. This will become a problem for time-travel, however.

62-- I suspect the definition of ConstructedAtomType with its name alone is insufficient to disambiguate the cases; for example, one could create a type named X, remove a type named X, and re-add it using different constructors. However, as long as requests are served from only one DatabaseContext at-a-time, the type name is unambiguous. This will become a problem for time-travel, however.

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

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

75data AtomType = IntAtomType |

64data AtomType = IntAtomType |

@@ -85,7 +74,7 @@ data AtomType = IntAtomType |

85 RelationalExprAtomType |

74 RelationalExprAtomType |

86 TypeVariableType TypeVarName

75 TypeVariableType TypeVarName

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

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

88− deriving (Eq, NFData, Generic, Binary, Show, Read, Hashable)

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

90instance Ord AtomType where

79instance Ord AtomType where

91 compare = undefined

80 compare = undefined

@@ -105,25 +94,37 @@ isRelationAtomType _ = False

105type AttributeName = StringType

94type AttributeName = StringType

106

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

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

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

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

109

110instance Hashable Attribute where

99instance Hashable Attribute where

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

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

112

101

102+type AttributesHash = Int

103+

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

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

105+newtype Attributes = Attributes {

114−type Attributes = V.Vector Attribute

106+ attributesVec :: V.Vector Attribute

107+ --,attributesSet :: HS.HashSet Attribute --compare with this generated in heap profile and benchmarks

108+ }

109+ deriving (NFData, Read, Hashable, Generic)

110+

111+attributesSet :: Attributes -> HS.HashSet Attribute

112+attributesSet = HS.fromList . V.toList . attributesVec

113+

114+instance Show Attributes where

115+ show attrs = "attributesFromList [" <> L.intercalate ", " (map (\attr -> "(" <> show attr <> ")") (V.toList (attributesVec attrs))) <> "]"

116+

117+--when attribute ordering is irrelevant

118+instance Eq Attributes where

119+ attrsA == attrsB =

120+ attributesVec attrsA == attributesVec attrsB ||

121+ attributesSet attrsA == attributesSet attrsB

115

122

116−-- | Equality function for a set of attributes.

117−attributesEqual :: Attributes -> Attributes -> Bool

118−attributesEqual attrs1 attrs2 = attrsAsSet attrs1 == attrsAsSet attrs2

119− where

120− attrsAsSet = HS.fromList . V.toList

121−

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

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

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

124

125

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

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

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

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

127

128

128instance Read Relation where

129instance Read Relation where

129 readsPrec = error "relation read not supported"

130 readsPrec = error "relation read not supported"

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

139instance Hashable RelationTuple where

140instance Hashable RelationTuple where

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

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

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

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

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

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

143− error "invalid tuple: attributes and tuple count mismatch"

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

144 else

145 else

145 salt `hashWithSalt`

146 salt `hashWithSalt`

146 sortedAttrs `hashWithSalt`

147 sortedAttrs `hashWithSalt`

@@ -153,23 +154,21 @@ instance Hashable RelationTuple where

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

154-- | A tuple is a set of attributes mapped to their 'Atom' values.

154data RelationTuple = RelationTuple Attributes (V.Vector Atom) deriving (Show, Read, Generic)

155data RelationTuple = RelationTuple Attributes (V.Vector Atom) deriving (Show, Read, Generic)

155

156

156−instance Binary RelationTuple

157−

158instance Eq RelationTuple where

157instance Eq RelationTuple where

159− (==) tuple1@(RelationTuple attrs1 _) tuple2@(RelationTuple attrs2 _) = attributesEqual attrs1 attrs2 && atomsEqual

158+ tuple1@(RelationTuple attrs1 _) == tuple2@(RelationTuple attrs2 _) =

159+ attrs1 == attrs2 && atomsEqual

160 where

161− atomForAttribute attr (RelationTuple attrs tupVec) = case V.findIndex (== attr) attrs of

161+ atomForAttribute attr (RelationTuple attrs tupVec) = case V.findIndex (== attr) (attributesVec attrs) of

162 Nothing -> Nothing

163 Just index -> tupVec V.!? index

164− 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)

165

166instance NFData RelationTuple where rnf = genericRnf

167

168−

169data Relation = Relation Attributes RelationTupleSet deriving (Show, Generic,Typeable)

168data Relation = Relation Attributes RelationTupleSet deriving (Show, Generic,Typeable)

170

169

171instance Eq Relation where

170instance Eq Relation where

172− Relation attrs1 tupSet1 == Relation attrs2 tupSet2 = attributesEqual attrs1 attrs2 && tupSet1 == tupSet2

171+ Relation attrs1 tupSet1 == Relation attrs2 tupSet2 = attrs1 == attrs2 && tupSet1 == tupSet2

173

172

174instance NFData Relation where rnf = genericRnf

173instance NFData Relation where rnf = genericRnf

175

174

@@ -180,8 +179,6 @@ instance Hashable Relation where

180 where

179 where

181 sortedAttrs = map snd (sortedAttributesIndices attrs)

180 sortedAttrs = map snd (sortedAttributesIndices attrs)

182

181

183−instance Binary Relation

184−

185-- | Used to represent the number of tuples in a relation.

182-- | Used to represent the number of tuples in a relation.

186data RelationCardinality = Countable | Finite Int deriving (Eq, Show, Generic, Ord)

183data RelationCardinality = Countable | Finite Int deriving (Eq, Show, Generic, Ord)

187

184

@@ -228,18 +225,13 @@ data RelationalExprBase a =

228 With [(WithNameExprBase a, RelationalExprBase a)] (RelationalExprBase a)

225 With [(WithNameExprBase a, RelationalExprBase a)] (RelationalExprBase a)

229 deriving (Show, Read, Eq, Generic, NFData, Foldable, Functor, Traversable)

226 deriving (Show, Read, Eq, Generic, NFData, Foldable, Functor, Traversable)

230

227

231−instance Hashable RelationalExpr where

228+instance Hashable RelationalExpr

232− hashWithSalt = genericHashWithSalt

233

229

234−instance Binary RelationalExpr

235−

236data WithNameExprBase a = WithNameExpr RelVarName a

230data WithNameExprBase a = WithNameExpr RelVarName a

237 deriving (Show, Read, Eq, Generic, NFData, Foldable, Functor, Traversable, Hashable)

231 deriving (Show, Read, Eq, Generic, NFData, Foldable, Functor, Traversable, Hashable)

238

232

239type WithNameExpr = WithNameExprBase ()

233type WithNameExpr = WithNameExprBase ()

240

234

241−instance Binary WithNameExpr

242−

243type GraphRefWithNameExpr = WithNameExprBase GraphRefTransactionMarker

235type GraphRefWithNameExpr = WithNameExprBase GraphRefTransactionMarker

244

236

245type NotificationName = StringType

237type NotificationName = StringType

@@ -251,14 +243,14 @@ data Notification = Notification {

251 reportOldExpr :: RelationalExpr, --run the expression in the pre-change context

243 reportOldExpr :: RelationalExpr, --run the expression in the pre-change context

252 reportNewExpr :: RelationalExpr --run the expression in the post-change context

244 reportNewExpr :: RelationalExpr --run the expression in the post-change context

253 }

245 }

254− deriving (Show, Eq, Binary, Generic, NFData)

246+ deriving (Show, Eq, Generic, NFData)

255

247

256type TypeVarName = StringType

248type TypeVarName = StringType

257

249

258-- | Metadata definition for type constructors such as @data Either a b@.

250-- | Metadata definition for type constructors such as @data Either a b@.

259data TypeConstructorDef = ADTypeConstructorDef TypeConstructorName [TypeVarName] |

251data TypeConstructorDef = ADTypeConstructorDef TypeConstructorName [TypeVarName] |

260 PrimitiveTypeConstructorDef TypeConstructorName AtomType

252 PrimitiveTypeConstructorDef TypeConstructorName AtomType

261− deriving (Show, Generic, Binary, Eq, NFData, Hashable, Read)

253+ deriving (Show, Generic, Eq, NFData, Hashable, Read)

262

254

263-- | Found in data constructors and type declarations: Left (Either Int Text) | Right Int

255-- | Found in data constructors and type declarations: Left (Either Int Text) | Right Int

264type TypeConstructor = TypeConstructorBase ()

256type TypeConstructor = TypeConstructorBase ()

@@ -266,7 +258,7 @@ data TypeConstructorBase a = ADTypeConstructor TypeConstructorName [TypeConstruc

266 PrimitiveTypeConstructor TypeConstructorName AtomType |

258 PrimitiveTypeConstructor TypeConstructorName AtomType |

267 RelationAtomTypeConstructor [AttributeExprBase a] |

259 RelationAtomTypeConstructor [AttributeExprBase a] |

268 TypeVariable TypeVarName

260 TypeVariable TypeVarName

269− deriving (Show, Generic, Binary, Eq, NFData, Hashable, Read)

261+ deriving (Show, Generic, Eq, NFData, Hashable, Read)

270

262

271type TypeConstructorMapping = [(TypeConstructorDef, DataConstructorDefs)]

263type TypeConstructorMapping = [(TypeConstructorDef, DataConstructorDefs)]

272

264

@@ -276,20 +268,20 @@ type DataConstructorName = StringType

276type AtomTypeName = StringType

268type AtomTypeName = StringType

277

269

278-- | Used to define a data constructor in a type constructor context such as @Left a | Right b@

270-- | Used to define a data constructor in a type constructor context such as @Left a | Right b@

279−data DataConstructorDef = DataConstructorDef DataConstructorName [DataConstructorDefArg] deriving (Eq, Show, Binary, Generic, NFData, Hashable, Read)

271+data DataConstructorDef = DataConstructorDef DataConstructorName [DataConstructorDefArg] deriving (Eq, Show, Generic, NFData, Hashable, Read)

280

272

281type DataConstructorDefs = [DataConstructorDef]

273type DataConstructorDefs = [DataConstructorDef]

282

274

283data DataConstructorDefArg = DataConstructorDefTypeConstructorArg TypeConstructor |

275data DataConstructorDefArg = DataConstructorDefTypeConstructorArg TypeConstructor |

284 DataConstructorDefTypeVarNameArg TypeVarName

276 DataConstructorDefTypeVarNameArg TypeVarName

285− deriving (Show, Generic, Binary, Eq, NFData, Hashable, Read)

277+ deriving (Show, Generic, Eq, NFData, Hashable, Read)

286

278

287type InclusionDependencies = M.Map IncDepName InclusionDependency

279type InclusionDependencies = M.Map IncDepName InclusionDependency

288type RelationVariables = M.Map RelVarName GraphRefRelationalExpr

280type RelationVariables = M.Map RelVarName GraphRefRelationalExpr

289

281

290data GraphRefTransactionMarker = TransactionMarker TransactionId |

282data GraphRefTransactionMarker = TransactionMarker TransactionId |

291 UncommittedContextMarker

283 UncommittedContextMarker

292− deriving (Eq, Show, Binary, Generic, NFData, Ord)

284+ deriving (Eq, Show, Generic, NFData, Ord)

293

285

294-- a fundamental relational expr to which other relational expressions compile

286-- a fundamental relational expr to which other relational expressions compile

295type GraphRefRelationalExpr = RelationalExprBase GraphRefTransactionMarker

287type GraphRefRelationalExpr = RelationalExprBase GraphRefTransactionMarker

@@ -300,17 +292,18 @@ type Subschemas = M.Map SchemaName Schema

300

292

301-- | Every transaction has one concrete database context and any number of isomorphic subschemas.

293-- | Every transaction has one concrete database context and any number of isomorphic subschemas.

302data Schemas = Schemas DatabaseContext Subschemas

294data Schemas = Schemas DatabaseContext Subschemas

295+ deriving (Generic)

303

296

304-- | The DatabaseContext is a snapshot of a database's evolving state and contains everything a database client can change over time.

297-- | The DatabaseContext is a snapshot of a database's evolving state and contains everything a database client can change over time.

305-- I spent some time thinking about whether the VirtualDatabaseContext/Schema and DatabaseContext data constructors should be the same constructor, but that would allow relation variables to be created in a "virtual" context which would appear to defeat the isomorphisms of the contexts. It should be possible to switch to an alternative schema to view the same equivalent information without information loss. However, allowing all contexts to reference another context while maintaining its own relation variables, new types, etc. could be interesting from a security perspective. For example, if a user creates a new relvar in a virtual context, then does it necessarily appear in all linked contexts? After deliberation, I think the relvar should appear in *all* linked contexts to retain the isomorphic properties, even when the isomorphism is for a subset of the context. This hints that the IsoMorphs should allow for "fall-through"; that is, when a relvar is not defined in the virtual context (for morphing), then the lookup should fall through to the underlying context.

298-- I spent some time thinking about whether the VirtualDatabaseContext/Schema and DatabaseContext data constructors should be the same constructor, but that would allow relation variables to be created in a "virtual" context which would appear to defeat the isomorphisms of the contexts. It should be possible to switch to an alternative schema to view the same equivalent information without information loss. However, allowing all contexts to reference another context while maintaining its own relation variables, new types, etc. could be interesting from a security perspective. For example, if a user creates a new relvar in a virtual context, then does it necessarily appear in all linked contexts? After deliberation, I think the relvar should appear in *all* linked contexts to retain the isomorphic properties, even when the isomorphism is for a subset of the context. This hints that the IsoMorphs should allow for "fall-through"; that is, when a relvar is not defined in the virtual context (for morphing), then the lookup should fall through to the underlying context.

306newtype Schema = Schema SchemaIsomorphs

299newtype Schema = Schema SchemaIsomorphs

307− deriving (Generic, Binary)

300+ deriving (Generic)

308

301

309data SchemaIsomorph = IsoRestrict RelVarName RestrictionPredicateExpr (RelVarName, RelVarName) |

302data SchemaIsomorph = IsoRestrict RelVarName RestrictionPredicateExpr (RelVarName, RelVarName) |

310 IsoRename RelVarName RelVarName |

303 IsoRename RelVarName RelVarName |

311 IsoUnion (RelVarName, RelVarName) RestrictionPredicateExpr RelVarName --maps two relvars to one relvar

304 IsoUnion (RelVarName, RelVarName) RestrictionPredicateExpr RelVarName --maps two relvars to one relvar

312 -- IsoTypeConstructor in morphAttrExpr

305 -- IsoTypeConstructor in morphAttrExpr

313− deriving (Generic, Binary, Show)

306+ deriving (Generic, Show)

314

307

315type SchemaIsomorphs = [SchemaIsomorph]

308type SchemaIsomorphs = [SchemaIsomorph]

316

309

@@ -328,8 +321,6 @@ type IncDepName = StringType

328-- | Inclusion dependencies represent every possible database constraint. Constraints enforce specific, arbitrarily-complex rules to which the database context's relation variables must adhere unconditionally.

321-- | Inclusion dependencies represent every possible database constraint. Constraints enforce specific, arbitrarily-complex rules to which the database context's relation variables must adhere unconditionally.

329data InclusionDependency = InclusionDependency RelationalExpr RelationalExpr deriving (Show, Eq, Generic, NFData, Hashable, Read)

322data InclusionDependency = InclusionDependency RelationalExpr RelationalExpr deriving (Show, Eq, Generic, NFData, Hashable, Read)

330

323

331−instance Binary InclusionDependency

332−

333type AttributeNameAtomExprMap = M.Map AttributeName AtomExpr

324type AttributeNameAtomExprMap = M.Map AttributeName AtomExpr

334

325

335--used for returning information about individual expressions

326--used for returning information about individual expressions

@@ -337,13 +328,10 @@ type DatabaseContextExprName = StringType

337

328

338type DatabaseContextExpr = DatabaseContextExprBase ()

329type DatabaseContextExpr = DatabaseContextExprBase ()

339

330

340−instance Hashable DatabaseContextExpr where

331+instance Hashable DatabaseContextExpr

341− hashWithSalt = genericHashWithSalt

342

332

343type GraphRefDatabaseContextExpr = DatabaseContextExprBase GraphRefTransactionMarker

333type GraphRefDatabaseContextExpr = DatabaseContextExprBase GraphRefTransactionMarker

344

334

345−instance Binary GraphRefDatabaseContextExpr

346−

347-- | Database context expressions modify the database context.

335-- | Database context expressions modify the database context.

348data DatabaseContextExprBase a =

336data DatabaseContextExprBase a =

349 NoOperation |

337 NoOperation |

@@ -376,8 +364,6 @@ data DatabaseContextExprBase a =

376instance Hashable (M.Map AttributeName AtomExpr) where

364instance Hashable (M.Map AttributeName AtomExpr) where

377 hashWithSalt salt m = salt `hashWithSalt` M.toList m

365 hashWithSalt salt m = salt `hashWithSalt` M.toList m

378

366

379−instance Binary DatabaseContextExpr

380−

381type ObjModuleName = StringType

367type ObjModuleName = StringType

382type ObjFunctionName = StringType

368type ObjFunctionName = StringType

383type Range = (Int,Int)

369type Range = (Int,Int)

@@ -388,7 +374,7 @@ data DatabaseContextIOExprBase a =

388 AddDatabaseContextFunction DatabaseContextFunctionName [TypeConstructor] DatabaseContextFunctionBodyScript |

374 AddDatabaseContextFunction DatabaseContextFunctionName [TypeConstructor] DatabaseContextFunctionBodyScript |

389 LoadDatabaseContextFunctions ObjModuleName ObjFunctionName FilePath |

375 LoadDatabaseContextFunctions ObjModuleName ObjFunctionName FilePath |

390 CreateArbitraryRelation RelVarName [AttributeExprBase a] Range

376 CreateArbitraryRelation RelVarName [AttributeExprBase a] Range

391− deriving (Show, Eq, Generic, Binary)

377+ deriving (Show, Eq, Generic)

392

378

393type GraphRefDatabaseContextIOExpr = DatabaseContextIOExprBase GraphRefTransactionMarker

379type GraphRefDatabaseContextIOExpr = DatabaseContextIOExprBase GraphRefTransactionMarker

394

380

@@ -411,8 +397,6 @@ data RestrictionPredicateExprBase a =

411 AttributeEqualityPredicate AttributeName (AtomExprBase a) -- relationalexpr must result in relation with single tuple

397 AttributeEqualityPredicate AttributeName (AtomExprBase a) -- relationalexpr must result in relation with single tuple

412 deriving (Show, Read, Eq, Generic, NFData, Foldable, Functor, Traversable)

398 deriving (Show, Read, Eq, Generic, NFData, Foldable, Functor, Traversable)

413

399

414−instance Binary RestrictionPredicateExpr

415−

416-- child + parent links

400-- child + parent links

417-- | A transaction graph's head name references the leaves of the transaction graph and can be used during session creation to indicate at which point in the graph commits should persist.

401-- | A transaction graph's head name references the leaves of the transaction graph and can be used during session creation to indicate at which point in the graph commits should persist.

418type HeadName = StringType

402type HeadName = StringType

@@ -421,6 +405,7 @@ type TransactionHeads = M.Map HeadName Transaction

421

405

422-- | The transaction graph is the global database's state which references every committed transaction.

406-- | The transaction graph is the global database's state which references every committed transaction.

423data TransactionGraph = TransactionGraph TransactionHeads (S.Set Transaction)

407data TransactionGraph = TransactionGraph TransactionHeads (S.Set Transaction)

408+ deriving Generic

424

409

425transactionHeadsForGraph :: TransactionGraph -> TransactionHeads

410transactionHeadsForGraph :: TransactionGraph -> TransactionHeads

426transactionHeadsForGraph (TransactionGraph hs _) = hs

411transactionHeadsForGraph (TransactionGraph hs _) = hs

@@ -443,12 +428,11 @@ data TransactionInfo = TransactionInfo TransactionId TransactionDiffs UTCTime |

443 deriving (Show, Generic)

428 deriving (Show, Generic)

444-}

429-}

445

430

446−instance Binary TransactionInfo

447−

448-- | Every set of modifications made to the database are atomically committed to the transaction graph as a transaction.

431-- | Every set of modifications made to the database are atomically committed to the transaction graph as a transaction.

449type TransactionId = UUID

432type TransactionId = UUID

450

433

451data Transaction = Transaction TransactionId TransactionInfo Schemas

434data Transaction = Transaction TransactionId TransactionInfo Schemas

435+ deriving Generic

452

436

453-- | The disconnected transaction represents an in-progress workspace used by sessions before changes are committed. This is similar to git's "index". After a transaction is committed, it is "connected" in the transaction graph and can no longer be modified.

437-- | The disconnected transaction represents an in-progress workspace used by sessions before changes are committed. This is similar to git's "index". After a transaction is committed, it is "connected" in the transaction graph and can no longer be modified.

454data DisconnectedTransaction = DisconnectedTransaction TransactionId Schemas DirtyFlag

438data DisconnectedTransaction = DisconnectedTransaction TransactionId Schemas DirtyFlag

@@ -484,8 +468,6 @@ data AtomExprBase a = AttributeAtomExpr AttributeName |

484 ConstructedAtomExpr DataConstructorName [AtomExprBase a] a

468 ConstructedAtomExpr DataConstructorName [AtomExprBase a] a

485 deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable)

469 deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable)

486

470

487−instance Binary AtomExpr

488−

489-- | Used in tuple creation when creating a relation.

471-- | Used in tuple creation when creating a relation.

490data ExtendTupleExprBase a = AttributeExtendTupleExpr AttributeName (AtomExprBase a)

472data ExtendTupleExprBase a = AttributeExtendTupleExpr AttributeName (AtomExprBase a)

491 deriving (Show, Read, Eq, Generic, NFData, Foldable, Functor, Traversable)

473 deriving (Show, Read, Eq, Generic, NFData, Foldable, Functor, Traversable)

@@ -496,8 +478,6 @@ instance Hashable ExtendTupleExpr

496

478

497type GraphRefExtendTupleExpr = ExtendTupleExprBase GraphRefTransactionMarker

479type GraphRefExtendTupleExpr = ExtendTupleExprBase GraphRefTransactionMarker

498

480

499−instance Binary ExtendTupleExpr

500−

501--enumerates the list of functions available to be run as part of tuple expressions

481--enumerates the list of functions available to be run as part of tuple expressions

502type AtomFunctions = HS.HashSet AtomFunction

482type AtomFunctions = HS.HashSet AtomFunction

503

483

@@ -508,6 +488,7 @@ type AtomFunctionBodyScript = StringType

508type AtomFunctionBodyType = [Atom] -> Either AtomFunctionError Atom

488type AtomFunctionBodyType = [Atom] -> Either AtomFunctionError Atom

509

489

510data AtomFunctionBody = AtomFunctionBody (Maybe AtomFunctionBodyScript) AtomFunctionBodyType

490data AtomFunctionBody = AtomFunctionBody (Maybe AtomFunctionBodyScript) AtomFunctionBodyType

491+ deriving Generic

511

492

512instance NFData AtomFunctionBody where

493instance NFData AtomFunctionBody where

513 rnf (AtomFunctionBody mScript _) = rnf mScript

494 rnf (AtomFunctionBody mScript _) = rnf mScript

@@ -553,8 +534,6 @@ type AttributeNames = AttributeNamesBase ()

553

534

554type GraphRefAttributeNames = AttributeNamesBase GraphRefTransactionMarker

535type GraphRefAttributeNames = AttributeNamesBase GraphRefTransactionMarker

555

536

556−instance Binary AttributeNames

557−

558-- | The persistence strategy is a global database option which represents how to persist the database in the filesystem, if at all.

537-- | The persistence strategy is a global database option which represents how to persist the database in the filesystem, if at all.

559data PersistenceStrategy = NoPersistence | -- ^ no filesystem persistence/memory-only database

538data PersistenceStrategy = NoPersistence | -- ^ no filesystem persistence/memory-only database

560 MinimalPersistence FilePath | -- ^ fsync off, not crash-safe

539 MinimalPersistence FilePath | -- ^ fsync off, not crash-safe

@@ -567,7 +546,7 @@ type GraphRefAttributeExpr = AttributeExprBase GraphRefTransactionMarker

567-- | Create attributes dynamically.

546-- | Create attributes dynamically.

568data AttributeExprBase a = AttributeAndTypeNameExpr AttributeName TypeConstructor a |

547data AttributeExprBase a = AttributeAndTypeNameExpr AttributeName TypeConstructor a |

569 NakedAttributeExpr Attribute

548 NakedAttributeExpr Attribute

570− deriving (Eq, Show, Read, Generic, Binary, NFData, Foldable, Functor, Traversable, Hashable)

549+ deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable, Hashable)

571

550

572-- | Dynamically create a tuple from attribute names and 'AtomExpr's.

551-- | Dynamically create a tuple from attribute names and 'AtomExpr's.

573newtype TupleExprBase a = TupleExpr (M.Map AttributeName (AtomExprBase a))

552newtype TupleExprBase a = TupleExpr (M.Map AttributeName (AtomExprBase a))

@@ -575,8 +554,6 @@ newtype TupleExprBase a = TupleExpr (M.Map AttributeName (AtomExprBase a))

575

554

576instance Hashable TupleExpr

555instance Hashable TupleExpr

577

556

578−instance Binary TupleExpr

579−

580type TupleExpr = TupleExprBase ()

557type TupleExpr = TupleExprBase ()

581

558

582type GraphRefTupleExpr = TupleExprBase GraphRefTransactionMarker

559type GraphRefTupleExpr = TupleExprBase GraphRefTransactionMarker

@@ -584,15 +561,12 @@ type GraphRefTupleExpr = TupleExprBase GraphRefTransactionMarker

584data TupleExprsBase a = TupleExprs a [TupleExprBase a]

561data TupleExprsBase a = TupleExprs a [TupleExprBase a]

585 deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable)

562 deriving (Eq, Show, Read, Generic, NFData, Foldable, Functor, Traversable)

586

563

587−instance Hashable TupleExprs where

564+instance Hashable TupleExprs

588− hashWithSalt = genericHashWithSalt

589

565

590type GraphRefTupleExprs = TupleExprsBase GraphRefTransactionMarker

566type GraphRefTupleExprs = TupleExprsBase GraphRefTransactionMarker

591

567

592type TupleExprs = TupleExprsBase ()

568type TupleExprs = TupleExprsBase ()

593

569

594−instance Binary TupleExprs

595−

596data MergeStrategy =

570data MergeStrategy =

597 -- | After a union merge, the merge transaction is a result of union'ing relvars of the same name, introducing all uniquely-named relvars, union of constraints, union of atom functions, notifications, and types (unless the names and definitions collide, e.g. two types of the same name with different definitions)

571 -- | After a union merge, the merge transaction is a result of union'ing relvars of the same name, introducing all uniquely-named relvars, union of constraints, union of atom functions, notifications, and types (unless the names and definitions collide, e.g. two types of the same name with different definitions)

598 UnionMergeStrategy |

572 UnionMergeStrategy |

@@ -600,7 +574,7 @@ data MergeStrategy =

600 UnionPreferMergeStrategy HeadName |

574 UnionPreferMergeStrategy HeadName |

601 -- | Similar to the our/theirs merge strategy in git, the merge transaction's context is identical to that of the last transaction in the selected branch.

575 -- | Similar to the our/theirs merge strategy in git, the merge transaction's context is identical to that of the last transaction in the selected branch.

602 SelectedBranchMergeStrategy HeadName

576 SelectedBranchMergeStrategy HeadName

603− deriving (Eq, Show, Binary, Generic, NFData)

577+ deriving (Eq, Show, Generic, NFData)

604

578

605type DatabaseContextFunctionName = StringType

579type DatabaseContextFunctionName = StringType

606

580

@@ -638,7 +612,7 @@ attrTypeVars (Attribute _ aType) = case aType of

638 ByteStringAtomType -> S.empty

612 ByteStringAtomType -> S.empty

639 BoolAtomType -> S.empty

613 BoolAtomType -> S.empty

640 RelationalExprAtomType -> S.empty

614 RelationalExprAtomType -> S.empty

641− (RelationAtomType attrs) -> S.unions (map attrTypeVars (V.toList attrs))

615+ (RelationAtomType attrs) -> S.unions (map attrTypeVars (V.toList (attributesVec attrs)))

642 (ConstructedAtomType _ tvMap) -> M.keysSet tvMap

616 (ConstructedAtomType _ tvMap) -> M.keysSet tvMap

643 (TypeVariableType nam) -> S.singleton nam

617 (TypeVariableType nam) -> S.singleton nam

644

618

@@ -662,28 +636,11 @@ atomTypeVars DateTimeAtomType = S.empty

662atomTypeVars ByteStringAtomType = S.empty

636atomTypeVars ByteStringAtomType = S.empty

663atomTypeVars BoolAtomType = S.empty

637atomTypeVars BoolAtomType = S.empty

664atomTypeVars RelationalExprAtomType = S.empty

638atomTypeVars RelationalExprAtomType = S.empty

665−atomTypeVars (RelationAtomType attrs) = S.unions (map attrTypeVars (V.toList attrs))

639+atomTypeVars (RelationAtomType attrs) = S.unions (map attrTypeVars (V.toList (attributesVec attrs)))

666atomTypeVars (ConstructedAtomType _ tvMap) = M.keysSet tvMap

640atomTypeVars (ConstructedAtomType _ tvMap) = M.keysSet tvMap

667atomTypeVars (TypeVariableType nam) = S.singleton nam

641atomTypeVars (TypeVariableType nam) = S.singleton nam

668

642

669unimplemented :: HasCallStack => a

643unimplemented :: HasCallStack => a

670−unimplemented = undefined

644+unimplemented = error "unimplemented"

671−

672−--for serializing GraphRefRelationalExpr as part of transaction serialization

673−instance Binary (TupleExprsBase GraphRefTransactionMarker)

674−

675−instance Binary (TupleExprBase GraphRefTransactionMarker)

676−

677−instance Binary GraphRefRelationalExpr

678−

679−instance Binary (AtomExprBase GraphRefTransactionMarker)

680−

681−instance Binary (AttributeNamesBase GraphRefTransactionMarker)

682−

683−instance Binary (RestrictionPredicateExprBase GraphRefTransactionMarker)

684−

685−instance Binary (ExtendTupleExprBase GraphRefTransactionMarker)

686−

687−instance Binary GraphRefWithNameExpr

688

645

689−

646+makeBaseFunctor ''RelationalExprBase

src/lib/ProjectM36/Client.hs+163−293

@@ -1,4 +1,4 @@

1−{-# LANGUAGE DeriveAnyClass, DeriveGeneric, ScopedTypeVariables, MonoLocalBinds #-}

1+{-# LANGUAGE DeriveGeneric, ScopedTypeVariables, MonoLocalBinds, DerivingVia #-}

2{-|

3Module: ProjectM36.Client

@@ -9,6 +9,7 @@ module ProjectM36.Client

9 Connection(..),

10 Port,

11 Hostname,

12+ ServiceName,

12 DatabaseName,

13 DatabaseName,

13 ConnectionError(..),

14 ConnectionError(..),

14 connectProjectM36,

15 connectProjectM36,

@@ -43,6 +44,7 @@ module ProjectM36.Client

43 defaultDatabaseName,

44 defaultDatabaseName,

44 defaultRemoteConnectionInfo,

45 defaultRemoteConnectionInfo,

45 defaultHeadName,

46 defaultHeadName,

47+ addClientNode,

46 PersistenceStrategy(..),

48 PersistenceStrategy(..),

47 RelationalExpr,

49 RelationalExpr,

48 RelationalExprBase(..),

50 RelationalExprBase(..),

@@ -53,11 +55,9 @@ module ProjectM36.Client

53 Attribute(..),

55 Attribute(..),

54 MergeStrategy(..),

56 MergeStrategy(..),

55 attributesFromList,

57 attributesFromList,

56− createNodeId,

57 createSessionAtCommit,

58 createSessionAtCommit,

58 createSessionAtHead,

59 createSessionAtHead,

59 closeSession,

60 closeSession,

60− addClientNode,

61 callTestTimeout_,

62 RelationCardinality(..),

63 TransactionGraphOperator(..),

@@ -67,7 +67,6 @@ module ProjectM36.Client

67 TransGraphRelationalExpr,

68 TransactionIdLookup(..),

69 TransactionIdHeadBacktrack(..),

70− NodeId(..),

71 Atom(..),

70 Atom(..),

72 Session,

71 Session,

73 SessionId,

72 SessionId,

@@ -107,6 +106,7 @@ module ProjectM36.Client

107 ) where

106 ) where

108import ProjectM36.Base hiding (inclusionDependencies) --defined in this module as well

107import ProjectM36.Base hiding (inclusionDependencies) --defined in this module as well

109import qualified ProjectM36.Base as B

108import qualified ProjectM36.Base as B

109+import ProjectM36.Serialise.Error ()

110import ProjectM36.Error

111import ProjectM36.Atomable

112import ProjectM36.AtomFunction as AF

@@ -134,28 +134,16 @@ import ProjectM36.Relation (typesAsRelation)

134import ProjectM36.ScriptSession (initScriptSession, ScriptSession)

135import qualified ProjectM36.Relation as R

136import Control.Exception.Base

137−import GHC.Conc.Sync

137+import Control.Concurrent.STM

138−

138+import Control.Concurrent.Async

139−import Network.Transport (Transport(closeTransport))

140−#if MIN_VERSION_network_transport_tcp(0,7,0)

141−import Network.Transport.TCP (createTransport, defaultTCPParameters, defaultTCPAddr)

142−import Network.Transport.TCP.Internal (encodeEndPointAddress)

143−#elif MIN_VERSION_network_transport_tcp(0,6,0)

144−import Network.Transport.TCP (createTransport, defaultTCPParameters)

145−import Network.Transport.TCP.Internal (encodeEndPointAddress)

146−#else

147−import Network.Transport.TCP (encodeEndPointAddress, createTransport, defaultTCPParameters)

148−#endif

149

139

150−import Control.Distributed.Process.Node (newLocalNode, initRemoteTable, runProcess, LocalNode, forkProcess, closeLocalNode)

151−import Control.Distributed.Process.Extras.Internal.Types (whereisRemote)

152−import Control.Distributed.Process.ManagedProcess.Client (call, safeCall)

153import Data.Either (isRight)

140import Data.Either (isRight)

154import Data.UUID.V4 (nextRandom)

141import Data.UUID.V4 (nextRandom)

155import Data.Word

142import Data.Word

156−import Control.Distributed.Process (ProcessId, Process, receiveWait, send, match, NodeId(..), reconnect)

143+import Data.Hashable

157import Control.Exception (IOException, handle, AsyncException, throwIO, fromException, Exception)

144import Control.Exception (IOException, handle, AsyncException, throwIO, fromException, Exception)

158import Control.Concurrent.MVar

145import Control.Concurrent.MVar

146+import Codec.Winery hiding (Schema, schema)

159import qualified Data.Map as M

147import qualified Data.Map as M

160#if MIN_VERSION_stm_containers(1,0,0)

148#if MIN_VERSION_stm_containers(1,0,0)

161import qualified StmContainers.Map as StmMap

149import qualified StmContainers.Map as StmMap

@@ -167,19 +155,19 @@ import qualified STMContainers.Set as StmSet

167import qualified ProjectM36.Session as Sess

155import qualified ProjectM36.Session as Sess

168import ProjectM36.Session

156import ProjectM36.Session

169import ProjectM36.Sessions

157import ProjectM36.Sessions

170−import Data.Binary (Binary)

171import GHC.Generics (Generic)

158import GHC.Generics (Generic)

172import Control.DeepSeq (force)

159import Control.DeepSeq (force)

173import System.IO

160import System.IO

174import Data.Time.Clock

161import Data.Time.Clock

175−import Data.Typeable

162+import qualified Network.RPC.Curryer.Client as RPC

163+import qualified Network.RPC.Curryer.Server as RPC

164+import Network.Socket (Socket, AddrInfo(..), getAddrInfo, defaultHints, AddrInfoFlag(..), SocketType(..), ServiceName, hostAddressToTuple, SockAddr(..))

165+import GHC.Conc (unsafeIOToSTM)

176

166

177type Hostname = String

167type Hostname = String

178

168

179type Port = Word16

169type Port = Word16

180

170

181−type DatabaseName = String

182−

183-- | The type for notifications callbacks in the client. When a registered notification fires due to a changed relational expression evaluation, the server propagates the notifications to the clients in the form of the callback.

171-- | The type for notifications callbacks in the client. When a registered notification fires due to a changed relational expression evaluation, the server propagates the notifications to the clients in the form of the callback.

184type NotificationCallback = NotificationName -> EvaluatedNotification -> IO ()

172type NotificationCallback = NotificationName -> EvaluatedNotification -> IO ()

185

173

@@ -199,15 +187,16 @@ data RequestTimeoutException = RequestTimeoutException

199

187

200instance Exception RequestTimeoutException

188instance Exception RequestTimeoutException

201

189

202−-- | Construct a 'ConnectionInfo' to describe how to make the 'Connection'. The database can be run within the current process or running remotely via distributed-process.

190+-- | Construct a 'ConnectionInfo' to describe how to make the 'Connection'. The database can be run within the current process or running remotely via RPC.

203−data ConnectionInfo = InProcessConnectionInfo PersistenceStrategy NotificationCallback [GhcPkgPath]|

191+data ConnectionInfo = InProcessConnectionInfo PersistenceStrategy NotificationCallback [GhcPkgPath] |

204− RemoteProcessConnectionInfo DatabaseName NodeId NotificationCallback

192+ RemoteConnectionInfo DatabaseName Hostname ServiceName NotificationCallback

205

193

206type EvaluatedNotifications = M.Map NotificationName EvaluatedNotification

194type EvaluatedNotifications = M.Map NotificationName EvaluatedNotification

207

195

208-- | Used for callbacks from the server when monitored changes have been made.

196-- | Used for callbacks from the server when monitored changes have been made.

209newtype NotificationMessage = NotificationMessage EvaluatedNotifications

197newtype NotificationMessage = NotificationMessage EvaluatedNotifications

210− deriving (Binary, Eq, Show, Generic)

198+ deriving (Eq, Show, Generic)

199+ deriving Serialise via WineryVariant NotificationMessage

211

200

212-- | When a notification is fired, the 'reportOldExpr' is evaluated in the commit's pre-change context while the 'reportNewExpr' is evaluated in the post-change context and they are returned along with the original notification.

201-- | When a notification is fired, the 'reportOldExpr' is evaluated in the commit's pre-change context while the 'reportNewExpr' is evaluated in the post-change context and they are returned along with the original notification.

213data EvaluatedNotification = EvaluatedNotification {

202data EvaluatedNotification = EvaluatedNotification {

@@ -215,13 +204,10 @@ data EvaluatedNotification = EvaluatedNotification {

215 reportOldRelation :: Either RelationalError Relation,

204 reportOldRelation :: Either RelationalError Relation,

216 reportNewRelation :: Either RelationalError Relation

205 reportNewRelation :: Either RelationalError Relation

217 }

206 }

218− deriving(Binary, Eq, Show, Generic)

207+ deriving (Eq, Show, Generic)

208+ deriving Serialise via WineryRecord EvaluatedNotification

219

209

220

210

221−-- | Create a 'NodeId' for use in connecting to a remote server using distributed-process.

222−createNodeId :: Hostname -> Port -> NodeId

223−createNodeId host port = NodeId $ encodeEndPointAddress host (show port) 1

224−

225-- | Use this for connecting to remote servers on the default port.

211-- | Use this for connecting to remote servers on the default port.

226defaultServerPort :: Port

212defaultServerPort :: Port

227defaultServerPort = 6543

213defaultServerPort = 6543

@@ -236,31 +222,16 @@ defaultHeadName = "master"

236

222

237-- | Create a connection configuration which connects to the localhost on the default server port and default server database name. The configured notification callback is set to ignore all events.

223-- | Create a connection configuration which connects to the localhost on the default server port and default server database name. The configured notification callback is set to ignore all events.

238defaultRemoteConnectionInfo :: ConnectionInfo

224defaultRemoteConnectionInfo :: ConnectionInfo

225+defaultRemoteConnectionInfo =

239−defaultRemoteConnectionInfo = RemoteProcessConnectionInfo defaultDatabaseName (createNodeId "127.0.0.1" defaultServerPort) emptyNotificationCallback

226+ RemoteConnectionInfo defaultDatabaseName defaultServerHostname (show defaultServerPort) emptyNotificationCallback

240

227

241−-- | The 'Connection' represents either local or remote access to a database. All operations flow through the connection.

228+defaultServerHostname :: Hostname

242−type ClientNodes = StmSet.Set ProcessId

229+defaultServerHostname = "localhost"

243−

244−-- internal structure specific to in-process connections

245−data InProcessConnectionConf = InProcessConnectionConf {

246− ipPersistenceStrategy :: PersistenceStrategy,

247− ipClientNodes :: ClientNodes,

248− ipSessions :: Sessions,

249− ipTransactionGraph :: TVar TransactionGraph,

250− ipScriptSession :: Maybe ScriptSession,

251− ipLocalNode :: LocalNode,

252− ipTransport :: Transport, -- we hold onto this so that we can close it gracefully

253− ipLocks :: Maybe (LockFile, MVar LockFileHash) -- nothing when NoPersistence

254− }

255

230

256−data RemoteProcessConnectionConf = RemoteProcessConnectionConf {

231+newtype RemoteConnectionConf = RemoteConnectionConf RPC.Connection

257− rLocalNode :: LocalNode,

258− rProcessId :: ProcessId, --remote processId

259− rTransport :: Transport --the TCP socket transport

260− }

261

232

262data Connection = InProcessConnection InProcessConnectionConf |

233data Connection = InProcessConnection InProcessConnectionConf |

263− RemoteProcessConnection RemoteProcessConnectionConf

234+ RemoteConnection RemoteConnectionConf

264

235

265-- | There are several reasons why a connection can fail.

236-- | There are several reasons why a connection can fail.

266data ConnectionError = SetupDatabaseDirectoryError PersistenceError |

237data ConnectionError = SetupDatabaseDirectoryError PersistenceError |

@@ -273,46 +244,14 @@ data ConnectionError = SetupDatabaseDirectoryError PersistenceError |

273remoteDBLookupName :: DatabaseName -> String

244remoteDBLookupName :: DatabaseName -> String

274remoteDBLookupName = (++) "db-"

245remoteDBLookupName = (++) "db-"

275

246

276−createLocalNode :: IO (LocalNode, Transport)

277−createLocalNode = do

278−#if MIN_VERSION_network_transport_tcp(0,7,0)

279− eLocalTransport <- createTransport (defaultTCPAddr "127.0.0.1" "0") defaultTCPParameters

280−#elif MIN_VERSION_network_transport_tcp(0,6,0)

281− eLocalTransport <- createTransport "127.0.0.1" "0" (\sn -> ("127.0.0.1", sn)) defaultTCPParameters

282−#else

283− eLocalTransport <- createTransport "127.0.0.1" "0" defaultTCPParameters

284−#endif

285− case eLocalTransport of

286− Left err -> error ("failed to create transport: " ++ show err)

287− Right localTransport -> do

288− localNode <- newLocalNode localTransport initRemoteTable

289− pure (localNode, localTransport)

290−

291−notificationListener :: NotificationCallback -> Process ()

292−notificationListener callback = do

293− --pid <- getSelfPid

294− --liftIO $ putStrLn $ "LISTENER THREAD START " ++ show pid

295− _ <- forever $

296− receiveWait [

297− match (\(NotificationMessage eNots) ->

298− --say $ "NOTIFICATION: " ++ show eNots

299− -- when notifications are thrown, they are not adjusted for the current schema which could be problematic, but we don't have access to the current session here

300− liftIO $ mapM_ (uncurry callback) (M.toList eNots)

301− )

302− ]

303− --say "LISTENER THREAD EXIT"

304− pure ()

305−

306−startNotificationListener :: LocalNode -> NotificationCallback -> IO ProcessId

307−startNotificationListener localNode callback = forkProcess localNode (notificationListener callback)

308−

309createScriptSession :: [String] -> IO (Maybe ScriptSession)

247createScriptSession :: [String] -> IO (Maybe ScriptSession)

310createScriptSession ghcPkgPaths = do

248createScriptSession ghcPkgPaths = do

311 eScriptSession <- initScriptSession ghcPkgPaths

249 eScriptSession <- initScriptSession ghcPkgPaths

312 case eScriptSession of

250 case eScriptSession of

313− Left err -> hPutStrLn stderr ("Failed to load scripting engine- scripting disabled: " ++ show err) >> pure Nothing --not a fatal error, but the scripting feature must be disabled

251+ Left err -> hPutStrLn stderr ("Warning: Haskell scripting disabled: " ++ show err) >> pure Nothing --not a fatal error, but the scripting feature must be disabled

314 Right s -> pure (Just s)

252 Right s -> pure (Just s)

315

253

254+

316-- | To create a 'Connection' to a remote or local database, create a 'ConnectionInfo' and call 'connectProjectM36'.

255-- | To create a 'Connection' to a remote or local database, create a 'ConnectionInfo' and call 'connectProjectM36'.

317connectProjectM36 :: ConnectionInfo -> IO (Either ConnectionError Connection)

256connectProjectM36 :: ConnectionInfo -> IO (Either ConnectionError Connection)

318--create a new in-memory database/transaction graph

257--create a new in-memory database/transaction graph

@@ -327,42 +266,63 @@ connectProjectM36 (InProcessConnectionInfo strat notificationCallback ghcPkgPath

327 graphTvar <- newTVarIO freshGraph

266 graphTvar <- newTVarIO freshGraph

328 clientNodes <- StmSet.newIO

267 clientNodes <- StmSet.newIO

329 sessions <- StmMap.newIO

268 sessions <- StmMap.newIO

330− (localNode, transport) <- createLocalNode

331− notificationPid <- startNotificationListener localNode notificationCallback

332 mScriptSession <- createScriptSession ghcPkgPaths

269 mScriptSession <- createScriptSession ghcPkgPaths

333−

270+ notifAsync <- startNotificationListener clientNodes notificationCallback

334 let conn = InProcessConnection InProcessConnectionConf {

271 let conn = InProcessConnection InProcessConnectionConf {

335 ipPersistenceStrategy = strat,

272 ipPersistenceStrategy = strat,

336 ipClientNodes = clientNodes,

273 ipClientNodes = clientNodes,

337 ipSessions = sessions,

274 ipSessions = sessions,

338 ipTransactionGraph = graphTvar,

275 ipTransactionGraph = graphTvar,

339 ipScriptSession = mScriptSession,

276 ipScriptSession = mScriptSession,

340− ipLocalNode = localNode,

341− ipTransport = transport,

342− ipLocks = Nothing}

277+ ipLocks = Nothing,

343− addClientNode conn notificationPid

278+ ipCallbackAsync = notifAsync

279+ }

344 pure (Right conn)

280 pure (Right conn)

345 MinimalPersistence dbdir -> connectPersistentProjectM36 strat NoDiskSync dbdir freshGraph notificationCallback ghcPkgPaths

281 MinimalPersistence dbdir -> connectPersistentProjectM36 strat NoDiskSync dbdir freshGraph notificationCallback ghcPkgPaths

346 CrashSafePersistence dbdir -> connectPersistentProjectM36 strat FsyncDiskSync dbdir freshGraph notificationCallback ghcPkgPaths

282 CrashSafePersistence dbdir -> connectPersistentProjectM36 strat FsyncDiskSync dbdir freshGraph notificationCallback ghcPkgPaths

347

283

348−connectProjectM36 (RemoteProcessConnectionInfo databaseName serverNodeId notificationCallback) = do

284+connectProjectM36 (RemoteConnectionInfo dbName hostName servicePort notificationCallback) = do

349− connStatus <- newEmptyMVar

285+ --TODO- add notification callback thread

350− (localNode, transport) <- createLocalNode

286+ let resolutionHints = defaultHints { addrFlags = [AI_NUMERICHOST, AI_NUMERICSERV],

351− let dbName = remoteDBLookupName databaseName

287+ addrSocketType = Stream

352− --putStrLn $ "Connecting to " ++ show serverNodeId ++ " " ++ dbName

288+ }

353− notificationListenerPid <- startNotificationListener localNode notificationCallback

289+ resolved <- getAddrInfo (Just resolutionHints) (Just hostName) (Just servicePort)

354− runProcess localNode $ do

290+ case resolved of

355− --even a failed connection retains an open socket!

291+ [] -> error ("DNS resolution failed for" <> hostName <> ":" <> servicePort)

356− mServerProcessId <- whereisRemote serverNodeId dbName

292+ addrInfo:_ -> do

357− case mServerProcessId of

293+ --supports IPv4 only for now

358− Nothing -> liftIO $ putMVar connStatus $ Left (NoSuchDatabaseByNameError databaseName)

294+ let (SockAddrInet port addr) = addrAddress addrInfo

359− Just serverProcessId -> do

295+ notificationHandlers =

360− loginConfirmation <- safeLogin (Login notificationListenerPid) serverProcessId

296+ [RPC.ClientAsyncRequestHandler $

361− if not loginConfirmation then

297+ \(NotificationMessage notifications') ->

362− liftIO $ putMVar connStatus (Left LoginError)

298+ forM_ (M.toList notifications') (uncurry notificationCallback)

363− else

299+ ]

364− liftIO $ putMVar connStatus (Right $ RemoteProcessConnection RemoteProcessConnectionConf {rLocalNode = localNode, rProcessId = serverProcessId, rTransport = transport})

300+ let connectExcHandler (e :: IOException) = pure $ Left (IOExceptionError e)

365− takeMVar connStatus

301+ eConn <- (Right <$> RPC.connect notificationHandlers (hostAddressToTuple addr) port) `catch` connectExcHandler

302+ case eConn of

303+ Left err -> pure (Left err)

304+ Right conn -> do

305+ eRet <- RPC.call conn (Login dbName)

306+ case eRet of

307+ Left err -> error (show err)

308+ Right False -> error "wtf"

309+ Right True ->

310+ --TODO handle connection errors!

311+ pure (Right (RemoteConnection (RemoteConnectionConf conn)))

312+

313+--convert RPC errors into exceptions

314+convertRPCErrors :: RPC.ConnectionError -> IO a

315+convertRPCErrors err =

316+ case err of

317+ RPC.TimeoutError -> throw RequestTimeoutException

318+ RPC.CodecError msg -> error $ "decoding message failed on server: " <> msg

319+ RPC.ExceptionError msg -> error $ "server threw exception: " <> msg

320+

321+addClientNode :: Connection -> RPC.Locking Socket -> IO ()

322+addClientNode (RemoteConnection _) _ = error "addClientNode called on remote connection"

323+addClientNode (InProcessConnection conf) lockSock = atomically (StmSet.insert clientInfo (ipClientNodes conf))

324+ where

325+ clientInfo = RemoteClientInfo lockSock

366

326

367connectPersistentProjectM36 :: PersistenceStrategy ->

327connectPersistentProjectM36 :: PersistenceStrategy ->

368 DiskSync ->

328 DiskSync ->

@@ -387,29 +347,34 @@ connectPersistentProjectM36 strat sync dbdir freshGraph notificationCallback ghc

387 tvarGraph <- newTVarIO graph'

347 tvarGraph <- newTVarIO graph'

388 sessions <- StmMap.newIO

348 sessions <- StmMap.newIO

389 clientNodes <- StmSet.newIO

349 clientNodes <- StmSet.newIO

390− (localNode, transport) <- createLocalNode

391 lockMVar <- newMVar digest

350 lockMVar <- newMVar digest

351+ notifAsync <- startNotificationListener clientNodes notificationCallback

392 let conn = InProcessConnection InProcessConnectionConf {

352 let conn = InProcessConnection InProcessConnectionConf {

393 ipPersistenceStrategy = strat,

353 ipPersistenceStrategy = strat,

394 ipClientNodes = clientNodes,

354 ipClientNodes = clientNodes,

395 ipSessions = sessions,

355 ipSessions = sessions,

396 ipTransactionGraph = tvarGraph,

356 ipTransactionGraph = tvarGraph,

397 ipScriptSession = mScriptSession,

357 ipScriptSession = mScriptSession,

398− ipLocalNode = localNode,

399− ipTransport = transport,

400− ipLocks = Just (lockFileH, lockMVar)

358+ ipLocks = Just (lockFileH, lockMVar),

359+ ipCallbackAsync = notifAsync

401 }

360 }

402−

403− notificationPid <- startNotificationListener localNode notificationCallback

404− addClientNode conn notificationPid

405 pure (Right conn)

361 pure (Right conn)

406−

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+

407-- | Create a new session at the transaction id and return the session's Id.

372-- | Create a new session at the transaction id and return the session's Id.

408createSessionAtCommit :: Connection -> TransactionId -> IO (Either RelationalError SessionId)

373createSessionAtCommit :: Connection -> TransactionId -> IO (Either RelationalError SessionId)

409createSessionAtCommit conn@(InProcessConnection _) commitId = do

374createSessionAtCommit conn@(InProcessConnection _) commitId = do

410 newSessionId <- nextRandom

375 newSessionId <- nextRandom

411 atomically $ createSessionAtCommit_ commitId newSessionId conn

376 atomically $ createSessionAtCommit_ commitId newSessionId conn

412−createSessionAtCommit conn@(RemoteProcessConnection _) uuid = remoteCall conn (CreateSessionAtCommit uuid)

377+createSessionAtCommit conn@(RemoteConnection _) uuid = remoteCall conn (CreateSessionAtCommit uuid)

413

378

414createSessionAtCommit_ :: TransactionId -> SessionId -> Connection -> STM (Either RelationalError SessionId)

379createSessionAtCommit_ :: TransactionId -> SessionId -> Connection -> STM (Either RelationalError SessionId)

415createSessionAtCommit_ commitId newSessionId (InProcessConnection conf) = do

380createSessionAtCommit_ commitId newSessionId (InProcessConnection conf) = do

@@ -426,7 +391,7 @@ createSessionAtCommit_ commitId newSessionId (InProcessConnection conf) = do

426 Nothing -> do

391 Nothing -> do

427 StmMap.insert (Session freshDiscon defaultSchemaName) newSessionId sessions

392 StmMap.insert (Session freshDiscon defaultSchemaName) newSessionId sessions

428 pure $ Right newSessionId

393 pure $ Right newSessionId

429−createSessionAtCommit_ _ _ (RemoteProcessConnection _) = error "createSessionAtCommit_ called on remote connection"

394+createSessionAtCommit_ _ _ (RemoteConnection _) = error "createSessionAtCommit_ called on remote connection"

430

395

431-- | Call 'createSessionAtHead' with a transaction graph's head's name to create a new session pinned to that head. This function returns a 'SessionId' which can be used in other function calls to reference the point in the transaction graph.

396-- | Call 'createSessionAtHead' with a transaction graph's head's name to create a new session pinned to that head. This function returns a 'SessionId' which can be used in other function calls to reference the point in the transaction graph.

432createSessionAtHead :: Connection -> HeadName -> IO (Either RelationalError SessionId)

397createSessionAtHead :: Connection -> HeadName -> IO (Either RelationalError SessionId)

@@ -438,22 +403,18 @@ createSessionAtHead conn@(InProcessConnection conf) headn = do

438 case transactionForHead headn graph of

403 case transactionForHead headn graph of

439 Nothing -> pure $ Left (NoSuchHeadNameError headn)

404 Nothing -> pure $ Left (NoSuchHeadNameError headn)

440 Just trans -> createSessionAtCommit_ (transactionId trans) newSessionId conn

405 Just trans -> createSessionAtCommit_ (transactionId trans) newSessionId conn

441−createSessionAtHead conn@(RemoteProcessConnection _) headn = remoteCall conn (CreateSessionAtHead headn)

406+createSessionAtHead conn@(RemoteConnection _) headn = remoteCall conn (CreateSessionAtHead headn)

442−

443−-- | Used internally for server connections to keep track of remote nodes for the purpose of sending notifications later.

444−addClientNode :: Connection -> ProcessId -> IO ()

445−addClientNode (RemoteProcessConnection _) _ = error "addClientNode called on remote connection"

446−addClientNode (InProcessConnection conf) newProcessId = atomically (StmSet.insert newProcessId (ipClientNodes conf))

447

407

448-- | Discards a session, eliminating any uncommitted changes present in the session.

408-- | Discards a session, eliminating any uncommitted changes present in the session.

449closeSession :: SessionId -> Connection -> IO ()

409closeSession :: SessionId -> Connection -> IO ()

450closeSession sessionId (InProcessConnection conf) =

410closeSession sessionId (InProcessConnection conf) =

451 atomically $ StmMap.delete sessionId (ipSessions conf)

411 atomically $ StmMap.delete sessionId (ipSessions conf)

452−closeSession sessionId conn@(RemoteProcessConnection _) = remoteCall conn (CloseSession sessionId)

412+closeSession sessionId conn@(RemoteConnection _) = remoteCall conn (CloseSession sessionId)

453

413

454-- | 'close' cleans up the database access connection and closes any relevant sockets.

414-- | 'close' cleans up the database access connection and closes any relevant sockets.

455close :: Connection -> IO ()

415close :: Connection -> IO ()

456close (InProcessConnection conf) = do

416close (InProcessConnection conf) = do

417+ cancel (ipCallbackAsync conf)

457 atomically $ do

418 atomically $ do

458 let sessions = ipSessions conf

419 let sessions = ipSessions conf

459#if MIN_VERSION_stm_containers(1,0,0)

420#if MIN_VERSION_stm_containers(1,0,0)

@@ -462,22 +423,18 @@ close (InProcessConnection conf) = do

462 StmMap.deleteAll sessions

423 StmMap.deleteAll sessions

463#endif

424#endif

464 pure ()

425 pure ()

465− closeLocalNode (ipLocalNode conf)

466− closeTransport (ipTransport conf)

467 let mLocks = ipLocks conf

426 let mLocks = ipLocks conf

468 case mLocks of

427 case mLocks of

469 Nothing -> pure ()

428 Nothing -> pure ()

470 Just (lockFileH, _) -> closeLockFile lockFileH

429 Just (lockFileH, _) -> closeLockFile lockFileH

471

430

472−close conn@(RemoteProcessConnection conf) = do

431+close (RemoteConnection (RemoteConnectionConf conn)) =

473− _ <- remoteCall conn Logout :: IO Bool

432+ RPC.close conn

474− closeLocalNode (rLocalNode conf)

475− closeTransport (rTransport conf)

476

433

477--used only by the server EntryPoints

434--used only by the server EntryPoints

478closeRemote_ :: Connection -> IO ()

435closeRemote_ :: Connection -> IO ()

479closeRemote_ (InProcessConnection _) = error "invalid call of closeRemote_ on InProcessConnection"

436closeRemote_ (InProcessConnection _) = error "invalid call of closeRemote_ on InProcessConnection"

480−closeRemote_ (RemoteProcessConnection conf) = runProcess (rLocalNode conf) (reconnect (rProcessId conf))

437+closeRemote_ (RemoteConnection (RemoteConnectionConf conn)) = RPC.close conn

481

438

482 --we need to actually close the localNode's connection to the remote

439 --we need to actually close the localNode's connection to the remote

483--within the database server, we must catch and handle all exception lest they take down the database process- this handling might be different for other use-cases

440--within the database server, we must catch and handle all exception lest they take down the database process- this handling might be different for other use-cases

@@ -488,35 +445,15 @@ excEither = handle handler

488 where

445 where

489 handler exc | Just (_ :: AsyncException) <- fromException exc = throwIO exc

446 handler exc | Just (_ :: AsyncException) <- fromException exc = throwIO exc

490 | otherwise = pure (Left (UnhandledExceptionError (show exc)))

447 | otherwise = pure (Left (UnhandledExceptionError (show exc)))

491−

492−runProcessResult :: LocalNode -> Process a -> IO a

493−runProcessResult localNode proc = do

494− ret <- newEmptyMVar

495− runProcess localNode $ do

496− val <- proc

497− liftIO $ putMVar ret val

498− takeMVar ret

499−

500−safeLogin :: Login -> ProcessId -> Process Bool

501−safeLogin login procId = do

502− ret <- call procId login

503− case ret of

504− Left (_ :: ServerError) -> pure False

505− Right val -> pure val

506

448

449+

507−remoteCall :: (Binary a, Binary b, Typeable a, Typeable b) => Connection -> a -> IO b

450+remoteCall :: (Serialise a, Serialise b) => Connection -> a -> IO b

508remoteCall (InProcessConnection _ ) _ = error "remoteCall called on local connection"

451remoteCall (InProcessConnection _ ) _ = error "remoteCall called on local connection"

509−remoteCall (RemoteProcessConnection conf) arg = runProcessResult localNode $ do

452+remoteCall (RemoteConnection (RemoteConnectionConf rpcConn)) arg = do

510− ret <- safeCall serverProcessId arg

453+ eRet <- RPC.call rpcConn arg

511− case ret of

454+ case eRet of

512− Left err -> error ("server died: " ++ show err)

455+ Left err -> convertRPCErrors err

513− Right ret' -> case ret' of

514− Left RequestTimeoutError -> liftIO (throwIO RequestTimeoutException)

515− Left (ProcessDiedError _) -> liftIO (throwIO RemoteProcessDiedException)

516− Right val -> pure val

456+ Right val -> pure val

517− where

518− localNode = rLocalNode conf

519− serverProcessId = rProcessId conf

520

457

521sessionForSessionId :: SessionId -> Sessions -> STM (Either RelationalError Session)

458sessionForSessionId :: SessionId -> Sessions -> STM (Either RelationalError Session)

522sessionForSessionId sessionId sessions =

459sessionForSessionId sessionId sessions =

@@ -551,7 +488,7 @@ currentSchemaName sessionId (InProcessConnection conf) = atomically $ do

551 case eSession of

488 case eSession of

552 Left err -> pure (Left err)

489 Left err -> pure (Left err)

553 Right session -> pure (Right (Sess.schemaName session))

490 Right session -> pure (Right (Sess.schemaName session))

554−currentSchemaName sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveCurrentSchemaName sessionId)

491+currentSchemaName sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveCurrentSchemaName sessionId)

555

492

556-- | Switch to the named isomorphic schema.

493-- | Switch to the named isomorphic schema.

557setCurrentSchemaName :: SessionId -> Connection -> SchemaName -> IO (Either RelationalError ())

494setCurrentSchemaName :: SessionId -> Connection -> SchemaName -> IO (Either RelationalError ())

@@ -563,7 +500,7 @@ setCurrentSchemaName sessionId (InProcessConnection conf) sname = atomically $ d

563 Right session -> case Sess.setSchemaName sname session of

500 Right session -> case Sess.setSchemaName sname session of

564 Left err -> pure (Left err)

501 Left err -> pure (Left err)

565 Right newSession -> StmMap.insert newSession sessionId sessions >> pure (Right ())

502 Right newSession -> StmMap.insert newSession sessionId sessions >> pure (Right ())

566−setCurrentSchemaName sessionId conn@(RemoteProcessConnection _) sname = remoteCall conn (ExecuteSetCurrentSchema sessionId sname)

503+setCurrentSchemaName sessionId conn@(RemoteConnection _) sname = remoteCall conn (ExecuteSetCurrentSchema sessionId sname)

567

504

568-- | Execute a relational expression in the context of the session and connection. Relational expressions are queries and therefore cannot alter the database.

505-- | Execute a relational expression in the context of the session and connection. Relational expressions are queries and therefore cannot alter the database.

569executeRelationalExpr :: SessionId -> Connection -> RelationalExpr -> IO (Either RelationalError Relation)

506executeRelationalExpr :: SessionId -> Connection -> RelationalExpr -> IO (Either RelationalError Relation)

@@ -587,7 +524,7 @@ executeRelationalExpr sessionId (InProcessConnection conf) expr = excEither $ at

587 Right rel -> pure (force (Right rel)) -- this is necessary so that any undefined/error exceptions are spit out here

524 Right rel -> pure (force (Right rel)) -- this is necessary so that any undefined/error exceptions are spit out here

588 Left err -> pure (Left err)

525 Left err -> pure (Left err)

589

526

590−executeRelationalExpr sessionId conn@(RemoteProcessConnection _) relExpr = remoteCall conn (ExecuteRelationalExpr sessionId relExpr)

527+executeRelationalExpr sessionId conn@(RemoteConnection _) relExpr = remoteCall conn (ExecuteRelationalExpr sessionId relExpr)

591

528

592-- | Execute a database context expression in the context of the session and connection. Database expressions modify the current session's disconnected transaction but cannot modify the transaction graph.

529-- | Execute a database context expression in the context of the session and connection. Database expressions modify the current session's disconnected transaction but cannot modify the transaction graph.

593executeDatabaseContextExpr :: SessionId -> Connection -> DatabaseContextExpr -> IO (Either RelationalError ())

530executeDatabaseContextExpr :: SessionId -> Connection -> DatabaseContextExpr -> IO (Either RelationalError ())

@@ -621,7 +558,7 @@ executeDatabaseContextExpr sessionId (InProcessConnection conf) expr = excEither

621 newSession = Session newDiscon (Sess.schemaName session)

558 newSession = Session newDiscon (Sess.schemaName session)

622 StmMap.insert newSession sessionId sessions

559 StmMap.insert newSession sessionId sessions

623 pure (Right ())

560 pure (Right ())

624−executeDatabaseContextExpr sessionId conn@(RemoteProcessConnection _) dbExpr = remoteCall conn (ExecuteDatabaseContextExpr sessionId dbExpr)

561+executeDatabaseContextExpr sessionId conn@(RemoteConnection _) dbExpr = remoteCall conn (ExecuteDatabaseContextExpr sessionId dbExpr)

625

562

626-- | Similar to a git rebase, 'autoMergeToHead' atomically creates a temporary branch and merges it to the latest commit of the branch referred to by the 'HeadName' and commits the merge. This is useful to reduce incidents of 'TransactionIsNotAHeadError's but at the risk of merge errors (thus making it similar to rebasing). Alternatively, as an optimization, if a simple commit is possible (meaning that the head has not changed), then a fast-forward commit takes place instead.

563-- | Similar to a git rebase, 'autoMergeToHead' atomically creates a temporary branch and merges it to the latest commit of the branch referred to by the 'HeadName' and commits the merge. This is useful to reduce incidents of 'TransactionIsNotAHeadError's but at the risk of merge errors (thus making it similar to rebasing). Alternatively, as an optimization, if a simple commit is possible (meaning that the head has not changed), then a fast-forward commit takes place instead.

627autoMergeToHead :: SessionId -> Connection -> MergeStrategy -> HeadName -> IO (Either RelationalError ())

564autoMergeToHead :: SessionId -> Connection -> MergeStrategy -> HeadName -> IO (Either RelationalError ())

@@ -650,7 +587,7 @@ autoMergeToHead sessionId (InProcessConnection conf) strat headName' = do

650 Left err -> pure (Left err)

587 Left err -> pure (Left err)

651 Right ((discon', graph'), transactionIdsAdded) ->

588 Right ((discon', graph'), transactionIdsAdded) ->

652 pure (Right (discon', graph', transactionIdsAdded))

589 pure (Right (discon', graph', transactionIdsAdded))

653−autoMergeToHead sessionId conn@(RemoteProcessConnection _) strat headName' = remoteCall conn (ExecuteAutoMergeToHead sessionId strat headName')

590+autoMergeToHead sessionId conn@(RemoteConnection _) strat headName' = remoteCall conn (ExecuteAutoMergeToHead sessionId strat headName')

654

591

655-- | Execute a database context IO-monad-based expression for the given session and connection. `DatabaseContextIOExpr`s modify the DatabaseContext but cannot be purely implemented.

592-- | Execute a database context IO-monad-based expression for the given session and connection. `DatabaseContextIOExpr`s modify the DatabaseContext but cannot be purely implemented.

656--this is almost completely identical to executeDatabaseContextExpr above

593--this is almost completely identical to executeDatabaseContextExpr above

@@ -676,22 +613,8 @@ executeDatabaseContextIOExpr sessionId (InProcessConnection conf) expr = excEith

676 context' = RE.dbc_context newState

613 context' = RE.dbc_context newState

677 atomically $ StmMap.insert newSession sessionId sessions

614 atomically $ StmMap.insert newSession sessionId sessions

678 pure (Right ())

615 pure (Right ())

679−executeDatabaseContextIOExpr sessionId conn@(RemoteProcessConnection _) dbExpr = remoteCall conn (ExecuteDatabaseContextIOExpr sessionId dbExpr)

616+executeDatabaseContextIOExpr sessionId conn@(RemoteConnection _) dbExpr = remoteCall conn (ExecuteDatabaseContextIOExpr sessionId dbExpr)

680

617

681−{-

682−executeGraphExprSTM_ :: TransactionId -> SessionId -> Session -> Sessions -> TransactionGraphOperator -> TransactionGraph -> TVar TransactionGraph -> STM (Either RelationalError (TransactionGraph, DisconnectedTransaction)

683−executeGraphExprSTM_ freshId sessionId session sessions graphExpr graph graphTVar= do

684− case evalGraphOp freshId (Sess.disconnectedTransaction session) graph graphExpr of

685− Left err -> do

686− when updateGraphOnError (writeTVar graphTVar graph)

687− pure $ Left err

688− Right (discon', graph') -> do

689− writeTVar graphTVar graph'

690− let newSession = Session discon' (Sess.schemaName session)

691− STMMap.insert newSession sessionId sessions

692− pure $ Right graph'

693−-}

694−

695-- process notifications for commits

618-- process notifications for commits

696executeCommitExprSTM_

619executeCommitExprSTM_

697 :: TransactionGraph

620 :: TransactionGraph

@@ -732,78 +655,8 @@ executeGraphExpr sessionId (InProcessConnection conf) graphExpr = excEither $ do

732 --if freshId appears in the graph, then we need to pass it on

655 --if freshId appears in the graph, then we need to pass it on

733 let transIds = [freshId | isRight (RE.transactionForId freshId graph')]

656 let transIds = [freshId | isRight (RE.transactionForId freshId graph')]

734 pure (Right (discon', graph', transIds))

657 pure (Right (discon', graph', transIds))

735−{-

658+

736−executeGraphExpr sessionId (InProcessConnection conf) graphExpr = excEither $ do

737− let strat = ipPersistenceStrategy conf

738− clientNodes = ipClientNodes conf

739− sessions = ipSessions conf

740− graphTvar = ipTransactionGraph conf

741− mLockFileH = ipLocks conf

742− lockHandler body = case graphExpr of

743− Commit -> case mLockFileH of

744− Nothing -> body False

745− Just (lockFileH, lockMVar) -> let acquireLocks = do

746− lastWrittenDigest <- takeMVar lockMVar

747− lockFile lockFileH WriteLock

748− latestDigest <- readGraphTransactionIdDigest strat

749− pure (latestDigest /= lastWrittenDigest)

750−

751− releaseLocks _ = do

752− --still holding the lock- get the latest digest

753− gDigest <- readGraphTransactionIdDigest strat

754− unlockFile lockFileH

755− putMVar lockMVar gDigest

756− in bracket acquireLocks releaseLocks body

757− _ -> body False

758− freshId <- nextRandom

759− lockHandler $ \dbWrittenByOtherProcess -> do

760− --if the database file has been updated since we wrote it last, load it before trying to sync our version done- this can result in TransactionNotAHeadErrors

761− --read transaction data and compare to existing graph

762− --in the future, we can detect if updated transaction graph can be safely merged (such as with a transaction on a separate head) (rebase-able commits should force the user to rebase from the client to confirm that the action makes sense)

763− manip <- atomically $ do

764− eSession <- sessionForSessionId sessionId sessions

765− --handle graph update by other process

766− oldGraph <- readTVar graphTvar

767− case eSession of

768− Left err -> pure (Left err)

769− Right session -> do

770− let mScriptSession = ipScriptSession conf

771− dbdir = case strat of

772− MinimalPersistence x -> x

773− CrashSafePersistence x -> x

774− _ -> error "accessing dbdir on non-persisted connection"

775− eRefreshedGraph <- if dbWrittenByOtherProcess then

776− unsafeIOToSTM (transactionGraphLoad dbdir oldGraph mScriptSession)

777− else

778− pure (Right oldGraph)

779− case eRefreshedGraph of

780− Left err -> pure (Left (DatabaseLoadError err))

781− Right refreshedGraph -> do

782− --snip it

783− eGraph <- executeGraphExprSTM_ dbWrittenByOtherProcess freshId sessionId session sessions graphExpr refreshedGraph graphTvar

784− --snip it

785− case eGraph of

786− Left err -> pure (Left err)

787− Right newGraph -> do

788− --handle commit

789− if isCommit graphExpr then do

790− case transactionForId (Sess.parentId session) oldGraph of

791− Left err -> pure $ Left err

792− Right previousTrans -> do

793− (evaldNots, nodes) <- executeCommitExprSTM_ (Trans.concreteDatabaseContext previousTrans) (Sess.concreteDatabaseContext session) clientNodes

794− nodesToNotify <- toList (StmSet.stream nodes)

795− pure $ Right (evaldNots, nodesToNotify, newGraph)

796− else

797− pure $ Right (M.empty, [], newGraph)

798− case manip of

799− Left err -> return $ Just err

800− Right (notsToFire, nodesToNotify, newGraph) -> do

801− --update filesystem database, if necessary

802− processTransactionGraphPersistence strat newGraph

803− sendNotifications nodesToNotify (ipLocalNode conf) notsToFire

804− pure Nothing

805−-}

806−executeGraphExpr sessionId conn@(RemoteProcessConnection _) graphExpr = remoteCall conn (ExecuteGraphExpr sessionId graphExpr)

659+executeGraphExpr sessionId conn@(RemoteConnection _) graphExpr = remoteCall conn (ExecuteGraphExpr sessionId graphExpr)

807

660

808-- | A trans-graph expression is a relational query executed against the entirety of a transaction graph.

661-- | A trans-graph expression is a relational query executed against the entirety of a transaction graph.

809executeTransGraphRelationalExpr :: SessionId -> Connection -> TransGraphRelationalExpr -> IO (Either RelationalError Relation)

662executeTransGraphRelationalExpr :: SessionId -> Connection -> TransGraphRelationalExpr -> IO (Either RelationalError Relation)

@@ -811,10 +664,7 @@ executeTransGraphRelationalExpr _ (InProcessConnection conf) tgraphExpr = excEit

811 let graphTvar = ipTransactionGraph conf

664 let graphTvar = ipTransactionGraph conf

812 graph <- readTVar graphTvar

665 graph <- readTVar graphTvar

813 pure $ force $ optimizeAndEvalTransGraphRelationalExpr graph tgraphExpr

666 pure $ force $ optimizeAndEvalTransGraphRelationalExpr graph tgraphExpr

814−{- case runReader (RE.evalRelationalExpr relExpr) (RE.mkRelationalExprState DBC.empty) of

815− Left err -> pure (Left err)

816− Right rel -> pure (force (Right rel))-}

817−executeTransGraphRelationalExpr sessionId conn@(RemoteProcessConnection _) tgraphExpr = remoteCall conn (ExecuteTransGraphRelationalExpr sessionId tgraphExpr)

667+executeTransGraphRelationalExpr sessionId conn@(RemoteConnection _) tgraphExpr = remoteCall conn (ExecuteTransGraphRelationalExpr sessionId tgraphExpr)

818

668

819-- | Schema expressions manipulate the isomorphic schemas for the current 'DatabaseContext'.

669-- | Schema expressions manipulate the isomorphic schemas for the current 'DatabaseContext'.

820executeSchemaExpr :: SessionId -> Connection -> Schema.SchemaExpr -> IO (Either RelationalError ())

670executeSchemaExpr :: SessionId -> Connection -> Schema.SchemaExpr -> IO (Either RelationalError ())

@@ -837,23 +687,24 @@ executeSchemaExpr sessionId (InProcessConnection conf) schemaExpr = atomically $

837 newSession = Session (DisconnectedTransaction (Discon.parentId discon) newSchemas False) (Sess.schemaName session)

687 newSession = Session (DisconnectedTransaction (Discon.parentId discon) newSchemas False) (Sess.schemaName session)

838 StmMap.insert newSession sessionId sessions

688 StmMap.insert newSession sessionId sessions

839 pure (Right ())

689 pure (Right ())

840−executeSchemaExpr sessionId conn@(RemoteProcessConnection _) schemaExpr = remoteCall conn (ExecuteSchemaExpr sessionId schemaExpr)

690+executeSchemaExpr sessionId conn@(RemoteConnection _) schemaExpr = remoteCall conn (ExecuteSchemaExpr sessionId schemaExpr)

841

691

842-- | After modifying a 'DatabaseContext', 'commit' the transaction to the transaction graph at the head which the session is referencing. This will also trigger checks for any notifications which need to be propagated.

692-- | After modifying a 'DatabaseContext', 'commit' the transaction to the transaction graph at the head which the session is referencing. This will also trigger checks for any notifications which need to be propagated.

843commit :: SessionId -> Connection -> IO (Either RelationalError ())

693commit :: SessionId -> Connection -> IO (Either RelationalError ())

844commit sessionId conn@(InProcessConnection _) = executeGraphExpr sessionId conn Commit

694commit sessionId conn@(InProcessConnection _) = executeGraphExpr sessionId conn Commit

845−commit sessionId conn@(RemoteProcessConnection _) = remoteCall conn (ExecuteGraphExpr sessionId Commit)

695+commit sessionId conn@(RemoteConnection _) = remoteCall conn (ExecuteGraphExpr sessionId Commit)

846−

696+

847−sendNotifications :: [ProcessId] -> LocalNode -> EvaluatedNotifications -> IO ()

697+sendNotifications :: [ClientInfo] -> EvaluatedNotifications -> IO ()

848−sendNotifications pids localNode nots = mapM_ sendNots pids

698+sendNotifications clients notifs =

849− where

699+ unless (M.null notifs) $ forM_ clients sender

850− sendNots remoteClientPid =

700+ where

851− unless (M.null nots) $ runProcess localNode $ send remoteClientPid (NotificationMessage nots)

701+ sender (RemoteClientInfo sock) = RPC.sendMessage sock (NotificationMessage notifs)

852−

702+ sender (InProcessClientInfo tvar) = putMVar tvar notifs

703+

853-- | Discard any changes made in the current 'Session' and 'DatabaseContext'. This resets the disconnected transaction to reference the original database context of the parent transaction and is a very cheap operation.

704-- | Discard any changes made in the current 'Session' and 'DatabaseContext'. This resets the disconnected transaction to reference the original database context of the parent transaction and is a very cheap operation.

854rollback :: SessionId -> Connection -> IO (Either RelationalError ())

705rollback :: SessionId -> Connection -> IO (Either RelationalError ())

855rollback sessionId conn@(InProcessConnection _) = executeGraphExpr sessionId conn Rollback

706rollback sessionId conn@(InProcessConnection _) = executeGraphExpr sessionId conn Rollback

856−rollback sessionId conn@(RemoteProcessConnection _) = remoteCall conn (ExecuteGraphExpr sessionId Rollback)

707+rollback sessionId conn@(RemoteConnection _) = remoteCall conn (ExecuteGraphExpr sessionId Rollback)

857

708

858-- | Write the transaction graph to disk. This function can be used to incrementally write new transactions to disk.

709-- | Write the transaction graph to disk. This function can be used to incrementally write new transactions to disk.

859processTransactionGraphPersistence :: PersistenceStrategy -> [TransactionId] -> TransactionGraph -> IO ()

710processTransactionGraphPersistence :: PersistenceStrategy -> [TransactionId] -> TransactionGraph -> IO ()

@@ -869,7 +720,7 @@ readGraphTransactionIdDigest (CrashSafePersistence dbdir) = readGraphTransaction

869-- | Return a relation whose type would match that of the relational expression if it were executed. This is useful for checking types and validating a relational expression's types.

720-- | Return a relation whose type would match that of the relational expression if it were executed. This is useful for checking types and validating a relational expression's types.

870typeForRelationalExpr :: SessionId -> Connection -> RelationalExpr -> IO (Either RelationalError Relation)

721typeForRelationalExpr :: SessionId -> Connection -> RelationalExpr -> IO (Either RelationalError Relation)

871typeForRelationalExpr sessionId conn@(InProcessConnection _) relExpr = atomically $ typeForRelationalExprSTM sessionId conn relExpr

722typeForRelationalExpr sessionId conn@(InProcessConnection _) relExpr = atomically $ typeForRelationalExprSTM sessionId conn relExpr

872−typeForRelationalExpr sessionId conn@(RemoteProcessConnection _) relExpr = remoteCall conn (ExecuteTypeForRelationalExpr sessionId relExpr)

723+typeForRelationalExpr sessionId conn@(RemoteConnection _) relExpr = remoteCall conn (ExecuteTypeForRelationalExpr sessionId relExpr)

873

724

874typeForRelationalExprSTM :: SessionId -> Connection -> RelationalExpr -> STM (Either RelationalError Relation)

725typeForRelationalExprSTM :: SessionId -> Connection -> RelationalExpr -> STM (Either RelationalError Relation)

875typeForRelationalExprSTM sessionId (InProcessConnection conf) relExpr = do

726typeForRelationalExprSTM sessionId (InProcessConnection conf) relExpr = do

@@ -906,7 +757,7 @@ inclusionDependencies sessionId (InProcessConnection conf) = do

906 else

757 else

907 pure (Schema.inclusionDependenciesInSchema schema (B.inclusionDependencies context))

758 pure (Schema.inclusionDependenciesInSchema schema (B.inclusionDependencies context))

908

759

909−inclusionDependencies sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveInclusionDependencies sessionId)

760+inclusionDependencies sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveInclusionDependencies sessionId)

910

761

911typeConstructorMapping :: SessionId -> Connection -> IO (Either RelationalError TypeConstructorMapping)

762typeConstructorMapping :: SessionId -> Connection -> IO (Either RelationalError TypeConstructorMapping)

912typeConstructorMapping sessionId (InProcessConnection conf) = do

763typeConstructorMapping sessionId (InProcessConnection conf) = do

@@ -917,7 +768,7 @@ typeConstructorMapping sessionId (InProcessConnection conf) = do

917 Left err -> pure $ Left err

768 Left err -> pure $ Left err

918 Right (session, _) -> --warning, no schema support for typeconstructors

769 Right (session, _) -> --warning, no schema support for typeconstructors

919 pure (Right (B.typeConstructorMapping (Sess.concreteDatabaseContext session)))

770 pure (Right (B.typeConstructorMapping (Sess.concreteDatabaseContext session)))

920−typeConstructorMapping sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveTypeConstructorMapping sessionId)

771+typeConstructorMapping sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveTypeConstructorMapping sessionId)

921

772

922-- | Return an optimized database expression which is logically equivalent to the input database expression. This function can be used to determine which expression will actually be evaluated.

773-- | Return an optimized database expression which is logically equivalent to the input database expression. This function can be used to determine which expression will actually be evaluated.

923planForDatabaseContextExpr :: SessionId -> Connection -> DatabaseContextExpr -> IO (Either RelationalError GraphRefDatabaseContextExpr)

774planForDatabaseContextExpr :: SessionId -> Connection -> DatabaseContextExpr -> IO (Either RelationalError GraphRefDatabaseContextExpr)

@@ -937,7 +788,7 @@ planForDatabaseContextExpr sessionId (InProcessConnection conf) dbExpr = do

937 else -- don't show any optimization because the current optimization infrastructure relies on access to the base context- this probably underscores the need for each schema to have its own DatabaseContext, even if it is generated on-the-fly-}

788 else -- don't show any optimization because the current optimization infrastructure relies on access to the base context- this probably underscores the need for each schema to have its own DatabaseContext, even if it is generated on-the-fly-}

938 pure (Left NonConcreteSchemaPlanError)

789 pure (Left NonConcreteSchemaPlanError)

939

790

940−planForDatabaseContextExpr sessionId conn@(RemoteProcessConnection _) dbExpr = remoteCall conn (RetrievePlanForDatabaseContextExpr sessionId dbExpr)

791+planForDatabaseContextExpr sessionId conn@(RemoteConnection _) dbExpr = remoteCall conn (RetrievePlanForDatabaseContextExpr sessionId dbExpr)

941

792

942-- | Return a relation which represents the current state of the global transaction graph. The attributes are

793-- | Return a relation which represents the current state of the global transaction graph. The attributes are

943-- * current- boolean attribute representing whether or not the current session references this transaction

794-- * current- boolean attribute representing whether or not the current session references this transaction

@@ -955,7 +806,7 @@ transactionGraphAsRelation sessionId (InProcessConnection conf) = do

955 Right session ->

806 Right session ->

956 graphAsRelation (Sess.disconnectedTransaction session) <$> readTVar tvar

807 graphAsRelation (Sess.disconnectedTransaction session) <$> readTVar tvar

957

808

958−transactionGraphAsRelation sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveTransactionGraph sessionId)

809+transactionGraphAsRelation sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveTransactionGraph sessionId)

959

810

960-- | Returns the names and types of the relation variables in the current 'Session'.

811-- | Returns the names and types of the relation variables in the current 'Session'.

961relationVariablesAsRelation :: SessionId -> Connection -> IO (Either RelationalError Relation)

812relationVariablesAsRelation :: SessionId -> Connection -> IO (Either RelationalError Relation)

@@ -977,7 +828,7 @@ relationVariablesAsRelation sessionId (InProcessConnection conf) = do

977 let schemaContext = context {relationVariables = relvars }

828 let schemaContext = context {relationVariables = relvars }

978 pure $ RE.relationVariablesAsRelation schemaContext graph

829 pure $ RE.relationVariablesAsRelation schemaContext graph

979

830

980−relationVariablesAsRelation sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveRelationVariableSummary sessionId)

831+relationVariablesAsRelation sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveRelationVariableSummary sessionId)

981

832

982-- | Returns the names and types of the atom functions in the current 'Session'.

833-- | Returns the names and types of the atom functions in the current 'Session'.

983atomFunctionsAsRelation :: SessionId -> Connection -> IO (Either RelationalError Relation)

834atomFunctionsAsRelation :: SessionId -> Connection -> IO (Either RelationalError Relation)

@@ -990,7 +841,7 @@ atomFunctionsAsRelation sessionId (InProcessConnection conf) = do

990 Right (session, _) ->

841 Right (session, _) ->

991 pure (AF.atomFunctionsAsRelation (atomFunctions (concreteDatabaseContext session)))

842 pure (AF.atomFunctionsAsRelation (atomFunctions (concreteDatabaseContext session)))

992

843

993−atomFunctionsAsRelation sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveAtomFunctionSummary sessionId)

844+atomFunctionsAsRelation sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveAtomFunctionSummary sessionId)

994

845

995databaseContextFunctionsAsRelation :: SessionId -> Connection -> IO (Either RelationalError Relation)

846databaseContextFunctionsAsRelation :: SessionId -> Connection -> IO (Either RelationalError Relation)

996databaseContextFunctionsAsRelation sessionId (InProcessConnection conf) = do

847databaseContextFunctionsAsRelation sessionId (InProcessConnection conf) = do

@@ -1002,7 +853,7 @@ databaseContextFunctionsAsRelation sessionId (InProcessConnection conf) = do

1002 Right (session, _) ->

853 Right (session, _) ->

1003 pure (DCF.databaseContextFunctionsAsRelation (dbcFunctions (concreteDatabaseContext session)))

854 pure (DCF.databaseContextFunctionsAsRelation (dbcFunctions (concreteDatabaseContext session)))

1004

855

1005−databaseContextFunctionsAsRelation sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveDatabaseContextFunctionSummary sessionId)

856+databaseContextFunctionsAsRelation sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveDatabaseContextFunctionSummary sessionId)

1006

857

1007-- | Returns the transaction id for the connection's disconnected transaction committed parent transaction.

858-- | Returns the transaction id for the connection's disconnected transaction committed parent transaction.

1008headTransactionId :: SessionId -> Connection -> IO (Either RelationalError TransactionId)

859headTransactionId :: SessionId -> Connection -> IO (Either RelationalError TransactionId)

@@ -1013,7 +864,7 @@ headTransactionId sessionId (InProcessConnection conf) = do

1013 case eSession of

864 case eSession of

1014 Left err -> pure (Left err)

865 Left err -> pure (Left err)

1015 Right session -> pure $ Right (Sess.parentId session)

866 Right session -> pure $ Right (Sess.parentId session)

1016−headTransactionId sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveHeadTransactionId sessionId)

867+headTransactionId sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveHeadTransactionId sessionId)

1017

868

1018headNameSTM_ :: SessionId -> Sessions -> TVar TransactionGraph -> STM (Either RelationalError HeadName)

869headNameSTM_ :: SessionId -> Sessions -> TVar TransactionGraph -> STM (Either RelationalError HeadName)

1019headNameSTM_ sessionId sessions graphTvar = do

870headNameSTM_ sessionId sessions graphTvar = do

@@ -1033,7 +884,7 @@ headName sessionId (InProcessConnection conf) = do

1033 let sessions = ipSessions conf

884 let sessions = ipSessions conf

1034 graphTvar = ipTransactionGraph conf

885 graphTvar = ipTransactionGraph conf

1035 atomically (headNameSTM_ sessionId sessions graphTvar)

886 atomically (headNameSTM_ sessionId sessions graphTvar)

1036−headName sessionId conn@(RemoteProcessConnection _) = remoteCall conn (ExecuteHeadName sessionId)

887+headName sessionId conn@(RemoteConnection _) = remoteCall conn (ExecuteHeadName sessionId)

1037

888

1038-- | Returns a listing of all available atom types.

889-- | Returns a listing of all available atom types.

1039atomTypesAsRelation :: SessionId -> Connection -> IO (Either RelationalError Relation)

890atomTypesAsRelation :: SessionId -> Connection -> IO (Either RelationalError Relation)

@@ -1047,7 +898,7 @@ atomTypesAsRelation sessionId (InProcessConnection conf) = do

1047 case typesAsRelation (B.typeConstructorMapping (Sess.concreteDatabaseContext session)) of

898 case typesAsRelation (B.typeConstructorMapping (Sess.concreteDatabaseContext session)) of

1048 Left err -> pure (Left err)

899 Left err -> pure (Left err)

1049 Right rel -> pure (Right rel)

900 Right rel -> pure (Right rel)

1050−atomTypesAsRelation sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveAtomTypesAsRelation sessionId)

901+atomTypesAsRelation sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveAtomTypesAsRelation sessionId)

1051

902

1052disconnectedTransactionIsDirty :: SessionId -> Connection -> IO (Either RelationalError Bool)

903disconnectedTransactionIsDirty :: SessionId -> Connection -> IO (Either RelationalError Bool)

1053disconnectedTransactionIsDirty sessionId (InProcessConnection conf) = do

904disconnectedTransactionIsDirty sessionId (InProcessConnection conf) = do

@@ -1058,12 +909,12 @@ disconnectedTransactionIsDirty sessionId (InProcessConnection conf) = do

1058 Left err -> pure (Left err)

909 Left err -> pure (Left err)

1059 Right session ->

910 Right session ->

1060 pure (Right (isDirty session))

911 pure (Right (isDirty session))

1061−disconnectedTransactionIsDirty sessionId conn@(RemoteProcessConnection _) = remoteCall conn (RetrieveSessionIsDirty sessionId)

912+disconnectedTransactionIsDirty sessionId conn@(RemoteConnection _) = remoteCall conn (RetrieveSessionIsDirty sessionId)

1062

913

1063--used only for testing- we expect this to throw an exception

914--used only for testing- we expect this to throw an exception

1064callTestTimeout_ :: SessionId -> Connection -> IO Bool

915callTestTimeout_ :: SessionId -> Connection -> IO Bool

1065callTestTimeout_ _ (InProcessConnection _) = error "bad testing call"

916callTestTimeout_ _ (InProcessConnection _) = error "bad testing call"

1066−callTestTimeout_ sessionId conn@(RemoteProcessConnection _) = remoteCall conn (TestTimeout sessionId)

917+callTestTimeout_ sessionId conn@(RemoteConnection _) = remoteCall conn (TestTimeout sessionId)

1067

918

1068--used in tests only

919--used in tests only

1069transactionGraph_ :: Connection -> IO TransactionGraph

920transactionGraph_ :: Connection -> IO TransactionGraph

@@ -1148,15 +999,8 @@ commitLock_ sessionId conf stmBlock = do

1148 Right (notsToFire, nodesToNotify, newGraph, transactionIdsToPersist) -> do

999 Right (notsToFire, nodesToNotify, newGraph, transactionIdsToPersist) -> do

1149 --update filesystem database, if necessary

1000 --update filesystem database, if necessary

1150 processTransactionGraphPersistence strat transactionIdsToPersist newGraph

1001 processTransactionGraphPersistence strat transactionIdsToPersist newGraph

1151− sendNotifications nodesToNotify (ipLocalNode conf) notsToFire

1002+ sendNotifications nodesToNotify notsToFire

1152 pure (Right ())

1003 pure (Right ())

1153−{-

1154−writeDisconAndGraph_ :: TVar TransactionGraph -> SessionId -> Session -> Sessions -> DisconnectedTransaction -> TransactionGraph -> STM ()

1155−writeDisconAndGraph_ graphTvar sessionId session sessions discon graph = do

1156− writeTVar graphTvar graph

1157− let newSession = Session discon (Sess.schemaName session)

1158− StmMap.insert newSession sessionId sessions

1159−-}

1160

1004

1161-- | Runs an IO monad, commits the result when the monad returns no errors, otherwise, rolls back the changes and the error.

1005-- | Runs an IO monad, commits the result when the monad returns no errors, otherwise, rolls back the changes and the error.

1162withTransaction :: SessionId -> Connection -> IO (Either RelationalError a) -> IO (Either RelationalError ()) -> IO (Either RelationalError a)

1006withTransaction :: SessionId -> Connection -> IO (Either RelationalError a) -> IO (Either RelationalError ()) -> IO (Either RelationalError a)

@@ -1208,7 +1052,7 @@ executeDataFrameExpr sessionId conn@(InProcessConnection _) dfExpr = do

1208 let dFrame' = maybe dFrame (`DF.drop'` dFrame) (DF.offset dfExpr)

1052 let dFrame' = maybe dFrame (`DF.drop'` dFrame) (DF.offset dfExpr)

1209 dFrame'' = maybe dFrame' (`DF.take'` dFrame') (DF.limit dfExpr)

1053 dFrame'' = maybe dFrame' (`DF.take'` dFrame') (DF.limit dfExpr)

1210 pure (Right dFrame'')

1054 pure (Right dFrame'')

1211−executeDataFrameExpr sessionId conn@(RemoteProcessConnection _) dfExpr = remoteCall conn (ExecuteDataFrameExpr sessionId dfExpr)

1055+executeDataFrameExpr sessionId conn@(RemoteConnection _) dfExpr = remoteCall conn (ExecuteDataFrameExpr sessionId dfExpr)

1212

1056

1213validateMerkleHashes :: SessionId -> Connection -> IO (Either RelationalError ())

1057validateMerkleHashes :: SessionId -> Connection -> IO (Either RelationalError ())

1214validateMerkleHashes sessionId (InProcessConnection conf) = do

1058validateMerkleHashes sessionId (InProcessConnection conf) = do

@@ -1222,4 +1066,30 @@ validateMerkleHashes sessionId (InProcessConnection conf) = do

1222 case Graph.validateMerkleHashes graph of

1066 case Graph.validateMerkleHashes graph of

1223 Left merkleErrs -> pure $ Left $ someErrors (map (\(MerkleValidationError tid expected actual) -> MerkleHashValidationError tid expected actual) merkleErrs)

1067 Left merkleErrs -> pure $ Left $ someErrors (map (\(MerkleValidationError tid expected actual) -> MerkleHashValidationError tid expected actual) merkleErrs)

1224 Right () -> pure (Right ())

1068 Right () -> pure (Right ())

1225−validateMerkleHashes sessionId conn@RemoteProcessConnection{} = remoteCall conn (ExecuteValidateMerkleHashes sessionId)

1069+validateMerkleHashes sessionId conn@RemoteConnection{} = remoteCall conn (ExecuteValidateMerkleHashes sessionId)

1070+

1071+type ClientNodes = StmSet.Set ClientInfo

1072+

1073+-- internal structure specific to in-process connections

1074+data InProcessConnectionConf = InProcessConnectionConf {

1075+ ipPersistenceStrategy :: PersistenceStrategy,

1076+ ipClientNodes :: ClientNodes,

1077+ ipSessions :: Sessions,

1078+ ipTransactionGraph :: TVar TransactionGraph,

1079+ ipScriptSession :: Maybe ScriptSession,

1080+ ipLocks :: Maybe (LockFile, MVar LockFileHash), -- nothing when NoPersistence

1081+ ipCallbackAsync :: Async ()

1082+ }

1083+

1084+-- clients may connect associate one socket/mvar with the server to register for change callbacks

1085+data ClientInfo = RemoteClientInfo (RPC.Locking Socket) |

1086+ InProcessClientInfo (MVar EvaluatedNotifications)

1087+

1088+instance Eq ClientInfo where

1089+ (RemoteClientInfo a) == (RemoteClientInfo b) = RPC.lockless a == RPC.lockless b

1090+ (InProcessClientInfo a) == (InProcessClientInfo b) = a == b

1091+ _ == _ = False

1092+

1093+instance Hashable ClientInfo where

1094+ hashWithSalt salt (RemoteClientInfo sock) = hashWithSalt salt (show (RPC.lockless sock))

1095+ hashWithSalt salt (InProcessClientInfo _) = hashWithSalt salt (1::Int)

src/lib/ProjectM36/DataFrame.hs+21−14

@@ -1,8 +1,8 @@

1−{-# LANGUAGE DeriveGeneric, DeriveAnyClass #-}

1+{-# LANGUAGE DeriveGeneric, DerivingVia #-}

2{- A dataframe is a strongly-typed, ordered list of named tuples. A dataframe differs from a relation in that its tuples are ordered.-}

3module ProjectM36.DataFrame where

4import ProjectM36.Base

5−import ProjectM36.Attribute as A

5+import ProjectM36.Attribute as A hiding (drop)

6import ProjectM36.Error

7import qualified ProjectM36.Relation as R

8import ProjectM36.Relation.Show.Term

@@ -16,15 +16,19 @@ import qualified Data.List as L

16import qualified Data.Set as S

17import Data.Maybe

18import qualified Data.Text as T

19−import Data.Binary

20import Control.Arrow

19import Control.Arrow

21#if __GLASGOW_HASKELL__ < 804

20#if __GLASGOW_HASKELL__ < 804

22import Data.Monoid

21import Data.Monoid

23#endif

22#endif

25−data AttributeOrderExpr = AttributeOrderExpr AttributeName Order deriving (Show, Generic, Binary)

24+data AttributeOrderExpr = AttributeOrderExpr AttributeName Order

25+ deriving (Show, Generic)

26+

26−data AttributeOrder = AttributeOrder AttributeName Order deriving (Show, Generic, Binary)

27+data AttributeOrder = AttributeOrder AttributeName Order

28+ deriving (Show, Generic)

29+

27−data Order = AscendingOrder | DescendingOrder deriving (Eq, Show, Generic, Binary)

30+data Order = AscendingOrder | DescendingOrder

31+ deriving (Eq, Show, Generic)

29ascending :: T.Text

33ascending :: T.Text

30ascending = "⬆"

34ascending = "⬆"

@@ -39,9 +43,11 @@ data DataFrame = DataFrame {

39 orders :: [AttributeOrder],

43 orders :: [AttributeOrder],

40 attributes :: Attributes,

44 attributes :: Attributes,

41 tuples :: [DataFrameTuple]

45 tuples :: [DataFrameTuple]

46+ }

42− } deriving (Show, Generic, Binary)

47+ deriving (Show, Generic)

44−data DataFrameTuple = DataFrameTuple Attributes (V.Vector Atom) deriving (Eq, Show, Generic, Binary)

49+data DataFrameTuple = DataFrameTuple Attributes (V.Vector Atom)

50+ deriving (Eq, Show, Generic)

46sortDataFrameBy :: [AttributeOrder] -> DataFrame -> Either RelationalError DataFrame

52sortDataFrameBy :: [AttributeOrder] -> DataFrame -> Either RelationalError DataFrame

47sortDataFrameBy attrOrders frame = do

53sortDataFrameBy attrOrders frame = do

@@ -75,7 +81,7 @@ compareTupleByOneAttributeName attr tuple1 tuple2 =

75 Right atom2 -> compareAtoms atom1 atom2

81 Right atom2 -> compareAtoms atom1 atom2

77atomForAttributeName :: AttributeName -> DataFrameTuple -> Either RelationalError Atom

83atomForAttributeName :: AttributeName -> DataFrameTuple -> Either RelationalError Atom

78−atomForAttributeName attrName (DataFrameTuple tupAttrs tupVec) = case V.findIndex (\attr -> attributeName attr == attrName) tupAttrs of

84+atomForAttributeName attrName (DataFrameTuple tupAttrs tupVec) = case V.findIndex (\attr -> attributeName attr == attrName) (attributesVec tupAttrs) of

79 Nothing -> Left (NoSuchAttributeNamesError (S.singleton attrName))

85 Nothing -> Left (NoSuchAttributeNamesError (S.singleton attrName))

80 Just index -> case tupVec V.!? index of

86 Just index -> case tupVec V.!? index of

81 Nothing -> Left (NoSuchAttributeNamesError (S.singleton attrName))

87 Nothing -> Left (NoSuchAttributeNamesError (S.singleton attrName))

@@ -122,17 +128,18 @@ data DataFrameExpr = DataFrameExpr {

122 orderExprs :: [AttributeOrderExpr],

128 orderExprs :: [AttributeOrderExpr],

123 offset :: Maybe Integer,

129 offset :: Maybe Integer,

124 limit :: Maybe Integer

130 limit :: Maybe Integer

131+ }

125− } deriving (Show, Binary, Generic)

132+ deriving (Show, Generic)

126

133

127dataFrameAsHTML :: DataFrame -> T.Text

134dataFrameAsHTML :: DataFrame -> T.Text

128-- web browsers don't display tables with empty cells or empty headers, so we have to insert some placeholders- it's not technically the same, but looks as expected in the browser

135-- web browsers don't display tables with empty cells or empty headers, so we have to insert some placeholders- it's not technically the same, but looks as expected in the browser

129dataFrameAsHTML df

136dataFrameAsHTML df

130− | length (tuples df) == 1 && L.null (attributes df) = style <>

137+ | length (tuples df) == 1 && A.null (attributes df) = style <>

131 tablestart <>

138 tablestart <>

132 "<tr><th></th></tr>" <>

139 "<tr><th></th></tr>" <>

133 "<tr><td></td></tr>" <>

140 "<tr><td></td></tr>" <>

134 tablefooter <> "</table>"

141 tablefooter <> "</table>"

135− | L.null (tuples df) && L.null (attributes df) = style <>

142+ | L.null (tuples df) && A.null (attributes df) = style <>

136 tablestart <>

143 tablestart <>

137 "<tr><th></th></tr>" <>

144 "<tr><th></th></tr>" <>

138 tablefooter <>

145 tablefooter <>

@@ -155,7 +162,7 @@ tuplesAsHTML = foldr folder ""

155 folder tuple acc = acc <> tupleAsHTML tuple

162 folder tuple acc = acc <> tupleAsHTML tuple

156

163

157tupleAssocs :: DataFrameTuple -> [(AttributeName, Atom)]

164tupleAssocs :: DataFrameTuple -> [(AttributeName, Atom)]

158−tupleAssocs (DataFrameTuple attrVec tupVec) = V.toList $ V.map (first attributeName) (V.zip attrVec tupVec)

165+tupleAssocs (DataFrameTuple attrs tupVec) = V.toList $ V.map (first attributeName) (V.zip (attributesVec attrs) tupVec)

159

166

160

167

161tupleAsHTML :: DataFrameTuple -> T.Text

168tupleAsHTML :: DataFrameTuple -> T.Text

@@ -167,7 +174,7 @@ tupleAsHTML tuple = "<tr>" <> T.concat (L.map tupleFrag (tupleAssocs tuple)) <>

167 atomAsHTML atom = atomToText atom

174 atomAsHTML atom = atomToText atom

168

175

169attributesAsHTML :: Attributes -> [AttributeOrder] -> T.Text

176attributesAsHTML :: Attributes -> [AttributeOrder] -> T.Text

170−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>"

171 where

178 where

172 oneAttrHTML attr = "<th>" <> prettyAttribute attr <> ordering (attributeName attr) <> "</th>"

179 oneAttrHTML attr = "<th>" <> prettyAttribute attr <> ordering (attributeName attr) <> "</th>"

173 ordering attrName = " " <> case L.find (\(AttributeOrder nam _) -> nam == attrName) orders' of

180 ordering attrName = " " <> case L.find (\(AttributeOrder nam _) -> nam == attrName) orders' of

src/lib/ProjectM36/DatabaseContext.hs+6−6

@@ -7,9 +7,9 @@ import ProjectM36.DataTypes.Basic

7import ProjectM36.AtomFunctions.Basic

8import ProjectM36.Relation

9import qualified Data.ByteString.Lazy as BL

10−import Data.Binary as B

11import ProjectM36.AtomFunction as AF

10import ProjectM36.AtomFunction as AF

12import ProjectM36.DatabaseContextFunction as DBCF

11import ProjectM36.DatabaseContextFunction as DBCF

12+import Codec.Winery

14empty :: DatabaseContext

15empty = DatabaseContext { inclusionDependencies = M.empty,

@@ -44,11 +44,11 @@ basicDatabaseContext = DatabaseContext { inclusionDependencies = M.empty,

45--for building the Merkle hash

46hashBytes :: DatabaseContext -> BL.ByteString

47−hashBytes ctx = mconcat [incDeps, rvs, atomFs, dbcFs, nots, tConsMap]

47+hashBytes ctx = BL.fromChunks [incDeps, rvs, nots, tConsMap] <> atomFs <> dbcFs

48 where

49− incDeps = B.encode (inclusionDependencies ctx)

49+ incDeps = serialise (inclusionDependencies ctx)

50− rvs = B.encode (relationVariables ctx)

50+ rvs = serialise (relationVariables ctx)

51 atomFs = HS.foldr (mappend . AF.hashBytes) mempty (atomFunctions ctx)

52 dbcFs = HS.foldr (mappend . DBCF.hashBytes) mempty (dbcFunctions ctx)

53− nots = B.encode (notifications ctx)

53+ nots = serialise (notifications ctx)

54− tConsMap = B.encode (typeConstructorMapping ctx)

54+ tConsMap = serialise (typeConstructorMapping ctx)

src/lib/ProjectM36/DatabaseContextFunction.hs+6−5

@@ -3,6 +3,7 @@ module ProjectM36.DatabaseContextFunction where

3--implements functions which operate as: [Atom] -> DatabaseContextExpr -> Either RelationalError DatabaseContextExpr

4import ProjectM36.Base

5import ProjectM36.Error

6+import ProjectM36.Serialise.Base ()

6import ProjectM36.Attribute as A

7import ProjectM36.Attribute as A

7import ProjectM36.Relation

8import ProjectM36.Relation

8import ProjectM36.AtomType

9import ProjectM36.AtomType

@@ -11,7 +12,7 @@ import qualified Data.Map as M

11import ProjectM36.ScriptSession

12import ProjectM36.ScriptSession

12import qualified Data.Text as T

13import qualified Data.Text as T

13import qualified Data.ByteString.Lazy as BL

14import qualified Data.ByteString.Lazy as BL

14−import Data.Binary as B

15+import Codec.Winery

16emptyDatabaseContextFunction :: DatabaseContextFunctionName -> DatabaseContextFunction

17emptyDatabaseContextFunction :: DatabaseContextFunctionName -> DatabaseContextFunction

17emptyDatabaseContextFunction name = DatabaseContextFunction {

18emptyDatabaseContextFunction name = DatabaseContextFunction {

@@ -82,9 +83,9 @@ databaseContextFunctionsAsRelation dbcFuncs = mkRelationFromList attrs tups

83-- for merkle hash

84-- for merkle hash

84hashBytes :: DatabaseContextFunction -> BL.ByteString

85hashBytes :: DatabaseContextFunction -> BL.ByteString

85−hashBytes func = mconcat [fname, ftype, fbody]

86+hashBytes func = BL.fromChunks [fname, ftype, fbody]

86 where

87 where

87− fname = B.encode (dbcFuncName func)

88+ fname = serialise (dbcFuncName func)

88− ftype = B.encode (dbcFuncType func)

89+ ftype = serialise (dbcFuncType func)

89 fbody = case dbcFuncBody func of

90 fbody = case dbcFuncBody func of

90− DatabaseContextFunctionBody mBody _ -> B.encode mBody

91+ DatabaseContextFunctionBody mBody _ -> serialise mBody

src/lib/ProjectM36/DatabaseContextFunctionError.hs+1−2

@@ -1,9 +1,8 @@

1{-# LANGUAGE DeriveGeneric, DeriveAnyClass #-}

2module ProjectM36.DatabaseContextFunctionError where

3import GHC.Generics

4−import Data.Binary

5import Control.DeepSeq

4import Control.DeepSeq

7{-# ANN module ("HLint: ignore Use newtype instead of data" :: String) #-}

6{-# ANN module ("HLint: ignore Use newtype instead of data" :: String) #-}

8data DatabaseContextFunctionError = DatabaseContextFunctionUserError String

7data DatabaseContextFunctionError = DatabaseContextFunctionUserError String

9− deriving (Generic, Eq, Show, Binary, NFData)

8+ deriving (Generic, Eq, Show, NFData)

src/lib/ProjectM36/Error.hs+16−14

@@ -9,7 +9,6 @@ import Control.DeepSeq (NFData, rnf)

9import Control.DeepSeq.Generics (genericRnf)

10import GHC.Generics (Generic)

11import qualified Data.Text as T

12−import Data.Binary

13import Data.Typeable

12import Data.Typeable

14import Control.Exception

13import Control.Exception

@@ -82,7 +81,7 @@ data RelationalError = NoSuchAttributeNamesError (S.Set AttributeName)

82 | RelationValuedAttributesNotSupportedError [AttributeName]

81 | RelationValuedAttributesNotSupportedError [AttributeName]

83 | NotificationNameInUseError NotificationName

82 | NotificationNameInUseError NotificationName

84 | NotificationNameNotInUseError NotificationName

83 | NotificationNameNotInUseError NotificationName

85− | 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'

86 | ExportError T.Text

85 | ExportError T.Text

87 | UnhandledExceptionError String

86 | UnhandledExceptionError String

88 | MergeTransactionError MergeError

87 | MergeTransactionError MergeError

@@ -104,14 +103,14 @@ data RelationalError = NoSuchAttributeNamesError (S.Set AttributeName)

104 | TupleExprsReferenceMultipleMarkersError

103 | TupleExprsReferenceMultipleMarkersError

105

104

106 | MerkleHashValidationError TransactionId MerkleHash MerkleHash

105 | MerkleHashValidationError TransactionId MerkleHash MerkleHash

107−

106+

108 | MultipleErrors [RelationalError]

107 | MultipleErrors [RelationalError]

109− deriving (Show,Eq,Generic,Binary,Typeable, NFData)

108+ deriving (Show,Eq,Generic,Typeable, NFData)

110

109

111data PersistenceError = InvalidDirectoryError FilePath |

110data PersistenceError = InvalidDirectoryError FilePath |

112 MissingTransactionError TransactionId |

111 MissingTransactionError TransactionId |

113 WrongDatabaseFormatVersionError String String

112 WrongDatabaseFormatVersionError String String

114− deriving (Show, Eq, Generic, Binary, NFData)

113+ deriving (Show, Eq, Generic, NFData)

115

114

116--collapse list of errors into normal error- if there is just one, just return one

115--collapse list of errors into normal error- if there is just one, just return one

117someErrors :: [RelationalError] -> RelationalError

116someErrors :: [RelationalError] -> RelationalError

@@ -129,7 +128,7 @@ data MergeError = SelectedHeadMismatchMergeError |

129 StrategyViolatesComponentMergeError | --failed merge in inc deps, relvars, etc.

128 StrategyViolatesComponentMergeError | --failed merge in inc deps, relvars, etc.

130 StrategyViolatesRelationVariableMergeError |

129 StrategyViolatesRelationVariableMergeError |

131 StrategyViolatesTypeConstructorMergeError

130 StrategyViolatesTypeConstructorMergeError

132− deriving (Show, Eq, Generic, Binary, Typeable)

131+ deriving (Show, Eq, Generic, Typeable)

133

132

134instance NFData MergeError where rnf = genericRnf

133instance NFData MergeError where rnf = genericRnf

135

134

@@ -137,17 +136,20 @@ data ScriptCompilationError = TypeCheckCompilationError String String | --expect

137 SyntaxErrorCompilationError String |

136 SyntaxErrorCompilationError String |

138 ScriptCompilationDisabledError |

137 ScriptCompilationDisabledError |

139 OtherScriptCompilationError String

138 OtherScriptCompilationError String

140− deriving (Show, Eq, Generic, Binary, Typeable, NFData)

139+ deriving (Show, Eq, Generic, Typeable, NFData)

141

140

142instance Exception ScriptCompilationError

141instance Exception ScriptCompilationError

143

142

144data SchemaError = RelVarReferencesMissing (S.Set RelVarName) |

143data SchemaError = RelVarReferencesMissing (S.Set RelVarName) |

145 RelVarInReferencedMoreThanOnce RelVarName |

144 RelVarInReferencedMoreThanOnce RelVarName |

146 RelVarOutReferencedMoreThanOnce RelVarName

145 RelVarOutReferencedMoreThanOnce RelVarName

147− deriving (Show, Eq, Generic, Binary, Typeable, NFData)

146+ deriving (Show, Eq, Generic, Typeable, NFData)

148−

147+

149−

148+

150−-- errors returned from the distributed-process call handlers

149+data ImportError' = InvalidSHA256Error T.Text

151−data ServerError = RequestTimeoutError |

150+ | SHA256MismatchError T.Text T.Text

152− ProcessDiedError String

151+ | InvalidFileURIError T.Text

152+ | ImportFileDecodeError T.Text

153+ | ImportFileError T.Text

154+ | ImportDownloadError T.Text

153− deriving (Generic, Binary, Eq)

155+ deriving (Show, Eq, Generic, Typeable, NFData)

src/lib/ProjectM36/IsomorphicSchema.hs+2−4

@@ -1,4 +1,4 @@

1−{-# LANGUAGE DeriveGeneric, DeriveAnyClass, LambdaCase #-}

1+{-# LANGUAGE DeriveGeneric, LambdaCase, DerivingVia #-}

2module ProjectM36.IsomorphicSchema where

3import ProjectM36.Base

4import ProjectM36.Error

@@ -9,7 +9,6 @@ import ProjectM36.RelationalExpression

9import qualified ProjectM36.AttributeNames as AN

10import Control.Monad

11import GHC.Generics

12−import Data.Binary

13import qualified Data.Map as M

12import qualified Data.Map as M

14import qualified Data.Set as S

13import qualified Data.Set as S

15import qualified Data.List as L

14import qualified Data.List as L

@@ -28,8 +27,7 @@ import Data.Monoid

29data SchemaExpr = AddSubschema SchemaName SchemaIsomorphs |

28data SchemaExpr = AddSubschema SchemaName SchemaIsomorphs |

30 RemoveSubschema SchemaName

29 RemoveSubschema SchemaName

31− deriving (Generic, Binary, Show)

30+ deriving (Generic, Show)

32−

34isomorphs :: Schema -> SchemaIsomorphs

32isomorphs :: Schema -> SchemaIsomorphs

35isomorphs (Schema i) = i

33isomorphs (Schema i) = i

src/lib/ProjectM36/MerkleHash.hs+2−3

@@ -1,10 +1,9 @@

1−{-# LANGUAGE GeneralizedNewtypeDeriving, DeriveGeneric #-}

1+{-# LANGUAGE GeneralizedNewtypeDeriving, DeriveGeneric, DerivingVia #-}

2module ProjectM36.MerkleHash where

3import Data.ByteString (ByteString)

4import GHC.Generics

5−import Data.Binary (Binary)

6import Control.DeepSeq (NFData)

5import Control.DeepSeq (NFData)

8newtype MerkleHash = MerkleHash { _unMerkleHash :: ByteString }

7newtype MerkleHash = MerkleHash { _unMerkleHash :: ByteString }

9− deriving (Show, Eq, Binary, Generic, Monoid, Semigroup, NFData)

8+ deriving (Show, Eq, Generic, Monoid, Semigroup, NFData)

src/lib/ProjectM36/Persist.hs+3−4

@@ -36,7 +36,6 @@ import Foreign.C

36#endif

38import System.IO (withFile, IOMode(WriteMode), Handle)

39−import qualified Data.ByteString.Lazy as BS

40import qualified Data.ByteString as BS'

39import qualified Data.ByteString as BS'

41import qualified Data.Text.Encoding as TE

40import qualified Data.Text.Encoding as TE

@@ -100,10 +99,10 @@ syncDirectory :: DiskSync -> FilePath -> IO ()

100syncDirectory FsyncDiskSync path = directoryFsync path

99syncDirectory FsyncDiskSync path = directoryFsync path

101syncDirectory NoDiskSync _ = pure ()

100syncDirectory NoDiskSync _ = pure ()

102

101

103−writeBSFileSync :: DiskSync -> FilePath -> BS.ByteString -> IO ()

102+writeBSFileSync :: DiskSync -> FilePath -> BS'.ByteString -> IO ()

104writeBSFileSync sync path bstring =

103writeBSFileSync sync path bstring =

105 withFile path WriteMode $ \handle -> do

104 withFile path WriteMode $ \handle -> do

106− BS.hPut handle bstring

105+ BS'.hPut handle bstring

107 syncHandle sync handle

106 syncHandle sync handle

108

107

109directoryFsync :: FilePath -> IO ()

108directoryFsync :: FilePath -> IO ()

@@ -131,4 +130,4 @@ fdCount = do

131 fds <- getDirectoryContents FDDIR

130 fds <- getDirectoryContents FDDIR

132 pure ((length fds) - 2)

131 pure ((length fds) - 2)

133--not supported on non-linux

132--not supported on non-linux

134−#endif

133+#endif

src/lib/ProjectM36/Relation.hs+17−22

@@ -9,7 +9,6 @@ import ProjectM36.Tuple

9import qualified ProjectM36.Attribute as A

10import ProjectM36.TupleSet

11import ProjectM36.Error

12−import ProjectM36.MiscUtils

13--import qualified Control.Parallel.Strategies as P

12--import qualified Control.Parallel.Strategies as P

14import qualified ProjectM36.TypeConstructorDef as TCD

13import qualified ProjectM36.TypeConstructorDef as TCD

15import qualified ProjectM36.DataConstructorDef as DCD

14import qualified ProjectM36.DataConstructorDef as DCD

@@ -17,7 +16,6 @@ import qualified Data.Text as T

17import Data.Either (isRight)

16import Data.Either (isRight)

18import System.Random.Shuffle

17import System.Random.Shuffle

19import Control.Monad.Random

18import Control.Monad.Random

20−import Data.List (sort)

22attributes :: Relation -> Attributes

20attributes :: Relation -> Attributes

23attributes (Relation attrs _ ) = attrs

21attributes (Relation attrs _ ) = attrs

@@ -35,7 +33,7 @@ atomTypeForName :: AttributeName -> Relation -> Either RelationalError AtomType

35atomTypeForName attrName (Relation attrs _) = A.atomTypeForAttributeName attrName attrs

33atomTypeForName attrName (Relation attrs _) = A.atomTypeForAttributeName attrName attrs

37mkRelationFromList :: Attributes -> [[Atom]] -> Either RelationalError Relation

35mkRelationFromList :: Attributes -> [[Atom]] -> Either RelationalError Relation

38−mkRelationFromList attrs atomMatrix =

36+mkRelationFromList attrs atomMatrix = do

39 Relation attrs <$> mkTupleSetFromList attrs atomMatrix

37 Relation attrs <$> mkTupleSetFromList attrs atomMatrix

41emptyRelationWithAttrs :: Attributes -> Relation

39emptyRelationWithAttrs :: Attributes -> Relation

@@ -43,11 +41,6 @@ emptyRelationWithAttrs attrs = Relation attrs emptyTupleSet

44mkRelation :: Attributes -> RelationTupleSet -> Either RelationalError Relation

42mkRelation :: Attributes -> RelationTupleSet -> Either RelationalError Relation

45mkRelation attrs tupleSet =

43mkRelation attrs tupleSet =

46− --check that all attributes are unique- this cannot be done when creating attributes because the check can become expensive

47− let duplicateAttrNames = dupes (sort (map A.attributeName (V.toList attrs))) in

48− if not (null duplicateAttrNames) then

49− Left (DuplicateAttributeNamesError (S.fromList duplicateAttrNames))

50− else

51 --check that all tuples have the same keys

44 --check that all tuples have the same keys

52 --check that all tuples have keys (1-N) where N is the attribute count

45 --check that all tuples have keys (1-N) where N is the attribute count

53 case verifyTupleSet attrs tupleSet of

46 case verifyTupleSet attrs tupleSet of

@@ -93,13 +86,12 @@ union (Relation attrs1 tupSet1) (Relation attrs2 tupSet2) =

93 else

86 else

94 Right $ Relation attrs1 newtuples

87 Right $ Relation attrs1 newtuples

95 where

88 where

96− newtuples = RelationTupleSet $ HS.toList . HS.fromList $ asList tupSet1 ++ map (reorderTuple attrs1) (asList tupSet2)

89+ newtuples = tupleSetUnion attrs1 tupSet1 tupSet2

97−

90+

98project :: S.Set AttributeName -> Relation -> Either RelationalError Relation

91project :: S.Set AttributeName -> Relation -> Either RelationalError Relation

99project attrNames rel@(Relation _ tupSet) = do

92project attrNames rel@(Relation _ tupSet) = do

100 newAttrs <- A.projectionAttributesForNames attrNames (attributes rel)

93 newAttrs <- A.projectionAttributesForNames attrNames (attributes rel)

101− let newAttrNameSet = A.attributeNameSet newAttrs

102− newTupleList = map (tupleProject newAttrNameSet) (asList tupSet)

94+ newTupleList <- mapM (tupleProject newAttrs) (asList tupSet)

103 pure (Relation newAttrs (RelationTupleSet (HS.toList (HS.fromList newTupleList))))

95 pure (Relation newAttrs (RelationTupleSet (HS.toList (HS.fromList newTupleList))))

104

105rename :: AttributeName -> AttributeName -> Relation -> Either RelationalError Relation

97rename :: AttributeName -> AttributeName -> Relation -> Either RelationalError Relation

@@ -154,7 +146,7 @@ group groupAttrNames newAttrName rel = do

154 groupProjectionAttributes <- A.projectionAttributesForNames groupAttrNames (attributes rel)

146 groupProjectionAttributes <- A.projectionAttributesForNames groupAttrNames (attributes rel)

155 let groupAttr = Attribute newAttrName (RelationAtomType groupProjectionAttributes)

147 let groupAttr = Attribute newAttrName (RelationAtomType groupProjectionAttributes)

156 matchingRelTuple tupIn = case imageRelationFor tupIn rel of

148 matchingRelTuple tupIn = case imageRelationFor tupIn rel of

157− Right rel2 -> RelationTuple (V.singleton groupAttr) (V.singleton (RelationAtom rel2))

149+ Right rel2 -> RelationTuple (A.singleton groupAttr) (V.singleton (RelationAtom rel2))

158 Left _ -> undefined

150 Left _ -> undefined

159 mogrifier tupIn = pure (tupleExtend tupIn (matchingRelTuple tupIn))

151 mogrifier tupIn = pure (tupleExtend tupIn (matchingRelTuple tupIn))

160 newAttrs = A.addAttribute groupAttr nonGroupProjectionAttributes

152 newAttrs = A.addAttribute groupAttr nonGroupProjectionAttributes

@@ -168,7 +160,8 @@ restrictEq :: RelationTuple -> Relation -> Either RelationalError Relation

168restrictEq tuple = restrict rfilter

160restrictEq tuple = restrict rfilter

169 where

161 where

170 rfilter :: RelationTuple -> Either RelationalError Bool

162 rfilter :: RelationTuple -> Either RelationalError Bool

163+ rfilter tupleIn = do

171− rfilter tupleIn = pure (tupleIntersection tuple tupleIn == tuple)

164+ pure (tupleIntersection tuple tupleIn == tuple)

172

165

173-- unwrap relation-valued attribute

166-- unwrap relation-valued attribute

174-- return error if relval attrs and nongroup attrs overlap

167-- return error if relval attrs and nongroup attrs overlap

@@ -190,13 +183,13 @@ ungroup relvalAttrName rel = case attributesForRelval relvalAttrName rel of

190tupleUngroup :: AttributeName -> Attributes -> RelationTuple -> Either RelationalError Relation

183tupleUngroup :: AttributeName -> Attributes -> RelationTuple -> Either RelationalError Relation

191tupleUngroup relvalAttrName newAttrs tuple = do

184tupleUngroup relvalAttrName newAttrs tuple = do

192 relvalRelation <- relationForAttributeName relvalAttrName tuple

185 relvalRelation <- relationForAttributeName relvalAttrName tuple

186+ let nonGroupAttrs = A.intersection newAttrs (tupleAttributes tuple)

187+ nonGroupTupleProjection <- tupleProject nonGroupAttrs tuple

188+ let folder tupleIn acc = case acc of

189+ Left err -> Left err

190+ Right accRel ->

191+ union accRel $ Relation newAttrs (RelationTupleSet [tupleExtend nonGroupTupleProjection tupleIn])

193 relFold folder (Right $ Relation newAttrs emptyTupleSet) relvalRelation

192 relFold folder (Right $ Relation newAttrs emptyTupleSet) relvalRelation

194− where

195− nonGroupTupleProjection = tupleProject nonGroupAttrNames tuple

196− nonGroupAttrNames = A.attributeNameSet newAttrs

197− folder tupleIn acc = case acc of

198− Left err -> Left err

199− Right accRel -> union accRel $ Relation newAttrs (RelationTupleSet [tupleExtend nonGroupTupleProjection tupleIn])

200

193

201attributesForRelval :: AttributeName -> Relation -> Either RelationalError Attributes

194attributesForRelval :: AttributeName -> Relation -> Either RelationalError Attributes

202attributesForRelval relvalAttrName (Relation attrs _) = do

195attributesForRelval relvalAttrName (Relation attrs _) = do

@@ -251,7 +244,8 @@ relMap mapper (Relation attrs tupleSet) =

251

244

252relMogrify :: (RelationTuple -> Either RelationalError RelationTuple) -> Attributes -> Relation -> Either RelationalError Relation

245relMogrify :: (RelationTuple -> Either RelationalError RelationTuple) -> Attributes -> Relation -> Either RelationalError Relation

253relMogrify mapper newAttributes (Relation _ tupSet) = do

246relMogrify mapper newAttributes (Relation _ tupSet) = do

254− newTuples <- mapM mapper (asList tupSet)

247+ newTuples <- mapM (fmap (reorderTuple newAttributes) . mapper) (asList tupSet)

248+

255 mkRelationFromTuples newAttributes newTuples

249 mkRelationFromTuples newAttributes newTuples

256

250

257relFold :: (RelationTuple -> a -> a) -> a -> Relation -> a

251relFold :: (RelationTuple -> a -> a) -> a -> Relation -> a

@@ -297,7 +291,8 @@ typesAsRelation types = mkRelationFromTuples attrs tuples

297 dConsType = RelationAtomType subAttrs

291 dConsType = RelationAtomType subAttrs

298 tuples = map mkTypeConsDescription types

292 tuples = map mkTypeConsDescription types

299

293

294+ mkTypeConsDescription (tCons, dConsList) =

300− mkTypeConsDescription (tCons, dConsList) = RelationTuple attrs (V.fromList [TextAtom (TCD.name tCons), mkDataConsRelation dConsList])

295+ RelationTuple attrs (V.fromList [TextAtom (TCD.name tCons), mkDataConsRelation dConsList])

301

296

302 mkDataConsRelation dConsList = case mkRelationFromTuples subAttrs $ map (\dCons -> RelationTuple subAttrs (V.singleton $ TextAtom $ T.intercalate " " (DCD.name dCons:map (T.pack . show) (DCD.fields dCons)))) dConsList of

297 mkDataConsRelation dConsList = case mkRelationFromTuples subAttrs $ map (\dCons -> RelationTuple subAttrs (V.singleton $ TextAtom $ T.intercalate " " (DCD.name dCons:map (T.pack . show) (DCD.fields dCons)))) dConsList of

303 Left err -> error ("mkRelationFromTuples pooped " ++ show err)

298 Left err -> error ("mkRelationFromTuples pooped " ++ show err)

src/lib/ProjectM36/Relation/Parse/CSV.hs+2−3

@@ -38,8 +38,7 @@ csvAsRelation attrs tConsMap inString = case APBL.parse (csvWithHeader csvDecode

38 let strHeader = V.map decodeUtf8 headerRaw

39 strMapRecords = V.map convertMap vecMapsRaw

40 convertMap hmap = HM.fromList $ L.map (decodeUtf8 *** (T.unpack . decodeUtf8)) (HM.toList hmap)

41− attrNames = V.map A.attributeName attrs

41+ attrNameSet = A.attributeNameSet attrs

42− attrNameSet = S.fromList (V.toList attrNames)

43 headerSet = S.fromList (V.toList strHeader)

42 headerSet = S.fromList (V.toList strHeader)

44 parseAtom attrName aType textIn = case APT.parseOnly (parseCSVAtomP attrName tConsMap aType <* APT.endOfInput) textIn of

43 parseAtom attrName aType textIn = case APT.parseOnly (parseCSVAtomP attrName tConsMap aType <* APT.endOfInput) textIn of

45 Left err -> Left (ParseError (T.pack err))

44 Left err -> Left (ParseError (T.pack err))

@@ -47,7 +46,7 @@ csvAsRelation attrs tConsMap inString = case APBL.parse (csvWithHeader csvDecode

47 makeTupleList :: HM.HashMap AttributeName String -> [Either CsvImportError Atom]

46 makeTupleList :: HM.HashMap AttributeName String -> [Either CsvImportError Atom]

48 makeTupleList tupMap = V.toList $ V.map (\attr ->

47 makeTupleList tupMap = V.toList $ V.map (\attr ->

49 either (Left . AttributeMappingError) Right $

48 either (Left . AttributeMappingError) Right $

50− parseAtom (A.attributeName attr) (A.atomType attr) (T.pack $ tupMap HM.! A.attributeName attr)) attrs

49+ parseAtom (A.attributeName attr) (A.atomType attr) (T.pack $ tupMap HM.! A.attributeName attr)) (attributesVec attrs)

51 if attrNameSet == headerSet then do

50 if attrNameSet == headerSet then do

52 tupleList <- mapM sequence $ V.toList (V.map makeTupleList strMapRecords)

51 tupleList <- mapM sequence $ V.toList (V.map makeTupleList strMapRecords)

53 case mkRelationFromList attrs tupleList of

52 case mkRelationFromList attrs tupleList of

src/lib/ProjectM36/Relation/Show/CSV.hs+5−5

@@ -1,7 +1,7 @@

1{-# OPTIONS_GHC -fno-warn-orphans #-}

2module ProjectM36.Relation.Show.CSV where

3import ProjectM36.Base

4−import ProjectM36.Attribute

4+import ProjectM36.Attribute as A

5import Data.Csv

6import ProjectM36.Tuple

7import qualified Data.ByteString.Lazy as BS

@@ -17,13 +17,13 @@ relationAsCSV (Relation attrs tupleSet)

17 | relValAttrs /= [] =

18 Left $ RelationValuedAttributesNotSupportedError (map attributeName relValAttrs)

19 --check that there is at least one attribute

20− | V.null attrs =

20+ | A.null attrs =

21 Left $ TupleAttributeCountMismatchError 0

22 | otherwise =

23 Right $ encodeByName bsAttrNames $ map RecordRelationTuple (asList tupleSet)

24 where

25− relValAttrs = V.toList $ V.filter (isRelationAtomType . atomType) attrs

25+ relValAttrs = V.toList $ V.filter (isRelationAtomType . atomType) (attributesVec attrs)

26− bsAttrNames = V.map (TE.encodeUtf8 . attributeName) attrs

26+ bsAttrNames = V.map (TE.encodeUtf8 . attributeName) (attributesVec attrs)

28{-

29instance ToRecord RelationTuple where

@@ -36,7 +36,7 @@ instance ToNamedRecord RecordRelationTuple where

36 toNamedRecord rTuple = namedRecord $ map (\(k,v) -> TE.encodeUtf8 k .= RecordAtom v) (tupleAssocs $ unTuple rTuple)

38instance DefaultOrdered RecordRelationTuple where

39− headerOrder (RecordRelationTuple tuple) = V.map (TE.encodeUtf8 . attributeName) (tupleAttributes tuple)

39+ headerOrder (RecordRelationTuple tuple) = V.map (TE.encodeUtf8 . attributeName) (attributesVec (tupleAttributes tuple))

41newtype RecordAtom = RecordAtom {unAtom :: Atom}

src/lib/ProjectM36/Relation/Show/HTML.hs+2−2

@@ -3,6 +3,7 @@ import ProjectM36.Base

3import ProjectM36.Relation

4import ProjectM36.Tuple

5import ProjectM36.Atom

6+import ProjectM36.Attribute as A

6import ProjectM36.AtomType

7import ProjectM36.AtomType

7import qualified Data.List as L

8import qualified Data.List as L

8import Data.Text (Text, pack)

9import Data.Text (Text, pack)

@@ -11,10 +12,9 @@ import qualified Data.Text.IO as TIO

11#if __GLASGOW_HASKELL__ < 804

12#if __GLASGOW_HASKELL__ < 804

12import Data.Monoid

13import Data.Monoid

13#endif

14#endif

14−import qualified Data.Vector as V

16attributesAsHTML :: Attributes -> Text

17−attributesAsHTML attrs = "<tr>" <> T.concat (map oneAttrHTML (V.toList attrs)) <> "</tr>"

17+attributesAsHTML attrs = "<tr>" <> T.concat (map oneAttrHTML (A.toList attrs)) <> "</tr>"

18 where

19 oneAttrHTML attr = "<th>" <> prettyAttribute attr <> "</th>"

src/lib/ProjectM36/RelationalExpression.hs+77−300

@@ -1,6 +1,7 @@

1{-# LANGUAGE ScopedTypeVariables #-}

2{-# LANGUAGE FlexibleInstances #-}

3{-# LANGUAGE FlexibleContexts #-}

4+{-# LANGUAGE OverloadedStrings #-}

4module ProjectM36.RelationalExpression where

5module ProjectM36.RelationalExpression where

5import ProjectM36.Relation

6import ProjectM36.Relation

6import ProjectM36.Tuple

7import ProjectM36.Tuple

@@ -40,6 +41,8 @@ import Control.Monad.Reader as R hiding (join)

40import ProjectM36.NormalizeExpr

41import ProjectM36.NormalizeExpr

41import ProjectM36.WithNameExpr

42import ProjectM36.WithNameExpr

42import Test.QuickCheck

43import Test.QuickCheck

44+import qualified Data.Functor.Foldable as Fold

45+import Control.Applicative

43#ifdef PM36_HASKELL_SCRIPTING

46#ifdef PM36_HASKELL_SCRIPTING

44import GHC hiding (getContext)

47import GHC hiding (getContext)

45import Control.Exception

48import Control.Exception

@@ -107,11 +110,11 @@ askEnv :: GraphRefRelationalExprM GraphRefRelationalExprEnv

107askEnv = R.ask

110askEnv = R.ask

108

111

109mergeTuplesIntoGraphRefRelationalExprEnv :: RelationTuple -> GraphRefRelationalExprEnv -> GraphRefRelationalExprEnv

112mergeTuplesIntoGraphRefRelationalExprEnv :: RelationTuple -> GraphRefRelationalExprEnv -> GraphRefRelationalExprEnv

110−mergeTuplesIntoGraphRefRelationalExprEnv tupIn e =

113+mergeTuplesIntoGraphRefRelationalExprEnv tupIn env =

111− e{ gre_extra = new_elems }

114+ env { gre_extra = new_elems }

112 where

115 where

113 new_elems = Just (Left newTuple)

116 new_elems = Just (Left newTuple)

114− mergedTupMap = M.union (tupleToMap tupIn) (tupleToMap (envTuple e))

117+ mergedTupMap = M.union (tupleToMap tupIn) (tupleToMap (envTuple env))

115 newTuple = mkRelationTupleFromMap mergedTupMap

118 newTuple = mkRelationTupleFromMap mergedTupMap

116

119

117mergeAttributesIntoGraphRefRelationalExprEnv :: Attributes -> GraphRefRelationalExprEnv -> GraphRefRelationalExprEnv

120mergeAttributesIntoGraphRefRelationalExprEnv :: Attributes -> GraphRefRelationalExprEnv -> GraphRefRelationalExprEnv

@@ -209,160 +212,6 @@ envContext = re_context

209setEnvContext :: RelationalExprEnv -> DatabaseContext -> RelationalExprEnv

212setEnvContext :: RelationalExprEnv -> DatabaseContext -> RelationalExprEnv

210setEnvContext e ctx = e { re_context = ctx }

213setEnvContext e ctx = e { re_context = ctx }

211

214

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−-}

366--helper function to process relation variable creation/assignment

215--helper function to process relation variable creation/assignment

367setRelVar :: RelVarName -> GraphRefRelationalExpr -> DatabaseContextEvalMonad ()

216setRelVar :: RelVarName -> GraphRefRelationalExpr -> DatabaseContextEvalMonad ()

368setRelVar relVarName relExpr = do

217setRelVar relVarName relExpr = do

@@ -382,6 +231,9 @@ setRelVar relVarName relExpr = do

382 Left err -> dbErr err

231 Left err -> dbErr err

383 Right _ -> putStateContext potentialContext

232 Right _ -> putStateContext potentialContext

384

233

234+--fast-path insertion- we already know that the previous relvar validated correctly, so we can validate just the relation that is being inserted for attribute matches- without this, even a single tuple relation inserted causes the entire relation to be re-validated unnecessarily

235+--insertIntoRelVar :: RelVarName -> GraphRefRelationalExpr -> DatabaseContextEvalMonad ()

236+

385-- it is not an error to delete a relvar which does not exist, just like it is not an error to insert a pre-existing tuple into a relation

237-- it is not an error to delete a relvar which does not exist, just like it is not an error to insert a pre-existing tuple into a relation

386deleteRelVar :: RelVarName -> DatabaseContextEvalMonad ()

238deleteRelVar :: RelVarName -> DatabaseContextEvalMonad ()

387deleteRelVar relVarName = do

239deleteRelVar relVarName = do

@@ -447,20 +299,36 @@ evalGraphRefDatabaseContextExpr (Assign relVarName expr) = do

447

299

448evalGraphRefDatabaseContextExpr (Insert relVarName relExpr) = do

300evalGraphRefDatabaseContextExpr (Insert relVarName relExpr) = do

449 gfExpr <- relVarByName relVarName

301 gfExpr <- relVarByName relVarName

302+ let optExpr = applyUnionCollapse (Union

303+ relExpr

304+ gfExpr)

450− evalGraphRefDatabaseContextExpr (Assign relVarName

305+ evalGraphRefDatabaseContextExpr (Assign relVarName optExpr)

451− (Union

452− gfExpr

453− relExpr))

454

306

455evalGraphRefDatabaseContextExpr (Delete relVarName predicate) = do

307evalGraphRefDatabaseContextExpr (Delete relVarName predicate) = do

456 gfExpr <- relVarByName relVarName

308 gfExpr <- relVarByName relVarName

457− setRelVar relVarName (Restrict (NotPredicate predicate) gfExpr)

309+ let optExpr = applyRestrictionCollapse (Restrict (NotPredicate predicate) gfExpr)

310+ setRelVar relVarName optExpr

458

311

459--union of restricted+updated portion and the unrestricted+unupdated portion

312--union of restricted+updated portion and the unrestricted+unupdated portion

460evalGraphRefDatabaseContextExpr (Update relVarName atomExprMap pred') = do

313evalGraphRefDatabaseContextExpr (Update relVarName atomExprMap pred') = do

461 rvExpr <- relVarByName relVarName

314 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

462 let unrestrictedPortion = Restrict (NotPredicate pred') rvExpr

323 let unrestrictedPortion = Restrict (NotPredicate pred') rvExpr

463− 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

464 updateAttr nam atomExpr = Extend (AttributeExtendTupleExpr (tmpAttr nam) atomExpr)

332 updateAttr nam atomExpr = Extend (AttributeExtendTupleExpr (tmpAttr nam) atomExpr)

465 projectAndRename attr expr = Rename (tmpAttr attr) attr (Project (InvertedAttributeNames (S.singleton attr)) expr)

333 projectAndRename attr expr = Rename (tmpAttr attr) attr (Project (InvertedAttributeNames (S.singleton attr)) expr)

466 restrictedPortion = Restrict pred' rvExpr

334 restrictedPortion = Restrict pred' rvExpr

@@ -774,21 +642,9 @@ evalGraphRefDatabaseContextIOExpr (CreateArbitraryRelation relVarName attrExprs

774 Left err -> pure (Left err)

642 Left err -> pure (Left err)

775 Right dbstate' -> putDBCIOContext (dbc_context dbstate')

643 Right dbstate' -> putDBCIOContext (dbc_context dbstate')

776

644

777−{-

778−updateTupleWithAtomExprs :: M.Map AttributeName AtomExpr -> DatabaseContext -> TransactionGraph -> RelationTuple -> Either RelationalError RelationTuple

779−updateTupleWithAtomExprs exprMap context graph tupIn = do

780− --resolve all atom exprs

781− let

782− atomsAssoc <- mapM (\(attrName, atomExpr) -> do

783− let atom = unimplemented

784− --atom <- runReader (evalAtomExpr tupIn atomExpr) (mkRelationalExprState context graph)

785− pure (attrName, atom)

786− ) (M.toList exprMap)

787− pure (updateTupleWithAtoms (M.fromList atomsAssoc) tupIn)

788−-}

789--run verification on all constraints

645--run verification on all constraints

790checkConstraints :: DatabaseContext -> TransactionId -> TransactionGraph -> Either RelationalError ()

646checkConstraints :: DatabaseContext -> TransactionId -> TransactionGraph -> Either RelationalError ()

791−checkConstraints context transId graph@(TransactionGraph graphHeads transSet) =

647+checkConstraints context transId graph@(TransactionGraph graphHeads transSet) = do

792 mapM_ (uncurry checkIncDep) (M.toList deps)

648 mapM_ (uncurry checkIncDep) (M.toList deps)

793 where

649 where

794 potentialGraph = TransactionGraph graphHeads (S.insert tempTrans transSet)

650 potentialGraph = TransactionGraph graphHeads (S.insert tempTrans transSet)

@@ -837,15 +693,6 @@ typeForRelationalExpr expr = do

837 runGf = runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr gfExpr)

693 runGf = runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr gfExpr)

838 lift $ except runGf

694 lift $ except runGf

839

695

840−--returns a database context with all tuples removed

841−--this is useful for type checking and optimization

842−{-

843−contextWithEmptyTupleSets :: DatabaseContext -> DatabaseContext

844−contextWithEmptyTupleSets contextIn = contextIn { relationVariables = relVars }

845− where

846− relVars = M.map (\rel -> ExistingRelation (Relation (attributes rel) emptyTupleSet)) (relationVariables contextIn)

847−-}

848−

849liftE :: (Monad m) => m (Either a b) -> ExceptT a m b

696liftE :: (Monad m) => m (Either a b) -> ExceptT a m b

850liftE v = do

697liftE v = do

851 y <- lift v

698 y <- lift v

@@ -1001,58 +848,6 @@ evalGraphRefAtomExpr tupIn cons@(ConstructedAtomExpr dConsName dConsArgs _) = do

1001 mapM (evalGraphRefAtomExpr tupIn) dConsArgs

848 mapM (evalGraphRefAtomExpr tupIn) dConsArgs

1002 pure (ConstructedAtom dConsName aType argAtoms)

849 pure (ConstructedAtom dConsName aType argAtoms)

1003

850

1004−{-

1005−evalAtomExpr :: RelationTuple -> AtomExpr -> RelationalExprM Atom

1006−evalAtomExpr tupIn expr =

1007− -}

1008−{-

1009−

1010−evalAtomExpr tupIn (AttributeAtomExpr attrName) = case atomForAttributeName attrName tupIn of

1011− Right atom -> pure (Right atom)

1012− err@(Left (NoSuchAttributeNamesError _)) -> do

1013− rstate <- ask

1014− let stateTup = stateTuple rstate

1015− pure (atomForAttributeName attrName stateTup)

1016− Left err -> pure (Left err)

1017−evalAtomExpr _ (NakedAtomExpr atom) = pure (Right atom)

1018−evalAtomExpr tupIn (FunctionAtomExpr funcName arguments ()) = do

1019− argTypes <- mapM (typeFromAtomExpr (tupleAttributes tupIn)) arguments

1020− context <- fmap stateElemsContext ask

1021− runExceptT $ do

1022− let functions = atomFunctions context

1023− func <- either throwE pure (atomFunctionForName funcName functions)

1024− let expectedArgCount = length (atomFuncType func) - 1

1025− actualArgCount = length argTypes

1026− safeInit [] = [] -- different behavior from normal init

1027− safeInit xs = init xs

1028− if expectedArgCount /= actualArgCount then

1029− throwE (FunctionArgumentCountMismatchError expectedArgCount actualArgCount)

1030− else do

1031− let zippedArgs = zip (safeInit (atomFuncType func)) argTypes

1032− mapM_ (\(expType, eActType) -> do

1033− actType <- either throwE pure eActType

1034− either throwE pure (atomTypeVerify expType actType)) zippedArgs

1035− evaldArgs <- mapM (liftE . evalAtomExpr tupIn) arguments

1036− case evalAtomFunction func evaldArgs of

1037− Left err -> throwE (AtomFunctionUserError err)

1038− Right result -> do

1039− --validate that the result matches the expected type

1040− _ <- either throwE pure (atomTypeVerify (last (atomFuncType func)) (atomTypeForAtom result))

1041− pure result

1042−evalAtomExpr tupIn (RelationAtomExpr relExpr) = do

1043− --merge existing state tuple context into new state tuple context to support an arbitrary number of levels, but new attributes trounce old attributes

1044− rstate <- ask

1045− runExceptT $ do

1046− let newState = mergeTuplesIntoRelationalExprState tupIn rstate

1047− relAtom <- either throwE pure (runReader (evalRelationalExpr relExpr) newState)

1048− pure (RelationAtom relAtom)

1049−evalAtomExpr tupIn cons@(ConstructedAtomExpr dConsName dConsArgs ()) = runExceptT $ do

1050− rstate <- lift ask

1051− let newState = mergeTuplesIntoRelationalExprState tupIn rstate

1052− aType <- either throwE pure (runReader (typeFromAtomExpr (tupleAttributes tupIn) cons) newState)

1053− argAtoms <- mapM (\arg -> either throwE pure (runReader (evalAtomExpr tupIn arg) newState)) dConsArgs

1054− pure (ConstructedAtom dConsName aType argAtoms)

1055−-}

1056typeForGraphRefAtomExpr :: Attributes -> GraphRefAtomExpr -> GraphRefRelationalExprM AtomType

851typeForGraphRefAtomExpr :: Attributes -> GraphRefAtomExpr -> GraphRefRelationalExprM AtomType

1057typeForGraphRefAtomExpr attrs (AttributeAtomExpr attrName) = do

852typeForGraphRefAtomExpr attrs (AttributeAtomExpr attrName) = do

1058 renv <- askEnv

853 renv <- askEnv

@@ -1119,7 +914,7 @@ verifyGraphRefAtomExprTypes relIn (FunctionAtomExpr funcName funcArgExprs tid) e

1119 let handler :: RelationalError -> GraphRefRelationalExprM AtomType

914 let handler :: RelationalError -> GraphRefRelationalExprM AtomType

1120 handler (AtomTypeMismatchError expSubType actSubType) = throwError (AtomFunctionTypeError funcName argCount expSubType actSubType)

915 handler (AtomTypeMismatchError expSubType actSubType) = throwError (AtomFunctionTypeError funcName argCount expSubType actSubType)

1121 handler err = throwError err

916 handler err = throwError err

1122− verifyGraphRefAtomExprTypes relIn atomExpr expectedType2 `catchError` handler

917+ verifyGraphRefAtomExprTypes relIn atomExpr expectedType2 `catchError` handler

1123 funcArgTypes <- mapM funcArgVerifier $ zip3 funcArgExprs expectedArgTypes [1..]

918 funcArgTypes <- mapM funcArgVerifier $ zip3 funcArgExprs expectedArgTypes [1..]

1124 if length funcArgTypes /= length expectedArgTypes - 1 then

919 if length funcArgTypes /= length expectedArgTypes - 1 then

1125 throwError (AtomTypeCountError funcArgTypes expectedArgTypes)

920 throwError (AtomTypeCountError funcArgTypes expectedArgTypes)

@@ -1165,7 +960,7 @@ evalGraphRefTupleExprs mAttrs (TupleExprs fixedMarker tupleExprL) = do

1165 lift $ except $ resolveAttributes accAttr tupAttr

960 lift $ except $ resolveAttributes accAttr tupAttr

1166 mostResolvedTypes <-

961 mostResolvedTypes <-

1167 foldM (\acc tup -> do

962 foldM (\acc tup -> do

1168− let zipped = zip (V.toList $ tupleAttributes tup) acc

963+ let zipped = zip (V.toList . attributesVec $ tupleAttributes tup) acc

1169 accNames = S.fromList $ map A.attributeName acc

964 accNames = S.fromList $ map A.attributeName acc

1170 tupNames = A.attributeNameSet (tupleAttributes tup)

965 tupNames = A.attributeNameSet (tupleAttributes tup)

1171 attrNamesDiff = S.union (S.difference accNames tupNames) (S.difference tupNames accNames)

966 attrNamesDiff = S.union (S.difference accNames tupNames) (S.difference tupNames accNames)

@@ -1176,7 +971,7 @@ evalGraphRefTupleExprs mAttrs (TupleExprs fixedMarker tupleExprL) = do

1176 pure nextTupleAttrs

971 pure nextTupleAttrs

1177 else

972 else

1178 throwError (TupleAttributeTypeMismatchError diff)

973 throwError (TupleAttributeTypeMismatchError diff)

1179− ) (V.toList $ tupleAttributes headTuple) tailTuples

974+ ) (V.toList . attributesVec $ tupleAttributes headTuple) tailTuples

1180 pure (A.attributesFromList mostResolvedTypes)

975 pure (A.attributesFromList mostResolvedTypes)

1181 --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

976 --strategy: if all the tuple expr transaction markers refer to one location, then we can pass the type constructor mapping from that location, otherwise, we cannot assume that the types are the same

1182 tConsMap <- case singularTransactions tupleExprL of

977 tConsMap <- case singularTransactions tupleExprL of

@@ -1222,56 +1017,6 @@ evalGraphRefTupleExpr mAttrs (TupleExpr tupMap) = do

1222-- _ <- lift $ except (validateTuple tup' tConss)

1017-- _ <- lift $ except (validateTuple tup' tConss)

1223 pure tup'

1018 pure tup'

1224

1019

1225−{-

1226−evalAttributeNames :: AttributeNames -> RelationalExpr -> RelationalExprM (Either RelationalError (S.Set AttributeName))

1227−evalAttributeNames attrNames expr = do

1228− eExprType <- typeForRelationalExpr expr

1229− case eExprType of

1230− Left err -> throwError err

1231− Right exprTyp -> do

1232− let typeNameSet = S.fromList (V.toList (A.attributeNames (attributes exprTyp)))

1233− case attrNames of

1234− AttributeNames names ->

1235− case A.projectionAttributesForNames names (attributes exprTyp) of

1236− Left err -> pure (Left err)

1237− Right attrs -> pure (Right (S.fromList (V.toList (A.attributeNames attrs))))

1238−

1239− InvertedAttributeNames names -> do

1240− let nonExistentAttributeNames = A.attributeNamesNotContained names typeNameSet

1241− if not (S.null nonExistentAttributeNames) then

1242− pure (Left (AttributeNamesMismatchError nonExistentAttributeNames))

1243− else

1244− pure (Right (A.nonMatchingAttributeNameSet names typeNameSet))

1245−

1246− UnionAttributeNames namesA namesB -> do

1247− eNameSetA <- evalAttributeNames namesA expr

1248− case eNameSetA of

1249− Left err -> pure (Left err)

1250− Right nameSetA -> do

1251− eNameSetB <- evalAttributeNames namesB expr

1252− case eNameSetB of

1253− Left err -> pure (Left err)

1254− Right nameSetB ->

1255− pure (Right (S.union nameSetA nameSetB))

1256−

1257− IntersectAttributeNames namesA namesB -> do

1258− eNameSetA <- evalAttributeNames namesA expr

1259− case eNameSetA of

1260− Left err -> pure (Left err)

1261− Right nameSetA -> do

1262− eNameSetB <- evalAttributeNames namesB expr

1263− case eNameSetB of

1264− Left err -> pure (Left err)

1265− Right nameSetB ->

1266− pure (Right (S.intersection nameSetA nameSetB))

1267−

1268− RelationalExprAttributeNames attrExpr -> do

1269− eAttrExprType <- typeForRelationalExpr attrExpr

1270− case eAttrExprType of

1271− Left err -> pure (Left err)

1272− Right attrExprType -> pure (Right (A.attributeNameSet (attributes attrExprType)))

1273−-}

1274−

1275--temporary implementation until we have a proper planner+executor

1020--temporary implementation until we have a proper planner+executor

1276evalGraphRefRelationalExpr :: GraphRefRelationalExpr -> GraphRefRelationalExprM Relation

1021evalGraphRefRelationalExpr :: GraphRefRelationalExpr -> GraphRefRelationalExprM Relation

1277evalGraphRefRelationalExpr (MakeRelationFromExprs mAttrExprs tupleExprs) = do

1022evalGraphRefRelationalExpr (MakeRelationFromExprs mAttrExprs tupleExprs) = do

@@ -1500,7 +1245,7 @@ relationVariablesAsRelation ctx graph = do

1500 let gfEnv = freshGraphRefRelationalExprEnv (Just ctx) graph

1245 let gfEnv = freshGraphRefRelationalExprEnv (Just ctx) graph

1501 gfType <- runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr gfExpr)

1246 gfType <- runGraphRefRelationalExprM gfEnv (typeForGraphRefRelationalExpr gfExpr)

1502 pure (rvName, gfType)

1247 pure (rvName, gfType)

1503− relVarToAtomList (rvName, rel) = [TextAtom rvName, attributesToRel (attributes rel)]

1248+ relVarToAtomList (rvName, rel) = [TextAtom rvName, attributesToRel (attributesVec (attributes rel))]

1504 attrAtoms a = [TextAtom (A.attributeName a), TextAtom (prettyAtomType (A.atomType a))]

1249 attrAtoms a = [TextAtom (A.attributeName a), TextAtom (prettyAtomType (A.atomType a))]

1505 attributesToRel attrl = case mkRelationFromList subrelAttrs (map attrAtoms (V.toList attrl)) of

1250 attributesToRel attrl = case mkRelationFromList subrelAttrs (map attrAtoms (V.toList attrl)) of

1506 Left err -> error ("relationVariablesAsRelation pooped " ++ show err)

1251 Left err -> error ("relationVariablesAsRelation pooped " ++ show err)

@@ -1520,15 +1265,6 @@ evalRelationalExpr expr = do

1520 Left err -> throwError err

1265 Left err -> throwError err

1521 Right rel -> pure rel

1266 Right rel -> pure rel

1522

1267

1523−{-

1524−relVarByName :: RelVarName -> GraphRefRelationalExprM GraphRefRelationalExpr

1525−relVarByName = do

1526− relvars <- relationVariables <$> getStateContext

1527− case M.lookup relVarName relvars of

1528− Nothing -> dbErr (RelVarNotDefinedError relVarName)

1529− Just gfexpr -> pure gfExpr

1530−-}

1531−

1532class (MonadError RelationalError m, Monad m) => DatabaseContextM m where

1268class (MonadError RelationalError m, Monad m) => DatabaseContextM m where

1533 getContext :: m DatabaseContext

1269 getContext :: m DatabaseContext

1534

1270

@@ -1613,3 +1349,44 @@ instance ResolveGraphRefTransactionMarker GraphRefAtomExpr where

1613 resolve (RelationAtomExpr expr) = RelationAtomExpr <$> resolve expr

1349 resolve (RelationAtomExpr expr) = RelationAtomExpr <$> resolve expr

1614 resolve (ConstructedAtomExpr dConsName atomExprs marker) =

1350 resolve (ConstructedAtomExpr dConsName atomExprs marker) =

1615 ConstructedAtomExpr dConsName <$> mapM resolve atomExprs <*> pure 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

128 "uuid",

129 "vector",

130 "text",

131− "binary",

132− "vector-binary-instances",

133 "time",

131 "time",

134 "project-m36",

132 "project-m36",

135 "bytestring"]

133 "bytestring"]

src/lib/ProjectM36/Serialise/AtomFunctionError.hsnew file+7

@@ -0,0 +1,7 @@

1+{-# LANGUAGE DerivingVia, StandaloneDeriving #-}

2+{-# OPTIONS_GHC -fno-warn-orphans #-}

3+module ProjectM36.Serialise.AtomFunctionError where

4+import Codec.Winery

5+import ProjectM36.AtomFunctionError

7+deriving via WineryVariant AtomFunctionError instance Serialise AtomFunctionError

src/lib/ProjectM36/Serialise/Base.hsnew file+85

@@ -0,0 +1,85 @@

1+{-# LANGUAGE StandaloneDeriving, DerivingVia, TypeApplications, TypeSynonymInstances, ScopedTypeVariables #-}

2+{-# OPTIONS_GHC -fno-warn-orphans #-}

3+--Serialise instances for ProjectM36.Base data types- orphan instance city

4+module ProjectM36.Serialise.Base where

5+import Codec.Winery hiding (Schema)

6+import Codec.Winery.Internal

7+import Control.Monad

8+import ProjectM36.Base

9+import ProjectM36.MerkleHash

10+import Data.UUID

11+import Data.Proxy

12+import Data.Word

13+import ProjectM36.Attribute as A

14+import qualified Data.List.NonEmpty as NE

15+import qualified Data.Vector as V

16+import Data.Time.Calendar (Day,toGregorian,fromGregorian)

17+

18+deriving via WineryVariant Atom instance Serialise Atom

19+deriving via WineryVariant AtomType instance Serialise AtomType

20+deriving via WineryVariant Attribute instance Serialise Attribute

21+deriving via WineryVariant RelationTupleSet instance Serialise RelationTupleSet

22+deriving via WineryVariant RelationTuple instance Serialise RelationTuple

23+deriving via WineryVariant Relation instance Serialise Relation

24+deriving via WineryVariant RelationCardinality instance Serialise RelationCardinality

25+deriving via WineryVariant (RelationalExprBase a) instance Serialise a => Serialise (RelationalExprBase a)

26+deriving via WineryVariant (WithNameExprBase a) instance Serialise a => Serialise (WithNameExprBase a)

27+deriving via WineryVariant Notification instance Serialise Notification

28+deriving via WineryVariant TypeConstructorDef instance Serialise TypeConstructorDef

29+deriving via WineryVariant (TypeConstructorBase a) instance Serialise a => Serialise (TypeConstructorBase a)

30+deriving via WineryVariant DataConstructorDef instance Serialise DataConstructorDef

31+deriving via WineryVariant DataConstructorDefArg instance Serialise DataConstructorDefArg

32+deriving via WineryVariant GraphRefTransactionMarker instance Serialise GraphRefTransactionMarker

33+deriving via WineryVariant SchemaIsomorph instance Serialise SchemaIsomorph

34+deriving via WineryVariant InclusionDependency instance Serialise InclusionDependency

35+deriving via WineryVariant (DatabaseContextExprBase a) instance Serialise a => Serialise (DatabaseContextExprBase a)

36+deriving via WineryVariant (DatabaseContextIOExprBase a) instance Serialise a => Serialise (DatabaseContextIOExprBase a)

37+deriving via WineryVariant (RestrictionPredicateExprBase a) instance Serialise a => Serialise (RestrictionPredicateExprBase a)

38+deriving via WineryVariant TransactionInfo instance Serialise TransactionInfo

39+deriving via WineryVariant (AtomExprBase a) instance Serialise a => Serialise (AtomExprBase a)

40+deriving via WineryVariant MerkleHash instance Serialise MerkleHash

41+deriving via WineryVariant (AttributeExprBase a) instance Serialise a => Serialise (AttributeExprBase a)

42+deriving via WineryVariant (TupleExprsBase a) instance Serialise a => Serialise (TupleExprsBase a)

43+deriving via WineryVariant (TupleExprBase a) instance Serialise a => Serialise (TupleExprBase a)

44+deriving via WineryVariant (AttributeNamesBase a) instance Serialise a => Serialise (AttributeNamesBase a)

45+deriving via WineryVariant (ExtendTupleExprBase a) instance Serialise a => Serialise (ExtendTupleExprBase a)

46+deriving via WineryVariant Schema instance Serialise Schema

47+deriving via WineryVariant MergeStrategy instance Serialise MergeStrategy

48+

49+fromWordsTup :: (Word32, Word32, Word32, Word32) -> TransactionId

50+fromWordsTup (a,b,c,d) = fromWords a b c d

51+

52+instance Serialise TransactionId where

53+ schemaGen _ = getSchema (Proxy @(Word32, Word32, Word32, Word32))

54+ toBuilder uuid = toBuilder (toWords uuid)

55+ extractor = fromWordsTup <$> extractor

56+ decodeCurrent = fromWordsTup <$> decodeCurrent

57+

58+instance Serialise a => Serialise (NE.NonEmpty a) where

59+ schemaGen _ = SVector <$> getSchema (Proxy @a)

60+ toBuilder xs = varInt (length xs) <> foldMap toBuilder xs

61+ extractor = NE.fromList . V.toList <$> extractListBy extractor --use nonempty instead to replace error with winery error

62+ decodeCurrent = do

63+ n <- decodeVarInt

64+ l <- replicateM n decodeCurrent

65+ pure (NE.fromList l)

66+

67+fromGregorianTup :: (Integer, Int, Int) -> Day

68+fromGregorianTup (a, b, c) = fromGregorian a b c

69+

70+instance Serialise Day where

71+ schemaGen _ = getSchema (Proxy @(Integer, Int, Int))

72+ toBuilder day = toBuilder (toGregorian day)

73+ extractor = fromGregorianTup <$> extractor

74+ decodeCurrent = fromGregorianTup <$> decodeCurrent

75+

76+instance Serialise Attributes where

77+ schemaGen _ = SVector <$> getSchema (Proxy @Attribute)

78+ toBuilder attrs = varInt (V.length (attributesVec attrs)) <> foldMap toBuilder (V.toList (attributesVec attrs))

79+ extractor =

80+ attributesFromList . V.toList <$> extractListBy extractor

81+

82+ decodeCurrent = do

83+ n <- decodeVarInt

84+ l <- replicateM n decodeCurrent

85+ pure (A.attributesFromList l)

src/lib/ProjectM36/Serialise/DataFrame.hsnew file+13

@@ -0,0 +1,13 @@

1+{-# LANGUAGE DerivingVia, StandaloneDeriving #-}

2+{-# OPTIONS_GHC -fno-warn-orphans #-}

3+module ProjectM36.Serialise.DataFrame where

4+import Codec.Winery

5+import ProjectM36.DataFrame

6+import ProjectM36.Serialise.Base ()

8+deriving via WineryVariant AttributeOrderExpr instance Serialise AttributeOrderExpr

9+deriving via WineryVariant AttributeOrder instance Serialise AttributeOrder

10+deriving via WineryVariant Order instance Serialise Order

11+deriving via WineryRecord DataFrame instance Serialise DataFrame

12+deriving via WineryVariant DataFrameTuple instance Serialise DataFrameTuple

13+deriving via WineryRecord DataFrameExpr instance Serialise DataFrameExpr

src/lib/ProjectM36/Serialise/DatabaseContextFunctionError.hsnew file+7

@@ -0,0 +1,7 @@

1+{-# LANGUAGE DerivingVia, StandaloneDeriving #-}

2+{-# OPTIONS_GHC -fno-warn-orphans #-}

3+module ProjectM36.Serialise.DatabaseContextFunctionError where

4+import Codec.Winery

5+import ProjectM36.DatabaseContextFunctionError

7+deriving via WineryVariant DatabaseContextFunctionError instance Serialise DatabaseContextFunctionError

src/lib/ProjectM36/Serialise/Error.hsnew file+15

@@ -0,0 +1,15 @@

1+{-# LANGUAGE DerivingVia, StandaloneDeriving #-}

2+{-# OPTIONS_GHC -fno-warn-orphans #-}

3+module ProjectM36.Serialise.Error where

4+import ProjectM36.Error

5+import Codec.Winery

6+import ProjectM36.Serialise.Base ()

7+import ProjectM36.Serialise.AtomFunctionError ()

8+import ProjectM36.Serialise.DatabaseContextFunctionError ()

10+deriving via WineryVariant RelationalError instance Serialise RelationalError

11+deriving via WineryVariant MergeError instance Serialise MergeError

12+deriving via WineryVariant ScriptCompilationError instance Serialise ScriptCompilationError

13+deriving via WineryVariant PersistenceError instance Serialise PersistenceError

14+deriving via WineryVariant SchemaError instance Serialise SchemaError

15+deriving via WineryVariant ImportError' instance Serialise ImportError'

src/lib/ProjectM36/Serialise/IsomorphicSchema.hsnew file+7

@@ -0,0 +1,7 @@

1+{-# LANGUAGE StandaloneDeriving, DerivingVia, TypeSynonymInstances, ScopedTypeVariables #-}

2+{-# OPTIONS_GHC -fno-warn-orphans #-}

3+module ProjectM36.Serialise.IsomorphicSchema where

4+import Codec.Winery

5+import ProjectM36.IsomorphicSchema

7+deriving via WineryVariant SchemaExpr instance Serialise SchemaExpr

src/lib/ProjectM36/Serialise/MergeError.hsnew file+1

@@ -0,0 +1 @@

src/lib/ProjectM36/Server.hs+166−91

@@ -7,77 +7,119 @@ import ProjectM36.Server.RemoteCallTypes

7import ProjectM36.Server.Config (ServerConfig(..))

8import ProjectM36.FSType

10−import Control.Monad.IO.Class (liftIO)

11−#if MIN_VERSION_network_transport_tcp(0,7,0)

12−import Network.Transport.TCP (createTransport, defaultTCPParameters, defaultTCPAddr)

13−#else

14−import Network.Transport.TCP (createTransport, defaultTCPParameters)

15−#endif

16−import Network.Transport (EndPointAddress(..), newEndPoint, address)

17−import Control.Distributed.Process.Node (initRemoteTable, runProcess, newLocalNode, initRemoteTable)

18−import Control.Distributed.Process.Extras.Time (Delay(..))

19−import Control.Distributed.Process (Process, register, getSelfPid)

20−import Control.Distributed.Process.ManagedProcess (defaultProcess, UnhandledMessagePolicy(..), ProcessDefinition(..), handleCall, serve, InitHandler, InitResult(..))

21−import Control.Concurrent.MVar (putMVar, MVar)

10+import Control.Concurrent.MVar (MVar)

22import System.IO (stderr, hPutStrLn)

11import System.IO (stderr, hPutStrLn)

23import System.FilePath (takeDirectory)

12import System.FilePath (takeDirectory)

24import System.Directory (doesDirectoryExist)

13import System.Directory (doesDirectoryExist)

14+import Network.RPC.Curryer.Server

15+import Network.Socket

16+import qualified StmContainers.Map as StmMap

17+import Control.Concurrent.STM

26−-- the state should be a mapping of remote connection to the disconnected transaction- the graph should be the same, so discon must be removed from the stm tuple

19+type TestMode = Bool

27−--trying to refactor this for less repetition is very challenging because the return type cannot be polymorphic or the distributed-process call gets confused and drops messages

28−serverDefinition :: Bool -> Timeout -> ProcessDefinition Connection

29−serverDefinition testBool ti = defaultProcess {

30− apiHandlers = [

31− handleCall (\conn (ExecuteHeadName sessionId) -> handleExecuteHeadName ti sessionId conn),

32− handleCall (\conn (ExecuteRelationalExpr sessionId expr) -> handleExecuteRelationalExpr ti sessionId conn expr),

33− handleCall (\conn (ExecuteDataFrameExpr sessionId expr) -> handleExecuteDataFrameExpr ti sessionId conn expr),

34− handleCall (\conn (ExecuteDatabaseContextExpr sessionId expr) -> handleExecuteDatabaseContextExpr ti sessionId conn expr),

35− handleCall (\conn (ExecuteDatabaseContextIOExpr sessionId expr) -> handleExecuteDatabaseContextIOExpr ti sessionId conn expr),

36− handleCall (\conn (ExecuteGraphExpr sessionId expr) -> handleExecuteGraphExpr ti sessionId conn expr),

37− handleCall (\conn (ExecuteTransGraphRelationalExpr sessionId expr) -> handleExecuteTransGraphRelationalExpr ti sessionId conn expr),

38− handleCall (\conn (ExecuteTypeForRelationalExpr sessionId expr) -> handleExecuteTypeForRelationalExpr ti sessionId conn expr),

39− handleCall (\conn (RetrieveInclusionDependencies sessionId) -> handleRetrieveInclusionDependencies ti sessionId conn),

40− handleCall (\conn (RetrievePlanForDatabaseContextExpr sessionId dbExpr) -> handleRetrievePlanForDatabaseContextExpr ti sessionId conn dbExpr),

41− handleCall (\conn (RetrieveHeadTransactionId sessionId) -> handleRetrieveHeadTransactionId ti sessionId conn),

42− handleCall (\conn (RetrieveTransactionGraph sessionId) -> handleRetrieveTransactionGraph ti sessionId conn),

43− handleCall (\conn (Login procId) -> handleLogin ti conn procId),

44− handleCall (\conn (CreateSessionAtHead headn) -> handleCreateSessionAtHead ti conn headn),

45− handleCall (\conn (CreateSessionAtCommit commitId) -> handleCreateSessionAtCommit ti conn commitId),

46− handleCall (\conn (CloseSession sessionId) -> handleCloseSession ti sessionId conn),

47− handleCall (\conn (RetrieveAtomTypesAsRelation sessionId) -> handleRetrieveAtomTypesAsRelation ti sessionId conn),

48− handleCall (\conn (RetrieveRelationVariableSummary sessionId) -> handleRetrieveRelationVariableSummary ti sessionId conn),

49− handleCall (\conn (RetrieveAtomFunctionSummary sessionId) -> handleRetrieveAtomFunctionSummary ti sessionId conn),

50− handleCall (\conn (RetrieveDatabaseContextFunctionSummary sessionId) -> handleRetrieveDatabaseContextFunctionSummary ti sessionId conn),

51− handleCall (\conn (RetrieveCurrentSchemaName sessionId) -> handleRetrieveCurrentSchemaName ti sessionId conn),

52− handleCall (\conn (ExecuteSchemaExpr sessionId schemaExpr) -> handleExecuteSchemaExpr ti sessionId conn schemaExpr),

53− handleCall (\conn (RetrieveSessionIsDirty sessionId) -> handleRetrieveSessionIsDirty ti sessionId conn),

54− handleCall (\conn (ExecuteAutoMergeToHead sessionId strat headName') -> handleExecuteAutoMergeToHead ti sessionId conn strat headName'),

55− handleCall (\conn (RetrieveTypeConstructorMapping sessionId) -> handleRetrieveTypeConstructorMapping ti sessionId conn),

56− handleCall (\conn (ExecuteValidateMerkleHashes sessionId) -> handleValidateMerkleHashes ti sessionId conn),

57− handleCall (\conn Logout -> handleLogout ti conn)

58− ] ++ testModeHandlers,

59− unhandledMessagePolicy = Terminate

60− --unhandledMessagePolicy = Log

61− }

62− where

63− testModeHandlers = [handleCall (\conn (TestTimeout sessionId) -> handleTestTimeout ti sessionId conn) | testBool]

64−

65−initServer :: InitHandler (Connection, DatabaseName, Maybe (MVar EndPointAddress), EndPointAddress) Connection

66−initServer (conn, dbname, mAddressMVar, saddress) = do

67− registerDB dbname

68− case mAddressMVar of

69− Nothing -> pure ()

70− Just addressMVar -> liftIO $ putMVar addressMVar saddress

71− --traceShowM ("server started on " ++ show saddress)

72− pure $ InitOk conn Infinity

74−registerDB :: DatabaseName -> Process ()

21+requestHandlers :: TestMode -> Maybe Timeout -> RequestHandlers ServerState

75−registerDB dbname = do

22+requestHandlers testFlag ti =

76− self <- getSelfPid

23+ [

77− let dbname' = remoteDBLookupName dbname

24+ RequestHandler (\sState (Login dbName) -> do

78− register dbname' self

25+ addClientLogin dbName sState

79− --liftIO $ putStrLn $ "registered " ++ (show self) ++ " " ++ dbname'

26+ conn <- getConn sState

80−

27+ handleLogin conn (connectionSocket sState)),

28+ RequestHandler (\sState Logout -> do

29+ conn <- getConn sState

30+ handleLogout ti conn),

31+ RequestHandler $ \sState (ExecuteHeadName sessionId) -> do

32+ --socket -> dbname --maybe create a socket->client state mapping in the server state, too

33+ conn <- getConn sState

34+ handleExecuteHeadName ti sessionId conn,

35+ RequestHandler (\sState (ExecuteRelationalExpr sessionId expr) -> do

36+ conn <- getConn sState

37+ handleExecuteRelationalExpr ti sessionId conn expr),

38+ RequestHandler (\sState (ExecuteDataFrameExpr sessionId expr) -> do

39+ conn <- getConn sState

40+ handleExecuteDataFrameExpr ti sessionId conn expr),

41+ RequestHandler (\sState (ExecuteDatabaseContextExpr sessionId expr) -> do

42+ conn <- getConn sState

43+ handleExecuteDatabaseContextExpr ti sessionId conn expr),

44+ RequestHandler (\sState (ExecuteDatabaseContextIOExpr sessionId expr) -> do

45+ conn <- getConn sState

46+ handleExecuteDatabaseContextIOExpr ti sessionId conn expr),

47+ RequestHandler (\sState (ExecuteGraphExpr sessionId expr) -> do

48+ conn <- getConn sState

49+ handleExecuteGraphExpr ti sessionId conn expr),

50+ RequestHandler (\sState (ExecuteTransGraphRelationalExpr sessionId expr) -> do

51+ conn <- getConn sState

52+ handleExecuteTransGraphRelationalExpr ti sessionId conn expr),

53+ RequestHandler (\sState (ExecuteTypeForRelationalExpr sessionId expr) -> do

54+ conn <- getConn sState

55+ handleExecuteTypeForRelationalExpr ti sessionId conn expr),

56+ RequestHandler (\sState (RetrieveInclusionDependencies sessionId) -> do

57+ conn <- getConn sState

58+ handleRetrieveInclusionDependencies ti sessionId conn),

59+ RequestHandler (\sState (RetrievePlanForDatabaseContextExpr sessionId dbExpr) -> do

60+ conn <- getConn sState

61+ handleRetrievePlanForDatabaseContextExpr ti sessionId conn dbExpr),

62+ RequestHandler (\sState (RetrieveHeadTransactionId sessionId) -> do

63+ conn <- getConn sState

64+ handleRetrieveHeadTransactionId ti sessionId conn),

65+ RequestHandler (\sState (RetrieveTransactionGraph sessionId) -> do

66+ conn <- getConn sState

67+ handleRetrieveTransactionGraph ti sessionId conn),

68+ RequestHandler (\sState (CreateSessionAtHead headn) -> do

69+ conn <- getConn sState

70+ handleCreateSessionAtHead ti conn headn),

71+ RequestHandler (\sState (CreateSessionAtCommit commitId) -> do

72+ conn <- getConn sState

73+ handleCreateSessionAtCommit ti conn commitId),

74+ RequestHandler (\sState (CloseSession sessionId) -> do

75+ conn <- getConn sState

76+ handleCloseSession sessionId conn),

77+ RequestHandler (\sState (RetrieveAtomTypesAsRelation sessionId) -> do

78+ conn <- getConn sState

79+ handleRetrieveAtomTypesAsRelation ti sessionId conn),

80+ RequestHandler (\sState (RetrieveRelationVariableSummary sessionId) -> do

81+ conn <- getConn sState

82+ handleRetrieveRelationVariableSummary ti sessionId conn),

83+ RequestHandler (\sState (RetrieveAtomFunctionSummary sessionId) -> do

84+ conn <- getConn sState

85+ handleRetrieveAtomFunctionSummary ti sessionId conn),

86+ RequestHandler (\sState (RetrieveDatabaseContextFunctionSummary sessionId) -> do

87+ conn <- getConn sState

88+ handleRetrieveDatabaseContextFunctionSummary ti sessionId conn), RequestHandler (\sState (RetrieveCurrentSchemaName sessionId) -> do

89+ conn <- getConn sState

90+ handleRetrieveCurrentSchemaName ti sessionId conn),

91+ RequestHandler (\sState (ExecuteSchemaExpr sessionId schemaExpr) -> do

92+ conn <- getConn sState

93+ handleExecuteSchemaExpr ti sessionId conn schemaExpr),

94+ RequestHandler (\sState (RetrieveSessionIsDirty sessionId) -> do

95+ conn <- getConn sState

96+ handleRetrieveSessionIsDirty ti sessionId conn),

97+ RequestHandler (\sState (ExecuteAutoMergeToHead sessionId strat headName') -> do

98+ conn <- getConn sState

99+ handleExecuteAutoMergeToHead ti sessionId conn strat headName'),

100+ RequestHandler (\sState (RetrieveTypeConstructorMapping sessionId) -> do

101+ conn <- getConn sState

102+ handleRetrieveTypeConstructorMapping ti sessionId conn),

103+ RequestHandler (\sState (ExecuteValidateMerkleHashes sessionId) -> do

104+ conn <- getConn sState

105+ handleValidateMerkleHashes ti sessionId conn)

106+ ] ++ if testFlag then testModeHandlers ti else []

107+

108+getConn :: ConnectionState ServerState -> IO Connection

109+getConn connState = do

110+ let sock = lockless (connectionSocket connState)

111+ sState = connectionServerState connState

112+ mConn <- connectionForClient sock sState

113+ case mConn of

114+ Nothing -> error "failed to find socket in client map"

115+ Just conn -> pure conn

116+

117+testModeHandlers :: Maybe Timeout -> RequestHandlers ServerState

118+testModeHandlers ti = [RequestHandler (\sState (TestTimeout sessionId) -> do

119+ conn <- getConn sState

120+ handleTestTimeout ti sessionId conn)]

121+

122+

81-- | A notification callback which logs the notification to stderr and does nothing else.

123-- | A notification callback which logs the notification to stderr and does nothing else.

82loggingNotificationCallback :: NotificationCallback

124loggingNotificationCallback :: NotificationCallback

83loggingNotificationCallback notName evaldNot = hPutStrLn stderr $ "Notification received \"" ++ show notName ++ "\": " ++ show evaldNot

125loggingNotificationCallback notName evaldNot = hPutStrLn stderr $ "Notification received \"" ++ show notName ++ "\": " ++ show evaldNot

@@ -102,9 +144,47 @@ checkFSType performCheck strat =

102checkFSErrorMsg :: String

144checkFSErrorMsg :: String

103checkFSErrorMsg = "The filesystem does not support journaling so writes may not be crash-safe. Use --disable-fscheck to disable this fatal error."

145checkFSErrorMsg = "The filesystem does not support journaling so writes may not be crash-safe. Use --disable-fscheck to disable this fatal error."

104

146

147+-- Sockets do not implement hashable, so we just use their string values as keys

148+type SocketString = String

149+

150+data ServerState =

151+ ServerState {

152+ --map available databases to local database configurations

153+ stateDBMap :: StmMap.Map DatabaseName Connection,

154+ --map clients to database names- after logging in, clients are afixed to specific database names

155+ stateClientMap :: StmMap.Map SocketString DatabaseName

156+ }

157+

158+-- add a client socket to the database mapping

159+addClientLogin :: DatabaseName -> ConnectionState ServerState -> IO ()

160+addClientLogin dbName cState = do

161+ let clientMap = stateClientMap (connectionServerState cState)

162+ sock = lockless (connectionSocket cState)

163+ atomically $ do

164+ mVal <- StmMap.lookup (show sock) clientMap

165+ case mVal of

166+ Nothing -> StmMap.insert dbName (show sock) clientMap

167+ Just _ -> pure () --TODO: throw exception- user already logged in

168+

169+connectionForClient :: Socket -> ServerState -> IO (Maybe Connection)

170+connectionForClient sock sState =

171+ atomically $ do

172+ mdbname <- StmMap.lookup (show sock) (stateClientMap sState)

173+ case mdbname of

174+ Nothing -> pure Nothing

175+ Just dbname ->

176+ StmMap.lookup dbname (stateDBMap sState)

177+

178+initialServerState :: DatabaseName -> Connection -> IO ServerState

179+initialServerState dbName conn =

180+ atomically $ do

181+ dbmap <- StmMap.new

182+ clientMap <- StmMap.new

183+ StmMap.insert conn dbName dbmap

184+ pure (ServerState { stateDBMap = dbmap, stateClientMap = clientMap })

105-- | A synchronous function to start the project-m36 daemon given an appropriate 'ServerConfig'. Note that this function only returns if the server exits. Returns False if the daemon exited due to an error. If the second argument is not Nothing, the port is put after the server is ready to service the port.

185-- | A synchronous function to start the project-m36 daemon given an appropriate 'ServerConfig'. Note that this function only returns if the server exits. Returns False if the daemon exited due to an error. If the second argument is not Nothing, the port is put after the server is ready to service the port.

106−launchServer :: ServerConfig -> Maybe (MVar EndPointAddress) -> IO Bool

186+launchServer :: ServerConfig -> Maybe (MVar SockAddr) -> IO Bool

107−launchServer daemonConfig mAddressMVar = do

187+launchServer daemonConfig mAddr = do

108 checkFSResult <- checkFSType (checkFS daemonConfig) (persistenceStrategy daemonConfig)

188 checkFSResult <- checkFSType (checkFS daemonConfig) (persistenceStrategy daemonConfig)

109 if not checkFSResult then do

189 if not checkFSResult then do

110 hPutStrLn stderr checkFSErrorMsg

190 hPutStrLn stderr checkFSErrorMsg

@@ -117,26 +197,21 @@ launchServer daemonConfig mAddressMVar = do

117 pure False

197 pure False

118 Right conn -> do

198 Right conn -> do

119 let hostname = bindHost daemonConfig

199 let hostname = bindHost daemonConfig

120− port = bindPort daemonConfig

200+ port = fromIntegral (bindPort daemonConfig)

121−#if MIN_VERSION_network_transport_tcp(0,7,0)

201+

122− etransport <- createTransport (defaultTCPAddr hostname (show port)) defaultTCPParameters

202+

123−#elif MIN_VERSION_network_transport_tcp(0,6,0)

203+ --curryer only supports IPv4 for now

124− etransport <- createTransport hostname (show port) (\nam -> (hostname, nam)) defaultTCPParameters

204+ let addrHints = defaultHints { addrSocketType = Stream, addrFamily = AF_INET }

125−#else

205+ hostAddrs <- getAddrInfo (Just addrHints) (Just hostname) Nothing

126− etransport <- createTransport hostname (show port) defaultTCPParameters

127−#endif

128− case etransport of

129− Left err -> error ("failed to create transport: " ++ show err)

130− Right transport -> do

131− eEndpoint <- newEndPoint transport

132− case eEndpoint of

206+ case hostAddrs of

133− Left err -> hPutStrLn stderr ("Failed to create transport: " ++ show err) >> pure False

207+ [] -> hPutStrLn stderr ("Failed to resolve: " <> hostname) >> pure False

134− Right endpoint -> do

208+ (AddrInfo _ _ _ _ (SockAddrInet _ addr32) _):_ -> do

135− localTCPNode <- newLocalNode transport initRemoteTable

209+ let hostAddr = hostAddressToTuple addr32

136− --traceShowM ("newLocalNode in Server " ++ show (localNodeId localTCPNode))

137− runProcess localTCPNode $ do

138− let testBool = testMode daemonConfig

139− reqTimeout = perRequestTimeout daemonConfig

210+ mTimeout = fromIntegral <$> case perRequestTimeout daemonConfig of

140− serve (conn, databaseName daemonConfig, mAddressMVar, address endpoint) initServer (serverDefinition testBool reqTimeout)

211+ 0 -> Nothing

141− liftIO $ putStrLn "serve returned"

212+ v -> Just v

142− pure True

213+

214+ sState <- initialServerState (databaseName daemonConfig) conn

215+ serve (requestHandlers (testMode daemonConfig) mTimeout) sState hostAddr port mAddr

216+ _ -> error "unsupported socket addressing mode (IPv4 only currently)"

217+

src/lib/ProjectM36/Server/Config.hs+6

@@ -12,6 +12,12 @@ data ServerConfig = ServerConfig { persistenceStrategy :: PersistenceStrategy,

12 }

13 deriving (Show)

15+data WebsocketServerConfig = WebsocketServerConfig { wsServerConfig :: ServerConfig,

16+ tlsCertificatePath :: Maybe String,

17+ tlsKeyPath :: Maybe String

18+ }

19+ deriving (Show)

20+

15defaultServerConfig :: ServerConfig

21defaultServerConfig :: ServerConfig

16defaultServerConfig = ServerConfig { persistenceStrategy = NoPersistence,

22defaultServerConfig = ServerConfig { persistenceStrategy = NoPersistence,

17 checkFS = True,

23 checkFS = True,

src/lib/ProjectM36/Server/EntryPoints.hs+125−157

@@ -3,176 +3,144 @@ module ProjectM36.Server.EntryPoints where

3import ProjectM36.Base hiding (inclusionDependencies)

4import ProjectM36.IsomorphicSchema

5import ProjectM36.Client as C

6−import ProjectM36.Error

7−import Control.Distributed.Process (Process, ProcessId)

8−import Control.Distributed.Process.ManagedProcess (ProcessReply)

9−import Control.Distributed.Process.ManagedProcess.Server (reply)

10−import Control.Distributed.Process.Async (async, task, waitCancelTimeout, AsyncResult(..))

11−import Control.Monad.IO.Class (liftIO)

12import Data.Map

6import Data.Map

13import Control.Concurrent (threadDelay)

7import Control.Concurrent (threadDelay)

14−import Data.Typeable

8+import Network.RPC.Curryer.Server

15−import Data.Binary

9+import System.Timeout hiding (Timeout)

10+import Network.Socket

11+import Control.Exception

17−timeoutOrDie :: (Binary a, Typeable a) => Timeout -> IO a -> Process (Either ServerError a)

13+timeoutOrDie :: Maybe Timeout -> IO a -> IO (Maybe a)

18−timeoutOrDie micros act =

14+timeoutOrDie mMicros act =

19− if micros == 0 then

20− liftIO act >>= \x -> pure (Right x)

21− else do

22− asyncUnit <- async (task (liftIO act))

23− asyncRes <- waitCancelTimeout micros asyncUnit

24− case asyncRes of

15+ case mMicros of

25− AsyncDone x -> pure (Right x)

16+ Nothing -> Just <$> act

26− AsyncCancelled -> pure (Left RequestTimeoutError)

17+ Just micros ->

27− AsyncFailed reason -> pure (Left (ProcessDiedError (show reason)))

18+ timeout (fromIntegral micros) act

28− AsyncLinkFailed reason -> pure (Left (ProcessDiedError (show reason)))

29− AsyncPending -> pure (Left (ProcessDiedError "process pending"))

30−

31−type Timeout = Int

32−

33−type Reply a = Process (ProcessReply (Either ServerError a) Connection)

34−

35−handleExecuteRelationalExpr :: Timeout -> SessionId -> Connection -> RelationalExpr -> Reply (Either RelationalError Relation)

36−handleExecuteRelationalExpr ti sessionId conn expr = do

37− ret <- timeoutOrDie ti (executeRelationalExpr sessionId conn expr)

38− reply ret conn

40−handleExecuteDataFrameExpr :: Timeout -> SessionId -> Connection -> DataFrameExpr -> Reply (Either RelationalError DataFrame)

20+timeoutRelErr :: Maybe Timeout -> IO (Either RelationalError a) -> IO (Either RelationalError a)

41−handleExecuteDataFrameExpr ti sessionId conn expr = do

21+timeoutRelErr mMicros act = do

42− ret <- timeoutOrDie ti (executeDataFrameExpr sessionId conn expr)

22+ ret <- timeoutOrDie mMicros act

43− reply ret conn

44−

45−handleExecuteDatabaseContextExpr :: Timeout -> SessionId -> Connection -> DatabaseContextExpr -> Reply (Either RelationalError ())

46−handleExecuteDatabaseContextExpr ti sessionId conn dbexpr = do

47− ret <- timeoutOrDie ti (executeDatabaseContextExpr sessionId conn dbexpr)

48− reply ret conn

49−

50−handleExecuteDatabaseContextIOExpr :: Timeout -> SessionId -> Connection -> DatabaseContextIOExpr -> Reply (Either RelationalError ())

51−handleExecuteDatabaseContextIOExpr ti sessionId conn dbexpr = do

52− ret <- timeoutOrDie ti (executeDatabaseContextIOExpr sessionId conn dbexpr)

53− reply ret conn

54−

55−handleExecuteHeadName :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError HeadName)

56−handleExecuteHeadName ti sessionId conn = do

57− ret <- timeoutOrDie ti (headName sessionId conn)

58− reply ret conn

59−

60−handleLogin :: Timeout -> Connection -> ProcessId -> Reply Bool

61−handleLogin ti conn newClientProcessId = do

62− ret <- timeoutOrDie ti (addClientNode conn newClientProcessId)

63 case ret of

23 case ret of

64− Right () -> reply (Right True) conn

24+ Nothing -> throw TimeoutException

65− Left err -> reply (Left err) conn

25+ Just v -> pure v

66−

26+

67−handleExecuteGraphExpr :: Timeout -> SessionId -> Connection -> TransactionGraphOperator -> Reply (Either RelationalError ())

68−handleExecuteGraphExpr ti sessionId conn graphExpr = do

69− ret <- timeoutOrDie ti (executeGraphExpr sessionId conn graphExpr)

70− reply ret conn

71−

72−handleExecuteTransGraphRelationalExpr :: Timeout -> SessionId -> Connection -> TransGraphRelationalExpr -> Reply (Either RelationalError Relation)

73−handleExecuteTransGraphRelationalExpr ti sessionId conn graphExpr = do

74− ret <- timeoutOrDie ti (executeTransGraphRelationalExpr sessionId conn graphExpr)

75− reply ret conn

77−handleExecuteTypeForRelationalExpr :: Timeout -> SessionId -> Connection -> RelationalExpr -> Reply (Either RelationalError Relation)

28+handleExecuteRelationalExpr :: Maybe Timeout -> SessionId -> Connection -> RelationalExpr -> IO (Either RelationalError Relation)

78−handleExecuteTypeForRelationalExpr ti sessionId conn relExpr = do

29+handleExecuteRelationalExpr ti sessionId conn expr =

30+ timeoutRelErr ti (executeRelationalExpr sessionId conn expr)

31+

32+handleExecuteDataFrameExpr :: Maybe Timeout -> SessionId -> Connection -> DataFrameExpr -> IO (Either RelationalError DataFrame)

33+handleExecuteDataFrameExpr ti sessionId conn expr =

34+ timeoutRelErr ti (executeDataFrameExpr sessionId conn expr)

35+

36+handleExecuteDatabaseContextExpr :: Maybe Timeout -> SessionId -> Connection -> DatabaseContextExpr -> IO (Either RelationalError ())

37+handleExecuteDatabaseContextExpr ti sessionId conn dbexpr =

38+ timeoutRelErr ti (executeDatabaseContextExpr sessionId conn dbexpr)

39+

40+handleExecuteDatabaseContextIOExpr :: Maybe Timeout -> SessionId -> Connection -> DatabaseContextIOExpr -> IO (Either RelationalError ())

41+handleExecuteDatabaseContextIOExpr ti sessionId conn dbexpr =

42+ timeoutRelErr ti (executeDatabaseContextIOExpr sessionId conn dbexpr)

43+

44+handleExecuteHeadName :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError HeadName)

45+handleExecuteHeadName ti sessionId conn =

46+ timeoutRelErr ti (headName sessionId conn)

47+

48+handleLogin :: Connection -> Locking Socket -> IO Bool

49+handleLogin conn lockSock = do

50+ addClientNode conn lockSock

51+ pure True

52+

53+handleExecuteGraphExpr :: Maybe Timeout -> SessionId -> Connection -> TransactionGraphOperator -> IO (Either RelationalError ())

54+handleExecuteGraphExpr ti sessionId conn graphExpr =

55+ timeoutRelErr ti (executeGraphExpr sessionId conn graphExpr)

56+

57+handleExecuteTransGraphRelationalExpr :: Maybe Timeout -> SessionId -> Connection -> TransGraphRelationalExpr -> IO (Either RelationalError Relation)

58+handleExecuteTransGraphRelationalExpr ti sessionId conn graphExpr =

59+ timeoutRelErr ti (executeTransGraphRelationalExpr sessionId conn graphExpr)

60+

61+handleExecuteTypeForRelationalExpr :: Maybe Timeout -> SessionId -> Connection -> RelationalExpr -> IO (Either RelationalError Relation)

62+handleExecuteTypeForRelationalExpr ti sessionId conn relExpr =

79− ret <- timeoutOrDie ti (typeForRelationalExpr sessionId conn relExpr)

63+ timeoutRelErr ti (typeForRelationalExpr sessionId conn relExpr)

80− reply ret conn

64+

81−

82−handleRetrieveInclusionDependencies :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError (Map IncDepName InclusionDependency))

65+handleRetrieveInclusionDependencies :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError (Map IncDepName InclusionDependency))

83−handleRetrieveInclusionDependencies ti sessionId conn = do

66+handleRetrieveInclusionDependencies ti sessionId conn =

84− ret <- timeoutOrDie ti (inclusionDependencies sessionId conn)

67+ timeoutRelErr ti (inclusionDependencies sessionId conn)

85− reply ret conn

68+

86−

87−handleRetrievePlanForDatabaseContextExpr :: Timeout -> SessionId -> Connection -> DatabaseContextExpr -> Reply (Either RelationalError GraphRefDatabaseContextExpr)

69+handleRetrievePlanForDatabaseContextExpr :: Maybe Timeout -> SessionId -> Connection -> DatabaseContextExpr -> IO (Either RelationalError GraphRefDatabaseContextExpr)

88−handleRetrievePlanForDatabaseContextExpr ti sessionId conn dbExpr = do

70+handleRetrievePlanForDatabaseContextExpr ti sessionId conn dbExpr =

89− ret <- timeoutOrDie ti (planForDatabaseContextExpr sessionId conn dbExpr)

71+ timeoutRelErr ti (planForDatabaseContextExpr sessionId conn dbExpr)

90− reply ret conn

72+

91−

92−handleRetrieveTransactionGraph :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError Relation)

73+handleRetrieveTransactionGraph :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Relation)

93−handleRetrieveTransactionGraph ti sessionId conn = do

74+handleRetrieveTransactionGraph ti sessionId conn =

94− ret <- timeoutOrDie ti (transactionGraphAsRelation sessionId conn)

75+ timeoutRelErr ti (transactionGraphAsRelation sessionId conn)

95− reply ret conn

76+

96−

97−handleRetrieveHeadTransactionId :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError TransactionId)

77+handleRetrieveHeadTransactionId :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError TransactionId)

98−handleRetrieveHeadTransactionId ti sessionId conn = do

78+handleRetrieveHeadTransactionId ti sessionId conn =

99− ret <- timeoutOrDie ti (headTransactionId sessionId conn)

79+ timeoutRelErr ti (headTransactionId sessionId conn)

100− reply ret conn

101−

102−handleCreateSessionAtCommit :: Timeout -> Connection -> TransactionId -> Reply (Either RelationalError SessionId)

103−handleCreateSessionAtCommit ti conn commitId = do

104− ret <- timeoutOrDie ti (createSessionAtCommit conn commitId)

105− reply ret conn

106−

107−handleCreateSessionAtHead :: Timeout -> Connection -> HeadName -> Reply (Either RelationalError SessionId)

108−handleCreateSessionAtHead ti conn headn = do

109− ret <- timeoutOrDie ti (createSessionAtHead conn headn)

110− reply ret conn

111−

112−handleCloseSession :: Timeout -> SessionId -> Connection -> Reply ()

113−handleCloseSession ti sessionId conn = do

114− ret <- timeoutOrDie ti (closeSession sessionId conn)

115− case ret of

116− Right () -> reply (Right ()) conn

117− Left err -> reply (Left err) conn

118

81+handleCreateSessionAtCommit :: Maybe Timeout -> Connection -> TransactionId -> IO (Either RelationalError SessionId)

82+handleCreateSessionAtCommit ti conn commitId =

83+ timeoutRelErr ti (createSessionAtCommit conn commitId)

84+

85+handleCreateSessionAtHead :: Maybe Timeout -> Connection -> HeadName -> IO (Either RelationalError SessionId)

86+handleCreateSessionAtHead ti conn headn =

87+ timeoutRelErr ti (createSessionAtHead conn headn)

88+

89+handleCloseSession :: SessionId -> Connection -> IO ()

90+handleCloseSession =

91+ closeSession

92+

119−handleRetrieveAtomTypesAsRelation :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError Relation)

93+handleRetrieveAtomTypesAsRelation :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Relation)

120−handleRetrieveAtomTypesAsRelation ti sessionId conn = do

94+handleRetrieveAtomTypesAsRelation ti sessionId conn =

121− ret <- timeoutOrDie ti (atomTypesAsRelation sessionId conn)

95+ timeoutRelErr ti (atomTypesAsRelation sessionId conn)

122− reply ret conn

123

124-- | Returns a relation which lists the names of relvars in the current session as well as its types.

97-- | Returns a relation which lists the names of relvars in the current session as well as its types.

125−handleRetrieveRelationVariableSummary :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError Relation)

98+handleRetrieveRelationVariableSummary :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Relation)

126−handleRetrieveRelationVariableSummary ti sessionId conn = do

99+handleRetrieveRelationVariableSummary ti sessionId conn =

127− ret <- timeoutOrDie ti (relationVariablesAsRelation sessionId conn)

100+ timeoutRelErr ti (relationVariablesAsRelation sessionId conn)

128− reply ret conn

101+

129−

130−handleRetrieveAtomFunctionSummary :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError Relation)

102+handleRetrieveAtomFunctionSummary :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Relation)

131−handleRetrieveAtomFunctionSummary ti sessionId conn = do

103+handleRetrieveAtomFunctionSummary ti sessionId conn =

132− ret <- timeoutOrDie ti (atomFunctionsAsRelation sessionId conn)

104+ timeoutRelErr ti (atomFunctionsAsRelation sessionId conn)

133− reply ret conn

105+

134−

135−handleRetrieveDatabaseContextFunctionSummary :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError Relation)

106+handleRetrieveDatabaseContextFunctionSummary :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Relation)

136−handleRetrieveDatabaseContextFunctionSummary ti sessionId conn = do

107+handleRetrieveDatabaseContextFunctionSummary ti sessionId conn =

137− ret <- timeoutOrDie ti (databaseContextFunctionsAsRelation sessionId conn)

108+ timeoutRelErr ti (databaseContextFunctionsAsRelation sessionId conn)

138− reply ret conn

109+

139−

140−handleRetrieveCurrentSchemaName :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError SchemaName)

110+handleRetrieveCurrentSchemaName :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError SchemaName)

141−handleRetrieveCurrentSchemaName ti sessionId conn = do

111+handleRetrieveCurrentSchemaName ti sessionId conn =

142− ret <- timeoutOrDie ti (currentSchemaName sessionId conn)

112+ timeoutRelErr ti (currentSchemaName sessionId conn)

143− reply ret conn

144

113

145−handleExecuteSchemaExpr :: Timeout -> SessionId -> Connection -> SchemaExpr -> Reply (Either RelationalError ())

114+handleExecuteSchemaExpr :: Maybe Timeout -> SessionId -> Connection -> SchemaExpr -> IO (Either RelationalError ())

146−handleExecuteSchemaExpr ti sessionId conn schemaExpr = do

115+handleExecuteSchemaExpr ti sessionId conn schemaExpr =

147− ret <- timeoutOrDie ti (executeSchemaExpr sessionId conn schemaExpr)

116+ timeoutRelErr ti (executeSchemaExpr sessionId conn schemaExpr)

148− reply ret conn

149

117

150−handleLogout :: Timeout -> Connection -> Reply Bool

118+handleLogout :: Maybe Timeout -> Connection -> IO Bool

151−handleLogout _ =

119+handleLogout _ _ =

152 --liftIO $ closeRemote_ conn

120 --liftIO $ closeRemote_ conn

153− reply (pure True)

121+ pure True

154

122

155−handleTestTimeout :: Timeout -> SessionId -> Connection -> Reply Bool

123+handleTestTimeout :: Maybe Timeout -> SessionId -> Connection -> IO Bool

156−handleTestTimeout ti _ conn = do

124+handleTestTimeout ti _ _ = do

157− ret <- timeoutOrDie ti (threadDelay 100000 >> pure True)

125+ ret <- timeoutRelErr ti (threadDelay 100000 >> pure (Right ()))

158− reply ret conn

126+ case ret of

127+ Right () -> pure True

128+ Left _ -> pure False

159

129

130+

131+

160−handleRetrieveSessionIsDirty :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError Bool)

132+handleRetrieveSessionIsDirty :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError Bool)

161−handleRetrieveSessionIsDirty ti sessionId conn = do

133+handleRetrieveSessionIsDirty ti sessionId conn =

162− ret <- timeoutOrDie ti (disconnectedTransactionIsDirty sessionId conn)

134+ timeoutRelErr ti (disconnectedTransactionIsDirty sessionId conn)

163− reply ret conn

135+

164−

165−handleExecuteAutoMergeToHead :: Timeout -> SessionId -> Connection -> MergeStrategy -> HeadName -> Reply (Either RelationalError ())

136+handleExecuteAutoMergeToHead :: Maybe Timeout -> SessionId -> Connection -> MergeStrategy -> HeadName -> IO (Either RelationalError ())

166−handleExecuteAutoMergeToHead ti sessionId conn strat headName' = do

137+handleExecuteAutoMergeToHead ti sessionId conn strat headName' =

167− ret <- timeoutOrDie ti (autoMergeToHead sessionId conn strat headName')

138+ timeoutRelErr ti (autoMergeToHead sessionId conn strat headName')

168− reply ret conn

169

139

170−handleRetrieveTypeConstructorMapping :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError TypeConstructorMapping)

140+handleRetrieveTypeConstructorMapping :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError TypeConstructorMapping)

171−handleRetrieveTypeConstructorMapping ti sessionId conn = do

141+handleRetrieveTypeConstructorMapping ti sessionId conn =

172− ret <- timeoutOrDie ti (C.typeConstructorMapping sessionId conn)

142+ timeoutRelErr ti (C.typeConstructorMapping sessionId conn)

173− reply ret conn

174

143

175−handleValidateMerkleHashes :: Timeout -> SessionId -> Connection -> Reply (Either RelationalError ())

144+handleValidateMerkleHashes :: Maybe Timeout -> SessionId -> Connection -> IO (Either RelationalError ())

176−handleValidateMerkleHashes ti sessionId conn = do

145+handleValidateMerkleHashes ti sessionId conn =

177− ret <- timeoutOrDie ti (C.validateMerkleHashes sessionId conn)

146+ timeoutRelErr ti (C.validateMerkleHashes sessionId conn)

178− reply ret conn

src/lib/ProjectM36/Server/ParseArgs.hs+32−15

@@ -17,14 +17,14 @@ parseArgsWithDefaults defaults = ServerConfig <$>

17 many parseGhcPkgPath <*>

18 parseTimeout (perRequestTimeout defaults) <*>

19 parseTestMode

20−

20+

21parsePersistenceStrategy :: Parser PersistenceStrategy

22parsePersistenceStrategy = CrashSafePersistence <$> (dbdirOpt <* fsyncOpt) <|>

23 MinimalPersistence <$> dbdirOpt <|>

24 pure NoPersistence

25− where

25+ where

26− dbdirOpt = strOption (short 'd' <>

26+ dbdirOpt = strOption (short 'd' <>

27− long "database-directory" <>

27+ long "database-directory" <>

28 metavar "DIRECTORY" <>

29 showDefaultWith show

30 )

@@ -34,43 +34,60 @@ parsePersistenceStrategy = CrashSafePersistence <$> (dbdirOpt <* fsyncOpt) <|>

35parseTestMode :: Parser Bool

36parseTestMode = flag True False (long "test-mode" <> hidden)

37−

37+

38−parseCheckFS :: Parser Bool

38+parseCheckFS :: Parser Bool

39parseCheckFS = flag True False (long "disable-fscheck" <>

40 help "Disable filesystem check for journaling.")

41−

41+

42parseDatabaseName :: Parser DatabaseName

43parseDatabaseName = strOption (short 'n' <>

44 long "database" <>

45 metavar "DATABASE_NAME")

47−parseHostname :: Hostname -> Parser Hostname

47+parseHostname :: Hostname -> Parser Hostname

48parseHostname defHostname = strOption (short 'h' <>

49 long "hostname" <>

50 metavar "HOST_NAME" <>

51 value defHostname)

52−

52+

53−parsePort :: Port -> Parser Port

53+parsePort :: Port -> Parser Port

54parsePort defPort = option auto (short 'p' <>

55 long "port" <>

56 metavar "PORT_NUMBER" <>

57 value defPort)

58−

58+

59parseGhcPkgPath :: Parser String

60parseGhcPkgPath = strOption (long "ghc-pkg-dir" <>

61 metavar "GHC_PACKAGE_DIRECTORY")

62−

62+

63−parseTimeout :: Int -> Parser Int

63+parseTimeout :: Int -> Parser Int

64parseTimeout defTimeout = option auto (long "timeout" <>

65 metavar "MICROSECONDS" <>

66 value defTimeout)

68parseConfig :: IO ServerConfig

69parseConfig = parseConfigWithDefaults defaultServerConfig

70−

70+

71parseConfigWithDefaults :: ServerConfig -> IO ServerConfig

72parseConfigWithDefaults defaults = execParser (info (parseArgsWithDefaults defaults <**> helpOption) idm)

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")

75helpOption :: Parser (a -> a)

92helpOption :: Parser (a -> a)

76helpOption = abortOption helpText $ mconcat

93helpOption = abortOption helpText $ mconcat

@@ -80,6 +97,6 @@ helpOption = abortOption helpText $ mconcat

80 where

97 where

81#if MIN_VERSION_optparse_applicative(0,16,0)

98#if MIN_VERSION_optparse_applicative(0,16,0)

82 helpText = ShowHelpText Nothing

99 helpText = ShowHelpText Nothing

83−#else

100+#else

84 helpText = ShowHelpText

101 helpText = ShowHelpText

85#endif

102#endif

src/lib/ProjectM36/Server/RemoteCallTypes.hs+65−36

@@ -1,4 +1,4 @@

1−{-# LANGUAGE DeriveAnyClass, DeriveGeneric #-}

1+{-# LANGUAGE DeriveGeneric, DerivingVia, CPP #-}

2module ProjectM36.Server.RemoteCallTypes where

3import ProjectM36.Base

4import ProjectM36.IsomorphicSchema

@@ -6,69 +6,98 @@ import ProjectM36.TransactionGraph

6import ProjectM36.DataFrame

7import ProjectM36.TransGraphRelationalExpression

8import ProjectM36.Session

9+import ProjectM36.Serialise.DataFrame ()

10+import ProjectM36.Serialise.IsomorphicSchema ()

9import GHC.Generics

11import GHC.Generics

10−import Data.Binary

12+import Codec.Winery

11−import Control.Distributed.Process (ProcessId)

13+

14+#define RPCData(typeName) deriving Generic \

15+ deriving Serialise via WineryVariant typeName

13{-# ANN module ("HLint: ignore Use newtype instead of data" :: String) #-}

17{-# ANN module ("HLint: ignore Use newtype instead of data" :: String) #-}

14-- | The initial login message. The argument should be the process id of the initiating client. This ProcessId will receive notification callbacks.

18-- | The initial login message. The argument should be the process id of the initiating client. This ProcessId will receive notification callbacks.

15−data Login = Login ProcessId

19+data Login = Login DatabaseName

16− deriving (Binary, Generic)

20+ RPCData(Login)

18data Logout = Logout

22data Logout = Logout

19− deriving (Binary, Generic)

23+ RPCData(Logout)

24+

20−data ExecuteRelationalExpr = ExecuteRelationalExpr SessionId RelationalExpr

25+data ExecuteRelationalExpr = ExecuteRelationalExpr SessionId RelationalExpr

21− deriving (Binary, Generic)

26+ RPCData(ExecuteRelationalExpr)

27+

22data ExecuteDataFrameExpr = ExecuteDataFrameExpr SessionId DataFrameExpr

28data ExecuteDataFrameExpr = ExecuteDataFrameExpr SessionId DataFrameExpr

23− deriving (Binary, Generic)

29+ RPCData(ExecuteDataFrameExpr)

30+

24data ExecuteDatabaseContextExpr = ExecuteDatabaseContextExpr SessionId DatabaseContextExpr

31data ExecuteDatabaseContextExpr = ExecuteDatabaseContextExpr SessionId DatabaseContextExpr

25− deriving (Binary, Generic)

32+ RPCData(ExecuteDatabaseContextExpr)

33+

26data ExecuteDatabaseContextIOExpr = ExecuteDatabaseContextIOExpr SessionId DatabaseContextIOExpr

34data ExecuteDatabaseContextIOExpr = ExecuteDatabaseContextIOExpr SessionId DatabaseContextIOExpr

27− deriving (Binary, Generic)

35+ RPCData(ExecuteDatabaseContextIOExpr)

36+

28data ExecuteGraphExpr = ExecuteGraphExpr SessionId TransactionGraphOperator

37data ExecuteGraphExpr = ExecuteGraphExpr SessionId TransactionGraphOperator

29− deriving (Binary, Generic)

38+ RPCData(ExecuteGraphExpr)

39+

30data ExecuteTransGraphRelationalExpr = ExecuteTransGraphRelationalExpr SessionId TransGraphRelationalExpr

40data ExecuteTransGraphRelationalExpr = ExecuteTransGraphRelationalExpr SessionId TransGraphRelationalExpr

31− deriving (Binary, Generic)

41+ RPCData(ExecuteTransGraphRelationalExpr)

42+

32data ExecuteHeadName = ExecuteHeadName SessionId

43data ExecuteHeadName = ExecuteHeadName SessionId

33− deriving (Binary, Generic)

44+ RPCData(ExecuteHeadName)

45+

34data ExecuteTypeForRelationalExpr = ExecuteTypeForRelationalExpr SessionId RelationalExpr

46data ExecuteTypeForRelationalExpr = ExecuteTypeForRelationalExpr SessionId RelationalExpr

35− deriving (Binary, Generic)

47+ RPCData(ExecuteTypeForRelationalExpr)

48+

36−data ExecuteSchemaExpr = ExecuteSchemaExpr SessionId SchemaExpr

49+data ExecuteSchemaExpr = ExecuteSchemaExpr SessionId SchemaExpr RPCData(ExecuteSchemaExpr)

37− deriving (Binary, Generic)

50+

38data ExecuteSetCurrentSchema = ExecuteSetCurrentSchema SessionId SchemaName

51data ExecuteSetCurrentSchema = ExecuteSetCurrentSchema SessionId SchemaName

39− deriving (Binary, Generic)

52+ RPCData(ExecuteSetCurrentSchema)

53+

40data RetrieveInclusionDependencies = RetrieveInclusionDependencies SessionId

54data RetrieveInclusionDependencies = RetrieveInclusionDependencies SessionId

41− deriving (Binary, Generic)

55+ RPCData(RetrieveInclusionDependencies)

56+

42data RetrievePlanForDatabaseContextExpr = RetrievePlanForDatabaseContextExpr SessionId DatabaseContextExpr

57data RetrievePlanForDatabaseContextExpr = RetrievePlanForDatabaseContextExpr SessionId DatabaseContextExpr

43− deriving (Binary, Generic)

58+ RPCData(RetrievePlanForDatabaseContextExpr)

59+

44data RetrieveTransactionGraph = RetrieveTransactionGraph SessionId

60data RetrieveTransactionGraph = RetrieveTransactionGraph SessionId

45− deriving (Binary, Generic)

61+ RPCData(RetrieveTransactionGraph)

62+

46data RetrieveHeadTransactionId = RetrieveHeadTransactionId SessionId

63data RetrieveHeadTransactionId = RetrieveHeadTransactionId SessionId

47− deriving (Binary, Generic)

64+ RPCData(RetrieveHeadTransactionId)

65+

48data CreateSessionAtCommit = CreateSessionAtCommit TransactionId

66data CreateSessionAtCommit = CreateSessionAtCommit TransactionId

49− deriving (Binary, Generic)

67+ RPCData(CreateSessionAtCommit)

68+

50data CreateSessionAtHead = CreateSessionAtHead HeadName

69data CreateSessionAtHead = CreateSessionAtHead HeadName

51− deriving (Binary, Generic)

70+ RPCData(CreateSessionAtHead)

71+

52data CloseSession = CloseSession SessionId

72data CloseSession = CloseSession SessionId

53− deriving (Binary, Generic)

73+ RPCData(CloseSession)

74+

54data RetrieveAtomTypesAsRelation = RetrieveAtomTypesAsRelation SessionId

75data RetrieveAtomTypesAsRelation = RetrieveAtomTypesAsRelation SessionId

55− deriving (Binary, Generic)

76+ RPCData(RetrieveAtomTypesAsRelation)

77+

56data RetrieveRelationVariableSummary = RetrieveRelationVariableSummary SessionId

78data RetrieveRelationVariableSummary = RetrieveRelationVariableSummary SessionId

57− deriving (Binary, Generic)

79+ RPCData(RetrieveRelationVariableSummary)

80+

58data RetrieveAtomFunctionSummary = RetrieveAtomFunctionSummary SessionId

81data RetrieveAtomFunctionSummary = RetrieveAtomFunctionSummary SessionId

59− deriving (Binary, Generic)

82+ RPCData(RetrieveAtomFunctionSummary)

83+

60data RetrieveDatabaseContextFunctionSummary = RetrieveDatabaseContextFunctionSummary SessionId

84data RetrieveDatabaseContextFunctionSummary = RetrieveDatabaseContextFunctionSummary SessionId

61− deriving (Binary, Generic)

85+ RPCData(RetrieveDatabaseContextFunctionSummary)

86+

62data RetrieveCurrentSchemaName = RetrieveCurrentSchemaName SessionId

87data RetrieveCurrentSchemaName = RetrieveCurrentSchemaName SessionId

63− deriving (Binary, Generic)

88+ RPCData(RetrieveCurrentSchemaName)

89+

64data TestTimeout = TestTimeout SessionId

90data TestTimeout = TestTimeout SessionId

65− deriving (Binary, Generic)

91+ RPCData(TestTimeout)

92+

66−data RetrieveSessionIsDirty = RetrieveSessionIsDirty SessionId

93+data RetrieveSessionIsDirty = RetrieveSessionIsDirty SessionId

67− deriving (Binary, Generic)

94+ RPCData(RetrieveSessionIsDirty)

95+

68data ExecuteAutoMergeToHead = ExecuteAutoMergeToHead SessionId MergeStrategy HeadName

96data ExecuteAutoMergeToHead = ExecuteAutoMergeToHead SessionId MergeStrategy HeadName

69− deriving (Binary, Generic)

97+ RPCData(ExecuteAutoMergeToHead)

98+

70data RetrieveTypeConstructorMapping = RetrieveTypeConstructorMapping SessionId

99data RetrieveTypeConstructorMapping = RetrieveTypeConstructorMapping SessionId

71− deriving (Binary, Generic)

100+ RPCData(RetrieveTypeConstructorMapping)

101

73data ExecuteValidateMerkleHashes = ExecuteValidateMerkleHashes SessionId

102data ExecuteValidateMerkleHashes = ExecuteValidateMerkleHashes SessionId

74− deriving (Binary, Generic)

103+ RPCData(ExecuteValidateMerkleHashes)

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

23-- the static optimizer performs optimizations which need not take any specific-relation statistics into account

25−--import Debug.Trace

26−

27data GraphRefSOptRelationalExprEnv =

25data GraphRefSOptRelationalExprEnv =

28 GraphRefSOptRelationalExprEnv

26 GraphRefSOptRelationalExprEnv

29 {

27 {

@@ -179,7 +177,7 @@ fullOptimizeGraphRefRelationalExpr expr = do

179optimizeGraphRefRelationalExpr :: GraphRefRelationalExpr -> GraphRefSOptRelationalExprM GraphRefRelationalExpr

177optimizeGraphRefRelationalExpr :: GraphRefRelationalExpr -> GraphRefSOptRelationalExprM GraphRefRelationalExpr

180optimizeGraphRefRelationalExpr e@(MakeStaticRelation _ _) = pure e

178optimizeGraphRefRelationalExpr e@(MakeStaticRelation _ _) = pure e

181

179

182−optimizeGraphRefRelationalExpr e@(MakeRelationFromExprs _ _) = pure e

180+optimizeGraphRefRelationalExpr e@MakeRelationFromExprs{} = pure e

183

181

184optimizeGraphRefRelationalExpr e@(ExistingRelation _) = pure e

182optimizeGraphRefRelationalExpr e@(ExistingRelation _) = pure e

185

183

@@ -209,6 +207,8 @@ optimizeGraphRefRelationalExpr (Union exprA exprB) = do

209 case (optExprA, optExprB) of

207 case (optExprA, optExprB) of

210 (Restrict predA (RelationVariable nameA sA),

208 (Restrict predA (RelationVariable nameA sA),

211 Restrict predB (RelationVariable nameB sB)) | nameA == nameB && sA == sB -> pure (Restrict (AndPredicate predA predB) (RelationVariable nameA sA))

209 Restrict predB (RelationVariable nameB sB)) | nameA == nameB && sA == sB -> pure (Restrict (AndPredicate predA predB) (RelationVariable nameA sA))

210+ (exprA', exprB') | isEmptyRelationExpr exprA' -> pure exprB'

211+ | isEmptyRelationExpr exprB' -> pure exprA'

212 _ -> if optExprA == optExprB then

213 pure optExprA

214 else

@@ -575,3 +575,4 @@ applyStaticRestrictionPushdown expr = case expr of

575-- no optimizations available

576optimizeDatabaseContextIOExpr :: GraphRefDatabaseContextIOExpr -> GraphRefSOptDatabaseContextExprM GraphRefDatabaseContextIOExpr

577optimizeDatabaseContextIOExpr = pure

578+

src/lib/ProjectM36/TransGraphRelationalExpression.hs−17

@@ -10,43 +10,26 @@ import Control.Monad.Trans.Reader

10import Control.Monad.Trans.Class

11import Control.Monad.Trans.Except

12import Data.Functor.Identity

13−import Data.Binary

15-- | The TransGraphRelationalExpression is equivalent to a relational expression except that relation variables can reference points in the transaction graph (at previous points in time).

14-- | The TransGraphRelationalExpression is equivalent to a relational expression except that relation variables can reference points in the transaction graph (at previous points in time).

16type TransGraphRelationalExpr = RelationalExprBase TransactionIdLookup

15type TransGraphRelationalExpr = RelationalExprBase TransactionIdLookup

18−instance Binary TransGraphRelationalExpr

19−

20type TransGraphAttributeNames = AttributeNamesBase TransactionIdLookup

17type TransGraphAttributeNames = AttributeNamesBase TransactionIdLookup

22−instance Binary TransGraphAttributeNames

23−

24type TransGraphExtendTupleExpr = ExtendTupleExprBase TransactionIdLookup

19type TransGraphExtendTupleExpr = ExtendTupleExprBase TransactionIdLookup

26−instance Binary TransGraphExtendTupleExpr

27−

28type TransGraphTupleExpr = TupleExprBase TransactionIdLookup

21type TransGraphTupleExpr = TupleExprBase TransactionIdLookup

30−instance Binary TransGraphTupleExpr

31−

32type TransGraphTupleExprs = TupleExprsBase TransactionIdLookup

23type TransGraphTupleExprs = TupleExprsBase TransactionIdLookup

34−instance Binary TransGraphTupleExprs

35−

36type TransGraphRestrictionPredicateExpr = RestrictionPredicateExprBase TransactionIdLookup

25type TransGraphRestrictionPredicateExpr = RestrictionPredicateExprBase TransactionIdLookup

38−instance Binary TransGraphRestrictionPredicateExpr

39−

40type TransGraphAtomExpr = AtomExprBase TransactionIdLookup

27type TransGraphAtomExpr = AtomExprBase TransactionIdLookup

42−instance Binary TransGraphAtomExpr

43−

44type TransGraphAttributeExpr = AttributeExprBase TransactionIdLookup

29type TransGraphAttributeExpr = AttributeExprBase TransactionIdLookup

46type TransGraphWithNameExpr = WithNameExprBase TransactionIdLookup

31type TransGraphWithNameExpr = WithNameExprBase TransactionIdLookup

48−instance Binary TransGraphWithNameExpr

49−

50newtype TransGraphEvalEnv = TransGraphEvalEnv {

33newtype TransGraphEvalEnv = TransGraphEvalEnv {

51 tge_graph :: TransactionGraph

34 tge_graph :: TransactionGraph

52 }

35 }

src/lib/ProjectM36/Transaction/Persist.hs+16−16

@@ -8,13 +8,13 @@ import ProjectM36.AtomFunction

8import ProjectM36.Persist (writeBSFileSync, DiskSync, renameSync)

9import qualified Data.Map as M

10import qualified Data.HashSet as HS

11−import qualified Data.Binary as B

12import System.FilePath

11import System.FilePath

13import System.Directory

12import System.Directory

14import qualified Data.Text as T

13import qualified Data.Text as T

15import Control.Monad

14import Control.Monad

16import ProjectM36.ScriptSession

15import ProjectM36.ScriptSession

17import ProjectM36.AtomFunctions.Basic (precompiledAtomFunctions)

16import ProjectM36.AtomFunctions.Basic (precompiledAtomFunctions)

17+import Codec.Winery

19#ifdef PM36_HASKELL_SCRIPTING

20import GHC

@@ -62,7 +62,7 @@ readTransaction dbdir transId mScriptSession = do

62 return $ Left $ MissingTransactionError transId

63 else do

64 relvars <- readRelVars transDir

65− transInfo <- B.decodeFile (transactionInfoPath transDir)

65+ transInfo <- readFileDeserialise (transactionInfoPath transDir)

66 incDeps <- readIncDeps transDir

67 typeCons <- readTypeConstructorMapping transDir

68 sschemas <- readSubschemas transDir

@@ -92,28 +92,28 @@ writeTransaction sync dbdir trans = do

92 writeDBCFuncs sync tempTransDir (dbcFunctions context)

93 writeTypeConstructorMapping sync tempTransDir (typeConstructorMapping context)

94 writeSubschemas sync tempTransDir (subschemas trans)

95− B.encodeFile (transactionInfoPath tempTransDir) (transactionInfo trans)

95+ writeFileSerialise (transactionInfoPath tempTransDir) (transactionInfo trans)

96 --move the temp directory to final location

97 renameSync sync tempTransDir finalTransDir

99writeRelVars :: DiskSync -> FilePath -> RelationVariables -> IO ()

100writeRelVars sync transDir relvars = do

101 let path = relvarsPath transDir

102− writeBSFileSync sync path (B.encode relvars)

102+ writeBSFileSync sync path (serialise relvars)

103

104readRelVars :: FilePath -> IO RelationVariables

105readRelVars transDir =

106− B.decodeFile (relvarsPath transDir)

106+ readFileDeserialise (relvarsPath transDir)

107

108writeAtomFuncs :: DiskSync -> FilePath -> AtomFunctions -> IO ()

109writeAtomFuncs sync transDir funcs = do

110 let atomFuncPath = atomFuncsPath transDir

111− writeBSFileSync sync atomFuncPath (B.encode $ map (\f -> (atomFuncType f, atomFuncName f, atomFunctionScript f)) (HS.toList funcs))

111+ writeBSFileSync sync atomFuncPath (serialise $ map (\f -> (atomFuncType f, atomFuncName f, atomFunctionScript f)) (HS.toList funcs))

112

113--all the atom functions are in one file

114readAtomFuncs :: FilePath -> Maybe ScriptSession -> IO AtomFunctions

115readAtomFuncs transDir mScriptSession = do

116− atomFuncsList <- B.decodeFile (atomFuncsPath transDir)

116+ atomFuncsList <- readFileDeserialise (atomFuncsPath transDir)

117 --only Haskell script functions can be serialized

118 --we always return the pre-compiled functions

119 funcs <- mapM (\(funcType, funcName, mFuncScript) -> loadAtomFunc precompiledAtomFunctions mScriptSession funcName funcType mFuncScript) atomFuncsList

@@ -153,7 +153,7 @@ readAtomFunc _ _ _ _ = error "Haskell scripting is disabled"

153#else

154readAtomFunc transDir funcName mScriptSession precompiledFuncs = do

155 let atomFuncPath = atomFuncsPath transDir

156− (funcType, mFuncScript) <- B.decodeFile @([AtomType],Maybe T.Text) atomFuncPath

156+ (funcType, mFuncScript) <- readFileDeserialise @([AtomType],Maybe T.Text) atomFuncPath

157 case mFuncScript of

158 --handle pre-compiled case- pull it from the precompiled list

159 Nothing -> case atomFunctionForName funcName precompiledFuncs of

@@ -184,7 +184,7 @@ writeDBCFuncs sync transDir funcs = mapM_ (writeDBCFunc sync transDir) (HS.toLis

184writeDBCFunc :: DiskSync -> FilePath -> DatabaseContextFunction -> IO ()

185writeDBCFunc sync transDir func = do

186 let dbcFuncPath = dbcFuncsDir transDir </> T.unpack (dbcFuncName func)

187− writeBSFileSync sync dbcFuncPath (B.encode (dbcFuncType func, databaseContextFunctionScript func))

187+ writeBSFileSync sync dbcFuncPath (serialise (dbcFuncType func, databaseContextFunctionScript func))

188

189readDBCFuncs :: FilePath -> Maybe ScriptSession -> IO DatabaseContextFunctions

190readDBCFuncs transDir mScriptSession = do

@@ -201,7 +201,7 @@ readDBCFunc transDir funcName _ precompiledFuncs = do

201readDBCFunc transDir funcName mScriptSession precompiledFuncs = do

202#endif

203 let dbcFuncPath = dbcFuncsDir transDir </> T.unpack funcName

204− (_funcType, mFuncScript) <- B.decodeFile @([AtomType], Maybe T.Text) dbcFuncPath

204+ (_funcType, mFuncScript) <- readFileDeserialise @([AtomType], Maybe T.Text) dbcFuncPath

205 case mFuncScript of

206 Nothing -> case databaseContextFunctionForName funcName precompiledFuncs of

207 Left _ -> error ("expected precompiled dbc function: " ++ T.unpack funcName)

@@ -225,7 +225,7 @@ readDBCFunc transDir funcName mScriptSession precompiledFuncs = do

225

226writeIncDep :: DiskSync -> FilePath -> (IncDepName, InclusionDependency) -> IO ()

227writeIncDep sync transDir (incDepName, incDep) =

228− writeBSFileSync sync (incDepsDir transDir </> T.unpack incDepName) $ B.encode incDep

228+ writeBSFileSync sync (incDepsDir transDir </> T.unpack incDepName) $ serialise incDep

229

230writeIncDeps :: DiskSync -> FilePath -> M.Map IncDepName InclusionDependency -> IO ()

231writeIncDeps sync transDir incdeps = mapM_ (writeIncDep sync transDir) $ M.toList incdeps

@@ -233,7 +233,7 @@ writeIncDeps sync transDir incdeps = mapM_ (writeIncDep sync transDir) $ M.toLis

233readIncDep :: FilePath -> IncDepName -> IO (IncDepName, InclusionDependency)

234readIncDep transDir incdepName = do

235 let incDepPath = incDepsDir transDir </> T.unpack incdepName

236− incDepData <- B.decodeFile incDepPath

236+ incDepData <- readFileDeserialise incDepPath

237 pure (incdepName, incDepData)

238

239readIncDeps :: FilePath -> IO (M.Map IncDepName InclusionDependency)

@@ -245,20 +245,20 @@ readIncDeps transDir = do

245readSubschemas :: FilePath -> IO Subschemas

246readSubschemas transDir = do

247 let sschemasPath = subschemasPath transDir

248− B.decodeFile sschemasPath

248+ readFileDeserialise sschemasPath

249

250writeSubschemas :: DiskSync -> FilePath -> Subschemas -> IO ()

251writeSubschemas sync transDir sschemas = do

252 let sschemasPath = subschemasPath transDir

253− writeBSFileSync sync sschemasPath (B.encode sschemas)

253+ writeBSFileSync sync sschemasPath (serialise sschemas)

254

255writeTypeConstructorMapping :: DiskSync -> FilePath -> TypeConstructorMapping -> IO ()

256writeTypeConstructorMapping sync path types = let atPath = typeConsPath path in

257− writeBSFileSync sync atPath $ B.encode types

257+ writeBSFileSync sync atPath $ serialise types

258

259readTypeConstructorMapping :: FilePath -> IO TypeConstructorMapping

260readTypeConstructorMapping path = do

261 let atPath = typeConsPath path

262− B.decodeFile atPath

262+ readFileDeserialise atPath

263

264

src/lib/ProjectM36/TransactionGraph.hs+15−13

@@ -1,4 +1,4 @@

1−{-# LANGUAGE DeriveAnyClass, DeriveGeneric, CPP, FlexibleContexts #-}

1+{-# LANGUAGE DeriveGeneric, CPP, FlexibleContexts, DerivingVia #-}

2module ProjectM36.TransactionGraph where

3import ProjectM36.Base

4import ProjectM36.Error

@@ -13,6 +13,7 @@ import ProjectM36.MerkleHash

13import qualified ProjectM36.DisconnectedTransaction as Discon

14import qualified ProjectM36.Attribute as A

16+import Codec.Winery

16import Control.Monad.Except hiding (join)

17import Control.Monad.Except hiding (join)

17import Control.Monad.Reader hiding (join)

18import Control.Monad.Reader hiding (join)

18import qualified Data.Vector as V

19import qualified Data.Vector as V

@@ -23,7 +24,6 @@ import qualified Data.List.NonEmpty as NE

23import Data.Time.Clock

24import Data.Time.Clock

24import qualified Data.Text as T

25import qualified Data.Text as T

25import GHC.Generics

26import GHC.Generics

26−import Data.Binary as B

27import Data.Either (lefts, rights, isRight)

28#if __GLASGOW_HASKELL__ < 804

29import Data.Monoid

@@ -38,13 +38,15 @@ import Crypto.Hash.SHA256

38-- | Record a lookup for a specific transaction in the graph.

39data TransactionIdLookup = TransactionIdLookup TransactionId |

40 TransactionIdHeadNameLookup HeadName [TransactionIdHeadBacktrack]

41− deriving (Show, Eq, Binary, Generic)

41+ deriving (Show, Eq, Generic)

42+ deriving Serialise via WineryVariant TransactionIdLookup

43-- | Used for git-style head backtracking such as topic~3^2.

44-- | Used for git-style head backtracking such as topic~3^2.

44−data TransactionIdHeadBacktrack = TransactionIdHeadParentBacktrack Int | -- ^ git equivalent of ~: walk back n parents, arbitrarily choosing a parent when a choice must be made

45+data TransactionIdHeadBacktrack = TransactionIdHeadParentBacktrack Int | -- ^ git equivalent of ~v: walk back n parents, arbitrarily choosing a parent when a choice must be made

45 TransactionIdHeadBranchBacktrack Int | -- ^ git equivalent of ^: walk back one parent level to the nth arbitrarily-chosen parent

46 TransactionIdHeadBranchBacktrack Int | -- ^ git equivalent of ^: walk back one parent level to the nth arbitrarily-chosen parent

46 TransactionStampHeadBacktrack UTCTime -- ^ git equivalent of 'git-rev-list -n 1 --before X' find the first transaction which was created before the timestamp

47 TransactionStampHeadBacktrack UTCTime -- ^ git equivalent of 'git-rev-list -n 1 --before X' find the first transaction which was created before the timestamp

47− deriving (Show, Eq, Binary, Generic)

48+ deriving (Show, Eq, Generic)

49+ deriving Serialise via WineryVariant TransactionIdHeadBacktrack

50-- | Operators which manipulate a transaction graph and which transaction the current 'Session' is based upon.

52-- | Operators which manipulate a transaction graph and which transaction the current 'Session' is based upon.

@@ -56,7 +58,8 @@ data TransactionGraphOperator = JumpToHead HeadName |

56 MergeTransactions MergeStrategy HeadName HeadName |

58 MergeTransactions MergeStrategy HeadName HeadName |

57 Commit |

59 Commit |

58 Rollback

60 Rollback

59− deriving (Eq, Show, Binary, Generic)

61+ deriving (Eq, Show, Generic)

62+ deriving Serialise via WineryVariant TransactionGraphOperator

61isCommit :: TransactionGraphOperator -> Bool

64isCommit :: TransactionGraphOperator -> Bool

62isCommit Commit = True

65isCommit Commit = True

@@ -381,7 +384,7 @@ subGraphOfFirstCommonAncestor origGraph resultHeads currentTrans' goalTrans trav

381 else do

384 else do

382 currentTransChildren <- childTransactions currentTrans' origGraph

385 currentTransChildren <- childTransactions currentTrans' origGraph

383 let searchChildren = S.difference (S.insert currentTrans' traverseSet) currentTransChildren

386 let searchChildren = S.difference (S.insert currentTrans' traverseSet) currentTransChildren

384− searchChild start = pathToTransaction origGraph start goalTrans (S.insert currentTrans' traverseSet)

387+ searchChild start' = pathToTransaction origGraph start' goalTrans (S.insert currentTrans' traverseSet)

385 childSearches = map searchChild (S.toList searchChildren)

388 childSearches = map searchChild (S.toList searchChildren)

386 errors = lefts childSearches

389 errors = lefts childSearches

387 pathsFound = rights childSearches

390 pathsFound = rights childSearches

@@ -593,10 +596,9 @@ addMerkleHash graph trans = Transaction (transactionId trans) newInfo (schemas t

593

596

594-- the new hash includes the parents' ids, the current id, and the hash of the context, and the merkle hashes of the parent transactions

597-- the new hash includes the parents' ids, the current id, and the hash of the context, and the merkle hashes of the parent transactions

595calculateMerkleHash :: Transaction -> TransactionGraph -> MerkleHash

598calculateMerkleHash :: Transaction -> TransactionGraph -> MerkleHash

596−calculateMerkleHash trans graph = MerkleHash $ hashlazy (mconcat [transIds,

599+calculateMerkleHash trans graph = MerkleHash $ hashlazy (BL.fromChunks [transIds,

597− dbcBytes,

600+ schemasBytes

598− schemasBytes,

599− parentMerkleHashes])

601+ ] <> dbcBytes <> parentMerkleHashes)

600 where

602 where

601 parentMerkleHashes = BL.fromChunks $ map (_unMerkleHash . getMerkleHash) parentTranses

603 parentMerkleHashes = BL.fromChunks $ map (_unMerkleHash . getMerkleHash) parentTranses

602 parentTranses =

604 parentTranses =

@@ -605,9 +607,9 @@ calculateMerkleHash trans graph = MerkleHash $ hashlazy (mconcat [transIds,

605 Left e -> error ("failed to find transaction in Merkle hash construction: " ++ show e)

607 Left e -> error ("failed to find transaction in Merkle hash construction: " ++ show e)

606 Right t -> S.toList t

608 Right t -> S.toList t

607 getMerkleHash t = merkleHash (transactionInfo t)

609 getMerkleHash t = merkleHash (transactionInfo t)

608− transIds = B.encode (transactionId trans : S.toList (parentIds trans))

610+ transIds = serialise (transactionId trans : S.toList (parentIds trans))

609 dbcBytes = DBC.hashBytes (concreteDatabaseContext trans)

611 dbcBytes = DBC.hashBytes (concreteDatabaseContext trans)

610− schemasBytes = B.encode (subschemas trans)

612+ schemasBytes = serialise (subschemas trans)

611

613

612validateMerkleHash :: Transaction -> TransactionGraph -> Either MerkleValidationError ()

614validateMerkleHash :: Transaction -> TransactionGraph -> Either MerkleValidationError ()

613validateMerkleHash trans graph =

615validateMerkleHash trans graph =

src/lib/ProjectM36/Tuple.hs+47−33

@@ -1,7 +1,7 @@

1module ProjectM36.Tuple where

2import ProjectM36.Base

3import ProjectM36.Error

4−import ProjectM36.Attribute

4+import ProjectM36.Attribute as A

5import ProjectM36.Atom

6import ProjectM36.AtomType

7import ProjectM36.DataTypes.Primitive

@@ -15,19 +15,19 @@ import Control.Arrow

15import Data.Maybe

17emptyTuple :: RelationTuple

18−emptyTuple = RelationTuple V.empty V.empty

18+emptyTuple = RelationTuple mempty mempty

20tupleSize :: RelationTuple -> Int

21−tupleSize (RelationTuple tupAttrs _) = V.length tupAttrs

21+tupleSize (RelationTuple tupAttrs _) = arity tupAttrs

23tupleAttributeNameSet :: RelationTuple -> S.Set AttributeName

24−tupleAttributeNameSet (RelationTuple tupAttrs _) = S.fromList $ V.toList $ V.map attributeName tupAttrs

24+tupleAttributeNameSet (RelationTuple tupAttrs _) = attributeNameSet tupAttrs

26tupleAttributes :: RelationTuple -> Attributes

27tupleAttributes (RelationTuple tupAttrs _) = tupAttrs

29tupleAssocs :: RelationTuple -> [(AttributeName, Atom)]

30−tupleAssocs (RelationTuple attrVec tupVec) = V.toList $ V.map (first attributeName) (V.zip attrVec tupVec)

30+tupleAssocs (RelationTuple attrs tupVec) = V.toList $ V.map (first attributeName) (V.zip (attributesVec attrs) tupVec)

32orderedTupleAssocs :: RelationTuple -> [(AttributeName, Atom)]

33orderedTupleAssocs tup@(RelationTuple attrVec _) = map (\attr -> (attributeName attr, atomForAttr (attributeName attr))) oAttrs

@@ -42,7 +42,7 @@ tupleAtoms :: RelationTuple -> V.Vector Atom

42tupleAtoms (RelationTuple _ tupVec) = tupVec

44atomForAttributeName :: AttributeName -> RelationTuple -> Either RelationalError Atom

45−atomForAttributeName attrName (RelationTuple tupAttrs tupVec) = case V.findIndex (\attr -> attributeName attr == attrName) tupAttrs of

45+atomForAttributeName attrName (RelationTuple tupAttrs tupVec) = case V.findIndex (\attr -> attributeName attr == attrName) (attributesVec tupAttrs) of

46 Nothing -> Left (NoSuchAttributeNamesError (S.singleton attrName))

47 Just index -> case tupVec V.!? index of

48 Nothing -> Left (NoSuchAttributeNamesError (S.singleton attrName))

@@ -59,7 +59,7 @@ vectorIndicesForAttributeNames attrNameVec attrs = if not $ V.null unknownAttrNa

59 Right $ V.map mapper attrNameVec

60 where

61 unknownAttrNames = V.filter (`V.notElem` attributeNames attrs) attrNameVec

62− mapper attrName = fromMaybe (error "logic failure in vectorIndicesForAttributeNames") (V.elemIndex attrName (V.map attributeName attrs))

62+ mapper attrName = fromMaybe (error "logic failure in vectorIndicesForAttributeNames") (V.elemIndex attrName (attributeNames attrs))

65relationForAttributeName :: AttributeName -> RelationTuple -> Either RelationalError Relation

@@ -86,10 +86,10 @@ mkRelationTuples attrs = map mapper

86 mapper = mkRelationTuple attrs

88mkRelationTupleFromMap :: M.Map AttributeName Atom -> RelationTuple

89−mkRelationTupleFromMap attrMap = RelationTuple attrs (V.map (attrMap M.!) attrNames)

89+mkRelationTupleFromMap attrMap = RelationTuple (attributesFromList attrs) (V.map (attrMap M.!) (V.fromList attrNames))

90 where

91− attrNames = V.fromList (M.keys attrMap)

91+ attrNames = M.keys attrMap

92− attrs = V.map (\attrName -> Attribute attrName (atomTypeForAtom (attrMap M.! attrName))) attrNames

92+ attrs = map (\attrName -> Attribute attrName (atomTypeForAtom (attrMap M.! attrName))) attrNames

94--return error if attribute names match but their types do not

95singleTupleSetJoin :: Attributes -> RelationTuple -> RelationTupleSet -> Either RelationalError [RelationTuple]

@@ -120,8 +120,8 @@ singleTupleJoin joinedAttrs tup1@(RelationTuple tupAttrs1 _) tup2@(RelationTuple

120 return $ Just $ RelationTuple joinedAttrs newVec

121 where

122 keysIntersection = V.map attributeName attrsIntersection

123− attrsIntersection = V.filter (`V.elem` tupAttrs1) tupAttrs2

123+ attrsIntersection = V.filter (`V.elem` attributesVec tupAttrs1) (attributesVec tupAttrs2)

124− newVec = V.map (findAtomForAttributeName . attributeName) joinedAttrs

124+ newVec = V.map (findAtomForAttributeName . attributeName) (attributesVec joinedAttrs)

125 --search both tuples for the attribute

126 findAtomForAttributeName attrName = head $ rights $ fmap (atomForAttributeName attrName) [tup1, tup2]

127

@@ -138,23 +138,31 @@ vectorUnion v1 v2 = V.foldr folder v1 v2

138tupleExtend :: RelationTuple -> RelationTuple -> RelationTuple

139tupleExtend (RelationTuple tupAttrs1 tupVec1) (RelationTuple tupAttrs2 tupVec2) = RelationTuple newAttrs newVec

140 where

141− newAttrs = tupAttrs1 V.++ tupAttrs2

141+ newAttrs = tupAttrs1 <> tupAttrs2

142− newVec = tupVec1 V.++ tupVec2

142+ newVec = tupVec1 <> tupVec2

143

144tupleAtomExtend :: AttributeName -> Atom -> RelationTuple -> RelationTuple

145tupleAtomExtend newAttrName atom tupIn = tupleExtend tupIn newTup

146 where

147− newTup = RelationTuple (V.singleton $ Attribute newAttrName (atomTypeForAtom atom)) (V.singleton atom)

147+ newTup = RelationTuple (A.singleton $ Attribute newAttrName (atomTypeForAtom atom)) (V.singleton atom)

148

149−--this could be cheaper- it may not be wortwhile to update all the tuples for projection, but then the attribute management must be slightly different- perhaps the attributes should be a vector of association tuples [(name, index)]

150−tupleProject :: S.Set AttributeName -> RelationTuple -> RelationTuple

149+{-tupleProject :: S.Set AttributeName -> RelationTuple -> RelationTuple

151tupleProject projectAttrs (RelationTuple attrs tupVec) = RelationTuple newAttrs newTupVec

150tupleProject projectAttrs (RelationTuple attrs tupVec) = RelationTuple newAttrs newTupVec

152 where

151 where

153− deleteIndices = V.findIndices (\attr -> S.notMember (attributeName attr) projectAttrs) attrs

152+ deleteIndices = V.findIndices (\attr -> S.notMember (attributeName attr) projectAttrs) (attributesVec attrs)

154 indexDeleter = V.ifilter (\index _ -> V.notElem index deleteIndices)

153 indexDeleter = V.ifilter (\index _ -> V.notElem index deleteIndices)

155− newAttrs = indexDeleter attrs

154+ newAttrs = case A.projectionAttributesForNames projectAttrs attrs of

155+ Left err -> error (show (err, projectAttrs, attrs))

156+ Right attrs' -> attrs'

156 newTupVec = indexDeleter tupVec

157 newTupVec = indexDeleter tupVec

157−

158+-}

159+-- remember that the attributes order matters

160+tupleProject :: Attributes -> RelationTuple -> Either RelationalError RelationTuple

161+tupleProject projectAttrs tup = do

162+ newTupVec <- foldM (\acc attr ->

163+ V.snoc acc <$> atomForAttributeName (attributeName attr) tup

164+ ) V.empty (attributesVec projectAttrs)

165+ pure $ reorderTuple projectAttrs (RelationTuple projectAttrs newTupVec)

158--return the attributes and atoms which are equal in both vectors

166--return the attributes and atoms which are equal in both vectors

159--semi-join

167--semi-join

160tupleIntersection :: RelationTuple -> RelationTuple -> RelationTuple

168tupleIntersection :: RelationTuple -> RelationTuple -> RelationTuple

@@ -162,12 +170,14 @@ tupleIntersection tuple1 tuple2 = RelationTuple newAttrs newTupVec

162 where

170 where

163 attrs1 = tupleAttributes tuple1

171 attrs1 = tupleAttributes tuple1

164 attrs2 = tupleAttributes tuple2

172 attrs2 = tupleAttributes tuple2

173+ intersectAttrs = A.intersection attrs1 attrs2

165− matchingIndices = V.findIndices (\attr -> V.elem attr attrs2 &&

174+ matchingIndices = V.findIndices (\attr -> A.member attr intersectAttrs &&

166− atomForAttributeName (attributeName attr) tuple1 ==

175+ atomForAttributeName (attributeName attr) tuple1 ==

167− atomForAttributeName (attributeName attr) tuple2

176+ atomForAttributeName (attributeName attr) tuple2) (attributesVec attrs1)

168− ) attrs1

169 indexFilter = V.ifilter (\index _ -> V.elem index matchingIndices)

177 indexFilter = V.ifilter (\index _ -> V.elem index matchingIndices)

170− newAttrs = indexFilter attrs1

178+ newAttrs = case A.projectionAttributesForNames (A.attributeNameSet intersectAttrs) attrs1 of

179+ Left _ -> mempty

180+ Right attrs' -> attrs'

171 newTupVec = indexFilter (tupleAtoms tuple1)

181 newTupVec = indexFilter (tupleAtoms tuple1)

172

182

173-- | An optimized form of tuple update which updates vectors efficiently.

183-- | An optimized form of tuple update which updates vectors efficiently.

@@ -175,19 +185,20 @@ updateTupleWithAtoms :: M.Map AttributeName Atom -> RelationTuple -> RelationTup

175updateTupleWithAtoms updateMap (RelationTuple attrs tupVec) = RelationTuple attrs newVec

185updateTupleWithAtoms updateMap (RelationTuple attrs tupVec) = RelationTuple attrs newVec

176 where

186 where

177 updateKeysSet = M.keysSet updateMap

187 updateKeysSet = M.keysSet updateMap

178− updateKeysIVec = V.filter (\(_,attr) -> S.member (attributeName attr) updateKeysSet) (V.indexed attrs)

188+ updateKeysIVec = V.filter (\(_,attr) -> S.member (attributeName attr) updateKeysSet) (V.indexed (attributesVec attrs))

179 newVec = V.update tupVec updateVec

189 newVec = V.update tupVec updateVec

180 updateVec = V.map (\(index, attr) -> (index, updateMap M.! attributeName attr)) updateKeysIVec

190 updateVec = V.map (\(index, attr) -> (index, updateMap M.! attributeName attr)) updateKeysIVec

181

191

182tupleToMap :: RelationTuple -> M.Map AttributeName Atom

192tupleToMap :: RelationTuple -> M.Map AttributeName Atom

183tupleToMap (RelationTuple attrs tupVec) = M.fromList assocList

193tupleToMap (RelationTuple attrs tupVec) = M.fromList assocList

184 where

194 where

185− assocList = V.toList $ V.map (\(index, attr) -> (attributeName attr, tupVec V.! index)) (V.indexed attrs)

195+ assocList = V.toList $ V.map (\(index, attr) -> (attributeName attr, tupVec V.! index)) (V.indexed (attributesVec attrs))

186

196

197+-- | Validate that the tuple has the correct attributes in the correct order

187verifyTuple :: Attributes -> RelationTuple -> Either RelationalError RelationTuple

198verifyTuple :: Attributes -> RelationTuple -> Either RelationalError RelationTuple

188−verifyTuple attrs tuple = let attrsTypes = V.map atomType attrs

199+verifyTuple attrs tuple = let attrsTypes = A.atomTypes attrs

189 tupleTypes = V.map atomTypeForAtom (tupleAtoms tuple) in

200 tupleTypes = V.map atomTypeForAtom (tupleAtoms tuple) in

190− if V.length attrs /= V.length tupleTypes then

201+ if A.arity attrs /= V.length tupleTypes then

191 Left $ TupleAttributeCountMismatchError 0

202 Left $ TupleAttributeCountMismatchError 0

192 else do

203 else do

193 mapM_ (uncurry atomTypeVerify) (V.zip attrsTypes tupleTypes)

204 mapM_ (uncurry atomTypeVerify) (V.zip attrsTypes tupleTypes)

@@ -196,15 +207,18 @@ verifyTuple attrs tuple = let attrsTypes = V.map atomType attrs

196--two tuples can be equal but the vectors of attributes could be out-of-order

207--two tuples can be equal but the vectors of attributes could be out-of-order

197--reorder if necessary- this is useful during relMogrify so that all the relation's tuples have identical atom/attribute ordering

208--reorder if necessary- this is useful during relMogrify so that all the relation's tuples have identical atom/attribute ordering

198reorderTuple :: Attributes -> RelationTuple -> RelationTuple

209reorderTuple :: Attributes -> RelationTuple -> RelationTuple

199−reorderTuple attrs tupIn = if tupleAttributes tupIn == attrs then

210+reorderTuple attrs tupIn = if attributesAndOrderEqual (tupleAttributes tupIn) attrs then

200 tupIn

211 tupIn

201 else

212 else

202− RelationTuple attrs (V.map mapper attrs)

213+ RelationTuple attrs (V.map mapper (attributesVec attrs))

203 where

214 where

204 mapper attr = case atomForAttributeName (attributeName attr) tupIn of

215 mapper attr = case atomForAttributeName (attributeName attr) tupIn of

205− Left err -> error ("logic bug in reorderTuple: " ++ show err)

216+ Left err -> error ("logic bug in reorderTuple: " ++ show err <> show tupIn)

206 Right atom -> atom

217 Right atom -> atom

207

218

208--used in Generics derivation for ADTs without named attributes

219--used in Generics derivation for ADTs without named attributes

209trimTuple :: Int -> RelationTuple -> RelationTuple

220trimTuple :: Int -> RelationTuple -> RelationTuple

210−trimTuple index (RelationTuple attrs vals) = RelationTuple (V.drop index attrs) (V.drop index vals)

221+trimTuple index (RelationTuple attrs vals) =

222+ RelationTuple newAttrs (V.drop index vals)

223+ where

224+ newAttrs = A.drop index attrs

src/lib/ProjectM36/TupleSet.hs+7

@@ -31,3 +31,10 @@ mkTupleSet attrs tuples = verifyTupleSet attrs (RelationTupleSet tuples)

32mkTupleSetFromList :: Attributes -> [[Atom]] -> Either RelationalError RelationTupleSet

33mkTupleSetFromList attrs atomMatrix = mkTupleSet attrs $ map (mkRelationTuple attrs . V.fromList) atomMatrix

34+

35+

36+-- | Union two tuplesets while reordering their attribute/atom mapping properly.

37+tupleSetUnion :: Attributes -> RelationTupleSet -> RelationTupleSet -> RelationTupleSet

38+tupleSetUnion targetAttrs tupSet1 tupSet2 = RelationTupleSet $ HS.toList . HS.fromList $ reorder (asList tupSet1) ++ reorder (asList tupSet2)

39+ where

40+ reorder = map (reorderTuple targetAttrs)

src/lib/ProjectM36/Tupleable.hs+9−8

@@ -38,7 +38,7 @@ import qualified Data.Text as T

38import qualified Data.Vector as V

39import GHC.Generics

40import ProjectM36.Atomable

41−import ProjectM36.Attribute hiding (null)

41+import ProjectM36.Attribute as A hiding (null, toList)

42import ProjectM36.Base

43import ProjectM36.DataTypes.Primitive

44import ProjectM36.Error

@@ -89,7 +89,7 @@ toInsertExpr vals rvName = do

90-- | Convert a 'Tupleable' to a create a 'Define' expression which can be used to create an empty relation variable. Use 'toInsertExpr' to insert the actual tuple data. This function is typically used with 'Data.Proxy'.

91toDefineExpr :: forall a proxy. Tupleable a => proxy a -> RelVarName -> DatabaseContextExpr

92−toDefineExpr _ rvName = Define rvName (map NakedAttributeExpr (V.toList attrs))

92+toDefineExpr _ rvName = Define rvName (map NakedAttributeExpr (V.toList (attributesVec attrs)))

93 where

94 attrs = toAttributes (Proxy :: Proxy a)

@@ -228,11 +228,12 @@ instance (Constructor c, TupleableG a, AtomableG a) => TupleableG (M1 C c a) whe

228 toTupleG opts (M1 v) = RelationTuple attrs atoms

229 where

230 attrsToCheck = toAttributesG opts v

231− counter = V.generate (V.length attrsToCheck) id

231+ counter = V.generate (arity attrsToCheck) id

232+ attrs = attributesFromList (V.toList attrsV)

232− attrs = V.zipWith (\num attr@(Attribute name typ) -> if T.null name then

233+ attrsV = V.zipWith (\num attr@(Attribute name typ) -> if T.null name then

233 Attribute ("attr" <> T.pack (show (num + 1))) typ

234 Attribute ("attr" <> T.pack (show (num + 1))) typ

234 else

235 else

235− attr) counter attrsToCheck

236+ attr) counter (attributesVec attrsToCheck)

236 atoms = V.fromList (toAtomsG v)

237 atoms = V.fromList (toAtomsG v)

237 toAttributesG opts (M1 v) = toAttributesG opts v

238 toAttributesG opts (M1 v) = toAttributesG opts v

238 fromTupleG opts tup = M1 <$> fromTupleG opts tup

239 fromTupleG opts tup = M1 <$> fromTupleG opts tup

@@ -241,7 +242,7 @@ instance (Constructor c, TupleableG a, AtomableG a) => TupleableG (M1 C c a) whe

241-- product types

242-- product types

242instance (TupleableG a, TupleableG b) => TupleableG (a :*: b) where

243instance (TupleableG a, TupleableG b) => TupleableG (a :*: b) where

243 toTupleG = error "toTupleG"

244 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

245 fromTupleG opts tup = (:*:) <$> fromTupleG opts tup <*> fromTupleG opts processedTuple

246 fromTupleG opts tup = (:*:) <$> fromTupleG opts tup <*> fromTupleG opts processedTuple

246 where

247 where

247 processedTuple = if isRecordTypeG (undefined :: a x) then

248 processedTuple = if isRecordTypeG (undefined :: a x) then

@@ -253,7 +254,7 @@ instance (TupleableG a, TupleableG b) => TupleableG (a :*: b) where

253--selector/record

254--selector/record

254instance (Selector c, AtomableG a) => TupleableG (M1 S c a) where

255instance (Selector c, AtomableG a) => TupleableG (M1 S c a) where

255 toTupleG = error "toTupleG"

256 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)

257 where

258 where

258 name = T.pack (selName m)

259 name = T.pack (selName m)

259 modifiedName = if T.null name then

260 modifiedName = if T.null name then

@@ -268,7 +269,7 @@ instance (Selector c, AtomableG a) => TupleableG (M1 S c a) where

268 val <- atomv atom

269 val <- atomv atom

269 pure (M1 val)

270 pure (M1 val)

270 where

271 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))))

272 atomv atom = maybe (Left (AtomTypeMismatchError

273 atomv atom = maybe (Left (AtomTypeMismatchError

273 expectedAtomType

274 expectedAtomType

274 (atomTypeForAtom atom)

275 (atomTypeForAtom atom)

src/lib/ProjectM36/WithNameExpr.hs+4−2

@@ -42,9 +42,11 @@ substituteWithNameMacros macros (NotEquals exprA exprB) =

42substituteWithNameMacros macros (Extend extendTup expr) =

43 Extend (substituteWitNameMacrosExtendTupleExpr macros extendTup) (substituteWithNameMacros macros expr)

44substituteWithNameMacros macros (With moreMacros expr) =

45− --collect and override existing macros and recurse

45+ --collect and update nested with exprs

46 let newMacros = foldr macroFolder macros moreMacros

47− macroFolder (wnexpr, mexpr) acc = filter (\(w,_) -> w /= wnexpr) acc ++ [(wnexpr, mexpr)] in

47+ macroFolder (wnexpr, mexpr) acc =

48+ let subExpr = substituteWithNameMacros macros mexpr in

49+ filter (\(w,_) -> w /= wnexpr) acc ++ [(wnexpr, subExpr)] in

48 --scan for a match- if it exists, replace it (representing a with clause at a lower level

50 --scan for a match- if it exists, replace it (representing a with clause at a lower level

49 substituteWithNameMacros newMacros expr

51 substituteWithNameMacros newMacros expr

stack.ghc8.0.yamldeleted−50

@@ -1,50 +0,0 @@

1−# This file was automatically generated by stack init

2−# For more information, see: http://docs.haskellstack.org/en/stable/yaml_configuration/

3−

4−# Specifies the GHC version and set of packages available (e.g., lts-3.5, nightly-2015-09-21, ghc-7.10.2)

5−resolver: lts-8.5

6−

7−# Local packages, usually specified by relative directory name

8−packages:

9−- '.'

10−# Packages to be pulled from upstream that are not in the resolver (e.g., acme-missiles-0.3)

11−extra-deps:

12−- data-accessor-transformers-0.2.1.7

13−- data-interval-1.2.0

14−- extended-reals-0.2.1.0

15−- gnuplot-0.5.4.1

16−- text-1.2.2.1

17−- aeson-1.2.1.00

18−- distributed-process-0.6.6

19−- distributed-process-async-0.2.4

20−- distributed-process-client-server-0.2.3

21−- distributed-process-extras-0.3.2

22−- deferred-folds-0.6.12

23−- rset-1.0.0

24−

25−# Override default flag values for local packages and extra-deps

26−flags: {}

27−

28−# Extra package databases containing global packages

29−extra-package-dbs: []

30−

31−# Control whether we use the GHC we find on the path

32−# system-ghc: true

33−

34−# Require a specific version of stack, using version ranges

35−# require-stack-version: -any # Default

36−# require-stack-version: >= 1.0.0

37−

38−# Override the architecture used by stack, especially useful on Windows

39−# arch: i386

40−# arch: x86_64

41−

42−# Extra directories used by stack for building

43−# extra-include-dirs: [/path/to/dir]

44−# extra-lib-dirs: [/path/to/dir]

45−

46−# Allow a newer minor version of GHC than the snapshot specifies

47−# compiler-check: newer-minor

48−

49−allow-newer: true

50−

stack.ghc8.10.yamlnew file+19

@@ -0,0 +1,19 @@

1+resolver: lts-17.13

2+packages:

3+ - "."

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−51

@@ -1,51 +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−# Packages to be pulled from upstream that are not in the resolver (e.g., acme-missiles-0.3)

11−extra-deps:

12−- data-accessor-transformers-0.2.1.7

13−- data-interval-1.2.0

14−- extended-reals-0.2.1.0

15−- gnuplot-0.5.4.1

16−- text-1.2.2.1

17−- aeson-1.2.1.00

18−- distributed-process-0.7.3

19−- distributed-process-async-0.2.4.1

20−- distributed-process-client-server-0.2.3

21−- distributed-process-extras-0.3.2

22−- rset-1.0.0

23−

24−# Override default flag values for local packages and extra-deps

25−flags:

26− project-m36:

27− stack: true

28−

29−# Extra package databases containing global packages

30−extra-package-dbs: []

31−

32−# Control whether we use the GHC we find on the path

33−# system-ghc: true

34−

35−# Require a specific version of stack, using version ranges

36−# require-stack-version: -any # Default

37−# require-stack-version: >= 1.0.0

38−

39−# Override the architecture used by stack, especially useful on Windows

40−# arch: i386

41−# arch: x86_64

42−

43−# Extra directories used by stack for building

44−# extra-include-dirs: [/path/to/dir]

45−# extra-lib-dirs: [/path/to/dir]

46−

47−# Allow a newer minor version of GHC than the snapshot specifies

48−# compiler-check: newer-minor

49−

50−allow-newer: true

51−

stack.ghc8.4.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-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−- data-interval-1.3.0

13−- extended-reals-0.2.3.0

14−- distributed-process-0.7.4

15−- distributed-process-async-0.2.6

16−- distributed-process-client-server-0.2.5.1

17−- distributed-process-extras-0.3.5

18−- rset-1.0.0

19−- hashable-time-0.2.0.2

20−- network-transport-tcp-0.6.0

21−

22−# Override default flag values for local packages and extra-deps

23−flags:

24− project-m36:

25− stack: true

26−

27−# Extra package databases containing global packages

28−extra-package-dbs: []

29−

30−# Control whether we use the GHC we find on the path

31−# system-ghc: true

32−

33−# Require a specific version of stack, using version ranges

34−# require-stack-version: -any # Default

35−# require-stack-version: >= 1.0.0

36−

37−# Override the architecture used by stack, especially useful on Windows

38−# arch: i386

39−# arch: x86_64

40−

41−# Extra directories used by stack for building

42−# extra-include-dirs: [/path/to/dir]

43−# extra-lib-dirs: [/path/to/dir]

44−

45−# Allow a newer minor version of GHC than the snapshot specifies

46−# compiler-check: newer-minor

47−

48−allow-newer: true

stack.ghc8.6.yaml+25−16

@@ -2,27 +2,36 @@

2# For more information, see: http://docs.haskellstack.org/en/stable/yaml_configuration/

4# Specifies the GHC version and set of packages available (e.g., lts-3.5, nightly-2015-09-21, ghc-7.10.2)

5−resolver: lts-14.3

5+resolver: lts-14.27

7# Local packages, usually specified by relative directory name

8packages:

9−- '.'

9+ - "."

10# Packages to be pulled from upstream that are not in the resolver (e.g., acme-missiles-0.3)

11extra-deps:

12−- git: https://github.com/haskell-distributed/distributed-process.git

12+ - git: https://github.com/agentm/curryer.git

13− commit: 660d554f6acd2dba8b605c84e8fa69e45708bc14

13+ commit: 74ecaac619ad1165a4517d5c0f4e530493bda130

14+ - git: https://github.com/composewell/streamly.git

15+ commit: ac3af8749194f1788704dda8667d0b3807075cc2

16+ - fast-builder-0.1.2.1

17+ - winery-1.3.2

18+ - barbies-2.0.2.0

19+ - barbies-th-0.1.7

14−- extended-reals-0.2.3.0

20+ - extended-reals-0.2.3.0

15−- data-interval-2.0.1

21+ - data-interval-2.0.1

16−- stm-containers-1.1.0.4

22+ - stm-containers-1.1.0.4

17−- distributed-static-0.3.9

18−- stm-hamt-1.2.0.4

23+ - stm-hamt-1.2.0.4

19−- distributed-process-async-0.2.6

20−- distributed-process-client-server-0.2.5.1

21−- distributed-process-extras-0.3.5

22−- rset-1.0.0

24+ - rset-1.0.0

23−- hashable-time-0.2.0.2

25+ - hashable-time-0.2.0.2

24−- network-transport-tcp-0.6.0

26+ - network-transport-tcp-0.6.0

25−- megaparsec-7.0.5

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

27# Override default flag values for local packages and extra-deps

36# Override default flag values for local packages and extra-deps

28flags:

37flags:

stack.ghc8.8.yaml+24−18

@@ -6,26 +6,32 @@ resolver: lts-16.4

7# Local packages, usually specified by relative directory name

8packages:

9−- '.'

9+ - "."

10# Packages to be pulled from upstream that are not in the resolver (e.g., acme-missiles-0.3)

11extra-deps:

12−- git: https://github.com/agentm/distributed-process.git

12+ - git: https://github.com/agentm/curryer.git

13− commit: 688a5b96d4b7b36d90c3db676230b2c943604288

13+ commit: 74ecaac619ad1165a4517d5c0f4e530493bda130

14+ - git: https://github.com/composewell/streamly.git

15+ commit: ac3af8749194f1788704dda8667d0b3807075cc2

16+ - fast-builder-0.1.2.1

17+ - winery-1.3.2

18+ - barbies-2.0.2.0

19+ - barbies-th-0.1.7

14−- extended-reals-0.2.3.0

20+ - extended-reals-0.2.3.0

15−- data-interval-2.0.1

21+ - data-interval-2.0.1

16−- stm-containers-1.1.0.4

22+ - stm-containers-1.1.0.4

17−- distributed-static-0.3.9

18−- stm-hamt-1.2.0.4

23+ - stm-hamt-1.2.0.4

19−- distributed-process-async-0.2.6

20−- distributed-process-client-server-0.2.5.1

21−- distributed-process-extras-0.3.5

22−- rset-1.0.0

24+ - rset-1.0.0

23−- hashable-time-0.2.0.2

25+ - hashable-time-0.2.0.2

24−- network-transport-tcp-0.7.0

26+ - network-transport-tcp-0.7.0

25−- megaparsec-7.0.5

27+ - megaparsec-7.0.5

26−- network-2.8.0.1

28+ - network-2.8.0.1

27−- primitive-extras-0.8

29+ - primitive-extras-0.8

28−- primitive-unlifted-0.1.3.0

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

30# Override default flag values for local packages and extra-deps

36# Override default flag values for local packages and extra-deps

31flags:

37flags:

test/Client/Simple.hs+1−2

@@ -9,7 +9,6 @@ import System.IO.Temp

9import System.FilePath

10import ProjectM36.TupleSet

11import ProjectM36.Attribute

12−import qualified Data.Vector as V

13import qualified Data.Map as M

12import qualified Data.Map as M

15main :: IO ()

14main :: IO ()

@@ -59,7 +58,7 @@ testSimpleCommitFailure = TestCase $ do

59 execute $ Assign "x" (ExistingRelation relationTrue)

58 execute $ Assign "x" (ExistingRelation relationTrue)

60 --cause error

59 --cause error

61 execute $ Assign "x" (MakeStaticRelation failAttrs emptyTupleSet)

60 execute $ Assign "x" (MakeStaticRelation failAttrs emptyTupleSet)

62− let expectedErr = Left (RelError (RelationTypeMismatchError V.empty failAttrs))

61+ let expectedErr = Left (RelError (RelationTypeMismatchError mempty failAttrs))

63 assertEqual "dbc error" expectedErr err

62 assertEqual "dbc error" expectedErr err

65-- #176 default merge couldn't handle Update

64-- #176 default merge couldn't handle Update

test/Relation/Atomable.hs+28−15

@@ -1,8 +1,7 @@

1--Test Atomable typeclass which allows users to use existing Haskell datatypes to marshal them to and from the database as ConstructedAtoms.

2−{-# LANGUAGE DeriveGeneric, DeriveAnyClass, OverloadedStrings, TypeApplications #-}

2+{-# LANGUAGE DeriveGeneric, DeriveAnyClass, OverloadedStrings, TypeApplications, DerivingVia #-}

3import Test.HUnit

4import ProjectM36.Client

5−import Data.Binary

6import Control.DeepSeq

5import Control.DeepSeq

7import System.Exit

6import System.Exit

8import TutorialD.Interpreter.TestBase

7import TutorialD.Interpreter.TestBase

@@ -13,52 +12,65 @@ import Data.Time.Calendar (fromGregorian)

13import Data.Text

12import Data.Text

14import qualified Data.Map as M

13import qualified Data.Map as M

15import Data.Proxy

14import Data.Proxy

15+import Codec.Winery

17{-# ANN module ("Hlint: ignore Use newtype instead of data" :: String) #-}

18data Test1T = Test1C Integer

19− deriving (Generic, Show, Eq, Binary, NFData, Atomable)

19+ deriving (Generic, Show, Eq, NFData, Atomable)

20+ deriving Serialise via WineryVariant Test1T

21data Test2T x = Test2C x

22data Test2T x = Test2C x

22− deriving (Show, Generic, Eq, Binary, NFData, Atomable)

23+ deriving (Show, Generic, Eq, NFData, Atomable)

24+ deriving Serialise via WineryVariant (Test2T x)

24data Test3T = Test3C Integer Integer

26data Test3T = Test3C Integer Integer

25− deriving (Show, Generic, Eq, Binary, NFData, Atomable)

27+ deriving (Show, Generic, Eq, NFData, Atomable)

28+ deriving Serialise via WineryVariant Test3T

27data Test4T = Test4Ca Integer |

30data Test4T = Test4Ca Integer |

28 Test4Cb Integer

31 Test4Cb Integer

29− deriving (Show, Generic, Eq, Binary, NFData, Atomable)

32+ deriving (Show, Generic, Eq, NFData, Atomable)

33+ deriving Serialise via WineryVariant Test4T

31data TestListT = TestListC [Integer]

35data TestListT = TestListC [Integer]

32− deriving (Show, Generic, Eq, Binary, NFData, Atomable)

36+ deriving (Show, Generic, Eq, NFData, Atomable)

37+ deriving Serialise via WineryVariant TestListT

34data TestNonEmptyT = TestNonEmptyC [Integer]

39data TestNonEmptyT = TestNonEmptyC [Integer]

35− deriving (Show, Generic, Eq, Binary, NFData, Atomable)

40+ deriving (Show, Generic, Eq, NFData, Atomable)

41+ deriving Serialise via WineryVariant TestNonEmptyT

37data Test5T = Test5C {

43data Test5T = Test5C {

38 con1 :: Integer,

44 con1 :: Integer,

39 con2 :: Integer

45 con2 :: Integer

40− } deriving (Show, Generic, Eq, Binary, NFData, Atomable)

46+ } deriving (Show, Generic, Eq, NFData, Atomable)

47+ deriving Serialise via WineryRecord Test5T

42data Test6T = Test6C (Maybe Integer)

49data Test6T = Test6C (Maybe Integer)

43− deriving (Show, Generic, Eq, Binary, NFData, Atomable)

50+ deriving (Show, Generic, Eq, NFData, Atomable)

51+ deriving Serialise via WineryVariant Test6T

45data Test7T = Test7C (Either Integer Integer)

53data Test7T = Test7C (Either Integer Integer)

46− deriving (Show, Generic, Eq, Binary, NFData, Atomable)

54+ deriving (Show, Generic, Eq, NFData, Atomable)

55+ deriving Serialise via WineryVariant Test7T

48data Test8T = Test8C Test1T

57data Test8T = Test8C Test1T

49− deriving (Show, Generic, Eq, Binary, NFData, Atomable)

58+ deriving (Show, Generic, Eq, NFData, Atomable)

59+ deriving Serialise via WineryVariant Test8T

51data User = User

61data User = User

52 { userFirstName :: Text

62 { userFirstName :: Text

53 , userLastName :: Text

63 , userLastName :: Text

54− } deriving (Eq, Ord, Show, Generic, NFData, Binary, Atomable)

64+ } deriving (Eq, Ord, Show, Generic, NFData, Atomable)

65+ deriving Serialise via WineryRecord User

56data Test9_4T = Test9_4C {

67data Test9_4T = Test9_4C {

57 f9_41 :: Int,

68 f9_41 :: Int,

58 f9_42 :: Int,

69 f9_42 :: Int,

59 f9_43 :: Int,

70 f9_43 :: Int,

60 f9_44 :: Int }

71 f9_44 :: Int }

61− deriving (Show, Generic, Eq, Binary, NFData, Atomable)

72+ deriving (Show, Generic, Eq, NFData, Atomable)

73+ deriving Serialise via WineryRecord Test9_4T

63data Test9_5T = Test9_5C {

75data Test9_5T = Test9_5C {

64 f9_51 :: Int,

76 f9_51 :: Int,

@@ -67,7 +79,8 @@ data Test9_5T = Test9_5C {

67 f9_54 :: Int,

79 f9_54 :: Int,

68 f9_55 :: Int

80 f9_55 :: Int

69 }

81 }

70− deriving (Show, Generic, Eq, Binary, NFData, Atomable)

82+ deriving (Show, Generic, Eq, NFData, Atomable)

83+ deriving Serialise via WineryRecord Test9_5T

72main :: IO ()

85main :: IO ()

73main = do

86main = do

test/Relation/Basic.hs+13−12

@@ -3,8 +3,6 @@ import ProjectM36.Base

3import ProjectM36.Relation

4import ProjectM36.Error

5import ProjectM36.DateExamples

6−import ProjectM36.TupleSet

7−import ProjectM36.Attribute hiding (null, attributeNames)

8import ProjectM36.DataTypes.Primitive

6import ProjectM36.DataTypes.Primitive

9import ProjectM36.RelationalExpression

7import ProjectM36.RelationalExpression

10import ProjectM36.TransactionGraph

8import ProjectM36.TransactionGraph

@@ -25,8 +23,8 @@ testList = TestList [testRelation "relationTrue" relationTrue, testRelation "rel

25 testRelation "products" productsRel,

23 testRelation "products" productsRel,

26 testRelation "supplierProducts" supplierProductsRel,

24 testRelation "supplierProducts" supplierProductsRel,

27 testMkRelationFromExprsBadAttrs,

25 testMkRelationFromExprsBadAttrs,

28− testDuplicateAttributes,

26+ testExistingRelationType,

29− testExistingRelationType

27+ testReorderTuple

30 ]

28 ]

32main :: IO ()

30main :: IO ()

@@ -65,7 +63,7 @@ validateAttrTypesMatchTupleAttrTypes rel@(Relation attrs tupSet) = foldr (\tuple

65 attrChecks tuple = V.map (\attr -> case atomForAttributeName (A.attributeName attr) tuple of

63 attrChecks tuple = V.map (\attr -> case atomForAttributeName (A.attributeName attr) tuple of

66 Left _ -> False

64 Left _ -> False

67 Right atom -> Right (atomTypeForAtom atom) ==

65 Right atom -> Right (atomTypeForAtom atom) ==

68− A.atomTypeForAttributeName (A.attributeName attr) attrs) (attributes rel)

66+ A.atomTypeForAttributeName (A.attributeName attr) attrs) (attributesVec (attributes rel))

70simpleRel :: Relation

68simpleRel :: Relation

71simpleRel = case mkRelation attrs tupleSet of

69simpleRel = case mkRelation attrs tupleSet of

@@ -103,16 +101,19 @@ testMkRelationFromExprsBadAttrs = TestCase $ do

103 Left err -> assertEqual "tuple type mismatch" (TupleAttributeTypeMismatchError (A.attributesFromList [Attribute "badAttr2" IntAtomType])) err

101 Left err -> assertEqual "tuple type mismatch" (TupleAttributeTypeMismatchError (A.attributesFromList [Attribute "badAttr2" IntAtomType])) err

104 Right _ -> assertFailure "expected tuple type mismatch"

102 Right _ -> assertFailure "expected tuple type mismatch"

105

103

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−

113testExistingRelationType :: Test

104testExistingRelationType :: Test

114testExistingRelationType = TestCase $ do

105testExistingRelationType = TestCase $ do

115 (graph, _) <- freshTransactionGraph dateExamples

106 (graph, _) <- freshTransactionGraph dateExamples

116 let typeResult = runRelationalExprM reenv (typeForRelationalExpr (ExistingRelation relationTrue))

107 let typeResult = runRelationalExprM reenv (typeForRelationalExpr (ExistingRelation relationTrue))

117 reenv = mkRelationalExprEnv dateExamples graph

108 reenv = mkRelationalExprEnv dateExamples graph

118 assertEqual "ExistingRelation with tuples type" (Right relationFalse) typeResult

109 assertEqual "ExistingRelation with tuples type" (Right relationFalse) typeResult

110+

111+-- | Ensure that tuple reordering honors the

112+testReorderTuple :: Test

113+testReorderTuple = TestCase $ do

114+ let tup1 = mkRelationTuple attrs1 (V.fromList [IntAtom 4, TextAtom "test"])

115+ attrs1 = A.attributesFromList [Attribute "a" IntAtomType, Attribute "b" TextAtomType]

116+ attrs2 = A.attributesFromList [Attribute "b" TextAtomType, Attribute "a" IntAtomType]

117+ actual = reorderTuple attrs2 tup1

118+ expected = mkRelationTuple attrs2 (V.fromList [TextAtom "test", IntAtom 4])

119+ assertEqual "reorderTuple" expected actual

test/Relation/Tupleable.hs+18−6

@@ -8,13 +8,13 @@

8 , DataKinds

9 , TypeOperators

10 , AllowAmbiguousTypes

11+ , DerivingVia

11 #-}

12 #-}

12import Test.HUnit

13import Test.HUnit

13import ProjectM36.Tupleable.Deriving

14import ProjectM36.Tupleable.Deriving

14import ProjectM36.Atomable

15import ProjectM36.Atomable

15−import ProjectM36.Attribute

16+import ProjectM36.Attribute as A

16import ProjectM36.Error

17import ProjectM36.Error

17−import Data.Binary

18import ProjectM36.Base

19import Control.DeepSeq (NFData)

20import qualified Data.Vector as V

@@ -23,6 +23,7 @@ import qualified Data.Text as T

23import qualified Data.Set as S

24import System.Exit

25import Data.Proxy

26+import Codec.Winery

27{-# ANN module ("Hlint: ignore Use newtype instead of data" :: String) #-}

28{-# ANN module ("Hlint: ignore Use newtype instead of data" :: String) #-}

@@ -30,35 +31,43 @@ data Test1T = Test1C {

30 attrA :: Integer

31 attrA :: Integer

31 }

32 }

32 deriving (Generic, Eq, Show)

33 deriving (Generic, Eq, Show)

34+ deriving Serialise via WineryRecord Test1T

34data Test2T = Test2C {

36data Test2T = Test2C {

35 attrB :: Integer,

37 attrB :: Integer,

36 attrC :: Integer

38 attrC :: Integer

37 }

39 }

38 deriving (Generic, Eq, Show)

40 deriving (Generic, Eq, Show)

41+ deriving Serialise via WineryRecord Test2T

40data Test3T = Test3C Integer

43data Test3T = Test3C Integer

41 deriving (Generic, Eq, Show)

44 deriving (Generic, Eq, Show)

45+ deriving Serialise via WineryVariant Test3T

43data Test4T = Test4C

47data Test4T = Test4C

44 deriving (Generic, Eq, Show)

48 deriving (Generic, Eq, Show)

49+ deriving Serialise via WineryVariant Test4T

46data Test5T = Test5C1 Integer |

51data Test5T = Test5C1 Integer |

47 Test5C2 Integer

52 Test5C2 Integer

48 deriving (Generic, Eq, Show)

53 deriving (Generic, Eq, Show)

54+ deriving Serialise via WineryVariant Test5T

50data Test6T = Test6C T.Text Integer Double

56data Test6T = Test6C T.Text Integer Double

51 deriving (Generic, Eq, Show)

57 deriving (Generic, Eq, Show)

53data Test7A = Test7AC Integer

59data Test7A = Test7AC Integer

54− deriving (Generic, Show, Eq, Binary, NFData, Atomable)

60+ deriving (Generic, Show, Eq, NFData, Atomable)

61+ deriving Serialise via WineryVariant Test7A

57data Test7T = Test7C Test7A

64data Test7T = Test7C Test7A

58 deriving (Generic, Show, Eq)

65 deriving (Generic, Show, Eq)

66+ deriving Serialise via WineryVariant Test7T

60data Test8T = Test8C

68data Test8T = Test8C

61 deriving (Generic, Show, Eq)

69 deriving (Generic, Show, Eq)

70+ deriving Serialise via WineryVariant Test8T

63data Test9T = Test9C

72data Test9T = Test9C

64 {

73 {

@@ -67,6 +76,7 @@ data Test9T = Test9C

67 attr9C :: Double

76 attr9C :: Double

68 }

77 }

69 deriving (Generic, Show, Eq)

78 deriving (Generic, Show, Eq)

79+ deriving Serialise via WineryRecord Test9T

71data Test10T = Test10C {

81data Test10T = Test10C {

72 longAttrNameA10 :: Integer,

82 longAttrNameA10 :: Integer,

@@ -74,6 +84,7 @@ data Test10T = Test10C {

74 longMixed_attr_NameC10 :: Integer

84 longMixed_attr_NameC10 :: Integer

75 }

85 }

76 deriving (Generic, Show, Eq)

86 deriving (Generic, Show, Eq)

87+ deriving Serialise via WineryRecord Test10T

78instance Tupleable Test1T

89instance Tupleable Test1T

@@ -99,7 +110,7 @@ main = do

99 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

110 if errors tcounts + failures tcounts > 0 then exitFailure else exitSuccess

100

111

101testList :: Test

112testList :: 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]

103

114

104testADT1 :: Test

115testADT1 :: Test

105testADT1 = TestCase $ assertEqual "one record constructor" (Right example) (fromTuple (toTuple example))

116testADT1 = TestCase $ assertEqual "one record constructor" (Right example) (fromTuple (toTuple example))

@@ -137,7 +148,7 @@ testADT7 :: Test

137testADT7 = TestCase $ do

148testADT7 = TestCase $ do

138 let example = Test7C (Test7AC 3)

149 let example = Test7C (Test7AC 3)

139 assertEqual "atom type" (Right example) (fromTuple (toTuple example))

150 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))

141 assertEqual "adt atomtype" expectedAttrs (toAttributes (Proxy :: Proxy Test7T))

152 assertEqual "adt atomtype" expectedAttrs (toAttributes (Proxy :: Proxy Test7T))

142

153

143testADT8 :: Test

154testADT8 :: Test

@@ -211,7 +222,8 @@ testDeleteExpr = TestCase $ do

211testReorderedTuple :: Test

222testReorderedTuple :: Test

212testReorderedTuple = TestCase $ do

223testReorderedTuple = TestCase $ do

213 let tupleRev :: RelationTuple -> RelationTuple

224 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))

215 expected = Test2C {attrB = 3,

227 expected = Test2C {attrB = 3,

216 attrC = 4}

228 attrC = 4}

217 actual = fromTuple . tupleRev . toTuple $ expected

229 actual = fromTuple . tupleRev . toTuple $ expected

test/Server/Main.hs+19−20

@@ -5,7 +5,6 @@ test client/server interaction

5import Test.HUnit

6import ProjectM36.Client

7import qualified ProjectM36.Client as C

8−import ProjectM36.Server.EntryPoints

9import ProjectM36.Server

8import ProjectM36.Server

10import ProjectM36.Server.Config

9import ProjectM36.Server.Config

11import ProjectM36.Relation

10import ProjectM36.Relation

@@ -14,16 +13,8 @@ import ProjectM36.IsomorphicSchema

14import ProjectM36.Base

13import ProjectM36.Base

16import System.Exit

15import System.Exit

17−

16+import Network.Socket (SockAddr(..))

18import Control.Concurrent

17import Control.Concurrent

19−import Network.Transport (EndPointAddress)

20−

21−#if MIN_VERSION_network_transport_tcp(0,6,0)

22−import Network.Transport.TCP.Internal (encodeEndPointAddress, decodeEndPointAddress)

23−#else

24−import Network.Transport.TCP (encodeEndPointAddress, decodeEndPointAddress)

25−#endif

26−

27import Data.Either (isRight)

18import Data.Either (isRight)

28import Control.Exception

19import Control.Exception

29import System.IO.Temp

20import System.IO.Temp

@@ -32,6 +23,8 @@ import System.FilePath

32import System.Directory

23import System.Directory

33#endif

24#endif

26+type Timeout = Int

27+

35testList :: SessionId -> Connection -> MVar () -> Test

28testList :: SessionId -> Connection -> MVar () -> Test

36testList sessionId conn notificationTestMVar = TestList $ serverTests ++ sessionTests

29testList sessionId conn notificationTestMVar = TestList $ serverTests ++ sessionTests

37 where

30 where

@@ -49,7 +42,7 @@ testList sessionId conn notificationTestMVar = TestList $ serverTests ++ session

49 testRelationVariableSummary,

42 testRelationVariableSummary,

50 testNotification notificationTestMVar

43 testNotification notificationTestMVar

51 ]

44 ]

52− serverTests = [testRequestTimeout, testFileDescriptorCount]

45+ serverTests = [testRequestTimeout, testFileDescriptorCount, testClientConnectFail]

54main :: IO ()

47main :: IO ()

55main = do

48main = do

@@ -69,11 +62,9 @@ main = do

69testDatabaseName :: DatabaseName

62testDatabaseName :: DatabaseName

70testDatabaseName = "test"

63testDatabaseName = "test"

72−testConnection :: EndPointAddress -> MVar () -> IO (Either ConnectionError (SessionId, Connection))

65+testConnection :: Port -> MVar () -> IO (Either ConnectionError (SessionId, Connection))

73−testConnection serverAddress mvar = do

66+testConnection serverPort mvar = do

74− let Just (host, service, _) = decodeEndPointAddress serverAddress

75− serverAddress' = encodeEndPointAddress host service 1

76− let connInfo = RemoteProcessConnectionInfo testDatabaseName (NodeId serverAddress') (testNotificationCallback mvar)

67+ let connInfo = RemoteConnectionInfo testDatabaseName "127.0.0.1" (show serverPort) (testNotificationCallback mvar)

77 --putStrLn ("testConnection: " ++ show serverAddress)

68 --putStrLn ("testConnection: " ++ show serverAddress)

78 eConn <- connectProjectM36 connInfo

69 eConn <- connectProjectM36 connInfo

79 case eConn of

70 case eConn of

@@ -85,7 +76,7 @@ testConnection serverAddress mvar = do

85 Right sessionId -> pure $ Right (sessionId, conn)

76 Right sessionId -> pure $ Right (sessionId, conn)

87-- | A version of 'launchServer' which returns the port on which the server is listening on a secondary thread

78-- | A version of 'launchServer' which returns the port on which the server is listening on a secondary thread

88−launchTestServer :: Timeout -> IO (EndPointAddress, ThreadId)

79+launchTestServer :: Timeout -> IO (Port, ThreadId)

89launchTestServer ti = do

80launchTestServer ti = do

90 addressMVar <- newEmptyMVar

81 addressMVar <- newEmptyMVar

91 tid <- forkIO $

82 tid <- forkIO $

@@ -99,9 +90,9 @@ launchTestServer ti = do

99 }

90 }

100

101 launchServer config (Just addressMVar) >> pure ()

92 launchServer config (Just addressMVar) >> pure ()

102− endPointAddress <- takeMVar addressMVar

93+ (SockAddrInet port _) <- takeMVar addressMVar

103 --liftIO $ putStrLn ("launched server on " ++ show endPointAddress)

94 --liftIO $ putStrLn ("launched server on " ++ show endPointAddress)

104− pure (endPointAddress, tid)

95+ pure (fromIntegral port, tid)

105

106testRelationalExpr :: SessionId -> Connection -> Test

97testRelationalExpr :: SessionId -> Connection -> Test

107testRelationalExpr sessionId conn = TestCase $ do

98testRelationalExpr sessionId conn = TestCase $ do

@@ -217,7 +208,7 @@ testRequestTimeout = TestCase $ do

217 Left err -> putStrLn ("failed to connect: " ++ show err) >> exitFailure

208 Left err -> putStrLn ("failed to connect: " ++ show err) >> exitFailure

218 Right (session, testConn) -> do

209 Right (session, testConn) -> do

219 res <- catchJust (\exc -> if exc == RequestTimeoutException then Just exc else Nothing) (callTestTimeout_ session testConn) (const (pure False))

210 res <- catchJust (\exc -> if exc == RequestTimeoutException then Just exc else Nothing) (callTestTimeout_ session testConn) (const (pure False))

220− assertBool "exception was not thrown" (not res)

211+ assertBool "timeout exception was not thrown" (not res)

221 killThread serverTid

212 killThread serverTid

222

213

223testFileDescriptorCount :: Test

214testFileDescriptorCount :: Test

@@ -247,3 +238,11 @@ fdCount = do

247--pass on non-linux platforms

238--pass on non-linux platforms

248testFileDescriptorCount = TestCase (pure ())

239testFileDescriptorCount = TestCase (pure ())

249#endif

240#endif

241+

242+testClientConnectFail :: Test

243+testClientConnectFail = TestCase $ do

244+ let connInfo = RemoteConnectionInfo "nonexistentdb" "127.0.0.1" "7777" emptyNotificationCallback

245+ eConn <- connectProjectM36 connInfo

246+ case eConn of

247+ Left (IOExceptionError _) -> pure ()

248+ _ -> assertFailure "connection failure failed"

test/Server/WebSocket.hs+3−9

@@ -18,12 +18,6 @@ import Data.Aeson

18import qualified Data.Map as M

19import qualified Data.ByteString.Lazy as BS

20import ProjectM36.Relation

21−#if MIN_VERSION_network_transport_tcp(0,6,0)

22−import Network.Transport.TCP.Internal (decodeEndPointAddress)

23−#else

24−import Network.Transport.TCP (decodeEndPointAddress)

25−#endif

26−

28--start the websocket server

22--start the websocket server

29-- run some tutoriald against it

23-- run some tutoriald against it

@@ -37,12 +31,12 @@ launchTestServer = do

37 testDatabaseName = "test"

31 testDatabaseName = "test"

38 -- start normal server

32 -- start normal server

39 _ <- forkIO (launchServer config (Just addressMVar) >> pure ())

33 _ <- forkIO (launchServer config (Just addressMVar) >> pure ())

40− serverAddress <- takeMVar addressMVar

34+ (SockAddrInet dbPort _) <- takeMVar addressMVar

41 let wsServerHost = "127.0.0.1"

35 let wsServerHost = "127.0.0.1"

42 wsServerPort = 8889

36 wsServerPort = 8889

43− Just (dbHost, dbPort, _) = decodeEndPointAddress serverAddress

37+ dbHost = "127.0.0.1"

44 -- start websocket server proxy -- runServer doesn't support returning an arbitrary socket

38 -- start websocket server proxy -- runServer doesn't support returning an arbitrary socket

45− _ <- forkIO (WS.runServer wsServerHost wsServerPort (websocketProxyServer (read dbPort) dbHost))

39+ _ <- forkIO (WS.runServer wsServerHost wsServerPort (websocketProxyServer (fromIntegral dbPort) dbHost))

46 --wait for socket to be listening

40 --wait for socket to be listening

47 waitForListenSocket 5 (fromIntegral wsServerPort)

41 waitForListenSocket 5 (fromIntegral wsServerPort)

48 pure (fromIntegral wsServerPort, testDatabaseName)

42 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+24−5

@@ -80,13 +80,15 @@ main = do

80 testBasicList,

81 testRelationDeclarationMismatch,

82 testInvalidTuples,

83− testSelfReferencingUncommittedContext

83+ testSelfReferencingUncommittedContext,

84+ testUnionAndIntersectionAttributeExprs

84 ]

85 ]

86simpleRelTests :: Test

87simpleRelTests :: Test

87simpleRelTests = TestCase $ do

88simpleRelTests = TestCase $ do

88 (graph, transId) <- freshTransactionGraph dateExamples

89 (graph, transId) <- freshTransactionGraph dateExamples

90+ mapM_ (\(tutd, expected) ->

89− mapM_ (\(tutd, expected) -> assertTutdEqual basicDatabaseContext transId graph expected tutd) testTups

91+ assertTutdEqual basicDatabaseContext transId graph expected tutd) testTups

90 where

92 where

91 testTups = [("x:=true", Right relationTrue),

93 testTups = [("x:=true", Right relationTrue),

92 ("x:=false", Right relationFalse),

94 ("x:=false", Right relationFalse),

@@ -134,7 +136,8 @@ simpleRelTests = TestCase $ do

134dateExampleRelTests :: Test

136dateExampleRelTests :: Test

135dateExampleRelTests = TestCase $ do

137dateExampleRelTests = TestCase $ do

136 (graph, transId) <- freshTransactionGraph dateExamples

138 (graph, transId) <- freshTransactionGraph dateExamples

139+ mapM_ (\(tutd, expected) ->

137− mapM_ (\(tutd, expected) -> assertTutdEqual dateExamples transId graph expected tutd) testTups

140+ assertTutdEqual dateExamples transId graph expected tutd) testTups

138 where

141 where

139 simpleEitherIntTextAttributes = A.attributesFromList [Attribute "a" (eitherAtomType IntegerAtomType TextAtomType)]

142 simpleEitherIntTextAttributes = A.attributesFromList [Attribute "a" (eitherAtomType IntegerAtomType TextAtomType)]

140 maybeIntegerAtomType = ConstructedAtomType "Maybe" (M.singleton "a" IntegerAtomType)

143 maybeIntegerAtomType = ConstructedAtomType "Maybe" (M.singleton "a" IntegerAtomType)

@@ -359,7 +362,7 @@ testComments :: Test

359testComments = TestCase $ do

362testComments = TestCase $ do

360 (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback

363 (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback

361 mapM_ (executeTutorialD sessionId dbconn) [

364 mapM_ (executeTutorialD sessionId dbconn) [

362− ":branch testbranch --test comment\n",

365+ ":branch testbranch --test comment",

363 ":jumphead {- test comment -} master"]

366 ":jumphead {- test comment -} master"]

364

367

365-- create a graph and query from two disparate contexts

368-- create a graph and query from two disparate contexts

@@ -542,7 +545,7 @@ testListConstructedAtom = TestCase $ do

542testTypeChecker :: Test

545testTypeChecker :: Test

543testTypeChecker = TestCase $ do

546testTypeChecker = TestCase $ do

544 (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback

547 (sessionId, dbconn) <- dateExamplesConnection emptyNotificationCallback

545− let err1 = "AtomFunctionTypeError \"max\" 1 (RelationAtomType [Attribute \"_\" IntegerAtomType]) IntegerAtomType"

548+ let err1 = "AtomFunctionTypeError \"max\" 1"

546 expectTutorialDErr sessionId dbconn (T.isPrefixOf err1) "x:=relation{tuple{a 0}}:{b:=max(@a)}"

549 expectTutorialDErr sessionId dbconn (T.isPrefixOf err1) "x:=relation{tuple{a 0}}:{b:=max(@a)}"

547

550

548--exercise expression parser

551--exercise expression parser

@@ -662,6 +665,10 @@ testWithClause = TestCase $ do

662 executeTutorialD sessionId dbconn "x:=with (x as s) x"

665 executeTutorialD sessionId dbconn "x:=with (x as s) x"

663 eX <- executeRelationalExpr sessionId dbconn (RelationVariable "x" ())

666 eX <- executeRelationalExpr sessionId dbconn (RelationVariable "x" ())

664 assertEqual "with x as s" (Right suppliersRel) eX

667 assertEqual "with x as s" (Right suppliersRel) eX

668+

669+ executeTutorialD sessionId dbconn "y:=with(a as true) (with (b as a) b)"

670+ eY <- executeRelationalExpr sessionId dbconn (RelationVariable "y" ())

671+ assertEqual "nested with" (Right relationTrue) eY

665

672

666 let err1 = "RelVarAlreadyDefinedError"

673 let err1 = "RelVarAlreadyDefinedError"

667 expectTutorialDErr sessionId dbconn (T.isPrefixOf err1) "x:=with (s as s) s"

674 expectTutorialDErr sessionId dbconn (T.isPrefixOf err1) "x:=with (s as s) s"

@@ -711,3 +718,15 @@ testSelfReferencingUncommittedContext = TestCase $ do

711 _ <- rollback sessionId dbconn

718 _ <- rollback sessionId dbconn

712 eSorig <- executeRelationalExpr sessionId dbconn (RelationVariable "s" ())

719 eSorig <- executeRelationalExpr sessionId dbconn (RelationVariable "s" ())

713 assertEqual "s=s'" eSorig eS

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/Printer.hs → test/TutorialD/PrinterTest.hsrenamed+1−1

@@ -43,5 +43,5 @@ parseRelExpr :: String -> IO RelationalExpr

43parseRelExpr tutdStr =

44 case parse relExprP "test" (pack tutdStr) of

45 Left err ->

46− assertFailure (errorBundlePretty err)

46+ assertFailure (show err)

47 Right parsed -> pure parsed

test/scripts.hs+5−2

@@ -4,6 +4,8 @@ import TutorialD.Interpreter.Import.TutorialD

4import System.Directory

5import Data.List (isSuffixOf)

6import System.Exit

7+import qualified Data.Text as T

8+import Text.URI

8testList :: IO Test

10testList :: IO Test

9testList = do

11testList = do

@@ -20,7 +22,8 @@ main = do

21testScript :: FilePath -> Test

23testScript :: FilePath -> Test

22testScript tutdFile = TestCase $ do

24testScript tutdFile = TestCase $ do

23− eImport <- importTutorialD tutdFile

25+ fileURI <- mkURI (T.pack ("file://" <> tutdFile))

26+ eImport <- importTutorialDFromFile fileURI Nothing

24 case eImport of

27 case eImport of

25 Left err -> assertFailure ("tutd import failure in " ++ tutdFile ++ ": " ++ show err)

28 Left err -> assertFailure ("tutd import failure in " ++ tutdFile ++ ": " ++ show err)

26− Right _ -> pure ()

29+ Right _ -> pure ()